intercom 0.0.1 → 0.0.2

data/lib/intercom/user_resource.rb

@@ -0,0 +1,75 @@
+require 'intercom/unix_timestamp_unwrapper'
+
+module Intercom
+  class UserResource
+    include UnixTimestampUnwrapper
+
+    def initialize(attributes={})
+      self.attributes = attributes
+    end
+
+    def to_hash
+      UserResource.for_wire(@attributes)
+    end
+
+    def email
+      @attributes["email"]
+    end
+
+    def email=(email)
+      @attributes["email"]=email
+    end
+
+    def user_id
+      @attributes["user_id"]
+    end
+
+    def user_id=(user_id)
+      @attributes["user_id"] = user_id
+    end
+
+    def update_from_api_response(api_response)
+      api_response.each do |key, value|
+        setter_method = "#{key.to_s}="
+        if self.respond_to?(setter_method)
+          self.send(setter_method, value)
+        else
+          @attributes[key.to_s] = value
+        end
+      end
+      self
+    end
+
+    private
+
+    def attributes=(attributes={})
+      @attributes = {}
+      (attributes || {}).each do |key, value|
+        self.send("#{key.to_s}=", value)
+      end
+    end
+
+    def self.for_wire(object)
+      return object.for_wire if object.respond_to?(:for_wire)
+      return object.map { |item| for_wire(item) } if object.is_a?(Array)
+      return object.inject({}) { |result, (k, value)| result[k] = for_wire(value); result } if object.is_a?(Hash)
+      object
+    end
+
+    def self.from_api(api_response)
+      obj = self.new
+      obj.update_from_api_response(api_response)
+    end
+
+    def method_missing(method, *args, &block)
+      return @attributes[method.to_s] if @attributes.has_key?(method.to_s)
+      super
+    end
+
+    def self.requires_parameters(parameters, required)
+      missing = Array(required) - parameters.keys.map(&:to_s)
+      raise ArgumentError.new("Missing required parameters (#{missing.join(', ')}).") unless missing.empty?
+    end
+
+  end
+end

data/lib/intercom/version.rb

@@ -1,3 +1,3 @@
-module Intercom
-  VERSION = "0.0.1"
+module Intercom #:nodoc:
+  VERSION = "0.0.2"
 end

data/spec/integration/intercom_api_integration_spec.rb

@@ -0,0 +1,28 @@
+require 'intercom'
+require 'minitest/autorun'
+
+describe "api.intercom.io dummy data requests" do
+  before :each do
+    Intercom.app_id = "dummy-app-id"
+    Intercom.secret_key = "dummy-secret-key"
+  end
+
+  it "should get a user" do
+    user = Intercom::User.find(:email => "somebody@example.com")
+    user.name.must_equal "Somebody"
+  end
+
+  it "not found... " do
+    proc { Intercom::User.find(:email => "not-found@example.com") }.must_raise Intercom::ResourceNotFound
+  end
+
+  it "server error" do
+    proc { Intercom::User.find(:email => "server-error@example.com") }.must_raise Intercom::ServerError
+  end
+
+  it "authentication failure with bad api key" do
+    Intercom.app_id = "bad-app-id"
+    Intercom.secret_key = "bad-secret-key"
+    proc { Intercom::User.find(:email => "not-found@example.com") }.must_raise Intercom::AuthenticationError
+  end
+end

data/spec/unit/intercom/impression_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe "/v1/impressions" do
+  it "creates a good impression" do
+    Intercom.expects(:post).with("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

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe "/v1/messages_threads" do
+  it "loads messages for a user" do
+    Intercom.expects(:get).with("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("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("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("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("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}
+    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_path_50']
+    end
+  end
+end

data/spec/unit/intercom/user_resource_spec.rb

@@ -0,0 +1,13 @@
+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

data/spec/unit/intercom/user_spec.rb

@@ -0,0 +1,133 @@
+require "spec_helper"
+
+describe "Intercom::User" do
+  it "to_hash'es itself" do
+    created_at = Time.now
+    user = Intercom::User.new("email" => "jim@example.com", :user_id => "12345", :created_at => created_at, :name => "Jim Bob")
+    as_hash = user.to_hash
+    as_hash["email"].must_equal "jim@example.com"
+    as_hash["user_id"].must_equal "12345"
+    as_hash["created_at"].must_equal created_at.to_i
+    as_hash["name"].must_equal "Jim Bob"
+  end
+
+  it "presents created_at and last_impression_at as Date" do
+    now = Time.now
+    user = Intercom::User.from_api(:created_at => now, :last_impression_at => now)
+    user.created_at.must_be_kind_of Time
+    user.created_at.to_s.must_equal now.to_s
+    user.last_impression_at.must_be_kind_of Time
+    user.last_impression_at.to_s.must_equal now.to_s
+  end
+
+  it "is ok on missing methods" do
+    user = Intercom::User.new
+    user.created_at.must_be_nil
+    user.last_impression_at.must_be_nil
+    user.email.must_be_nil
+    user.social_profiles.must_equal([])
+  end
+
+  it "presents a complete user record correctly" do
+    user = Intercom::User.from_api(test_user)
+    user.session_count.must_equal 123
+    user.social_profiles.size.must_equal 4
+    twitter_account = user.social_profiles.first
+    twitter_account.must_be_kind_of Intercom::SocialProfile
+    twitter_account.type.must_equal "twitter"
+    twitter_account.username.must_equal "abc"
+    twitter_account.url.must_equal "http://twitter.com/abc"
+    user.custom_data["a"].must_equal "b"
+    user.custom_data["b"].must_equal 2
+    user.relationship_score.must_equal 90
+    user.last_seen_ip.must_equal "1.2.3.4"
+    user.last_seen_user_agent.must_equal "Mozilla blah blah ie6"
+  end
+
+  it "has read-only social accounts" do
+    user = Intercom::User.new(:social_profiles => [:url => "http://twitter.com/abc", "username" => "abc", "type" => "twitter"])
+    user.social_profiles.size.must_equal 1
+    twitter = user.social_profiles.first
+    twitter.type.must_equal "twitter"
+    twitter.url.must_equal "http://twitter.com/abc"
+    twitter.username.must_equal "abc"
+    user.to_hash["social_profiles"].must_equal nil
+    proc { user.social_profiles << "a" }.must_raise RuntimeError, "can't modify frozen array"
+    proc { Intercom::User.new.social_profiles << "a" }.must_raise RuntimeError, "can't modify frozen array"
+  end
+
+  it "has read-only location data" do
+    Intercom::User.new.location_data.must_equal({})
+    user = Intercom::User.new(:location_data => {"city" => "Dublin"})
+    user.location_data.must_equal({"city" => "Dublin"})
+    proc { user.location_data["change"] = "123" }.must_raise RuntimeError, "can't modify frozen hash"
+    user.to_hash["location_data"].must_equal nil
+  end
+
+  it "allows easy setting of custom data" do
+    now = Time.now
+    user = Intercom::User.new()
+    user.custom_data["mad"] = 123
+    user.custom_data["other"] = now
+    user.custom_data["thing"] = "yay"
+    user.to_hash["custom_data"].must_equal "mad" => 123, "other" => now, "thing" => "yay"
+  end
+
+  it "rejects nested data structures in custom_data" do
+    user = Intercom::User.new()
+    proc { user.custom_data["thing"] = [1] }.must_raise ArgumentError
+    proc { user.custom_data["thing"] = {1 => 2} }.must_raise ArgumentError
+
+    user = Intercom::User.from_api(test_user)
+    proc { user.custom_data["thing"] = [1] }.must_raise ArgumentError
+  end
+
+  it "fetches a user" do
+    Intercom.expects(:get).with("users", {"email" => "bo@example.com"}).returns(test_user)
+    user = Intercom::User.find("email" => "bo@example.com")
+    user.email.must_equal "bo@example.com"
+    user.name.must_equal "Joe Schmoe"
+    user.session_count.must_equal 123
+  end
+
+  it "saves a user" do
+    user = Intercom::User.new("email" => "jo@example.com", :user_id => "i-1224242")
+    Intercom.expects(:post).with("users", {"email" => "jo@example.com", "user_id" => "i-1224242"}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
+    user.save
+  end
+
+  it "can use User.create for convenience" do
+    Intercom.expects(:post).with("users", {"email" => "jo@example.com", "user_id" => "i-1224242"}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
+    user = Intercom::User.create("email" => "jo@example.com", :user_id => "i-1224242")
+    user.email.must_equal "jo@example.com"
+  end
+
+  it "updates the @user with attributes as set by the server" do
+    Intercom.expects(:post).with("users", {"email" => "jo@example.com", "user_id" => "i-1224242"}).returns({"email" => "jo@example.com", "user_id" => "i-1224242", "session_count" => 4})
+    user = Intercom::User.create("email" => "jo@example.com", :user_id => "i-1224242")
+    user.session_count.must_equal 4
+  end
+
+  it "raises argument error when trying to set a read only attribute" do
+    read_only_attributes = %w(relationship_score last_impression_at session_count)
+    read_only_attributes.each do |read_only|
+      proc { Intercom::User.create("email" => "jo@example.com", read_only => "some value") }.must_raise NoMethodError
+      user = Intercom::User.new
+      user.public_methods.include?("#{read_only}=").must_equal false
+    end
+  end
+
+  it "sets/gets rw keys" do
+    params = {"email" => "me@example.com", :user_id => "abc123", "name" => "Bob Smith", "last_seen_ip" => "1.2.3.4", "last_seen_user_agent" => "ie6", "created_at" => Time.now}
+    user = Intercom::User.new(params)
+    user.to_hash.keys.sort.must_equal params.keys.map(&:to_s).sort
+    params.keys.each do | key|
+      user.send(key).to_s.must_equal params[key].to_s
+    end
+  end
+
+  it "will allow extra attributes in response from api" do
+    user = Intercom::User.send(:from_api, {"new_param" => "some value"})
+    user.new_param.must_equal "some value"
+  end
+end

data/spec/unit/intercom_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Intercom do
+  it "has a version number" do
+    Intercom::VERSION.must_equal "0.0.2"
+  end
+
+  describe "API" do
+    before do
+      Intercom.app_id = "abc123"
+      Intercom.secret_key = "super-secret-key"
+    end
+
+    it "raises ArgumentError if no app_id or secret_key specified" do
+      Intercom.app_id = nil
+      Intercom.secret_key = nil
+      proc { Intercom.url_for_path("something") }.must_raise ArgumentError, "You must set both Intercom.app_id and Intercom.secret_key to use this client. See https://github.com/intercom/intercom-ruby for usage examples."
+    end
+
+    it "defaults to https to api.intercom.io" do
+      Intercom.url_for_path("some/resource/path").must_equal "https://abc123:super-secret-key@api.intercom.io/v1/some/resource/path"
+    end
+
+    it "raises ResourceNotFound if get a 404" do
+
+    end
+
+    describe "overriding protocol/hostname" do
+      before do
+        @protocol = Intercom.protocol
+        @hostname = Intercom.hostname
+      end
+
+      after do
+        Intercom.protocol = @protocol
+        Intercom.hostname = @hostname
+      end
+
+      it "allows overriding of the endpoint and protocol" do
+        Intercom.protocol = "http"
+        Intercom.hostname = "localhost:3000"
+        Intercom.url_for_path("some/resource/path").must_equal "http://abc123:super-secret-key@localhost:3000/v1/some/resource/path"
+      end
+    end
+  end
+
+  it "checks for email or user id" do
+    proc { Intercom.require_email_or_user_id("else") }.must_raise ArgumentError, "Expected params Hash, got String"
+    proc { Intercom.require_email_or_user_id(:something => "else") }.must_raise ArgumentError, "Either email or user_id must be specified"
+    proc { Intercom.get("users", :something => "else") }.must_raise ArgumentError, "Either email or user_id must be specified"
+    proc { Intercom.put("users", :something => "else") }.must_raise ArgumentError, "Either email or user_id must be specified"
+    proc { Intercom.post("users", :something => "else") }.must_raise ArgumentError, "Either email or user_id must be specified"
+    Intercom.require_email_or_user_id(:email => "bob@example.com", :something => "else")
+    Intercom.require_email_or_user_id("email" => "bob@example.com", :something => "else")
+    Intercom.require_email_or_user_id(:user_id => "123")
+  end
+end

data/spec/unit/spec_helper.rb

@@ -0,0 +1,80 @@
+require 'intercom'
+require 'minitest/autorun'
+require 'mocha'
+
+def test_user
+  {
+      :user_id => 'id-from-customers-app',
+      :email => "bo@example.com",
+      :name => "Joe Schmoe",
+      :created_at => 1323422442,
+      :last_seen_ip  => "1.2.3.4",
+      :last_seen_user_agent  => "Mozilla blah blah ie6",
+      :custom_data => {"a" => "b", "b" => 2},
+      :relationship_score  => 90,
+      :session_count => 123,
+      :last_impression_at => 1323422442,
+      :social_profiles => [
+          {"type" => "twitter", "url" => "http://twitter.com/abc", "username" => "abc"},
+          {"type" => "twitter", "username" => "abc2", "url" => "http://twitter.com/abc2"},
+          {"type" => "facebook", "url" => "http://facebook.com/abc", "username" => "abc", "id" => "1234242"},
+          {"type" => "quora", "url" => "http://facebook.com/abc", "username" => "abc", "id" => "1234242"}
+      ],
+      :location_data => {
+          "country_code" => "IRL"
+      }
+  }
+end
+
+def test_messages
+  [test_message, test_message]
+end
+
+def test_message
+  {
+      "created_at" => 1329837506,
+      "updated_at" => 1329664706,
+      "read" => true,
+      "created_by_user" => true,
+      "thread_id" => 5591,
+      "messages" => [
+          {
+              "created_at" => 1329837506,
+              "html" => "<p>Hey Intercom, What is up?</p>\n",
+              "from" => {
+                  "email" => "bob@example.com",
+                  "name" => "Bob",
+                  "user_id" => "123",
+                  "is_admin" => false
+              }
+          },
+          {
+              "created_at" => 1329664706,
+              "rendered_body" => "<p>Not much, you?</p>\n",
+              "from" => {
+                  "name" => "Super Duper Admin",
+                  "avatar_path_50" => "https//s3.amazonaws.com/intercom-prod/app/public/system/avatars/1454/medium/intercom-ben-avatar.jpg?1326725052",
+                  "is_admin" => true
+              }
+          },
+          {
+              "created_at" => 1329664806,
+              "rendered_body" => "<p>Not much either :(</p>\n",
+              "from" => {
+                  "email" => "bob@example.com",
+                  "name" => "Bob",
+                  "user_id" => "123",
+                  "is_admin" => false
+              }
+          }
+      ]
+  }
+end
+
+def capture_exception(&block)
+  begin
+    block.call
+  rescue => e
+    return e
+  end
+end