intercom 3.5.10 → 3.9.5

data/spec/unit/intercom/client_collection_proxy_spec.rb

@@ -38,21 +38,21 @@ describe Intercom::ClientCollectionProxy do
      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(false, per_page=10, page=1, total_pages=1, total_count=10, user_list=users))
+    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)
   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(true, per_page=2, page=3, total_pages=5, total_count=10, user_list=users))
+    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)
   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(true, per_page=2, page=30, total_pages=2, total_count=3, user_list=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()
   end
@@ -62,7 +62,7 @@ describe Intercom::ClientCollectionProxy do
     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(true, per_page=4, page=5, total_pages=6, total_count=30, user_list=users))
+    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)
   end
@@ -72,7 +72,7 @@ describe Intercom::ClientCollectionProxy do
     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(true, per_page=4, page=5, total_pages=6, total_count=30, user_list=users))
+    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)
   end

data/spec/unit/intercom/client_spec.rb

@@ -4,12 +4,22 @@ module Intercom
   describe Client do
     let(:app_id) { 'myappid' }
     let(:api_key) { 'myapikey' }
-    let(:client) { Client.new(app_id: app_id, api_key: api_key) }
+    let(:client) do
+      Client.new(
+        app_id: app_id,
+        api_key: api_key,
+        handle_rate_limit: true
+      )
+    end
 
     it 'should set the base url' do
       client.base_url.must_equal('https://api.intercom.io')
     end
 
+    it 'should have handle_rate_limit set' do
+      _(client.handle_rate_limit).must_equal(true)
+    end
+
     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')
@@ -17,10 +27,68 @@ module Intercom
       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.options(prev)
+      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.options(prev)
+      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.options(prev)
+      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
     end
 
+    describe 'API version' do
+      it 'does not set the api version by default' do
+        assert_nil(client.api_version)
+      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')
+      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)
+      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')
+      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
+      end
+
+      it 'raises on empty api version' do
+        proc { Client.new(app_id: app_id, api_key: api_key, 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"],
+          headers: { 'X-RateLimit-Reset' => Time.now.utc + 10 },
+          body: { "test": "testing" }.to_json
+        )
+
+        client.get("/users", { id: "123" })
+      end
+    end
+
     describe 'OAuth clients' do
       it 'supports "token"' do
         client = Client.new(token: 'foo')

data/spec/unit/intercom/company_spec.rb

@@ -1,36 +1,40 @@
-require 'spec_helper'
+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(app_id: "app_id",  api_key: "api_key") }
 
-  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
+  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
     end
 
-    it 'on find_all' do
+    it "on find_all" do
       client.expects(:get).with("/companies", {}).returns(nil)
       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)
+    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
     end
   end
 
-  it 'gets users in a company' do
+  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('abc123').each do |u|
-    end
+    client.companies.users_by_intercom_company_id("abc123").each { |u| }
+  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| }
   end
 
-  it 'finds a company' do
+  it "finds a company" do
     client.expects(:get).with("/companies/531ee472cce572a6ec000006", {}).returns(test_company)
-    company = client.companies.find(id: '531ee472cce572a6ec000006')
+    company = client.companies.find(id: "531ee472cce572a6ec000006")
     company.name.must_equal("Blue Sun")
   end
 end

data/spec/unit/intercom/contact_spec.rb

@@ -50,4 +50,10 @@ describe "Intercom::Contact" do
     client.contacts.delete(contact)
   end
 
+  it "sends a request for a hard deletion" do
+    contact = Intercom::Contact.new("id" => "1")
+    client.expects(:post).with("/user_delete_requests", {intercom_user_id: "1"}).returns({id: contact.id})
+    client.contacts.request_hard_delete(contact)
+  end
+
 end

data/spec/unit/intercom/conversation_spec.rb

@@ -8,6 +8,11 @@ describe "Intercom::Conversation" do
     client.conversations.find(:id => "147")
   end
 
+  it "gets all conversations" do
+    client.expects(:get).with("/conversations", {}).returns(test_conversation_list)
+    client.conversations.all.each { |c| }
+  end
+
   it 'marks a conversation as read' do
     client.expects(:put).with('/conversations/147', { read: true })
     client.conversations.mark_read('147')
@@ -23,6 +28,11 @@ describe "Intercom::Conversation" do
     client.conversations.reply(id: '147', type: 'user', body: 'Thanks again', message_type: 'comment', user_id: 'ac4', attachment_urls: ["http://www.example.com/attachment.jpg"])
   end
 
+  it 'sends a reply to a users last conversation from an admin' do
+    client.expects(:post).with('/conversations/last/reply', { type: 'admin', body: 'Thanks again', message_type: 'comment', user_id: 'ac4', admin_id: '123' }).returns(test_conversation)
+    client.conversations.reply_to_last(type: 'admin', body: 'Thanks again', message_type: 'comment', user_id: 'ac4', admin_id: '123')
+  end
+
   it 'opens a conversation' do
     client.expects(:post).with('/conversations/147/reply', { type: 'admin', message_type: 'open', conversation_id: '147', admin_id: '123'}).returns(test_conversation)
     client.conversations.open(id: '147', admin_id: '123')
@@ -38,6 +48,11 @@ describe "Intercom::Conversation" do
     client.conversations.assign(id: '147', admin_id: '123', assignee_id: '124')
   end
 
+  it 'snoozes a conversation' do
+    client.expects(:post).with('/conversations/147/reply', { type: 'admin', message_type: 'snoozed', conversation_id: '147', admin_id: '123', snoozed_until: tomorrow}).returns(test_conversation)
+    client.conversations.snooze(id: '147', admin_id: '123', snoozed_until: tomorrow)
+  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"])

data/spec/unit/intercom/event_spec.rb

@@ -11,6 +11,25 @@ describe "Intercom::Event" do
     client.events.find_all(type: 'user', email: 'joe@example.com').first
   end
 
+  it "has the correct collection proxy class" do
+    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)
+  end
+
+  it "keeps iterating if next link" do
+    client.expects(:get).with("/events", type: 'user', email: 'joe@example.com').returns(page_of_events(true))
+    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)
+  end
+
   it "creates an event with metadata" do
     client.expects(:post).with('/events', {'event_name' => 'Eventful 1', 'created_at' => created_time.to_i, 'email' => 'joe@example.com', 'metadata' => {'invitee_email' => 'pi@example.org', :invite_code => 'ADDAFRIEND', 'found_date' => 12909364407}}).returns(:status => 202)
 

data/spec/unit/intercom/request_spec.rb

@@ -1,16 +1,157 @@
 require 'spec_helper'
 require 'ostruct'
 
-describe 'Intercom::Request' do
-  it 'raises an error when a html error page rendered' do
-    response = OpenStruct.new(:code => 500)
-    req = Intercom::Request.new('path/', 'GET')
-    proc {req.parse_body('<html>somethjing</html>', response)}.must_raise(Intercom::ServerError)
+WebMock.enable!
+
+describe 'Intercom::Request', '#execute' do
+  let(:uri) {"https://api.intercom.io/users"}
+  let(:req) { Intercom::Request.get(uri, {}) }
+  let(:default_body) { { data: "test" }.to_json }
+
+  def execute!
+    req.execute(uri, username: 'ted', secret: '')
+  end
+
+  it 'should call sleep for rate limit error three times and raise a rate limit error otherwise' do
+    stub_request(:any, uri).to_return(
+      status: [429, "Too Many Requests"],
+      headers: { 'X-RateLimit-Reset' => (Time.now.utc + 10).to_i.to_s },
+      body: default_body
+    )
+
+    req.handle_rate_limit=true
+
+    req.expects(:sleep).times(3).with(any_parameters)
+
+    expect { execute! }.must_raise(Intercom::RateLimitExceeded)
+  end
+
+  it 'should not call sleep for rate limit error' do
+    stub_request(:any, uri).to_return(
+      status: [200, "OK"],
+      headers: { 'X-RateLimit-Reset' => Time.now.utc + 10 },
+      body: default_body
+    )
+
+    req.handle_rate_limit=true
+    req.expects(:sleep).never.with(any_parameters)
+
+    execute!
+  end
+
+  it 'should call sleep for rate limit error just once' do
+    stub_request(:any, uri).to_return(
+      status: [429, "Too Many Requests"],
+      headers: { 'X-RateLimit-Reset' => (Time.now.utc + 10).to_i.to_s },
+    ).then.to_return(status: [200, "OK"], body: default_body)
+
+    req.handle_rate_limit=true
+    req.expects(:sleep).with(any_parameters)
+
+    execute!
   end
 
-  it 'parse_body returns nil if decoded_body is nil' do
-    response = OpenStruct.new(:code => 500)
-    req = Intercom::Request.new('path/', 'GET')
-    req.parse_body(nil, response).must_equal(nil)
+  it 'should not sleep if rate limit reset time has passed' do
+    stub_request(:any, uri).to_return(
+      status: [429, "Too Many Requests"],
+      headers: { 'X-RateLimit-Reset' => Time.parse("February 25 2010").utc.to_i.to_s },
+      body: default_body
+    ).then.to_return(status: [200, "OK"], body: default_body)
+
+    req.handle_rate_limit=true
+    req.expects(:sleep).never.with(any_parameters)
+
+    execute!
+  end
+
+  it 'handles an empty body gracefully' do
+    stub_request(:any, uri).to_return(
+      status: 200,
+      body: nil
+    )
+
+    assert_nil(execute!)
+  end
+
+  describe 'HTTP error handling' do
+    it 'raises an error when the response is successful but the body is not JSON' do
+      stub_request(:any, uri).to_return(
+        status: 200,
+        body: '<html>something</html>'
+      )
+
+      expect { execute! }.must_raise(Intercom::UnexpectedResponseError)
+    end
+
+    it 'raises an error when an html error page rendered' do
+      stub_request(:any, uri).to_return(
+        status: 500,
+        body: '<html>something</html>'
+      )
+
+      expect { execute! }.must_raise(Intercom::ServerError)
+    end
+
+    it 'raises an error if the decoded_body is "null"' do
+      stub_request(:any, uri).to_return(
+        status: 500,
+        body: 'null'
+      )
+
+      expect { execute! }.must_raise(Intercom::ServerError)
+    end
+
+    it 'raises a RateLimitExceeded error when the response code is 429' do
+      stub_request(:any, uri).to_return(
+        status: 429,
+        body: 'null'
+      )
+
+      expect { execute! }.must_raise(Intercom::RateLimitExceeded)
+    end
+
+    it 'raises a GatewayTimeoutError error when the response code is 504' do
+      stub_request(:any, uri).to_return(
+        status: 504,
+        body: '<html> <head><title>504 Gateway Time-out</title></head> <body bgcolor="white"> <center><h1>504 Gateway Time-out</h1></center> </body> </html>'
+      )
+
+      expect { execute! }.must_raise(Intercom::GatewayTimeoutError)
+    end
+  end
+
+  describe "application error handling" do
+    let(:uri) {"https://api.intercom.io/conversations/reply"}
+    let(:req) { Intercom::Request.put(uri, {}) }
+
+    it 'should raise ResourceNotUniqueError error on resource_conflict code' do
+      stub_request(:put, uri).to_return(
+        status: [409, "Resource Already Exists"],
+        headers: { 'X-RateLimit-Reset' => (Time.now.utc + 10).to_i.to_s },
+        body: { type: "error.list", errors: [ code: "resource_conflict" ] }.to_json
+      )
+
+      expect { execute! }.must_raise(Intercom::ResourceNotUniqueError)
+    end
+
+    it 'should raise ApiVersionInvalid error on intercom_version_invalid code' do
+      stub_request(:put, uri).to_return(
+        status: [400, "Bad Request"],
+        headers: { 'X-RateLimit-Reset' => (Time.now.utc + 10).to_i.to_s },
+        body: { type: "error.list", errors: [ code: "intercom_version_invalid" ] }.to_json
+      )
+
+      expect { execute! }.must_raise(Intercom::ApiVersionInvalid)
+    end
+
+    it 'should raise ResourceNotFound error on company_not_found code' do
+      stub_request(:put, uri).to_return(
+        status: [404, "Not Found"],
+        headers: { 'X-RateLimit-Reset' => (Time.now.utc + 10).to_i.to_s },
+        body: { type: "error.list", errors: [ code: "company_not_found" ] }.to_json
+      )
+
+      expect { execute! }.must_raise(Intercom::ResourceNotFound)
+    end
   end
 end

data/spec/unit/intercom/search_collection_proxy_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Intercom::SearchCollectionProxy do
+  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+
+  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
+  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
+  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
+  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
+  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
+  end
+
+  it "stops iterating if no starting_after value" do
+    client.expects(:post).with("/customers/search", { query: {} }).  returns(page_of_customers(false))
+    emails = []
+    client.customers.search(query: {}).each { |user| emails << user.email }
+    emails.must_equal %W(user1@example.com user2@example.com user3@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))
+    emails = []
+    client.customers.search(query: {}).each { |user| emails << user.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'
+  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)
+  end
+
+end