connect-sdk-ruby 1.0.0

data/spec/lib/defaultimpl/default_connection_spec.rb

@@ -0,0 +1,334 @@
+require 'spec_helper'
+require 'uri'
+require 'sinatra'
+
+DefaultConnection ||= Ingenico::Connect::SDK::DefaultImpl::DefaultConnection
+StdoutCommunicatorLogger ||= Ingenico::Connect::SDK::Logging::StdoutCommunicatorLogger
+
+describe DefaultConnection do
+  let(:connect_timeout) { 10 }
+  let(:socket_timeout) { 10 }
+  let(:max_connections) { 10 }
+  let(:proxy_configuration) { nil }
+  subject(:connection) do
+    described_class.new(connect_timeout: connect_timeout,
+                          socket_timeout: socket_timeout,
+                          max_connections: max_connections,
+                          proxy_configuration: proxy_configuration)
+  end
+
+  context 'construction' do
+    context 'without proxy' do
+      let(:proxy_configuration) { nil }
+      let(:max_connections) { nil }
+
+      it 'has the correct timeout values' do
+        expect(
+          connection.instance_variable_get(:@connect_timeout)
+        ).to eq(connect_timeout)
+
+        expect(
+          connection.instance_variable_get(:@socket_timeout)
+        ).to eq(socket_timeout)
+
+        expect(
+          connection.instance_variable_get(:@proxy_configuration)
+        ).to be_nil
+      end
+    end
+
+    context 'with proxy' do
+      let(:uri) { URI('http://test-proxy') }
+
+      context 'without authentication' do
+        let(:proxy_configuration) { Ingenico::Connect::SDK::ProxyConfiguration.new(address: uri) }
+
+        it 'has the correct timeout values and proxy settings' do
+          expect(
+            connection.instance_variable_get(:@connect_timeout)
+          ).to eq(connect_timeout)
+
+          expect(
+            connection.instance_variable_get(:@socket_timeout)
+          ).to eq(socket_timeout)
+
+          expect(
+            connection.instance_variable_get(:@proxy_configuration).host
+          ).to eq('test-proxy')
+
+          expect(
+            connection.instance_variable_get(:@proxy_configuration).port
+          ).to eq(80)
+
+          expect(
+            connection.instance_variable_get(:@proxy_configuration).scheme
+          ).to eq('http')
+        end
+      end
+
+      context 'with authentication' do
+        let(:username) { 'test-username' }
+        let(:password) { 'test-password' }
+        let(:proxy_configuration) do
+          Ingenico::Connect::SDK::ProxyConfiguration.new(address: uri,
+                                      username: username,
+                                      password: password)
+        end
+
+        it 'has the correct timeout values and proxy settings' do
+          expect(
+            connection.instance_variable_get(:@connect_timeout)
+          ).to eq(connect_timeout)
+
+          expect(
+            connection.instance_variable_get(:@socket_timeout)
+          ).to eq(socket_timeout)
+
+          pc = connection.instance_variable_get(:@proxy_configuration)
+        
+          expect(pc.host).to eq('test-proxy')
+          expect(pc.port).to eq(80)
+          expect(pc.scheme).to eq('http')
+          expect(pc.username).to eq(username)
+          expect(pc.password).to eq(password)
+        end
+      end
+    end
+  end # construction
+
+  context 'sending and receiving' do
+    
+    class DummyResponse
+      def status
+        200
+      end
+      attr_accessor :headers, :body, :content_type, :uri
+    end
+
+    context 'without proxy' do
+      before :example do
+        # mock the HTTPClient obj inside DefaultConnection
+        # for each type of requests so no real requests will be made
+        client = connection.instance_variable_get(:@http_client)
+          allow(client).to receive(:get) do |uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response
+        end
+
+        allow(client).to receive(:delete) do |uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response
+        end
+
+        allow(client).to receive(:post) do |uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response.body = hash[:body]
+          dummy_response
+        end
+
+        allow(client).to receive(:put) do |uri, hash|
+          dummy_response = DummyResponse.new
+          dummy_response.headers = hash[:header]
+          dummy_response.uri = uri
+          dummy_response.body = hash[:body]
+          dummy_response
+        end
+      end
+
+      let(:headers) { { 'header1' => 'dummy', 'header2' => 'yammy' } }
+      let(:sdk_headers) do
+        arr = []
+        headers.each { |k, v| arr << Ingenico::Connect::SDK::ResponseHeader.new(k, v) }
+        arr
+      end
+      let(:uri) { URI('http://foobar.com/v1/1234/services/convert/amount?source=EUR&amount=1000&target=USD') }
+
+      def expected_header_str(headers)
+        str = ''
+        headers.each { |k, v| str += k + '=' + '"' + v + '"' + ', '}
+        str.chomp(', ')
+      end
+
+      def sdk_headers_to_s(sdk_headers)
+        sdk_headers.inject('') { |s, h| s + h.name + ':' + h.value + ',' }
+      end
+
+      it 'sends the correct get request' do
+        res = connection.get(uri, sdk_headers)
+        expect(sdk_headers_to_s(res.headers)).to eq(sdk_headers_to_s(sdk_headers))
+      end
+
+      it 'sends the correct delete request' do
+        res = connection.delete(uri, sdk_headers)
+        expect(sdk_headers_to_s(res.headers)).to eq(sdk_headers_to_s(sdk_headers))
+      end
+
+      context 'with body' do
+        let(:body) { 'dummy body' }
+
+        it 'sends the correct post request' do
+          res = connection.post(uri, sdk_headers, body)
+          expect(res.get_header_value('Content-Type')).to eq('application/json')
+          expect(res.body).to eq(body)
+        end
+
+        it 'sends the correct put request' do
+          res = connection.put(uri, sdk_headers, body)
+          expect(res.get_header_value('Content-Type')).to eq('application/json')
+          expect(res.body).to eq(body)
+        end
+      end
+
+      context 'with logging' do
+        let(:logger) { StdoutCommunicatorLogger.INSTANCE }
+        let(:request_regex) do
+          # captures:
+          #   1) uuid
+          #   2) method
+          #   3) uri
+          #   4) headers
+          %r{\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} Outgoing request \(requestId='([-a-zA-Z0-9]+)'\):
+  method:       '([A-Z]+)'
+  uri:          '(.+)'
+  headers:      '(.*)'}
+        end
+
+        let(:request_with_body_regex) do
+          # captures:
+          #   1) uuid
+          #   2) method
+          #   3) uri
+          #   4) headers
+          #   5) content_type
+          #   6) body
+          %r{\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} Outgoing request \(requestId='([-a-zA-Z0-9]+)'\):
+  method:       '([A-Z]+)'
+  uri:          '(.+)'
+  headers:      '(.*)'
+  content-type: '(.+)'
+  body:         '(.+)'}
+        end
+
+        let(:response_regex) do
+          # captures:
+          #   1) status-cde
+          #   2) headers
+          #   3) content-type
+          #   4) body
+          %r{\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} Incoming response \(requestId='([-a-zA-Z0-9]+)'.*\):
+  status-code:  '(\d+)'
+  headers:      '(.*)'
+  content-type: '(.*)'
+  body:         '(.*)'}
+        end
+
+        let(:regex) { Regexp.new(request_regex.to_s + "\n" + response_regex.to_s) }
+
+        let(:with_body_regex) do
+          Regexp.new(request_with_body_regex.to_s + "\n" + response_regex.to_s)
+        end
+
+        before :example do
+          $stdout = StringIO.new
+          connection.enable_logging(logger)
+        end
+
+        after :example do
+          connection.disable_logging
+          $stdout.close
+          $stdout = STDOUT
+        end
+
+        # TODO: DELETE is basically the same, do we need to test it?
+        it 'logs the correct get request' do
+          connection.get(uri, sdk_headers)
+          expect($stdout.string).to match(regex)
+          match_info = $stdout.string.match(regex)
+          expect(match_info[2]).to eq('GET')
+          expect(match_info[3]).to eq(uri.path + '?' + uri.query)
+          expect(match_info[4]).to eq(expected_header_str(headers))
+        end
+
+        # TODO: same for PUT
+        context 'with body' do
+          let(:body) { 'dummy body' }
+          it 'logs the correct post request' do
+            connection.post(uri, sdk_headers, body)
+            expect($stdout.string).to match(with_body_regex)
+            match_info = $stdout.string.match(with_body_regex)
+            expect(match_info[2]).to eq('POST')
+            expect(match_info[3]).to eq(uri.path + '?' + uri.query)
+            headers['Content-Type'] = 'application/json' # with body
+            expect(match_info[4]).to eq(expected_header_str(headers))
+            expect(match_info[5]).to eq('application/json')
+            expect(match_info[6]).to eq(body)
+          end
+        end
+      end
+    end
+  end # sending and receiving
+
+  context 'connection' do
+    server = nil
+    before :context do
+      WebMock.allow_net_connect!
+      server = Thread.new do
+        class DummyServer < Sinatra::Application
+          prefix = 'spec/fixtures/resources/defaultimpl/'
+
+          get '/convert_amount.json' do
+            content_type :json
+            IO.read(prefix + 'convertAmount.json')
+          end
+
+          get '/' do
+            'testing'
+          end
+
+          run!
+        end
+      end
+      sleep 1 # wait for the server
+    end
+
+    after :context do
+      Thread.kill(server) # shutdown the server
+      WebMock.disable_net_connect!
+    end
+
+    before :example do
+      connection.close
+    end
+
+    let(:uri) { URI('http://localhost:4567/convert_amount.json') }
+    let(:sdk_headers) { [] }
+
+    it 'uses persistent connection if HTTP 1.1 is supported' do
+      100.times { connection.get(uri, sdk_headers) }
+      expect(connection.session_count).to eq(1)
+    end
+
+    it 'retrieves the correct json file' do
+      res = connection.get(uri, sdk_headers)
+      prefix = 'spec/fixtures/resources/defaultimpl/'
+      expect(res.body).to eq(IO.read(prefix + 'convertAmount.json'))
+    end
+
+    it 'can explicitly close connections' do
+      connection.get(uri, sdk_headers)
+      expect(connection.session_count).to eq(1)
+
+      connection.close
+      expect(connection.session_count).to eq(0)
+
+      connection.get(uri, sdk_headers)
+      expect(connection.session_count).to eq(1)
+    end
+  end
+end

data/spec/lib/defaultimpl/default_marshaller_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'ingenico/connect/sdk/domain/definitions/address'
+require 'ingenico/connect/sdk/domain/token/customer_token'
+require 'ingenico/connect/sdk/domain/token/token_card'
+require 'ingenico/connect/sdk/domain/token/token_card_data'
+require 'ingenico/connect/sdk/domain/token/token_response'
+
+DataObject ||= Ingenico::Connect::SDK::DataObject
+DefaultMarshaller ||= Ingenico::Connect::SDK::DefaultImpl::DefaultMarshaller
+Token ||= Ingenico::Connect::SDK::Domain::Token
+
+class TokenResponseWithExtraField < Token::TokenResponse
+  attr_accessor :dummy
+end
+
+describe DefaultMarshaller do
+  context 'unmarshal()' do
+    it 'should unmarshal extra fields' do
+      token = TokenResponseWithExtraField.new
+      token.card = Token::TokenCard.new
+      token.card.customer = Token::CustomerToken.new
+      token.card.customer.billing_address = Ingenico::Connect::SDK::Domain::Definitions::Address.new
+      token.card.customer.billing_address.country_code = 'NL'
+      token.card.data = Token::TokenCardData.new
+      token.dummy = 'foobar'
+      # marshal the extended token and unmarshal it as a regular token response
+      unmarshalled = DefaultMarshaller.INSTANCE.unmarshal(DefaultMarshaller.INSTANCE.marshal(token), Token::TokenResponse)
+
+      expect(unmarshalled.card).to_not be_nil
+      expect(unmarshalled.card.customer).to_not be_nil
+      expect(unmarshalled.card.customer.billing_address).to_not be_nil
+      expect(unmarshalled.card.customer.billing_address.country_code).to eq('NL')
+      expect(token.card.data).to_not be_nil
+    end
+  end
+end

data/spec/lib/factory_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'uri'
+
+Factory ||= Ingenico::Connect::SDK::Factory
+
+describe 'Factory' do
+  it 'can initialize configurations' do
+    configuration = Factory.create_configuration(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY)
+
+    expect(configuration.api_endpoint).to eq('https://api-sandbox.globalcollect.com')
+    expect(configuration.authorization_type).to eq('v1HMAC')
+    expect(configuration.connect_timeout).to eq(-1)
+    expect(configuration.socket_timeout).to eq(-1)
+    expect(configuration.max_connections).to eq(100)
+    expect(configuration.api_key_id).to eq(API_KEY_ID)
+    expect(configuration.secret_api_key).to eq(SECRET_API_KEY)
+    expect(configuration.proxy_configuration).to be_nil
+  end
+
+  it 'can initialize communicators' do
+    communicator = Factory.create_communicator_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY)
+    session = communicator.instance_variable_get(:@session)
+    connection = session.connection
+    authenticator = session.authenticator
+    meta_data_provider = session.meta_data_provider
+    request_headers = meta_data_provider.meta_data_headers
+
+    expect(communicator.marshaller).to be(Ingenico::Connect::SDK::DefaultImpl::DefaultMarshaller.INSTANCE)
+    expect(connection).to be_an_instance_of(Ingenico::Connect::SDK::DefaultImpl::DefaultConnection)
+    expect(authenticator).to be_an_instance_of(Ingenico::Connect::SDK::DefaultImpl::DefaultAuthenticator)
+    expect(meta_data_provider).to be_an_instance_of(Ingenico::Connect::SDK::MetaDataProvider)
+
+    expect(authenticator.instance_variable_get(:@authorization_type))
+        .to eq(Ingenico::Connect::SDK::DefaultImpl::AuthorizationType.get_authorization('v1HMAC'))
+    expect(authenticator.instance_variable_get(:@api_key_id)).to eq(API_KEY_ID)
+    expect(authenticator.instance_variable_get(:@secret_api_key)).to eq(SECRET_API_KEY)
+
+    expect(request_headers.length).to eq(1)
+    expect(request_headers[0].name).to eq('X-GCS-ServerMetaInfo')
+  end
+end

data/spec/lib/logging/header_obfuscator_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+HeaderObfuscator ||= Ingenico::Connect::SDK::Logging::HeaderObfuscator
+ValueObfuscator ||= Ingenico::Connect::SDK::Logging::ValueObfuscator
+
+describe HeaderObfuscator do
+  subject(:sample) { HeaderObfuscator.new(obsfs) }
+  context 'initialize' do
+    let(:obsfs) { { 'k1' => ValueObfuscator.fixed_length(5),
+                    'k2' => ValueObfuscator.keep_start_count(2) } }
+    it 'is cass insensitive' do
+      obsfs_copy = sample.instance_variable_get(:@obfuscators)
+      expect(
+        obsfs_copy['k1']
+      ).to equal(obsfs_copy['K1'])
+    end
+  end
+
+  it '.builder returns new Builder obj' do
+    expect(
+      HeaderObfuscator.builder.is_a? HeaderObfuscator::Builder
+    ).to be(true)
+  end
+
+  context 'Builder' do
+    it 'checks argument type' do
+      b = HeaderObfuscator.builder
+      expect {
+        b.with_all(123)
+      }.to raise_error(ArgumentError)
+
+      expect {
+        b.with_fixed_length(123)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'inherits parent methods' do
+      b = HeaderObfuscator.builder
+      expect {
+        b.with_keep_start_count('k1', 123)
+        b.with_keep_end_count('k2', 123)
+      }.not_to raise_error
+    end
+
+    it 'implements build method' do
+      expect(
+        HeaderObfuscator.builder.build.is_a? HeaderObfuscator
+      ).to be(true)
+    end
+  end
+end