cogniteev-intercom 2.5.4

data/spec/unit/intercom/admin_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe "Intercom::Admin" do
+  it "returns a CollectionProxy for all without making any requests" do
+    Intercom.expects(:execute_request).never
+    all = Intercom::Admin.all
+    all.must_be_instance_of(Intercom::CollectionProxy)
+  end
+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(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(true))
+    Intercom.expects(:get).with('https://api.intercom.io/users?per_page=50&page=2', {}).returns(page_of_users(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(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(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(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/company_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Intercom::Company do
+  
+  describe 'when no response raises error' do
+    it 'on find' do
+      Intercom.expects(:get).with("/companies", {:company_id => '4'}).returns(nil)
+      proc {Intercom::Company.find(:company_id => '4')}.must_raise Intercom::HttpError
+    end
+    
+    it 'on find_all' do
+      Intercom.expects(:get).with("/companies", {}).returns(nil)
+      proc {Intercom::Company.all.each {|company| }}.must_raise Intercom::HttpError
+    end
+    
+    it 'on load' do
+      Intercom.expects(:get).with("/companies", {:company_id => '4'}).returns({'type' =>'user', 'id' =>'aaaaaaaaaaaaaaaaaaaaaaaa', 'company_id' => '4', 'name' => 'MyCo'})
+      company = Intercom::Company.find(:company_id => '4')
+      Intercom.expects(:get).with('/companies/aaaaaaaaaaaaaaaaaaaaaaaa', {}).returns(nil)
+      proc {company.load}.must_raise Intercom::HttpError
+    end
+  end
+end

data/spec/unit/intercom/contact_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe "Intercom::Contact" do
+  it 'should not throw ArgumentErrors when there are no parameters' do
+    Intercom.expects(:post)
+    Intercom::Contact.create
+  end
+
+  describe 'converting' do
+    let(:contact) { Intercom::Contact.from_api(user_id: 'contact_id') }
+    let(:user) { Intercom::User.from_api(id: 'user_id') }
+
+    it do
+      Intercom.expects(:post).with(
+        "/contacts/convert",
+        {
+          contact: { user_id: contact.user_id },
+          user: user.identity_hash
+        }
+      ).returns(test_user)
+
+      contact.convert(user)
+    end
+  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/lib/flat_store_spec.rb

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

data/spec/unit/intercom/message_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe "Intercom::Message" do
+
+  let (:user) {Intercom::User.new("email" => "jim@example.com", :user_id => "12345", :created_at => Time.now, :name => "Jim Bob")}
+
+  it 'creates an user message with symbol keys' do
+    Intercom.expects(:post).with('/messages', {'from' => { :type => 'user', :email => 'jim@example.com'}, 'body' => 'halp'}).returns(:status => 200)
+    Intercom::Message.create(:from => { :type => "user", :email => "jim@example.com" }, :body => "halp")
+  end
+  
+  it "creates an user message with string keys" do
+    Intercom.expects(:post).with('/messages', {'from' => { 'type' => 'user', 'email' => 'jim@example.com'}, 'body' => 'halp'}).returns(:status => 200)
+    Intercom::Message.create('from' => { 'type' => "user", 'email' => "jim@example.com" }, 'body' => "halp")
+  end
+  
+  it "creates a admin message" do
+    Intercom.expects(:post).with('/messages', {'from' => { 'type' => "admin", 'id' => "1234" }, 'to' => { 'type' => 'user', 'id' => '5678' }, 'body' => 'halp', 'message_type' => 'inapp'}).returns(:status => 200)
+    Intercom::Message.create('from' => { 'type' => "admin", 'id' => "1234" }, :to => { 'type' => 'user', 'id' => '5678' }, 'body' => "halp", 'message_type' => 'inapp')
+  end
+end

data/spec/unit/intercom/note_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe "notes" do
+  it "creates a note" do
+    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.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

data/spec/unit/intercom/notification_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe "Intercom::Notification" do
+
+  it "converts notification hash to object" do
+    payload = Intercom::Notification.new(test_user_notification)
+    payload.must_be_instance_of Intercom::Notification
+  end
+
+  it "returns correct model type for User" do
+    payload = Intercom::Notification.new(test_user_notification)
+    payload.model_type.must_equal Intercom::User
+  end
+
+  it "returns correct User notification topic" do
+    payload = Intercom::Notification.new(test_user_notification)
+    payload.topic.must_equal "user.created"
+  end
+
+  it "returns instance of User" do
+    payload = Intercom::Notification.new(test_user_notification)
+    payload.model.must_be_instance_of Intercom::User
+  end
+
+  it "returns instance of Conversation" do
+    payload = Intercom::Notification.new(test_conversation_notification)
+    payload.model.must_be_instance_of Intercom::Conversation
+  end
+
+  it "returns correct model type for Conversation" do
+    payload = Intercom::Notification.new(test_conversation_notification)
+    payload.model_type.must_equal Intercom::Conversation
+  end
+
+  it "returns correct Conversation notification topic" do
+    payload = Intercom::Notification.new(test_conversation_notification)
+    payload.topic.must_equal "conversation.user.created"
+  end
+
+  it "returns inner User object for Conversation" do
+    payload = Intercom::Notification.new(test_conversation_notification)
+    payload.model.user.must_be_instance_of Intercom::User
+  end
+  
+  it "returns inner User object with nil tags" do
+    user_notification = {
+      "type" => "notification_event",
+      "app_id" => "aa11aa",
+      "data" => {
+        "type" => "notification_event_data",
+        "item" => {
+          "type" => "user",
+          "id" => "abc123def",
+          "user_id" => "666",
+          "email" => "joe@example.com",
+          "name" => "Joe",
+          "tags" => {
+            "type" => "tag.list",
+            "tags" => nil
+          }
+        }
+      },  
+    }
+    payload = Intercom::Notification.new(user_notification)
+    payload.model.tags.must_equal([])
+  end
+
+end

data/spec/unit/intercom/request_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe 'Intercom::Request' do
+  it 'raises an error when a html error page rendered' do
+    response = OpenStruct.new(:code => 500)
+    req = Intercom::Request.new('path/', 'GET')
+    proc {req.parse_body('<html>somethjing</html>', response)}.must_raise(Intercom::ServerError)
+  end
+
+  it 'parse_body returns nil if decoded_body is nil' do
+    response = OpenStruct.new(:code => 500)
+    req = Intercom::Request.new('path/', 'GET')
+    req.parse_body(nil, response).must_equal(nil)
+  end
+end

data/spec/unit/intercom/subscription_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe "Intercom::Subscription" do
+  it "gets a subscription" do
+    Intercom.expects(:get).with("/subscriptions/nsub_123456789", {}).returns(test_subscription)
+    subscription = Intercom::Subscription.find(:id => "nsub_123456789")
+    subscription.request.topics[0].must_equal "user.created"
+    subscription.request.topics[1].must_equal "conversation.user.replied"
+  end
+
+  it "creates a subscription" do
+    Intercom.expects(:post).with("/subscriptions", {'url' => "http://example.com", 'topics' => ["user.created"]}).returns(test_subscription)
+    subscription = Intercom::Subscription.create(:url => "http://example.com", :topics => ["user.created"])
+    subscription.request.topics[0].must_equal "user.created"
+    subscription.request.url.must_equal "http://example.com"
+  end
+
+end

data/spec/unit/intercom/tag_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "Intercom::Tag" do
+  it "gets a tag" do
+    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("/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("/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
+  end
+
+end

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

@@ -0,0 +1,85 @@
+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) { DummyClass.new.extend(Intercom::Traits::ApiResource)}
+
+  before(:each) { api_resource.from_response(object_json) }
+
+  it "does not set type on parsing json" do
+    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)
+    except(object_json, 'type').keys.each do |attribute|
+      assert_equal initialized_api_resource.send(attribute), api_resource.send(attribute)
+    end
+  end
+  
+  def except(h, *keys)
+    keys.each { |key| h.delete(key) }
+    h
+  end
+  
+  class DummyClass; end
+end

data/spec/unit/intercom/user_spec.rb

@@ -0,0 +1,230 @@
+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 throws a Intercom::AttributeNotSetError on trying to access an attribute that has not been set" do
+    user = Intercom::User.new
+    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.name.must_equal "twitter"
+    twitter_account.username.must_equal "abc"
+    twitter_account.url.must_equal "http://twitter.com/abc"
+
+    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"
+
+    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 update_last_request_at' do
+    Intercom.expects(:post).with("/users", {"user_id" => "1224242", 'update_last_request_at' => true, "custom_attributes" => {}}).returns({"user_id" => "i-1224242", "last_request_at" => 1414509439})
+    Intercom::User.create(user_id:'1224242', update_last_request_at:true)
+  end
+
+  it "allows easy setting of custom data" do
+    now = Time.now
+    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", "company_id" => "6"},
+      {"name" => "Test", "company_id" => "9"}
+    ]
+    user.companies = companies
+    user.to_hash["companies"].must_equal companies
+  end
+
+  it "rejects nested data structures in custom_attributes" do
+    user = Intercom::User.new()
+    
+    proc { user.custom_attributes["thing"] = [1] }.must_raise(ArgumentError)
+    proc { user.custom_attributes["thing"] = {1 => 2} }.must_raise(ArgumentError)
+    proc { user.custom_attributes["thing"] = {1 => {2 => 3}} }.must_raise(ArgumentError)
+
+    user = Intercom::User.from_api(test_user)
+    proc { user.custom_attributes["thing"] = [1] }.must_raise(ArgumentError)
+  end
+
+  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_attributes => {"mad" => 123, "another" => 432, "other" => @now.to_i, :thing => "yay"})
+    end
+
+    it "increments up by 1 with no args" do
+      @user.increment("mad")
+      @user.to_hash["custom_attributes"]["mad"].must_equal 124
+    end
+
+    it "increments up by given value" do
+      @user.increment("mad", 4)
+      @user.to_hash["custom_attributes"]["mad"].must_equal 127
+    end
+
+    it "increments down by given value" do
+      @user.increment("mad", -1)
+      @user.to_hash["custom_attributes"]["mad"].must_equal 122
+    end
+
+    it "can increment new custom data fields" do
+      @user.increment("new_field", 3)
+      @user.to_hash["custom_attributes"]["new_field"].must_equal 3
+    end
+
+    it "can call increment on the same key twice and increment by 2" do
+      @user.increment("mad")
+      @user.increment("mad")
+      @user.to_hash["custom_attributes"]["mad"].must_equal 125
+    end
+  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 "bob@example.com"
+    user.name.must_equal "Joe Schmoe"
+    user.session_count.must_equal 123
+  end
+
+  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("/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 => {'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 => [{'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 'can save a user with a nil email' do
+    user = Intercom::User.new("email" => nil, :user_id => "i-1224242", :companies => [{'company_id' => 6, 'name' => "Intercom"}])
+    Intercom.expects(:post).with("/users", {'custom_attributes' => {}, "email" => nil, "user_id" => "i-1224242", "companies" => [{"company_id" => 6, "name" => "Intercom"}]}).returns({"email" => nil, "user_id" => "i-1224242"})
+    user.save
+  end
+
+  it "deletes a user" do
+    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("/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("/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 "allows setting dates to nil without converting them to 0" do
+    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)
+    custom_attributes = (params.keys + ['custom_attributes']).map(&:to_s).sort
+    user.to_hash.keys.sort.must_equal custom_attributes
+    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
+
+  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::CollectionProxy)
+  end
+
+  it "returns the total number of users" do
+    Intercom::Count.expects(:user_count).returns('count_info')
+    Intercom::User.count
+  end  
+end