hubspot-ruby 0.1.7 → 0.1.8

data/spec/lib/hubspot/contact_list_spec.rb

@@ -0,0 +1,249 @@
+describe Hubspot::ContactList do
+  let(:example_contact_list_hash) do
+    VCR.use_cassette("contact_list_example", record: :none) do
+      HTTParty.get("https://api.hubapi.com/contacts/v1/lists/1?hapikey=demo").parsed_response
+    end
+  end
+
+  let(:static_list) { Hubspot::ContactList.all(static: true, count: 3).last }
+  let(:dynamic_list) { Hubspot::ContactList.all(dynamic: true, count: 1).first }
+
+  let(:example_contact_hash) do
+    VCR.use_cassette("contact_example", record: :none) do
+      HTTParty.get("https://api.hubapi.com/contacts/v1/contact/email/testingapis@hubspot.com/profile?hapikey=demo").parsed_response
+    end
+  end
+    
+  describe '#initialize' do
+    subject { Hubspot::ContactList.new(example_contact_list_hash) }
+  	
+    it { should be_an_instance_of Hubspot::ContactList }
+    its(:id) { should be_an(Integer) }
+    its(:portal_id) { should be_a(Integer) }
+    its(:name) { should_not be_empty }
+    its(:dynamic) { should be true } 
+    its(:properties) { should be_a(Hash) }
+  end	
+
+  before { Hubspot.configure(hapikey: "demo") }
+
+  describe '#contacts' do
+    cassette 'contacts_among_list'
+
+    let(:list) { Hubspot::ContactList.new(example_contact_list_hash) }
+
+    it 'returns by defaut 20 contact lists' do
+      expect(list.contacts.count).to eql 20
+      contact = list.contacts.first
+      expect(contact).to be_a(Hubspot::Contact)
+    end
+
+    it 'add default properties to the contacts returned' do
+      contact = list.contacts.first
+      expect(contact.email).to_not be_empty 
+    end
+
+    expect_count_and_offset do |params| 
+      Hubspot::ContactList.find(1).contacts(params) 
+    end
+  end
+
+  describe '.create' do
+    subject{ Hubspot::ContactList.create!({ name: name }) }
+    
+    context 'with all required parameters' do 
+      cassette 'create_list'
+
+      let(:name) { 'testing list' }
+      it { should be_an_instance_of Hubspot::ContactList }
+      its(:id) { should be_an(Integer) }
+      its(:portal_id) { should be_an(Integer) }
+      its(:dynamic) { should be false }
+
+      context 'adding filters parameters' do
+        cassette 'create_list_with_filters'
+
+        it 'returns a ContactList object with filters set' do 
+          name = 'list with filters'
+          filters_param = [[{ operator: "EQ", value: "@hubspot", property: "twitterhandle", type: "string"}]]
+          list_with_filters = Hubspot::ContactList.create!({ name: name, filters: filters_param })
+          expect(list_with_filters).to be_a(Hubspot::ContactList)
+          expect(list_with_filters.properties['filters']).to_not be_empty
+        end
+      end
+    end
+
+    context 'without all required parameters' do
+      cassette 'fail_to_create_list'
+
+      it 'raises an error' do 
+        expect { Hubspot::ContactList.create!({ name: nil }) }.to raise_error(Hubspot::RequestError)
+      end
+    end
+  end
+
+  describe '.all' do
+    context 'all list types' do
+      cassette 'find_all_lists'
+
+      it 'returns by defaut 20 contact lists' do
+        lists = Hubspot::ContactList.all  
+        expect(lists.count).to eql 20	
+
+        list = lists.first
+        expect(list).to be_a(Hubspot::ContactList) 	
+        expect(list.id).to be_an(Integer)
+  	  end
+
+      expect_count_and_offset { |params| Hubspot::ContactList.all(params) }
+    end
+
+    context 'static lists' do 
+      cassette 'find_all_stastic_lists'
+
+      it 'returns by defaut all the static contact lists' do
+      	lists = Hubspot::ContactList.all(static: true)  
+        expect(lists.count).to be > 20	
+
+        list = lists.first
+        expect(list).to be_a(Hubspot::ContactList) 
+        expect(list.dynamic).to be false
+      end
+    end
+
+    context 'dynamic lists' do
+      cassette 'find_all_dynamic_lists'
+     
+      it 'returns by defaut all the static contact lists' do
+      	lists = Hubspot::ContactList.all(dynamic: true)  
+        expect(lists.count).to be > 20
+
+        list = lists.first
+        expect(list).to be_a(Hubspot::ContactList)
+        expect(list.dynamic).to be true
+      end
+    end
+  end
+  
+  describe '.find' do
+    context 'given an id' do
+      cassette "contact_list_find"
+      subject { Hubspot::ContactList.find(id) }
+
+      context 'when the contact list is found' do
+        let(:id) { 1 }
+        it { should be_an_instance_of Hubspot::ContactList }
+        its(:name) { should == 'twitterers' }
+
+        let(:id) { '1' }
+        it { should be_an_instance_of Hubspot::ContactList }
+      end
+
+      context 'Wrong parameter type given' do
+        it 'raises an error' do 
+          expect { Hubspot::ContactList.find(static_list) }.to raise_error(Hubspot::InvalidParams)
+        end 
+      end
+
+      context 'when the contact list is not found' do
+        it 'raises an error' do 
+          expect { Hubspot::ContactList.find(-1) }.to raise_error(Hubspot::RequestError) 
+        end
+      end
+    end
+
+    context 'given a list of ids' do
+      cassette "contact_list_batch_find"
+
+      it 'find lists of contacts' do
+      	lists = Hubspot::ContactList.find([2,3,4])
+      	list = lists.first
+      	expect(list).to be_a(Hubspot::ContactList)
+      	expect(list.id).to be == 2
+      	expect(lists.second.id).to be == 3
+      	expect(lists.last.id).to be == 4
+      end
+    end
+  end
+
+  describe '#add' do 
+  	cassette "add_contacts_to_lists"
+  
+  	context 'static list' do
+  	  it 'returns true if contacts have been added to the list' do
+        contact = Hubspot::Contact.all(count: 1).first 
+        mock(Hubspot::Connection).post_json("/contacts/v1/lists/:list_id/add", {:params=>{:list_id=>4}, :body=>{:vids=>[contact.vid]}}) { { 'updated' => [contact.vid] } }
+        
+      	expect(static_list.add(contact)).to be true
+  	  end
+
+      it 'returns false if the contact already exists in the list' do 
+        contact = static_list.contacts(count: 1).first
+        expect(static_list.add(contact)).to be false
+      end
+  	end
+    
+    context 'dynamic list' do 
+      it 'raises error if try to add a contact to a dynamic list' do 
+        contact = Hubspot::Contact.new(example_contact_hash) 
+        expect { dynamic_list.add(contact) }.to raise_error(Hubspot::RequestError)
+      end
+    end
+  end
+
+  describe '#remove' do
+  	cassette "remove_contacts_from_lists"
+
+    context 'static list' do
+      it 'returns true if removes all contacts in batch mode' do 
+      	contacts = static_list.contacts(count: 2)
+        expect(static_list.remove([contacts.first, contacts.last])).to be true
+      end
+
+      it 'returns false if the contact cannot be removed' do 
+        contact_not_present_in_list = Hubspot::Contact.new(example_contact_hash) 
+        expect(static_list.remove(contact_not_present_in_list)).to be false
+      end
+    end  
+
+    context 'dynamic list' do 
+      it 'raises error if try to remove a contact from a dynamic list' do 
+      	contact = dynamic_list.contacts(recent: true, count: 1).first
+        expect { dynamic_list.remove(contact) }.to raise_error(Hubspot::RequestError) 
+      end
+    end
+  end
+
+  describe '#update!' do 
+    cassette "contact_list_update"
+
+    let(:contact_list) { Hubspot::ContactList.new(example_contact_list_hash) }
+    let(:params) { { name: "update list name" } }
+    subject { contact_list.update!(params) }
+
+    it { should be_an_instance_of Hubspot::ContactList }
+    its(:name){ should == "update list name" }
+  end
+
+  describe '#destroy!' do 
+    cassette "contact_list_destroy"
+
+    let(:contact_list) { Hubspot::ContactList.create!({ name: "newcontactlist_#{Time.now.to_i}"}) }
+    subject{ contact_list.destroy! }
+    it { should be_true }
+    
+    it "should be destroyed" do
+      subject
+      contact_list.destroyed?.should be_true
+    end
+  end
+
+  describe '#refresh' do
+    cassette "contact_list_refresh" 
+
+    let(:contact_list) { Hubspot::ContactList.new(example_contact_list_hash) }
+    subject { contact_list.refresh }
+
+    it { should be true }
+  end
+end

data/spec/lib/hubspot/contact_properties_spec.rb

@@ -0,0 +1,8 @@
+describe Hubspot::ContactProperties do
+  describe '.add_default_parameters' do
+    subject { Hubspot::ContactProperties.add_default_parameters({}) }
+    context "default parameters" do
+      its([:property]){ should == "email" }
+    end
+  end
+end

data/spec/lib/hubspot/contact_spec.rb

@@ -38,8 +38,8 @@ describe Hubspot::Contact do
     context "with an existing email" do
       cassette "contact_create_existing_email"
       let(:email){ "testingapis@hubspot.com" }
-      it "raises a ContactExistsError" do
-        expect{ subject }.to raise_error Hubspot::ContactExistsError
+      it "raises a RequestError" do
+        expect{ subject }.to raise_error Hubspot::RequestError
       end
     end
     context "with an invalid email" do
@@ -52,89 +52,145 @@ describe Hubspot::Contact do
   end
 
   describe ".find_by_email" do
-    cassette "contact_find_by_email"
-    subject{ Hubspot::Contact.find_by_email(email) }
+    context 'given an uniq email' do
+      cassette "contact_find_by_email"
+      subject{ Hubspot::Contact.find_by_email(email) }
+
+      context "when the contact is found" do
+        let(:email){ "testingapis@hubspot.com" }
+        it{ should be_an_instance_of Hubspot::Contact }
+        its(:vid){ should == 82325 }
+      end
 
-    context "when the contact is found" do
-      let(:email){ "testingapis@hubspot.com" }
-      it{ should be_an_instance_of Hubspot::Contact }
-      its(:vid){ should == 82325 }
+      context "when the contact cannot be found" do
+        it 'raises an error' do 
+          expect { Hubspot::Contact.find_by_email('notacontact@test.com') }.to raise_error(Hubspot::RequestError)
+        end
+      end
     end
 
-    context "when the contact cannot be found" do
-      let(:email){ "notacontact@test.com" }
-      it{ should be_nil }
+    context 'batch mode' do 
+      cassette "contact_find_by_email_batch_mode"
+
+      it 'find lists of contacts' do
+        emails = ['testingapis@hubspot.com', 'testingapisawesomeandstuff@hubspot.com']
+        contacts = Hubspot::Contact.find_by_email(emails)
+        pending
+      end
     end
   end
 
   describe ".find_by_id" do
-    cassette "contact_find_by_id"
-    subject{ Hubspot::Contact.find_by_id(vid) }
+    context 'given an uniq id' do 
+      cassette "contact_find_by_id"
+      subject{ Hubspot::Contact.find_by_id(vid) }
+
+      context "when the contact is found" do
+        let(:vid){ 82325 }
+        it{ should be_an_instance_of Hubspot::Contact }
+        its(:email){ should == "testingapis@hubspot.com" }
+      end
 
-    context "when the contact is found" do
-      let(:vid){ 82325 }
-      it{ should be_an_instance_of Hubspot::Contact }
-      its(:email){ should == "testingapis@hubspot.com" }
+      context "when the contact cannot be found" do
+        it 'raises an error' do
+          expect { Hubspot::Contact.find_by_id(9999999) }.to raise_error(Hubspot::RequestError) 
+        end
+      end
     end
 
-    context "when the contact cannot be found" do
-      let(:vid){ 9999999 }
-      it{ should be_nil }
+    context 'batch mode' do 
+      cassette "contact_find_by_id_batch_mode"
+
+      # NOTE: error currently appends on API endpoint
+      it 'find lists of contacts' do
+        expect { Hubspot::Contact.find_by_id([82325]) }.to raise_error(Hubspot::ApiError)
+      end
     end
   end
 
   describe ".find_by_utk" do
-    cassette "contact_find_by_utk"
-    subject{ Hubspot::Contact.find_by_utk(utk) }
+    context 'given an uniq utk' do 
+      cassette "contact_find_by_utk"
+      subject{ Hubspot::Contact.find_by_utk(utk) }
+
+      context "when the contact is found" do
+        let(:utk){ "f844d2217850188692f2610c717c2e9b" }
+        it{ should be_an_instance_of Hubspot::Contact }
+        its(:utk){ should == "f844d2217850188692f2610c717c2e9b" }
+      end
 
-    context "when the contact is found" do
-      let(:utk){ "f844d2217850188692f2610c717c2e9b" }
-      it{ should be_an_instance_of Hubspot::Contact }
-      its(:utk){ should == "f844d2217850188692f2610c717c2e9b" }
+      context "when the contact cannot be found" do
+        it 'raises an error' do 
+          expect { Hubspot::Contact.find_by_utk("invalid") }.to raise_error(Hubspot::RequestError) 
+        end
+      end
     end
 
-    context "when the contact cannot be found" do
-      let(:utk){ "invalid" }
-      it{ should be_nil }
+    context 'batch mode' do 
+      cassette "contact_find_by_utk_batch_mode"
+
+      it 'find lists of contacts' do
+        utks = ['f844d2217850188692f2610c717c2e9b', 'j94344d22178501692f2610c717c2e9b']
+        expect { Hubspot::Contact.find_by_utk(utks) }.to raise_error(Hubspot::ApiError)
+      end
     end
   end
 
 
   describe '.all' do
-    cassette 'find_all_contacts'
+    context 'all contacts' do 
+      cassette 'find_all_contacts'
 
-    it 'must get the contacts list' do
-      contacts = Hubspot::Contact.all
+      it 'must get the contacts list' do
+        contacts = Hubspot::Contact.all
 
-      expect(contacts.size).to eql 20 # defautl page size
+        expect(contacts.size).to eql 20 # default page size
 
-      first = contacts.first
-      last = contacts.last
+        first = contacts.first
+        last = contacts.last
 
-      expect(first.vid).to eql 154835
-      expect(first['firstname']).to eql 'HubSpot'
-      expect(first['lastname']).to eql 'Test'
+        expect(first).to be_a Hubspot::Contact
+        expect(first.vid).to eql 154835
+        expect(first['firstname']).to eql 'HubSpot'
+        expect(first['lastname']).to eql 'Test'
 
-      expect(last).to be_a Hubspot::Contact
-      expect(last.vid).to eql 196199
-      expect(last['firstname']).to eql 'Eleanor'
-      expect(last['lastname']).to eql 'Morgan'
-    end
+        expect(last).to be_a Hubspot::Contact
+        expect(last.vid).to eql 196199
+        expect(last['firstname']).to eql 'Eleanor'
+        expect(last['lastname']).to eql 'Morgan'
+      end
 
-    it 'must filter only 2 contacts' do
-      contacts = Hubspot::Contact.all(count: 2)
-      expect(contacts.size).to eql 2
+      it 'must filter only 2 contacts' do
+        contacts = Hubspot::Contact.all(count: 2)
+        expect(contacts.size).to eql 2
+      end
+
+      it 'it must offset the contacts' do
+        single_list = Hubspot::Contact.all(count: 1)
+        expect(single_list.size).to eql 1
+        first = single_list.first
+
+        second = Hubspot::Contact.all(count: 1, vidOffset: first.vid).first
+        expect(second.vid).to eql 196181
+        expect(second['firstname']).to eql 'Charles'
+        expect(second['lastname']).to eql 'Gowland'
+      end
     end
 
-    it 'it must offset the contacts' do
-      single_list = Hubspot::Contact.all(count: 1)
-      expect(single_list.size).to eql 1
-      first = single_list.first
+    context 'recent contacts' do 
+      cassette 'find_all_recent_contacts'
 
-      second = Hubspot::Contact.all(count: 1, 'vidOffset': first.vid).first
-      expect(second.vid).to eql 196181
-      expect(second['firstname']).to eql 'Charles'
-      expect(second['lastname']).to eql 'Gowland'
+      it 'must get the contacts list' do
+        contacts = Hubspot::Contact.all(recent: true)
+        expect(contacts.size).to eql 20
+
+        first, last = contacts.first, contacts.last
+        expect(first).to be_a Hubspot::Contact
+        expect(first.vid).to eql 263794
+
+        expect(last).to be_a Hubspot::Contact
+        expect(last.vid).to eql 263776
+      end
     end
   end