Merge pull request #13 from aliok/RHMAP-9849-document_custom_id

RHMAP-9849 documents w/ custom id

Author: aliok

README.md

@@ -30,19 +30,19 @@ Add fh-db as a dependency to your module and require it where required, like any
 ### Start Mongo Server
 Start the docker machine for the version of mongo you wish to test:
 ```bash
-docker run -d -p 27017:27017 mongo:2.4
+docker run -d -p 27017:27017 mongo:2.6
 ```
 
 ### Note for docker-machine users
 You will need to connect your localhost:27017 to the docker-machine:27017, do this with the following command:
 ```
-VBoxManage controlvm <docker-machine-name> natpf1 "docker-mongo,tcp,127.0.0.1,27017,,27017"
+VBoxManage controlvm `docker-machine active` natpf1 "docker-mongo,tcp,127.0.0.1,27017,,27017"
 ```
 In the above `docker-mongo` is the name of the rule, this is important to remember, in order to remove it when not required.
 
 Remove the above rule as follows:
 ```
-VBoxManage controlvm dev natpf1 delete docker-mongo
+VBoxManage controlvm `docker-machine active` natpf1 delete docker-mongo
 ```
 
 
@@ -52,8 +52,9 @@ connect to Mongo:
 mongo
 ```
 
-#### For versions > 3.x
-You will need to update the authentication to work with fh-db, which is done as follows:
+#### For MongoDB versions > 3.x
+Well, instead of MongoDB 2.6 stated above if you used MongoDB 3.x, you will need to update the authentication
+to work with fh-db, which is done as follows:
 ```
 use admin
 db.system.users.remove({})
@@ -73,12 +74,7 @@ mongo
 ```
 
 #### Add the admin user:
-##### 2.4.x
-```
-use admin
-db.addUser('admin', 'admin');
-```
-##### >= 2.6
+
 ```
 use admin
 db.createUser({user: 'admin', pwd: 'admin', roles: ['root']})
@@ -93,13 +89,7 @@ mongo admin -u admin -p admin
 #### Add the ditchuser
 
 Log in as the admin user, if you are not yet, then run:
-##### 2.4.x
-```
-use fh-ditch
-db.addUser('ditchuser', 'ditchpassword');
-```
 
-##### >= 2.6
 ```
 use fh-ditch
 db.createUser({user: 'ditchuser', pwd: 'ditchpassword', roles: ['dbAdmin']})

lib/ditcher.js

@@ -354,7 +354,8 @@ Ditcher.prototype.doRead = function (params, callback) {
   try {
     query = {"_id": self.database.createObjectIdFromHexString(params.guid)};
   } catch (err) {
-    return callback(new Error('Error creating ObjectId from string: ' + JSON.stringify(err)));
+    // if the guid passed is not a hex ObjectID, use it as is
+    query = {"_id": params.guid};
   }
   self.logger.debug("Ditcher.read/query: " + JSON.stringify(query));
 
@@ -395,7 +396,8 @@ Ditcher.prototype.doUpdate = function (params, callback) {
   try {
     criteria = {"_id": self.database.createObjectIdFromHexString(params.guid)};
   } catch (err) {
-    return callback(new Error('Error creating ObjectId from string: ' + JSON.stringify(err)));
+    // if the guid passed is not a hex ObjectID, use it as is
+    criteria = {"_id": params.guid};
   }
   self.logger.debug("Ditcher.update/criteria: " + JSON.stringify(criteria));
 

lib/fhmongodb.js

@@ -303,10 +303,19 @@ Database.prototype.remove = function (collectionName, id, callback) {
   var self = this;
 
   this.db.collection(collectionName, function (err, collection) {
-    if (null !== err) return callback(err, null);
+    if (null !== err){
+      return callback(err, null);
+    }
+
+    // if a GUID id is passed as strings, convert it to an ObjectID
+    try{
+      id = self.createObjectIdFromHexString(id);
+    }catch(err){
+      // if not, use the id as is
+    }
 
     collection.remove({
-      _id: self.createObjectIdFromHexString(id)
+      _id: id
     }, function (err, docs) {
       return callback(err, docs);
     });
@@ -379,7 +388,9 @@ Database.prototype.countCollection = function (collectionName, callback) {
   if (null === this.db) return callback(new Error("no database open"), null);
 
   this.db.collection(collectionName, function (err, collection) {
-    if (err) return callback(err, null);
+    if (err){
+      return callback(err, null);
+    }
     collection.count(callback);
   });
 };

npm-shrinkwrap.json

@@ -1,7 +1,7 @@
 {
   "name": "fh-db",
   "description": "FeedHenry Database Library",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "repository": {
     "type": "git",
     "url": "git@github.com:feedhenry/fh-db.git"

package.json

@@ -1,6 +1,6 @@
 sonar.projectKey=fh-db
 sonar.projectName=fh-db-nightly-master
-sonar.projectVersion=1.2.2
+sonar.projectVersion=1.2.3
 
 sonar.sources=./lib
 sonar.tests=./test

sonar-project.properties

@@ -410,7 +410,7 @@ var testBasicOperationsOwnDatabase = function(cb){
                   testDelete,
                   testListCollections,
                   testDeleteAgain,
-                  testDeleteInvalidGuid,
+                  testDeleteNonHexGuid,
                   testList1,
                   testList2,
                   testList3,
@@ -570,8 +570,8 @@ var testDeleteAgain = function (created, cb) {
   });
 };
 
-var testDeleteInvalidGuid = function(created, cb) {
-  logger.info("test testDeleteInvalidGuid()");
+var testDeleteNonHexGuid = function(created, cb) {
+  logger.info("test testDeleteNonHexGuid()");
   var deleteReq = {
     "__fhdb" : "123456789",
     "type" : "fh_test_collection",
@@ -583,7 +583,8 @@ var testDeleteInvalidGuid = function(created, cb) {
   }
 
   ditch.doDelete(deleteReq, function(err, deleteRes) {
-    assert.ok(err, "Should have called back with error");
+    assert.ok(!err);
+    assert.equal(JSON.stringify(deleteRes), "{}");
     cb();
   });
 };
@@ -1202,6 +1203,89 @@ var testImport = function(created, cb) {
   });
 };
 
+var testNonHexId = function() {
+  logger.info("BEGIN testDbActions...");
+  
+  var collectionName = "fh_test_collection_non_hex_id";
+  var createData = {
+    "__fhdb" : test_fhdb_name,
+    "type" : collectionName,
+    "fields" : {
+      "_id": "foobar",
+      "firstName" : "Foo",
+      "lastName" : "Bar"
+    }
+  };
+
+  async.waterfall([
+    function(cb) {
+      logger.info("test testCreate()");
+
+      var testData = JSON.parse(JSON.stringify(createData));
+      var expectedResult = JSON.parse(JSON.stringify(testData.fields));
+
+      ditch.doCreate(testData, function(err, res) {
+        assert.equal(res.guid, createData.fields._id);
+        assert.equal(res.fields.firstName, createData.fields.firstName);
+        assert.equal(res.fields.lastName, createData.fields.lastName);
+        cb(undefined, res);
+      });
+    },
+    function(created, cb) {
+      logger.info("test testRead()");
+      var readReq = {
+        "__fhdb" : test_fhdb_name,
+        "type" : collectionName,
+        "guid" : created.guid
+      };
+
+      logger.debug("readReq", readReq);
+      ditch.doRead(readReq, function(err, res) {
+        assert.equal(res.guid, createData.fields._id);
+        assert.equal(res.fields.firstName, createData.fields.firstName);
+        assert.equal(res.fields.lastName, createData.fields.lastName);
+        cb(undefined, created);
+      });
+    },
+    function(created, cb) {
+      logger.info("test testUpdate()");
+      var updateReq = JSON.parse(JSON.stringify(created));
+      updateReq.fields.firstName = 'Fizz';
+      updateReq["__fhdb"] = test_fhdb_name;
+
+      ditch.doUpdate(updateReq, function(err, res) {
+        logger.debug("updateRes = " + JSON.stringify(res));
+
+        // firstName should have changed - other fields still the
+        // same
+        assert.equal(res.guid, createData.fields._id);
+        assert.equal(res.fields.firstName, "Fizz");
+        assert.equal(res.fields.lastName, createData.fields.lastName);
+        cb(undefined, created);
+      });
+    },
+    function(created, cb) {
+      logger.info("test testDelete()");
+      var deleteReq = {
+        "__fhdb" : test_fhdb_name,
+        "type" : collectionName,
+        "guid" : created.guid
+      };
+
+      ditch.doDelete(deleteReq, function(err, deleteRes) {
+        assert.equal(deleteRes.guid, createData.fields._id);
+        assert.equal(deleteRes.fields.firstName, "Fizz");
+        assert.equal(deleteRes.fields.lastName, createData.fields.lastName);
+        cb(undefined, created);
+      });
+    }
+  ], function (err, result) {
+    assert.ok(!err);
+    ditch.tearDown();
+  });
+
+};
+
 
 exports.testDbActions = function(beforeExit) {
   logger.info("BEGIN testDbActions...");
@@ -1227,7 +1311,7 @@ exports.testDbActions = function(beforeExit) {
         testListCollections,
         testDelete,
         testDeleteAgain,
-        testDeleteInvalidGuid,
+        testDeleteNonHexGuid,
         testList1,
         testList2,
         testList3,
@@ -1254,7 +1338,8 @@ exports.testDbActions = function(beforeExit) {
         async.apply(testDeleteAll, 0),
         testCollectionOwnAppDatabase,
         testCollectionDitchAppDatabase,
-        testBasicOperationsOwnDatabase
+        testBasicOperationsOwnDatabase,
+        testNonHexId
         ], function (err, result) {
           assert.ok(!err);
           ditch.tearDown();

test/test_ditcher.js

@@ -332,3 +332,79 @@ exports[ 'test basic database ops' ] = function () {
   }
   self.db.tearUp();
 };
+
+exports[ 'test update and delete item with an id that is not hex' ] = function () {
+  var test_collection_name = "testcollection_forinvaliddocid";
+  var self = this;
+  self.db = new Database();
+  self.db.name = "test-fhmongodb-database";
+
+  self.db.on('tearUp', do_ops);
+  
+  var sampleData = { _id : "foobar", test2 : "test value2"};
+
+  function do_ops() {
+    self.db.db.authenticate(config.database.adminauth.user, config.database.adminauth.user, {authSource:"admin"}, function(err, result){
+      assert.ok(!err);
+      self.db.dropDatabase(function(err) {
+        assert.equal(err, null);
+      
+        self.db.removeAll(test_collection_name, function(err, items) {
+          assert.equal(err, null);
+        
+          self.db.create(test_collection_name, sampleData, function(err, docs) {
+            assert.ok(!err, JSON.stringify(err));
+         
+            async.series([
+              function(cb){
+                self.db.find(test_collection_name, {"_id": sampleData._id}, function(err, items) {
+                  assert.ok(!err, JSON.stringify(err));
+
+                  var numItems = items.length;
+                  assert.equal(1, numItems);
+                  return cb();
+                });
+              },
+              function (cb) {
+                self.db.countCollection(test_collection_name, function(err, count) {
+                    assert.equal(count, 1);
+                    return cb();
+                  });
+              },
+              function(cb) {
+                self.db.update(
+                    test_collection_name,
+                    {"_id": sampleData._id},
+                    { _id : sampleData._id, test2 : "updated test value2"},
+                    false,
+                    function(err) {
+                      assert.ok(!err, JSON.stringify(err));
+                      return cb();
+                    });
+              },
+              function(cb) {
+                self.db.remove(
+                    test_collection_name,
+                    sampleData._id,
+                    function(err) {
+                      assert.ok(!err, JSON.stringify(err));
+                      return cb();
+                    });
+              },
+              function(cb) {
+                self.db.dropCollection(test_collection_name, function(err, item) {
+                  assert.equal(err, null);
+                  return cb();
+                });
+              }
+            ], function(err, results) {
+              self.db.tearDown();
+              assert.ok(!err);
+            });
+          });
+        });
+      });
+    });
+  }
+  self.db.tearUp();
+};