synapse_pay 0.0.1

data/synapse_pay.gemspec

@@ -0,0 +1,29 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'synapse_pay/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'synapse_pay'
+  s.summary = 'Ruby bindings for SynapsePay API'
+  s.description = 'SynapsePay allows you to integrate bank payments into your applications'
+  s.homepage = 'http://synapsepay.readme.io/v1.0/docs'
+  s.authors = ['Apibits.com']
+  s.email = ['libraries@apibits.com']
+  s.version = SynapsePay::VERSION
+  s.license = 'MIT'
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('mime-types', '>= 1.25', '< 3.0')
+  s.add_dependency('json', '~> 1.8.1')
+
+  s.add_development_dependency('mocha', '~> 0.13.2')
+  s.add_development_dependency('shoulda', '~> 3.4.0')
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rake')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end
+

data/test/synapse_pay/api_list_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module SynapsePay
+  class APIListTest < ::Test::Unit::TestCase
+
+    context '#new / #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
+
+  end
+end

data/test/synapse_pay/api_method_test.rb

@@ -0,0 +1,89 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module SynapsePay
+  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 '#new / #initialize' do
+      should 'set the api_key' do
+        assert_equal(SynapsePay.api_key, @api_method.api_key)
+      end
+
+      should 'set the api_base' do
+        assert_equal(SynapsePay.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, SynapsePay.api_key, nil).returns(@headers)
+        APIMethod.new(@method, @path, @params, @headers, @object)
+      end
+
+      should 'verify the api key exists' do
+        SynapsePay.api_key = nil
+        assert_raises(AuthenticationError) do
+          APIMethod.new(@method, @path, @params, @headers, @object)
+        end
+      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/synapse_pay/headers_builder_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module SynapsePay
+  class HeadersBuilderTest < ::Test::Unit::TestCase
+
+    setup do
+      @headers = {
+        :dog => "dog-value"
+      }
+      @api_key = "test-api-key"
+      @built_headers = HeadersBuilder.build(@headers, @api_key)
+    end
+
+    should 'set the content_type' do
+      assert(@built_headers.has_key?(:content_type))
+      assert_equal('application/x-www-form-urlencoded', @built_headers[:content_type])
+    end
+
+    should 'set the user_agent' do
+      assert(@built_headers.has_key?(:user_agent))
+      assert(@built_headers[:user_agent].include?(SynapsePay::VERSION))
+      assert(@built_headers[:user_agent].include?(SynapsePay.api_version))
+    end
+
+    should 'set the basic auth header' do
+      assert(@built_headers.has_key?("Authorization"))
+      encoded_api_key = Base64.encode64("#{@api_key}:")
+      assert(@built_headers["Authorization"].include?(encoded_api_key))
+    end
+
+    should 'set the custom auth header' do
+      auth_key = "CLIENT-TOKEN"
+      header = HeadersBuilder.build(@headers, @api_key, auth_key)
+      assert(header.has_key?(auth_key))
+      assert_equal(@api_key, header[auth_key])
+    end
+
+  end
+end

data/test/synapse_pay/params_builder_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module SynapsePay
+  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/synapse_pay/path_builder_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module SynapsePay
+  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/synapse_pay/requester_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module SynapsePay
+  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(@url, @params, :get)
+        assert(url != @url)
+        assert(params.nil?)
+      end
+
+      should 'convert :delete params to a query string' do
+        url, params = Requester.prepare_params(@url, @params, :delete)
+        assert(url != @url)
+        assert(params.nil?)
+      end
+
+      should 'convert :head params to a query string' do
+        url, params = Requester.prepare_params(@url, @params, :head)
+        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(@url, expected, @method)
+          assert_equal(expected, params)
+        end
+
+        should 'convert params to a query string if a file is not present' do
+          url, params = Requester.prepare_params(@url, @params, @method)
+          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 []' 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/synapse_pay/util_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module SynapsePay
+  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

data/test/test_data.rb

@@ -0,0 +1,72 @@
+module SynapsePay
+  module TestData
+
+    def test_response(body, code=200)
+      # When an exception is raised, restclient clobbers method_missing.  Hence we
+      # can't just use the stubs interface.
+      body = JSON.generate(body) if !(body.kind_of? String)
+      m = mock
+      m.instance_variable_set('@synapse_pay_values', { :body => body, :code => code })
+      def m.body; @synapse_pay_values[:body]; end
+      def m.code; @synapse_pay_values[:code]; end
+      m
+    end
+
+    def test_mock_resource
+      {
+        :object => 'mock_resource',
+        :name => 'test mr name',
+        :nested => {
+          :id => 'test_nested_id',
+          :object => 'nested_resource',
+          :price => 500
+        },
+        :nested_alt_id => 'nested_alt_id',
+        :nested_with => {
+          :id => 'nested_with_id',
+          :price => 500
+        },
+        :thash => { :some_key => "some value" },
+        :tarray => ["abc", "xyz"],
+        :id => 'test_mock_resource_id'
+      }
+    end
+
+    def test_mock_resource_list
+      {
+        :object => 'list',
+        :data => [test_mock_resource, test_mock_resource, test_mock_resource],
+      }
+    end
+
+
+    # Errors
+    def test_api_error
+      {
+        :error => {
+          :type => "api_error"
+        }
+      }
+    end
+
+    def test_invalid_api_key_error
+      {
+        :error => {
+          :type => "invalid_request_error",
+          :message => "Invalid API Key provided: invalid"
+        }
+      }
+    end
+
+    def test_missing_id_error
+      {
+        :error => {
+          :param => "id",
+          :type => "invalid_request_error",
+          :message => "Missing id"
+        }
+      }
+    end
+
+  end
+end