@dhyasama/totem-merge 6.0.1

package/test/index.js

@@ -0,0 +1,1159 @@
+"use strict";
+
+var config = require('./config');
+var dbUri = config.db.uri;
+
+if (dbUri.indexOf('@test-shard-') === -1) {
+  console.log('Not a test db. Quitting...');
+  process.exit();
+}
+
+var should = require("should");
+var mongoose = require('mongoose');
+var models = require('@dhyasama/totem-models')(mongoose, config);
+var clearDB = require('mocha-mongoose')(config.db.uri, {noClear: true});
+var Merge = require('../index.js');
+var merge;
+var Deal = mongoose.model('Deal');
+var Interaction = mongoose.model('Interaction');
+var List = mongoose.model('List');
+var Message = mongoose.model('Message');
+var News = mongoose.model('News');
+var Organization = mongoose.model('Organization');
+var Person = mongoose.model('Person');
+
+var customer;
+var org1, org2, org3, org4, org5, org6;
+var person1, person2, person3;
+
+describe('Merge', function() {
+
+  // connect to test db
+  before(function(done) {
+    if (mongoose.connection.db) return done();
+    mongoose.connect(config.db.uri, done);
+  });
+
+  // clear test db
+  before(function(done) {
+    clearDB(done);
+  });
+
+  // Customer prep
+  before(function(done) {
+
+    customer = new Organization();
+    customer.name = 'HUGE VC';
+    customer.slug = 'huge-vc';
+
+    Organization.upsert(customer, 'test', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      customer = result;
+
+      return done();
+
+    });
+
+  });
+
+  // People prep
+  before(function(done) {
+
+    var p3 = new Person();
+    p3.name.first = 'Toni';
+    p3.name.last = 'Braxton';
+    p3.slug = 'toni-braxton';
+
+    var p1 = new Person();
+    p1.name.first = 'George';
+    p1.name.last = 'Miller';
+    p1.slug = 'george-miller';
+    p1.bio = 'Hello World!';
+    p1.aliases.push('G-Money');
+    p1.sources.push({
+      person: p3._id,
+      customer: customer._id
+    });
+
+    var p2 = new Person();
+    p2.name.first = 'Braxton';
+    p2.name.last = 'Miller';
+    p2.slug = 'braxton-miller';
+    p2.sources.push(p1.sources[0]);
+
+    Person.upsert(p1, 'test', function(err, newPerson1) {
+
+      should.not.exist(err);
+      should.exist(newPerson1);
+      person1 = newPerson1;
+
+      Person.upsert(p2, 'test', function(err, newPerson2) {
+
+        should.not.exist(err);
+        should.exist(newPerson1);
+        person2 = newPerson2;
+
+        Person.upsert(p3, 'test', function(err, newPerson3) {
+
+          should.not.exist(err);
+          should.exist(newPerson3);
+          person3 = newPerson3;
+
+          return done();
+
+        });
+
+      });
+
+    });
+
+  });
+
+  // Org prep
+  before(function(done) {
+
+    var o1 = new Organization();
+    o1.name = 'Shiny and Chrome';
+    o1.slug = 'TEST 1';
+    o1.logoUrl = 'http://no.com';
+    o1.description = 'no';
+    o1.website = 'https://yes.com';
+    o1.websiteAliases.push('https://yup.com');
+    o1.social = {
+      'twitter': 'dhyasamatwitter',
+      'facebook': 'dhyasamafacebook',
+      'linkedin': 'dhyasamalinkedin'
+    };
+    o1.addPerson({ person: person1._id, title: 'CEO' });
+    o1.addPerson({ person: person2._id, title: 'CTO' });
+
+    var o2 = new Organization();
+    o2.name = 'Furiosa Five';
+    o2.slug = 'TEST 2';
+    o2.logoUrl = 'http://yes.com';
+    o2.website = 'furiosafive.com';
+    o2.addPerson({ person: person2._id, title: 'CTO' });
+    o2.addPerson({ person: person1._id, title: 'CEO' });
+
+    var o3 = new Organization();
+    o3.name = 'Fab Five';
+    o3.slug = 'fab-five';
+    o3.addPerson({ person: person3._id, title: 'VP Engineering' });
+
+    var o4 = new Organization();
+    o4.name = 'ABC';
+    o4.slug = 'abc';
+    o4.logoUrl = 'http://abc.com';
+    o4.description = 'abc';
+    o4.website = 'https://abc.com';
+    o4.websiteAliases.push('https://abcdef.com');
+    o4.social = {
+      'twitter': 'abc',
+      'facebook': 'abc',
+      'linkedin': 'abc'
+    };
+    o4.addPerson({ person: person1._id, title: 'abc' });
+    o4.addPerson({ person: person2._id, title: 'def' });
+
+    var o5 = new Organization();
+    o5.name = '123';
+    o5.slug = '123';
+    o5.logoUrl = 'http://123.com';
+    o5.website = '123.com';
+    o5.addPerson({ person: person2._id, title: '123' });
+    o5.addPerson({ person: person1._id, title: '456' });
+
+    var o6 = new Organization();
+    o6.name = 'jingles';
+    o6.slug = 'jingles';
+    o6.logoUrl = 'http://jingles.com';
+    o6.website = 'jingles.com';
+    o6.addPerson({ person: person2._id, title: 'jingles1' });
+    o6.addPerson({ person: person1._id, title: 'jingles2' });
+
+    Organization.upsert(o1, 'test', function(err, newOrg1) {
+
+      should.not.exist(err);
+      should.exist(newOrg1);
+
+      // getbyid to populate investedIn
+      Organization.getById(newOrg1.id, { CUSTOMER_ID: customer._id, role: 'none' }, function(err, result1) {
+
+        should.not.exist(err);
+        should.exist(result1);
+
+        org1 = result1;
+
+        Organization.upsert(o2, 'test', function(err, newOrg2) {
+
+          should.not.exist(err);
+          should.exist(newOrg2);
+
+          Organization.getById(newOrg2.id, { CUSTOMER_ID: customer._id, role: 'none' }, function(err, result2) {
+
+            should.not.exist(err);
+            should.exist(result2);
+
+            org2 = result2;
+
+            Organization.upsert(o3, 'test', function(err, newOrg3) {
+
+              should.not.exist(err);
+              should.exist(newOrg3);
+
+              Organization.getById(newOrg3.id, { CUSTOMER_ID: customer._id, role: 'none' }, function(err, result3) {
+
+                should.not.exist(err);
+                should.exist(result3);
+
+                org3 = result3;
+
+                Organization.upsert(o4, 'test', function(err, newOrg4) {
+
+                  should.not.exist(err);
+                  should.exist(newOrg4);
+
+                  Organization.getById(newOrg4.id, { CUSTOMER_ID: customer._id, role: 'none' }, function(err, result4) {
+
+                    should.not.exist(err);
+                    should.exist(result4);
+
+                    org4 = result4;
+
+                    Organization.upsert(o5, 'test', function(err, newOrg5) {
+
+                      should.not.exist(err);
+                      should.exist(newOrg5);
+
+                      Organization.getById(newOrg5.id, { CUSTOMER_ID: customer._id, role: 'none' }, function(err, result5) {
+
+                        should.not.exist(err);
+                        should.exist(result5);
+
+                        org5 = result5;
+
+                        Organization.upsert(o6, 'test', function(err, newOrg6) {
+
+                          should.not.exist(err);
+                          should.exist(newOrg6);
+
+                          Organization.getById(newOrg6.id, { CUSTOMER_ID: customer._id, role: 'none' }, function(err, result6) {
+
+                            should.not.exist(err);
+                            should.exist(result6);
+
+                            org6 = result6;
+
+                            return done();
+
+                          });
+
+                        });
+
+                      });
+
+                    });
+
+                  });
+
+                });
+
+              });
+
+            });
+
+          });
+
+        });
+
+      });
+
+    });
+
+  });
+
+  // List prep
+  before(function(done) {
+
+    List.createList('Test List', { organizations:[org1], people: [person1] }, person1, { CUSTOMER_ID: customer._id }, function(err, list) {
+      should.not.exist(err);
+      should.exist(list);
+      return done();
+    });
+
+  });
+
+  // News prep
+  before(function(done) {
+
+    var newsItem = new News({
+      title: 'Test News',
+      createdOn: new Date(),
+      createdBy: 'test',
+      link: 'http://totemvc.com',
+      org: org1
+    });
+
+    News.upsert(newsItem, function(err, result) {
+      should.not.exist(err);
+      should.exist(result);
+      return done();
+    });
+
+  });
+
+  // Interaction prep
+  before(function(done) {
+
+    var interaction = new Interaction({
+      calendarEventId: new mongoose.Types.ObjectId(),
+      providerEventId: 'ABC123',
+      totemCustomerId: customer._id,
+      summary: 'Test',
+      startTime: new Date(),
+      recurring: false,
+      attendees: {
+        internal: [person2],
+        external: [person1, person3]
+      }
+    });
+
+    Interaction.upsert(interaction, function(err, result) {
+      should.not.exist(err);
+      should.exist(result);
+      return done();
+    });
+
+  });
+
+  describe('Orgs', function() {
+
+    it('Flags organization to be merged', function (done) {
+
+      config.flag = true;
+      merge = new Merge(mongoose, config);
+
+      merge.organizations(org2, org1, 'testy', customer._id, function(err, result) {
+        should.not.exist(err);
+        should.exist(result);
+        result.addedTo.flags.length.should.equal(1);
+        return done();
+      });
+
+    });
+
+    it('Merges organizations', function (done) {
+
+      // reset to not flag
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      org1.investedIn = [];
+
+      Organization.upsert(org2, 'testy', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        merge.organizationsById(org2._id, org1._id, 'testy', customer._id, function(err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+
+          result.slug.should.equal('test 2');
+          result.id.should.equal(org2.id);
+          should.equal(result.logoUrl, 'http://yes.com');
+          result.aliases.should.containEql(org1.name);
+          result.people.length.should.equal(2);
+          result.website.should.equal('furiosafive.com');
+
+          org2 = result;
+
+          News.listForCompany(org1, function(err, result) {
+            should.not.exist(err);
+            should.exist(result);
+            result.length.should.equal(0);
+            return done();
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges organizations with different people', function (done) {
+
+      // reset to not flag
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      org4.people = [];
+      org4.people.push({
+        person: new mongoose.Types.ObjectId(),
+        roles: [{
+          role: 'test 4'
+        }]
+      });
+
+      org5.people = [];
+      org5.people.push({
+        person: new mongoose.Types.ObjectId(),
+        roles: [{
+          role: 'test 5'
+        }]
+      });
+
+      Organization.upsert(org2, 'testy', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        Organization.upsert(org2, 'testy', function(err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+
+          merge.organizationsById(org5._id, org4._id, 'testy', customer._id, function(err, result) {
+            should.not.exist(err);
+            should.exist(result);
+            result.people.length.should.equal(2);
+            org5 = result;
+            return done();
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges organizations with the same people', function (done) {
+
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      org2.people = [];
+      org2.people.push({
+        person: person2,
+        roles: [{
+          role: 'test 1'
+        }]
+      });
+
+      org5.people = [];
+      org5.people.push({
+        person: person2,
+        roles: [{
+          role: 'test 2'
+        }]
+      });
+
+      Organization.upsert(org2, 'testy', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        org2 = result;
+
+        Organization.upsert(org5, 'testy', function (err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+
+          org5 = result;
+
+          merge.organizationsById(org5._id, org2._id, 'testy', customer._id, function(err, result) {
+            should.not.exist(err);
+            should.exist(result);
+            result.people.length.should.equal(1);
+            return done();
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges organizations when source has a deal', function (done) {
+
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var deal = new Deal({
+        customer: customer._id,
+        organization: org5._id,
+        description: 'aok',
+        stage: 'New'
+      });
+
+      Deal.upsert(deal, { account: new mongoose.Types.ObjectId() }, function(err, result1) {
+
+        should.not.exist(err);
+        should.exist(result1);
+
+        merge.organizationsById(org6._id, org5._id, new mongoose.Types.ObjectId(), customer._id, function(err, result2) {
+
+          should.not.exist(err);
+          should.exist(result2);
+
+          org6 = result2;
+
+          Deal.getById(deal.id, { CUSTOMER_ID: customer._id }, function(err, result3) {
+
+            should.not.exist(err);
+            should.exist(result3);
+
+            result3.organization._id.toString().should.equal(org6._id.toString());
+
+            return done();
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges organizations when target has a list', function (done) {
+
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var list = new List({
+        customer: customer._id,
+        name: 'my list',
+        key: 'my-list',
+        createdOn: new Date(),
+        createdBy: new mongoose.Types.ObjectId(),
+        organizations: [org3]
+      });
+
+      List.upsert(list, function(err, result1) {
+
+        should.not.exist(err);
+        should.exist(result1);
+
+        merge.organizationsById(org6._id, org3._id, new mongoose.Types.ObjectId(), customer._id, function(err, result2) {
+
+          should.not.exist(err);
+          should.exist(result2);
+
+          org6 = result2;
+
+          List.getById(list.id, { CUSTOMER_ID: customer._id }, function(err, result3) {
+
+            should.not.exist(err);
+            should.exist(result3);
+
+            result3.customer.toString().should.equal(customer._id.toString());
+            result3.organizations.length.should.equal(1);
+            result3.organizations[0]._id.toString().should.equal(org6._id.toString());
+
+            return done();
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges organizations when target has a message', function (done) {
+
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var newOrg = new Organization();
+      newOrg.name = 'New Org';
+      newOrg.slug = 'neworg';
+
+      Organization.upsert(newOrg, 'testy', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        var message = new Message({
+          createdOn: new Date(),
+          updatedOn: new Date(),
+          webhook: new mongoose.Types.ObjectId(),
+          type: 'email',
+          subtype: 'updates',
+          customer: customer._id,
+          organization: org6._id,
+          raw: {}
+        });
+
+        Message.upsert(message, function(err, result1) {
+
+          should.not.exist(err);
+          should.exist(result1);
+
+          merge.organizationsById(org6._id, newOrg._id, new mongoose.Types.ObjectId(), customer._id, function(err, result2) {
+
+            should.not.exist(err);
+            should.exist(result2);
+
+            org6 = result2;
+
+            Message.getById(message.id, { CUSTOMER_ID: customer._id }, function(err, result3) {
+
+              should.not.exist(err);
+              should.exist(result3);
+
+              result3.customer.toString().should.equal(customer._id.toString());
+              result3.organization._id.toString().should.equal(org6._id.toString());
+
+              return done();
+
+            });
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges organizations when target has news', function (done) {
+
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var newOrg = new Organization();
+      newOrg.name = 'Another New Org';
+      newOrg.slug = 'anotherneworg';
+
+      Organization.upsert(newOrg, 'testy', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        var news = new News({
+          title: 'Newsy News',
+          createdOn: new Date(),
+          createdBy: 'tester',
+          link: 'http://somenewssite.com/somenewsitem',
+          org: org6._id
+        });
+
+        News.upsert(news, function(err, result1) {
+
+          should.not.exist(err);
+          should.exist(result1);
+
+          merge.organizationsById(org6._id, newOrg._id, new mongoose.Types.ObjectId(), customer._id, function(err, result2) {
+
+            should.not.exist(err);
+            should.exist(result2);
+
+            org6 = result2;
+
+            News.findById(news.id, function(err, result3) {
+
+              should.not.exist(err);
+              should.exist(result3);
+
+              result3.org.toString().should.equal(org6._id.toString());
+
+              return done();
+
+            });
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Will not merge customer', function (done) {
+
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var newOrg = new Organization();
+      newOrg.name = 'Yet Another New Org';
+      newOrg.slug = 'yetanotherneworg';
+
+      Organization.upsert(newOrg, 'testy', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        org6.customer.totemUrl = 'http://test.totemvc.com';
+
+        Organization.upsert(org6, 'testy', function(err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+
+          merge.organizationsById(org6._id, newOrg._id, 'testy', customer._id, function(err, result) {
+            should.exist(err);
+            should.not.exist(result);
+            return done();
+          });
+
+        });
+
+      });
+
+    });
+
+  });
+
+  describe('People', function() {
+
+    it('Flags person to be merged', function (done) {
+
+      config.flag = true;
+      merge = new Merge(mongoose, config);
+
+      merge.people(person2, person1, 'testy', customer._id, function(err, result) {
+        should.not.exist(err);
+        should.exist(result);
+        result.addedTo.flags.length.should.equal(1);
+        return done();
+      });
+
+    });
+
+    it('Merges people', function (done) {
+
+      // reset to not flag
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      merge.peopleById(person2.id, person1.id, 'testy', customer._id, function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+        result.slug.should.equal('braxton-miller');
+        result.id.should.equal(person2.id);
+        should.equal(result.bio, 'Hello World!');
+        result.aliases.should.containEql(person1.name.full);
+        result.sources.length.should.equal(1);
+
+        return done();
+
+      });
+
+    });
+
+    it('Merges people with different phone numbers', function (done) {
+
+      // reset to not flag
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      Person.getById(person2._id, { CUSTOMER_ID: customer._id }, function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        result.contact.phone = [];
+        result.contact.phone.push({
+          number: '207-555-1212',
+          type: 'other',
+          primary: true
+        });
+
+        Person.upsert(result, 'test', function(err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+          person2 = result;
+
+          var newPerson = new Person();
+          newPerson.name.first = 'New';
+          newPerson.name.last = 'Person';
+          newPerson.slug = 'new-person';
+          newPerson.contact.phone = [];
+          newPerson.contact.phone.push({
+            number: '207-939-6565',
+            type: 'other',
+            primary: true
+          });
+
+          Person.upsert(newPerson, 'test', function(err, result) {
+
+            should.not.exist(err);
+            should.exist(result);
+            newPerson = result;
+
+            merge.peopleById(person2.id, newPerson.id, 'testy', customer._id, function(err, result) {
+              should.not.exist(err);
+              should.exist(result);
+              result.contact.phone.length.should.equal(2);
+              return done();
+            });
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges people with same phone number', function (done) {
+
+      Person.getById(person2._id, { CUSTOMER_ID: customer._id }, function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        result.contact.phone = [];
+        result.contact.phone.push({
+          number: '207-939-6565',
+          type: 'other',
+          primary: true
+        });
+
+        Person.upsert(result, 'test', function(err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+          person2 = result;
+
+          var newPerson = new Person();
+          newPerson.name.first = 'New';
+          newPerson.name.last = 'Person';
+          newPerson.slug = 'new-person';
+          newPerson.contact.phone = [];
+          newPerson.contact.phone.push({
+            number: '207-939-6565',
+            type: 'other',
+            primary: true
+          });
+
+          Person.upsert(newPerson, 'test', function(err, result) {
+
+            should.not.exist(err);
+            should.exist(result);
+            newPerson = result;
+
+            merge.peopleById(person2.id, newPerson.id, 'testy', customer._id, function(err, result) {
+              should.not.exist(err);
+              should.exist(result);
+              result.contact.phone.length.should.equal(1);
+              return done();
+            });
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges two people that are referenced by same org', function (done) {
+
+      // reset to not flag
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var myNewPerson1 = new Person();
+      myNewPerson1.name = { first:'jason', last:'reynolds'};
+      myNewPerson1.slug = 'jason-reynolds';
+
+      var myNewPerson2 = new Person();
+      myNewPerson2.name = { first:'jim', last:'jenkins'};
+      myNewPerson2.slug = 'jim-jenkins';
+
+      Person.upsert(myNewPerson1, 'test', function(err, newPerson1) {
+
+        should.not.exist(err);
+        should.exist(newPerson1);
+
+        Person.upsert(myNewPerson2, 'test', function (err, newPerson2) {
+
+          should.not.exist(err);
+          should.exist(newPerson2);
+
+          var myNewOrg = new Organization();
+          myNewOrg.name = 'test';
+          myNewOrg.slug = 'test';
+          myNewOrg.people = [];
+          myNewOrg.addPerson({ person: newPerson1._id, title: 'CEO' });
+          myNewOrg.addPerson({ person: newPerson2._id, title: 'CTO' });
+
+          Organization.upsert(myNewOrg, 'testy', function(err, result) {
+
+            should.not.exist(err);
+            should.exist(result);
+
+            merge.peopleById(newPerson2.id, newPerson1.id, 'testy', customer._id, function(err, merged) {
+
+              should.not.exist(err);
+              should.exist(merged);
+
+              Organization.getById(result.id, { CUSTOMER_ID: customer._id, role: 'none' }, function(err, finalResult) {
+
+                should.not.exist(err);
+                should.exist(finalResult);
+                should.exist(finalResult.people);
+                finalResult.people.length.should.equal(1);
+                finalResult.people[0].person._id.toString().should.equal(newPerson2._id.toString());
+
+                return done();
+
+              });
+
+            });
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges two people and only source is referenced by org', function (done) {
+
+      var myNewPerson1 = new Person();
+      myNewPerson1.name = { first:'jason', last:'reynolds'};
+      myNewPerson1.slug = 'jason-reynolds';
+
+      var myNewPerson2 = new Person();
+      myNewPerson2.name = { first:'jim', last:'jenkins'};
+      myNewPerson2.slug = 'jim-jenkins';
+
+      Person.upsert(myNewPerson1, 'test', function(err, newPerson1) {
+
+        should.not.exist(err);
+        should.exist(newPerson1);
+
+        Person.upsert(myNewPerson2, 'test', function (err, newPerson2) {
+
+          should.not.exist(err);
+          should.exist(newPerson2);
+
+          var myNewOrg = new Organization();
+          myNewOrg.name = 'test';
+          myNewOrg.slug = 'test';
+          myNewOrg.people = [];
+          myNewOrg.addPerson({ person: newPerson1._id, title: 'CEO' });
+
+          Organization.upsert(myNewOrg, 'testy', function(err, result) {
+
+            should.not.exist(err);
+            should.exist(result);
+            should.exist(result.people);
+            result.people.length.should.equal(1);
+            result.people[0].person.toString().should.equal(newPerson1._id.toString()); // source
+
+            merge.peopleById(newPerson2.id, newPerson1.id, 'testy', customer._id, function(err, merged) {
+
+              should.not.exist(err);
+              should.exist(merged);
+
+              Organization.getById(result.id, { CUSTOMER_ID: customer._id, role: 'none' }, function(err, finalResult) {
+
+                should.not.exist(err);
+                should.exist(finalResult);
+                should.exist(finalResult.people);
+                finalResult.people.length.should.equal(1);
+                finalResult.people[0].person._id.toString().should.equal(newPerson2._id.toString()); // target
+
+                return done();
+
+              });
+
+            });
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges two sources for same customer', function(done) {
+
+      // reset to not flag
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var newPerson1 = new Person();
+      newPerson1.name.first = 'New';
+      newPerson1.name.last = 'Person';
+      newPerson1.slug = 'new-person-1';
+      newPerson1.sources = [{
+        person: person3,
+        customer: customer
+      }];
+
+      var newPerson2 = new Person();
+      newPerson2.name.first = 'Newer';
+      newPerson2.name.last = 'Person';
+      newPerson2.slug = 'new-person-2';
+      newPerson2.sources = [{
+        person: person2,
+        customer: customer
+      }];
+
+      Person.upsert(newPerson1, 'test', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+        newPerson1 = result;
+
+        Person.upsert(newPerson2, 'test', function(err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+          newPerson2 = result;
+
+          merge.peopleById(newPerson2.id, newPerson1.id, 'testy', customer._id, function(err, result) {
+
+            should.not.exist(err);
+            should.exist(result);
+
+            result.sources.length.should.equal(2);
+            result.sources[0].person._id.toString().should.equal(person2._id.toString());
+            result.sources[0].customer.toString().should.equal(customer._id.toString());
+            result.sources[1].person._id.toString().should.equal(person3._id.toString());
+            result.sources[1].customer.toString().should.equal(customer._id.toString());
+
+
+            return done();
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges same source for different customers', function(done) {
+
+      // reset to not flag
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var newPerson1 = new Person();
+      newPerson1.name.first = 'New';
+      newPerson1.name.last = 'Person';
+      newPerson1.slug = 'new-person-1';
+      newPerson1.sources = [{
+        person: person3._id,
+        customer: org2._id
+      }];
+
+      var newPerson2 = new Person();
+      newPerson2.name.first = 'Newer';
+      newPerson2.name.last = 'Person';
+      newPerson2.slug = 'new-person-2';
+      newPerson2.sources = [{
+        person: person3._id,
+        customer: org3._id
+      }];
+
+      Person.upsert(newPerson1, 'test', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+        newPerson1 = result;
+
+        Person.upsert(newPerson2, 'test', function(err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+          newPerson2 = result;
+
+          merge.peopleById(newPerson2.id, newPerson1.id, 'testy', customer._id, function(err, result) {
+
+            should.not.exist(err);
+            should.exist(result);
+
+            result.sources.length.should.equal(2);
+            result.sources[0].person._id.toString().should.equal(person3._id.toString());
+            result.sources[0].customer.toString().should.equal(org3._id.toString());
+            result.sources[1].person._id.toString().should.equal(person3._id.toString());
+            result.sources[1].customer.toString().should.equal(org2._id.toString());
+
+
+            return done();
+
+          });
+
+        });
+
+      });
+
+    });
+
+    it('Merges two sources for two customers', function(done) {
+
+      // reset to not flag
+      config.flag = false;
+      merge = new Merge(mongoose, config);
+
+      var newPerson1 = new Person();
+      newPerson1.name.first = 'New';
+      newPerson1.name.last = 'Person';
+      newPerson1.slug = 'new-person-1';
+      newPerson1.sources = [{
+        person: person3._id,
+        customer: org3._id
+      }];
+
+      var newPerson2 = new Person();
+      newPerson2.name.first = 'Newer';
+      newPerson2.name.last = 'Person';
+      newPerson2.slug = 'new-person-2';
+      newPerson2.sources = [{
+        person: person2._id,
+        customer: org2._id
+      }];
+
+      Person.upsert(newPerson1, 'test', function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+        newPerson1 = result;
+
+        Person.upsert(newPerson2, 'test', function(err, result) {
+
+          should.not.exist(err);
+          should.exist(result);
+          newPerson2 = result;
+
+          merge.peopleById(newPerson2.id, newPerson1.id, 'testy', customer._id, function(err, result) {
+
+            should.not.exist(err);
+            should.exist(result);
+
+            result.sources.length.should.equal(2);
+            result.sources[0].person._id.toString().should.equal(person2._id.toString());
+            result.sources[0].customer.toString().should.equal(org2._id.toString());
+            result.sources[1].person._id.toString().should.equal(person3._id.toString());
+            result.sources[1].customer.toString().should.equal(org3._id.toString());
+
+
+            return done();
+
+          });
+
+        });
+
+      });
+
+    });
+
+  });
+
+});