hubspot-api-ruby 0.21.0 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3d7600de11889f3e5dfe562ccec90bb6c1edd20b866c972e35ae11c1ce3bacf
-  data.tar.gz: 65698aa080bdb71c8c0e05436cd36af6981b3f1d8c79de9e7e95c32888b9e252
+  metadata.gz: 660784a9172dc42af4abe066bad9f2a5297fe8d7b4fe3e6f9fed5617d583fcaa
+  data.tar.gz: 1d6d7072a0c0ce71b9dcdba3155572be2f9e5b12b6e3a3fd0bb002acad0836a1
 SHA512:
-  metadata.gz: 49597d6095f36055416f3610e5e7b1059a6f08829b9e3a9c248b753f2ad133d31087edcb6c86f5100cd66bb939d33b8ea1c9fab321012a8a9c5394b3c7ec9368
-  data.tar.gz: 6ebf057a56f6d2d643c2582d96f7f8fd8002cfe7088a72d0bec190dc62e06961470f04b18121d87f2d0b42abe3f2bda6821a63294590e1d536be412b0cd6c472
+  metadata.gz: bf383fe3b8dc2cad6e64774874b90163c28cce2c8007bf7dfc850169ae31eda46615416716b9f4299decaa49b5d4309e3d52f3f60498085e3fb073db9376806f
+  data.tar.gz: 3870a04cb0535f399f8e29b1aeb2d95b65aa58cdee7c00b36ec502589099445de94c7a70d88725f0c3d9b10a934ab6ec95587d352d2af4b05a5dcbe32932b9cd

data/hubspot-api-ruby.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "hubspot-api-ruby"
-  s.version = "0.21.0"
+  s.version = "0.22.1"
   s.require_paths = ["lib"]
   s.authors = ["Jonathan"]
   s.email = ["jonathan@hoggo.com"]
@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
     "changelog_uri" => "https://github.com/captaincontrat/hubspot-api-ruby/blob/master/History.md"
   }
 
-  s.required_ruby_version = ">= 3.1"
+  s.required_ruby_version = ">= 3.2"
 
   # Add runtime dependencies here
   s.add_runtime_dependency "activesupport", ">= 4.2.2"
@@ -37,4 +37,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency("byebug")
   s.add_development_dependency("faker")
   s.add_development_dependency("factory_bot")
+  s.add_development_dependency("irb")
 end

data/lib/hubspot/contact.rb

@@ -1,8 +1,8 @@
 class Hubspot::Contact < Hubspot::Resource
-  self.id_field = "vid"
-  self.update_method = "post"
+  self.id_field = 'vid'
+  self.update_method = 'post'
 
-  ALL_PATH                = '/contacts/v1/lists/all/contacts/all'
+  ALL_PATH                = '/crm/v3/objects/contacts'
   CREATE_PATH             = '/contacts/v1/contact'
   CREATE_OR_UPDATE_PATH   = '/contacts/v1/contact/createOrUpdate/email/:email'
   DELETE_PATH             = '/contacts/v1/contact/vid/:id'
@@ -16,14 +16,16 @@ class Hubspot::Contact < Hubspot::Resource
 
   class << self
     def all(opts = {})
-      Hubspot::PagedCollection.new(opts) do |options, offset, limit|
-        response = Hubspot::Connection.get_json(
-          ALL_PATH,
-          options.merge("count" => limit, "vidOffset" => offset)
-          )
+      Hubspot::PagedCollection.new(opts) do |options, after, limit|
+        request_options = options.merge(limit:)
+        request_options[:after] = after if after.present?
+        response = Hubspot::Connection.get_json(ALL_PATH, request_options)
 
-        contacts = response["contacts"].map { |result| from_result(result) }
-        [contacts, response["vid-offset"], response["has-more"]]
+        contacts = response['results'].map do |result| 
+          from_result result, id_field: Hubspot::Resource.id_field 
+        end
+        after = response.dig('paging', 'next', 'after')
+        [contacts, after, after.present?]
       end
     end
 
@@ -31,7 +33,7 @@ class Hubspot::Contact < Hubspot::Resource
       response = Hubspot::Connection.get_json(FIND_PATH, id: vid)
       from_result(response)
     end
-    
+
     def find_by_email(email)
       response = Hubspot::Connection.get_json(FIND_BY_EMAIL_PATH, email: email)
       from_result(response)
@@ -41,17 +43,17 @@ class Hubspot::Contact < Hubspot::Resource
       response = Hubspot::Connection.get_json(FIND_BY_USER_TOKEN_PATH, token: token)
       from_result(response)
     end
-    alias_method :find_by_utk, :find_by_user_token
+    alias find_by_utk find_by_user_token
 
     def create(email, properties = {})
-      super(properties.merge("email" => email))
+      super(properties.merge('email' => email))
     end
 
     def create_or_update(email, properties = {})
       request = {
-        properties: Hubspot::Utils.hash_to_properties(properties.stringify_keys, key_name: "property")
+        properties: Hubspot::Utils.hash_to_properties(properties.stringify_keys, key_name: 'property')
       }
-      response = Hubspot::Connection.post_json(CREATE_OR_UPDATE_PATH, params: {email: email}, body: request)
+      response = Hubspot::Connection.post_json(CREATE_OR_UPDATE_PATH, params: { email: email }, body: request)
       from_result(response)
     end
 
@@ -60,10 +62,10 @@ class Hubspot::Contact < Hubspot::Resource
         response = Hubspot::Connection.get_json(
           SEARCH_PATH,
           options.merge(q: query, offset: offset, count: limit)
-          )
+        )
 
-        contacts = response["contacts"].map { |result| from_result(result) }
-        [contacts, response["offset"], response["has-more"]]
+        contacts = response['contacts'].map { |result| from_result(result) }
+        [contacts, response['offset'], response['has-more']]
       end
     end
 
@@ -71,23 +73,23 @@ class Hubspot::Contact < Hubspot::Resource
       Hubspot::Connection.post_json(
         MERGE_PATH,
         params: { id: primary.to_i, no_parse: true },
-        body: { "vidToMerge" => secondary.to_i }
-        )
+        body: { 'vidToMerge' => secondary.to_i }
+      )
 
       true
     end
-    
+
     def batch_update(contacts, opts = {})
       request = contacts.map do |contact|
         # Use the specified options or update with the changes
         changes = opts.empty? ? contact.changes : opts
 
-        unless changes.empty?
-          {
-            "vid" => contact.id,
-            "properties" => changes.map { |k, v| { "property" => k, "value" => v } }
-          }
-        end
+        next if changes.empty?
+
+        {
+          'vid' => contact.id,
+          'properties' => changes.map { |k, v| { 'property' => k, 'value' => v } }
+        }
       end
 
       # Remove any objects without changes and return if there is nothing to update

data/lib/hubspot/contact_list.rb

@@ -3,106 +3,105 @@ module Hubspot
   # HubSpot Contact lists API
   #
   class ContactList
-    LISTS_PATH           = '/contacts/v1/lists'
-    LIST_PATH            = '/contacts/v1/lists/:list_id'
-    LIST_BATCH_PATH      = LISTS_PATH + '/batch'
-    CONTACTS_PATH        = LIST_PATH + '/contacts/all'
-    RECENT_CONTACTS_PATH = LIST_PATH + '/contacts/recent'
-    ADD_CONTACT_PATH     = LIST_PATH + '/add'
-    REMOVE_CONTACT_PATH  = LIST_PATH + '/remove'
+    LISTS_PATH             = '/crm/v3/lists'
+    LIST_PATH              = '/crm/v3/lists/:list_id'
+    SEARCH_PATH            = LISTS_PATH + '/search'
+    CONTACTS_PATH          = LIST_PATH + '/memberships'
+    RECENT_CONTACTS_PATH   = LIST_PATH + '/memberships/join-order'
+    ADD_CONTACTS_PATH      = LIST_PATH + '/memberships/add'
+    REMOVE_CONTACTS_PATH   = LIST_PATH + '/memberships/remove'
+    UPDATE_NAME_PATH       = LIST_PATH + '/update-list-name'
+    CONTACT_OBJECT_TYPE_ID = '0-1'
+    MANUAL_PROCESSING_TYPE = 'MANUAL'
 
     class << self
-      # {http://developers.hubspot.com/docs/methods/lists/create_list}
-      def create!(opts={})
-        dynamic = opts.delete(:dynamic) { false }
-        portal_id = opts.delete(:portal_id) { Hubspot::Config.portal_id }
+      # {https://developers.hubspot.com/docs/api-reference/legacy/crm/lists/guide#create-a-list}
+      def create!(opts = {})
+        object_type_id = opts.delete(:object_type_id) { CONTACT_OBJECT_TYPE_ID }
+        processing_type = opts.delete(:processing_type) { MANUAL_PROCESSING_TYPE }
+        body = opts.merge(objectTypeId: object_type_id, processingType: processing_type)
 
-        response = Hubspot::Connection.post_json(LISTS_PATH, params: {}, body: opts.merge({ dynamic: dynamic, portal_id: portal_id}) )
+        response = Hubspot::Connection.post_json(LISTS_PATH, params: {}, body:)
         new(response)
       end
 
-      # {http://developers.hubspot.com/docs/methods/lists/get_lists}
-      # {http://developers.hubspot.com/docs/methods/lists/get_static_lists}
-      # {http://developers.hubspot.com/docs/methods/lists/get_dynamic_lists}
-      def all(opts={})
-        static = opts.delete(:static) { false }
-        dynamic = opts.delete(:dynamic) { false }
-
-        # NOTE: As opposed of what the documentation says, getting the static or dynamic lists returns all the lists, not only 20 lists
-        path = LISTS_PATH + (static ? '/static' : dynamic ? '/dynamic' : '')
-        response = Hubspot::Connection.get_json(path, opts)
-        response['lists'].map { |l| new(l) }
+      # {https://developers.hubspot.com/docs/api-reference/legacy/crm/lists/guide#retrieve-by-searching-list-details}
+      def all(opts = {})
+        body = opts.delete(:body) || { query: '' }
+
+        Hubspot::PagedCollection.new(opts) do |options, after, limit|
+          response = Hubspot::Connection.post_json(
+            SEARCH_PATH,
+            options.merge('limit' => limit, 'offset' => after, 'offset_param' => 'after', params: {}, body:)
+          )
+
+          lists = response['lists'].map { |list| new(list) }
+          after = response.dig('paging', 'next', 'after')
+          [lists, after, after.present?]
+        end
       end
 
-      # {http://developers.hubspot.com/docs/methods/lists/get_list}
-      # {http://developers.hubspot.com/docs/methods/lists/get_batch_lists}
+      # {https://developers.hubspot.com/docs/api-reference/legacy/crm/lists/get-list-listId}
+      # {https://developers.hubspot.com/docs/api-reference/legacy/crm/lists/get-lists#parameter-list-ids}
       def find(ids)
         batch_mode, path, params = case ids
-        when Integer then [false, LIST_PATH, { list_id: ids }]
-        when String then [false, LIST_PATH, { list_id: ids.to_i }]
-        when Array then [true, LIST_BATCH_PATH, { batch_list_id: ids.map(&:to_i) }]
-        else raise Hubspot::InvalidParams, 'expecting Integer or Array of Integers parameter'
-        end
+                                   when Integer then [false, LIST_PATH, { list_id: ids }]
+                                   when String then [false, LIST_PATH, { list_id: ids.to_i }]
+                                   when Array then [true, LISTS_PATH, { listIds: ids.map(&:to_i) }]
+                                   else raise Hubspot::InvalidParams, 'expecting Integer or Array of Integers parameter'
+                                   end
 
         response = Hubspot::Connection.get_json(path, params)
         batch_mode ? response['lists'].map { |l| new(l) } : new(response)
       end
     end
 
-    attr_reader :id
-    attr_reader :portal_id
-    attr_reader :name
-    attr_reader :dynamic
-    attr_reader :properties
+    attr_reader :id, :legacy_list_id, :name, :processing_type, :properties
 
     def initialize(hash)
-      self.send(:assign_properties, hash)
+      send(:assign_properties, hash.key?('list') ? hash['list'] : hash)
     end
 
-    # {http://developers.hubspot.com/docs/methods/lists/update_list}
-    def update!(opts={})
-      response = Hubspot::Connection.post_json(LIST_PATH, params: { list_id: @id }, body: opts)
-      self.send(:assign_properties, response)
+    # {https://developers.hubspot.com/docs/api-reference/legacy/crm/lists/update-list-name}
+    def update_name!(new_name)
+      response = Hubspot::Connection.put_json(UPDATE_NAME_PATH, params: { list_id: id, listName: new_name }, body: {})
+      send(:assign_properties, response['updatedList'])
       self
     end
 
     # {http://developers.hubspot.com/docs/methods/lists/delete_list}
     def destroy!
-      response = Hubspot::Connection.delete_json(LIST_PATH, { list_id: @id })
+      response = Hubspot::Connection.delete_json(LIST_PATH, { list_id: id })
       @destroyed = (response.code == 204)
     end
 
-    # {http://developers.hubspot.com/docs/methods/lists/get_list_contacts}
-    def contacts(opts={})
-      # NOTE: caching functionality can be dependant of the nature of the list, if dynamic or not ...
-      bypass_cache = opts.delete(:bypass_cache) { false }
-      recent = opts.delete(:recent) { false }
-      paged = opts.delete(:paged) { false }
-
-      if bypass_cache || @contacts.nil?
-        path = recent ? RECENT_CONTACTS_PATH : CONTACTS_PATH
-        opts[:list_id] = @id
-
-        response = Hubspot::Connection.get_json(path, Hubspot::ContactProperties.add_default_parameters(opts))
-        @contacts = response['contacts'].map! { |c| Hubspot::Contact.from_result(c) }
-        paged ? response : @contacts
-      else
-        @contacts
+    # {https://developers.hubspot.com/docs/api-reference/legacy/crm/lists/memberships/get-memberships-by-id}
+    def contact_ids(opts = {})
+      path = opts.delete(:recent) ? RECENT_CONTACTS_PATH : CONTACTS_PATH
+      opts[:list_id] = id
+      Hubspot::PagedCollection.new(opts) do |options, after, limit|
+        response = Hubspot::Connection.get_json(
+          path, options.merge('limit' => limit, 'offset' => after, 'offset_param' => 'after')
+        )
+
+        contact_ids = response['results'].pluck('recordId')
+        after = response.dig('paging', 'next', 'after')
+        [contact_ids, after, after.present?]
       end
     end
 
     # {http://developers.hubspot.com/docs/methods/lists/add_contact_to_list}
-    def add(contacts)
-      contact_ids = [contacts].flatten.uniq.compact.map(&:id)
-      response = Hubspot::Connection.post_json(ADD_CONTACT_PATH, params: { list_id: @id }, body: { vids: contact_ids })
-      response['updated'].sort == contact_ids.sort
+    def add(contact_ids)
+      contact_ids = [contact_ids].flatten.uniq.compact
+      response = Hubspot::Connection.put_json(ADD_CONTACTS_PATH, params: { list_id: id }, body: contact_ids)
+      response['recordsIdsAdded']&.sort == contact_ids.sort.map(&:to_s)
     end
 
     # {http://developers.hubspot.com/docs/methods/lists/remove_contact_from_list}
-    def remove(contacts)
-      contact_ids = [contacts].flatten.uniq.compact.map(&:id)
-      response = Hubspot::Connection.post_json(REMOVE_CONTACT_PATH, params: { list_id: @id }, body: { vids: contact_ids })
-      response['updated'].sort == contact_ids.sort
+    def remove(contact_ids)
+      contact_ids = [contact_ids].flatten.uniq.compact
+      response = Hubspot::Connection.put_json(REMOVE_CONTACTS_PATH, params: { list_id: id }, body: contact_ids)
+      response['recordIdsRemoved']&.sort == contact_ids.sort.map(&:to_s)
     end
 
     def destroyed?
@@ -113,9 +112,9 @@ module Hubspot
 
     def assign_properties(hash)
       @id = hash['listId']
-      @portal_id = hash['portalId']
+      @legacy_list_id = hash['legacyListId']
       @name = hash['name']
-      @dynamic = hash['dynamic']
+      @processing_type = hash['processingType']
       @properties = hash
     end
   end

data/lib/hubspot/resource.rb

@@ -9,7 +9,7 @@ module Hubspot
     self.update_method = "put"
 
     class << self
-      def from_result(result)
+      def from_result(result, id_field: self.id_field)
         resource = new(result[id_field])
         resource.send(:initialize_from, result.with_indifferent_access)
         resource
@@ -55,9 +55,12 @@ module Hubspot
       @changes = HashWithIndifferentAccess.new
       @properties = HashWithIndifferentAccess.new
 
-      if id_or_properties.is_a?(Integer) || id_or_properties.nil?
+      case id_or_properties
+      when Integer, NilClass
         @id = id_or_properties
-      elsif id_or_properties.is_a?(Hash)
+      when String
+        @id = Integer id_or_properties
+      when Hash
         @id = id_or_properties.delete(id_field) || id_or_properties.delete(:id)
 
         add_accessors(id_or_properties.keys)

data/spec/factories/contacts.rb

@@ -1,10 +1,12 @@
-
 FactoryBot.define do
-  factory :contact, class: Hubspot::Contact do
+  factory :contact, class: 'Hubspot::Contact' do
     to_create { |instance| instance.save }
 
     firstname { Faker::Name.first_name }
     lastname { Faker::Name.last_name }
-    email { Faker::Internet.email(name: "#{Time.new.to_i.to_s[-5..-1]}#{(0..3).map { (65 + rand(26)).chr }.join}") }
+    email do
+      Faker::Internet.email(name: "#{Time.new.to_i.to_s[-5..-1]}#{(0..3).map { rand(65..90).chr }.join}",
+                            domain: 'hubspot.com')
+    end
   end
 end

data/spec/lib/hubspot/connection_spec.rb

@@ -212,9 +212,9 @@ describe Hubspot::Connection do
       end
 
       context "passing Array as parameters for batch mode, key is prefixed with batch_" do
-        let(:path) { Hubspot::ContactList::LIST_BATCH_PATH }
+        let(:path) { Hubspot::ContactList::LISTS_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" }
+        it { should == "https://api.hubapi.com/crm/v3/lists?listId=1&listId=2&listId=3" }
       end
     end
   end

data/spec/lib/hubspot/contact_list_spec.rb

@@ -1,104 +1,88 @@
 describe Hubspot::ContactList do
   # uncomment if you need to create test data in your panel.
-  # note that sandboxes have a limit of 5 dynamic lists
+  # note that sandboxes have a limit of 10 dynamic lists
   # before(:all) do
   #   VCR.use_cassette("create_all_lists") do
   #     25.times { Hubspot::ContactList.create!(name: SecureRandom.hex) }
-  #     3.times { Hubspot::ContactList.create!(name: SecureRandom.hex, dynamic: true, filters: [[{ operator: "EQ", value: "@hubspot", property: "twitterhandle", type: "string"}]]) }
+  #     3.times { Hubspot::ContactList.create!(name: SecureRandom.hex, processing_type: 'DYNAMIC', "filterBranch": { "filterBranches": [{ "filterBranches": [], "filterBranchType": "AND", "filters": [{ "filterType": "PROPERTY", property: "twitterhandle", operation: { operationType: 'STRING', operator: 'IS_EQUAL_TO', value: '@hubspot'}}]}], "filterBranchType": "OR", "filters": [] } ) }
   #   end
   # end
 
-  let(:example_contact_list_hash) do
-    VCR.use_cassette("contact_list_example") do
-      headers = { Authorization: "Bearer #{ENV.fetch('HUBSPOT_ACCESS_TOKEN')}" }
-      response = HTTParty.get("https://api.hubapi.com/contacts/v1/lists/static?count=1", headers: headers).parsed_response
-      response['lists'].first
-    end
-  end
-
   let(:static_list) do
     Hubspot::ContactList.create!(name: "static list #{SecureRandom.hex}")
   end
 
-  shared_examples "count and offset" do |params|
-    it 'returns only the number of objects specified by count' do
-      result = instance_exec(count: 2, &params[:block])
-      expect(result.size).to eql 2
+  describe '#initialize' do
+    subject { Hubspot::ContactList.new(example_contact_list_hash) }
 
-      result = instance_exec(count: 4, &params[:block])
-      expect(result.size).to eql 4
+    let(:example_contact_list_hash) do
+      VCR.use_cassette('contact_list_example') do
+        headers = { Authorization: "Bearer #{ENV.fetch('HUBSPOT_ACCESS_TOKEN')}" }
+        response = HTTParty.get('https://api.hubapi.com/contacts/v1/lists?count=2', headers: headers).parsed_response
+        response['lists'].last
+      end
     end
 
-    it 'returns objects by a specified offset' do
-      non_offset_objects = instance_exec(count: 2, &params[:block])
-      objects_with_offset = instance_exec(count: 2, offset: 2, &params[:block])
-      expect(non_offset_objects).to_not eql objects_with_offset
+    specify(:aggregate_failures) do
+      expect(subject).to be_an_instance_of Hubspot::ContactList
+      expect(subject.name).not_to be_empty
+      expect(subject.processing_type).to be_nil
+      expect(subject.properties).to be_a(Hash)
     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 false }
-    its(:properties) { should be_a(Hash) }
-  end
-
-  describe '#contacts' do
+  describe '#contact_ids' do
     cassette 'contacts_among_list'
 
     let(:list) { @list }
 
     before(:all) do
-      VCR.use_cassette 'create_and_add_all_contacts' do
+      VCR.use_cassette 'contact_lists/create_and_add_all_contacts' do
         @list = Hubspot::ContactList.create!(name: "contacts list #{SecureRandom.hex}")
-        25.times do
-          contact = Hubspot::Contact.create("#{SecureRandom.hex}@hubspot.com")
-          @list.add(contact)
-        end
+        contacts = (1..30).map { Hubspot::Contact.create("#{SecureRandom.hex}@hubspot.com") }
+        @list.add(contacts.map(&:id))
       end
     end
 
-    it 'returns by default 20 contact lists with paging data' do
-      contact_data = list.contacts({bypass_cache: true, paged: true})
-      contacts = contact_data['contacts']
-
-      expect(contact_data).to have_key 'vid-offset'
-      expect(contact_data).to have_key 'has-more'
-
-      expect(contacts.count).to eql 20
-      contact = contacts.first
-      expect(contact).to be_a(Hubspot::Contact)
-      expect(contact.email).to_not be_empty
+    it 'returns by default 25 contact lists with paging data' do
+      results = list.contact_ids
+      expect(results).to be_a(Hubspot::PagedCollection)
+      expect(results.first).to be_a(String)
+      expect(results.more?).to be true
+      expect(results.count).to eql 25
     end
-
-    it_behaves_like 'count and offset', {block: ->(r) { Hubspot::ContactList.find(list.id).contacts(r) }}
   end
 
   describe '.create' do
-    subject{ Hubspot::ContactList.create!({ name: name }) }
+    subject { Hubspot::ContactList.create!(name:) }
 
     context 'with all required parameters' do
       cassette 'create_list'
 
       let(:name) { "testing list #{SecureRandom.hex}" }
-      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 }
+
+      specify(:aggregate_failures) do
+        expect(subject).to be_an_instance_of Hubspot::ContactList
+        expect(subject.processing_type).to eq described_class::MANUAL_PROCESSING_TYPE
+      end
 
       context 'adding filters parameters' do
         cassette 'create_list_with_filters'
 
         it 'returns a ContactList object with filters set' do
           name = "list with filters #{SecureRandom.hex}"
-          filters_param = [[{ operator: "EQ", value: "@hubspot", property: "twitterhandle", type: "string"}]]
-          list_with_filters = Hubspot::ContactList.create!({ name: name, filters: filters_param })
+          filter_branch = { filterBranches: [
+            { filterBranches: [], filterBranchType: 'AND', filters: [
+              { filterType: 'PROPERTY', property: 'twitterhandle',
+                operation: { operationType: 'STRING', operator: 'IS_EQUAL_TO', value: '@hubspot' } }
+            ] }
+          ], filterBranchType: 'OR', filters: [] }
+
+          list_with_filters = Hubspot::ContactList.create!(processing_type: 'DYNAMIC', name: name,
+                                                           filterBranch: filter_branch)
           expect(list_with_filters).to be_a(Hubspot::ContactList)
-          expect(list_with_filters.properties['filters']).to_not be_empty
+          expect(list_with_filters.properties['filterBranch']).not_to be_empty
+          expect(list_with_filters.processing_type).to eq 'DYNAMIC'
         end
       end
     end
@@ -107,75 +91,49 @@ describe Hubspot::ContactList do
       cassette 'fail_to_create_list'
 
       it 'raises an error' do
-        expect { Hubspot::ContactList.create!({ name: nil }) }.to raise_error(Hubspot::RequestError)
+        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'
+    cassette 'find_all_lists'
 
-      it 'returns by default 20 contact lists' do
-        lists = Hubspot::ContactList.all
-        expect(lists.count).to eql 20
+    it 'returns by default 20 contact lists' do
+      lists = Hubspot::ContactList.all
+      expect(lists).to be_a(Hubspot::PagedCollection)
+      expect(lists.count).to eql 20
 
-        list = lists.first
-        expect(list).to be_a(Hubspot::ContactList)
-        expect(list.id).to be_an(Integer)
-      end
-
-      it_behaves_like 'count and offset', {block: ->(r) { Hubspot::ContactList.all(r) }}
-    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 > 2
-
-        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 dynamic contact lists' do
-        lists = Hubspot::ContactList.all(dynamic: true)
-        expect(lists.count).to be > 2
-
-        list = lists.first
-        expect(list).to be_a(Hubspot::ContactList)
-        expect(list.dynamic).to be true
-      end
+      list = lists.first
+      expect(list).to be_a(Hubspot::ContactList)
+      expect(list.id).to be_present
     end
   end
 
   describe '.find' do
     context 'given an id' do
-      cassette "contact_list_find"
+      cassette 'contact_list_find'
       subject { Hubspot::ContactList.find(id) }
 
-      let(:list) { Hubspot::ContactList.new(example_contact_list_hash) }
+      let(:list) { Hubspot::ContactList.create!(name: SecureRandom.hex) }
 
       context 'when the contact list is found' do
         let(:id) { list.id.to_i }
-        it { should be_an_instance_of Hubspot::ContactList }
-        its(:name) { should == list.name }
 
-        context "string id" do
+        it { is_expected.to be_an_instance_of Hubspot::ContactList }
+        its(:name) { is_expected.to eq list.name }
+
+        context 'string id' do
           let(:id) { list.id.to_s }
-          it { should be_an_instance_of Hubspot::ContactList }
+
+          it { is_expected.to be_an_instance_of Hubspot::ContactList }
+          its(:name) { is_expected.to eq list.name }
         end
       end
 
       context 'Wrong parameter type given' do
         it 'raises an error' do
-          expect { Hubspot::ContactList.find({ foo: :bar }) }.to raise_error(Hubspot::InvalidParams)
+          expect { Hubspot::ContactList.find(foo: :bar) }.to raise_error(Hubspot::InvalidParams)
         end
       end
 
@@ -187,32 +145,30 @@ describe Hubspot::ContactList do
     end
 
     context 'given a list of ids' do
-      cassette "contact_list_batch_find"
+      cassette 'contact_list_batch_find'
 
       let(:list1) { Hubspot::ContactList.create!(name: SecureRandom.hex) }
       let(:list2) { Hubspot::ContactList.create!(name: SecureRandom.hex) }
       let(:list3) { Hubspot::ContactList.create!(name: SecureRandom.hex) }
 
       it 'find lists of contacts' do
-        lists = Hubspot::ContactList.find([list1.id,list2.id,list3.id])
+        lists = Hubspot::ContactList.find([list1.id, list2.id, list3.id])
         list = lists.first
         expect(list).to be_a(Hubspot::ContactList)
-        expect(list.id).to be == list1.id
-        expect(lists.second.id).to be == list2.id
-        expect(lists.last.id).to be == list3.id
+        expect(lists.map(&:id)).to contain_exactly(list1.id, list2.id, list3.id)
       end
     end
   end
 
-  describe "#add" do
-    context "for a static list" do
-      it "adds the contact to the contact list" do
-        VCR.use_cassette("contact_lists/add_contact") do
+  describe '#add' do
+    context 'for a static list' do
+      it 'adds the contact to the contact list' do
+        VCR.use_cassette('contact_lists/add_contact') do
           contact = Hubspot::Contact.create("#{SecureRandom.hex}@example.com")
           contact_list_params = { name: "my-contacts-list-#{SecureRandom.hex}" }
           contact_list = Hubspot::ContactList.create!(contact_list_params)
 
-          result = contact_list.add([contact])
+          result = contact_list.add([contact.id])
 
           expect(result).to be true
 
@@ -221,18 +177,18 @@ describe Hubspot::ContactList do
         end
       end
 
-      context "when the contact already exists in the contact list" do
-        it "returns false" do
-          VCR.use_cassette("contact_lists/add_existing_contact") do
+      context 'when the contact already exists in the contact list' do
+        it 'returns false' do
+          VCR.use_cassette('contact_lists/add_existing_contact') do
             contact = Hubspot::Contact.create("#{SecureRandom.hex}@example.com")
 
             contact_list_params = { name: "my-contacts-list-#{SecureRandom.hex}" }
             contact_list = Hubspot::ContactList.create!(contact_list_params)
-            contact_list.add([contact])
+            contact_list.add([contact.id])
 
-            result = contact_list.add([contact])
+            result = contact_list.add([contact.id])
 
-            expect(result).to be true
+            expect(result).to be false
 
             contact.delete
             contact_list.destroy!
@@ -241,70 +197,76 @@ describe Hubspot::ContactList do
       end
     end
 
-    context "for a dynamic list" do
-      it "raises an error as dynamic lists add contacts via on filters" do
-        VCR.use_cassette("contact_list/add_contact_to_dynamic_list") do
+    context 'for a dynamic list' do
+      it 'raises an error as dynamic lists add contacts via on filters' do
+        VCR.use_cassette('contact_lists/add_contact_to_dynamic_list') do
           contact = Hubspot::Contact.create("#{SecureRandom.hex}@example.com")
+          filter_branch = {
+            filterBranches: [{ filterBranches: [], filterBranchType: 'AND', filters: [
+              { filterType: 'PROPERTY', property: 'twitterhandle',
+                operation: { operationType: 'STRING', operator: 'IS_EQUAL_TO', value: '@hubspot' } }
+            ] }], filterBranchType: 'OR', filters: []
+          }
           contact_list_params = {
             name: "my-contacts-list-#{SecureRandom.hex}",
-            dynamic: true,
-            "filters": [
-              [
-                {
-                  "operator": "EQ",
-                  "property": "email",
-                  "type": "string",
-                  "value": "@hubspot.com"
-                },
-              ],
-            ],
+            processing_type: 'DYNAMIC',
+            filterBranch: filter_branch
           }
           contact_list = Hubspot::ContactList.create!(contact_list_params)
 
-          expect {
-            contact_list.add(contact)
-          }.to raise_error(Hubspot::RequestError)
+          expect { contact_list.add(contact) }.to raise_error(Hubspot::RequestError)
         end
       end
     end
   end
 
   describe '#remove' do
-    cassette "remove_contacts_from_lists"
+    it 'returns true if removes all contacts' do
+      VCR.use_cassette('contact_lists/remove_contact') do
+        contact_ids = (1..2).map { Hubspot::Contact.create("#{SecureRandom.hex}@example.com").id }
+        contact_list_params = { name: "my-contacts-list-#{SecureRandom.hex}" }
+        contact_list = Hubspot::ContactList.create!(contact_list_params)
+
+        contact_list.add(contact_ids)
+        result = contact_list.remove(contact_ids)
+
+        expect(result).to be true
 
-    context 'static list' do
-      it 'returns true if removes all contacts in batch mode' do
-        list = Hubspot::ContactList.new(example_contact_list_hash)
-        contacts = list.contacts(count: 2)
-        expect(list.remove([contacts.first, contacts.last])).to be true
+        contact_list.destroy!
       end
+    end
+
+    it 'returns false if the contact cannot be removed' do
+      VCR.use_cassette('contact_lists/remove_unknown_contact') do
+        contact_list_params = { name: "my-contacts-list-#{SecureRandom.hex}" }
+        contact_list = Hubspot::ContactList.create!(contact_list_params)
+        result = contact_list.remove([42])
+        expect(result).to be false
 
-      it 'returns false if the contact cannot be removed' do
-        contact_not_present_in_list = Hubspot::Contact.new(1234)
-        expect(static_list.remove(contact_not_present_in_list)).to be false
+        contact_list.destroy!
       end
     end
   end
 
-  describe '#update!' do
-    cassette "contact_list_update"
-
-    let(:params) { { name: "updated list name" } }
-    subject { static_list.update!(params) }
+  describe '#update_name!' do
+    cassette 'contact_list_update'
 
-    it { should be_an_instance_of Hubspot::ContactList }
-    its(:name){ should == params[:name] }
+    subject { static_list.update_name!('updated list name') }
 
     after { static_list.destroy! }
+
+    it { is_expected.to be_an_instance_of Hubspot::ContactList }
+    its(:name) { is_expected.to eq 'updated list name' }
   end
 
   describe '#destroy!' do
-    cassette "contact_list_destroy"
+    cassette 'contact_list_destroy'
+
+    subject { static_list.destroy! }
 
-    subject{ static_list.destroy! }
-    it { should be true }
+    it { is_expected.to be true }
 
-    it "should be destroyed" do
+    it 'is destroyed' do
       subject
       expect(static_list).to be_destroyed
     end

data/spec/lib/hubspot/contact_spec.rb

@@ -1,23 +1,81 @@
 RSpec.describe Hubspot::Contact do
-
-  it_behaves_like "a saveable resource", :contact do
+  it_behaves_like 'a saveable resource', :contact do
     def set_property(contact)
-      contact.firstname = "foobar"
+      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" } }
+  it_behaves_like 'an updateable resource', :contact do
+    let(:changed_properties) { { firstname: 'foobar' } }
+    let(:overlapping_properties) { { firstname: 'asdf', lastname: 'qwer' } }
+  end
+
+  describe '.all' do
+    context 'without options' do
+      cassette
+
+      subject { described_class.all }
+
+      it 'returns a collection' do
+        expect(subject).to be_a(Hubspot::PagedCollection)
+        expect(subject.first).to be_a(Hubspot::Contact)
+      end
+
+      it 'has an offset' do
+        expect(subject.next_offset).not_to be_blank
+      end
+
+      it 'identifies if there are more resources' do
+        expect(subject.more?).to be true
+      end
+    end
+
+    context 'with an offset' do
+      cassette
+
+      subject { described_class.all offset: contact.id }
+
+      let!(:contact) { create :contact }
+
+      it 'returns a collection' do
+        expect(subject).to be_a(Hubspot::PagedCollection)
+      end
+
+      it 'has an offset' do
+        expect(subject.next_offset).not_to be_blank
+      end
+
+      it 'identifies if there are more resources' do
+        expect(subject.more?).not_to be_nil
+      end
+    end
+
+    context 'with a limit' do
+      cassette
+
+      subject { described_class.all limit: limit }
+
+      let(:limit) { 1 }
+
+      it 'returns a collection' do
+        expect(subject).to be_a(Hubspot::PagedCollection)
+        expect(subject.first).to be_a(Hubspot::Contact)
+      end
+
+      it 'respects the limit' do
+        expect(subject.size).to eq(limit)
+      end
+    end
   end
 
   describe '.find' do
     context 'with a valid ID' do
       cassette
 
+      subject { described_class.find contact.id }
+
       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)
@@ -31,9 +89,9 @@ RSpec.describe Hubspot::Contact do
       subject { described_class.find 0 }
 
       it 'raises an error' do
-        expect {
+        expect do
           subject
-        }.to raise_error(Hubspot::NotFoundError, /contact does not exist/)
+        end.to raise_error(Hubspot::NotFoundError, /contact does not exist/)
       end
     end
   end
@@ -42,9 +100,10 @@ RSpec.describe Hubspot::Contact do
     context 'without properties' do
       cassette
 
-      let(:email) { Faker::Internet.email(name: "#{(0..3).map { (65 + rand(26)).chr }.join}#{Time.new.to_i.to_s[-5..-1]}") }
       subject { described_class.create email }
 
+      let(:email) { Faker::Internet.email(name: "#{(0..3).map { rand(65..90).chr }.join}#{Time.new.to_i.to_s[-5..-1]}") }
+
       it 'creates a new contact' do
         expect(subject).to be_a(described_class)
         expect(subject.id).not_to be_nil
@@ -54,12 +113,12 @@ RSpec.describe Hubspot::Contact do
     context 'with properties' do
       cassette
 
-      let(:email) { Faker::Internet.email(name: "#{(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 }
 
+      let(:email) { Faker::Internet.email(name: "#{(0..3).map { rand(65..90).chr }.join}#{Time.new.to_i.to_s[-5..-1]}") }
+      let(:firstname) { 'Allison' }
+      let(:properties) { { firstname: firstname } }
+
       it 'creates a new contact' do
         expect(subject).to be_a(described_class)
         expect(subject.id).not_to be_nil
@@ -77,29 +136,29 @@ RSpec.describe Hubspot::Contact do
     context 'with an existing email address' do
       cassette
 
+      subject { described_class.create email }
+
       let(:contact) { create :contact }
       let(:email) { contact.email }
 
-      subject { described_class.create email }
-
       it 'raises an error' do
-        expect {
+        expect do
           subject
-        }.to raise_error(Hubspot::RequestError)
+        end.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 }
 
+      let(:email) { 'an_invalid_email' }
+
       it 'raises an error' do
-        expect {
+        expect do
           subject
-        }.to raise_error(Hubspot::RequestError)
+        end.to raise_error(Hubspot::RequestError)
       end
     end
   end
@@ -107,10 +166,10 @@ RSpec.describe Hubspot::Contact do
   describe '.find_by_email' do
     cassette
 
-    let(:contact) { create :contact }
-
     subject { described_class.find_by_email contact.email }
 
+    let(:contact) { create :contact }
+
     it 'finds the contact' do
       expect(subject).to be_a(described_class)
       expect(subject.id).to eq(contact.id)
@@ -124,9 +183,10 @@ RSpec.describe Hubspot::Contact do
   describe '.find_by_user_token' do
     cassette
 
-    let(:contact) { create :contact }
     subject { described_class.find_by_user_token contact.utk }
 
+    let(:contact) { create :contact }
+
     it 'finds the contact' do
       skip 'need a contact with a user token'
       expect(subject).to be_a(described_class)
@@ -167,11 +227,11 @@ RSpec.describe Hubspot::Contact do
     context 'with valid contact ids' do
       cassette
 
+      subject { described_class.merge contact1.id, contact2.id }
+
       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
@@ -183,9 +243,9 @@ RSpec.describe Hubspot::Contact do
       subject { described_class.merge 1, 2 }
 
       it 'raises an error' do
-        expect {
+        expect do
           subject
-        }.to raise_error(Hubspot::RequestError)
+        end.to raise_error(Hubspot::RequestError)
       end
     end
   end
@@ -194,11 +254,11 @@ RSpec.describe Hubspot::Contact do
     context 'with a valid contact' do
       cassette
 
+      subject { contact1.merge(contact2) }
+
       let!(:contact1) { create :contact }
       let!(:contact2) { create :contact }
 
-      subject { contact1.merge(contact2) }
-
       it 'succeeds' do
         expect(subject).to be_truthy
       end
@@ -207,14 +267,14 @@ RSpec.describe Hubspot::Contact do
     context 'with an invalid contact' do
       cassette
 
-      let!(:contact1) { create :contact }
-
       subject { contact1.merge(contact1.id) }
 
+      let!(:contact1) { create :contact }
+
       it 'raises an error' do
-        expect {
+        expect do
           subject
-        }.to raise_error(Hubspot::RequestError)
+        end.to raise_error(Hubspot::RequestError)
       end
     end
   end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hubspot-api-ruby
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.1
 platform: ruby
 authors:
 - Jonathan
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -248,6 +247,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: hubspot-api-ruby is a wrapper for the HubSpot REST API
 email:
 - jonathan@hoggo.com
@@ -339,7 +352,6 @@ licenses:
 - MIT
 metadata:
   changelog_uri: https://github.com/captaincontrat/hubspot-api-ruby/blob/master/History.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -347,15 +359,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: hubspot-api-ruby is a wrapper for the HubSpot REST API
 test_files: []