How to use the couchbase.errors function in couchbase

bucket.get(k, function (err, gdoc) {
                expect(err).to.be.ok
                expect(err.code).to.equal(couchbase.errors.keyNotFound)

                // new ones
                var k = userSchema.getRefKey('email', user.email)
                bucket.get(k, function (err, indexRes) {
                  checkRes(err, indexRes)
                  k = userSchema.getRefKey('userName', user.username)
                  bucket.get(k, function (err, indexRes) {
                    checkRes(err, indexRes)
                    done()
                  })
                })
              })
            })

bucket.get(k, function (err, indexRes) {
                  expect(err).to.be.ok
                  expect(err.code).to.equal(couchbase.errors.keyNotFound)

                  var keys = _.map(['joe2@gmail.com', 'joe3@gmail.com', 'joe4@gmail.com'], function (em) {
                    return userSchema.getRefKey('email', em)
                  })

                  bucket.getMulti(keys, function (err, indexRes) {
                    expect(err).to.not.be.ok

                    var ex = [
                      [user.id, user2.id],
                      [user2.id],
                      [user.id]
                    ]
                    _.values(indexRes).forEach(function (ir, i) {
                      checkRes(ir, ex[i].sort())
                    })

bucket.get(rdoc.id, function (err, doc) {
            expect(doc).to.not.be.ok
            expect(err).to.be.ok
            expect(err.code).to.equal(couchbase.errors.keyNotFound)

            bucket.get(k, function (err, indexRes) {
              expect(indexRes).to.not.be.ok
              expect(err).to.be.ok
              expect(err.code).to.equal(couchbase.errors.keyNotFound)

              done()
            })
          })
        })

bucket.get(key, function (err, doc) {
              expect(doc).to.not.be.ok
              expect(err).to.be.ok
              expect(err.code).to.equal(couchbase.errors.keyNotFound)
              eaCb()
            })
          }, function () {

bucket.get(docKey, function (err, doc) {
          expect(doc).to.not.be.ok
          expect(err).to.be.ok
          expect(err.code).to.equal(couchbase.errors.keyNotFound)

          done()
        })
      })

bucket.get(rdoc.email, function (err, doc) {
              expect(doc).to.not.be.ok
              expect(err).to.be.ok
              expect(err.code).to.equal(couchbase.errors.keyNotFound)

              bucket.get(user2.email, function (err, doc) {
                expect(rdoc).to.be.ok

                bucket.get(k, function (err, indexRes) {
                  expect(err).to.not.be.ok
                  expect(indexRes).to.be.ok
                  expect(indexRes.value).to.be.ok
                  expect(indexRes.value.keys).to.be.ok
                  expect(indexRes.value.keys).to.be.an.instanceof(Array)
                  expect(indexRes.value.keys.length).to.equal(1)

                  expect(indexRes.value.keys).to.deep.equal([user2.email])

                  user2.remove(function (err, rdoc) {
                    expect(err).to.not.be.ok

bucket.get(k, function (err, indexRes) {
            expect(err).to.be.ok
            expect(err.code).to.equal(couchbase.errors.keyNotFound)

            k = userSchema.getRefKey('email', user.email)
            bucket.get(k, function (err, indexRes) {
              checkRes(err, indexRes)
              done()
            })
          })
        })

stateBucket.get(key, function(err, result) {
					if (err && err.code == cb.errors.keyNotFound) {
						console.log(('Subscription key "'+key+'"').red+' not found');
						return c();
					}
					else if (err)
						return c(err);

					if (!result.value)
						return c();
					else {
						var stringStream = new stream.Readable();
						stringStream._read = function noop(){};
						stringStream.push('['+result.value.slice(0, -1)+']');
						stringStream.push(null);
						bfj.parse(stringStream).then(function(data) {
							data.forEach(function(item) {
								if (!subscriptionDevices[key])

  static get errors() { return couchbase.errors; }
  static get ClassicAuthenticator() { return couchbase.ClassicAuthenticator; }

stateBucket.getAndLock(deltasKey, function(err, result) {
							if (err && err.code == cb.errors.keyNotFound)
								callback(null, false);
							else if (err)
								callback(err);
							else
								callback(null, result);
						});
					},