intercom 1.0.0 → 2.0.0

data/spec/integration/intercom_api_integration_spec.rb

@@ -1,134 +0,0 @@
-require "spec_helper"
-require 'fakeweb'
-
-describe "api.intercom.io dummy data requests" do
-  before :each do
-    Intercom.app_id = "some-app-id"
-    Intercom.api_key = "some-secret-key"
-    Intercom.endpoint = "https://intercom.example.com"
-    FakeWeb.clean_registry
-  end
-
-  def fixture(name)
-    File.read(File.expand_path("../fixtures/#{name}.json", __FILE__))
-  end
-
-  it "should get all user" do
-    FakeWeb.register_uri(:get, %r|v1/users|, :body => fixture('v1-users'))
-    Intercom::User.all.count.must_be :>, 0
-  end
-
-  it "should get a user" do
-    FakeWeb.register_uri(:get, %r(v1/users\?email=), :body => fixture('v1-user'))
-    user = Intercom::User.find(:email => "somebody@example.com")
-    user.name.must_equal "Somebody"
-  end
-
-  it "not found... " do
-    FakeWeb.register_uri(:get, %r(v1/users\?email=not-found), :status => [404, "Not Found"])
-    proc { Intercom::User.find(:email => "not-found@example.com") }.must_raise Intercom::ResourceNotFound
-  end
-
-  it "server error" do
-    FakeWeb.register_uri(:get, %r(v1/users\?email=server-error), :status => [500, "Oh Noes"])
-    proc { Intercom::User.find(:email => "server-error@example.com") }.must_raise Intercom::ServerError
-  end
-
-  it "authentication failure with bad api key" do
-    FakeWeb.register_uri(:get, %r(v1/users\?email=authentication-error), :status => [401, "Authentication Error"])
-    Intercom.app_id = "bad-app-id"
-    Intercom.api_key = "bad-secret-key"
-    proc { Intercom::User.find(:email => "authentication-error@example.com") }.must_raise Intercom::AuthenticationError
-  end
-
-  it "should find_all messages for a user" do
-    FakeWeb.register_uri(:get, %r(v1/users/message_threads\?email=somebody), :body => fixture('v1-users-message_threads'))
-    message_thread = Intercom::MessageThread.find_all(:email => "somebody@example.com").first
-    %w(thread_id read messages created_at updated_at created_by_user).each do |expected|
-      message_thread.send(expected).wont_be_nil
-    end
-  end
-  
-  it "handles blank string bodies" do
-    FakeWeb.register_uri(:get, %r(v1/users\?email=), :body => fixture('v1-user'))
-    user = Intercom::User.find(:email => "somebody@example.com")
-    FakeWeb.register_uri(:post, %r(/events), :status => ["202", "Created"], :body => ' ')
-  end
-
-  it "should mark message_thread as read" do
-    FakeWeb.register_uri(:get, %r(v1/users/message_threads\?email=somebody), :body => fixture('v1-users-message_threads'))
-    FakeWeb.register_uri(:put, %r(v1/users/message_threads), :body => fixture('v1-users-message_thread'))
-    message_thread = Intercom::MessageThread.find_all(:email => "somebody@example.com").first
-    message_thread.mark_as_read!
-  end
-
-  it "should create some impression" do
-    FakeWeb.register_uri(:post, %r(v1/users/impressions), :body => fixture('v1-users-impression'))
-    impression = Intercom::Impression.create(:email => 'somebody@example.com')
-    impression.unread_messages.must_be :>, 0
-    impression.email.must_equal 'somebody@example.com'
-  end
-
-  it "should create some notes" do
-    FakeWeb.register_uri(:post, %r(v1/users/notes), :body => fixture('v1-users-note'))
-    note = Intercom::Note.create(:body => "This is a note", :email => "somebody@example.com")
-    note.html.must_equal "<p>This is a note</p>"
-    note.user.email.must_equal "somebody@example.com"
-  end
-  
-  it "should create an event" do
-    FakeWeb.register_uri(:get, %r(v1/users\?email=), :body => fixture('v1-user'))
-    user = Intercom::User.find(:email => "somebody@example.com")
-    FakeWeb.register_uri(:post, %r(/events), :status => ["202", "Created"])
-    Intercom::Event.create(:event_name => "signup", :created_at => 1391691571, :user => user).event_name.must_equal "signup"
-  end
-  
-  it "should create batch events" do
-    FakeWeb.register_uri(:get, %r(v1/users\?email=), :body => fixture('v1-user'))
-    user = Intercom::User.find(:email => "somebody@example.com")
-    
-    first_event = Intercom::Event.new
-    first_event.event_name = "first event"
-    first_event.created_at = Time.now
-    first_event.user = user
-    
-    second_event = Intercom::Event.new
-    second_event.event_name = "second event"
-    second_event.created_at = Time.now
-    
-    FakeWeb.register_uri(:post, %r(/events), :status => ["202", "Created"])
-    Intercom::Event.save_batch_events([first_event, second_event], user)
-  end
-  
-  it "should create an event from a user" do
-    FakeWeb.register_uri(:get, %r(v1/users\?email=), :body => fixture('v1-user'))
-    user = Intercom::User.find(:email => "somebody@example.com")
-    FakeWeb.register_uri(:post, %r(/events), :status => ["202", "Created"])
-    user.track_event("signup").event_name.must_equal "signup"
-  end
-
-  it "should failover to good endpoint when first one is un-reachable" do
-    FakeWeb.allow_net_connect = %r(127.0.0.7)
-    FakeWeb.register_uri(:get, %r(api.intercom.io/v1/users), :body => fixture('v1-user'))
-    Intercom.endpoints = unshuffleable_array(["http://127.0.0.7", "https://api.intercom.io"])
-    user = Intercom::User.find(:email => "somebody@example.com")
-    user.name.must_equal "Somebody"
-  end
-
-  it "should raise error when endpoint(s) are un-reachable" do
-    FakeWeb.register_uri(:get, %r|example\.com/|, :status => ["503", "Service Unavailable"])
-    Intercom.endpoints = ["http://example.com"]
-    proc { Intercom::User.find(:email => "somebody@example.com")}.must_raise Intercom::ServiceUnavailableError
-    Intercom.endpoints = ["http://example.com", "http://api.example.com"]
-    proc { Intercom::User.find(:email => "somebody@example.com")}.must_raise Intercom::ServiceUnavailableError
-  end
-
-  it "should raise gateway error when the request returns a 502" do
-    FakeWeb.register_uri(:get, %r|example\.com/|, :status => ["502", "Bad Gateway"])
-    Intercom.endpoints = ["http://example.com"]
-    proc { Intercom::User.find(:email => "somebody@example.com")}.must_raise Intercom::BadGatewayError
-    Intercom.endpoints = ["http://example.com", "http://api.example.com"]
-    proc { Intercom::User.find(:email => "somebody@example.com")}.must_raise Intercom::BadGatewayError
-
-  end
-end

data/spec/unit/intercom/impression_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-describe "/v1/impressions" do
-  it "creates a good impression" do
-    Intercom.expects(:post).with("/v1/users/impressions", {"email" => "jo@example.com", "location" => "/some/path/in/my/app"}).returns({"unread_messages" => 10})
-    impression = Intercom::Impression.create("email" => "jo@example.com", "location" => "/some/path/in/my/app")
-    impression.unread_messages.must_equal 10
-  end
-
-  it "sets/gets allowed keys" do
-    params = {"user_ip" => "1.2.3.4", "user_agent" => "ie6", "location" => "/some/path/in/my/app", "email" => "me@example.com", :user_id => "abc123"}
-    impression = Intercom::Impression.new(params)
-    impression.to_hash.keys.sort.must_equal params.keys.map(&:to_s).sort
-    params.keys.each do | key|
-      impression.send(key).must_equal params[key]
-    end
-  end
-end

data/spec/unit/intercom/message_thread_spec.rb

@@ -1,74 +0,0 @@
-require "spec_helper"
-
-describe "/v1/messages_threads" do
-  it "loads messages for a user" do
-    Intercom.expects(:get).with("/v1/users/message_threads", {"email" => "bo@example.com"}).returns(test_messages)
-    message_threads = Intercom::MessageThread.find_all("email" => "bo@example.com")
-    message_threads.size.must_equal 2
-    message_threads.first.messages.size.must_equal 3
-    message_threads.first.messages[0].html.must_equal "<p>Hey Intercom, What is up?</p>\n"
-  end
-
-  it "loads message for a thread id" do
-    Intercom.expects(:get).with("/v1/users/message_threads", {"email" => "bo@example.com", "thread_id" => 123}).returns(test_message)
-    message_thread = Intercom::MessageThread.find("email" => "bo@example.com", "thread_id" => 123)
-    message_thread.messages.size.must_equal 3
-  end
-
-  it "creates a new message" do
-    Intercom.expects(:post).with("/v1/users/message_threads", {"email" => "jo@example.com", "body" => "Hello World"}).returns(test_message)
-    message_thread = Intercom::MessageThread.create("email" => "jo@example.com", "body" => "Hello World")
-    message_thread.messages.size.must_equal 3
-  end
-
-  it "creates a comment on existing thread" do
-    Intercom.expects(:post).with("/v1/users/message_threads", {"email" => "jo@example.com", "body" => "Hello World", "thread_id" => 123}).returns(test_message)
-    message_thread = Intercom::MessageThread.create("email" => "jo@example.com", "body" => "Hello World", "thread_id" => 123)
-    message_thread.messages.size.must_equal 3
-  end
-
-  it "marks a thread as read... " do
-    Intercom.expects(:put).with("/v1/users/message_threads", {"read" => true, "email" => "jo@example.com", "thread_id" => 123}).returns(test_message)
-    message_thread = Intercom::MessageThread.mark_as_read("email" => "jo@example.com", "thread_id" => 123)
-    message_thread.messages.size.must_equal 3
-  end
-
-  it "sets/gets allowed keys" do
-    params = {"email" => "me@example.com", :user_id => "abc123", "thread_id" => "123", "body" => "hello world", "read" => true, "url" => "http://example.com"}
-    message_thread = Intercom::MessageThread.new(params)
-    message_thread.to_hash.keys.sort.must_equal params.keys.map(&:to_s).sort
-    params.keys.each do |key|
-      message_thread.send(key).must_equal params[key]
-    end
-  end
-
-  it "should do automatic unwrapping of the timestamp " do
-    message_thread = Intercom::MessageThread.from_api(test_message)
-    message_thread.created_at.to_s.must_equal Time.at(test_message['created_at']).to_s
-    message_thread.updated_at.to_s.must_equal Time.at(test_message['updated_at']).to_s
-  end
-
-  describe "messages" do
-    it "has nice interface onto messages thread." do
-      message_thread = Intercom::MessageThread.from_api(test_message)
-      message_thread.messages.size.must_equal 3
-      message_thread.messages[0].created_at.to_s.must_equal Time.at(test_message['messages'][0]['created_at']).to_s
-      message_thread.messages[0].html.must_equal test_message['messages'][0]['html']
-      from_0 = test_message['messages'][0]['from']
-      message_thread.messages[0].from.email.must_equal from_0['email']
-      message_thread.messages[0].from.name.must_equal from_0['name']
-      message_thread.messages[0].from.admin?.must_equal from_0['is_admin']
-      message_thread.messages[0].from.user_id.must_equal from_0['user_id']
-      message_thread.messages[0].from.avatar_path_50.must_equal nil
-
-      message_thread.messages[1].created_at.must_equal Time.at(test_message['messages'][1]['created_at'])
-      message_thread.messages[1].html.must_equal test_message['messages'][1]['html']
-      from_1 = test_message['messages'][1]['from']
-      message_thread.messages[1].from.email.must_equal from_1['email']
-      message_thread.messages[1].from.name.must_equal from_1['name']
-      message_thread.messages[1].from.admin?.must_equal from_1['is_admin']
-      message_thread.messages[1].from.user_id.must_equal from_1['user_id']
-      message_thread.messages[1].from.avatar_path_50.must_equal from_1['avatar']['square_50']
-    end
-  end
-end

data/spec/unit/intercom/user_collection_proxy_spec.rb

@@ -1,46 +0,0 @@
-require "spec_helper"
-
-describe Intercom::UserCollectionProxy do
-  before :each do
-    Intercom.expects(:execute_request).never
-  end
-
-  it "supports each" do
-    Intercom.expects(:get).with("/v1/users", {:page => 1}).returns(page_of_users)
-    emails = []
-    Intercom::User.all.each { |user| emails << user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
-  end
-
-  it "supports querying for tagged users" do
-    Intercom.expects(:get).with("/v1/users", {:tag_id => "1234", :page => 1}).returns(page_of_users)
-    emails = []
-    Intercom::User.where(:tag_id => '1234').each { |user| emails << user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
-  end
-
-  it "should only pass whitelisted attributes to collection query" do
-    Intercom.expects(:get).with("/v1/users", {:tag_name => '1234', :page => 1}).returns(page_of_users)
-    emails = []
-    Intercom::User.where(:danger_zone => 'BOOM', :tag_name => '1234').each { |user| emails << user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
-  end
-
-  it "supports map" do
-    Intercom.expects(:get).with("/v1/users", {:page => 1}).returns(page_of_users).twice
-    Intercom::User.all.map { |user| user.email }.must_equal %W(user1@example.com user2@example.com user3@example.com)
-    Intercom::User.all.collect { |user| user.email }.must_equal %W(user1@example.com user2@example.com user3@example.com)
-  end
-
-  it "loads multiple pages" do
-    Intercom.expects(:get).with("/v1/users", {:page => 1}).returns(page_of_users(1, 1))
-    Intercom.expects(:get).with("/v1/users", {:page => 2}).returns(page_of_users(2, 1))
-    Intercom.expects(:get).with("/v1/users", {:page => 3}).returns(page_of_users(3, 1))
-    Intercom::User.all.map { |user| user.email }.must_equal %W(user1@example.com user2@example.com user3@example.com)
-  end
-
-  it "only loads the first page when counting" do
-    Intercom.expects(:get).with("/v1/users", {:per_page => 1}).returns(page_of_users(1, 1))
-    Intercom::User.all.count.must_equal(3)
-  end
-end

data/spec/unit/intercom/user_event_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-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}
-  
-  it "creates an event" do
-    Intercom.expects(:post).with("/events",
-                                 { :type => 'event.list',
-                                   :data => [ {:event_name => "signup", :created => created_time.to_i, :type => 'event', 
-                                      :user => { :user_id => user.user_id},
-                                    }]}).returns(:status => 200)
-
-    Intercom::Event.create({ :event_name => "signup", :user => user, :created_at => created_time })
-  end
-
-  it 'automatically adds a created time upon creation' do
-    Intercom.expects(:post).with("/events",
-                                 { :type => 'event.list',
-                                   :data => [ {:event_name => "sale of item", :created => Time.now.to_i, :type => 'event', :user => { :user_id => user.user_id}
-                                    }]}).returns(:status => 200)
-    
-    Intercom::Event.create({ :event_name => "sale of item", :user => user })
-  end
-  
-  it "creates an event with metadata" do
-    Intercom.expects(:post).with("/events",
-                                 { :type => 'event.list',
-                                   :data => [ {:event_name => "signup", :created => created_time.to_i, :type => 'event', :user => { :user_id => user.user_id}, :metadata => { :something => "here"}
-                                    }]}).returns(:status => 200)
-    Intercom::Event.create({ :event_name => "signup", :user => user, :created_at => created_time, :metadata => { :something => "here"} })
-  end
-
-  it 'fails when no user supplied' do
-    event = Intercom::Event.new
-    event.event_name = "some event"
-    event.created_at = Time.now
-    proc { event.save }.must_raise ArgumentError, "Missing User"
-  end
-  
-  it 'uses the user.email if no user.id found' do
-    user2 = Intercom::User.new("email" => "jim@example.com", :created_at => Time.now, :name => "Jim Bob")
-    Intercom.expects(:post).with("/events",
-                                 { :type => 'event.list',
-                                   :data => [ {:event_name => "signup", :created => created_time.to_i, :type => 'event', 
-                                      :user => { :email => user2.email}
-                                    }]}).returns(:status => 200)
-
-    Intercom::Event.create({ :event_name => "signup", :user => user2, :created_at => created_time })
-  end
-  
-  describe 'while batching events' do
-    
-    let (:event1) do
-      event = Intercom::Event.new
-      event.event_name = "first event"
-      event.created_at = Time.now
-      event.user = user
-      event
-    end
-
-    let (:event2) do
-      event = Intercom::Event.new
-      event.event_name = "second event"
-      event.created_at = Time.now
-      event
-    end
-    
-    it 'creates batched events' do
-      Intercom.expects(:post).with("/events",
-                                   { :type => 'event.list',
-                                     :data => [ 
-                                         {:event_name => "first event", :created => event1.created_at.to_i,
-                                          :type => 'event', :user => {:user_id => user.user_id}},
-                                         {:event_name => "second event", :created => event2.created_at.to_i,
-                                          :type => 'event'},
-                                     ],
-                                     :user => { :user_id => user.user_id}}).returns(:status => 200)
-      Intercom::Event.save_batch_events([event1, event2], user)
-    end
-  end
-end

data/spec/unit/intercom/user_resource_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-describe Intercom::UserResource do
-  describe "requires_params" do
-    it "raises if they are missing" do
-      params = {"a" => 1, "b" => 2}
-      Intercom::UserResource.requires_parameters(params, %W(a b))
-      expected_message = "Missing required parameters (c)."
-      proc { Intercom::UserResource.requires_parameters(params, %W(a b c)) }.must_raise ArgumentError, expected_message
-      capture_exception { Intercom::UserResource.requires_parameters(params, %W(a b c)) }.message.must_equal expected_message
-    end
-  end
-end