intercom-rails 0.2.24 → 0.2.25

data/test/intercom-rails/config_test.rb

@@ -1,79 +0,0 @@
-require 'test_setup'
-
-class ConfigTest < MiniTest::Unit::TestCase 
-
-  include InterTest
-
-  def test_setting_app_id
-    IntercomRails.config.app_id = "1234"
-    assert_equal IntercomRails.config.app_id, "1234"
-  end
-
-  def test_setting_current_user
-    current_user = Proc.new { @blah }
-    IntercomRails.config.user.current = current_user
-    assert_equal IntercomRails.config.user.current, current_user
-  end
-
-  def test_setting_current_user_not_to_a_proc
-    assert_raises ArgumentError do
-      IntercomRails.config.user.current = 1
-    end
-  end
-
-  def test_configuring_intercom_with_block
-    IntercomRails.config do |config|
-      config.app_id = "4567"
-    end
-
-    assert_equal IntercomRails.config.app_id, "4567"
-  end
-
-  def test_custom_data_rejects_non_proc_or_symbol_attributes
-    exception = assert_raises ArgumentError do 
-      IntercomRails.config.user.custom_data = {
-        'foo' => Proc.new {},
-        'bar' => 'heyheyhey!'
-      }
-    end 
-
-    assert_equal "all custom_data attributes should be either a Proc or a symbol", exception.message
-  end
-
-  def test_setting_custom_data
-    custom_data_config = {
-      'foo' => Proc.new {},
-      'bar' => :method_name
-    }
-
-    IntercomRails.config.user.custom_data = custom_data_config
-    assert_equal custom_data_config, IntercomRails.config.user.custom_data
-  end
-
-  def test_setting_company_custom_data
-    custom_data_config = {
-      'the_local' => Proc.new { 'club 93' }
-    }
-
-    IntercomRails.config.company.custom_data = custom_data_config
-    assert_equal custom_data_config, IntercomRails.config.company.custom_data
-  end
-
-  def test_setting_inbox_style
-    IntercomRails.config.inbox.style = :custom
-    assert_equal :custom, IntercomRails.config.inbox.style
-  end
-
-  def test_reset_clears_existing_config
-    IntercomRails.config.user.custom_data = {'muffin' => :muffin}
-    IntercomRails.config.reset!
-    assert_equal nil, IntercomRails.config.user.custom_data
-  end
-
-  def test_reset_clears_inbox_config_too
-    IntercomRails.config.inbox.style = :custom
-    IntercomRails.config.reset!
-    assert_equal nil, IntercomRails.config.inbox.style
-  end
-
-end

data/test/intercom-rails/import_network_test.rb

@@ -1,122 +0,0 @@
-require 'import_test_setup'
-require 'sinatra/base'
-
-class MockIntercom < Sinatra::Base
-
-  set :server, 'thin'
-
-  before do
-    content_type 'application/json'
-  end
-
-  get '/health_check' do
-    content_type 'plain/text'
-    'hello world'
-  end
-
-  post '/all_successful' do
-    {:failed => []}.to_json 
-  end
-
-  post '/one_failure' do
-    {:failed => ['ben@intercom.io']}.to_json
-  end
-
-  post '/bad_auth' do
-    status 403
-    {"error" => {"type" => "not_authenticated", "message" => "HTTP Basic: Access denied."}}.to_json
-  end
-
-  post '/500_error' do
-    status 500
-    {"error" => {"type" => "server_error", "message" => "Danger deploy, gone wrong?"}}.to_json
-  end
-
-end
-
-class InterRunner < MiniTest::Unit
-
-  self.runner = self.new
-  
-  def _run(*args)
-    @mock_intercom_pid = start_mock_intercom
-    super
-  ensure
-    Process.kill('INT', @mock_intercom_pid)
-    Process.wait(@mock_intercom_pid) rescue SystemError
-  end
-
-  private
-
-  def start_mock_intercom
-    pid = fork do 
-      MockIntercom.run!(:port => 46837) do |server|
-        server.silent = true
-      end
-    end
-
-    response = nil
-    uri = URI.parse("http://localhost:46837/health_check")
-
-    begin
-      response = Net::HTTP.get_response(uri).body until(response == 'hello world')
-    rescue Errno::ECONNREFUSED
-      sleep(0.5)
-      retry
-    end
-
-    pid
-  end
-
-end
-
-class ImportNetworkTest < InterRunner::TestCase
-
-  include InterTest
-  include ImportTest
-
-  def api_path=(path)
-    IntercomRails::Import.stub(:bulk_create_api_endpoint) {
-      URI.parse("http://localhost:46837/#{path}")
-    }
-
-    @import = IntercomRails::Import.new
-  end
-
-  def test_empty_failed
-    self.api_path = '/all_successful'
-
-    @import.run
-    assert_equal [], @import.failed
-    assert_equal 2, @import.total_sent
-  end
-
-  def test_sets_failed_correctly
-    self.api_path = '/one_failure'
-
-    @import.run
-    assert_equal ["ben@intercom.io"], @import.failed
-    assert_equal 2, @import.total_sent
-  end
-
-  def test_raises_import_error_on_bad_auth
-    self.api_path = '/bad_auth'
-
-    exception = assert_raises(IntercomRails::ImportError) { 
-      @import.run
-    }
-
-    assert_equal "App ID or API Key are incorrect, please check them in config/initializers/intercom.rb", exception.message
-  end
-
-  def test_throws_exception_when_intercom_api_is_being_a_dick
-    self.api_path = '/500_error'
-
-    exception = assert_raises(IntercomRails::IntercomAPIError) {
-      @import.run
-    }
-
-    assert_equal "The Intercom API request failed with the code: 500, after 3 attempts.", exception.message
-  end
-
-end

data/test/intercom-rails/import_unit_test.rb

@@ -1,125 +0,0 @@
-require 'import_test_setup'
-
-class ImportUnitTest < MiniTest::Unit::TestCase 
-
-  include InterTest
-  include ImportTest
-
-  def test_run_with_wrong_rails_env
-    Rails.stub(:env).and_return ActiveSupport::StringInquirer.new("development")
-
-    exception = assert_raises IntercomRails::ImportError do
-      IntercomRails::Import.run
-    end
-
-    assert_equal exception.message, "You can only import your users from your production environment"
-  end
-
-  def test_run_with_no_user_class
-    IntercomRails::Import.any_instance.stub(:user_klass).and_return(nil)
-
-    exception = assert_raises IntercomRails::ImportError do
-      IntercomRails::Import.run
-    end
-    
-    assert_equal exception.message, "We couldn't find your user class, please set one in config/initializers/intercom_rails.rb"
-  end
-
-  def test_run_with_unsupported_user_class
-    IntercomRails::Import.any_instance.stub(:user_klass).and_return(Class)
-
-    exception = assert_raises IntercomRails::ImportError do
-      IntercomRails::Import.run
-    end
-    
-    assert_equal exception.message, "Only ActiveRecord and Mongoid models are supported"
-  end
-
-  def test_run_with_no_api_key
-    IntercomRails.config.stub(:api_key).and_return(nil)
-
-    exception = assert_raises IntercomRails::ImportError do
-      IntercomRails::Import.run
-    end
-    
-    assert_equal exception.message, "Please add an Intercom API Key to config/initializers/intercom.rb"
-  end
-
-  def test_mongoid
-    klass = Class.new
-    klass.class_eval do
-      include Mongoid::Document
-    end
-    IntercomRails::Import.any_instance.stub(:user_klass).and_return(klass)
-
-    @import = IntercomRails::Import.new
-    @import.should_receive(:map_to_users_for_wire).with(klass.all).and_call_original
-    @import.should_receive(:send_users).and_return('failed' => [])
-    @import.run
-  end
-
-  def test_status_output
-    @import = IntercomRails::Import.new(:status_enabled => true)
-    @import.stub(:send_users).and_return('failed' => [1])
-    @import.should_receive(:batches).and_yield(nil, 3)
-
-    $stdout.flush
-    @old_stdout = $stdout.dup
-    $stdout = @output = StringIO.new
-
-    @import.run
-    expected_output = <<-output
-* Found user class: User
-* Intercom API key found
-* Sending users in batches of 100:
-..F
-* Successfully created 2 users
-* Failed to create 1 user, this is likely due to bad data
-    output
-    $stdout.flush
-
-    assert_equal expected_output, @output.string
-  ensure
-    $stdout = @old_stdout
-  end
-
-  def test_prepares_companies
-    @import = IntercomRails::Import.new
-
-    u = dummy_user
-    u.instance_eval do
-      def apps
-        [dummy_company]
-      end
-    end
-
-    User.stub(:find_in_batches).and_yield([u])
-
-    IntercomRails.config.user.company_association = Proc.new { |user| user.apps }
-
-    prepare_for_batch_users = nil
-    @import.stub(:prepare_batch) { |users| prepare_for_batch_users = users }
-    @import.stub(:send_users).and_return('failed' => [])
-
-    @import.run
-
-    assert_equal 1, prepare_for_batch_users[0][:companies].length
-    User.rspec_reset
-  end
-
-  def test_max_batch_size_default
-    @import = IntercomRails::Import.new
-    assert_equal 100, @import.max_batch_size
-  end
-
-  def test_max_batch_size_settable
-    @import = IntercomRails::Import.new(:max_batch_size => 50)
-    assert_equal 50, @import.max_batch_size
-  end
-
-  def test_max_batch_size_hard_limit
-    @import = IntercomRails::Import.new(:max_batch_size => 101)
-    assert_equal 100, @import.max_batch_size
-  end
-
-end

data/test/intercom-rails/proxy/company_test.rb

@@ -1,46 +0,0 @@
-require 'test_setup'
-
-class CompanyTest < MiniTest::Unit::TestCase
-
-  include InterTest
-
-  Company = IntercomRails::Proxy::Company
-  DUMMY_COMPANY = dummy_company
-
-  def test_finds_current_company
-    IntercomRails.config.company.current = Proc.new { @app }
-    object_with_app_instance_var = Object.new 
-    object_with_app_instance_var.instance_variable_set(:@app, DUMMY_COMPANY)
-
-    c = Company.current_in_context(object_with_app_instance_var)
-    assert_equal true, c.valid?
-    expected_hash = {:id => '6', :name => 'Intercom'}
-    assert_equal expected_hash, c.to_hash
-  end
-
-  def test_whiny_nil
-    NilClass.class_eval do
-      def id
-        raise ArgumentError, "boo"
-      end
-    end
-
-    search_object = nil 
-    assert_equal false, Company.new(search_object).valid?
-  end
-
-  def test_companies_for_user
-    IntercomRails.config.user.company_association = Proc.new { |user| user.apps }
-    test_user = dummy_user
-    test_user.instance_eval do
-      def apps
-        [DUMMY_COMPANY, dummy_company(:name => "Prey", :id => "800")]
-      end
-    end
-
-    companies = Company.companies_for_user(IntercomRails::Proxy::User.new(test_user))
-    assert_equal 2, companies.length
-    assert_equal ["Intercom", "Prey"], companies.map(&:company).map(&:name)
-  end
-
-end

data/test/intercom-rails/proxy/user_test.rb

@@ -1,143 +0,0 @@
-require 'test_setup'
-
-class UserTest < MiniTest::Unit::TestCase
-
-  User = IntercomRails::Proxy::User
-
-  include InterTest
-  include IntercomRails
-
-  DUMMY_USER = dummy_user(:email => 'ciaran@intercom.io', :name => 'Ciaran Lee')
-
-  def test_raises_error_when_no_user_found
-    assert_raises(IntercomRails::NoUserFoundError) {
-      User.current_in_context(Object.new)
-    }
-  end
-
-  def test_finds_current_user
-    object_with_current_user_method = Object.new
-    object_with_current_user_method.instance_eval do
-      def current_user
-        DUMMY_USER
-      end
-    end
-
-    @user_proxy = User.current_in_context(object_with_current_user_method)
-    assert_user_found 
-  end
-
-  def test_finds_user_instance_variable
-    object_with_instance_variable = Object.new
-    object_with_instance_variable.instance_eval do
-      @user = DUMMY_USER 
-    end
-
-    @user_proxy = User.current_in_context(object_with_instance_variable)
-    assert_user_found 
-  end
-
-  def test_finds_config_user
-    object_from_config = Object.new
-    object_from_config.instance_eval do
-      def something_esoteric
-        DUMMY_USER
-      end
-    end
-
-    IntercomRails.config.user.current = Proc.new { something_esoteric }
-    @user_proxy = User.current_in_context(object_from_config)
-    assert_user_found 
-  end
-
-  def test_finds_config_user_does_not_fallback_to_auto_find_users
-    IntercomRails.config.user.current = Proc.new { something_esoteric }
-    object_with_instance_variable = Object.new
-    object_with_instance_variable.instance_eval do
-      @user = DUMMY_USER 
-    end
-
-    assert_raises(IntercomRails::NoUserFoundError) {
-      User.current_in_context(object_with_instance_variable)
-    }
-  end
-
-  def assert_user_found
-    assert_equal DUMMY_USER, @user_proxy.user
-  end
-
-  def test_includes_custom_data
-    plan_dummy_user = DUMMY_USER.dup
-    plan_dummy_user.instance_eval do
-      def plan
-        'pro'
-      end
-    end
-
-    IntercomRails.config.user.custom_data = {
-      'plan' => :plan
-    }
-
-    @user_proxy = User.new(plan_dummy_user)
-    assert_equal 'pro', @user_proxy.to_hash['plan']
-  end
-
-  def test_converts_dates_to_timestamps
-    plan_dummy_user = DUMMY_USER.dup
-    plan_dummy_user.instance_eval do
-      def some_date
-        Time.at(5)
-      end
-    end
-
-    IntercomRails.config.user.custom_data = {
-      'some_date' => :some_date
-    }
-
-    @user_proxy = User.new(plan_dummy_user)
-    assert_equal 5, @user_proxy.to_hash['some_date']
-  end
-
-  def test_valid_returns_true_if_user_id_or_email
-    assert_equal true, User.new(DUMMY_USER).valid?
-  end
-
-  def test_not_valid_if_new_record?
-    new_record_user = dummy_user(:email => 'not-saved@intercom.io', :name => 'New Record')
-    def new_record_user.new_record?
-      true
-    end
-    assert_equal false, User.new(new_record_user).valid?
-  end
-
-  def test_includes_custom_data_from_intercom_custom_data
-    object_with_intercom_custom_data = Object.new
-    object_with_intercom_custom_data.instance_eval do
-      def intercom_custom_data
-        o = Object.new 
-        o.instance_eval do 
-          def user
-            {:ponies => :rainbows}
-          end
-        end 
-
-        o
-      end
-    end
-
-    @user_proxy = User.new(DUMMY_USER, object_with_intercom_custom_data) 
-    assert_equal :rainbows, @user_proxy.to_hash[:ponies]
-  end
-
-  def test_whiny_nil
-    NilClass.class_eval do
-      def id
-        raise ArgumentError, "boo"
-      end
-    end
-
-    search_object = nil 
-    assert_equal false, User.new(search_object).valid?
-  end
-
-end