connect-sdk-ruby 1.0.0

data/spec/lib/logging/logging_util_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+LoggingUtil = Ingenico::Connect::SDK::Logging::LoggingUtil
+
+def test_obfuscate_body_with_matches(originalResource, obfuscatedResource)
+  prefix = 'spec/fixtures/resources/logging/'
+  body = IO.read(prefix + originalResource)
+  expected = IO.read(prefix + obfuscatedResource)
+  expected == LoggingUtil.obfuscate_body(body)
+end
+
+def test_obfuscate_body_with_no_matches(resource)
+  prefix = 'spec/fixtures/resources/logging/'
+  body = IO.read(prefix + resource)
+  body == LoggingUtil.obfuscate_body(body)
+end
+
+def test_obfuscate_header_with_match(name, originalValue, expectedValue)
+  expectedValue == LoggingUtil.obfuscate_header(name, originalValue)
+end
+
+def test_obfuscate_header_with_no_match(name, originalValue)
+  originalValue == LoggingUtil.obfuscate_header(name, originalValue)
+end
+
+describe LoggingUtil do
+  context '.obfuscate_body()' do
+
+    context 'with null body' do
+      let(:body) { nil }
+      it 'returns null body' do
+        expect(
+          LoggingUtil.obfuscate_body(body)
+        ).to be_nil
+      end
+    end
+
+    context 'with empty body' do
+      let(:body) { '' }
+      it 'returns empty body' do
+        expect(
+          LoggingUtil.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 iban' do
+      expect(
+        test_obfuscate_body_with_matches("bodyWithIbanOriginal.json",
+                                         "bodyWithIbanObfuscated.json")
+      ).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
+  end
+
+  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)
+      
+      expect(
+        test_obfuscate_header_with_match("X-GCS-Authentication-Token",
+                                         "foobar", "********")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("x-gcs-authentication-token",
+                                         "foobar", "********")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("X-GCS-AUTHENTICATION-TOKEN",
+                                         "foobar", "********")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("X-GCS-CallerPassword", "foobar", 
+                                         "********")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("x-gcs-callerpassword", "foobar", 
+                                     "********")
+      ).to be(true)
+
+      expect(
+        test_obfuscate_header_with_match("X-GCS-CALLERPASSWORD", "foobar",
+                                         "********")
+      ).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
+  end
+end

data/spec/lib/logging/obfuscator_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+Obfuscator ||= Ingenico::Connect::SDK::Logging::Obfuscator
+ValueObfuscator ||= Ingenico::Connect::SDK::Logging::ValueObfuscator
+
+describe Obfuscator do
+  subject(:sample) { Obfuscator.new(obsfs, caseInsensitive) }
+  context 'initialize' do
+    let(:obsfs) { { 'k1' => ValueObfuscator.fixed_length(5),
+                    'k2' => ValueObfuscator.keep_start_count(2) } }
+
+    context 'case sensitive' do
+      let(:caseInsensitive) { false }
+      it 'deep-copies obfuscators' do
+        obsfs_copy = sample.instance_variable_get(:@obfuscators)
+        obsfs['k2'] = nil
+        expect(obsfs_copy).not_to be_nil
+      end
+    end
+
+    context 'case insensitive' do
+      let(:caseInsensitive) { true }
+      it 'deep-copies obfuscators' do
+        obsfs_copy = sample.instance_variable_get(:@obfuscators)
+        expect(obsfs_copy['K2']).to equal(obsfs_copy['k2'])
+        obsfs['k2'] = nil
+        expect(obsfs_copy).not_to be_nil
+      end
+    end
+  end
+
+  context '.obfuscate_value' do
+    let(:obsfs) { { 'k1' => ValueObfuscator.fixed_length(10),
+                    'k2' => ValueObfuscator.keep_start_count(1) } }
+    let(:caseInsensitive) { false }
+    it 'uses the correct obfuscator' do
+      str = 'str'
+
+      expect(
+        sample.obfuscate_value('k1', str)
+      ).to eq('*' * 10)
+
+      expect(
+        sample.obfuscate_value('k2', str)
+      ).to eq('s**')
+
+      expect(
+        sample.obfuscate_value('k3', str)
+      ).to eq(str)
+    end
+  end
+end

data/spec/lib/logging/ruby_communicator_logger_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'logger'
+require 'English'
+
+RubyCommunicatorLogger = Ingenico::Connect::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, logLevel, errorLevel) }
+
+  def expected_msg(msg, thrown=false)
+    return msg unless thrown
+    msg + $RS + thrown.backtrace.join($RS)
+  end
+
+  after do
+    # delete the log files
+    logger.close
+    File.delete(filename)
+  end
+
+  context 'logging without error' do
+
+    let(:errorLevel) { Logger::WARN }
+    let(:msg) { 'Hello World' }
+
+    context "with level 'INFO'" do
+      let(:logLevel) { Logger::INFO }
+      let(:tag) { 'I' }
+
+      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(:logLevel) { 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(:errorLevel) { Logger::WARN }
+    let(:logLevel) { 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 ||= Ingenico::Connect::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.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/lib/logging/value_obfuscator_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+include Ingenico::Connect::SDK::Logging
+
+describe ValueObfuscator do
+  let(:fixed_length) { 10 }
+  let(:keep_start_count) { 20 }
+  let(:keep_end_count) { 30 }
+
+  it 'can be initialized correctly' do
+    sample = ValueObfuscator.send(:new, fixed_length,
+                                  keep_start_count, keep_end_count)
+    expect(sample.instance_variable_get(:@fixed_length)).to eq(10)
+    expect(sample.instance_variable_get(:@keep_start_count)).to eq(20)
+    expect(sample.instance_variable_get(:@keep_end_count)).to eq(30)
+  end
+
+  it 'has the correct class variable ALL' do
+    sample = ValueObfuscator.ALL
+    expect(sample.instance_variable_get(:@fixed_length)).to eq(0)
+    expect(sample.instance_variable_get(:@keep_start_count)).to eq(0)
+    expect(sample.instance_variable_get(:@keep_end_count)).to eq(0)
+  end
+
+  it 'can be initialized only with fixed_length' do
+    sample = ValueObfuscator.fixed_length(fixed_length)
+    expect(sample.instance_variable_get(:@fixed_length)).to eq(10)
+    expect(sample.instance_variable_get(:@keep_start_count)).to eq(0)
+    expect(sample.instance_variable_get(:@keep_end_count)).to eq(0)
+  end
+
+  it 'can be initialized only with keep_start_count' do
+    sample = ValueObfuscator.keep_start_count(keep_start_count)
+    expect(sample.instance_variable_get(:@fixed_length)).to eq(0)
+    expect(sample.instance_variable_get(:@keep_start_count)).to eq(20)
+    expect(sample.instance_variable_get(:@keep_end_count)).to eq(0)
+  end
+
+  it 'can be initialized only with keep_end_count' do
+    sample = ValueObfuscator.keep_end_count(keep_end_count)
+    expect(sample.instance_variable_get(:@fixed_length)).to eq(0)
+    expect(sample.instance_variable_get(:@keep_start_count)).to eq(0)
+    expect(sample.instance_variable_get(:@keep_end_count)).to eq(30)
+  end
+
+  context '.repeat_mask' do
+    it 'returns the correct mask' do
+      sample = ValueObfuscator.ALL
+      expect(sample.send(:repeat_mask, 5)).to eq('*' * 5)
+    end
+  end
+
+  context '.obfuscate_value' do
+    subject(:sample) { ValueObfuscator.send(:new, fixed_length,
+                                            keep_start_count, keep_end_count) }
+    let(:value) { 'str' }
+
+    it 'returns nil if value is nil' do
+      expect(sample.obfuscate_value(nil)).to be_nil
+    end
+
+    it 'returns empty string if value has length 0' do
+      expect(sample.obfuscate_value('')).to eq ('')
+    end
+
+    it 'calls repeak_mask(@fixed_length) if @fixed_length is not 0' do
+      expect(
+        sample.obfuscate_value('str')
+      ).to eq(sample.send(:repeat_mask, fixed_length))
+    end
+
+    it 'calls repeak_mask(value.length) if using ALL' do
+      expect(
+        ValueObfuscator.ALL.obfuscate_value(value)
+      ).to eq(sample.send(:repeat_mask, value.length))
+    end
+
+    context '.keep_start_count or .keep_end_count' do
+      subject(:sample) { ValueObfuscator.keep_start_count(5) }
+
+      it 'returns orignal value if value is too short' do
+        expect(
+          sample.obfuscate_value('str')
+        ).to eq('str')
+      end
+
+      it 'returns masked string if value is long enough' do
+        str = 'this str is long enough'
+        expect(
+          sample.obfuscate_value(str)
+        ).to eq('this ' + '*' * (str.length - 5))
+      end
+    end
+  end
+end

data/spec/lib/meta_data_provider_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'ingenico/connect/sdk/domain/metadata/shopping_cart_extension'
+require 'base64'
+
+describe 'MetaDataProvider' do
+
+  MetaDataProvider ||= Ingenico::Connect::SDK::MetaDataProvider
+  RequestHeader ||= Ingenico::Connect::SDK::RequestHeader
+
+  it 'can give meta_data_headers with a full shopping cart' do
+    shopping_cart_extension = Ingenico::Connect::SDK::Domain::Metadata::ShoppingCartExtension.new('Ingenico.creator', 'Extension', '1.0')
+    meta_data_provider = MetaDataProvider.new('Ingenico', shopping_cart_extension: shopping_cart_extension)
+
+    request_headers = meta_data_provider.meta_data_headers
+    expect(request_headers.length).to eq(1)
+    expect(request_headers.length).to eq(1)
+
+    # Server meta info is stored in json format and encoded using utf-8 and base64
+    server_meta_info_json = Base64.strict_decode64(request_headers[0].value).force_encoding('utf-8')
+    server_meta_info = Ingenico::Connect::SDK::DefaultImpl::DefaultMarshaller.INSTANCE.unmarshal(server_meta_info_json, MetaDataProvider::ServerMetaInfo)
+
+    expect(server_meta_info.platform_identifier).to eq(meta_data_provider.send(:get_platform_identifier))
+    expect(server_meta_info.sdk_identifier).to eq(meta_data_provider.send(:get_sdk_identifier))
+    expect(server_meta_info.sdk_creator).to eq('Ingenico')
+    expect(server_meta_info.shopping_cart_extension.creator).to eq(shopping_cart_extension.creator)
+    expect(server_meta_info.shopping_cart_extension.name).to eq(shopping_cart_extension.name)
+    expect(server_meta_info.shopping_cart_extension.version).to eq(shopping_cart_extension.version)
+  end
+
+  it 'provides a server_meta_info header when no additional headers are provided' do
+    meta_data_provider = MetaDataProvider.new('Ingenico')
+
+    request_headers = meta_data_provider.meta_data_headers
+    expect(request_headers.length).to eq(1)
+    expect(request_headers[0].name).to eq('X-GCS-ServerMetaInfo')
+    expect(request_headers[0].value).to_not be_nil
+
+    # Server meta info is stored in json format and encoded using utf-8 and base64
+    server_meta_info_json = Base64.strict_decode64(request_headers[0].value).force_encoding('utf-8')
+    server_meta_info = Ingenico::Connect::SDK::DefaultImpl::DefaultMarshaller.INSTANCE.unmarshal(server_meta_info_json, MetaDataProvider::ServerMetaInfo)
+
+    expect(server_meta_info.platform_identifier).to eq(meta_data_provider.send(:get_platform_identifier))
+    expect(server_meta_info.sdk_identifier).to eq(meta_data_provider.send(:get_sdk_identifier))
+    expect(server_meta_info.sdk_creator).to eq('Ingenico')
+  end
+
+  it 'provides a server_meta_info header and any additional headers provided' do
+    additional_headers = [RequestHeader.new('Header1', '&=$%'), RequestHeader.new('Header2', 'blah, blah'),
+                          RequestHeader.new('Header3', 'foo')]
+    meta_data_provider = MetaDataProvider.new('Ingenico', additional_request_headers: additional_headers)
+    request_headers = meta_data_provider.meta_data_headers
+
+    expect(request_headers.length).to eq(4)
+
+    i = 1
+    additional_headers.each do |header|
+      expect(request_headers[i]).to eq(header)
+      i += 1
+    end
+  end
+
+  it 'refuses headers marked as prohibited' do
+    MetaDataProvider.PROHIBITED_HEADERS.each do |name|
+      additional_headers = [RequestHeader.new('Header1', 'Value1'),
+                            RequestHeader.new(name, 'blood diamonds'),
+                            RequestHeader.new('Header3', 'Value3')]
+      expect{MetaDataProvider.new('Ingenico', additional_request_headers: additional_headers)}
+          .to raise_error{|error| expect(error.message).to include(name)}
+    end
+  end
+end