fruit_to_lime 2.5.5 → 2.5.6

data/spec/person_spec.rb

@@ -1,134 +1,134 @@
-require "spec_helper"
-require 'fruit_to_lime'
-
-describe "Person" do
-    let(:person) {
-        FruitToLime::Person.new
-    }
-
-    it "can set a customfield" do
-        person.set_custom_field({:integration_id=>'the key',
-            :value=> 'the value'})
-
-        value = person.custom_values[0]
-        field = value.field
-        field.integration_id.should eq 'the key'
-        value.value.should eq 'the value'
-    end
-
-    it "will set custom field with same integration_id to the last value" do
-        person.set_custom_field({:integration_id=>'the key',
-            :value=> 'the value'})
-
-        person.set_custom_field({:integration_id=>'the key',
-            :value=> 'the value 2'})
-        value = person.custom_values[0]
-        field = value.field
-
-        person.custom_values.length.should eq 1
-        field.integration_id.should eq 'the key'
-        value.value.should eq 'the value 2'
-    end
-
-    it "will set custom field with same id to the last value" do
-        person.set_custom_field({:id=>'the id',
-            :value=> 'the value'})
-
-        person.set_custom_field({:id=>'the id',
-            :value=> 'the value 2'})
-        value = person.custom_values[0]
-        field = value.field
-
-        person.custom_values.length.should eq 1
-        field.id.should eq 'the id'
-        value.value.should eq 'the value 2'
-    end
-
-    it "will set custom field (using set_custom_value) with same integration_id to the last value" do
-        person.set_custom_value('the id','the value')
-
-        person.set_custom_value('the id','the value 2')
-        value = person.custom_values[0]
-        field = value.field
-
-        person.custom_values.length.should eq 1
-        field.integration_id.should eq 'the id'
-        value.value.should eq 'the value 2'
-    end
-
-    it "will only set tag once" do
-        person.set_tag('tag1')
-        person.set_tag('tag1')
-        person.tags.length.should eq 1
-        tag = person.tags[0]
-        tag.value.should eq 'tag1'
-    end
-
-    it "should have a firstname if no lastname" do
-        person.first_name = "Vincent"
-        person.last_name = nil
-
-        error = person.validate
-        error.should be_empty
-    end
-
-    it "should be currently employed if nothing specified" do
-        expect(person.currently_employed).to eq(true)
-    end
-
-    it "should have a lastname if no firstname" do
-        person.first_name = String.new
-        person.last_name = "Vega"
-
-        error = person.validate
-        error.should be_empty
-    end
-
-    it "shouldnt pass validation with no firstname and lastname" do
-        person.first_name = String.new
-        person.last_name = nil
-
-        error = person.validate
-        error.should start_with("A firstname or lastname is required for person")
-    end
-
-    it "should auto convert org to org.ref during assignment" do
-        # given
-        org = FruitToLime::Organization.new({:integration_id => "123", :name => "Lundalogik"})
-
-        # when
-        person.organization = org
-
-        # then
-        person.organization.is_a?(FruitToLime::OrganizationReference).should eq true
-    end
-
-    describe "parse_name_to_firstname_lastname_se" do
-        it "can parse 'Kalle Nilsson' into firstname 'Kalle' and lastname 'Nilsson'" do
-            person.parse_name_to_firstname_lastname_se 'Kalle Nilsson'
-
-            person.first_name.should eq 'Kalle'
-            person.last_name.should eq 'Nilsson'
-        end
-
-        it "can parse 'Kalle Svensson Nilsson' into firstname 'Kalle' and lastname 'Svensson Nilsson'" do
-            person.parse_name_to_firstname_lastname_se 'Kalle Svensson Nilsson'
-
-            person.first_name.should eq 'Kalle'
-            person.last_name.should eq 'Svensson Nilsson'
-        end
-
-        it "sets default name when name is empty" do
-            person.parse_name_to_firstname_lastname_se '', 'a default'
-
-            person.first_name.should eq 'a default'
-        end
-
-        it "sets default name when name is nil" do
-            person.parse_name_to_firstname_lastname_se nil, 'a default'
-
-            person.first_name.should eq 'a default'
-        end
-    end
-end
-
+require "spec_helper"
+require 'fruit_to_lime'
+
+describe "Person" do
+    let(:person) {
+        FruitToLime::Person.new
+    }
+
+    it "can set a customfield" do
+        person.set_custom_field({:integration_id=>'the key',
+            :value=> 'the value'})
+
+        value = person.custom_values[0]
+        field = value.field
+        field.integration_id.should eq 'the key'
+        value.value.should eq 'the value'
+    end
+
+    it "will set custom field with same integration_id to the last value" do
+        person.set_custom_field({:integration_id=>'the key',
+            :value=> 'the value'})
+
+        person.set_custom_field({:integration_id=>'the key',
+            :value=> 'the value 2'})
+        value = person.custom_values[0]
+        field = value.field
+
+        person.custom_values.length.should eq 1
+        field.integration_id.should eq 'the key'
+        value.value.should eq 'the value 2'
+    end
+
+    it "will set custom field with same id to the last value" do
+        person.set_custom_field({:id=>'the id',
+            :value=> 'the value'})
+
+        person.set_custom_field({:id=>'the id',
+            :value=> 'the value 2'})
+        value = person.custom_values[0]
+        field = value.field
+
+        person.custom_values.length.should eq 1
+        field.id.should eq 'the id'
+        value.value.should eq 'the value 2'
+    end
+
+    it "will set custom field (using set_custom_value) with same integration_id to the last value" do
+        person.set_custom_value('the id','the value')
+
+        person.set_custom_value('the id','the value 2')
+        value = person.custom_values[0]
+        field = value.field
+
+        person.custom_values.length.should eq 1
+        field.integration_id.should eq 'the id'
+        value.value.should eq 'the value 2'
+    end
+
+    it "will only set tag once" do
+        person.set_tag('tag1')
+        person.set_tag('tag1')
+        person.tags.length.should eq 1
+        tag = person.tags[0]
+        tag.value.should eq 'tag1'
+    end
+
+    it "should have a firstname if no lastname" do
+        person.first_name = "Vincent"
+        person.last_name = nil
+
+        error = person.validate
+        error.should be_empty
+    end
+
+    it "should be currently employed if nothing specified" do
+        expect(person.currently_employed).to eq(true)
+    end
+
+    it "should have a lastname if no firstname" do
+        person.first_name = String.new
+        person.last_name = "Vega"
+
+        error = person.validate
+        error.should be_empty
+    end
+
+    it "shouldnt pass validation with no firstname and lastname" do
+        person.first_name = String.new
+        person.last_name = nil
+
+        error = person.validate
+        error.should start_with("A firstname or lastname is required for person")
+    end
+
+    it "should auto convert org to org.ref during assignment" do
+        # given
+        org = FruitToLime::Organization.new({:integration_id => "123", :name => "Lundalogik"})
+
+        # when
+        person.organization = org
+
+        # then
+        person.organization.is_a?(FruitToLime::OrganizationReference).should eq true
+    end
+
+    describe "parse_name_to_firstname_lastname_se" do
+        it "can parse 'Kalle Nilsson' into firstname 'Kalle' and lastname 'Nilsson'" do
+            person.parse_name_to_firstname_lastname_se 'Kalle Nilsson'
+
+            person.first_name.should eq 'Kalle'
+            person.last_name.should eq 'Nilsson'
+        end
+
+        it "can parse 'Kalle Svensson Nilsson' into firstname 'Kalle' and lastname 'Svensson Nilsson'" do
+            person.parse_name_to_firstname_lastname_se 'Kalle Svensson Nilsson'
+
+            person.first_name.should eq 'Kalle'
+            person.last_name.should eq 'Svensson Nilsson'
+        end
+
+        it "sets default name when name is empty" do
+            person.parse_name_to_firstname_lastname_se '', 'a default'
+
+            person.first_name.should eq 'a default'
+        end
+
+        it "sets default name when name is nil" do
+            person.parse_name_to_firstname_lastname_se nil, 'a default'
+
+            person.first_name.should eq 'a default'
+        end
+    end
+end
+

data/spec/rootmodel_spec.rb

@@ -1,277 +1,306 @@
-require "spec_helper"
-require 'fruit_to_lime'
-
-describe "RootModel" do
-    let(:rootmodel) {
-        FruitToLime::RootModel.new
-    }
-
-    it "will contain integration coworker by default" do
-        rootmodel.find_coworker_by_integration_id("import").first_name.should eq "Import"
-        rootmodel.coworkers.length.should eq 1
-    end
-
-    it "can add a coworker from a hash" do
-        rootmodel.add_coworker({
-            :integration_id => "123key",
-            :first_name => "Kalle",
-            :last_name => "Anka",
-            :email => "kalle.anka@vonanka.com"
-        })
-        rootmodel.find_coworker_by_integration_id("123key").first_name.should eq "Kalle"
-        rootmodel.coworkers.length.should eq 2
-    end
-
-    it "can add a coworker from a new coworker" do
-        coworker = FruitToLime::Coworker.new
-        coworker.integration_id = "123key"
-        coworker.first_name="Kalle"
-        coworker.last_name="Anka"
-        coworker.email = "kalle.anka@vonanka.com"
-        rootmodel.add_coworker(coworker)
-        rootmodel.find_coworker_by_integration_id("123key").first_name.should eq "Kalle"
-        rootmodel.coworkers.length.should eq 2
-    end
-
-    it "will not add a new coworker when the coworker is already added (same integration id)" do
-        rootmodel.add_coworker({
-            :integration_id=>"123key",
-            :first_name=>"Kalle",
-            :last_name=>"Anka",
-            :email=>"kalle.anka@vonanka.com"
-        })
-        rootmodel.coworkers.length.should eq 2
-        expect {
-            rootmodel.add_coworker({
-                :integration_id=>"123key",
-                :first_name=>"Knatte",
-                :last_name=>"Anka",
-                :email=>"knatte.anka@vonanka.com"
-            })
-        }.to raise_error(FruitToLime::AlreadyAddedError)
-        rootmodel.find_coworker_by_integration_id("123key").first_name.should eq "Kalle"
-        rootmodel.coworkers.length.should eq 2
-    end
-
-    it "can add an organization from hash" do
-        rootmodel.add_organization({
-                                       :integration_id => "123key",
-                                       :name => "Beagle Boys"
-        })
-        rootmodel.find_organization_by_integration_id("123key").name.should eq "Beagle Boys"
-        rootmodel.organizations.length.should eq 1
-    end
-
-    it "can add an organization from a new organization" do
-        # given
-        organization = FruitToLime::Organization.new
-        organization.integration_id = "123key"
-        organization.name = "Beagle Boys"
-
-        # when
-        rootmodel.add_organization(organization)
-
-        # then
-        rootmodel.find_organization_by_integration_id("123key").name.should eq "Beagle Boys"
-        rootmodel.organizations.length.should eq 1
-    end
-
-    it "will not add a new organizations when the organizations is already added (same integration id)" do
-        # given
-        rootmodel.add_organization({
-            :integration_id => "123key",
-            :name => "Beagle Boys"
-        })
-        rootmodel.organizations.length.should eq 1
-        rootmodel.find_organization_by_integration_id("123key").name.should eq "Beagle Boys"
-
-        # when, then
-        expect {
-            rootmodel.add_organization({
-                :integration_id => "123key",
-                :name => "Beagle Boys 2"
-            })
-        }.to raise_error(FruitToLime::AlreadyAddedError)
-        rootmodel.find_organization_by_integration_id("123key").name.should eq "Beagle Boys"
-        rootmodel.organizations.length.should eq 1
-    end
-
-    it "can add a deal from hash" do
-        rootmodel.add_deal({
-                                       :integration_id => "123key",
-                                       :name => "Big deal"
-        })
-        rootmodel.find_deal_by_integration_id("123key").name.should eq "Big deal"
-        rootmodel.deals.length.should eq 1
-    end
-
-    it "can add a deal from a new deal" do
-        # given
-        deal = FruitToLime::Deal.new
-        deal.integration_id = "123key"
-        deal.name = "Big deal"
-
-        # when
-        rootmodel.add_deal(deal)
-
-        # then
-        rootmodel.find_deal_by_integration_id("123key").name.should eq "Big deal"
-        rootmodel.deals.length.should eq 1
-    end
-
-    it "will not add a new deal when the deal is already added (same integration id)" do
-        # given
-        rootmodel.add_deal({
-            :integration_id => "123key",
-            :name => "Big deal"
-        })
-        rootmodel.deals.length.should eq 1
-        rootmodel.find_deal_by_integration_id("123key").name.should eq "Big deal"
-
-        # when, then
-        expect {
-            rootmodel.add_deal({
-                :integration_id => "123key",
-                :name => "Bigger deal"
-            })
-        }.to raise_error(FruitToLime::AlreadyAddedError)
-        rootmodel.find_deal_by_integration_id("123key").name.should eq "Big deal"
-        rootmodel.deals.length.should eq 1
-    end
-
-    it "can add a note from hash" do
-        rootmodel.add_note({
-                               :integration_id => "123key",
-                               :text => "This is a note"
-        })
-        rootmodel.find_note_by_integration_id("123key").text.should eq "This is a note"
-        rootmodel.notes.length.should eq 1
-    end
-
-    it "can add a note from a new note" do
-        # given
-        note = FruitToLime::Note.new
-        note.integration_id = "123key"
-        note.text = "This is a note"
-
-        # when
-        rootmodel.add_note(note)
-
-        # then
-        rootmodel.find_note_by_integration_id("123key").text.should eq "This is a note"
-        rootmodel.notes.length.should eq 1
-    end
-
-    it "will not add a new organizations when the organizations is already added (same integration id)" do
-        # given
-        rootmodel.add_note({
-            :integration_id => "123key",
-            :text => "This is a note"
-        })
-        rootmodel.notes.length.should eq 1
-
-        # when, then
-        expect {
-            rootmodel.add_note({
-                :integration_id => "123key",
-                :text => "This is another note"
-            })
-        }.to raise_error(FruitToLime::AlreadyAddedError)
-        rootmodel.notes.length.should eq 1
-        rootmodel.find_note_by_integration_id("123key").text.should eq "This is a note"
-    end
-
-    it "Will find a person by integration id" do
-        # given
-        organization = FruitToLime::Organization.new
-        organization.name = "Hubba Bubba"
-        organization.add_employee({
-            :integration_id => "123",
-            :first_name => "Billy",
-            :last_name => "Bob"
-        })
-        
-        rootmodel.add_organization(organization)
-        
-        # when
-        found_person = rootmodel.find_person_by_integration_id("123")
-
-        # then
-        found_person.integration_id.should eq "123"
-        found_person.first_name.should eq "Billy"
-        found_person.last_name.should eq "Bob"
-    end
-
-    it "Will find a person by integration id from an organization with many employees" do
-        # given
-        organization = FruitToLime::Organization.new
-        organization.name = "Hubba Bubba"
-        organization.add_employee({
-            :integration_id => "123",
-            :first_name => "Billy",
-            :last_name => "Bob"
-        })
-        organization.add_employee({
-            :integration_id => "456",
-            :first_name => "Vincent",
-            :last_name => "Vega"
-        })
-        
-        rootmodel.add_organization(organization)
-
-        # when
-        found_person = rootmodel.find_person_by_integration_id("123")
-
-        # then
-        found_person.integration_id.should eq "123"
-        found_person.first_name.should eq "Billy"
-        found_person.last_name.should eq "Bob"
-    end
-
-    it "will ignore empty integration ids during sanity check" do
-        org1 = FruitToLime::Organization.new
-        org1.name = "company 1"
-        rootmodel.organizations.push org1
-
-        org2 = FruitToLime::Organization.new
-        org2.name = "company 2"
-        rootmodel.organizations.push org2
-
-        rootmodel.sanity_check.should eq ""
-    end
-
-    it "will report when the same integration id is used during sanity check" do
-        org1 = FruitToLime::Organization.new
-        org1.integration_id = "1"
-        org1.name = "company 1"
-        rootmodel.organizations.push org1
-
-        org2 = FruitToLime::Organization.new
-        org2.integration_id = "1"
-        org2.name = "company 2"
-        rootmodel.organizations.push org2
-
-        rootmodel.sanity_check.should eq "Duplicate organization integration_id: 1."
-    end
-
-    it "will report when the same integrationid on person is used during sanity check" do
-        org1 = FruitToLime::Organization.new
-        org1.integration_id = "1"
-        org1.name = "company 1"
-        person1 = FruitToLime::Person.new
-        person1.integration_id = '1'
-        org1.add_employee person1
-
-        rootmodel.organizations.push org1
-
-        org2 = FruitToLime::Organization.new
-        org2.integration_id = "2"
-        org2.name = "company 2"
-        person2 = FruitToLime::Person.new
-        person2.integration_id = '1'
-        org2.add_employee person2
-        rootmodel.organizations.push org2
-
-        rootmodel.sanity_check.should eq "Duplicate person integration_id: 1."
-    end
-end
+require "spec_helper"
+require 'fruit_to_lime'
+
+describe "RootModel" do
+    let(:rootmodel) {
+        FruitToLime::RootModel.new
+    }
+
+    it "will contain integration coworker by default" do
+        rootmodel.find_coworker_by_integration_id("import").first_name.should eq "Import"
+        rootmodel.coworkers.length.should eq 1
+    end
+
+    it "can add a coworker from a hash" do
+        rootmodel.add_coworker({
+            :integration_id => "123key",
+            :first_name => "Kalle",
+            :last_name => "Anka",
+            :email => "kalle.anka@vonanka.com"
+        })
+        rootmodel.find_coworker_by_integration_id("123key").first_name.should eq "Kalle"
+        rootmodel.coworkers.length.should eq 2
+    end
+
+    it "can add a coworker from a new coworker" do
+        coworker = FruitToLime::Coworker.new
+        coworker.integration_id = "123key"
+        coworker.first_name="Kalle"
+        coworker.last_name="Anka"
+        coworker.email = "kalle.anka@vonanka.com"
+        rootmodel.add_coworker(coworker)
+        rootmodel.find_coworker_by_integration_id("123key").first_name.should eq "Kalle"
+        rootmodel.coworkers.length.should eq 2
+    end
+
+    it "will not add a new coworker when the coworker is already added (same integration id)" do
+        rootmodel.add_coworker({
+            :integration_id=>"123key",
+            :first_name=>"Kalle",
+            :last_name=>"Anka",
+            :email=>"kalle.anka@vonanka.com"
+        })
+        rootmodel.coworkers.length.should eq 2
+        expect {
+            rootmodel.add_coworker({
+                :integration_id=>"123key",
+                :first_name=>"Knatte",
+                :last_name=>"Anka",
+                :email=>"knatte.anka@vonanka.com"
+            })
+        }.to raise_error(FruitToLime::AlreadyAddedError)
+        rootmodel.find_coworker_by_integration_id("123key").first_name.should eq "Kalle"
+        rootmodel.coworkers.length.should eq 2
+    end
+
+    it "can add an organization from hash" do
+        rootmodel.add_organization({
+                                       :integration_id => "123key",
+                                       :name => "Beagle Boys"
+        })
+        rootmodel.find_organization_by_integration_id("123key").name.should eq "Beagle Boys"
+        rootmodel.organizations.length.should eq 1
+    end
+
+    it "can add an organization from a new organization" do
+        # given
+        organization = FruitToLime::Organization.new
+        organization.integration_id = "123key"
+        organization.name = "Beagle Boys"
+
+        # when
+        rootmodel.add_organization(organization)
+
+        # then
+        rootmodel.find_organization_by_integration_id("123key").name.should eq "Beagle Boys"
+        rootmodel.organizations.length.should eq 1
+    end
+
+    it "will not add a new organizations when the organizations is already added (same integration id)" do
+        # given
+        rootmodel.add_organization({
+            :integration_id => "123key",
+            :name => "Beagle Boys"
+        })
+        rootmodel.organizations.length.should eq 1
+        rootmodel.find_organization_by_integration_id("123key").name.should eq "Beagle Boys"
+
+        # when, then
+        expect {
+            rootmodel.add_organization({
+                :integration_id => "123key",
+                :name => "Beagle Boys 2"
+            })
+        }.to raise_error(FruitToLime::AlreadyAddedError)
+        rootmodel.find_organization_by_integration_id("123key").name.should eq "Beagle Boys"
+        rootmodel.organizations.length.should eq 1
+    end
+
+    it "can add a deal from hash" do
+        rootmodel.add_deal({
+                                       :integration_id => "123key",
+                                       :name => "Big deal"
+        })
+        rootmodel.find_deal_by_integration_id("123key").name.should eq "Big deal"
+        rootmodel.deals.length.should eq 1
+    end
+
+    it "can add a deal from a new deal" do
+        # given
+        deal = FruitToLime::Deal.new
+        deal.integration_id = "123key"
+        deal.name = "Big deal"
+
+        # when
+        rootmodel.add_deal(deal)
+
+        # then
+        rootmodel.find_deal_by_integration_id("123key").name.should eq "Big deal"
+        rootmodel.deals.length.should eq 1
+    end
+
+    it "will set reponsible coworker to import_coworker if none specifed" do
+        # given
+        deal = FruitToLime::Deal.new
+        deal.integration_id = "123key"
+        deal.name = "Big deal"
+
+        # when
+        rootmodel.add_deal(deal)
+
+        # then
+        deal.responsible_coworker.integration_id.should eq rootmodel.import_coworker.integration_id
+    end
+
+    it "will not set reponsible coworker to import_coworker if specifed" do
+        # given
+        deal = FruitToLime::Deal.new
+        deal.integration_id = "123key"
+        deal.name = "Big deal"
+        coworker = FruitToLime::Coworker.new
+        coworker.integration_id = "123"
+        deal.responsible_coworker = coworker
+
+        # when
+        rootmodel.add_deal(deal)
+
+        # then
+        deal.responsible_coworker.integration_id.should eq coworker.integration_id
+    end
+
+    it "will not add a new deal when the deal is already added (same integration id)" do
+        # given
+        rootmodel.add_deal({
+            :integration_id => "123key",
+            :name => "Big deal"
+        })
+        rootmodel.deals.length.should eq 1
+        rootmodel.find_deal_by_integration_id("123key").name.should eq "Big deal"
+
+        # when, then
+        expect {
+            rootmodel.add_deal({
+                :integration_id => "123key",
+                :name => "Bigger deal"
+            })
+        }.to raise_error(FruitToLime::AlreadyAddedError)
+        rootmodel.find_deal_by_integration_id("123key").name.should eq "Big deal"
+        rootmodel.deals.length.should eq 1
+    end
+
+    it "can add a note from hash" do
+        rootmodel.add_note({
+                               :integration_id => "123key",
+                               :text => "This is a note"
+        })
+        rootmodel.find_note_by_integration_id("123key").text.should eq "This is a note"
+        rootmodel.notes.length.should eq 1
+    end
+
+    it "can add a note from a new note" do
+        # given
+        note = FruitToLime::Note.new
+        note.integration_id = "123key"
+        note.text = "This is a note"
+
+        # when
+        rootmodel.add_note(note)
+
+        # then
+        rootmodel.find_note_by_integration_id("123key").text.should eq "This is a note"
+        rootmodel.notes.length.should eq 1
+    end
+
+    it "will not add a new organizations when the organizations is already added (same integration id)" do
+        # given
+        rootmodel.add_note({
+            :integration_id => "123key",
+            :text => "This is a note"
+        })
+        rootmodel.notes.length.should eq 1
+
+        # when, then
+        expect {
+            rootmodel.add_note({
+                :integration_id => "123key",
+                :text => "This is another note"
+            })
+        }.to raise_error(FruitToLime::AlreadyAddedError)
+        rootmodel.notes.length.should eq 1
+        rootmodel.find_note_by_integration_id("123key").text.should eq "This is a note"
+    end
+
+    it "Will find a person by integration id" do
+        # given
+        organization = FruitToLime::Organization.new
+        organization.name = "Hubba Bubba"
+        organization.add_employee({
+            :integration_id => "123",
+            :first_name => "Billy",
+            :last_name => "Bob"
+        })
+
+        rootmodel.add_organization(organization)
+
+        # when
+        found_person = rootmodel.find_person_by_integration_id("123")
+
+        # then
+        found_person.integration_id.should eq "123"
+        found_person.first_name.should eq "Billy"
+        found_person.last_name.should eq "Bob"
+    end
+
+    it "Will find a person by integration id from an organization with many employees" do
+        # given
+        organization = FruitToLime::Organization.new
+        organization.name = "Hubba Bubba"
+        organization.add_employee({
+            :integration_id => "123",
+            :first_name => "Billy",
+            :last_name => "Bob"
+        })
+        organization.add_employee({
+            :integration_id => "456",
+            :first_name => "Vincent",
+            :last_name => "Vega"
+        })
+
+        rootmodel.add_organization(organization)
+
+        # when
+        found_person = rootmodel.find_person_by_integration_id("123")
+
+        # then
+        found_person.integration_id.should eq "123"
+        found_person.first_name.should eq "Billy"
+        found_person.last_name.should eq "Bob"
+    end
+
+    it "will ignore empty integration ids during sanity check" do
+        org1 = FruitToLime::Organization.new
+        org1.name = "company 1"
+        rootmodel.organizations.push org1
+
+        org2 = FruitToLime::Organization.new
+        org2.name = "company 2"
+        rootmodel.organizations.push org2
+
+        rootmodel.sanity_check.should eq ""
+    end
+
+    it "will report when the same integration id is used during sanity check" do
+        org1 = FruitToLime::Organization.new
+        org1.integration_id = "1"
+        org1.name = "company 1"
+        rootmodel.organizations.push org1
+
+        org2 = FruitToLime::Organization.new
+        org2.integration_id = "1"
+        org2.name = "company 2"
+        rootmodel.organizations.push org2
+
+        rootmodel.sanity_check.should eq "Duplicate organization integration_id: 1."
+    end
+
+    it "will report when the same integrationid on person is used during sanity check" do
+        org1 = FruitToLime::Organization.new
+        org1.integration_id = "1"
+        org1.name = "company 1"
+        person1 = FruitToLime::Person.new
+        person1.integration_id = '1'
+        org1.add_employee person1
+
+        rootmodel.organizations.push org1
+
+        org2 = FruitToLime::Organization.new
+        org2.integration_id = "2"
+        org2.name = "company 2"
+        person2 = FruitToLime::Person.new
+        person2.integration_id = '1'
+        org2.add_employee person2
+        rootmodel.organizations.push org2
+
+        rootmodel.sanity_check.should eq "Duplicate person integration_id: 1."
+    end
+end