hubspot-ruby 0.1.8 → 0.2.0

data/spec/lib/hubspot/config_spec.rb

@@ -50,4 +50,4 @@ describe Hubspot::Config do
       end
     end
   end
-end
+end

data/spec/lib/hubspot/connection_spec.rb

@@ -1,42 +1,48 @@
 describe Hubspot::Connection do
   before(:each) do
-    @url = 'http://localhost:3000'
-    @http_reponse = mock('http_response')
+    @url           = 'http://localhost:3000'
+    @http_response = mock('http_response')
   end
 
-  describe '.get_json' do 
-  	it 'delegates url format to Hubspot::Utils, call HTTParty get and returns response' do 
-  	  @http_reponse.success? { true }
-      @http_reponse.parsed_response { {} }  
-      
-  	  mock(Hubspot::Connection).generate_url(@url, {}) { @url }
-  	  mock(Hubspot::Connection).get(@url, format: :json) { @http_reponse }
+  describe '.get_json' do
+    it 'delegates url format to Hubspot::Utils, call HTTParty get and returns response' do
+      @http_response.success? { true }
+      @http_response.parsed_response { {} }
+      @http_response.code { 200 }
+      @http_response.body { 'mocked response' }
+
+      mock(Hubspot::Connection).generate_url(@url, {}) { @url }
+      mock(Hubspot::Connection).get(@url, format: :json) { @http_response }
       Hubspot::Connection.get_json(@url, {})
-  	end
+    end
   end
 
-  describe '.post_json' do 
-  	it 'delegates url format to Hubspot::Utils, call HTTParty post and returns response' do 
-  	  @http_reponse.success? { true }
-      @http_reponse.parsed_response { {} }  
-      
-  	  mock(Hubspot::Connection).generate_url(@url, {}) { @url }
-  	  mock(Hubspot::Connection).post(@url, body: "{}", headers: {"Content-Type"=>"application/json"}, format: :json) { @http_reponse }
+  describe '.post_json' do
+    it 'delegates url format to Hubspot::Utils, call HTTParty post and returns response' do
+      @http_response.success? { true }
+      @http_response.parsed_response { {} }
+      @http_response.code { 200 }
+      @http_response.body { 'mocked response' }
+
+      mock(Hubspot::Connection).generate_url(@url, {}) { @url }
+      mock(Hubspot::Connection).post(@url, body: "{}", headers: {"Content-Type"=>"application/json"}, format: :json) { @http_response }
       Hubspot::Connection.post_json(@url, params: {}, body: {})
-  	end
+    end
   end
 
-  describe '.delete_json' do 
-  	it 'delegates url format to Hubspot::Utils, call HTTParty delete and returns response' do 
-  	  @http_reponse.success? { true }
+  describe '.delete_json' do
+    it 'delegates url format to Hubspot::Utils, call HTTParty delete and returns response' do
+      @http_response.success? { true }
+      @http_response.code { 200 }
+      @http_response.body { 'mocked response' }
 
-  	  mock(Hubspot::Connection).generate_url(@url, {}) { @url }
-  	  mock(Hubspot::Connection).delete(@url, format: :json) { @http_reponse }
+      mock(Hubspot::Connection).generate_url(@url, {}) { @url }
+      mock(Hubspot::Connection).delete(@url, format: :json) { @http_response }
       Hubspot::Connection.delete_json(@url, {})
-  	end
+    end
   end
 
-  context 'private methods' do 
+  context 'private methods' do
     describe ".generate_url" do
       let(:path){ "/test/:email/profile" }
       let(:params){{email: "test"}}
@@ -102,11 +108,11 @@ describe Hubspot::Connection do
         it{ should == "https://cool.com/test/test/profile"}
       end
 
-      context "passing Array as parameters for batch mode, key is prefixed with batch_" do 
+      context "passing Array as parameters for batch mode, key is prefixed with batch_" do
         let(:path) { Hubspot::ContactList::LIST_BATCH_PATH }
         let(:params) { { batch_list_id: [1,2,3] } }
         it{ should == "https://api.hubapi.com/contacts/v1/lists/batch?listId=1&listId=2&listId=3&hapikey=demo" }
       end
     end
   end
-end
+end

data/spec/lib/hubspot/contact_list_spec.rb

@@ -13,17 +13,17 @@ describe Hubspot::ContactList 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(:dynamic) { should be true }
     its(:properties) { should be_a(Hash) }
-  end	
+  end
 
   before { Hubspot.configure(hapikey: "demo") }
 
@@ -40,18 +40,18 @@ describe Hubspot::ContactList do
 
     it 'add default properties to the contacts returned' do
       contact = list.contacts.first
-      expect(contact.email).to_not be_empty 
+      expect(contact.email).to_not be_empty
     end
 
-    expect_count_and_offset do |params| 
-      Hubspot::ContactList.find(1).contacts(params) 
+    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 
+
+    context 'with all required parameters' do
       cassette 'create_list'
 
       let(:name) { 'testing list' }
@@ -63,7 +63,7 @@ describe Hubspot::ContactList do
       context 'adding filters parameters' do
         cassette 'create_list_with_filters'
 
-        it 'returns a ContactList object with filters set' do 
+        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 })
@@ -76,7 +76,7 @@ describe Hubspot::ContactList do
     context 'without all required parameters' do
       cassette 'fail_to_create_list'
 
-      it 'raises an error' do 
+      it 'raises an error' do
         expect { Hubspot::ContactList.create!({ name: nil }) }.to raise_error(Hubspot::RequestError)
       end
     end
@@ -87,35 +87,35 @@ describe Hubspot::ContactList do
       cassette 'find_all_lists'
 
       it 'returns by defaut 20 contact lists' do
-        lists = Hubspot::ContactList.all  
-        expect(lists.count).to eql 20	
+        lists = Hubspot::ContactList.all
+        expect(lists.count).to eql 20
 
         list = lists.first
-        expect(list).to be_a(Hubspot::ContactList) 	
+        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 
+    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	
+      	lists = Hubspot::ContactList.all(static: true)
+        expect(lists.count).to be > 20
 
         list = lists.first
-        expect(list).to be_a(Hubspot::ContactList) 
+        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)  
+      	lists = Hubspot::ContactList.all(dynamic: true)
         expect(lists.count).to be > 20
 
         list = lists.first
@@ -124,7 +124,7 @@ describe Hubspot::ContactList do
       end
     end
   end
-  
+
   describe '.find' do
     context 'given an id' do
       cassette "contact_list_find"
@@ -140,14 +140,14 @@ describe Hubspot::ContactList do
       end
 
       context 'Wrong parameter type given' do
-        it 'raises an error' do 
+        it 'raises an error' do
           expect { Hubspot::ContactList.find(static_list) }.to raise_error(Hubspot::InvalidParams)
-        end 
+        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) 
+        it 'raises an error' do
+          expect { Hubspot::ContactList.find(-1) }.to raise_error(Hubspot::RequestError)
         end
       end
     end
@@ -156,65 +156,65 @@ describe Hubspot::ContactList 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
+        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 
+  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 
+        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) 
+    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"
+    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)
+      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) 
+      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  
+    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) 
+    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 
+  describe '#update!' do
     cassette "contact_list_update"
 
     let(:contact_list) { Hubspot::ContactList.new(example_contact_list_hash) }
@@ -225,13 +225,13 @@ describe Hubspot::ContactList do
     its(:name){ should == "update list name" }
   end
 
-  describe '#destroy!' do 
+  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
@@ -239,11 +239,11 @@ describe Hubspot::ContactList do
   end
 
   describe '#refresh' do
-    cassette "contact_list_refresh" 
+    cassette "contact_list_refresh"
 
     let(:contact_list) { Hubspot::ContactList.new(example_contact_list_hash) }
     subject { contact_list.refresh }
 
     it { should be true }
   end
-end
+end

data/spec/lib/hubspot/contact_properties_spec.rb

@@ -1,8 +1,239 @@
 describe Hubspot::ContactProperties do
   describe '.add_default_parameters' do
     subject { Hubspot::ContactProperties.add_default_parameters({}) }
-    context "default parameters" do
-      its([:property]){ should == "email" }
+    context 'default parameters' do
+      its([:property]) { should == 'email' }
     end
   end
-end
+
+  let(:example_groups) do
+    VCR.use_cassette('groups_example', record: :once) do
+      HTTParty.get('https://api.hubapi.com/contacts/v2/groups?hapikey=demo').parsed_response
+    end
+  end
+
+  let(:example_properties) do
+    VCR.use_cassette('properties_example', record: :once) do
+      HTTParty.get('https://api.hubapi.com/contacts/v2/properties?hapikey=demo').parsed_response
+    end
+  end
+
+  before { Hubspot.configure(hapikey: 'demo') }
+
+  describe 'Properties' do
+    describe '.all' do
+      context 'with no filter' do
+        cassette 'all_properties'
+
+        it 'should return all properties' do
+          expect(Hubspot::ContactProperties.all).to eql(example_properties)
+        end
+      end
+
+      let(:groups) { %w(calltrackinginfo emailinformation) }
+
+      context 'with included groups' do
+        cassette 'properties_in_groups'
+
+        it 'should return properties for the specified group[s]' do
+          response = Hubspot::ContactProperties.all({}, { include: groups })
+          response.each { |p| expect(groups.include?(p['groupName'])).to be_true }
+        end
+      end
+
+      context 'with excluded groups' do
+        cassette 'properties_not_in_groups'
+
+        it 'should return properties for the non-specified group[s]' do
+          response = Hubspot::ContactProperties.all({}, { exclude: groups })
+          response.each { |p| expect(groups.include?(p['groupName'])).to be_false }
+        end
+      end
+    end
+
+    let(:params) { {
+      'name'                          => 'my_new_property',
+      'label'                         => 'This is my new property',
+      'description'                   => 'What kind of x would you like?',
+      'groupName'                     => 'contactinformation',
+      'type'                          => 'string',
+      'fieldType'                     => 'text',
+      'hidden'                        => false,
+      'options'                       => [],
+      'deleted'                       => false,
+      'displayOrder'                  => 0,
+      'formField'                     => true,
+      'readOnlyValue'                 => false,
+      'readOnlyDefinition'            => false,
+      'mutableDefinitionNotDeletable' => false,
+      'calculated'                    => false,
+      'externalOptions'               => false,
+      'displayMode'                   => 'current_value'
+    } }
+    let(:valid_params) { params.select { |k, _| Hubspot::ContactProperties::PROPERTY_SPECS[:field_names].include?(k) } }
+
+    describe '.create!' do
+      context 'with no valid parameters' do
+        cassette 'fail_to_create_property'
+
+        it 'should return nil' do
+          expect(Hubspot::ContactProperties.create!({})).to be(nil)
+        end
+      end
+
+      context 'with all valid parameters' do
+        cassette 'create_property'
+
+        it 'should return the valid parameters' do
+          response = Hubspot::ContactProperties.create!(params)
+          valid_params.each { |k, v| expect(response[k]).to eq(v) }
+        end
+      end
+    end
+
+    describe '.update!' do
+      context 'with no valid parameters' do
+
+        it 'should return nil ' do
+          expect(Hubspot::ContactProperties.update!(params['name'], {})).to be(nil)
+        end
+      end
+
+      context 'with mixed parameters' do
+        cassette 'update_property'
+
+        it 'should return the valid parameters' do
+          params['description']       = 'What is their favorite flavor?'
+          valid_params['description'] = params['description']
+
+          response = Hubspot::ContactProperties.update!(params['name'], params)
+          valid_params.each { |k, v| expect(response[k]).to eq(v) }
+        end
+      end
+    end
+
+    describe '.delete!' do
+      let(:name) { params['name'] }
+
+      context 'with existing property' do
+        cassette 'delete_property'
+
+        it 'should return nil' do
+          expect(Hubspot::ContactProperties.delete!(name)).to eq(nil)
+        end
+      end
+
+      context 'with non-existent property' do
+        cassette 'delete_non_property'
+
+        it 'should raise an error' do
+          expect { Hubspot::ContactProperties.delete!(name) }.to raise_error(Hubspot::RequestError)
+        end
+      end
+    end
+  end
+
+  describe 'Groups' do
+    describe '.groups' do
+      context 'with no filter' do
+        cassette 'all_groups'
+
+        it 'should return all groups' do
+          expect(Hubspot::ContactProperties.groups).to eql(example_groups)
+        end
+      end
+
+      let(:groups) { %w(calltrackinginfo emailinformation) }
+
+      context 'with included groups' do
+        cassette 'groups_included'
+
+        it 'should return the specified groups' do
+          response = Hubspot::ContactProperties.groups({}, { include: groups })
+          response.each { |p| expect(groups.include?(p['name'])).to be_true }
+        end
+      end
+
+      context 'with excluded groups' do
+        cassette 'groups_not_excluded'
+
+        it 'should return groups that were not excluded' do
+          response = Hubspot::ContactProperties.groups({}, { exclude: groups })
+          response.each { |p| expect(groups.include?(p['name'])).to be_false }
+        end
+      end
+    end
+
+    let(:params) { { 'name' => 'ff_group1', 'displayName' => 'Test Group One', 'displayOrder' => 100, 'badParam' => 99 } }
+
+    describe '.create_group!' do
+      context 'with no valid parameters' do
+        it 'should return nil' do
+          expect(Hubspot::ContactProperties.create_group!({})).to be(nil)
+        end
+      end
+
+      context 'with mixed parameters' do
+        cassette 'create_group'
+
+        it 'should return the valid parameters' do
+          response = Hubspot::ContactProperties.create_group!(params)
+          expect(Hubspot::ContactProperties.same?(response, params)).to be_true
+        end
+      end
+
+      context 'with some valid parameters' do
+        cassette 'create_group_some_params'
+
+        let(:sub_params) { params.select { |k, _| k != 'displayName' } }
+
+        it 'should return the valid parameters' do
+          params['name'] = 'ff_group234'
+          response       = Hubspot::ContactProperties.create_group!(sub_params)
+          expect(Hubspot::ContactProperties.same?(response, sub_params)).to be_true
+        end
+      end
+    end
+
+    describe '.update_group!' do
+      context 'with no valid parameters' do
+
+        it 'should return nil ' do
+          expect(Hubspot::ContactProperties.update_group!(params['name'], {})).to be(nil)
+        end
+      end
+
+      context 'with mixed parameters' do
+        cassette 'update_group'
+
+        it 'should return the valid parameters' do
+          params['displayName'] = 'Test Group OneA'
+
+          response = Hubspot::ContactProperties.update_group!(params['name'], params)
+          expect(Hubspot::ContactProperties.same?(response, params)).to be_true
+        end
+      end
+
+    end
+
+    describe '.delete_group!' do
+      let(:name) { params['name'] }
+
+      context 'with existing group' do
+        cassette 'delete_group'
+
+        it 'should return nil' do
+          expect(Hubspot::ContactProperties.delete_group!(name)).to eq(nil)
+        end
+      end
+
+      context 'with non-existent group' do
+        cassette 'delete_non_group'
+
+        it 'should raise an error' do
+          expect { Hubspot::ContactProperties.delete_group!(name) }.to raise_error(Hubspot::RequestError)
+        end
+      end
+    end
+  end
+end