intercom 3.5.10 → 4.1.2

data/spec/unit/intercom/conversation_spec.rb

@@ -1,13 +1,18 @@
 require 'spec_helper'
 
 describe "Intercom::Conversation" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it "gets a conversation" do
     client.expects(:get).with("/conversations/147", {}).returns(test_conversation)
     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,11 +48,64 @@ describe "Intercom::Conversation" do
     client.conversations.assign(id: '147', admin_id: '123', assignee_id: '124')
   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"
-  # 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 'runs assignment rules on a conversation' do
+    client.expects(:post).with('/conversations/147/run_assignment_rules', {}).returns(test_conversation)
+    client.conversations.run_assignment_rules('147')
+  end
+
+  describe 'nested resources' do
+    let(:conversation) { Intercom::Conversation.new('id' => '1', 'client' => client) }
+    let(:tag) { Intercom::Tag.new('id' => '1') }
 
+    it 'adds a tag to a conversation' do
+      client.expects(:post).with("/conversations/1/tags", { 'id': tag.id, 'admin_id': test_admin['id'] }).returns(tag.to_hash)
+      conversation.add_tag({ "id": tag.id,  "admin_id": test_admin['id'] })
+    end
+
+    it 'does not add a tag to a conversation if no admin_id is passed' do
+      client.expects(:post).with("/conversations/1/tags", { 'id': tag.id }).returns(nil)
+      _(proc { conversation.add_tag({ "id": tag.id }) }).must_raise Intercom::HttpError
+    end
+
+    it 'removes a tag from a conversation' do
+      client.expects(:delete).with("/conversations/1/tags/1", { "id": tag.id, "admin_id": test_admin['id'] }).returns(tag.to_hash)
+      conversation.remove_tag({ "id": tag.id, "admin_id": test_admin['id'] })
+    end
+
+    it 'does not remove a tag from a conversation if no admin_id is passed' do
+      client.expects(:delete).with("/conversations/1/tags/1", { "id": tag.id }).returns(nil)
+      _(proc { conversation.remove_tag({ "id": tag.id }) }).must_raise Intercom::HttpError
+    end
+
+    describe 'contacts' do
+      let(:response) do
+        {
+          customers: [
+            { type: test_contact['type'], id: test_contact['id'] }
+          ]
+        }
+      end
+
+      it 'adds a contact to a conversation' do
+        client.expects(:post)
+              .with("/conversations/1/customers",
+                    { admin_id: test_admin['id'], customer: { intercom_user_id: test_contact['id'] } })
+              .returns(response.to_hash)
+        conversation.add_contact(admin_id: test_admin['id'], customer: { intercom_user_id: test_contact['id'] })
+      end
+
+      it 'removes a contact from a conversation' do
+        client.expects(:delete)
+              .with("/conversations/1/customers/aaaaaaaaaaaaaaaaaaaaaaaa",
+                    { id: 'aaaaaaaaaaaaaaaaaaaaaaaa', admin_id: '1234' })
+              .returns(response.to_hash)
+        conversation.remove_contact(id: test_contact['id'], admin_id: test_admin['id'])
+      end
+    end
+  end
 end

data/spec/unit/intercom/count_spec.rb

@@ -1,24 +1,24 @@
 require "spec_helper"
 
 describe "Intercom::Count" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it 'should get app wide counts' do
     client.expects(:get).with("/counts", {}).returns(test_app_count)
     counts = client.counts.for_app
-    counts.tag['count'].must_equal(341)
+    _(counts.tag['count']).must_equal(341)
   end
 
   it 'should get type counts' do
     client.expects(:get).with("/counts", {type: 'user', count: 'segment'}).returns(test_segment_count)
     counts = client.counts.for_type(type: 'user', count: 'segment')
-    counts.user['segment'][4]["segment 1"].must_equal(1)
+    _(counts.user['segment'][4]["segment 1"]).must_equal(1)
   end
 
   it 'should not include count param when nil' do
     client.expects(:get).with("/counts", {type: 'conversation'}).returns(test_conversation_count)
     counts = client.counts.for_type(type: 'conversation')
-    counts.conversation.must_equal({
+    _(counts.conversation).must_equal({
       "assigned" => 1,
       "closed" => 15,
       "open" => 1,

data/spec/unit/intercom/data_attribute_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe "Intercom::DataAttribute" do
+  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.data_attributes.all
+    _(all).must_be_instance_of(Intercom::ClientCollectionProxy)
+  end
+
+
+  it "creates a new data attribute" do
+    client.expects(:post).with("/data_attributes", { "name" => "blah", "model" => "contact", "data_type" => "string" }).returns(status: 200)
+    client.data_attributes.create("name": "blah",
+                                  "model": "contact",
+                                  "data_type": "string" )
+  end
+
+  it "updates an existing attribute" do
+    attribute = Intercom::DataAttribute.new("id": 123,
+                                            "name": "blah",
+                                            "model": "contact",
+                                            "data_type": "string")
+    client.expects(:put).with("/data_attributes/#{attribute.id}", { "name" => "New name", "model" => "contact", "data_type" => "string" })
+    attribute.name = "New name"
+    client.data_attributes.save(attribute)
+    _(attribute.name).must_equal "New name"
+  end
+
+  it 'gets a list of attributes' do
+    client.expects(:get).with("/data_attributes", {}).returns(test_data_attribute_list)
+    client.data_attributes.all.each { |d| }
+  end
+
+  it 'finds all customer or company attributes' do
+    client.expects(:get).with("/data_attributes", { "model": "contact" }).returns(test_data_attribute_list)
+    client.data_attributes.find_all({"model": "contact"}).each { |d| }
+  end
+end

data/spec/unit/intercom/deprecated_leads_collection_proxy_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Intercom::ClientCollectionProxy do
+  let(:client) { Intercom::Client.new(token: 'token') }
+  let(:lead_json) do
+    { 'type' => 'contact.list', 'contacts' => [{ 'type' => 'contact', 'id' => 'id' }] }
+  end
+
+  it 'stops iterating if no next link' do
+    client.expects(:get).with('/contacts', {}).returns(lead_json)
+    client.deprecated__leads.all.each do |company|
+      _(company.class).must_equal Intercom::Lead
+    end
+  end
+end

data/spec/unit/intercom/event_spec.rb

@@ -4,13 +4,32 @@ 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)
     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)
 
@@ -55,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",
@@ -76,7 +95,7 @@ describe "Intercom::Event" do
           {
             method: "post",
             data_type: "event",
-            data:{
+            data: {
               event_name: "invited-friend",
               created_at: 1438944979,
               user_id: "314159",
@@ -124,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)