hubspot-api-ruby 0.8.0

data/spec/lib/hubspot/contact_spec.rb

@@ -0,0 +1,223 @@
+RSpec.describe Hubspot::Contact do
+
+  before{ Hubspot.configure(hapikey: 'demo') }
+
+  it_behaves_like "a saveable resource", :contact do
+    def set_property(contact)
+      contact.firstname = "foobar"
+    end
+  end
+
+  it_behaves_like "an updateable resource", :contact do
+    let(:changed_properties) { { firstname: "foobar" } }
+    let(:overlapping_properties) { { firstname: "asdf", lastname: "qwer" } }
+  end
+
+  describe '.find' do
+    context 'with a valid ID' do
+      cassette
+
+      let(:company) { create :company }
+      let(:contact) { create :contact, associatedcompanyid: company.id }
+      subject { described_class.find contact.id }
+
+      it 'finds the contact' do
+        expect(subject).to be_a(described_class)
+        expect(subject.id).to eq(contact.id)
+      end
+    end
+
+    context 'with an invalid ID' do
+      cassette
+
+      subject { described_class.find 0 }
+
+      it 'raises an error' do
+        expect {
+          subject
+        }.to raise_error(Hubspot::RequestError, /contact does not exist/)
+      end
+    end
+  end
+
+  describe '.create' do
+    context 'without properties' do
+      cassette
+
+      let(:email) { Faker::Internet.safe_email("#{(0..3).map { (65 + rand(26)).chr }.join}#{Time.new.to_i.to_s[-5..-1]}") }
+      subject { described_class.create email }
+
+      it 'creates a new contact' do
+        expect(subject).to be_a(described_class)
+        expect(subject.id).not_to be_nil
+      end
+    end
+
+    context 'with properties' do
+      cassette
+
+      let(:email) { Faker::Internet.safe_email("#{(0..3).map { (65 + rand(26)).chr }.join}#{Time.new.to_i.to_s[-5..-1]}") }
+      let(:firstname) { "Allison" }
+      let(:properties) { { firstname: firstname } }
+
+      subject { described_class.create email, properties }
+
+      it 'creates a new contact' do
+        expect(subject).to be_a(described_class)
+        expect(subject.id).not_to be_nil
+      end
+
+      it 'has the property set' do
+        expect(subject.firstname).to eq(firstname)
+      end
+
+      it 'is persisted' do
+        expect(subject).to be_persisted
+      end
+    end
+
+    context 'with an existing email address' do
+      cassette
+
+      let(:contact) { create :contact }
+      let(:email) { contact.email }
+
+      subject { described_class.create email }
+
+      it 'raises an error' do
+        expect {
+          subject
+        }.to raise_error(Hubspot::RequestError)
+      end
+    end
+
+    context 'with an invalid email address' do
+      cassette
+
+      let(:email) { 'an_invalid_email' }
+
+      subject { described_class.create email }
+
+      it 'raises an error' do
+        expect {
+          subject
+        }.to raise_error(Hubspot::RequestError)
+      end
+    end
+  end
+
+  describe '.find_by_email' do
+    cassette
+
+    let(:contact) { create :contact }
+
+    subject { described_class.find_by_email contact.email }
+
+    it 'finds the contact' do
+      expect(subject).to be_a(described_class)
+      expect(subject.id).to eq(contact.id)
+    end
+
+    it 'is persisted' do
+      expect(subject).to be_persisted
+    end
+  end
+
+  describe '.find_by_user_token' do
+    cassette
+
+    let(:contact) { create :contact }
+    subject { described_class.find_by_user_token contact.utk }
+
+    it 'finds the contact' do
+      skip 'need a contact with a user token'
+      expect(subject).to be_a(described_class)
+      expect(subject.id).to eq(contact.id)
+    end
+  end
+
+  describe '.search' do
+    cassette
+
+    context 'when the query returns contacts' do
+      subject { described_class.search 'com' }
+
+      it 'has contacts' do
+        expect(subject).not_to be_empty
+        expect(subject.first).to be_a(described_class)
+      end
+    end
+
+    context 'when the query returns no contacts' do
+      subject { described_class.search '123xyz' }
+
+      it 'has no contacts' do
+        expect(subject).to be_empty
+      end
+
+      it 'does not have more' do
+        expect(subject.more?).to be_falsey
+      end
+
+      it 'does not have a next page' do
+        expect(subject.next_page?).to be_falsey
+      end
+    end
+  end
+
+  describe '.merge' do
+    context 'with valid contact ids' do
+      cassette
+
+      let!(:contact1) { create :contact }
+      let!(:contact2) { create :contact }
+
+      subject { described_class.merge contact1.id, contact2.id }
+
+      it 'succeeds' do
+        expect(subject).to be_truthy
+      end
+    end
+
+    context 'with invalid contact ids' do
+      cassette
+
+      subject { described_class.merge 1, 2 }
+
+      it 'raises an error' do
+        expect {
+          subject
+        }.to raise_error(Hubspot::RequestError)
+      end
+    end
+  end
+
+  describe '#merge' do
+    context 'with a valid contact' do
+      cassette
+
+      let!(:contact1) { create :contact }
+      let!(:contact2) { create :contact }
+
+      subject { contact1.merge(contact2) }
+
+      it 'succeeds' do
+        expect(subject).to be_truthy
+      end
+    end
+
+    context 'with an invalid contact' do
+      cassette
+
+      let!(:contact1) { create :contact }
+
+      subject { contact1.merge(1) }
+
+      it 'raises an error' do
+        expect {
+          subject
+        }.to raise_error(Hubspot::RequestError)
+      end
+    end
+  end
+end

data/spec/lib/hubspot/deal_pipeline_spec.rb

@@ -0,0 +1,85 @@
+RSpec.describe Hubspot::DealPipeline do
+  before do
+    Hubspot.configure hapikey: 'demo'
+  end
+
+  describe ".find" do
+    it "retrieves a record by id" do
+      VCR.use_cassette("find_deal_pipeline") do
+        deal_pipeline = Hubspot::DealPipeline.create!(label: "New Pipeline")
+        id = deal_pipeline.pipeline_id
+
+        result = Hubspot::DealPipeline.find(deal_pipeline.pipeline_id)
+
+        assert_requested :get, hubspot_api_url("/deals/v1/pipelines/#{id}")
+        expect(result).to be_a(Hubspot::DealPipeline)
+
+        deal_pipeline.destroy!
+      end
+    end
+  end
+
+  describe ".all" do
+    it "returns a list" do
+      VCR.use_cassette("all_deal_pipelines") do
+        deal_pipeline = Hubspot::DealPipeline.create!(label: "New Pipeline")
+
+        results = Hubspot::DealPipeline.all
+
+        assert_requested :get, hubspot_api_url("/deals/v1/pipelines")
+        expect(results).to be_kind_of(Array)
+        expect(results.first).to be_a(Hubspot::DealPipeline)
+
+        deal_pipeline.destroy!
+      end
+    end
+  end
+
+  describe ".create!" do
+    it "creates a new record" do
+      VCR.use_cassette("create_deal_pipeline") do
+        result = Hubspot::DealPipeline.create!(label: "New Pipeline")
+
+        assert_requested :post, hubspot_api_url("/deals/v1/pipelines")
+        expect(result).to be_a(Hubspot::DealPipeline)
+
+        result.destroy!
+      end
+    end
+  end
+
+  describe "#destroy!" do
+    it "deletes the record" do
+      VCR.use_cassette("delete_deal_pipeline") do
+        deal_pipeline = Hubspot::DealPipeline.create!(label: "New Pipeline")
+        id = deal_pipeline.pipeline_id
+
+        result = deal_pipeline.destroy!
+
+        assert_requested :delete, hubspot_api_url("/deals/v1/pipelines/#{id}")
+        expect(result).to be_a(HTTParty::Response)
+      end
+    end
+  end
+
+  describe "#[]" do
+    it "returns the stage at the specified index" do
+      data = {
+        "stages" => [
+          {"active": true, "label": "New Lead"},
+          {"active": true, "label": "Proposal"},
+        ],
+      }
+
+      deal_pipeline = Hubspot::DealPipeline.new(data)
+
+      result = deal_pipeline[0]
+
+      expect(result).to eq(data["stages"][0])
+    end
+  end
+
+  def hubspot_api_url(path)
+    URI.join(Hubspot::Config.base_url, path, "?hapikey=demo")
+  end
+end

data/spec/lib/hubspot/deal_properties_spec.rb

@@ -0,0 +1,262 @@
+describe Hubspot::DealProperties do
+  describe '.add_default_parameters' do
+    let(:opts) { {} }
+    subject { Hubspot::DealProperties.add_default_parameters(opts) }
+    context 'default parameters' do
+      context 'without property parameter' do
+        its([:property]) { should == 'email' }
+      end
+
+      context 'with property parameter' do
+        let(:opts) { {property: 'dealname' } }
+        its([:property]) { should == 'dealname'}
+      end
+    end
+  end
+
+  let(:example_groups) do
+    VCR.use_cassette('deal_groups_example') 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') 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