intercom 1.0.0 → 2.0.0

data/lib/intercom/version.rb

@@ -1,3 +1,3 @@
 module Intercom #:nodoc:
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/spec/spec_helper.rb

@@ -4,27 +4,57 @@ require 'mocha/setup'
 
 def test_user(email="bob@example.com")
   {
-      :user_id => 'id-from-customers-app',
-      :email => email,
-      :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,
-      :unsubscribed_from_emails => true,
-      :avatar_url => "http://google.com/logo.png",
-      :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"
-      }
+    "type" =>"user",
+    "id" =>"aaaaaaaaaaaaaaaaaaaaaaaa",
+    "user_id" => 'id-from-customers-app',
+    "email" => email,
+    "name" => "Joe Schmoe",
+    "avatar" => {"type"=>"avatar", "image_url"=>"https://graph.facebook.com/1/picture?width=24&height=24"},
+    "app_id" => "the-app-id",
+    "created_at" => 1323422442,
+    "custom_attributes" => {"a" => "b", "b" => 2},
+    "companies" =>
+     {"type"=>"company.list",
+      "companies"=>
+       [{"type"=>"company",
+         "company_id"=>"123",
+         "id"=>"bbbbbbbbbbbbbbbbbbbbbbbb",
+         "app_id"=>"the-app-id",
+         "name"=>"Company 1",
+         "remote_created_at"=>1390936440,
+         "created_at"=>1401970114,
+         "updated_at"=>1401970114,
+         "last_request_at"=>1401970113,
+         "monthly_spend"=>0,
+         "session_count"=>0,
+         "user_count"=>1,
+         "tag_ids"=>[],
+         "custom_attributes"=>{"category"=>"Tech"}}]},
+    "session_count" => 123,
+    "unsubscribed_from_emails" => true,
+    "last_request_at" =>1401970113,
+    "created_at" =>1401970114,
+    "remote_created_at" =>1393613864,
+    "updated_at" =>1401970114,
+    "user_agent_data" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11",
+    "social_profiles" =>{"type"=>"social_profile.list",
+       "social_profiles" => [
+           {"type" => "social_profile", "name" => "twitter", "url" => "http://twitter.com/abc", "username" => "abc", "id" => nil},
+           {"type" => "social_profile", "name" => "twitter", "username" => "abc2", "url" => "http://twitter.com/abc2", "id" => nil},
+           {"type" => "social_profile", "name" => "facebook", "url" => "http://facebook.com/abc", "username" => "abc", "id" => "1234242"},
+           {"type" => "social_profile", "name" => "quora", "url" => "http://facebook.com/abc", "username" => "abc", "id" => "1234242"}
+       ]},
+   "location_data"=>
+    {"type"=>"location_data",
+     "city_name"=> 'Dublin',
+     "continent_code"=> 'EU',
+     "country_name"=> 'Ireland',
+     "latitude"=> '90',
+     "longitude"=> '10',
+     "postal_code"=> 'IE',
+     "region_name"=> 'Europe',
+     "timezone"=> '+1000',
+     "country_code" => "IRL"}
   }
 end
 
@@ -77,19 +107,20 @@ def test_message
   }
 end
 
-def page_of_users(page=1, per_page=10)
-  all_users = [test_user("user1@example.com"), test_user("user2@example.com"), test_user("user3@example.com")]
-  offset = (page - 1) * per_page
-  limit = page * per_page
-  next_page = limit < all_users.size ? page + 1 : nil
-  previous_page = offset > 0 ? page - 1 : nil
+def page_of_users(include_next_link: false)
+  all_user =
   {
-      "users" => all_users[offset..limit-1],
-      "total_count" => all_users.size,
-      "page" => page,
-      "next_page" => next_page,
-      "previous_page" => previous_page,
-      "total_pages" => (all_users.size.to_f / per_page).ceil.to_i
+     "type"=>"user.list",
+     "pages"=>
+      {
+        "type"=>"pages",
+        "next"=> (include_next_link ? "https://api.intercom.io/users?per_page=50&page=2" : nil),
+        "page"=>1,
+        "per_page"=>50,
+        "total_pages"=>7
+      },
+      "users"=> [test_user("user1@example.com"), test_user("user2@example.com"), test_user("user3@example.com")],
+      "total_count"=>314
   }
 end
 

data/spec/unit/intercom/collection_proxy_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Intercom::CollectionProxy do
+
+  it "stops iterating if no next link" do
+    Intercom.expects(:get).with("/users", {}).returns(page_of_users(include_next_link:false))
+    emails = []
+    Intercom::User.all.each { |user| emails << user.email }
+    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+  end
+
+  it "keeps iterating if next link" do
+    Intercom.expects(:get).with("/users", {}).returns(page_of_users(include_next_link:true))
+    Intercom.expects(:get).with('https://api.intercom.io/users?per_page=50&page=2', {}).returns(page_of_users(include_next_link:false))
+    emails = []
+    Intercom::User.all.each { |user| emails << user.email }
+  end
+
+  it "supports indexed array access" do
+    Intercom.expects(:get).with("/users", {}).returns(page_of_users(include_next_link:false))
+    Intercom::User.all[0].email.must_equal 'user1@example.com'
+  end
+
+  it "supports map" do
+    Intercom.expects(:get).with("/users", {}).returns(page_of_users(include_next_link:false))
+    emails = Intercom::User.all.map { |user| user.email }
+    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+  end
+
+  it "supports querying" do
+    Intercom.expects(:get).with("/users", {:tag_name => 'Taggart J'}).returns(page_of_users(include_next_link:false))
+    Intercom::User.find_all(:tag_name => 'Taggart J').map(&:email).must_equal %W(user1@example.com user2@example.com user3@example.com)
+  end
+end

data/spec/unit/intercom/event_spec.rb

@@ -0,0 +1,25 @@
+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 with metadata" do
+    Intercom.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)
+
+    Intercom::Event.create(:event_name => "Eventful 1", :created_at => created_time,
+                                   :email => 'joe@example.com',
+                                   :metadata => {
+                                     "invitee_email" => "pi@example.org",
+                                     :invite_code => "ADDAFRIEND",
+                                     "found_date" => 12909364407
+    })
+  end
+
+  it "creates an event without metadata" do
+    Intercom.expects(:post).with('/events', {'event_name' => 'sale of item', 'email' => 'joe@example.com'})
+    Intercom::Event.create(:event_name => "sale of item", :email => 'joe@example.com')
+  end
+ 
+end

data/spec/unit/intercom/{flat_store_spec.rb → lib/flat_store_spec.rb}

@@ -1,29 +1,29 @@
 require "spec_helper"
 
-describe Intercom::FlatStore do
+describe Intercom::Lib::FlatStore do
   it "raises if you try to set or merge in nested hash structures" do
-    data = Intercom::FlatStore.new()
+    data = Intercom::Lib::FlatStore.new()
     proc { data["thing"] = [1] }.must_raise ArgumentError
     proc { data["thing"] = {1 => 2} }.must_raise ArgumentError
-    proc { Intercom::FlatStore.new({1 => {2 => 3}}) }.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::FlatStore.new()
+    data =Intercom::Lib::FlatStore.new()
     proc { data[1] = "something" }.must_raise ArgumentError
   end
 
   it "sets and merges valid entries" do
-    data = Intercom::FlatStore.new()
+    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::FlatStore.new({"a" => 1, :b => 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
+end

data/spec/unit/intercom/note_spec.rb

@@ -1,18 +1,19 @@
 require "spec_helper"
 
-describe "/v1/notes" do
+describe "notes" do
   it "creates a note" do
-    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})
+    Intercom.expects(:post).with("/notes", {"body" => "Note to leave on user"}).returns({"body" => "<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>"
+    note.body.must_equal "<p>Note to leave on user</p>"
   end
 
   it "sets/gets allowed keys" do
     params = {"body" => "Note body", "email" => "me@example.com", :user_id => "abc123"}
     note = Intercom::Note.new(params)
+
     note.to_hash.keys.sort.must_equal params.keys.map(&:to_s).sort
     params.keys.each do | key|
       note.send(key).must_equal params[key]
     end
   end
-end
+end

data/spec/unit/intercom/tag_spec.rb

@@ -2,19 +2,19 @@ require 'spec_helper'
 
 describe "Intercom::Tag" do
   it "gets a tag" do
-    Intercom.expects(:get).with("/v1/tags", {:name => "Test Tag"}).returns(test_tag)
+    Intercom.expects(:get).with("/tags", {:name => "Test Tag"}).returns(test_tag)
     tag = Intercom::Tag.find(:name => "Test Tag")
     tag.name.must_equal "Test Tag"
   end
 
   it "creates a tag" do
-    Intercom.expects(:post).with("/v1/tags", {:name => "Test Tag"}).returns(test_tag)
+    Intercom.expects(:post).with("/tags", {'name' => "Test Tag"}).returns(test_tag)
     tag = Intercom::Tag.create(:name => "Test Tag")
     tag.name.must_equal "Test Tag"
   end
 
   it "tags users" do
-    Intercom.expects(:post).with("/v1/tags", {:name => "Test Tag", :user_ids => ["abc123", "def456"], :tag_or_untag => "tag"}).returns(test_tag)
+    Intercom.expects(:post).with("/tags", {'name' => "Test Tag", 'user_ids' => ["abc123", "def456"], 'tag_or_untag' => "tag"}).returns(test_tag)
     tag = Intercom::Tag.create(:name => "Test Tag", :user_ids => ["abc123", "def456"], :tag_or_untag => "tag")
     tag.name.must_equal "Test Tag"
     tag.tagged_user_count.must_equal 2

data/spec/unit/intercom/traits/api_resource_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+describe Intercom::Traits::ApiResource do
+  let(:object_json) do
+    {"type"=>"company",
+     "id"=>"aaaaaaaaaaaaaaaaaaaaaaaa",
+     "app_id"=>"some-app-id",
+     "name"=>"SuperSuite",
+     "plan_id"=>1,
+     "remote_company_id"=>"8",
+     "remote_created_at"=>103201,
+     "created_at"=>1374056196,
+     "user_count"=>1,
+     "custom_attributes"=>{}}
+  end
+  let(:api_resource) { Object.new.extend(Intercom::Traits::ApiResource)}
+
+  before(:each) { api_resource.from_response(object_json) }
+
+  it "does not set type on parsing json" do
+    assert_nil api_resource.instance_variable_get(:@type)
+    api_resource.wont_respond_to :type
+  end
+
+  it "coerces time on parsing json" do
+    assert_equal Time.at(1374056196), api_resource.created_at
+  end
+
+  it "exposes string" do
+    assert_equal Time.at(1374056196), api_resource.created_at
+  end
+
+  it "dynamically defines accessors when a non-existent property is called that looks like a setter" do
+    api_resource.wont_respond_to :spiders
+    api_resource.spiders = 4
+    api_resource.must_respond_to :spiders
+  end
+
+  it "calls dynamically defined getter when asked" do
+    api_resource.foo = 4
+    assert_equal 4, api_resource.foo
+  end
+
+  it "accepts unix timestamps into dynamically defined date setters" do
+    api_resource.foo_at = 1401200468
+    assert_equal 1401200468, api_resource.instance_variable_get(:@foo_at)
+  end
+
+  it "exposes dates correctly for dynamically defined getters" do
+    api_resource.foo_at = 1401200468
+    assert_equal Time.at(1401200468), api_resource.foo_at
+  end
+
+  it "throws regular method missing error when non-existent getter is called that is backed by an instance variable" do
+    api_resource.instance_variable_set(:@bar, 'you cant see me')
+    proc { api_resource.bar }.must_raise NoMethodError
+  end
+
+  it "throws attribute not set error when non-existent getter is called that is not backed by an instance variable" do
+    proc { api_resource.flubber }.must_raise Intercom::AttributeNotSetError
+  end
+
+  it "throws regular method missing error when non-existent method is called that cannot be an accessor" do
+    proc { api_resource.flubber! }.must_raise NoMethodError
+    proc { api_resource.flubber? }.must_raise NoMethodError
+  end
+
+  it "throws regular method missing error when non-existent setter is called with multiple arguments" do
+    proc { api_resource.send(:flubber=, 'a', 'b') }.must_raise NoMethodError
+  end
+
+  it "an initialized ApiResource is equal to on generated from a response" do
+    class ConcreteApiResource; include Intercom::Traits::ApiResource; end
+    initialized_api_resource = ConcreteApiResource.new(object_json)
+    object_json.except('type').keys.each do |attribute|
+      assert_equal initialized_api_resource.send(attribute), api_resource.send(attribute)
+    end
+  end
+end

data/spec/unit/intercom/user_spec.rb

@@ -3,7 +3,7 @@ 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")
+    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"
@@ -20,99 +20,97 @@ describe "Intercom::User" do
     user.last_impression_at.to_s.must_equal now.to_s
   end
 
-  it "is ok on missing methods" do
+  it "is throws a Intercom::AttributeNotSetError on trying to access an attribute that has not been set" 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([])
+    proc { user.foo_property }.must_raise Intercom::AttributeNotSetError
   end
 
   it "presents a complete user record correctly" do
     user = Intercom::User.from_api(test_user)
+    user.user_id.must_equal 'id-from-customers-app'
+    user.email.must_equal 'bob@example.com'
+    user.name.must_equal 'Joe Schmoe'
+    user.app_id.must_equal 'the-app-id'
     user.session_count.must_equal 123
+    user.created_at.to_i.must_equal 1401970114
+    user.remote_created_at.to_i.must_equal 1393613864
+    user.updated_at.to_i.must_equal 1401970114
+
+    user.avatar.must_be_kind_of Intercom::Avatar
+    user.avatar.image_url.must_equal 'https://graph.facebook.com/1/picture?width=24&height=24'
+
+    user.companies.must_be_kind_of Array
+    user.companies.size.must_equal 1
+    user.companies[0].must_be_kind_of Intercom::Company
+    user.companies[0].company_id.must_equal "123"
+    user.companies[0].id.must_equal "bbbbbbbbbbbbbbbbbbbbbbbb"
+    user.companies[0].app_id.must_equal "the-app-id"
+    user.companies[0].name.must_equal "Company 1"
+    user.companies[0].remote_created_at.to_i.must_equal 1390936440
+    user.companies[0].created_at.to_i.must_equal 1401970114
+    user.companies[0].updated_at.to_i.must_equal 1401970114
+    user.companies[0].last_request_at.to_i.must_equal 1401970113
+    user.companies[0].monthly_spend.must_equal 0
+    user.companies[0].session_count.must_equal 0
+    user.companies[0].user_count.must_equal 1
+    user.companies[0].tag_ids.must_equal []
+
+    user.custom_attributes.must_be_kind_of Intercom::Lib::FlatStore
+    user.custom_attributes["a"].must_equal "b"
+    user.custom_attributes["b"].must_equal 2
+
     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.name.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"
-    user.avatar_url.must_equal "http://google.com/logo.png"
-    user.unsubscribed_from_emails.must_equal true
-    user.location_data['country_code'].must_equal "IRL"
-  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 error_on_modify_frozen, "can't modify frozen array"
-    proc { Intercom::User.new.social_profiles << "a" }.must_raise error_on_modify_frozen, "can't modify frozen array"
-  end
+    user.location_data.must_be_kind_of Intercom::LocationData
+    user.location_data.city_name.must_equal "Dublin"
+    user.location_data.continent_code.must_equal "EU"
+    user.location_data.country_name.must_equal "Ireland"
+    user.location_data.latitude.must_equal "90"
+    user.location_data.longitude.must_equal "10"
+    user.location_data.country_code.must_equal "IRL"
 
-  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 error_on_modify_frozen, "can't modify frozen hash"
-    user.to_hash["location_data"].must_equal nil
+    user.unsubscribed_from_emails.must_equal true
+    user.user_agent_data.must_equal "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11"
   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.to_i
-    user.custom_data["thing"] = "yay"
-    user.to_hash["custom_data"].must_equal "mad" => 123, "other" => now.to_i, "thing" => "yay"
-  end
-
-  it "allows easy setting of company data" do
-    user = Intercom::User.new()
-    user.company["name"] = "Intercom"
-    user.company["id"] = 6
-    user.to_hash["company"].must_equal "name" => "Intercom", "id" => 6
+    user = Intercom::User.new
+    user.custom_attributes["mad"] = 123
+    user.custom_attributes["other"] = now.to_i
+    user.custom_attributes["thing"] = "yay"
+    user.to_hash["custom_attributes"].must_equal "mad" => 123, "other" => now.to_i, "thing" => "yay"
   end
 
   it "allows easy setting of multiple companies" do
     user = Intercom::User.new()
     companies = [
-      {"name" => "Intercom", "id" => "6"},
-      {"name" => "Test", "id" => "9"}
+      {"name" => "Intercom", "company_id" => "6"},
+      {"name" => "Test", "company_id" => "9"}
     ]
     user.companies = companies
     user.to_hash["companies"].must_equal companies
   end
 
-  it "rejects setting companies without an array of hashes" do
+  it "rejects nested data structures in custom_attributes" do
     user = Intercom::User.new()
-    proc { user.companies = {"name" => "test"} }.must_raise ArgumentError
-    proc { user.companies = [ ["name", "test"] ]}.must_raise ArgumentError
-  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
-    proc { user.custom_data = {1 => {2 => 3}} }.must_raise ArgumentError
+    proc { user.custom_attributes["thing"] = [1] }.must_raise ArgumentError
+    proc { user.custom_attributes["thing"] = {1 => 2} }.must_raise ArgumentError
+    proc { user.custom_attributes = {1 => {2 => 3}} }.must_raise ArgumentError
 
     user = Intercom::User.from_api(test_user)
-    proc { user.custom_data["thing"] = [1] }.must_raise ArgumentError
+    proc { user.custom_attributes["thing"] = [1] }.must_raise ArgumentError
   end
 
-  describe "incrementing custom_data fields" do
+  describe "incrementing custom_attributes fields" do
     before :each do
       @now = Time.now
-      @user = Intercom::User.new("email" => "jo@example.com", :user_id => "i-1224242", :custom_data => {"mad" => 123, "another" => 432, "other" => @now.to_i, :thing => "yay"})
+      @user = Intercom::User.new("email" => "jo@example.com", :user_id => "i-1224242", :custom_attributes => {"mad" => 123, "another" => 432, "other" => @now.to_i, :thing => "yay"})
     end
 
     it "increments up by 1 with no args" do
@@ -131,8 +129,8 @@ describe "Intercom::User" do
     end
 
     it "doesn't allow direct access to increments hash" do
-      proc { @user.increments["mad"] = 1 }.must_raise NoMethodError
-      proc { @user.increments }.must_raise NoMethodError
+      proc { @user.increments["mad"] = 1 }.must_raise Intercom::AttributeNotSetError
+      proc { @user.increments }.must_raise Intercom::AttributeNotSetError
     end
 
     it "can update the increments hash without losing previous changes" do
@@ -155,67 +153,59 @@ describe "Intercom::User" do
   end
 
   it "fetches a user" do
-    Intercom.expects(:get).with("/v1/users", {"email" => "bo@example.com"}).returns(test_user)
+    Intercom.expects(:get).with("/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"
     user.session_count.must_equal 123
   end
 
-  it "saves a user" do
+  it "saves a user (always sends custom_attributes)" do
     user = Intercom::User.new("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"})
+    Intercom.expects(:post).with("/users", {"email" => "jo@example.com", "user_id" => "i-1224242", "custom_attributes" => {}}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
     user.save
   end
 
   it "saves a user with a company" do
-    user = Intercom::User.new("email" => "jo@example.com", :user_id => "i-1224242", :company => {:id => 6, :name => "Intercom"})
-    Intercom.expects(:post).with("/v1/users", {"email" => "jo@example.com", "user_id" => "i-1224242", "company" => {"id" => 6, "name" => "Intercom"}}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
+    user = Intercom::User.new("email" => "jo@example.com", :user_id => "i-1224242", :company => {'company_id' => 6, 'name' => "Intercom"})
+    Intercom.expects(:post).with("/users", {'custom_attributes' => {}, "user_id" => "i-1224242", "email" => "jo@example.com", "company" => {"company_id" => 6, "name" => "Intercom"}}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
     user.save
   end
 
   it "saves a user with a companies" do
-    user = Intercom::User.new("email" => "jo@example.com", :user_id => "i-1224242", :companies => [{:id => 6, :name => "Intercom"}])
-    Intercom.expects(:post).with("/v1/users", {"email" => "jo@example.com", "user_id" => "i-1224242", "companies" => [{"id" => 6, "name" => "Intercom"}]}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
+    user = Intercom::User.new("email" => "jo@example.com", :user_id => "i-1224242", :companies => [{'company_id' => 6, 'name' => "Intercom"}])
+    Intercom.expects(:post).with("/users", {'custom_attributes' => {}, "email" => "jo@example.com", "user_id" => "i-1224242", "companies" => [{"company_id" => 6, "name" => "Intercom"}]}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
     user.save
   end
 
   it "deletes a user" do
-    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")
+    user = Intercom::User.new("id" => "1")
+    Intercom.expects(:delete).with("/users/1", {}).returns(user)
+    user.delete
   end
 
   it "can use User.create for convenience" do
-    Intercom.expects(:post).with("/v1/users", {"email" => "jo@example.com", "user_id" => "i-1224242"}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
+    Intercom.expects(:post).with("/users", {'custom_attributes' => {}, "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("/v1/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("/users", {"email" => "jo@example.com", "user_id" => "i-1224242", 'custom_attributes' => {}}).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 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 "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
+    Intercom.expects(:post).with("/users", {"email" => "jo@example.com", 'custom_attributes' => {}, "remote_created_at" => nil}).returns({"email" => "jo@example.com"})
+    user = Intercom::User.create("email" => "jo@example.com", "remote_created_at" => nil)
+    user.remote_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)
-    user.to_hash.keys.sort.must_equal params.keys.map(&:to_s).sort
+    user.to_hash.keys.sort.must_equal (params.keys + ['custom_attributes']).map(&:to_s).sort
     params.keys.each do |key|
       user.send(key).to_s.must_equal params[key].to_s
     end
@@ -226,49 +216,41 @@ describe "Intercom::User" do
     user.new_param.must_equal "some value"
   end
 
-  it "returns a UserCollectionProxy for all without making any requests" do
+  it "returns a CollectionProxy for all without making any requests" do
     Intercom.expects(:execute_request).never
     all = Intercom::User.all
-    all.must_be_instance_of(Intercom::UserCollectionProxy)
+    all.must_be_instance_of(Intercom::CollectionProxy)
   end
 
   it "returns the total number of users" do
-    Intercom.expects(:get).with("/v1/users", {:per_page => 1}).returns(page_of_users)
-    Intercom::User.count.must_be_kind_of(Integer)
+    Intercom::Count.expects(:user_count).returns('count_info')
+    Intercom::User.count
   end
 
-  it "can find_by_email" do
-    Intercom::User.expects(:find).with(:email => "bob@example.com")
-    Intercom::User.find_by_email("bob@example.com")
-  end
+ ##TODO: Investigate
+  #it "converts company created_at values to unix timestamps" do
+  #  time = Time.now
 
-  it "can find_by_user_id" do
-    Intercom::User.expects(:find).with(:user_id => "abc123")
-    Intercom::User.find_by_user_id("abc123")
-  end
+  #  user = Intercom::User.new("companies" => [
+  #    { "created_at" => time },
+  #    { "created_at" => time.to_i }
+  #  ])
 
-  it "converts company created_at values to unix timestamps" do
-    time = Time.now
+  #  as_hash = user.to_hash
+  #  require 'ruby-debug' ; debugger
+  #  first_company_as_hash = as_hash["companies"][0]
+  #  second_company_as_hash = as_hash["companies"][1]
 
-    user = Intercom::User.new("companies" => [
-      { "created_at" => time },
-      { "created_at" => time.to_i }
-    ])
-
-    as_hash = user.to_hash
-    first_company_as_hash = as_hash["companies"][0]
-    second_company_as_hash = as_hash["companies"][1]
-
-    first_company_as_hash["created_at"].must_equal time.to_i
-    second_company_as_hash["created_at"].must_equal time.to_i
-  end
+  #  first_company_as_hash["created_at"].must_equal time.to_i
+  #  second_company_as_hash["created_at"].must_equal time.to_i
+  #end
   
-  it "tracks events" do
-    user = Intercom::User.new("email" => "jim@example.com", :user_id => "12345", :created_at => Time.now, :name => "Jim Bob")
-    Intercom::Event.expects(:create).with(:event_name => 'registration', :user => user)
-    event = user.track_event('registration')
+#  it "tracks events" do
+#    user = Intercom::User.new("email" => "jim@example.com", :user_id => "12345", :created_at => Time.now, :name => "Jim Bob")
+#    Intercom::Event.expects(:create).with(:event_name => 'registration', :user => user)
+#    event = user.track_event('registration')
     
-    Intercom::Event.expects(:create).with(:event_name => 'another', :user => user, :created_at => 1391691571)
-    event = user.track_event("another", {:created_at => 1391691571})
-  end
+#    Intercom::Event.expects(:create).with(:event_name => 'another', :user => user, :created_at => 1391691571)
+#    event = user.track_event("another", {:created_at => 1391691571})
+#  end
 end