intercom 3.9.5 → 4.0.0

data/spec/unit/intercom/search_collection_proxy_spec.rb

@@ -1,56 +1,60 @@
 require "spec_helper"
 
 describe Intercom::SearchCollectionProxy do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
-  it "send query to the customer search endpoint" do
-    client.expects(:post).with("/customers/search", { query: {} }).  returns(page_of_customers(false))
-    client.customers.search(query: {}).first
+  it "sends query to the contact search endpoint" do
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(false))
+    client.contacts.search(query: {}).first
   end
 
-  it "send query to the customer search endpoint with sort_field" do
-    client.expects(:post).with("/customers/search", { query: {}, sort: { field: "name" } }).  returns(page_of_customers(false))
-    client.customers.search(query: {}, sort_field: "name").first
+  it "sends query to the conversation search endpoint" do
+    client.expects(:post).with("/conversations/search", { query: {} }).returns(test_conversation_list)
+    client.conversations.search(query: {}).first
   end
 
-  it "send query to the customer search endpoint with sort_field and sort_order" do
-    client.expects(:post).with("/customers/search", { query: {}, sort: { field: "name", order: "ascending" } }).  returns(page_of_customers(false))
-    client.customers.search(query: {}, sort_field: "name", sort_order: "ascending").first
+  it "sends query to the contact search endpoint with sort_field" do
+    client.expects(:post).with("/contacts/search", { query: {}, sort: { field: "name" } }).returns(page_of_contacts(false))
+    client.contacts.search(query: {}, sort_field: "name").first
   end
 
-  it "send query to the customer search endpoint with per_page" do
-    client.expects(:post).with("/customers/search", { query: {}, pagination: { per_page: 10 }}).  returns(page_of_customers(false))
-    client.customers.search(query: {}, per_page: 10).first
+  it "sends query to the contact search endpoint with sort_field and sort_order" do
+    client.expects(:post).with("/contacts/search", { query: {}, sort: { field: "name", order: "ascending" } }).returns(page_of_contacts(false))
+    client.contacts.search(query: {}, sort_field: "name", sort_order: "ascending").first
   end
 
-  it "send query to the customer search endpoint with starting_after" do
-    client.expects(:post).with("/customers/search", { query: {}, pagination: { starting_after: "EnCrYpTeDsTrInG" }}).  returns(page_of_customers(false))
-    client.customers.search(query: {}, starting_after: "EnCrYpTeDsTrInG").first
+  it "sends query to the contact search endpoint with per_page" do
+    client.expects(:post).with("/contacts/search", { query: {}, pagination: { per_page: 10 }}).returns(page_of_contacts(false))
+    client.contacts.search(query: {}, per_page: 10).first
+  end
+
+  it "sends query to the contact search endpoint with starting_after" do
+    client.expects(:post).with("/contacts/search", { query: {}, pagination: { starting_after: "EnCrYpTeDsTrInG" }}).returns(page_of_contacts(false))
+    client.contacts.search(query: {}, starting_after: "EnCrYpTeDsTrInG").first
   end
 
   it "stops iterating if no starting_after value" do
-    client.expects(:post).with("/customers/search", { query: {} }).  returns(page_of_customers(false))
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(false))
     emails = []
-    client.customers.search(query: {}).each { |user| emails << user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+    client.contacts.search(query: {}).each { |contact| emails << contact.email }
+    _(emails).must_equal %w[test1@example.com test2@example.com test3@example.com]
   end
 
   it "keeps iterating if starting_after value" do
-    client.expects(:post).with("/customers/search", { query: {} }).returns(page_of_customers(true))
-    client.expects(:post).with("/customers/search", { query: {}, pagination: { starting_after: "EnCrYpTeDsTrInG" }}).returns(page_of_customers(false))
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(true))
+    client.expects(:post).with("/contacts/search", { query: {}, pagination: { starting_after: "EnCrYpTeDsTrInG" }}).returns(page_of_contacts(false))
     emails = []
-    client.customers.search(query: {}).each { |user| emails << user.email }
+    client.contacts.search(query: {}).each { |contact| emails << contact.email }
   end
 
   it "supports indexed array access" do
-    client.expects(:post).with("/customers/search", { query: {} }).returns(page_of_customers(false))
-    client.customers.search(query: {})[0].email.must_equal 'user1@example.com'
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(false))
+    _(client.contacts.search(query: {})[0].email).must_equal 'test1@example.com'
   end
 
   it "supports map" do
-    client.expects(:post).with("/customers/search", { query: {} }).returns(page_of_customers(false))
-    emails = client.customers.search(query: {}).map { |user| user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
+    client.expects(:post).with("/contacts/search", { query: {} }).returns(page_of_contacts(false))
+    emails = client.contacts.search(query: {}).map { |contact| contact.email }
+    _(emails).must_equal %w[test1@example.com test2@example.com test3@example.com]
   end
-
 end

data/spec/unit/intercom/segment_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe "Intercom::Segment" do
 
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it 'lists segments' do
     client.expects(:get).with('/segments', {}).returns(segment_list)
     segments = client.segments.all.to_a
-    segments[0].name.must_equal('Active')
+    _(segments[0].name).must_equal('Active')
   end
 end

data/spec/unit/intercom/subscription_spec.rb

@@ -1,20 +1,19 @@
 require 'spec_helper'
 
 describe "Intercom::Subscription" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it "gets a subscription" do
     client.expects(:get).with("/subscriptions/nsub_123456789", {}).returns(test_subscription)
     subscription = client.subscriptions.find(:id => "nsub_123456789")
-    subscription.request.topics[0].must_equal "user.created"
-    subscription.request.topics[1].must_equal "conversation.user.replied"
+    _(subscription.request.topics[0]).must_equal "user.created"
+    _(subscription.request.topics[1]).must_equal "conversation.user.replied"
   end
 
   it "creates a subscription" do
     client.expects(:post).with("/subscriptions", {'url' => "http://example.com", 'topics' => ["user.created"]}).returns(test_subscription)
     subscription = client.subscriptions.create(:url => "http://example.com", :topics => ["user.created"])
-    subscription.request.topics[0].must_equal "user.created"
-    subscription.request.url.must_equal "http://example.com"
+    _(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

@@ -1,23 +1,31 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe "Intercom::Tag" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+describe 'Intercom::Tag' do
+  let(:client) { Intercom::Client.new(token: 'token') }
+
+  it 'creates a tag' do
+    client.expects(:post).with('/tags', 'name' => 'Test Tag').returns(test_tag)
+    tag = client.tags.create(name: 'Test Tag')
+    _(tag.name).must_equal 'Test Tag'
+  end
 
-  it "creates a tag" do
-    client.expects(:post).with("/tags", {'name' => "Test Tag"}).returns(test_tag)
-    tag = client.tags.create(:name => "Test Tag")
-    tag.name.must_equal "Test Tag"
+  it 'finds a tag by id' do
+    client.expects(:get).with('/tags/4f73428b5e4dfc000b000112', {}).returns(test_tag)
+    tag = client.tags.find(id: '4f73428b5e4dfc000b000112')
+    _(tag.name).must_equal 'Test Tag'
   end
 
-  it "tags users" do
-    client.expects(:post).with("/tags", {'name' => "Test Tag", 'users' => [ { user_id: 'abc123' }, { user_id: 'def456' } ], 'tag_or_untag' => 'tag'}).returns(test_tag)
-    tag = client.tags.tag(:name => "Test Tag", :users => [ { user_id: "abc123" }, { user_id: "def456" } ] )
-    tag.name.must_equal "Test Tag"
-    tag.tagged_user_count.must_equal 2
+  it 'tags companies' do
+    client.expects(:post).with('/tags', 'name' => 'Test Tag', 'companies' => [{ company_id: 'abc123' }, { company_id: 'def456' }], 'tag_or_untag' => 'tag').returns(test_tag)
+    tag = client.tags.tag(name: 'Test Tag', companies: [{ company_id: 'abc123' }, { company_id: 'def456' }])
+    _(tag.name).must_equal 'Test Tag'
+    _(tag.tagged_company_count).must_equal 2
   end
 
-  it 'untags users' do
-    client.expects(:post).with("/tags", {'name' => "Test Tag", 'users' => [ { user_id: 'abc123', untag: true }, { user_id: 'def456', untag: true } ], 'tag_or_untag' => 'untag'}).returns(test_tag)
-    client.tags.untag(:name => "Test Tag", :users => [ { user_id: "abc123" }, { user_id: "def456" } ])
+  it 'untags companies' do
+    client.expects(:post).with('/tags', 'name' => 'Test Tag', 'companies' => [{ company_id: 'abc123', untag: true }, { company_id: 'def456', untag: true }], 'tag_or_untag' => 'untag').returns(test_tag)
+    client.tags.untag(name: 'Test Tag', companies: [{ company_id: 'abc123' }, { company_id: 'def456' }])
   end
 end

data/spec/unit/intercom/team_spec.rb

@@ -1,12 +1,12 @@
 require "spec_helper"
 
 describe "Intercom::Team" do
-  let (:client) { Intercom::Client.new(token: 'token') }
+  let(:client) { Intercom::Client.new(token: 'token') }
 
   it "returns a CollectionProxy for all without making any requests" do
     client.expects(:execute_request).never
     all = client.teams.all
-    all.must_be_instance_of(Intercom::ClientCollectionProxy)
+    _(all).must_be_instance_of(Intercom::ClientCollectionProxy)
   end
 
   it 'gets an team list' do

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

@@ -1,98 +1,100 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+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"=>{},
-     "metadata"=>{
-       "type"=>"user",
-       "color"=>"cyan"
-     }}
+    { 'type' => 'company',
+      'id' => 'aaaaaaaaaaaaaaaaaaaaaaaa',
+      'app_id' => 'some-app-id',
+      'name' => 'SuperSuite',
+      'plan_id' => 1,
+      'remote_company_id' => '8',
+      'remote_created_at' => 103_201,
+      'created_at' => 1_374_056_196,
+      'user_count' => 1,
+      'custom_attributes' => {},
+      'metadata' => {
+        'type' => 'user',
+        'color' => 'cyan'
+      } }
   end
 
   let(:object_hash) do
     {
-      type: "company",
-      id: "aaaaaaaaaaaaaaaaaaaaaaaa",
-      app_id: "some-app-id",
-      name: "SuperSuite",
+      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,
+      remote_company_id: '8',
+      remote_created_at: 103_201,
+      created_at: 1_374_056_196,
       user_count: 1,
-      custom_attributes: { type: "ping" },
+      custom_attributes: { type: 'ping' },
       metadata: {
-        type: "user",
-        color: "cyan"
+        type: 'user',
+        color: 'cyan'
       }
     }
   end
 
-  let(:api_resource) { DummyClass.new.extend(Intercom::Traits::ApiResource)}
+  let(:api_resource) { DummyClass.new.extend(Intercom::Traits::ApiResource) }
 
   before(:each) { api_resource.from_response(object_json) }
 
-  it "coerces time on parsing json" do
-    assert_equal Time.at(1374056196), api_resource.created_at
+  it 'coerces time on parsing json' do
+    assert_equal Time.at(1_374_056_196), api_resource.created_at
   end
 
-  it "exposes string" do
-    assert_equal Time.at(1374056196), api_resource.created_at
+  it 'exposes string' do
+    assert_equal Time.at(1_374_056_196), api_resource.created_at
   end
 
   it "treats 'metadata' as a plain hash, not a typed object" do
     assert_equal Hash, api_resource.metadata.class
   end
 
-  it "dynamically defines accessors when a non-existent property is called that looks like a setter" do
-    api_resource.wont_respond_to :spiders
+  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
+    _(api_resource).must_respond_to :spiders
   end
 
-  it "calls dynamically defined getter when asked" do
+  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)
+  it 'accepts unix timestamps into dynamically defined date setters' do
+    api_resource.foo_at = 1_401_200_468
+    assert_equal 1_401_200_468, 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
+  it 'exposes dates correctly for dynamically defined getters' do
+    api_resource.foo_at = 1_401_200_468
+    assert_equal Time.at(1_401_200_468), 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
+  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
+    _(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
+  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
+  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
+  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 one generated from a response" do
+  it 'an initialized ApiResource is equal to one 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|
@@ -100,7 +102,7 @@ describe Intercom::Traits::ApiResource do
     end
   end
 
-  it "initialized ApiResource using hash is equal to one generated from response" do
+  it 'initialized ApiResource using hash is equal to one generated from response' do
     class ConcreteApiResource; include Intercom::Traits::ApiResource; end
 
     api_resource.from_hash(object_hash)

data/spec/unit/intercom/user_spec.rb

@@ -1,283 +1,284 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-describe "Intercom::User" do
-  let (:client) { Intercom::Client.new(app_id: 'app_id',  api_key: 'api_key') }
+require 'spec_helper'
+
+describe 'Intercom::User' do
+  let (:client) { Intercom::Client.new(token: 'token') }
 
   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"
-    as_hash["created_at"].must_equal created_at.to_i
-    as_hash["name"].must_equal "Jim Bob"
+    _(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
+  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
+    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
+  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
+    _(proc { user.foo_property }).must_raise Intercom::AttributeNotSetError
   end
 
-  it "presents a complete user record correctly" do
+  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
+    _(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 1_401_970_114
+    _(user.remote_created_at.to_i).must_equal 1_393_613_864
+    _(user.updated_at.to_i).must_equal 1_401_970_114
+
+    _(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 1_390_936_440
+    _(user.companies[0].created_at.to_i).must_equal 1_401_970_114
+    _(user.companies[0].updated_at.to_i).must_equal 1_401_970_114
+    _(user.companies[0].last_request_at.to_i).must_equal 1_401_970_113
+    _(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"
+    _(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
-    client.expects(:post).with("/users", {"user_id" => "1224242", 'update_last_request_at' => true, "custom_attributes" => {}}).returns({"user_id" => "i-1224242", "last_request_at" => 1414509439})
-    client.users.create(user_id: '1224242', update_last_request_at: true)
+    client.expects(:post).with('/users', 'user_id' => '1224242', 'update_last_request_at' => true, 'custom_attributes' => {}).returns('user_id' => 'i-1224242', 'last_request_at' => 1_414_509_439)
+    client.deprecated__users.create(user_id: '1224242', update_last_request_at: true)
   end
 
-  it "allows easy setting of custom data" do
+  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"
+    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()
+  it 'allows easy setting of multiple companies' do
+    user = Intercom::User.new
     companies = [
-      {"name" => "Intercom", "company_id" => "6"},
-      {"name" => "Test", "company_id" => "9"}
+      { 'name' => 'Intercom', 'company_id' => '6' },
+      { 'name' => 'Test', 'company_id' => '9' }
     ]
     user.companies = companies
-    user.to_hash["companies"].must_equal companies
+    _(user.to_hash['companies']).must_equal companies
   end
 
-  it "rejects nested data structures in custom_attributes" do
-    user = Intercom::User.new()
+  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)
+    _(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)
+    _(proc { user.custom_attributes['thing'] = [1] }).must_raise(ArgumentError)
   end
 
-  describe "incrementing custom_attributes 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_attributes => {"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
-      @user.increment("mad")
-      @user.to_hash["custom_attributes"]["mad"].must_equal 124
+    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
+    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
+    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
+    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
+    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
 
-  describe "decrementing custom_attributes fields" do
+  describe 'decrementing 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"})
+      @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 "decrements down by 1 with no args" do
-      @user.decrement("mad")
-      @user.to_hash["custom_attributes"]["mad"].must_equal 122
+    it 'decrements down by 1 with no args' do
+      @user.decrement('mad')
+      _(@user.to_hash['custom_attributes']['mad']).must_equal 122
     end
 
-    it "decrements down by given value" do
-      @user.decrement("mad", 3)
-      @user.to_hash["custom_attributes"]["mad"].must_equal 120
+    it 'decrements down by given value' do
+      @user.decrement('mad', 3)
+      _(@user.to_hash['custom_attributes']['mad']).must_equal 120
     end
 
-    it "can decrement new custom data fields" do
-      @user.decrement("new_field", 5)
-      @user.to_hash["custom_attributes"]["new_field"].must_equal -5
+    it 'can decrement new custom data fields' do
+      @user.decrement('new_field', 5)
+      _(@user.to_hash['custom_attributes']['new_field']).must_equal(-5)
     end
 
-    it "can call decrement on the same key twice and decrement by 2" do
-      @user.decrement("mad")
-      @user.decrement("mad")
-      @user.to_hash["custom_attributes"]["mad"].must_equal 121
+    it 'can call decrement on the same key twice and decrement by 2' do
+      @user.decrement('mad')
+      @user.decrement('mad')
+      _(@user.to_hash['custom_attributes']['mad']).must_equal 121
     end
   end
 
-  it "fetches a user" do
-    client.expects(:get).with("/users", {"email" => "bo@example.com"}).returns(test_user)
-    user = client.users.find("email" => "bo@example.com")
-    user.email.must_equal "bob@example.com"
-    user.name.must_equal "Joe Schmoe"
-    user.session_count.must_equal 123
+  it 'fetches a user' do
+    client.expects(:get).with('/users', 'email' => 'bo@example.com').returns(test_user)
+    user = client.deprecated__users.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 'gets users by tag' do
-    client.expects(:get).with("/users?tag_id=124", {}).returns(page_of_users(false))
-    client.users.by_tag(124).each { |t| }
+    client.expects(:get).with('/users?tag_id=124', {}).returns(page_of_users(false))
+    client.deprecated__users.by_tag(124).each { |t| }
   end
 
   it 'gets users by segment' do
-    client.expects(:get).with("/users?segment_id=124", {}).returns(page_of_users(false))
-    client.users.by_segment(124).each { |t| }
+    client.expects(:get).with('/users?segment_id=124', {}).returns(page_of_users(false))
+    client.deprecated__users.by_segment(124).each { |t| }
   end
 
-  it "saves a user (always sends custom_attributes)" do
-    user = Intercom::User.new("email" => "jo@example.com", :user_id => "i-1224242")
-    client.expects(:post).with("/users", {"email" => "jo@example.com", "user_id" => "i-1224242", "custom_attributes" => {}}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
-    client.users.save(user)
+  it 'saves a user (always sends custom_attributes)' do
+    user = Intercom::User.new('email' => 'jo@example.com', :user_id => 'i-1224242')
+    client.expects(:post).with('/users', 'email' => 'jo@example.com', 'user_id' => 'i-1224242', 'custom_attributes' => {}).returns('email' => 'jo@example.com', 'user_id' => 'i-1224242')
+    client.deprecated__users.save(user)
   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"})
-    client.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"})
-    client.users.save(user)
+  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' })
+    client.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')
+    client.deprecated__users.save(user)
   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"}])
-    client.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"})
-    client.users.save(user)
+  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' }])
+    client.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')
+    client.deprecated__users.save(user)
   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"}])
-    client.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"})
-    client.users.save(user)
+    user = Intercom::User.new('email' => nil, :user_id => 'i-1224242', :companies => [{ 'company_id' => 6, 'name' => 'Intercom' }])
+    client.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')
+    client.deprecated__users.save(user)
   end
 
-  it "archives a user" do
-    user = Intercom::User.new("id" => "1")
-    client.expects(:delete).with("/users/1", {}).returns(user)
-    client.users.archive(user)
+  it 'archives a user' do
+    user = Intercom::User.new('id' => '1')
+    client.expects(:delete).with('/users/1', {}).returns(user)
+    client.deprecated__users.archive(user)
+  end
+  it 'has an alias to archive a user' do
+    user = Intercom::User.new('id' => '1')
+    client.expects(:delete).with('/users/1', {}).returns(user)
+    client.deprecated__users.delete(user)
   end
-   it "has an alias to archive a user" do
-     user = Intercom::User.new("id" => "1")
-     client.expects(:delete).with("/users/1", {}).returns(user)
-     client.users.delete(user)
-   end
-
 
-  it "sends a request for a hard deletion" do
-    user = Intercom::User.new("id" => "1")
-    client.expects(:post).with("/user_delete_requests", {intercom_user_id: "1"}).returns({id: user.id})
-    client.users.request_hard_delete(user)
+  it 'sends a request for a hard deletion' do
+    user = Intercom::User.new('id' => '1')
+    client.expects(:post).with('/user_delete_requests', intercom_user_id: '1').returns(id: user.id)
+    client.deprecated__users.request_hard_delete(user)
   end
 
-  it "can use client.users.create for convenience" do
-    client.expects(:post).with("/users", {'custom_attributes' => {}, "email" => "jo@example.com", "user_id" => "i-1224242"}).returns({"email" => "jo@example.com", "user_id" => "i-1224242"})
-    user = client.users.create("email" => "jo@example.com", :user_id => "i-1224242")
-    user.email.must_equal "jo@example.com"
+  it 'can use client.users.create for convenience' do
+    client.expects(:post).with('/users', 'custom_attributes' => {}, 'email' => 'jo@example.com', 'user_id' => 'i-1224242').returns('email' => 'jo@example.com', 'user_id' => 'i-1224242')
+    user = client.deprecated__users.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
-    client.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 = client.users.create("email" => "jo@example.com", :user_id => "i-1224242")
-    user.session_count.must_equal 4
+  it 'updates the user with attributes as set by the server' do
+    client.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 = client.deprecated__users.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
-    client.expects(:post).with("/users", {"email" => "jo@example.com", 'custom_attributes' => {}, "remote_created_at" => nil}).returns({"email" => "jo@example.com"})
-    user = client.users.create("email" => "jo@example.com", "remote_created_at" => nil)
+  it 'allows setting dates to nil without converting them to 0' do
+    client.expects(:post).with('/users', 'email' => 'jo@example.com', 'custom_attributes' => {}, 'remote_created_at' => nil).returns('email' => 'jo@example.com')
+    user = client.deprecated__users.create('email' => 'jo@example.com', 'remote_created_at' => nil)
     assert_nil user.remote_created_at
   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}
+  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
+    _(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
+      _(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"
+  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 ClientCollectionProxy for all without making any requests" do
+  it 'returns a ClientCollectionProxy for all without making any requests' do
     client.expects(:execute_request).never
-    all = client.users.all
-    all.must_be_instance_of(Intercom::ClientCollectionProxy)
+    all = client.deprecated__users.all
+    _(all).must_be_instance_of(Intercom::ClientCollectionProxy)
   end
 
   it 'can print users without crashing' do
-    client.expects(:get).with("/users", {"email" => "bo@example.com"}).returns(test_user)
-    user = client.users.find("email" => "bo@example.com")
+    client.expects(:get).with('/users', 'email' => 'bo@example.com').returns(test_user)
+    user = client.deprecated__users.find('email' => 'bo@example.com')
 
     begin
       orignal_stdout = $stdout
@@ -285,91 +286,88 @@ describe "Intercom::User" do
 
       puts user
       p user
-
     ensure
       $stdout = orignal_stdout
     end
   end
 
   describe 'bulk operations' do
-    let (:job) {
+    let (:job) do
       {
-        "app_id"=>"app_id",
-        "id"=>"super_awesome_job",
-        "created_at"=>1446033421,
-        "completed_at"=>1446048736,
-        "closing_at"=>1446034321,
-        "updated_at"=>1446048736,
-        "name"=>"api_bulk_job",
-        "state"=>"completed",
-        "links"=>
+        'app_id' => 'app_id',
+        'id' => 'super_awesome_job',
+        'created_at' => 1_446_033_421,
+        'completed_at' => 1_446_048_736,
+        'closing_at' => 1_446_034_321,
+        'updated_at' => 1_446_048_736,
+        'name' => 'api_bulk_job',
+        'state' => 'completed',
+        'links' =>
           {
-            "error"=>"https://api.intercom.io/jobs/super_awesome_job/error",
-            "self"=>"https://api.intercom.io/jobs/super_awesome_job"
+            'error' => 'https://api.intercom.io/jobs/super_awesome_job/error',
+            'self' => 'https://api.intercom.io/jobs/super_awesome_job'
           },
-        "tasks"=>
+        'tasks' =>
           [
             {
-              "id"=>"super_awesome_task",
-              "item_count"=>2,
-              "created_at"=>1446033421,
-              "started_at"=>1446033709,
-              "completed_at"=>1446033709,
-              "state"=>"completed"
+              'id' => 'super_awesome_task',
+              'item_count' => 2,
+              'created_at' => 1_446_033_421,
+              'started_at' => 1_446_033_709,
+              'completed_at' => 1_446_033_709,
+              'state' => 'completed'
             }
           ]
-        }
-    }
-    let(:bulk_request) {
-       {
+      }
+    end
+    let(:bulk_request) do
+      {
         items: [
           {
-            method: "post",
-            data_type: "user",
-            data:{
+            method: 'post',
+            data_type: 'user',
+            data: {
               user_id: 25,
-              email: "alice@example.com"
+              email: 'alice@example.com'
             }
           },
           {
-            method: "delete",
-            data_type: "user",
-            data:{
+            method: 'delete',
+            data_type: 'user',
+            data: {
               user_id: 26,
-              email: "bob@example.com"
+              email: 'bob@example.com'
             }
           }
         ]
       }
-    }
-    let(:users_to_create) {
+    end
+    let(:users_to_create) do
       [
         {
           user_id: 25,
-          email: "alice@example.com"
+          email: 'alice@example.com'
         }
       ]
-    }
-    let(:users_to_delete) {
+    end
+    let(:users_to_delete) do
       [
         {
           user_id: 26,
-          email: "bob@example.com"
+          email: 'bob@example.com'
         }
       ]
-    }
-
-    it "submits a bulk job" do
-      client.expects(:post).with("/bulk/users", bulk_request).returns(job)
-      client.users.submit_bulk_job(create_items: users_to_create, delete_items: users_to_delete)
     end
 
-    it "adds users to an existing bulk job" do
-      bulk_request[:job] = {id: 'super_awesome_job'}
-      client.expects(:post).with("/bulk/users", bulk_request).returns(job)
-      client.users.submit_bulk_job(create_items: users_to_create, delete_items: users_to_delete, job_id: 'super_awesome_job')
+    it 'submits a bulk job' do
+      client.expects(:post).with('/bulk/users', bulk_request).returns(job)
+      client.deprecated__users.submit_bulk_job(create_items: users_to_create, delete_items: users_to_delete)
     end
 
+    it 'adds users to an existing bulk job' do
+      bulk_request[:job] = { id: 'super_awesome_job' }
+      client.expects(:post).with('/bulk/users', bulk_request).returns(job)
+      client.deprecated__users.submit_bulk_job(create_items: users_to_create, delete_items: users_to_delete, job_id: 'super_awesome_job')
+    end
   end
-
 end