stackmob 0.0.2 → 0.1.0

data/test/unit/stackmob/test_client.rb

@@ -1,105 +0,0 @@
-require 'helper'
-
-class StackmobClientTest < MiniTest::Unit::TestCase 
-  
-  attr_reader :valid_client
-
-  def app_name
-    "test"
-  end
-
-  def app_vsn
-    0
-  end
-
-  def test_params
-    {:abc => 123, :def => 456}
-  end
-
-  def stub_all_requests(method, resp_obj)
-    OAuth::AccessToken.any_instance.stubs(method).returns(resp_obj)    
-  end  
-
-  def setup
-    @valid_client = StackMob::Client.new("http://123.com/", app_name, app_vsn, "some-valid-test-key", "some-valid-test-secret")
-    @test_hash = {"a" => 1, "b" => 2}
-    @good_resp = mock("Net::HTTPResponse")
-    @good_resp.stubs(:code).returns(200)
-    @good_resp.stubs(:body).returns(Yajl::Encoder.encode(@test_hash))                                 
-
-    # hack to give test suite access to underlying oauth object
-    class << valid_client
-      def _oauth
-        @oauth_client
-      end
-    end
-  end
-
-  def test_response_json_parsed
-    stub_all_requests(:get, @good_resp)
-
-    assert_equal @test_hash, valid_client.request(:get, :some_service, "/abc")
-  end
-
-  def test_requesting_invalid_method_raises_error
-    assert_raises StackMob::Client::InvalidRequestMethod do
-      valid_client.request(:invalid, :some_service, "/asd")
-    end
-  end
-
-  def test_when_resp_code_is_not_200
-    failed = mock("Net::HTTPResponse")
-    failed.stubs(:code).returns(404)
-    stub_all_requests(:get, failed)
-
-    
-    assert_raises StackMob::Client::RequestError do
-      valid_client.request(:get, :some_service, "/asd")
-    end
-  end
-
-  def test_when_json_parsing_will_raise_an_error
-    resp_w_invalid_body = mock("Net::HTTPResponse")
-    resp_w_invalid_body.stubs(:code).returns(200)
-    resp_w_invalid_body.stubs(:body).returns("this is not valid json")
-    stub_all_requests(:get, resp_w_invalid_body)
-
-    assert_raises StackMob::Client::BadResponseBody do
-      valid_client.request(:get, :some_service, "/asd")
-    end
-  end
-
-  def test_get_with_request_params
-    service = :some_service
-    path = "user"
-
-    valid_client._oauth.expects(:get).with("/#{service}/#{app_vsn}/#{app_name}/#{path}?abc=123&def=456", "").returns(@good_resp)
-    valid_client.request(:get, service, path, test_params)
-  end
-
-  def test_post_with_request_params
-    service = :some_service
-    path = "user"
-    @good_resp.stubs(:code).returns(201)
-
-    valid_client._oauth.expects(:post).with("/#{service}/#{app_vsn}/#{app_name}/#{path}", Yajl::Encoder.encode(test_params), "Content-Type" => "application/json").returns(@good_resp)
-    valid_client.request(:post, service, path, test_params)
-  end
-
-  def test_delete_with_request_params
-    service = :a_service
-    path = "abc"
-    
-    valid_client._oauth.expects(:delete).with("/#{service}/#{app_vsn}/#{app_name}/#{path}?something=123", "").returns(@good_resp)
-    valid_client.request(:delete, service, path, something: "123")
-  end
-
-  def test_put_with_request_params
-    service = :some_service
-    path = "abc"
-    
-    valid_client._oauth.expects(:put).with("/#{service}/#{app_vsn}/#{app_name}/#{path}", Yajl::Encoder.encode(test_params), "Content-Type" => "application/json").returns(@good_resp)
-    valid_client.request(:put, service, path, test_params)
-  end
-
-end

data/test/unit/stackmob/test_data_store.rb

@@ -1,83 +0,0 @@
-require 'helper'
-
-class StackMobDataStoreTest < MiniTest::Unit::TestCase
-  
-  def setup
-    @mock_client = mock("StackMob::Client")
-    @datastore = StackMob::DataStore.new(@mock_client)
-  end
-
-  def test_given_client_is_returned_client
-    assert_equal @mock_client, @datastore.client
-  end
-
-  def test_api_schema_calls_listapi
-    @mock_client.expects(:request).with(:get, :api, "/listapi").returns("obj" => "")
-    @datastore.api_schema
-  end
-
-  def test_delete_call
-    uid = "abc"
-
-    @mock_client.expects(:request).with(:delete, :api, "/user", :user_id => uid).returns(nil)
-    @datastore.delete(:user, :user_id => uid)
-  end
-
-  def test_create_call
-    name = "test user"
-
-    @mock_client.expects(:request).with(:post, :api, "/user", :name => name).returns(nil)
-    @datastore.create(:user, :name => name)
-  end
-  
-  def test_get_all_call
-    @mock_client.expects(:request).with(:get, :api, "/user", Hash.new).returns(nil)
-    @datastore.get(:user)
-  end
-
-  def test_update_call
-    uid = "abc"
-    name = "test user"
-    params = {:name => name}
-
-    @mock_client.expects(:request).with(:put, :api, "/user/#{uid}", params).returns(nil)
-    @datastore.update(:user, uid, params)
-  end  
-
-  def test_create_returns_false_on_request_error
-    @mock_client.expects(:request).raises(StackMob::Client::RequestError)
-    assert !@datastore.create(:user, :name => "def")
-  end
-
-  def test_create_bang_does_not_catch_error
-    @mock_client.expects(:request).raises(StackMob::Client::RequestError)
-    assert_raises StackMob::Client::RequestError do 
-      @datastore.create!(:user, :name => "def")
-    end
-  end
-
-  def test_update_returns_false_on_request_error
-    @mock_client.expects(:request).raises(StackMob::Client::RequestError)
-    assert !@datastore.update(:user, "123", :name => "def")
-  end
-
-  def test_update_bang_does_not_catch_error
-    @mock_client.expects(:request).raises(StackMob::Client::RequestError)
-    assert_raises StackMob::Client::RequestError do 
-      @datastore.update!(:user, "123", :name => "def")
-    end
-  end
-
-  def test_delete_returns_false_on_request_error
-    @mock_client.expects(:request).raises(StackMob::Client::RequestError)
-    assert !@datastore.delete(:user, :name => "ads")
-  end
-
-  def test_delete_bang_does_not_catch_error
-    @mock_client.expects(:request).raises(StackMob::Client::RequestError)
-    assert_raises StackMob::Client::RequestError do 
-      @datastore.delete!(:user, :name => "def")
-    end
-  end
-  
-end

data/test/unit/stackmob/test_deployer.rb

@@ -1,21 +0,0 @@
-require 'helper'
-
-class StackMobDeployerTest < MiniTest::Unit::TestCase
-  
-  def setup
-    @mock_client = mock("StackMob::Client")
-    @deployer = StackMob::Deployer.new(@mock_client)
-  end
-
-  def test_register_call
-    hostname = "testing1234"
-    @mock_client.expects(:request).with(:post, :api, "heroku/app", :hostname => hostname)
-    @deployer.register(hostname)
-  end
-
-  def test_fetch_call
-    @mock_client.expects(:request).with(:get, :api, "heroku/app")
-    @deployer.fetch
-  end
-
-end

data/test/unit/stackmob/test_push.rb

@@ -1,133 +0,0 @@
-require 'helper'
-
-class StackMobPushTest < MiniTest::Unit::TestCase
-
-  def setup
-    @test_token = "abcdefghijklmnopqrstuv"    
-    @user_id = "123"
-
-    @mock_client = mock("StackMob::Client")
-    @push = StackMob::Push.new(@mock_client)
-  end
-
-  def test_given_client_is_returned_client
-    assert_equal @mock_client, @push.client
-  end
-
-  def test_register_call
-    @mock_client.expects(:request).with(:post, :push, "/device_tokens", :userId => @user_id, :token => @test_token).returns(nil)
-    @push.register(@user_id, @test_token)
-  end
-
-  def test_broadcast_call
-    badge = 1,
-    sound = "testsound.mp3"
-    alert = "testing"
-
-    expected_body = {:recipients => [], 
-                     :aps => {:alert => alert, :sound => sound, :badge => badge}, 
-                     :areRecipientsDeviceTokens => true,
-                     :exclude_tokens => []}
-    expected_params = [:post, :push, "/push_broadcast", expected_body]
-    @mock_client.expects(:request).with(*expected_params).returns(nil)
-
-    @push.broadcast(:badge => badge, :sound => sound, :alert => alert)
-  end
-
-  def test_broadcast_missing_alert_raises_error
-    assert_raises ArgumentError do 
-      @push.broadcast(:badge => 0, :sound => "") 
-    end
-  end
-
-  def test_broadcast_badge_defaults_to_zero
-    sound = "test.mp3"
-    alert = "alert message"
-
-    expected_body = {:recipients => [], 
-                     :aps => {:alert => alert, :sound => sound, :badge => 0}, 
-                     :areRecipientsDeviceTokens => true,
-                     :exclude_tokens => []}
-    expected_params = [:post, :push, "/push_broadcast", expected_body]
-    @mock_client.expects(:request).with(*expected_params).returns(nil)
-    @push.broadcast(:sound => sound, :alert => alert)
-  end
-
-  def test_broadcast_sound_defaults_to_empty_string
-    badge = 1
-    alert = "alert message"
-
-    expected_body = {:recipients => [], 
-                     :aps => {:alert => alert, :sound => "", :badge => badge}, 
-                     :areRecipientsDeviceTokens => true,
-                     :exclude_tokens => []}
-    expected_params = [:post, :push, "/push_broadcast", expected_body]
-    @mock_client.expects(:request).with(*expected_params).returns(nil)
-    @push.broadcast(:badge => badge, :alert => alert)
-  end
-
-  def test_send_messsage_to_one_call
-    sound = "testsound.mp3"
-    alert = "Single Message"
-    badge = 2
-    token = "abc"
-
-    expected_body = {:recipients => [token],
-                     :aps => {:badge => badge, :sound => sound, :alert => alert},
-                     :areRecipientsDeviceTokens => true,
-                     :exclude_tokens => []}
-    expected_params = [:post, :push, "/push", expected_body]
-    @mock_client.expects(:request).with(*expected_params).returns(nil)
-    @push.send_message(token, :alert => alert, :sound => sound, :badge => badge)
-  end
-
-  def test_send_message_without_alert_raises_error
-    assert_raises ArgumentError do
-      @push.send_message("avc", :sound => "somefile.mp3", :badge => 1)
-    end
-  end
-
-  def test_send_message_defaults_badge_to_zero
-    sound = "testsound.mp3"
-    alert = "Single Message"
-    token = "abc"
-
-    expected_body = {:recipients => [token],
-                     :aps => {:badge => 0, :sound => sound, :alert => alert},
-                     :areRecipientsDeviceTokens => true,
-                     :exclude_tokens => []}
-    expected_params = [:post, :push, "/push", expected_body]
-    @mock_client.expects(:request).with(*expected_params).returns(nil)
-    @push.send_message(token, :alert => alert, :sound => sound)
-  end
-
-  def test_send_message_defaults_sound_to_empty_string
-    alert = "Single Message"
-    badge = 2
-    token = "abc"
-
-    expected_body = {:recipients => [token],
-                     :aps => {:badge => badge, :sound => "", :alert => alert},
-                     :areRecipientsDeviceTokens => true,
-                     :exclude_tokens => []}
-    expected_params = [:post, :push, "/push", expected_body]
-    @mock_client.expects(:request).with(*expected_params).returns(nil)
-    @push.send_message(token, :alert => alert, :badge => badge)
-  end
-
-  def test_send_message_with_user_ids
-    sound = "testsound.mp3"
-    alert = "Single Message"
-    badge = 2
-    token = "abc"
-
-    expected_body = {:recipients => [token],
-                     :aps => {:badge => badge, :sound => sound, :alert => alert},
-                     :areRecipientsDeviceTokens => false,
-                     :exclude_tokens => []}
-    expected_params = [:post, :push, "/push", expected_body]
-    @mock_client.expects(:request).with(*expected_params).returns(nil)
-    @push.send_message(token, :alert => alert, :sound => sound, :badge => badge, :recipients_are_users => true)
-  end
-
-end

data/test/unit/test_stackmob.rb

@@ -1,129 +0,0 @@
-require 'helper'
-
-class StackMobTestCase < MiniTest::Unit::TestCase
-
-  def setup
-    @config_dev_key = "config_dev_key"
-    @config_dev_secret = "config_dev_secret"
-    @config_prod_key = "config_prod_key"
-    @config_prod_secret = "config_prod_secret"
-    @config_app_name = "config_app_name"
-    @config_client_name = "config_client_name"
-
-    @env_dev_key = "env_dev_key"
-    @env_dev_secret = "env_dev_secret"
-    @env_prod_key = "env_prod_key"
-    @env_prod_secret = "env_prod_secret"
-    @env_app_name = "env_app_name"
-    @env_client_name = "env_client_name"
-
-    StackMob.stubs(:config).returns("sm_client_name" => @config_client_name, "sm_app_name" => @config_app_name, 
-                                    "development" => {"key" => @config_dev_key, "secret" => @config_dev_secret}, "production" => {"key" => @config_prod_key, "secret" => @config_prod_secret})
-  end
-
-  def test_fetch_app_name_when_no_env_key_exists
-    assert_equal @config_app_name, StackMob.app_name
-  end
-
-  def test_fetch_app_name_when_env_key_exists
-    ENV["STACKMOB_APP_NAME"] = @env_app_name
-
-    assert_equal @env_app_name, StackMob.app_name
-
-    ENV["STACKMOB_APP_NAME"] = nil
-  end
-
-  def test_fetch_client_name_when_no_env_key_exists
-    assert_equal @config_client_name, StackMob.client_name
-  end
-
-  def test_fetch_client_name_when_env_key_exists
-    ENV["STACKMOB_CLIENT_NAME"] = @env_client_name
-
-    assert_equal @env_client_name, StackMob.client_name
-
-    ENV["STACKMOB_CLIENT_NAME"] = nil
-  end
-
-  def test_fetch_dev_key_when_no_env_key_exists
-    previous_rack_env = ENV["RACK_ENV"]
-    ENV["RACK_ENV"] = "development"
-    
-    assert_equal @config_dev_key, StackMob.key
-
-    ENV["RACK_ENV"] = previous_rack_env
-  end
-
-  def test_fetch_dev_secret_when_no_env_secret_exists
-    previous_rack_env = ENV["RACK_ENV"]
-    ENV["RACK_ENV"] = "development"
-
-    assert_equal @config_dev_secret, StackMob.secret
-
-    ENV["RACK_ENV"] = previous_rack_env
-  end
-
-  def test_fetch_prod_key_when_no_env_key_exists
-    previous_rack_env = ENV["RACK_ENV"]
-    ENV["RACK_ENV"] = "production"
-    
-    assert_equal @config_prod_key, StackMob.key
-
-    ENV["RACK_ENV"] = previous_rack_env
-  end
-
-  def test_fetch_prod_secret_when_no_env_secret_exists
-    previous_rack_env = ENV["RACK_ENV"]
-    ENV["RACK_ENV"] = "production"
-
-    assert_equal @config_prod_secret, StackMob.secret
-
-    ENV["RACK_ENV"] = previous_rack_env
-  end
-
-  def test_fetches_dev_key_from_env_when_exists
-    previous_rack_env = ENV["RACK_ENV"]
-    ENV["RACK_ENV"] = "development"
-    ENV["STACKMOB_SAND_PUBLIC_KEY"] = @env_dev_key
-
-    assert_equal @env_dev_key, StackMob.key
-    
-    ENV["STACKMOB_SAND_PUBLIC_KEY"] = nil
-    ENV["RACK_ENV"] = previous_rack_env
-  end
-
-  def test_fetches_dev_secret_from_env_when_exists
-    previous_rack_env = ENV["RACK_ENV"]
-    ENV["RACK_ENV"] = "development"
-    ENV["STACKMOB_SAND_PRIVATE_KEY"] = @env_dev_secret
-
-    assert_equal @env_dev_secret, StackMob.secret
-
-    ENV["STACKMOB_SAND_PRIVATE_KEY"] = nil
-    ENV["RACK_ENV"] = previous_rack_env
-  end
-
-  def test_fetches_prod_key_from_env_when_exists
-    previous_rack_env = ENV["RACK_ENV"]
-    ENV["RACK_ENV"] = "production"
-    ENV["STACKMOB_PROD_PUBLIC_KEY"] = @env_prod_key
-    
-    assert_equal @env_prod_key, StackMob.key
-
-    ENV["RACK_ENV"] = previous_rack_env
-    ENV["STACKMOB_PROD_PUBLIC_KEY"] = nil
-  end
-
-  def test_fetches_prod_secret_from_env_when_exists
-    previous_rack_env = ENV["RACK_ENV"]
-    ENV["RACK_ENV"] = "production"
-    ENV["STACKMOB_PROD_PRIVATE_KEY"] = @env_prod_secret
-    
-    assert_equal @env_prod_secret, StackMob.secret
-
-    ENV["RACK_ENV"] = previous_rack_env
-    ENV["STACKMOB_PROD_PRIVATE_KEY"] = nil
-  end
-
-
-end