intercom 3.9.4 → 4.1.1

data/spec/unit/intercom/request_spec.rb

@@ -9,7 +9,7 @@ describe 'Intercom::Request', '#execute' do
   let(:default_body) { { data: "test" }.to_json }
 
   def execute!
-    req.execute(uri, username: 'ted', secret: '')
+    req.execute(uri, token: 'test-token')
   end
 
   it 'should call sleep for rate limit error three times and raise a rate limit error otherwise' do

data/spec/unit/intercom/scroll_collection_proxy_spec.rb

@@ -1,56 +1,57 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe Intercom::ScrollCollectionProxy do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
-  it "stops iterating if no users returned" do
-    client.expects(:get).with("/users/scroll", '').returns(users_scroll(false))
-    emails = []
-    client.users.scroll.each { |user| emails << user.email }
-    emails.must_equal %W()
+  it 'stops iterating if no companies returned' do
+    client.expects(:get).with('/companies/scroll', '').returns(companies_scroll(false))
+    names = []
+    client.companies.scroll.each { |company| names << company.name }
+    _(names).must_equal %w[]
   end
 
-  it "keeps iterating if users returned" do
-    client.expects(:get).with("/users/scroll", '').returns(users_scroll(true))
-    client.expects(:get).with('/users/scroll', {:scroll_param => 'da6bbbac-25f6-4f07-866b-b911082d7'}).returns(users_scroll(false))
-    emails = []
-    client.users.scroll.each { |user| emails << user.email }
+  it 'keeps iterating if companies returned' do
+    client.expects(:get).with('/companies/scroll', '').returns(companies_scroll(true))
+    client.expects(:get).with('/companies/scroll', scroll_param: 'da6bbbac-25f6-4f07-866b-b911082d7').returns(companies_scroll(false))
+    names = []
+    client.companies.scroll.each { |company| names << company.name }
   end
 
-  it "supports indexed array access" do
-    client.expects(:get).with("/users/scroll", '').returns(users_scroll(true))
-    client.users.scroll[0].email.must_equal 'user1@example.com'
+  it 'supports indexed array access' do
+    client.expects(:get).with('/companies/scroll', '').returns(companies_scroll(true))
+    _(client.companies.scroll[0].name).must_equal 'company1'
   end
 
-  it "supports map" do
-    client.expects(:get).with("/users/scroll", '').returns(users_scroll(true))
-    client.expects(:get).with('/users/scroll', {:scroll_param => 'da6bbbac-25f6-4f07-866b-b911082d7'}).returns(users_scroll(false))
-    emails = client.users.scroll.map { |user| user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+  it 'supports map' do
+    client.expects(:get).with('/companies/scroll', '').returns(companies_scroll(true))
+    client.expects(:get).with('/companies/scroll', scroll_param: 'da6bbbac-25f6-4f07-866b-b911082d7').returns(companies_scroll(false))
+    names = client.companies.scroll.map(&:name)
+    _(names).must_equal %w[company1 company2 company3]
   end
 
-  it "returns one page scroll" do
-    client.expects(:get).with("/users/scroll", '').returns(users_scroll(true))
-    scroll = client.users.scroll.next
-    emails = []
-    scroll.records.each {|usr| emails << usr.email}
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+  it 'returns one page scroll' do
+    client.expects(:get).with('/companies/scroll', '').returns(companies_scroll(true))
+    scroll = client.companies.scroll.next
+    names = []
+    scroll.records.each { |usr| names << usr.name }
+    _(names).must_equal %w[company1 company2 company3]
   end
 
-  it "keeps iterating if called with scroll_param" do
-    client.expects(:get).with("/users/scroll", '').returns(users_scroll(true))
-    client.expects(:get).with('/users/scroll', {:scroll_param => 'da6bbbac-25f6-4f07-866b-b911082d7'}).returns(users_scroll(true))
-    scroll = client.users.scroll.next
-    scroll = client.users.scroll.next('da6bbbac-25f6-4f07-866b-b911082d7')
-    emails =[]
-    scroll.records.each {|usr| puts usr.email}
+  it 'keeps iterating if called with scroll_param' do
+    client.expects(:get).with('/companies/scroll', '').returns(companies_scroll(true))
+    client.expects(:get).with('/companies/scroll', scroll_param: 'da6bbbac-25f6-4f07-866b-b911082d7').returns(companies_scroll(true))
+    scroll = client.companies.scroll.next
+    scroll = client.companies.scroll.next('da6bbbac-25f6-4f07-866b-b911082d7')
+    scroll.records.each(&:name)
   end
 
-  it "works with an empty list" do
-    client.expects(:get).with("/users/scroll", '').returns(users_scroll(false))
-    scroll = client.users.scroll.next
-    emails = []
-    scroll.records.each {|usr| emails << usr.email}
-    emails.must_equal %W()
+  it 'works with an empty list' do
+    client.expects(:get).with('/companies/scroll', '').returns(companies_scroll(false))
+    scroll = client.companies.scroll.next
+    names = []
+    scroll.records.each { |usr| names << usr.name }
+    _(names).must_equal %w[]
   end
 end

data/spec/unit/intercom/search_collection_proxy_spec.rb

@@ -1,56 +1,60 @@
 require "spec_helper"
 
 describe Intercom::SearchCollectionProxy do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
-  it "send query to the customer search endpoint" do
-    client.expects(:post).with("/customers/search", { query: {} }).  returns(page_of_customers(false))
-    client.customers.search(query: {}).first
+  it "sends query to the contact search endpoint" do
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(false))
+    client.contacts.search(query: {}).first
   end
 
-  it "send query to the customer search endpoint with sort_field" do
-    client.expects(:post).with("/customers/search", { query: {}, sort: { field: "name" } }).  returns(page_of_customers(false))
-    client.customers.search(query: {}, sort_field: "name").first
+  it "sends query to the conversation search endpoint" do
+    client.expects(:post).with("/conversations/search", { query: {} }).returns(test_conversation_list)
+    client.conversations.search(query: {}).first
   end
 
-  it "send query to the customer search endpoint with sort_field and sort_order" do
-    client.expects(:post).with("/customers/search", { query: {}, sort: { field: "name", order: "ascending" } }).  returns(page_of_customers(false))
-    client.customers.search(query: {}, sort_field: "name", sort_order: "ascending").first
+  it "sends query to the contact search endpoint with sort_field" do
+    client.expects(:post).with("/contacts/search", { query: {}, sort: { field: "name" } }).returns(page_of_contacts(false))
+    client.contacts.search(query: {}, sort_field: "name").first
   end
 
-  it "send query to the customer search endpoint with per_page" do
-    client.expects(:post).with("/customers/search", { query: {}, pagination: { per_page: 10 }}).  returns(page_of_customers(false))
-    client.customers.search(query: {}, per_page: 10).first
+  it "sends query to the contact search endpoint with sort_field and sort_order" do
+    client.expects(:post).with("/contacts/search", { query: {}, sort: { field: "name", order: "ascending" } }).returns(page_of_contacts(false))
+    client.contacts.search(query: {}, sort_field: "name", sort_order: "ascending").first
   end
 
-  it "send query to the customer search endpoint with starting_after" do
-    client.expects(:post).with("/customers/search", { query: {}, pagination: { starting_after: "EnCrYpTeDsTrInG" }}).  returns(page_of_customers(false))
-    client.customers.search(query: {}, starting_after: "EnCrYpTeDsTrInG").first
+  it "sends query to the contact search endpoint with per_page" do
+    client.expects(:post).with("/contacts/search", { query: {}, pagination: { per_page: 10 }}).returns(page_of_contacts(false))
+    client.contacts.search(query: {}, per_page: 10).first
+  end
+
+  it "sends query to the contact search endpoint with starting_after" do
+    client.expects(:post).with("/contacts/search", { query: {}, pagination: { starting_after: "EnCrYpTeDsTrInG" }}).returns(page_of_contacts(false))
+    client.contacts.search(query: {}, starting_after: "EnCrYpTeDsTrInG").first
   end
 
   it "stops iterating if no starting_after value" do
-    client.expects(:post).with("/customers/search", { query: {} }).  returns(page_of_customers(false))
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(false))
     emails = []
-    client.customers.search(query: {}).each { |user| emails << user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+    client.contacts.search(query: {}).each { |contact| emails << contact.email }
+    _(emails).must_equal %w[test1@example.com test2@example.com test3@example.com]
   end
 
   it "keeps iterating if starting_after value" do
-    client.expects(:post).with("/customers/search", { query: {} }).returns(page_of_customers(true))
-    client.expects(:post).with("/customers/search", { query: {}, pagination: { starting_after: "EnCrYpTeDsTrInG" }}).returns(page_of_customers(false))
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(true))
+    client.expects(:post).with("/contacts/search", { query: {}, pagination: { starting_after: "EnCrYpTeDsTrInG" }}).returns(page_of_contacts(false))
     emails = []
-    client.customers.search(query: {}).each { |user| emails << user.email }
+    client.contacts.search(query: {}).each { |contact| emails << contact.email }
   end
 
   it "supports indexed array access" do
-    client.expects(:post).with("/customers/search", { query: {} }).returns(page_of_customers(false))
-    client.customers.search(query: {})[0].email.must_equal 'user1@example.com'
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(false))
+    _(client.contacts.search(query: {})[0].email).must_equal 'test1@example.com'
   end
 
   it "supports map" do
-    client.expects(:post).with("/customers/search", { query: {} }).returns(page_of_customers(false))
-    emails = client.customers.search(query: {}).map { |user| user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(false))
+    emails = client.contacts.search(query: {}).map { |contact| contact.email }
+    _(emails).must_equal %w[test1@example.com test2@example.com test3@example.com]
   end
-
 end

data/spec/unit/intercom/section_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Intercom::Section do
+  let(:client) { Intercom::Client.new(token: 'token') }
+
+  it 'creates a section' do
+    client.expects(:post).with('/help_center/sections', { 'name' => 'Section 1', 'parent_id' => '1' }).returns(test_section)
+    client.sections.create(:name => 'Section 1', :parent_id => '1')
+  end
+
+  it 'lists sections' do
+    client.expects(:get).with('/help_center/sections', {}).returns(test_section_list)
+    client.sections.all.each { |t| }
+  end
+
+  it 'finds a section' do
+    client.expects(:get).with('/help_center/sections/1', {}).returns(test_section)
+    client.sections.find(id: '1')
+  end
+
+  it 'updates a section' do
+    section = Intercom::Section.new(id: '12345')
+    client.expects(:put).with('/help_center/sections/12345', {})
+    client.sections.save(section)
+  end
+
+  it 'deletes a section' do
+    section = Intercom::Section.new(id: '12345')
+    client.expects(:delete).with('/help_center/sections/12345', {})
+    client.sections.delete(section)
+  end
+end

data/spec/unit/intercom/segment_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe "Intercom::Segment" do
 
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it 'lists segments' do
     client.expects(:get).with('/segments', {}).returns(segment_list)
     segments = client.segments.all.to_a
-    segments[0].name.must_equal('Active')
+    _(segments[0].name).must_equal('Active')
   end
 end

data/spec/unit/intercom/subscription_spec.rb

@@ -1,20 +1,19 @@
 require 'spec_helper'
 
 describe "Intercom::Subscription" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it "gets a subscription" do
     client.expects(:get).with("/subscriptions/nsub_123456789", {}).returns(test_subscription)
     subscription = client.subscriptions.find(:id => "nsub_123456789")
-    subscription.request.topics[0].must_equal "user.created"
-    subscription.request.topics[1].must_equal "conversation.user.replied"
+    _(subscription.request.topics[0]).must_equal "user.created"
+    _(subscription.request.topics[1]).must_equal "conversation.user.replied"
   end
 
   it "creates a subscription" do
     client.expects(:post).with("/subscriptions", {'url' => "http://example.com", 'topics' => ["user.created"]}).returns(test_subscription)
     subscription = client.subscriptions.create(:url => "http://example.com", :topics => ["user.created"])
-    subscription.request.topics[0].must_equal "user.created"
-    subscription.request.url.must_equal "http://example.com"
+    _(subscription.request.topics[0]).must_equal "user.created"
+    _(subscription.request.url).must_equal "http://example.com"
   end
-
 end

data/spec/unit/intercom/tag_spec.rb

@@ -1,23 +1,31 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe "Intercom::Tag" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+describe 'Intercom::Tag' do
+  let(:client) { Intercom::Client.new(token: 'token') }
+
+  it 'creates a tag' do
+    client.expects(:post).with('/tags', 'name' => 'Test Tag').returns(test_tag)
+    tag = client.tags.create(name: 'Test Tag')
+    _(tag.name).must_equal 'Test Tag'
+  end
 
-  it "creates a tag" do
-    client.expects(:post).with("/tags", {'name' => "Test Tag"}).returns(test_tag)
-    tag = client.tags.create(:name => "Test Tag")
-    tag.name.must_equal "Test Tag"
+  it 'finds a tag by id' do
+    client.expects(:get).with('/tags/4f73428b5e4dfc000b000112', {}).returns(test_tag)
+    tag = client.tags.find(id: '4f73428b5e4dfc000b000112')
+    _(tag.name).must_equal 'Test Tag'
   end
 
-  it "tags users" do
-    client.expects(:post).with("/tags", {'name' => "Test Tag", 'users' => [ { user_id: 'abc123' }, { user_id: 'def456' } ], 'tag_or_untag' => 'tag'}).returns(test_tag)
-    tag = client.tags.tag(:name => "Test Tag", :users => [ { user_id: "abc123" }, { user_id: "def456" } ] )
-    tag.name.must_equal "Test Tag"
-    tag.tagged_user_count.must_equal 2
+  it 'tags companies' do
+    client.expects(:post).with('/tags', 'name' => 'Test Tag', 'companies' => [{ company_id: 'abc123' }, { company_id: 'def456' }], 'tag_or_untag' => 'tag').returns(test_tag)
+    tag = client.tags.tag(name: 'Test Tag', companies: [{ company_id: 'abc123' }, { company_id: 'def456' }])
+    _(tag.name).must_equal 'Test Tag'
+    _(tag.tagged_company_count).must_equal 2
   end
 
-  it 'untags users' do
-    client.expects(:post).with("/tags", {'name' => "Test Tag", 'users' => [ { user_id: 'abc123', untag: true }, { user_id: 'def456', untag: true } ], 'tag_or_untag' => 'untag'}).returns(test_tag)
-    client.tags.untag(:name => "Test Tag", :users => [ { user_id: "abc123" }, { user_id: "def456" } ])
+  it 'untags companies' do
+    client.expects(:post).with('/tags', 'name' => 'Test Tag', 'companies' => [{ company_id: 'abc123', untag: true }, { company_id: 'def456', untag: true }], 'tag_or_untag' => 'untag').returns(test_tag)
+    client.tags.untag(name: 'Test Tag', companies: [{ company_id: 'abc123' }, { company_id: 'def456' }])
   end
 end

data/spec/unit/intercom/team_spec.rb

@@ -1,12 +1,12 @@
 require "spec_helper"
 
 describe "Intercom::Team" do
-  let (:client) { Intercom::Client.new(token: 'token') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it "returns a CollectionProxy for all without making any requests" do
     client.expects(:execute_request).never
     all = client.teams.all
-    all.must_be_instance_of(Intercom::ClientCollectionProxy)
+    _(all).must_be_instance_of(Intercom::ClientCollectionProxy)
   end
 
   it 'gets an team list' do

data/spec/unit/intercom/traits/api_resource_spec.rb

@@ -1,98 +1,115 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe Intercom::Traits::ApiResource do
   let(:object_json) do
-    {"type"=>"company",
-     "id"=>"aaaaaaaaaaaaaaaaaaaaaaaa",
-     "app_id"=>"some-app-id",
-     "name"=>"SuperSuite",
-     "plan_id"=>1,
-     "remote_company_id"=>"8",
-     "remote_created_at"=>103201,
-     "created_at"=>1374056196,
-     "user_count"=>1,
-     "custom_attributes"=>{},
-     "metadata"=>{
-       "type"=>"user",
-       "color"=>"cyan"
-     }}
+    { 'type' => 'company',
+      'id' => 'aaaaaaaaaaaaaaaaaaaaaaaa',
+      'app_id' => 'some-app-id',
+      'name' => 'SuperSuite',
+      'plan_id' => 1,
+      'remote_company_id' => '8',
+      'remote_created_at' => 103_201,
+      'created_at' => 1_374_056_196,
+      'user_count' => 1,
+      'custom_attributes' => {},
+      'metadata' => {
+        'type' => 'user',
+        'color' => 'cyan'
+      },
+      'nested_fields' => {
+        'type' => 'nested_fields_content',
+        'field_1' => {
+          'type' => 'field_content',
+          'name' => 'Nested Field'
+        }
+      }
+    }
   end
 
   let(:object_hash) do
     {
-      type: "company",
-      id: "aaaaaaaaaaaaaaaaaaaaaaaa",
-      app_id: "some-app-id",
-      name: "SuperSuite",
+      type: 'company',
+      id: 'aaaaaaaaaaaaaaaaaaaaaaaa',
+      app_id: 'some-app-id',
+      name: 'SuperSuite',
       plan_id: 1,
-      remote_company_id: "8",
-      remote_created_at: 103201,
-      created_at: 1374056196,
+      remote_company_id: '8',
+      remote_created_at: 103_201,
+      created_at: 1_374_056_196,
       user_count: 1,
-      custom_attributes: { type: "ping" },
+      custom_attributes: { type: 'ping' },
       metadata: {
-        type: "user",
-        color: "cyan"
+        type: 'user',
+        color: 'cyan'
+      },
+      nested_fields: {
+        type: 'nested_fields_content',
+        field_1: {
+          type: 'field_content',
+          name: 'Nested Field'
+        }
       }
     }
   end
 
-  let(:api_resource) { DummyClass.new.extend(Intercom::Traits::ApiResource)}
+  let(:api_resource) { DummyClass.new.extend(Intercom::Traits::ApiResource) }
 
   before(:each) { api_resource.from_response(object_json) }
 
-  it "coerces time on parsing json" do
-    assert_equal Time.at(1374056196), api_resource.created_at
+  it 'coerces time on parsing json' do
+    assert_equal Time.at(1_374_056_196), api_resource.created_at
   end
 
-  it "exposes string" do
-    assert_equal Time.at(1374056196), api_resource.created_at
+  it 'exposes string' do
+    assert_equal Time.at(1_374_056_196), api_resource.created_at
   end
 
   it "treats 'metadata' as a plain hash, not a typed object" do
     assert_equal Hash, api_resource.metadata.class
   end
 
-  it "dynamically defines accessors when a non-existent property is called that looks like a setter" do
-    api_resource.wont_respond_to :spiders
+  it 'dynamically defines accessors when a non-existent property is called that looks like a setter' do
+    _(api_resource).wont_respond_to :spiders
     api_resource.spiders = 4
-    api_resource.must_respond_to :spiders
+    _(api_resource).must_respond_to :spiders
   end
 
-  it "calls dynamically defined getter when asked" do
+  it 'calls dynamically defined getter when asked' do
     api_resource.foo = 4
     assert_equal 4, api_resource.foo
   end
 
-  it "accepts unix timestamps into dynamically defined date setters" do
-    api_resource.foo_at = 1401200468
-    assert_equal 1401200468, api_resource.instance_variable_get(:@foo_at)
+  it 'accepts unix timestamps into dynamically defined date setters' do
+    api_resource.foo_at = 1_401_200_468
+    assert_equal 1_401_200_468, api_resource.instance_variable_get(:@foo_at)
   end
 
-  it "exposes dates correctly for dynamically defined getters" do
-    api_resource.foo_at = 1401200468
-    assert_equal Time.at(1401200468), api_resource.foo_at
+  it 'exposes dates correctly for dynamically defined getters' do
+    api_resource.foo_at = 1_401_200_468
+    assert_equal Time.at(1_401_200_468), api_resource.foo_at
   end
 
-  it "throws regular method missing error when non-existent getter is called that is backed by an instance variable" do
+  it 'throws regular method missing error when non-existent getter is called that is backed by an instance variable' do
     api_resource.instance_variable_set(:@bar, 'you cant see me')
-    proc { api_resource.bar }.must_raise NoMethodError
+    _(proc { api_resource.bar }).must_raise NoMethodError
   end
 
-  it "throws attribute not set error when non-existent getter is called that is not backed by an instance variable" do
-    proc { api_resource.flubber }.must_raise Intercom::AttributeNotSetError
+  it 'throws attribute not set error when non-existent getter is called that is not backed by an instance variable' do
+    _(proc { api_resource.flubber }).must_raise Intercom::AttributeNotSetError
   end
 
-  it "throws regular method missing error when non-existent method is called that cannot be an accessor" do
-    proc { api_resource.flubber! }.must_raise NoMethodError
-    proc { api_resource.flubber? }.must_raise NoMethodError
+  it 'throws regular method missing error when non-existent method is called that cannot be an accessor' do
+    _(proc { api_resource.flubber! }).must_raise NoMethodError
+    _(proc { api_resource.flubber? }).must_raise NoMethodError
   end
 
-  it "throws regular method missing error when non-existent setter is called with multiple arguments" do
-    proc { api_resource.send(:flubber=, 'a', 'b') }.must_raise NoMethodError
+  it 'throws regular method missing error when non-existent setter is called with multiple arguments' do
+    _(proc { api_resource.send(:flubber=, 'a', 'b') }).must_raise NoMethodError
   end
 
-  it "an initialized ApiResource is equal to one generated from a response" do
+  it 'an initialized ApiResource is equal to one generated from a response' do
     class ConcreteApiResource; include Intercom::Traits::ApiResource; end
     initialized_api_resource = ConcreteApiResource.new(object_json)
     except(object_json, 'type').keys.each do |attribute|
@@ -100,17 +117,55 @@ describe Intercom::Traits::ApiResource do
     end
   end
 
-  it "initialized ApiResource using hash is equal to one generated from response" do
+  it 'initialized ApiResource using hash is equal to one generated from response' do
     class ConcreteApiResource; include Intercom::Traits::ApiResource; end
 
     api_resource.from_hash(object_hash)
     initialized_api_resource = ConcreteApiResource.new(object_hash)
-
     except(object_json, 'type').keys.each do |attribute|
       assert_equal initialized_api_resource.send(attribute), api_resource.send(attribute)
     end
   end
 
+  describe 'correctly equates two resources' do
+    class DummyResource; include Intercom::Traits::ApiResource; end
+
+    specify 'if each resource has the same class and same value' do
+      api_resource1 = DummyResource.new(object_json)
+      api_resource2 = DummyResource.new(object_json)
+      assert_equal (api_resource1 == api_resource2), true
+    end
+
+    specify 'if each resource has the same class and different value' do
+      object2_json = object_json.merge('id' => 'bbbbbb')
+      api_resource1 = DummyResource.new(object_json)
+      api_resource2 = DummyResource.new(object2_json)
+      assert_equal (api_resource1 == api_resource2), false
+    end
+
+    specify 'if each resource has a different class' do
+      dummy_resource = DummyResource.new(object_json)
+      assert_equal (dummy_resource == api_resource), false
+    end
+  end
+
+  it 'correctly generates submittable hash when no updates' do
+    assert_equal api_resource.to_submittable_hash, {}
+  end
+
+  it 'correctly generates submittable hash when there are updates' do
+    api_resource.name = 'SuperSuite updated'
+    api_resource.nested_fields.field_1.name = 'Updated Name'
+    assert_equal api_resource.to_submittable_hash, {
+      'name' => 'SuperSuite updated',
+      'nested_fields' => {
+        'field_1' => {
+            'name' => 'Updated Name'
+        }
+      }
+    }
+  end
+
   def except(h, *keys)
     keys.each { |key| h.delete(key) }
     h