connect-sdk-ruby 2.47.1 → 3.0.0

data/spec/lib/logging/logging_util_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper'
-
-LoggingUtil = Ingenico::Connect::SDK::Logging::LoggingUtil
-
-def test_obfuscate_body_with_matches(original_resource, obfuscated_resource)
-  prefix = 'spec/fixtures/resources/logging/'
-  body = IO.read(prefix + original_resource)
-  expected = IO.read(prefix + obfuscated_resource)
-  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, original_value, expected_value)
-  expected_value == LoggingUtil.obfuscate_header(name, original_value)
-end
-
-def test_obfuscate_header_with_no_match(name, original_value)
-  original_value == LoggingUtil.obfuscate_header(name, original_value)
-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
-
-    it 'works with object' do
-      expect(
-        test_obfuscate_body_with_matches("bodyWithObjectOriginal.json",
-                                         "bodyWithObjectObfuscated.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

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-Obfuscator ||= Ingenico::Connect::SDK::Logging::Obfuscator
-ValueObfuscator ||= Ingenico::Connect::SDK::Logging::ValueObfuscator
-
-describe Obfuscator do
-  subject(:sample) { Obfuscator.new(obsfs, case_insensitive) }
-  context 'initialize' do
-    let(:obsfs) { { 'k1' => ValueObfuscator.fixed_length(5),
-                    'k2' => ValueObfuscator.keep_start_count(2) } }
-
-    context 'case sensitive' do
-      let(:case_insensitive) { 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(:case_insensitive) { 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(:case_insensitive) { 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/value_obfuscator_spec.rb

@@ -1,107 +0,0 @@
-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 'cannot be explicitly instantiated' do
-    expect{ValueObfuscator.new(fixed_length,
-                              keep_start_count,
-                              keep_end_count)
-    }.to raise_error(NoMethodError)
-
-    expect{ValueObfuscator.private_new(fixed_length,
-                              keep_start_count,
-                              keep_end_count)
-    }.to raise_error(NoMethodError)
-  end
-
-  it 'can be initialized correctly' do
-    sample = ValueObfuscator.send(:private_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(:private_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 repeat_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 repeat_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 original 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

@@ -1,93 +0,0 @@
-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', 'ExtensionId')
-    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)
-    expect(server_meta_info.shopping_cart_extension.extension_id).to eq(shopping_cart_extension.extension_id)
-  end
-
-  it 'can give meta_data_headers with a full shopping cart without an extension id' 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)
-    expect(server_meta_info.shopping_cart_extension.extension_id).to eq(shopping_cart_extension.extension_id)
-  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