hubspot-ruby 0.1.8 → 0.2.0

data/spec/lib/hubspot/contact_spec.rb

@@ -1,76 +1,109 @@
 describe Hubspot::Contact do
   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
+    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
 
-  before{ Hubspot.configure(hapikey: "demo") }
+  before{ Hubspot.configure(hapikey: 'demo') }
 
-  describe "#initialize" do
+  describe '#initialize' do
     subject{ Hubspot::Contact.new(example_contact_hash) }
     it{ should be_an_instance_of Hubspot::Contact }
-    its(["email"]){ should == "testingapis@hubspot.com" }
-    its(["firstname"]){ should == "Clint" }
-    its(["lastname"]){ should == "Eastwood" }
-    its(["phone"]){ should == "555-555-5432" }
-    its(:utk){ should == "1234567890" }
+    its(['email']){ should == 'testingapis@hubspot.com' }
+    its(['firstname']){ should == 'Clint' }
+    its(['lastname']){ should == 'Eastwood' }
+    its(['phone']){ should == '555-555-5432' }
+    its(:utk){ should == '1234567890' }
     its(:vid){ should == 82325 }
   end
 
-  describe ".create!" do
-    cassette "contact_create"
+  describe '.create!' do
+    cassette 'contact_create'
     let(:params){{}}
     subject{ Hubspot::Contact.create!(email, params) }
-    context "with a new email" do
+    context 'with a new email' do
       let(:email){ "newcontact#{Time.now.to_i}@hsgem.com" }
       it{ should be_an_instance_of Hubspot::Contact }
       its(:email){ should match /newcontact.*@hsgem.com/ } # Due to VCR the email may not match exactly
 
-      context "and some params" do
-        cassette "contact_create_with_params"
+      context 'and some params' do
+        cassette 'contact_create_with_params'
         let(:email){ "newcontact_x_#{Time.now.to_i}@hsgem.com" }
-        let(:params){ {firstname: "Hugh", lastname: "Jackman" } }
-        its(["firstname"]){ should == "Hugh"}
-        its(["lastname"]){ should == "Jackman"}
+        let(:params){ {firstname: 'Hugh', lastname: 'Jackman' } }
+        its(['firstname']){ should == 'Hugh'}
+        its(['lastname']){ should == 'Jackman'}
       end
     end
-    context "with an existing email" do
-      cassette "contact_create_existing_email"
-      let(:email){ "testingapis@hubspot.com" }
-      it "raises a RequestError" do
+    context 'with an existing email' do
+      cassette 'contact_create_existing_email'
+      let(:email){ 'testingapis@hubspot.com' }
+      it 'raises a RequestError' do
         expect{ subject }.to raise_error Hubspot::RequestError
       end
     end
-    context "with an invalid email" do
-      cassette "contact_create_invalid_email"
-      let(:email){ "not_an_email" }
-      it "raises a RequestError" do
+    context 'with an invalid email' do
+      cassette 'contact_create_invalid_email'
+      let(:email){ 'not_an_email' }
+      it 'raises a RequestError' do
         expect{ subject }.to raise_error Hubspot::RequestError
       end
     end
   end
 
-  describe ".find_by_email" do
+  describe '.createOrUpdate' do
+    cassette 'contact_create_or_update'
+    let(:params){{}}
+    subject{ Hubspot::Contact.createOrUpdate(email, params) }
+    context 'with a new email' do
+      let(:email){ "newcontact#{Time.now.to_i}@hsgem.com" }
+      it{ should be_an_instance_of Hubspot::Contact }
+      its(:email){ should match /newcontact.*@hsgem.com/ } # Due to VCR the email may not match exactly
+
+      context 'and some params' do
+        cassette 'contact_create_or_update_with_params'
+        let(:email){ "newcontact_x_#{Time.now.to_i}@hsgem.com" }
+        let(:params){ {firstname: 'Hugh', lastname: 'Jackman' } }
+        its(['firstname']){ should == 'Hugh'}
+        its(['lastname']){ should == 'Jackman'}
+      end
+    end
+    context 'with an existing email' do
+      cassette 'contact_create_or_update_existing_email'
+      let(:email){ 'testingapis@hubspot.com' }
+      let(:params){ { firstname: 'Hugh', lastname: 'Jackman, Jr.' } }
+      its(['firstname']){ should == 'Hugh'}
+      its(['lastname']){ should == 'Jackman, Jr.'}
+    end
+    context 'with an invalid email' do
+      cassette 'contact_create_or_update_invalid_email'
+      let(:email){ 'not_an_email' }
+      it 'raises a RequestError' do
+        expect{ subject }.to raise_error Hubspot::RequestError
+      end
+    end
+  end
+
+  describe '.find_by_email' do
     context 'given an uniq email' do
-      cassette "contact_find_by_email"
+      cassette 'contact_find_by_email'
       subject{ Hubspot::Contact.find_by_email(email) }
 
-      context "when the contact is found" do
-        let(:email){ "testingapis@hubspot.com" }
+      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 cannot be found" do
-        it 'raises an error' do 
+      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 'batch mode' do 
-      cassette "contact_find_by_email_batch_mode"
+    context 'batch mode' do
+      cassette 'contact_find_by_email_batch_mode'
 
       it 'find lists of contacts' do
         emails = ['testingapis@hubspot.com', 'testingapisawesomeandstuff@hubspot.com']
@@ -80,54 +113,61 @@ describe Hubspot::Contact do
     end
   end
 
-  describe ".find_by_id" do
-    context 'given an uniq id' do 
-      cassette "contact_find_by_id"
+  describe '.find_by_id' do
+    before do
+      @s = StringIO.new
+      Hubspot::Config.logger = Logger.new(@s)
+    end
+
+    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
+      context 'when the contact is found' do
         let(:vid){ 82325 }
         it{ should be_an_instance_of Hubspot::Contact }
-        its(:email){ should == "testingapis@hubspot.com" }
+        its(:email){ should == 'testingapis@hubspot.com' }
       end
 
-      context "when the contact cannot be found" do
+      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) 
+          expect { Hubspot::Contact.find_by_id(9999999) }.to raise_error(Hubspot::RequestError)
+          expect(@s.string).to include 'Response: 404'
         end
       end
     end
 
-    context 'batch mode' do 
-      cassette "contact_find_by_id_batch_mode"
+    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)
+        expect(@s.string).to include('Response: 200')
       end
     end
   end
 
-  describe ".find_by_utk" do
-    context 'given an uniq utk' do 
-      cassette "contact_find_by_utk"
+  describe '.find_by_utk' do
+    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" }
+      context 'when the contact is found' do
+        let(:utk){ 'f844d2217850188692f2610c717c2e9b' }
         it{ should be_an_instance_of Hubspot::Contact }
-        its(:utk){ should == "f844d2217850188692f2610c717c2e9b" }
+        its(:utk){ should == 'f844d2217850188692f2610c717c2e9b' }
       end
 
-      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) 
+      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 'batch mode' do 
-      cassette "contact_find_by_utk_batch_mode"
+    context 'batch mode' do
+      cassette 'contact_find_by_utk_batch_mode'
 
       it 'find lists of contacts' do
         utks = ['f844d2217850188692f2610c717c2e9b', 'j94344d22178501692f2610c717c2e9b']
@@ -136,9 +176,38 @@ describe Hubspot::Contact do
     end
   end
 
+  describe '.search' do
+    subject { Hubspot::Contact.search(query, options) }
+
+    cassette 'contact_search'
+
+    let(:options) { {} }
+
+    context 'when query returns contacts' do
+      let(:query) { '@hubspot.com' }
+
+      it { expect(subject['has-more']).to eq(true) }
+      it { subject['contacts'].each { |contact| expect(contact).to be_an_instance_of(Hubspot::Contact) } }
+
+      context 'when query finds more than count, but is limited' do
+        let(:options) { { count: 1 } }
+
+        it { expect(subject['has-more']).to eq(true) }
+        it { expect(subject['total'] > 1).to eq(true) }
+      end
+    end
+
+    context 'when the query returns no results' do
+      let(:query) { 'something_that_does_not_exist' }
+
+      it { expect(subject['total']).to eq(0) }
+      it { expect(subject['has-more']).to eq(false) }
+      it { expect(subject['contacts']).to be_empty }
+    end
+  end
 
   describe '.all' do
-    context 'all contacts' do 
+    context 'all contacts' do
       cassette 'find_all_contacts'
 
       it 'must get the contacts list' do
@@ -177,7 +246,7 @@ describe Hubspot::Contact do
       end
     end
 
-    context 'recent contacts' do 
+    context 'recent contacts' do
       cassette 'find_all_recent_contacts'
 
       it 'must get the contacts list' do
@@ -194,45 +263,45 @@ describe Hubspot::Contact do
     end
   end
 
-  describe "#update!" do
-    cassette "contact_update"
+  describe '#update!' do
+    cassette 'contact_update'
     let(:contact){ Hubspot::Contact.new(example_contact_hash) }
-    let(:params){ {firstname: "Steve", lastname: "Cunningham"} }
+    let(:params){ {firstname: 'Steve', lastname: 'Cunningham'} }
     subject{ contact.update!(params) }
 
     it{ should be_an_instance_of Hubspot::Contact }
-    its(["firstname"]){ should ==  "Steve" }
-    its(["lastname"]){ should ==  "Cunningham" }
+    its(['firstname']){ should ==  'Steve' }
+    its(['lastname']){ should ==  'Cunningham' }
 
-    context "when the request is not successful" do
-      let(:contact){ Hubspot::Contact.new({"vid" => "invalid", "properties" => {}})}
-      it "raises an error" do
+    context 'when the request is not successful' do
+      let(:contact){ Hubspot::Contact.new({'vid' => 'invalid', 'properties' => {}})}
+      it 'raises an error' do
         expect{ subject }.to raise_error Hubspot::RequestError
       end
     end
   end
 
-  describe "#destroy!" do
-    cassette "contact_destroy"
+  describe '#destroy!' do
+    cassette 'contact_destroy'
     let(:contact){ Hubspot::Contact.create!("newcontact_y_#{Time.now.to_i}@hsgem.com") }
     subject{ contact.destroy! }
     it { should be_true }
-    it "should be destroyed" do
+    it 'should be destroyed' do
       subject
       contact.destroyed?.should be_true
     end
-    context "when the request is not successful" do
-      let(:contact){ Hubspot::Contact.new({"vid" => "invalid", "properties" => {}})}
-      it "raises an error" do
+    context 'when the request is not successful' do
+      let(:contact){ Hubspot::Contact.new({'vid' => 'invalid', 'properties' => {}})}
+      it 'raises an error' do
         expect{ subject }.to raise_error Hubspot::RequestError
         contact.destroyed?.should be_false
       end
     end
   end
 
-  describe "#destroyed?" do
+  describe '#destroyed?' do
     let(:contact){ Hubspot::Contact.new(example_contact_hash) }
     subject{ contact }
     its(:destroyed?){ should be_false }
   end
-end
+end

data/spec/lib/hubspot/deal_properties_spec.rb

@@ -0,0 +1,254 @@
+describe Hubspot::DealProperties do
+  describe '.add_default_parameters' do
+    subject { Hubspot::DealProperties.add_default_parameters({}) }
+    context 'default parameters' do
+      its([:property]) { should == 'email' }
+    end
+  end
+
+  let(:example_groups) do
+    VCR.use_cassette('deal_groups_example', record: :once) do
+      HTTParty.get('https://api.hubapi.com/deals/v1/groups?hapikey=demo').parsed_response
+    end
+  end
+
+  let(:example_properties) do
+    VCR.use_cassette('deal_properties_example', record: :once) do
+      HTTParty.get('https://api.hubapi.com/deals/v1/properties?hapikey=demo').parsed_response
+    end
+  end
+
+  before { Hubspot.configure(hapikey: 'demo') }
+
+  describe 'Properties' do
+    describe '.all' do
+      context 'with no filter' do
+        cassette 'deal_all_properties'
+
+        it 'should return all properties' do
+          expect(Hubspot::DealProperties.all).to eql(example_properties)
+        end
+      end
+
+      let(:groups) { %w(calltrackinginfo emailinformation) }
+
+      context 'with included groups' do
+        cassette 'deal_properties_in_groups'
+
+        it 'should return properties for the specified group[s]' do
+          response = Hubspot::DealProperties.all({}, { include: groups })
+          response.each { |p| expect(groups.include?(p['groupName'])).to be_true }
+        end
+      end
+
+      context 'with excluded groups' do
+        cassette 'deal_properties_not_in_groups'
+
+        it 'should return properties for the non-specified group[s]' do
+          response = Hubspot::DealProperties.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'                   => 'How much money do you have?',
+      'groupName'                     => 'dealinformation',
+      'type'                          => 'string',
+      'fieldType'                     => 'text',
+      'hidden'                        => false,
+      'options'                       => [{
+                                            'description'  => '',
+                                            'value'        => 'Over $50K',
+                                            'readOnly'     => false,
+                                            'label'        => 'Over $50K',
+                                            'displayOrder' => 0,
+                                            'hidden'       => false,
+                                            'doubleData'   => 0.0
+                                          },
+                                          {
+                                            'description'  => '',
+                                            'value'        => 'Under $50K',
+                                            'readOnly'     => false,
+                                            'label'        => 'Under $50K',
+                                            'displayOrder' => 1,
+                                            'hidden'       => false,
+                                            'doubleData'   => 0.0
+                                          }],
+      'deleted'                       => false,
+      'displayOrder'                  => 0,
+      'formField'                     => true,
+      'readOnlyValue'                 => false,
+      'readOnlyDefinition'            => false,
+      'mutableDefinitionNotDeletable' => false,
+      'calculated'                    => false,
+      'externalOptions'               => false,
+      'displayMode'                   => 'current_value'
+    } }
+
+    describe '.create!' do
+      context 'with no valid parameters' do
+        cassette 'deal_fail_to_create_property'
+
+        it 'should return nil' do
+          expect(Hubspot::DealProperties.create!({})).to be(nil)
+        end
+      end
+
+      context 'with all valid parameters' do
+        cassette 'deal_create_property'
+
+        it 'should return the valid parameters' do
+          response = Hubspot::DealProperties.create!(params)
+          expect(Hubspot::DealProperties.same?(params, response)).to be_true
+        end
+      end
+    end
+
+    describe '.update!' do
+      context 'with no valid parameters' do
+
+        it 'should return nil ' do
+          expect(Hubspot::DealProperties.update!(params['name'], {})).to be(nil)
+        end
+      end
+
+      context 'with mixed parameters' do
+        cassette 'deal_update_property'
+
+        it 'should return the valid parameters' do
+          params['description'] = 'What is their favorite flavor?'
+
+          response = Hubspot::DealProperties.update!(params['name'], params)
+          expect(Hubspot::DealProperties.same?(response, params)).to be_true
+        end
+      end
+    end
+
+    describe '.delete!' do
+      let(:name) { params['name'] }
+
+      context 'with existing property' do
+        cassette 'deal_delete_property'
+
+        it 'should return nil' do
+          expect(Hubspot::DealProperties.delete!(name)).to eq(nil)
+        end
+      end
+
+      context 'with non-existent property' do
+        cassette 'deal_delete_non_property'
+
+        it 'should raise an error' do
+          expect { Hubspot::DealProperties.delete!(name) }.to raise_error(Hubspot::RequestError)
+        end
+      end
+    end
+  end
+
+  describe 'Groups' do
+    describe '.groups' do
+      context 'with no filter' do
+        cassette 'deal_all_groups'
+
+        it 'should return all groups' do
+          expect(Hubspot::DealProperties.groups).to eql(example_groups)
+        end
+      end
+
+      let(:groups) { %w(calltrackinginfo emailinformation) }
+
+      context 'with included groups' do
+        cassette 'deal_groups_included'
+
+        it 'should return the specified groups' do
+          response = Hubspot::DealProperties.groups({}, { include: groups })
+          response.each { |p| expect(groups.include?(p['name'])).to be_true }
+        end
+      end
+
+      context 'with excluded groups' do
+        cassette 'deal_groups_not_excluded'
+
+        it 'should return groups that were not excluded' do
+          response = Hubspot::DealProperties.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::DealProperties.create_group!({})).to be(nil)
+        end
+      end
+
+      context 'with mixed parameters' do
+        cassette 'deal_create_group'
+
+        it 'should return the valid parameters' do
+          response = Hubspot::DealProperties.create_group!(params)
+          expect(Hubspot::DealProperties.same?(response, params)).to be_true
+        end
+      end
+
+      context 'with some valid parameters' do
+        cassette 'deal_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::DealProperties.create_group!(sub_params)
+          expect(Hubspot::DealProperties.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::DealProperties.update_group!(params['name'], {})).to be(nil)
+        end
+      end
+
+      context 'with mixed parameters' do
+        cassette 'deal_update_group'
+
+        it 'should return the valid parameters' do
+          params['displayName'] = 'Test Group OneA'
+
+          response = Hubspot::DealProperties.update_group!(params['name'], params)
+          expect(Hubspot::DealProperties.same?(response, params)).to be_true
+        end
+      end
+
+    end
+
+    describe '.delete_group!' do
+      let(:name) { params['name'] }
+
+      context 'with existing group' do
+        cassette 'deal_delete_group'
+
+        it 'should return nil' do
+          expect(Hubspot::DealProperties.delete_group!(name)).to eq(nil)
+        end
+      end
+
+      context 'with non-existent group' do
+        cassette 'deal_delete_non_group'
+
+        it 'should raise an error' do
+          expect { Hubspot::DealProperties.delete_group!(name) }.to raise_error(Hubspot::RequestError)
+        end
+      end
+    end
+  end
+end