alman 0.0.1

data/test/alman/api_client_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class ApiClientTest < ::Test::Unit::TestCase
+    setup do
+      @headers = {
+        :Accept => "application/json",
+        :Authorization => "Fake Auth"
+      }
+      @params = {
+        :customer_id => 123
+      }
+      @client = ApiClient.new(@headers, @params)
+    end
+
+    context '#execute' do
+      setup do
+        @api_method = mock
+        @api_method.stubs(:headers).returns({
+          :fake_header => "fake-header-val"
+        })
+        @api_method.stubs(:headers=)
+        @api_method.stubs(:params).returns({
+          :fake_param => "fake-param"
+        })
+        @api_method.stubs(:params=)
+        @api_method.stubs(:execute)
+      end
+
+      should 'merge the client headers and params into the api_method' do
+        expected_headers = { :hello => true }
+        expected_params = { :goodbye => false }
+
+        ParamsBuilder.expects(:merge).with(@api_method.headers, @headers).returns(expected_headers)
+        ParamsBuilder.expects(:merge).with(@api_method.params, @params).returns(expected_params)
+
+        @api_method.expects(:headers=).with(expected_headers)
+        @api_method.expects(:params=).with(expected_params)
+
+        @client.execute(@api_method)
+      end
+
+      should 'call api_method.execute and return the results' do
+        expected = { :status => "success!" }
+        @api_method.expects(:execute).returns(expected)
+        assert_equal(expected, @client.execute(@api_method))
+      end
+    end
+
+  end
+end

data/test/alman/api_endpoint_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class ApiEndpointTest < ::Test::Unit::TestCase
+    context '#initialize' do
+      should 'set the client and parent' do
+        ep = ApiEndpoint.new("client", "parent")
+        assert_equal("client", ep.client)
+        assert_equal("parent", ep.parent)
+      end
+    end
+  end
+end

data/test/alman/api_list_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class ApiListTest < ::Test::Unit::TestCase
+
+    context '#initialize' do
+      setup do
+        @fake_resource = { :data => "fake-data" }
+        @list = ApiList.new(ApiResource, [@fake_resource])
+      end
+
+      should 'set the klass' do
+        assert_equal(ApiResource, @list.klass)
+      end
+
+      should 'convert the data to klass instances' do
+        assert(@list.first.is_a?(ApiResource))
+        assert_equal(@fake_resource, @list.first.json)
+      end
+    end
+
+    context '#refresh_from' do
+      setup do
+        @fake_resource = { :data => "fake-data" }
+        @fake_method = "fake-api-method"
+        @fake_client = "fake-client"
+        @list = ApiList.new(ApiResource, [], "invalid", "invalid")
+      end
+
+      should 'update the api_method' do
+        @list.refresh_from([@fake_resource], @fake_method)
+        assert_equal(@list.api_method, @fake_method)
+      end
+
+      should 'update the client' do
+        @list.refresh_from([@fake_resource], nil, @fake_client)
+        assert_equal(@list.client, @fake_client)
+      end
+
+      should 'clear existing data' do
+        @list.refresh_from(["new-data"])
+
+        assert_nil(@list.api_method)
+        assert_nil(@list.client)
+      end
+    end
+
+  end
+end

data/test/alman/api_method_test.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class ApiMethodTest < ::Test::Unit::TestCase
+    setup do
+      @method = :get
+      @path = "/testing"
+      @params = { :param_a => "1" }
+      @headers = { :header_a => "a" }
+      @object = mock
+      @api_method = ApiMethod.new(@method, @path, @params, @headers, @object)
+    end
+
+    context '#initialize' do
+      should 'set the api_base' do
+        assert_equal(Alman.api_base, @api_method.api_base)
+      end
+
+      should 'use PathBuilder with path, object, and params' do
+        PathBuilder.expects(:build).with(@path, @object, @params).returns(@path)
+        ApiMethod.new(@method, @path, @params, @headers, @object)
+      end
+
+      should 'use ParamsBuilder with params' do
+        ParamsBuilder.expects(:build).with(@params).returns(@params)
+        ApiMethod.new(@method, @path, @params, @headers, @object)
+      end
+
+      should 'use HeadersBuilder with headers, api_key, and nil auth_header' do
+        HeadersBuilder.expects(:build).with(@headers).returns(@headers)
+        ApiMethod.new(@method, @path, @params, @headers, @object)
+      end
+    end
+
+    context '#execute' do
+      setup do
+        @mock_response = mock
+        @mock_response.stubs(:body).returns('{"status": "success"}')
+        @mock_response.stubs(:code).returns(200)
+      end
+
+      should 'call Requester.request with the set attrs' do
+        Requester.expects(:request).with(@method, @api_method.url, @api_method.params, @api_method.headers).returns(@mock_response)
+        @api_method.execute
+      end
+
+      should 'create an ApiError if the request fails' do
+        Requester.expects(:request).raises(RestClient::RequestTimeout.new)
+
+        assert_raises(ApiError) { @api_method.execute }
+      end
+
+      should 'return the response parsed as json' do
+        Requester.expects(:request).returns(@mock_response)
+        assert_equal({:status => "success"}, @api_method.execute)
+      end
+
+      should 'return an AuthenticationError if the status is 401' do
+        error = RestClient::ExceptionWithResponse.new
+        error.expects(:http_code).returns(401)
+
+        Requester.expects(:request).raises(error)
+        assert_raises(AuthenticationError) { @api_method.execute }
+      end
+    end
+
+    context '#response_json' do
+      setup do
+        @api_method.response_body = 'not-valid-json'
+      end
+
+      should 'throw an error if the response_body isnt valid json' do
+        assert_raises(ApiError) { @api_method.response_json }
+      end
+    end
+
+  end
+end

data/test/alman/headers_builder_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class HeadersBuilderTest < ::Test::Unit::TestCase
+
+    setup do
+      @headers = {
+        :dog => "dog-value"
+      }
+      @built_headers = HeadersBuilder.build(@headers)
+    end
+
+    should 'set the user_agent' do
+      assert(@built_headers.has_key?(:user_agent))
+      assert(@built_headers[:user_agent].include?(Alman::VERSION))
+      assert(@built_headers[:user_agent].include?(Alman.api_version))
+    end
+
+    should 'set a client user agent' do
+      # This can be raw or json encoded depending on various things
+      unless @built_headers.has_key?(:x_alman_client_user_agent) ||
+        @built_headers.has_key?(:x_alman_client_raw_user_agent)
+        raise "No valid client user agent found"
+      end
+    end
+
+  end
+end

data/test/alman/params_builder_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class ParamsBuilderTest < ::Test::Unit::TestCase
+
+    setup do
+      @params = {
+        :dog => "dog-value",
+        "string" => "str-value"
+      }
+    end
+
+    context '#clean' do
+      setup do
+        @built_params = ParamsBuilder.clean(@params)
+      end
+
+      should 'convert keys to symbols' do
+        assert(@built_params.has_key?(:string))
+        assert_equal(@params["string"], @built_params[:string])
+      end
+
+      should 'not have any string keys' do
+        @built_params.each do |k, v|
+          assert(k.is_a?(Symbol))
+        end
+      end
+    end
+
+    context '#merge' do
+      setup do
+        @to_merge = {
+          :string => "other-str-value",
+          "cat" => "cat-value"
+        }
+        @built_params = ParamsBuilder.merge(@params, @to_merge)
+      end
+
+      should 'convert keys to symbols' do
+        assert(@built_params.has_key?(:cat))
+        assert(@built_params.has_key?(:string))
+        assert(!@built_params.has_key?("string"))
+      end
+
+      should 'merge in all values' do
+        assert_equal(@params[:dog], @built_params[:dog])
+        assert_equal(@to_merge[:string], @built_params[:string])
+        assert_equal(@to_merge["cat"], @built_params[:cat])
+      end
+
+      should 'prioritize values in @to_merge' do
+        assert_equal(@to_merge[:string], @built_params[:string])
+      end
+    end
+
+  end
+end

data/test/alman/path_builder_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class PathBuilderTest < ::Test::Unit::TestCase
+    class FakeClass
+      def abc; return "abc-value"; end
+      def self.xyz; return "xyz-value"; end
+    end
+
+    setup do
+      @params = {
+        :dog => "dog-value"
+      }
+      @obj = FakeClass.new
+    end
+
+    should 'use instance methods' do
+      path = "/a/:abc/123"
+      expected = "/a/abc-value/123"
+
+      actual = PathBuilder.build(path, @obj, nil)
+      assert_equal(expected, actual)
+    end
+
+    should 'use class methods' do
+      path = "/a/:xyz/123"
+      expected = "/a/xyz-value/123"
+
+      actual = PathBuilder.build(path, FakeClass, nil)
+      assert_equal(expected, actual)
+    end
+
+    should 'use param values' do
+      path = "/a/:dog/123"
+      expected = "/a/dog-value/123"
+
+      actual = PathBuilder.build(path, nil, @params)
+      assert_equal(expected, actual)
+    end
+
+    should 'use both methods and params' do
+      path = "/a/:dog/:abc/123"
+      expected = "/a/dog-value/abc-value/123"
+
+      actual = PathBuilder.build(path, @obj, @params)
+      assert_equal(expected, actual)
+    end
+
+  end
+end

data/test/alman/requester_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class RequesterTest < ::Test::Unit::TestCase
+    setup do
+    end
+
+    context '#prepare_params' do
+      setup do
+        @url = "test_url"
+        @params = { :a => 1, :b => [2, 3] }
+      end
+
+      should 'convert :get params to a query string' do
+        url, params = Requester.prepare_params(:get, @url, @params)
+        assert(url != @url)
+        assert(params.nil?)
+      end
+
+      should 'convert :delete params to a query string' do
+        url, params = Requester.prepare_params(:delete, @url, @params)
+        assert(url != @url)
+        assert(params.nil?)
+      end
+
+      should 'convert :head params to a query string' do
+        url, params = Requester.prepare_params(:head, @url, @params)
+        assert(url != @url)
+        assert(params.nil?)
+      end
+
+      context 'method = :post' do
+        setup do
+          @method = :post
+        end
+
+        should 'not convert params to a query string if a file is in them' do
+          expected = { file: File.new(__FILE__) }
+          url, params = Requester.prepare_params(@method, @url, expected)
+          assert_equal(expected, params)
+        end
+
+        should 'convert params to a query string if a file is not present' do
+          url, params = Requester.prepare_params(@method, @url, @params)
+          assert(params.is_a?(String))
+        end
+      end
+    end
+
+    context '#query_string' do
+      should 'join #query_array results with an "&"' do
+        start = { :a => 1, :b => [2, 3] }
+        expected = ["a=1", "b[]=2", "b[]=3"]
+
+        actual = Requester.query_string(start).split('&')
+        actual.each do |str|
+          assert(expected.include?(str))
+        end
+      end
+    end
+
+    context '#query_array' do
+      should 'convert { :a => "value" } to ["a=value"]' do
+        start = { :a => "value" }
+        finish = ["a=value"]
+
+        assert_equal(finish, Requester.query_array(start))
+      end
+
+      should 'convert { :a => { :b => { :c => "cvalue" } } } to ["a[b][c]=cvalue"]' do
+        start = { :a => { :b => { :c => "cvalue" } } }
+        finish = ["a[b][c]=cvalue"]
+
+        assert_equal(finish, Requester.query_array(start))
+      end
+
+      should 'convert { :a => [1, 2] } to ["a[]=1", "a[]=2"]' do
+        start = { :a => [1, 2] }
+        finish = ["a[]=1", "a[]=2"]
+
+        assert_equal(finish, Requester.query_array(start))
+      end
+    end
+
+  end
+end

data/test/alman/util_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Alman
+  class UtilTest < ::Test::Unit::TestCase
+    context '#symbolize_keys' do
+      should "convert keys to symbols" do
+        start = {
+          'foo' => 'bar',
+          'array' => [{ 'foo' => 'bar' }],
+          'nested' => {
+            1 => 2,
+            :symbol => 9,
+            'string' => nil
+          }
+        }
+        finish = {
+          :foo => 'bar',
+          :array => [{ :foo => 'bar' }],
+          :nested => {
+            1 => 2,
+            :symbol => 9,
+            :string => nil
+          }
+        }
+
+        symbolized = Util.symbolize_keys(start)
+        assert_equal(finish, symbolized)
+      end
+    end
+
+    context '#sorta_deep_clone' do
+      # Super hand wavy test.. but it works for now so whatever.
+      should 'clone well enough that we dont accidentally alter json' do
+        start = { :a => "abc", :b => [ { :c => "c-1" }, { :c => "c-2" } ] }
+        cloned = Util.sorta_deep_clone(start)
+
+        cloned[:a] = "123"
+        cloned[:b] << { :c => "c-3" }
+        cloned[:b][0][:c] = "c-one"
+
+        assert_equal({ :a => "abc", :b => [ { :c => "c-1" }, { :c => "c-2" } ] }, start)
+      end
+    end
+
+    context '#constantize' do
+      should 'convert :ApiResource to the class object' do
+        assert_equal(ApiResource, Util.constantize(:ApiResource))
+      end
+    end
+  end
+end