go_import 3.0.0

data/spec/deal_spec.rb

@@ -0,0 +1,182 @@
+require "spec_helper"
+require 'go_import'
+
+describe "Deal" do
+    let(:deal){
+        GoImport::Deal.new
+    }
+
+    it "will auto convert org to org.ref during assignment" do
+        # given
+        org = GoImport::Organization.new({:integration_id => "123", :name => "Lundalogik"})
+
+        # when
+        deal.customer = org
+
+        # then
+        deal.customer.is_a?(GoImport::OrganizationReference).should eq true
+    end
+
+    it "will auto convert coworker to coworker.ref during assignment" do
+        # given
+        coworker = GoImport::Coworker.new({:integration_id => "456", :first_name => "Billy", :last_name => "Bob"})
+
+        # when
+        deal.responsible_coworker = coworker
+
+        # then
+        deal.responsible_coworker.is_a?(GoImport::CoworkerReference).should eq true
+    end
+
+    it "will auto convert person to person.ref during assignment" do
+        # given
+        person = GoImport::Person.new({:integration_id => "123"})
+
+        # when
+        deal.customer_contact = person
+
+        # then
+        deal.customer_contact.is_a?(GoImport::PersonReference).should eq true
+    end
+
+    it "will fail on validation if name is empty" do
+        # given
+        deal.name = ""
+        deal.status = "required status"
+
+        # when, then
+        deal.validate.length.should be > 0
+    end
+
+    it "will fail on validation if name is nil" do
+        # given
+        deal.name = nil
+        deal.status = "required status"
+
+        # when, then
+        deal.validate.length.should be > 0
+    end
+
+    it "will fail on validation if status dont have a status reference" do
+        # given
+        deal.name = "Deal must have a name"
+        # this will create a status with a status_reference
+        deal.status = "Driv"
+
+        # when
+        # and this will set the reference to nil (this will probably
+        # never happen in the real world).
+        deal.status.status_reference = nil
+
+        # then
+        deal.validate.length.should be > 0
+    end
+
+    it "will fail on validation if status has an invalid status reference" do
+        # given
+        deal.name = "Deal must have a name"
+        deal.status = ""
+
+        # when, then
+        deal.validate.length.should be > 0
+    end
+
+    it "should convert value strings that looks like number to number" do
+        # given
+        deal.name = "The deal with a strange value"
+
+        # when
+        deal.value = "357 000"
+
+        # then
+        deal.value.should eq "357000"
+    end
+
+    it "should raise invalidvalueerror if value is not a number" do
+        # given
+        deal.name = "The deal with an invalid value"
+
+        # when, then
+        expect {
+            deal.value = "Im not a number"
+        }.to raise_error(GoImport::InvalidValueError)
+    end
+
+    it "should set value if value is an integer" do
+        # given
+        deal.name = "The new deal"
+
+        # when
+        deal.value = "100"
+
+        # then
+        deal.value.should eq "100"
+    end
+
+    it "should set value if value is a float" do
+        # given
+        deal.name = "The new deal"
+
+        # when
+        deal.value = "100.10"
+
+        # then
+        deal.value.should eq "100.10"
+    end
+
+    it "should set value to 0 if value is nil" do
+        # given
+        deal.name = "The new deal"
+
+        # when
+        deal.value = nil
+
+        # then
+        deal.value.should eq 0
+    end
+
+    it "should set status_reference from status_setting" do
+        # This case should be used when the status is defined in the rootmodel
+
+        # given
+        deal.name = "Deal with status from deal_status_setting"
+        deal_status_setting = GoImport::DealStatusSetting.new({:integration_id => "123", :label => "Driv"})
+
+        # when
+        deal.status = deal_status_setting
+
+        # then
+        deal.status.is_a?(GoImport::DealStatus).should eq true
+        deal.status.status_reference.is_a?(GoImport::DealStatusReference).should eq true
+        deal.status.status_reference.label.should eq "Driv"
+        deal.status.status_reference.integration_id.should eq "123"
+    end
+
+    it "should set status_reference from label and integrationid if status is a string" do
+        # This case should be used when the status is already defined
+        # in the appliation and is referenced by label
+
+        # given
+        deal.name = "Deal with status from label"
+
+        # when
+        deal.status = "Driv"
+
+        # then
+        deal.status.is_a?(GoImport::DealStatus).should eq true
+        deal.status.status_reference.is_a?(GoImport::DealStatusReference).should eq true
+        deal.status.status_reference.label.should eq "Driv"
+        deal.status.status_reference.integration_id.should eq "Driv"
+    end
+
+    it "should raise error if status reference cant be created" do
+        # given
+        deal.name = "Deal with failed status"
+
+        # when, then
+        expect {
+            deal.status = GoImport::DealStatus.new({:id => 123})
+        }.to raise_error(GoImport::InvalidDealStatusError)
+    end
+
+end

data/spec/deal_status_reference_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+require 'go_import'
+
+describe "DealStatusReference" do
+    let(:deal_status_reference){
+        GoImport::DealStatusReference.new
+    }
+
+    it "should fail on validation if name, id and integration_id is nil" do
+        # given
+        #deal_status_reference
+
+        # when, then
+        deal_status_reference.validate.length.should be > 0
+    end
+end
+

data/spec/documents_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require 'go_import'
+
+describe "Documents" do
+    let(:documents) {
+        GoImport::Documents.new
+    }
+
+    it "can add a new link" do
+        # given
+        link = GoImport::Link.new
+        link.integration_id = "123key"
+        link.url = "http://dropbox.com/files/readme.txt"
+
+        # when
+        documents.add_link link
+
+        # then
+        documents.find_link_by_integration_id("123key").url.should eq "http://dropbox.com/files/readme.txt"
+        documents.links.length.should eq 1
+    end
+
+    it "will not add a new link when a link with the same integration_id already exists" do
+        # given
+        documents.add_link({ :integration_id => "123", :url => "http://dropbox.com" })
+        documents.links.length.should eq 1
+
+        # when, then
+        expect {
+            documents.add_link({ :integration_id => "123", :url => "http://drive.google.com" })
+        }.to raise_error(GoImport::AlreadyAddedError)
+        documents.links.length.should eq 1
+        documents.find_link_by_integration_id("123").url.should eq "http://dropbox.com"
+    end
+
+end
+

data/spec/helpers/csv_helper_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'go_import'
+
+describe GoImport::CsvHelper do
+    it "should" do
+        v = GoImport::CsvHelper.text_to_hashes("id;navn
+1;Noerrebro")
+        v.should include({"id"=>"1","navn"=>"Noerrebro"})
+    end
+    it "should handle sv chars" do
+        v = GoImport::CsvHelper.text_to_hashes("id;navn
+1;Bj\u{00F6}rk")
+        v.should include({"id"=>"1","navn"=>"Bj\u{00F6}rk"})
+    end
+    it "should handle escaped newlines" do
+        v = GoImport::CsvHelper.text_to_hashes("id;navn
+1;\"Bj\u{00F6}rk
+And a new line\"")
+        v.should include({"id"=>"1","navn"=>"Bj\u{00F6}rk
+And a new line"})
+    end
+    it "should handle escaped newlines with ',' as delim" do
+        v = GoImport::CsvHelper.text_to_hashes("id,navn
+1,\"Bj\u{00F6}rk
+And a new line\"")
+        v.should include({"id"=>"1","navn"=>"Bj\u{00F6}rk
+And a new line"})
+    end
+end

data/spec/helpers/email_helper_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'go_import'
+
+describe GoImport::EmailHelper do
+    it "should validate a common email address" do
+        # given
+        import_email = "apl@lundalogik.se"
+
+        # when, then
+        GoImport::EmailHelper.is_valid?(import_email).should eq true
+    end
+
+    it "should validate an address with firstname.lastname" do
+        GoImport::EmailHelper.is_valid?("firstname.lastname@example.com").should eq true
+    end
+
+    it "should validate an address with lots of subdomains" do
+        GoImport::EmailHelper.is_valid?("firstname.lastname@sub1.sub2.example.com").should eq true
+    end
+
+    it "should validate an address with some special chars" do
+        GoImport::EmailHelper.is_valid?("firstname-lastname+=@sub1.sub2.example.com").should eq true
+    end
+
+    it "should validate an address with no top level domain" do
+        GoImport::EmailHelper.is_valid?("firstname@example").should eq true
+    end
+
+    it "should not validate an invalid address" do
+        GoImport::EmailHelper.is_valid?("hubbabubba").should eq false
+    end
+end

data/spec/helpers/phone_helper_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'go_import'
+
+describe GoImport::PhoneHelper do
+    before(:each) do
+        GoImport::PhoneHelper.set_country_code(:se)
+    end
+
+    it "should parse phonenumbers" do
+        # given, when
+        nice_number = GoImport::PhoneHelper.parse_numbers("0709-685226")
+
+        # then
+        nice_number.should eq "+46709685226"
+    end
+
+    it "should parse multiple numbers with default delimiter" do
+        # given
+        source = "046 - 270 48 00, 0709-685226"
+
+        # when
+        home, mobile = GoImport::PhoneHelper.parse_numbers(source)
+
+        # then
+        home.should eq "+46462704800"
+        mobile.should eq "+46709685226"
+    end
+
+    it "should parse multiple numbers with custom delimiter" do
+        # given
+        source = "046 - 270 48 00/ 0709-685226"
+
+        # when
+        home, mobile = GoImport::PhoneHelper.parse_numbers(source, '/')
+
+        # then
+        home.should eq "+46462704800"
+        mobile.should eq "+46709685226"
+    end
+
+    it "should parse numbers with different delimiters" do
+        # given
+        source1 = "046 - 270 48 00/ 0709-685226"
+        source2 = "08-562 776 00, 070-73 85 180"
+        source3 = "031-712 44 00\\\\ 0707 38 52 72/, 031 71 244 04"
+
+        # when
+        home1, mobile1 = GoImport::PhoneHelper.parse_numbers(source1, ['/', ',', "\\\\"])
+        home2, mobile2 = GoImport::PhoneHelper.parse_numbers(source2, ['/', ',', "\\\\"])
+        home3, mobile3, direct3 = GoImport::PhoneHelper.parse_numbers(source3, ['/', ',', "\\\\"])
+
+        # then
+        home1.should eq "+46462704800"
+        mobile1.should eq "+46709685226"
+
+        home2.should eq "+46856277600"
+        mobile2.should eq "+46707385180"
+
+        home3.should eq "+46317124400"
+        mobile3.should eq "+46707385272"
+        direct3.should eq "+46317124404"
+    end
+
+    it "should not mess with invalid numbers by default" do
+        # given
+        source = "im not a number"
+
+        # when
+        number = GoImport::PhoneHelper.parse_numbers(source)
+
+        # then
+        number.should eq "im not a number"
+    end
+
+    it "should not mess with invalid numbers unless strict mode" do
+        # given
+        source = "im not a number"
+
+        # when
+        number = GoImport::PhoneHelper.parse_numbers_strict(source)
+
+        # then
+        number.should eq ""
+    end
+
+    it "should parse foreign numbers" do
+        # given
+        source = "22 13 00 30"
+
+        # when
+        GoImport::PhoneHelper.set_country_code(:no)
+        number = GoImport::PhoneHelper.parse_numbers(source)
+
+        # then
+        number.should eq "+4722130030"
+    end
+end

data/spec/helpers/roo_helper_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'go_import'
+require 'roo'
+describe GoImport::RooHelper do
+    it "should handle sv chars" do
+        samplefile = File.join(File.dirname(__FILE__), '..', 'sample_data', 'excel.xlsx')
+        rows = GoImport::RooHelper.new(Roo::Excelx.new(samplefile)).rows
+        rows.should include({"Alpha"=>"L\u00E5s","Beta"=>"m\u00E4sk","\u00D6rjan"=>"l\u00E4sk","\u00C4skil"=>""})
+    end
+end

data/spec/helpers/serialize_helper_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+require 'go_import'
+
+describe GoImport::SerializeHelper do
+
+    describe "Serialize note" do
+        let(:serialized) {
+            n = GoImport::Note.new
+            n.text = "text"
+            GoImport::SerializeHelper::serialize(n,-1)
+        }
+        it "should contain text" do
+            serialized.should match(/<Text>[\n ]*text[\n ]*<\/Text>/)
+        end
+        it "should contain start tag" do
+            serialized.should match(/<Note>/)
+        end
+        it "should be utf-8" do
+            serialized.encoding.should equal Encoding::UTF_8
+        end
+    end
+
+    describe "Serialize note with xml inside" do
+        let(:serialized) {
+            n = GoImport::Note.new
+            n.text = "<text>"
+            GoImport::SerializeHelper::serialize(n,-1)
+        }
+        it "should contain encoded text" do
+            serialized.should match(/<Text>[\n ]*&lt;text&gt;[\n ]*<\/Text>/)
+        end
+    end
+
+    describe "Serialize custom value with xml inside" do
+        let(:serialized) {
+            v = GoImport::CustomValue.new
+            v.value = "<text>"
+            v.field = GoImport::CustomFieldReference.new()
+            v.field.integration_id = "1"
+            GoImport::SerializeHelper::serialize(v,-1)
+        }
+        it "should contain encoded text" do
+            serialized.should match(/<Value>[\n ]*&lt;text&gt;[\n ]*<\/Value>/)
+        end
+
+    end
+
+    describe "Serialize without data" do
+        let(:serialized) {
+            p = GoImport::Person.new
+            GoImport::SerializeHelper::serialize(p,-1)
+        }
+        it "should not contain fields that are not set" do
+            serialized.should_not match(/<Email>/)
+            serialized.should_not match(/<Position>/)
+            serialized.should_not match(/<AlternativeEmail>/)
+            serialized.should_not match(/<Tags>/)
+            serialized.should_not match(/<CustomValues>/)
+        end
+        it "should be utf-8" do
+            serialized.encoding.should equal Encoding::UTF_8
+        end
+    end
+
+    describe "Serialize person" do
+        let(:serialized) {
+            p = GoImport::Person.new
+            p.id = "1"
+            p.first_name = "Kalle"
+            p.last_name = "Anka"
+            p.with_source do |source|
+                source.par_se('122345')
+            end
+            #p.source_ref = {:name=>'Go',:id=>"PASE122345"}
+            p.with_postal_address do |addr|
+                addr.city = "Ankeborg"
+            end
+            p.currently_employed=true
+            p.set_tag("tag:anka")
+            p.set_tag("tag:Bj\u{00F6}rk")
+            p.set_tag("tag:<Bj\u{00F6}rk>")
+            p.set_custom_field({:integration_id=>"2", :value=>"cf value"})
+            p.set_custom_field({:integration_id=>"3", :value=>"cf Bj\u{00F6}rk"})
+            p.set_custom_field({:integration_id=>"4", :value=>"cf <Bj\u{00F6}rk>"})
+            GoImport::SerializeHelper::serialize(p,-1)
+        }
+        it "should contain first and last name" do
+            serialized.should match(/<FirstName>[\n ]*Kalle[\n ]*<\/FirstName>/)
+            serialized.should match(/Anka/)
+        end
+        it "should contain currently_employed" do
+            serialized.should match(/<CurrentlyEmployed>[\n ]*true[\n ]*<\/CurrentlyEmployed>/)
+        end
+        it "should tag name" do
+            serialized.should match(/tag:anka/)
+        end
+        it "should contain address" do
+            serialized.should match(/Ankeborg/)
+        end
+        it "should contain custom field" do
+            serialized.should match(/cf value/)
+        end
+        it "should contain reference to source" do
+            serialized.should match(/122345/)
+        end
+        it "should handle sv chars in tags" do
+            serialized.should match(/tag:Bj\u{00F6}rk/)
+        end
+        it "should handle sv chars in custom value" do
+            serialized.should match(/cf Bj\u{00F6}rk/)
+        end
+        it "should handle xml in tag" do
+            serialized.should match(/tag:&lt;Bj\u{00F6}rk&gt;/)
+        end
+        it "should handle xml in custom value" do
+            serialized.should match(/cf &lt;Bj\u{00F6}rk&gt;/)
+        end
+        it "should be utf-8" do
+            serialized.encoding.should equal Encoding::UTF_8
+        end
+    end
+    describe "Serialize organization" do
+        let(:serialized) {
+            o = GoImport::Organization.new
+            o.name = "Ankeborgs bibliotek"
+            o.with_source do |source|
+                source.par_se('122345')
+            end
+            #o.source_ref = {:name=>'Go',:id=>"PASE122345"}
+            o.set_tag("tag:bibliotek")
+            o.set_tag("tag:Bj\u{00F6}rk")
+            o.set_custom_field({:integration_id=>"2", :value=>"cf value"})
+            o.set_custom_field({:integration_id=>"3", :value=>"cf Bj\u{00F6}rk"})
+            o.with_postal_address do |addr|
+                addr.city = "Ankeborg"
+            end
+            o.with_visit_address do |addr|
+                addr.city = "Gaaseborg"
+            end
+            o.add_employee({
+                :integration_id => "1",
+                :first_name => "Kalle",
+                :last_name => "Anka"
+            })
+            GoImport::SerializeHelper::serialize(o,-1)
+        }
+        it "should contain name" do
+            serialized.should match(/Ankeborgs bibliotek/)
+        end
+        it "should contain employee" do
+            serialized.should match(/Kalle/)
+            serialized.should match(/Anka/)
+        end
+        it "should contain address" do
+            serialized.should match(/Ankeborg/)
+            serialized.should match(/Gaaseborg/)
+        end
+        it "should tag name" do
+            serialized.should match(/<Tag>[\n ]*tag:bibliotek[\n ]*<\/Tag>/)
+        end
+        it "should contain custom field" do
+            serialized.should match(/cf value/)
+            #puts serialized
+        end
+        it "should contain reference to source" do
+            serialized.should match(/122345/)
+        end
+        it "should handle sv chars in tags" do
+            serialized.should match(/tag:Bj\u{00F6}rk/)
+        end
+        it "should handle sv chars in custom value" do
+            serialized.should match(/cf Bj\u{00F6}rk/)
+        end
+        it "should be utf-8" do
+            serialized.encoding.should equal Encoding::UTF_8
+        end
+    end
+
+    describe "Serialize goimport" do
+        let(:serialized) {
+            i = GoImport::RootModel.new
+            o = GoImport::Organization.new
+            o.name = "Ankeborgs bibliotek"
+            i.organizations.push(o)
+            GoImport::SerializeHelper::serialize(i,-1)
+        }
+        it "should contain name" do
+            serialized.should match(/Ankeborgs bibliotek/)
+        end
+        it "should have version" do
+            serialized.should match(/<GoImport Version='v2_0'/)
+        end
+        it "should be utf-8" do
+            serialized.encoding.should equal Encoding::UTF_8
+        end
+    end
+    describe "Get import rows" do
+        describe "for person" do
+            let(:import_rows) { GoImport::Person.new.get_import_rows }
+            it "should contain integration id" do
+                import_rows.should include({:id=>'integration_id', :name=>'Integration id', :type=>:string})
+                import_rows.should include({:id=>'id', :name=>'Go id', :type=>:string})
+            end
+            it "should contain address" do
+                expected = {:id=>'postal_address', :name=>'Postal address', :type=>:address,
+                    :model=>[
+                    {:id=>'street',:name=>'Street', :type=>:string},
+                    {:id=>'zip_code',:name=>'Zip code', :type=>:string},
+                    {:id=>'city',:name=>'City', :type=>:string},
+                    {:id=>'country_code',:name=>'Country code', :type=>:string},
+                    {:id=>'location',:name=>'Location', :type=>:string},
+                    {:id=>'country_name',:name=>'Country name', :type=>:string},
+                ]}
+                import_rows.should include(expected)
+            end
+            it "should contain organization" do
+                import_rows.should include({
+                    :id=>'organization',
+                    :name=>'Organization',
+                    :type=>:organization_reference,
+                    :model=>[
+                        {:id=>'id', :name=>'Go id', :type=>:string},
+                        {:id=>'integration_id', :name=>'Integration id', :type=>:string},
+                        {:id=>'heading', :name=>'Heading', :type=>:string}
+                        ]
+                    })
+            end
+        end
+        describe "for organization" do
+            let(:import_rows) { GoImport::Organization.new.get_import_rows }
+            it "should contain integration id" do
+                import_rows.should include({:id=>'integration_id', :name=>'Integration id', :type=>:string})
+                import_rows.should include({:id=>'id', :name=>'Go id', :type=>:string})
+            end
+            it "should contain address" do
+                expected = {:id=>'postal_address', :name=>'Postal address', :type=>:address,
+                    :model=>[
+                        {:id=>'street',:name=>'Street', :type=>:string},
+                        {:id=>'zip_code',:name=>'Zip code', :type=>:string},
+                        {:id=>'city',:name=>'City', :type=>:string},
+                        {:id=>'country_code',:name=>'Country code', :type=>:string},
+                        {:id=>'location',:name=>'Location', :type=>:string},
+                        {:id=>'country_name',:name=>'Country name', :type=>:string},
+                    ]}
+                import_rows.should include(expected)
+            end
+        end
+    end
+end