intercom 3.9.5 → 4.2.1

data/spec/unit/intercom/admin_spec.rb

@@ -1,12 +1,12 @@
 require "spec_helper"
 
 describe "Intercom::Admin" 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.admins.all
-    all.must_be_instance_of(Intercom::ClientCollectionProxy)
+    _(all).must_be_instance_of(Intercom::ClientCollectionProxy)
   end
 
   it "gets me (access token method only)" do

data/spec/unit/intercom/article_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe "Intercom::Article" do
+  let(:client) { Intercom::Client.new(token: 'token') }
+
+  describe "Getting an Article" do
+    it "successfully finds an article" do
+      client.expects(:get).with("/articles/1", {}).returns(test_article)
+      client.articles.find(id: "1")
+    end
+  end
+
+  describe "Creating an Article" do
+    it "successfully creates and article with information passed individually" do
+      client.expects(:post).with("/articles", {"title" => "new title", "author_id" => 1, "body" => "<p>thingbop</p>", "state" => "draft"}).returns(test_article)
+      client.articles.create(:title => "new title", :author_id => 1, :body => "<p>thingbop</p>", :state => "draft")
+    end
+
+    it "successfully creates and article with information in json" do
+      client.expects(:post).with("/articles", {"title" => "new title", "author_id" => 1, "body" => "<p>thingbop</p>", "state" => "draft"}).returns(test_article)
+      client.articles.create({title: "new title", author_id: 1, body: "<p>thingbop</p>", state: "draft"})
+    end
+  end
+
+  describe "Updating an article" do
+    it "successfully updates an article" do
+      article = Intercom::Article.new(id: 12345)
+      client.expects(:put).with('/articles/12345', {})
+      client.articles.save(article)
+    end
+  end
+
+  describe "Deleting an article" do
+    it "successfully deletes an article" do
+      article = Intercom::Article.new(id: 12345)
+      client.expects(:delete).with('/articles/12345', {})
+      client.articles.delete(article)
+    end
+  end
+end

data/spec/unit/intercom/base_collection_proxy_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Intercom::BaseCollectionProxy do
+  let(:client) { Intercom::Client.new(token: 'token') }
+
+  it "stops iterating if no starting after value" do
+    client.expects(:get).with("/contacts", {}).returns(page_of_contacts(false))
+    emails = []
+    client.contacts.all.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(:get).with("/contacts", {}).returns(page_of_contacts(true))
+    client.expects(:get).with('/contacts', { starting_after: "EnCrYpTeDsTrInG" }).returns(page_of_contacts(false))
+    emails = []
+    client.contacts.all.each { |contact| emails << contact.email }
+    _(emails).must_equal %w[test1@example.com test2@example.com test3@example.com test1@example.com test2@example.com test3@example.com]
+  end
+
+  it "supports indexed array access" do
+    client.expects(:get).with("/contacts", {}).returns(page_of_contacts(false))
+    _(client.contacts.all[0].email).must_equal "test1@example.com"
+  end
+
+  it "supports map" do
+    client.expects(:get).with("/contacts", {}).returns(page_of_contacts(false))
+    emails = client.contacts.all.map { |contact| contact.email }
+    _(emails).must_equal %w[test1@example.com test2@example.com test3@example.com]
+  end
+
+  it "keeps entire collection iterable after first iteration" do
+    contacts = client.contacts.all
+    emails_iter1 = []
+    emails_iter2 = []
+    expects_pagination = proc do
+      client.expects(:get).with("/contacts", {}).returns(page_of_contacts(true))
+      client.expects(:get).with("/contacts", { starting_after: "EnCrYpTeDsTrInG" }).returns(page_of_contacts(false))
+    end
+
+    expects_pagination.call
+    contacts.each { |contact| emails_iter1 << contact.email }
+    expects_pagination.call
+    contacts.each { |contact| emails_iter2 << contact.email }
+    _(emails_iter1).must_equal emails_iter2
+  end
+
+  it "supports query params" do
+    client.expects(:get).with("/conversations", {:intercom_user_id => 'abcdef0000'}).returns(test_conversation_list)
+    _(client.conversations.find_all(:intercom_user_id => 'abcdef0000').map(&:id)).must_equal %w[147]
+  end
+end

data/spec/unit/intercom/client_collection_proxy_spec.rb

@@ -1,80 +1,80 @@
 require "spec_helper"
 
 describe Intercom::ClientCollectionProxy 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 next link" do
-    client.expects(:get).with("/users", {}).returns(page_of_users(false))
-    emails = []
-    client.users.all.each { |user| emails << user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+    client.expects(:get).with("/companies", {}).returns(page_of_companies(false))
+    names = []
+    client.companies.all.each { |company| names << company.name }
+    _(names).must_equal %W(company1 company2 company3)
   end
 
   it "keeps iterating if next link" do
-    client.expects(:get).with("/users", {}).returns(page_of_users(true))
-    client.expects(:get).with('https://api.intercom.io/users?per_page=50&page=2', {}).returns(page_of_users(false))
-    emails = []
-    client.users.all.each { |user| emails << user.email }
+    client.expects(:get).with("/companies", {}).returns(page_of_companies(true))
+    client.expects(:get).with('https://api.intercom.io/companies?per_page=50&page=2', {}).returns(page_of_companies(false))
+    names = []
+    client.companies.all.each { |company| names << company.name }
   end
 
   it "supports indexed array access" do
-    client.expects(:get).with("/users", {}).returns(page_of_users(false))
-    client.users.all[0].email.must_equal 'user1@example.com'
+    client.expects(:get).with("/companies", {}).returns(page_of_companies(false))
+    _(client.companies.all[0].name).must_equal 'company1'
   end
 
   it "supports map" do
-    client.expects(:get).with("/users", {}).returns(page_of_users(false))
-    emails = client.users.all.map { |user| user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+    client.expects(:get).with("/companies", {}).returns(page_of_companies(false))
+    names = client.companies.all.map { |company| company.name }
+    _(names).must_equal %W(company1 company2 company3)
   end
 
   it "supports querying" do
-    client.expects(:get).with("/users", {:tag_name => 'Taggart J'}).returns(page_of_users(false))
-    client.users.find_all(:tag_name => 'Taggart J').map(&:email).must_equal %W(user1@example.com user2@example.com user3@example.com)
+    client.expects(:get).with("/companies", {:tag_name => 'Taggart J'}).returns(page_of_companies(false))
+    _(client.companies.find_all(:tag_name => 'Taggart J').map(&:name)).must_equal %W(company1 company2 company3)
   end
 
   it "supports single page pagination" do
-    users = [test_user("user1@example.com"), test_user("user2@example.com"), test_user("user3@example.com"),
-     test_user("user4@example.com"), test_user("user5@example.com"), test_user("user6@example.com"),
-     test_user("user7@example.com"), test_user("user8@example.com"), test_user("user9@example.com"),
-     test_user("user10@example.com")]
-    client.expects(:get).with("/users", {:type=>'users', :per_page => 10, :page => 1}).returns(users_pagination(include_next_link: false, per_page: 10, page: 1, total_pages: 1, total_count: 10, user_list: users))
-    result = client.users.find_all(:type=>'users', :per_page => 10, :page => 1).map {|user| user.email }
-    result.must_equal %W(user1@example.com user2@example.com user3@example.com user4@example.com user5@example.com user6@example.com user7@example.com user8@example.com user9@example.com user10@example.com)
+    companies = [test_company("company1"), test_company("company2"), test_company("company3"),
+     test_company("company4"), test_company("company5"), test_company("company6"),
+     test_company("company7"), test_company("company8"), test_company("company9"),
+     test_company("company10")]
+    client.expects(:get).with("/companies", {:type=>'companies', :per_page => 10, :page => 1}).returns(companies_pagination(include_next_link: false, per_page: 10, page: 1, total_pages: 1, total_count: 10, company_list: companies))
+    result = client.companies.find_all(:type=>'companies', :per_page => 10, :page => 1).map {|company| company.name }
+    _(result).must_equal %W(company1 company2 company3 company4 company5 company6 company7 company8 company9 company10)
   end
 
   it "supports multi page pagination" do
-    users = [test_user("user3@example.com"), test_user("user4@example.com")]
-    client.expects(:get).with("/users", {:type=>'users', :per_page => 2, :page => 3}).returns(users_pagination(include_next_link: true, per_page: 2, page: 3, total_pages: 5, total_count: 10, user_list: users))
-    result = client.users.find_all(:type=>'users', :per_page => 2, :page => 3).map {|user| user.email }
-    result.must_equal %W(user3@example.com user4@example.com)
+    companies = [test_company("company3"), test_company("company4")]
+    client.expects(:get).with("/companies", {:type=>'companies', :per_page => 2, :page => 3}).returns(companies_pagination(include_next_link: true, per_page: 2, page: 3, total_pages: 5, total_count: 10, company_list: companies))
+    result = client.companies.find_all(:type=>'companies', :per_page => 2, :page => 3).map {|company| company.name }
+    _(result).must_equal %W(company3 company4)
   end
 
   it "works with page out of range request" do
-    users = []
-    client.expects(:get).with("/users", {:type=>'users', :per_page => 2, :page => 30}).returns(users_pagination(include_next_link: true, per_page: 2, page: 30, total_pages: 2, total_count: 3, user_list: users))
-    result = client.users.find_all(:type=>'users', :per_page => 2, :page => 30).map {|user| user.email }
-    result.must_equal %W()
+    companies = []
+    client.expects(:get).with("/companies", {:type=>'companies', :per_page => 2, :page => 30}).returns(companies_pagination(include_next_link: true, per_page: 2, page: 30, total_pages: 2, total_count: 3, company_list: companies))
+    result = client.companies.find_all(:type=>'companies', :per_page => 2, :page => 30).map {|company| company.name }
+    _(result).must_equal %W()
   end
 
   it "works with asc order" do
     test_date=1457337600
     time_increment=1000
-    users = [test_user_dates(email="user1@example.com", created_at=test_date), test_user_dates(email="user2@example.com", created_at=test_date-time_increment),
-             test_user_dates(email="user3@example.com", created_at=test_date-2*time_increment), test_user_dates(email="user4@example.com", created_at=test_date-3*time_increment)]
-    client.expects(:get).with("/users", {:type=>'users', :per_page => 4, :page => 5, :order => "asc", :sort => "created_at"}).returns(users_pagination(include_next_link: true, per_page: 4, page: 5, total_pages: 6, total_count: 30, user_list: users))
-    result = client.users.find_all(:type=>'users', :per_page => 4, :page => 5, :order => "asc", :sort => "created_at").map(&:email)
-    result.must_equal %W(user1@example.com user2@example.com user3@example.com user4@example.com)
+    companies = [test_company_dates(name="company1", created_at=test_date), test_company_dates(name="company2", created_at=test_date-time_increment),
+             test_company_dates(name="company3", created_at=test_date-2*time_increment), test_company_dates(name="company4", created_at=test_date-3*time_increment)]
+    client.expects(:get).with("/companies", {:type=>'companies', :per_page => 4, :page => 5, :order => "asc", :sort => "created_at"}).returns(companies_pagination(include_next_link: true, per_page: 4, page: 5, total_pages: 6, total_count: 30, company_list: companies))
+    result = client.companies.find_all(:type=>'companies', :per_page => 4, :page => 5, :order => "asc", :sort => "created_at").map(&:name)
+    _(result).must_equal %W(company1 company2 company3 company4)
   end
 
   it "works with desc order" do
     test_date=1457337600
     time_increment=1000
-    users = [test_user_dates(email="user4@example.com", created_at=3*test_date), test_user_dates(email="user3@example.com", created_at=test_date-2*time_increment),
-             test_user_dates(email="user2@example.com", created_at=test_date-time_increment), test_user_dates(email="user1@example.com", created_at=test_date)]
-    client.expects(:get).with("/users", {:type=>'users', :per_page => 4, :page => 5, :order => "desc", :sort => "created_at"}).returns(users_pagination(include_next_link: true, per_page: 4, page: 5, total_pages: 6, total_count: 30, user_list: users))
-    result = client.users.find_all(:type=>'users', :per_page => 4, :page => 5, :order => "desc", :sort => "created_at").map {|user| user.email }
-    result.must_equal %W(user4@example.com user3@example.com user2@example.com user1@example.com)
+    companies = [test_company_dates(name="company4", created_at=3*test_date), test_company_dates(name="company3", created_at=test_date-2*time_increment),
+             test_company_dates(name="company2", created_at=test_date-time_increment), test_company_dates(name="company1", created_at=test_date)]
+    client.expects(:get).with("/companies", {:type=>'companies', :per_page => 4, :page => 5, :order => "desc", :sort => "created_at"}).returns(companies_pagination(include_next_link: true, per_page: 4, page: 5, total_pages: 6, total_count: 30, company_list: companies))
+    result = client.companies.find_all(:type=>'companies', :per_page => 4, :page => 5, :order => "desc", :sort => "created_at").map {|company| company.name }
+    _(result).must_equal %W(company4 company3 company2 company1)
   end
 
 end

data/spec/unit/intercom/client_spec.rb

@@ -1,19 +1,19 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Intercom
   describe Client do
-    let(:app_id) { 'myappid' }
-    let(:api_key) { 'myapikey' }
+    let(:token) { 'my_access_token' }
     let(:client) do
       Client.new(
-        app_id: app_id,
-        api_key: api_key,
+        token: token,
         handle_rate_limit: true
       )
     end
 
     it 'should set the base url' do
-      client.base_url.must_equal('https://api.intercom.io')
+      _(client.base_url).must_equal('https://api.intercom.io')
     end
 
     it 'should have handle_rate_limit set' do
@@ -22,34 +22,34 @@ module Intercom
 
     it 'should be able to change the base url' do
       prev = client.options(Intercom::Client.set_base_url('https://mymockintercom.io'))
-      client.base_url.must_equal('https://mymockintercom.io')
+      _(client.base_url).must_equal('https://mymockintercom.io')
       client.options(prev)
-      client.base_url.must_equal('https://api.intercom.io')
+      _(client.base_url).must_equal('https://api.intercom.io')
     end
 
     it 'should be able to change the timeouts' do
       prev = client.options(Intercom::Client.set_timeouts(open_timeout: 10, read_timeout: 15))
-      client.timeouts.must_equal(open_timeout: 10, read_timeout: 15)
+      _(client.timeouts).must_equal(open_timeout: 10, read_timeout: 15)
       client.options(prev)
-      client.timeouts.must_equal(open_timeout: 30, read_timeout: 90)
+      _(client.timeouts).must_equal(open_timeout: 30, read_timeout: 90)
     end
 
     it 'should be able to change the open timeout individually' do
       prev = client.options(Intercom::Client.set_timeouts(open_timeout: 50))
-      client.timeouts.must_equal(open_timeout: 50, read_timeout: 90)
+      _(client.timeouts).must_equal(open_timeout: 50, read_timeout: 90)
       client.options(prev)
-      client.timeouts.must_equal(open_timeout: 30, read_timeout: 90)
+      _(client.timeouts).must_equal(open_timeout: 30, read_timeout: 90)
     end
 
     it 'should be able to change the read timeout individually' do
       prev = client.options(Intercom::Client.set_timeouts(read_timeout: 50))
-      client.timeouts.must_equal(open_timeout: 30, read_timeout: 50)
+      _(client.timeouts).must_equal(open_timeout: 30, read_timeout: 50)
       client.options(prev)
-      client.timeouts.must_equal(open_timeout: 30, read_timeout: 90)
+      _(client.timeouts).must_equal(open_timeout: 30, read_timeout: 90)
     end
 
     it 'should raise on nil credentials' do
-      proc { Client.new(app_id: nil, api_key: nil) }.must_raise MisconfiguredClientError
+      _(proc { Client.new(token: nil) }).must_raise MisconfiguredClientError
     end
 
     describe 'API version' do
@@ -58,42 +58,41 @@ module Intercom
       end
 
       it 'allows api version to be provided' do
-        Client.new(app_id: app_id, api_key: api_key, api_version: '1.0').api_version.must_equal('1.0')
+        _(Client.new(token: token, api_version: '2.0').api_version).must_equal('2.0')
       end
 
       it 'allows api version to be nil' do
         # matches default behavior, and will honor version set in the Developer Hub
-        assert_nil(Client.new(app_id: app_id, api_key: api_key, api_version: nil).api_version)
+        assert_nil(Client.new(token: token, api_version: nil).api_version)
       end
 
       it 'allows api version to be Unstable' do
-        Client.new(app_id: app_id, api_key: api_key, api_version: 'Unstable').api_version.must_equal('Unstable')
+        _(Client.new(token: token, api_version: 'Unstable').api_version).must_equal('Unstable')
       end
 
       it 'raises on invalid api version' do
-        proc { Client.new(app_id: app_id, api_key: api_key, api_version: '0.2') }.must_raise MisconfiguredClientError
+        _(proc { Client.new(token: token, api_version: '0.2') }).must_raise MisconfiguredClientError
       end
 
       it 'raises on empty api version' do
-        proc { Client.new(app_id: app_id, api_key: api_key, api_version: '') }.must_raise MisconfiguredClientError
+        _(proc { Client.new(token: token, api_version: '') }).must_raise MisconfiguredClientError
       end
 
-      it "assigns works" do
-        stub_request(:any, "https://api.intercom.io/users?id=123").to_return(
-          status: [200, "OK"],
+      it 'assigns works' do
+        stub_request(:any, 'https://api.intercom.io/contacts?id=123').to_return(
+          status: [200, 'OK'],
           headers: { 'X-RateLimit-Reset' => Time.now.utc + 10 },
-          body: { "test": "testing" }.to_json
+          body: { "test": 'testing' }.to_json
         )
 
-        client.get("/users", { id: "123" })
+        client.get('/contacts', id: '123')
       end
     end
 
     describe 'OAuth clients' do
       it 'supports "token"' do
         client = Client.new(token: 'foo')
-        client.username_part.must_equal('foo')
-        client.password_part.must_equal('')
+        _(client.token).must_equal('foo')
       end
     end
   end

data/spec/unit/intercom/collection_spec.rb

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

data/spec/unit/intercom/company_spec.rb

@@ -1,40 +1,44 @@
 require "spec_helper"
 
 describe Intercom::Company do
-  let (:client) { Intercom::Client.new(app_id: "app_id",  api_key: "api_key") }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   describe "when no response raises error" do
     it "on find" do
       client.expects(:get).with("/companies", {:company_id => "4"}).returns(nil)
-      proc {client.companies.find(:company_id => "4")}.must_raise Intercom::HttpError
+      _(proc { client.companies.find(:company_id => "4")}).must_raise Intercom::HttpError
     end
 
-    it "on find_all" do
+    it "on all" do
       client.expects(:get).with("/companies", {}).returns(nil)
-      proc {client.companies.all.each {|company| }}.must_raise Intercom::HttpError
+      _(proc { client.companies.all.each {|company| }}).must_raise Intercom::HttpError
     end
 
     it "on load" do
       client.expects(:get).with("/companies", {:company_id => "4"}).returns({"type" =>"user", "id" =>"aaaaaaaaaaaaaaaaaaaaaaaa", "company_id" => "4", "name" => "MyCo"})
       company = client.companies.find(:company_id => "4")
       client.expects(:get).with("/companies/aaaaaaaaaaaaaaaaaaaaaaaa", {}).returns(nil)
-      proc {client.companies.load(company)}.must_raise Intercom::HttpError
+      _(proc { client.companies.load(company)}).must_raise Intercom::HttpError
     end
   end
 
-  it "gets users in a company by intercom ID" do
-    client.expects(:get).with("/companies/abc123/users", {}).returns(page_of_users(false))
-    client.companies.users_by_intercom_company_id("abc123").each { |u| }
+  it "finds a company" do
+    client.expects(:get).with("/companies/531ee472cce572a6ec000006", {}).returns(test_company)
+    company = client.companies.find(id: "531ee472cce572a6ec000006")
+    _(company.name).must_equal("Blue Sun")
   end
 
-  it "gets users in a company by external company ID" do
-    client.expects(:get).with("/companies", { company_id: "abc123", type: "user" }).returns(page_of_users(false))
-    client.companies.users_by_company_id("abc123").each { |u| }
+  it "returns a collection proxy for listing contacts" do
+    company = Intercom::Company.new("id" => "1")
+    proxy = company.contacts
+    _(proxy.resource_name).must_equal 'contacts'
+    _(proxy.url).must_equal '/companies/1/contacts'
+    _(proxy.resource_class).must_equal Intercom::Contact
   end
 
-  it "finds a company" do
-    client.expects(:get).with("/companies/531ee472cce572a6ec000006", {}).returns(test_company)
-    company = client.companies.find(id: "531ee472cce572a6ec000006")
-    company.name.must_equal("Blue Sun")
+  it "deletes a company" do
+    company = Intercom::Company.new("id" => "1")
+    client.expects(:delete).with("/companies/1", {})
+    client.companies.delete(company)
   end
 end