intercom 3.9.5 → 4.1.3

data/spec/unit/intercom/event_spec.rb

@@ -4,7 +4,7 @@ describe "Intercom::Event" do
 
   let(:user) {Intercom::User.new("email" => "jim@example.com", :user_id => "12345", :created_at => Time.now, :name => "Jim Bob")}
   let(:created_time) {Time.now - 300}
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it 'gets events for a user' do
     client.expects(:get).with('/events', type: 'user', email: 'joe@example.com').returns(test_event_list)
@@ -12,14 +12,14 @@ describe "Intercom::Event" do
   end
 
   it "has the correct collection proxy class" do
-    client.events.collection_proxy_class.must_equal Intercom::EventCollectionProxy
+    _(client.events.collection_proxy_class).must_equal Intercom::EventCollectionProxy
   end
 
   it "stops iterating if no next link" do
     client.expects(:get).with("/events", type: 'user', email: 'joe@example.com').returns(page_of_events(false))
     event_names = []
     client.events.find_all(type: 'user', email: 'joe@example.com').each { |event| event_names << event.event_name }
-    event_names.must_equal %W(invited-friend)
+    _(event_names).must_equal %W(invited-friend)
   end
 
   it "keeps iterating if next link" do
@@ -27,7 +27,7 @@ describe "Intercom::Event" do
     client.expects(:get).with("https://api.intercom.io/events?type=user&intercom_user_id=55a3b&before=144474756550", {}).returns(page_of_events(false))
     event_names = []
     client.events.find_all(type: 'user', email: 'joe@example.com').each { |event| event_names << event.event_name }
-    event_names.must_equal %W(invited-friend invited-friend)
+    _(event_names).must_equal %W(invited-friend invited-friend)
   end
 
   it "creates an event with metadata" do
@@ -74,15 +74,15 @@ describe "Intercom::Event" do
               "state"=>"completed"
             }
           ]
-        }
+      }
     }
     let(:bulk_request) {
-       {
+      {
         items: [
           {
             method: "post",
             data_type: "event",
-            data:{
+            data: {
               event_name: "ordered-item",
               created_at: 1438944980,
               user_id: "314159",
@@ -95,7 +95,7 @@ describe "Intercom::Event" do
           {
             method: "post",
             data_type: "event",
-            data:{
+            data: {
               event_name: "invited-friend",
               created_at: 1438944979,
               user_id: "314159",
@@ -143,9 +143,7 @@ describe "Intercom::Event" do
     end
 
     it "does not submit delete jobs" do
-      lambda { client.events.submit_bulk_job(delete_items: events) }.must_raise ArgumentError
+      _(lambda { client.events.submit_bulk_job(delete_items: events) }).must_raise ArgumentError
     end
-
   end
-
 end

data/spec/unit/intercom/job_spec.rb

@@ -1,41 +1,41 @@
 require "spec_helper"
 
 describe "jobs" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
   let (:job) {
     {
-      "app_id"=>"app_id",
-      "id"=>"super_awesome_job",
-      "created_at"=>1446033421,
-      "completed_at"=>1446048736,
-      "closing_at"=>1446034321,
-      "updated_at"=>1446048736,
-      "name"=>"api_bulk_job",
-      "state"=>"completed",
-      "links"=>
+      "app_id" => "app_id",
+      "id" => "super_awesome_job",
+      "created_at" => 1446033421,
+      "completed_at" => 1446048736,
+      "closing_at" => 1446034321,
+      "updated_at" => 1446048736,
+      "name" => "api_bulk_job",
+      "state" => "completed",
+      "links" =>
         {
-          "error"=>"https://api.intercom.io/jobs/super_awesome_job/error",
-          "self"=>"https://api.intercom.io/jobs/super_awesome_job"
+          "error" => "https://api.intercom.io/jobs/super_awesome_job/error",
+          "self" => "https://api.intercom.io/jobs/super_awesome_job"
         },
-      "tasks"=>
+      "tasks" =>
         [
           {
-            "id"=>"super_awesome_task",
-            "item_count"=>2,
-            "created_at"=>1446033421,
-            "started_at"=>1446033709,
-            "completed_at"=>1446033709,
-            "state"=>"completed"
+            "id" => "super_awesome_task",
+            "item_count" => 2,
+            "created_at" => 1446033421,
+            "started_at" => 1446033709,
+            "completed_at" => 1446033709,
+            "state" => "completed"
           }
         ]
-      }
+    }
   }
   let (:error_feed) {
     {
-      "app_id"=>"app_id",
-      "job_id"=>"super_awesome_job",
-      "pages"=>{},
-      "items"=>[]
+      "app_id" => "app_id",
+      "job_id" => "super_awesome_job",
+      "pages" => {},
+      "items" => []
     }
   }
 

data/spec/unit/intercom/lead_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Intercom::Lead' do
+  let (:client) { Intercom::Client.new(token: 'token') }
+
+  it 'should be listable' do
+    proxy = client.deprecated__leads.all
+    _(proxy.resource_name).must_equal 'contacts'
+    _(proxy.resource_class).must_equal Intercom::Lead
+  end
+
+  it 'should not throw ArgumentErrors when there are no parameters' do
+    client.expects(:post)
+    client.deprecated__leads.create
+  end
+
+  it 'can update a lead with an id' do
+    lead = Intercom::Lead.new(id: 'de45ae78gae1289cb')
+    client.expects(:put).with('/contacts/de45ae78gae1289cb', 'custom_attributes' => {})
+    client.deprecated__leads.save(lead)
+  end
+
+  describe 'converting' do
+    let(:lead) { Intercom::Lead.from_api(user_id: 'contact_id') }
+    let(:user) { Intercom::User.from_api(id: 'user_id') }
+
+    it do
+      client.expects(:post).with(
+        '/contacts/convert',
+        contact: { user_id: lead.user_id },
+        user: { 'id' => user.id }
+      ).returns(test_user)
+
+      client.deprecated__leads.convert(lead, user)
+    end
+  end
+
+  it 'returns a DeprecatedLeadsCollectionProxy for all without making any requests' do
+    client.expects(:execute_request).never
+    all = client.deprecated__leads.all
+    _(all).must_be_instance_of(Intercom::DeprecatedLeadsCollectionProxy)
+  end
+
+  it 'deletes a lead' do
+    lead = Intercom::Lead.new('id' => '1')
+    client.expects(:delete).with('/contacts/1', {}).returns(lead)
+    client.deprecated__leads.delete(lead)
+  end
+
+  it 'sends a request for a hard deletion' do
+    lead = Intercom::Lead.new('id' => '1')
+    client.expects(:post).with('/user_delete_requests', intercom_user_id: '1').returns(id: lead.id)
+    client.deprecated__leads.request_hard_delete(lead)
+  end
+end

data/spec/unit/intercom/lib/flat_store_spec.rb

@@ -1,29 +1,31 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe Intercom::Lib::FlatStore do
-  it "raises if you try to set or merge in nested hash structures" do
-    data = Intercom::Lib::FlatStore.new()
-    proc { data["thing"] = [1] }.must_raise ArgumentError
-    proc { data["thing"] = {1 => 2} }.must_raise ArgumentError
-    proc { Intercom::Lib::FlatStore.new({1 => {2 => 3}}) }.must_raise ArgumentError
+  it 'raises if you try to set or merge in nested hash structures' do
+    data = Intercom::Lib::FlatStore.new
+    _(proc { data['thing'] = [1] }).must_raise ArgumentError
+    _(proc { data['thing'] = { 1 => 2 } }).must_raise ArgumentError
+    _(proc { Intercom::Lib::FlatStore.new(1 => { 2 => 3 }) }).must_raise ArgumentError
   end
 
-  it "raises if you try to use a non string key" do
-    data =Intercom::Lib::FlatStore.new()
-    proc { data[1] = "something" }.must_raise ArgumentError
+  it 'raises if you try to use a non string key' do
+    data = Intercom::Lib::FlatStore.new
+    _(proc { data[1] = 'something' }).must_raise ArgumentError
   end
 
-  it "sets and merges valid entries" do
-    data = Intercom::Lib::FlatStore.new()
-    data["a"] = 1
+  it 'sets and merges valid entries' do
+    data = Intercom::Lib::FlatStore.new
+    data['a'] = 1
     data[:b] = 2
-    data[:a].must_equal 1
-    data["b"].must_equal 2
-    data[:b].must_equal 2
-    data = Intercom::Lib::FlatStore.new({"a" => 1, :b => 2})
-    data["a"].must_equal 1
-    data[:a].must_equal 1
-    data["b"].must_equal 2
-    data[:b].must_equal 2
+    _(data[:a]).must_equal 1
+    _(data['b']).must_equal 2
+    _(data[:b]).must_equal 2
+    data = Intercom::Lib::FlatStore.new('a' => 1, :b => 2)
+    _(data['a']).must_equal 1
+    _(data[:a]).must_equal 1
+    _(data['b']).must_equal 2
+    _(data[:b]).must_equal 2
   end
 end

data/spec/unit/intercom/message_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "Intercom::Message" do
 
   let (:user) {Intercom::User.new("email" => "jim@example.com", :user_id => "12345", :created_at => Time.now, :name => "Jim Bob")}
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it 'creates an user message with symbol keys' do
     client.expects(:post).with('/messages', {'from' => { :type => 'user', :email => 'jim@example.com'}, 'body' => 'halp'}).returns(:status => 200)

data/spec/unit/intercom/note_spec.rb

@@ -1,13 +1,7 @@
 require "spec_helper"
 
 describe "notes" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
-
-  it "creates a note" do
-    client.expects(:post).with("/notes", {"body" => "Note to leave on user"}).returns({"body" => "<p>Note to leave on user</p>", "created_at" => 1234567890})
-    note = client.notes.create("body" => "Note to leave on user")
-    note.body.must_equal "<p>Note to leave on user</p>"
-  end
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it 'gets a note' do
     client.expects(:get).with("/notes/123", {}).returns({"id" => "123", "body" => "<p>Note to leave on user</p>", "created_at" => 1234567890})
@@ -18,9 +12,9 @@ describe "notes" do
     params = {"body" => "Note body", "email" => "me@example.com", :user_id => "abc123"}
     note = Intercom::Note.new(params)
 
-    note.to_hash.keys.sort.must_equal params.keys.map(&:to_s).sort
-    params.keys.each do | key|
-      note.send(key).must_equal params[key]
+    _(note.to_hash.keys.sort).must_equal params.keys.map(&:to_s).sort
+    params.keys.each do |key|
+      _(note.send(key)).must_equal params[key]
     end
   end
 end

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