acquiring-sdk-ruby 0.1.0

data/spec/lib/factory_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'uri'
+
+Factory ||= Worldline::Acquiring::SDK::Factory
+
+describe 'Factory' do
+  it 'can initialize configurations' do
+    configuration = Factory.create_configuration(PROPERTIES_URI_OAUTH2, OAUTH2_CLIENT_ID, OAUTH2_CLIENT_SECRET)
+
+    expect(configuration.api_endpoint).to eq('https://api.preprod.acquiring.worldline-solutions.com')
+    expect(configuration.authorization_type).to eq('OAuth2')
+    expect(configuration.connect_timeout).to eq(1000)
+    expect(configuration.socket_timeout).to eq(1000)
+    expect(configuration.max_connections).to eq(100)
+    expect(configuration.oauth2_client_id).to eq(OAUTH2_CLIENT_ID)
+    expect(configuration.oauth2_client_secret).to eq(OAUTH2_CLIENT_SECRET)
+    expect(configuration.proxy_configuration).to be_nil
+  end
+
+  it 'can initialize communicators' do
+    communicator = Factory.create_communicator_from_file(PROPERTIES_URI_OAUTH2, OAUTH2_CLIENT_ID, OAUTH2_CLIENT_SECRET)
+    connection = communicator.instance_variable_get(:@connection)
+    authenticator = communicator.instance_variable_get(:@authenticator)
+    metadata_provider = communicator.instance_variable_get(:@metadata_provider)
+    request_headers = metadata_provider.metadata_headers
+
+    expect(communicator.marshaller).to be(Worldline::Acquiring::SDK::JSON::DefaultMarshaller.instance)
+    expect(connection).to be_an_instance_of(Worldline::Acquiring::SDK::Communication::DefaultConnection)
+    expect(authenticator).to be_an_instance_of(Worldline::Acquiring::SDK::Authentication::OAuth2Authenticator)
+    expect(metadata_provider).to be_an_instance_of(Worldline::Acquiring::SDK::Communication::MetadataProvider)
+
+    expect(authenticator.instance_variable_get(:@client_id)).to eq(OAUTH2_CLIENT_ID)
+    expect(authenticator.instance_variable_get(:@client_secret)).to eq(OAUTH2_CLIENT_SECRET)
+
+    expect(request_headers.length).to eq(1)
+    expect(request_headers[0].name).to eq('X-WL-ServerMetaInfo')
+  end
+end

data/spec/lib/json/default_marshaller_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+DataObject ||= Worldline::Acquiring::SDK::Domain::DataObject
+DefaultMarshaller ||= Worldline::Acquiring::SDK::JSON::DefaultMarshaller
+
+class BaseObject < DataObject
+  attr_accessor :id
+
+  def to_h
+    hash = super
+    hash['id'] = @id unless @id.nil?
+    hash
+  end
+
+  def from_hash(hash)
+    super
+    if hash.has_key? 'id'
+      @id = hash['id']
+    end
+  end
+end
+
+class ObjectWithExtraField < BaseObject
+  attr_accessor :dummy
+end
+
+describe DefaultMarshaller do
+  context 'unmarshal()' do
+    it 'should unmarshal extra fields' do
+      object = ObjectWithExtraField.new
+      object.id = '1234'
+      object.dummy = 'foobar'
+      # marshal the extended object and unmarshal it as a regular object
+      unmarshalled = DefaultMarshaller.instance.unmarshal(DefaultMarshaller.instance.marshal(object), BaseObject)
+
+      expect(unmarshalled.id).to eq('1234')
+    end
+  end
+end

data/spec/lib/logging/obfuscation/body_obfuscator_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+BodyObfuscator = Worldline::Acquiring::SDK::Logging::Obfuscation::BodyObfuscator
+
+def test_obfuscate_body_with_matches(original_resource, obfuscated_resource,
+                                     body_obfuscator=BodyObfuscator.default_obfuscator)
+  prefix = 'spec/fixtures/resources/logging/'
+  body = IO.read(prefix + original_resource)
+  expected = IO.read(prefix + obfuscated_resource)
+  expected == body_obfuscator.obfuscate_body(body)
+end
+
+def test_obfuscate_body_with_no_matches(resource)
+  prefix = 'spec/fixtures/resources/logging/'
+  body = IO.read(prefix + resource)
+  body == BodyObfuscator.default_obfuscator.obfuscate_body(body)
+end
+
+describe BodyObfuscator do
+  context '.obfuscate_body()' do
+
+    context 'with null body' do
+      let(:body) { nil }
+      it 'returns null body' do
+        expect(
+          BodyObfuscator.default_obfuscator.obfuscate_body(body)
+        ).to be_nil
+      end
+    end
+
+    context 'with empty body' do
+      let(:body) { '' }
+      it 'returns empty body' do
+        expect(
+          BodyObfuscator.default_obfuscator.obfuscate_body(body)
+        ).to eq(body)
+      end
+    end
+
+    it 'works with card' do
+      expect(
+        test_obfuscate_body_with_matches("bodyWithCardOriginal.json",
+                                         "bodyWithCardObfuscated.json")
+      ).to be(true)
+    end
+
+    it 'works with custom card rule' do
+      def obfuscate_custom(value)
+        # range describes the range of characters to replace with asterisks
+        range = 6...(value.length - 4)
+        value[range] = '*' * range.size
+        value
+      end
+
+      body_obfuscator = BodyObfuscator.new(additional_rules={
+        'cardNumber' => method(:obfuscate_custom)
+      })
+
+      expect(
+        test_obfuscate_body_with_matches("bodyWithCardOriginal.json",
+                                         "bodyWithCardCustomObfuscated.json",
+                                         body_obfuscator=body_obfuscator)
+      ).to be(true)
+    end
+
+    it 'works with bin' do
+      expect(
+        test_obfuscate_body_with_matches("bodyWithBinOriginal.json",
+                                         "bodyWithBinObfuscated.json")
+      ).to be(true)
+    end
+
+    it 'works when there is no match' do
+      expect(
+        test_obfuscate_body_with_no_matches("bodyNoObfuscation.json")
+      ).to be(true)
+    end
+
+    it 'works with object' do
+      expect(
+        test_obfuscate_body_with_matches("bodyWithObjectOriginal.json",
+                                         "bodyWithObjectObfuscated.json")
+      ).to be(true)
+    end
+  end
+end

data/spec/lib/logging/obfuscation/header_obfuscator_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+HeaderObfuscator = Worldline::Acquiring::SDK::Logging::Obfuscation::HeaderObfuscator
+Obfuscation = Worldline::Acquiring::SDK::Logging::Obfuscation
+
+def test_obfuscate_header_with_match(name, original_value, expected_value,
+                                     header_obfuscator=HeaderObfuscator.default_obfuscator)
+  expected_value == header_obfuscator.obfuscate_header(name, original_value)
+end
+
+def test_obfuscate_header_with_no_match(name, original_value)
+  original_value == HeaderObfuscator.default_obfuscator.obfuscate_header(name, original_value)
+end
+
+describe HeaderObfuscator do
+  context '.obfuscate_header()' do
+    it 'works when there is a match' do
+      expect(
+        test_obfuscate_header_with_match("Authorization",
+                                         "Basic QWxhZGRpbjpPcGVuU2VzYW1l",
+                                         "********")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("authorization",
+                                         "Basic QWxhZGRpbjpPcGVuU2VzYW1l",
+                                         "********")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("AUTHORIZATION",
+                                         "Basic QWxhZGRpbjpPcGVuU2VzYW1l",
+                                         "********")
+      ).to be(true)
+    end
+
+    it 'works when there is no match' do
+      expect(
+        test_obfuscate_header_with_no_match("Content-Type",
+                                            "application/json")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_no_match("content-type",
+                                            "application/json")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_no_match("CONTENT-TYPE",
+                                            "application/json")
+      ).to be(true)
+    end
+
+    it 'works with a custom rule' do
+      header_obfuscator = HeaderObfuscator.new(additional_rules={
+        'content-type' => Obfuscation.obfuscate_all
+      })
+
+      expect(
+        test_obfuscate_header_with_match("Authorization",
+                                         "Basic QWxhZGRpbjpPcGVuU2VzYW1l",
+                                         "********",
+                                         header_obfuscator=header_obfuscator)
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("authorization",
+                                         "Basic QWxhZGRpbjpPcGVuU2VzYW1l",
+                                         "********",
+                                         header_obfuscator=header_obfuscator)
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("AUTHORIZATION",
+                                         "Basic QWxhZGRpbjpPcGVuU2VzYW1l",
+                                         "********",
+                                         header_obfuscator=header_obfuscator)
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("Content-Type", "application/json",
+                                         "****************",
+                                         header_obfuscator=header_obfuscator)
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("content-type", "application/json",
+                                         "****************",
+                                         header_obfuscator=header_obfuscator)
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("CONTENT-TYPE", "application/json",
+                                         "****************",
+                                         header_obfuscator=header_obfuscator)
+      ).to be(true)
+    end
+
+  end
+end

data/spec/lib/logging/ruby_communicator_logger_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'logger'
+require 'English'
+
+RubyCommunicatorLogger = Worldline::Acquiring::SDK::Logging::RubyCommunicatorLogger
+
+describe RubyCommunicatorLogger do
+
+  # TODO: is it possbile that we run into a filename collision here?
+  let(:filename) { "testing-#{(0...8).map { (65 + rand(26)).chr }.join}.log" }
+  let(:logger) { Logger.new(RubyCommunicatorLogger.create_logfile(filename)) }
+  let(:regex) { Regexp.new("#{tag}, .* -- : (.*)#{$RS}", Regexp::MULTILINE) }
+  subject(:sample) { RubyCommunicatorLogger.new(logger, log_level, error_level) }
+
+  def expected_msg(msg, thrown=false)
+    return msg unless thrown
+    msg + $RS + thrown.to_s + $RS + thrown.backtrace.join($RS)
+  end
+
+  after do
+    # delete the log files
+    logger.close
+    File.delete(filename)
+  end
+
+
+  context 'logging without error' do
+
+    let(:error_level) { Logger::WARN }
+    let(:msg) { 'Hello World' }
+
+    context "with level 'INFO'" do
+      let(:log_level) { Logger::INFO }
+      let(:tag) { 'I' }
+
+      it 'should not throw an exception when logging unicode strings' do
+        message =  Worldline::Acquiring::SDK::Logging::ResponseLogMessageBuilder.new("aaa", 2345, 45.32)
+        body = "Schröder"
+        content = "JSON"
+        message.set_body(body, content)
+        sample.log(message.get_message)
+      end
+      it 'logs with the correct logLevel and message' do
+        sample.log(msg)
+        line = IO.readlines(filename).last
+
+        expect(line).to match(regex)
+        expect(
+          line.match(regex)[1] # first capture
+        ).to eq(expected_msg(msg))
+      end
+    end
+
+    context "with level 'WARN'" do
+      let(:log_level) { Logger::WARN }
+      let(:tag) { 'W' }
+
+      it 'logs with the correct logLevel and message' do
+        sample.log(msg)
+        line = IO.readlines(filename).last
+
+        expect(line).to match(regex)
+        expect(
+          line.match(regex)[1] # idem
+        ).to eq(expected_msg(msg))
+      end
+    end
+  end
+
+  context 'logging with error' do
+    let(:error_level) { Logger::WARN }
+    let(:log_level) { Logger::INFO }
+    let(:msg) { 'Some error message' }
+    let(:tag) { 'W' }
+
+    it 'logs with the errorLevel and message with backtrace' do
+      def dummy_method
+        raise 'Boom!'
+      end
+
+      begin
+        dummy_method
+      rescue => exception
+        sample.log(msg, exception)
+      end
+
+      line = IO.read(filename)
+      expect(line).to match(regex)
+      expect(line.match(regex)[1]).to eq(expected_msg(msg, exception))
+    end
+  end
+end

data/spec/lib/logging/stdout_communicator_logger_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'English'
+
+StdoutCommunicatorLogger ||= Worldline::Acquiring::SDK::Logging::StdoutCommunicatorLogger
+
+describe StdoutCommunicatorLogger do
+  before do
+    $stdout = StringIO.new
+  end
+
+  after do
+    $stdout.close
+    $stdout = STDOUT
+  end
+
+  subject(:sample) { StdoutCommunicatorLogger.instance }
+  let(:regex) do
+    Regexp.new("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2} (.*)#{$RS}",
+               Regexp::MULTILINE)
+  end
+
+  def expected_msg(msg, thrown=false)
+    return msg unless thrown
+    msg + $RS + thrown.to_s + $RS + thrown.backtrace.join($RS)
+  end
+
+  context 'test log' do
+    let(:msg) { 'Hello World' }
+
+    it 'should log the exact message' do
+      sample.log(msg)
+
+      expect(
+        $stdout.string
+      ).to match(regex)
+
+      expect(
+        regex.match($stdout.string)[1] # first capture
+      ).to eq(expected_msg(msg))
+    end
+
+    it 'should log the backtrace of the exception' do
+
+      def dummy_method
+        raise 'Boom!'
+      end
+
+      begin
+        dummy_method
+      rescue => exception
+        sample.log(msg, exception)
+      end
+
+      expect(
+        $stdout.string
+      ).to match(regex)
+
+      expect(
+        regex.match($stdout.string)[1] # first capture
+      ).to eq(expected_msg(msg, exception))
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require 'rspec'
+require 'webmock/rspec'
+
+require 'worldline/acquiring/sdk'
+require 'comparable_extension'
+
+RSpec.configure do |config|
+
+  WebMock.disable_net_connect! # make it explicit
+
+  config.order = 'random'
+  config.profile_examples = 5 # show the slowest tests
+
+  # declaration of constants to use throughout the tests
+  config.before(:suite) do
+    class MockAuthenticator < Worldline::Acquiring::SDK::Authentication::Authenticator
+      def get_authorization(http_method, resource_uri, request_headers)
+        'ignored'
+      end
+    end
+
+    PROPERTIES_URI_OAUTH2 = File.expand_path('../../spec/fixtures/resources/properties.oauth2.yml', __FILE__)
+    OAUTH2_CLIENT_ID = 'someId'
+    OAUTH2_CLIENT_SECRET = 'someSecret'
+    authenticator = MockAuthenticator.new
+    COMMUNICATOR = Worldline::Acquiring::SDK::Factory.create_communicator_from_file(PROPERTIES_URI_OAUTH2, OAUTH2_CLIENT_ID, OAUTH2_CLIENT_SECRET,
+                                                                                    authenticator: authenticator)
+    CLIENT = Worldline::Acquiring::SDK::Factory.create_client_from_communicator(COMMUNICATOR)
+  end
+
+  config.after(:suite) { CLIENT.close }
+end