intercom 0.0.11 → 0.0.12

data/README.rdoc

@@ -55,7 +55,7 @@ The API supports:
 
 ==== Notes
 
-    Intercom::Note.create(:email => "bob@example.com", :body => "This is the text of the note"
+    Intercom::Note.create(:email => "bob@example.com", :body => "This is the text of the note")
 
 === Errors
 

data/Rakefile

@@ -4,6 +4,7 @@ require 'rake/clean'
 
 Rake::TestTask.new("spec:unit") do |spec|
   spec.libs.push "lib"
+  spec.libs.push "spec"
   spec.libs.push "spec/unit"
   spec.test_files = FileList['spec/unit/**/*_spec.rb']
   spec.warning = true
@@ -11,6 +12,7 @@ end
 
 Rake::TestTask.new("spec:integration") do |spec|
   spec.libs.push "lib"
+  spec.libs.push "spec"
   spec.test_files = FileList['spec/integration/**/*_spec.rb']
   spec.warning = true
 end

data/changes.txt

@@ -1,3 +1,6 @@
+0.0.12
+ - add support for multiple endpoints, with failover on service unavailable / socket connect timeout. (only relevant to customers who must use static ip addresses to access our API)
+
 0.0.11
  - add support for creating notes on users
 

data/intercom.gemspec

@@ -6,9 +6,9 @@ require "intercom/version"
 Gem::Specification.new do |spec|
   spec.name        = "intercom"
   spec.version     = Intercom::VERSION
-  spec.authors     = ["Ben McRedmond", "Ciaran Lee", "Darragh Curran",]
-  spec.email       = ["ben@intercom.io", "ciaran@intercom.io", "darragh@intercom.io"]
-  spec.homepage    = "http://www.intercom.io"
+  spec.authors     = ["Ben McRedmond", "Ciaran Lee", "Darragh Curran", "Jeff Gardner"]
+  spec.email       = ["ben@intercom.io", "ciaran@intercom.io", "darragh@intercom.io", "jeff@intercom.io"]
+  spec.homepage    = "https://www.intercom.io"
   spec.summary     = %q{Ruby bindings for the Intercom API}
   spec.description = %Q{Intercom (https://www.intercom.io) is a customer relationship management and messaging tool for web app owners. This library wraps the api provided by Intercom. See http://docs.intercom.io/api for more details. }
 

data/lib/intercom.rb

@@ -22,6 +22,8 @@ require "json"
 module Intercom
   @hostname = "api.intercom.io"
   @protocol = "https"
+  @endpoints = nil
+  @current_endpoint = nil
   @app_id = nil
   @api_key = nil
 
@@ -44,28 +46,58 @@ module Intercom
   end
 
   private
-  def self.url_for_path(path)
-    raise ArgumentError, "You must set both Intercom.app_id and Intercom.api_key to use this client. See https://github.com/intercom/intercom for usage examples." if [@app_id, @api_key].any?(&:nil?)
-    "#{protocol}://#{@app_id}:#{@api_key}@#{hostname}/v1/#{path}"
+  def self.target_base_url
+    raise ArgumentError, "You must set both Intercom.app_id and Intercom.api_key to use this client. See https://github.com/intercom/intercom-ruby for usage examples." if [@app_id, @api_key].any?(&:nil?)
+    basic_auth_part = "#{@app_id}:#{@api_key}@"
+    current_endpoint.gsub(/(https?:\/\/)(.*)/, "\\1#{basic_auth_part}\\2")
+  end
+
+  def self.send_request_to_path(request)
+    request.execute(target_base_url)
+  rescue Intercom::ServiceUnavailableError => e
+    if endpoints.length > 1
+      retry_on_alternative_endpoint(request)
+    else
+      raise e
+    end
+  end
+
+  def self.retry_on_alternative_endpoint(request)
+    @current_endpoint = alternative_random_endpoint
+    request.execute(target_base_url)
+  end
+
+  def self.current_endpoint
+    return @current_endpoint if @current_endpoint && @endpoint_randomized_at > (Time.now - (60 * 5))
+    @endpoint_randomized_at = Time.now
+    @current_endpoint = random_endpoint
+  end
+
+  def self.random_endpoint
+    endpoints.shuffle.first
+  end
+
+  def self.alternative_random_endpoint
+    (endpoints.shuffle - [@current_endpoint]).first
   end
 
   def self.post(path, payload_hash)
-    Intercom::Request.post(url_for_path(path), payload_hash).execute
+    send_request_to_path(Intercom::Request.post(path, payload_hash))
   end
 
   def self.delete(path, payload_hash)
-    Intercom::Request.delete(url_for_path(path), payload_hash).execute
+    send_request_to_path(Intercom::Request.delete(path, payload_hash))
   end
 
   def self.put(path, payload_hash)
-    Intercom::Request.put(url_for_path(path), payload_hash).execute
+    send_request_to_path(Intercom::Request.put(path, payload_hash))
   end
 
   def self.get(path, params)
-    Intercom::Request.get(url_for_path(path), params).execute
+    send_request_to_path(Intercom::Request.get(path, params))
   end
 
-  def self.check_required_params(params, path=nil)
+  def self.check_required_params(params, path=nil) #nodoc
     return if path.eql?("users")
     raise ArgumentError.new("Expected params Hash, got #{params.class}") unless params.is_a?(Hash)
     raise ArgumentError.new("Either email or user_id must be specified") unless params.keys.any? { |key| %W(email user_id).include?(key.to_s) }
@@ -75,18 +107,32 @@ module Intercom
     @protocol
   end
 
-  def self.protocol=(override)
+  def self.protocol=(override) #nodoc
     @protocol = override
   end
 
-  def self.hostname
+  def self.hostname #nodoc
     @hostname
   end
 
-  def self.hostname=(override)
+  def self.hostname=(override) #nodoc
     @hostname = override
   end
 
+  def self.endpoint=(endpoint) #nodoc
+    self.endpoints = [endpoint]
+    @current_endpoint = nil
+  end
+
+  def self.endpoints=(endpoints) #nodoc
+    @endpoints = endpoints
+    @current_endpoint = nil
+  end
+
+  def self.endpoints
+    @endpoints || ["#{@protocol}://#{hostname}"]
+  end
+
   # Raised when the credentials you provide don't match a valid account on Intercom.
   # Check that you have set <b>Intercom.app_id=</b> and <b>Intercom.api_key=</b> correctly.
   class AuthenticationError < StandardError;
@@ -96,6 +142,10 @@ module Intercom
   class ServerError < StandardError;
   end
 
+  # Raised when we reach socket connect timeout
+  class ServiceUnavailableError < StandardError;
+  end
+
   # Raised when requesting resources on behalf of a user that doesn't exist in your application on Intercom.
   class ResourceNotFound < StandardError;
   end

data/lib/intercom/impression.rb

@@ -30,7 +30,7 @@ module Intercom
     ##
     # Records that a user has interacted with your application, including the 'location' within the app they used
     def save
-      response = Intercom.post("users/impressions", to_hash)
+      response = Intercom.post("/v1/users/impressions", to_hash)
       self.update_from_api_response(response)
     end
 

data/lib/intercom/message_thread.rb

@@ -23,14 +23,14 @@ module Intercom
     # @return [Message]
     def self.find(params)
       requires_parameters(params, %W(thread_id))
-      api_response = Intercom.get("users/message_threads", params)
+      api_response = Intercom.get("/v1/users/message_threads", params)
       MessageThread.from_api(api_response)
     end
 
     # Finds all Messages to show a particular user
     # @return [Array<Message>]
     def self.find_all(params)
-      response = Intercom.get("users/message_threads", params)
+      response = Intercom.get("/v1/users/message_threads", params)
       response.map { |message| MessageThread.from_api(message) }
     end
 
@@ -50,7 +50,7 @@ module Intercom
 
     # @return [Message]
     def save(method=:post)
-      response = Intercom.send(method, "users/message_threads", to_hash)
+      response = Intercom.send(method, "/v1/users/message_threads", to_hash)
       self.update_from_api_response(response)
     end
 

data/lib/intercom/note.rb

@@ -28,7 +28,7 @@ module Intercom
     ##
     # Records a note on a user of your application
     def save
-      response = Intercom.post("users/notes", to_hash)
+      response = Intercom.post("/v1/users/notes", to_hash)
       self.update_from_api_response(response)
     end
 

data/lib/intercom/request.rb

@@ -3,43 +3,37 @@ require 'net/https'
 
 module Intercom
   class Request
-    attr_accessor :uri, :net_http_method
+    attr_accessor :path, :net_http_method
 
-    def initialize(uri, net_http_method)
-      set_common_headers(net_http_method, uri)
-
-      self.uri = uri
+    def initialize(path, net_http_method)
+      self.path = path
       self.net_http_method = net_http_method
     end
 
-    def set_common_headers(method, uri)
-      method.basic_auth(CGI.unescape(uri.user), CGI.unescape(uri.password))
+    def set_common_headers(method, base_uri)
+      method.basic_auth(CGI.unescape(base_uri.user), CGI.unescape(base_uri.password))
       method.add_field('Accept', 'application/json')
       method.add_field('AcceptEncoding', 'gzip, deflate')
     end
 
-    def self.get(url, params)
-      uri = URI.parse(url)
-      new(uri, Net::HTTP::Get.new(append_query_string_to_url(uri.path, params), default_headers))
+    def self.get(path, params)
+      new(path, Net::HTTP::Get.new(append_query_string_to_url(path, params), default_headers))
     end
 
-    def self.post(url, form_data)
-      uri = URI.parse(url)
-      new(uri, method_with_body(Net::HTTP::Post, uri, form_data))
+    def self.post(path, form_data)
+      new(path, method_with_body(Net::HTTP::Post, path, form_data))
     end
 
-    def self.delete(url, params)
-      uri = URI.parse(url)
-      new(uri, Net::HTTP::Delete.new(append_query_string_to_url(uri.path, params), default_headers))
+    def self.delete(path, params)
+      new(path, Net::HTTP::Delete.new(append_query_string_to_url(path, params), default_headers))
     end
 
-    def self.put(url, form_data)
-      uri = URI.parse(url)
-      new(uri, method_with_body(Net::HTTP::Put, uri, form_data))
+    def self.put(path, form_data)
+      new(path, method_with_body(Net::HTTP::Put, path, form_data))
     end
 
-    def self.method_with_body(http_method, uri, params)
-      request = http_method.send(:new, uri.request_uri, default_headers)
+    def self.method_with_body(http_method, path, params)
+      request = http_method.send(:new, path, default_headers)
       request.body = params.to_json
       request["Content-Type"] = "application/json"
       request
@@ -49,25 +43,29 @@ module Intercom
       {'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/json'}
     end
 
-    def client
+    def client(uri)
       net = Net::HTTP.new(uri.host, uri.port)
       if uri.is_a?(URI::HTTPS)
-        net.use_ssl = uri.is_a?(URI::HTTPS)
+        net.use_ssl = true
         net.verify_mode = OpenSSL::SSL::VERIFY_PEER
         net.ca_file = File.join(File.dirname(__FILE__), '../data/cacert.pem')
       end
       net.read_timeout = 30
-      net.open_timeout = 10
+      net.open_timeout = 3
       net
     end
 
-    def execute
-      client.start do |http|
+    def execute(target_base_url=nil)
+      base_uri = URI.parse(target_base_url)
+      set_common_headers(net_http_method, base_uri)
+      client(base_uri).start do |http|
         response = http.request(net_http_method)
         raise_errors_on_failure(response)
         decoded = decode(response['content-encoding'], response.body)
         JSON.parse(decoded)
       end
+    rescue Timeout::Error
+      raise Intercom::ServiceUnavailableError
     end
 
     def decode(content_encoding, body)
@@ -80,6 +78,8 @@ module Intercom
         raise Intercom::ResourceNotFound
       elsif res.code.to_i.eql?(401)
         raise Intercom::AuthenticationError
+      elsif res.code.to_i.eql?(503)
+        raise Intercom::ServiceUnavailableError
       elsif res.code.to_i.eql?(500)
         raise Intercom::ServerError
       end

data/lib/intercom/unix_timestamp_unwrapper.rb

@@ -6,7 +6,7 @@ module Intercom
     end
 
     def set_time_at(attribute_name, time)
-      @attributes[attribute_name.to_s] = time.to_i
+      @attributes[attribute_name.to_s] = (time.nil?) ? nil : time.to_i
     end
   end
-end
+end

data/lib/intercom/user.rb

@@ -30,7 +30,7 @@ module Intercom
     #
     # @return [User]
     def self.find(params)
-      response = Intercom.get("users", params)
+      response = Intercom.get("/v1/users", params)
       User.from_api(response)
     end
 
@@ -91,14 +91,14 @@ module Intercom
     # This operation is not idempotent.
     # @return [User]
     def self.delete(params)
-      response = Intercom.delete("users", params)
+      response = Intercom.delete("/v1/users", params)
       User.from_api(response)
     end
 
     # instance method alternative to #create
     # @return [User]
     def save
-      response = Intercom.post("users", to_hash)
+      response = Intercom.post("/v1/users", to_hash)
       self.update_from_api_response(response)
     end
 

data/lib/intercom/user_collection_proxy.rb

@@ -19,7 +19,7 @@ module Intercom
   class UserCollectionProxy
     # @return [Integer] number of users tracked on Intercom for this application
     def count
-      response = Intercom.get("users", {:per_page => 1})
+      response = Intercom.get("/v1/users", {:per_page => 1})
       response["total_count"]
     end
 
@@ -29,7 +29,7 @@ module Intercom
       page = 1
       fetch_another_page = true
       while fetch_another_page
-        current_page = Intercom.get("users", {:page => page})
+        current_page = Intercom.get("/v1/users", {:page => page})
         current_page["users"].each do |user|
           block.call User.from_api(user)
         end

data/lib/intercom/version.rb

@@ -1,3 +1,3 @@
 module Intercom #:nodoc:
-  VERSION = "0.0.11"
+  VERSION = "0.0.12"
 end

data/spec/integration/intercom_api_integration_spec.rb

@@ -1,10 +1,10 @@
-require 'intercom'
-require 'minitest/autorun'
+require "spec_helper"
 
 describe "api.intercom.io dummy data requests" do
   before :each do
     Intercom.app_id = "dummy-app-id"
     Intercom.api_key = "dummy-secret-key"
+    Intercom.endpoint = "https://api.intercom.io"
   end
 
   it "should get all user" do
@@ -53,4 +53,17 @@ describe "api.intercom.io dummy data requests" do
     note.html.must_equal "<p>This is a note</p>"
     note.user.email.must_equal "somebody@example.com"
   end
+
+  it "should failover to good endpoint when first one is un-reachable" do
+    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
+    Intercom.endpoints = ["http://127.0.0.7"]
+    proc { Intercom::User.find(:email => "somebody@example.com")}.must_raise Intercom::ServiceUnavailableError
+    Intercom.endpoints = ["http://127.0.0.7", "http://127.0.0.6"]
+    proc { Intercom::User.find(:email => "somebody@example.com")}.must_raise Intercom::ServiceUnavailableError
+  end
 end

data/spec/{unit/spec_helper.rb → spec_helper.rb}

@@ -97,4 +97,11 @@ def capture_exception(&block)
   rescue => e
     return e
   end
+end
+
+def unshuffleable_array(array)
+  def array.shuffle
+    self
+  end
+  array
 end

data/spec/unit/intercom/impression_spec.rb

@@ -2,7 +2,7 @@ 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})
+    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

data/spec/unit/intercom/message_thread_spec.rb

@@ -2,7 +2,7 @@ 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)
+    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
@@ -10,25 +10,25 @@ describe "/v1/messages_threads" do
   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)
+    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("users/message_threads", {"email" => "jo@example.com", "body" => "Hello World"}).returns(test_message)
+    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("users/message_threads", {"email" => "jo@example.com", "body" => "Hello World", "thread_id" => 123}).returns(test_message)
+    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("users/message_threads", {"read" => true, "email" => "jo@example.com", "thread_id" => 123}).returns(test_message)
+    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

data/spec/unit/intercom/note_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "/v1/notes" do
   it "creates a note" do
-    Intercom.expects(:post).with("users/notes", {"body" => "Note to leave on user"}).returns({"html" => "<p>Note to leave on user</p>", "created_at" => 1234567890})
+    Intercom.expects(:post).with("/v1/users/notes", {"body" => "Note to leave on user"}).returns({"html" => "<p>Note to leave on user</p>", "created_at" => 1234567890})
     note = Intercom::Note.create("body" => "Note to leave on user")
     note.html.must_equal "<p>Note to leave on user</p>"
   end

data/spec/unit/intercom/user_collection_proxy_spec.rb

@@ -6,27 +6,27 @@ describe Intercom::UserCollectionProxy do
   end
 
   it "supports each" do
-    Intercom.expects(:get).with("users", {:page => 1}).returns(page_of_users)
+    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 map" do
-    Intercom.expects(:get).with("users", {:page => 1}).returns(page_of_users).twice
+    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 "yields each user to the block" do
-    Intercom.expects(:get).with("users", {:per_page => 1}).returns(page_of_users(1,1))
+    Intercom.expects(:get).with("/v1/users", {:per_page => 1}).returns(page_of_users(1,1))
     Intercom::User.all.count.must_equal 3
   end
 
   it "loads multiple pages" do
-    Intercom.expects(:get).with("users", {:page => 1}).returns(page_of_users(1, 1))
-    Intercom.expects(:get).with("users", {:page => 2}).returns(page_of_users(2, 1))
-    Intercom.expects(:get).with("users", {:page => 3}).returns(page_of_users(3, 1))
+    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
 end

data/spec/unit/intercom/user_spec.rb

@@ -84,7 +84,7 @@ describe "Intercom::User" do
   end
 
   it "fetches a user" do
-    Intercom.expects(:get).with("users", {"email" => "bo@example.com"}).returns(test_user)
+    Intercom.expects(:get).with("/v1/users", {"email" => "bo@example.com"}).returns(test_user)
     user = Intercom::User.find("email" => "bo@example.com")
     user.email.must_equal "bob@example.com"
     user.name.must_equal "Joe Schmoe"
@@ -93,23 +93,23 @@ describe "Intercom::User" do
 
   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"})
+    Intercom.expects(:post).with("/v1/users", {"email" => "jo@example.com", "user_id" => "i-1224242"}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
     user.save
   end
 
   it "deletes a user" do
-    Intercom.expects(:delete).with("users", {"email" => "jo@example.com", "user_id" => "i-1224242"}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
+    Intercom.expects(:delete).with("/v1/users", {"email" => "jo@example.com", "user_id" => "i-1224242"}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
     Intercom::User.delete("email" => "jo@example.com", "user_id" => "i-1224242")
   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"})
+    Intercom.expects(:post).with("/v1/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})
+    Intercom.expects(:post).with("/v1/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
@@ -123,6 +123,12 @@ describe "Intercom::User" do
     end
   end
 
+  it "allows setting dates to nil without converting them to 0" do
+    Intercom.expects(:post).with("/v1/users", {"email" => "jo@example.com", "created_at" => nil}).returns({"email" => "jo@example.com"})
+    user = Intercom::User.create("email" => "jo@example.com", "created_at" => nil)
+    user.created_at.must_equal nil
+  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)
@@ -152,4 +158,4 @@ describe "Intercom::User" do
     Intercom::User.expects(:find).with(:user_id => "abc123")
     Intercom::User.find_by_user_id("abc123")
   end
-end
+end

data/spec/unit/intercom_spec.rb

@@ -14,11 +14,11 @@ describe Intercom do
     it "raises ArgumentError if no app_id or api_key specified" do
       Intercom.app_id = nil
       Intercom.api_key = nil
-      proc { Intercom.url_for_path("something") }.must_raise ArgumentError, "You must set both Intercom.app_id and Intercom.api_key to use this client. See https://github.com/intercom/intercom-ruby for usage examples."
+      proc { Intercom.target_base_url }.must_raise ArgumentError, "You must set both Intercom.app_id and Intercom.api_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"
+      Intercom.target_base_url.must_equal "https://abc123:super-secret-key@api.intercom.io"
     end
 
     it "raises ResourceNotFound if get a 404" do
@@ -29,6 +29,7 @@ describe Intercom do
       before do
         @protocol = Intercom.protocol
         @hostname = Intercom.hostname
+        Intercom.endpoints = nil
       end
 
       after do
@@ -39,11 +40,35 @@ describe Intercom do
       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"
+        Intercom.target_base_url.must_equal "http://abc123:super-secret-key@localhost:3000"
+      end
+
+      it "prefers endpoints" do
+        Intercom.endpoint = "https://localhost:7654"
+        Intercom.target_base_url.must_equal "https://abc123:super-secret-key@localhost:7654"
+        Intercom.endpoints = unshuffleable_array(["http://example.com","https://localhost:7654"])
+        Intercom.target_base_url.must_equal "http://abc123:super-secret-key@example.com"
+      end
+
+      it "has endpoints" do
+        Intercom.endpoints.must_equal ["https://api.intercom.io"]
+        Intercom.endpoints = ["http://example.com","https://localhost:7654"]
+        Intercom.endpoints.must_equal ["http://example.com","https://localhost:7654"]
+      end
+
+      it "should randomize endpoints if last checked endpoint is > 5 minutes ago" do
+        Intercom.instance_variable_set(:@current_endpoint, "http://start")
+        Intercom.instance_variable_set(:@endpoints, ["http://alternative"])
+        Intercom.instance_variable_set(:@endpoint_randomized_at, Time.now - 120)
+        Intercom.current_endpoint.must_equal "http://start"
+        Intercom.instance_variable_set(:@endpoint_randomized_at, Time.now - 360)
+        Intercom.current_endpoint.must_equal "http://alternative"
+        Intercom.instance_variable_get(:@endpoint_randomized_at).to_i.must_be_close_to Time.now.to_i
       end
     end
   end
 
+
   it "checks for email or user id" do
     proc { Intercom.check_required_params("else") }.must_raise ArgumentError, "Expected params Hash, got String"
     proc { Intercom.check_required_params(:something => "else") }.must_raise ArgumentError, "Either email or user_id must be specified"

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: intercom
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
   prerelease: 
 platform: ruby
 authors:
 - Ben McRedmond
 - Ciaran Lee
 - Darragh Curran
+- Jeff Gardner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-30 00:00:00.000000000 Z
+date: 2013-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -68,6 +69,7 @@ email:
 - ben@intercom.io
 - ciaran@intercom.io
 - darragh@intercom.io
+- jeff@intercom.io
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -94,6 +96,7 @@ files:
 - lib/intercom/user_resource.rb
 - lib/intercom/version.rb
 - spec/integration/intercom_api_integration_spec.rb
+- spec/spec_helper.rb
 - spec/unit/intercom/impression_spec.rb
 - spec/unit/intercom/message_thread_spec.rb
 - spec/unit/intercom/note_spec.rb
@@ -102,8 +105,7 @@ files:
 - spec/unit/intercom/user_resource_spec.rb
 - spec/unit/intercom/user_spec.rb
 - spec/unit/intercom_spec.rb
-- spec/unit/spec_helper.rb
-homepage: http://www.intercom.io
+homepage: https://www.intercom.io
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -129,6 +131,7 @@ specification_version: 3
 summary: Ruby bindings for the Intercom API
 test_files:
 - spec/integration/intercom_api_integration_spec.rb
+- spec/spec_helper.rb
 - spec/unit/intercom/impression_spec.rb
 - spec/unit/intercom/message_thread_spec.rb
 - spec/unit/intercom/note_spec.rb
@@ -137,4 +140,3 @@ test_files:
 - spec/unit/intercom/user_resource_spec.rb
 - spec/unit/intercom/user_spec.rb
 - spec/unit/intercom_spec.rb
-- spec/unit/spec_helper.rb