peddler 2.1.1 → 2.3.0

data/test/unit/peddler/test_flat_file_parser.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'peddler/flat_file_parser'
-
-class TestPeddlerFlatFileParser < MiniTest::Test
-  def test_parsing_data
-    body = build_body("Feed Processing Summary:\n\tNumber of records processed\t\t11006\n\tNumber of records successful\t\t11006\n\noriginal-record-number\tsku\terror-code\terror-type\terror-message\n1822\t85da472e-ba6c-11e3-95af-002590a74356\t5000\tWarning\tThe update for Sku '85da472e-ba6c-11e3-95af-002590a74356' was skipped because it is identical to the update in feed '9518995390'.\n",
-                      encoding: Encoding::ASCII_8BIT)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), 'ISO-8859-1')
-    assert_kind_of CSV::Table, parser.parse
-  end
-
-  def test_parsing_data_a_line_at_a_time
-    body = build_body("Feed Processing Summary:\n\tNumber of records processed\t\t11006\n\tNumber of records successful\t\t11006\n\noriginal-record-number\tsku\terror-code\terror-type\terror-message\n1822\t85da472e-ba6c-11e3-95af-002590a74356\t5000\tWarning\tThe update for Sku '85da472e-ba6c-11e3-95af-002590a74356' was skipped because it is identical to the update in feed '9518995390'.\n",
-                      encoding: Encoding::ASCII_8BIT)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), 'ISO-8859-1')
-    counter = 0
-    parser.parse { counter += 1 }
-    assert counter.positive?
-  end
-
-  def test_the_work_around_empty_rows
-    body = build_body("Feed Processing Summary:\n\tNumber of records processed\t\t2\n\tNumber of records successful\t\t2\n\nfoo\tbar\n1\ta\n\n2\tb\n",
-                      encoding: Encoding::ASCII_8BIT)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), 'ISO-8859-1')
-    assert_equal 3, parser.parse.count
-  end
-
-  def test_summary
-    body = build_body("Feed Processing Summary:\n\tNumber of records processed\t\t11006\n\tNumber of records successful\t\t11006\n\noriginal-record-number\tsku\terror-code\terror-type\terror-message\n1822\t85da472e-ba6c-11e3-95af-002590a74356\t5000\tWarning\tThe update for Sku '85da472e-ba6c-11e3-95af-002590a74356' was skipped because it is identical to the update in feed '9518995390'.\n",
-                      encoding: Encoding::ASCII_8BIT)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), 'ISO-8859-1')
-    refute_empty parser.records_count
-  end
-
-  def test_summary_of_non_english_reports
-    body = build_body("Riepilogo elaborazione feed:\n\tNumero record elaborati\t\t1\n\tNumero record elaborati con successo\t\t1\n\n",
-                      encoding: 'Cp1252')
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), 'ISO-8859-1')
-    refute_empty parser.records_count
-  end
-
-  def test_validates
-    body = build_body("Feed Processing Summary:\n\tNumber of records processed\t\t11006\n\tNumber of records successful\t\t11006\n\noriginal-record-number\tsku\terror-code\terror-type\terror-message\n1822\t85da472e-ba6c-11e3-95af-002590a74356\t5000\tWarning\tThe update for Sku '85da472e-ba6c-11e3-95af-002590a74356' was skipped because it is identical to the update in feed '9518995390'.\n",
-                      encoding: Encoding::ASCII_8BIT)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), 'ISO-8859-1')
-    assert parser.valid?
-  end
-
-  def test_handling_reports_without_a_summary
-    response = OpenStruct.new(body: "Foo\nBar\n")
-    parser = Peddler::FlatFileParser.new(response, 'ISO-8859-1')
-    refute_empty parser.content
-  end
-
-  def test_encoding_if_passed_in_header
-    body = build_body("Foo\nfür\n", encoding: Encoding::UTF_8)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body,
-                                                             charset: 'UTF-8'),
-                                         Encoding::CP1252)
-    assert_equal 'für', parser.parse[0]['Foo']
-  end
-
-  def test_handling_japanese_flat_files
-    body = build_body("Foo\nこんにちは\n", encoding: Encoding::SHIFT_JIS)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), Encoding::WINDOWS_31J)
-    assert_equal 'こんにちは', parser.parse[0]['Foo']
-  end
-
-  def test_handling_japanese_curly_braces
-    body = build_body("Foo\n〝\n", encoding: Encoding::WINDOWS_31J)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), Encoding::WINDOWS_31J)
-    assert_equal '〝', parser.parse[0]['Foo']
-  end
-
-  def test_handling_latin_1_flat_files
-    body = build_body("Foo\n™\n", encoding: 'Cp1252')
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), Encoding::CP1252)
-    assert_equal '™', parser.parse['Foo'][0]
-  end
-
-  def test_handling_undefined_characters
-    body = +"Foo\n\xFF\n"
-    body.force_encoding(Encoding::ASCII_8BIT)
-    parser = Peddler::FlatFileParser.new(build_mock_response(body), Encoding::ASCII_8BIT)
-    assert_equal '�', parser.parse['Foo'][0]
-  end
-
-  def test_handling_utf8_flat_files
-    body = "Foo\nfür\n"
-    parser = Peddler::FlatFileParser.new(build_mock_response(body, ascii: false), Encoding::CP1252)
-    assert_equal 'für', parser.parse['Foo'][0]
-  end
-
-  private
-
-  def build_body(str, encoding:)
-    str.dup.encode(encoding)
-  end
-
-  def build_mock_response(body, ascii: true, charset: nil)
-    body.force_encoding(Encoding::ASCII_8BIT) if ascii
-    headers = {
-      'Content-MD5' => Digest::MD5.base64digest(body)
-    }
-    headers['Content-Type'] = "text/plain;charset=#{charset}" if charset
-
-    OpenStruct.new(body: body, headers: headers)
-  end
-end

data/test/unit/peddler/test_headers.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'peddler/headers'
-
-class TestPeddlerHeaders < MiniTest::Test
-  include ::Peddler::Headers
-
-  attr_reader :headers
-
-  def setup
-    @headers = {
-      'Content-Length' => '100',
-      'Content-MD5' => 'rkkx1Xv/k56/onrN0m7E/Q==',
-      'Content-Type' => 'text/plain;charset=UTF-8',
-      'x-mws-quota-max' => '200.0',
-      'x-mws-quota-remaining' => '200.0',
-      'x-mws-quota-resetsOn' => '2017-01-30T00:03:00.000Z',
-      'x-mws-request-id' => '123',
-      'x-mws-timestamp' => '2017-01-29T23:55:25.356Z',
-      'x-mws-response-context' => 'foo'
-    }
-  end
-
-  def test_content_length
-    assert_kind_of Integer, content_length
-  end
-
-  def test_content_md5
-    assert content_md5
-  end
-
-  def test_content_media_type
-    assert content_media_type
-  end
-
-  def test_content_type
-    assert content_type
-  end
-
-  def test_content_subtype
-    assert content_subtype
-  end
-
-  def test_content_charset
-    assert_kind_of Encoding, content_charset
-  end
-
-  def test_no_content_length
-    @headers.delete('Content-Length')
-    assert_nil content_length
-  end
-
-  def test_no_content_type
-    @headers.delete('Content-Type')
-    assert_nil content_media_type
-    assert_nil content_type
-    assert_nil content_subtype
-    assert_nil content_charset
-  end
-
-  def test_no_content_charset
-    @headers['Content-Type'] = 'text/xml'
-    assert content_media_type
-    assert content_type
-    assert content_subtype
-    assert_nil content_charset
-  end
-
-  def test_mws_quota_max
-    assert_kind_of Integer, mws_quota_max
-  end
-
-  def test_mws_quota_remaining
-    assert_kind_of Integer, mws_quota_remaining
-  end
-
-  def test_mws_quota_resets_on
-    assert_kind_of Time, mws_quota_resets_on
-  end
-
-  def test_request_id
-    assert mws_request_id
-  end
-
-  def test_timestamp
-    assert_kind_of Time, mws_timestamp
-  end
-
-  def test_response_context
-    assert mws_response_context
-  end
-
-  def test_handling_no_quota
-    @headers = {}
-    assert_nil mws_quota_max
-    assert_nil mws_quota_remaining
-    assert_nil mws_quota_resets_on
-    assert_nil mws_request_id
-    assert_nil mws_timestamp
-    assert_nil mws_response_context
-  end
-end

data/test/unit/peddler/test_marketplace.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'peddler/marketplace'
-
-class TestPeddlerMarketplace < MiniTest::Test
-  def setup
-    @marketplace = Peddler::Marketplace.find('ATVPDKIKX0DER')
-  end
-
-  def test_country_code
-    assert @marketplace.country_code
-  end
-
-  def test_host
-    assert @marketplace.host
-  end
-
-  def test_encoding
-    assert @marketplace.encoding
-  end
-
-  def test_guard_against_missing_country_code
-    error = assert_raises ArgumentError do
-      Peddler::Marketplace.find(nil)
-    end
-    assert_equal 'missing marketplace', error.message
-  end
-
-  def test_guard_against_invalid_country_code
-    error = assert_raises ArgumentError do
-      Peddler::Marketplace.find('FOO')
-    end
-    assert_equal '"FOO" is not a valid marketplace', error.message
-  end
-
-  class TestFindByCountryCode < TestPeddlerMarketplace
-    def setup
-      @marketplace = Peddler::Marketplace.find('US')
-    end
-
-    def test_translation_of_uk_to_gb
-      marketplace = Peddler::Marketplace.find('UK')
-      assert_equal 'GB', marketplace.country_code
-    end
-  end
-end

data/test/unit/peddler/test_operation.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'peddler/operation'
-
-class TestPeddlerOperation < MiniTest::Test
-  def setup
-    @operation = Peddler::Operation.new('Foo')
-  end
-
-  def test_that_it_converts_key_to_structured_list
-    @operation.store('FooStatus', [1, 2])
-    @operation.structure!('FooStatus', 'Foo')
-    refute @operation.key?('FooStatus')
-    assert_equal 1, @operation['FooStatus.Foo.1']
-    assert_equal 2, @operation['FooStatus.Foo.2']
-  end
-
-  def test_that_it_converts_nested_keys_to_structured_list
-    @operation.store('Foo.1.Status', [{ 'Baz' => 1 }])
-    @operation.store('Foo.2.Status', [{ 'Baz' => 2 }])
-    @operation.structure!('Status', 'Bar')
-    refute @operation.key?('Foo.1.Status')
-    refute @operation.key?('Foo.2.Status')
-    assert_equal 1, @operation['Foo.1.Status.Bar.1.Baz']
-    assert_equal 2, @operation['Foo.2.Status.Bar.1.Baz']
-  end
-
-  def test_that_store_camelizes_symbol_key
-    @operation.store(:foo_bar, 'baz')
-    assert @operation.key?('FooBar')
-    refute @operation.key?(:foo_bar)
-  end
-
-  def test_that_store_wont_camelize_string_key
-    @operation.store('foo_bar', 'baz')
-    assert @operation.key?('foo_bar')
-    refute @operation.key?('FooBar')
-  end
-
-  def test_that_store_wont_camelize_symbol_key_with_capital_letter
-    @operation.store('MarketplaceId'.to_sym, '1')
-    assert @operation.key?('MarketplaceId')
-  end
-
-  def test_that_store_upcases_sku
-    @operation.store(:seller_sku, 'foo')
-    assert @operation.key?('SellerSKU')
-    refute @operation.key?(:seller_sku)
-  end
-
-  def test_that_store_upcases_cod
-    @operation.store(:include_cod_fulfillment_preview, 'foo')
-    assert @operation.key?('IncludeCODFulfillmentPreview')
-    refute @operation.key?(:include_cod_fulfillment_preview)
-  end
-
-  def test_that_store_timestamps_time_values
-    ts = Minitest::Mock.new
-    ts.expect(:iso8601, 'foo')
-    @operation.store('time', ts)
-
-    assert_equal 'foo', @operation.fetch('time')
-  end
-
-  def test_stringifying_hash_values
-    @operation.store('Foo', bar: 1)
-    assert_equal 1, @operation.fetch('Foo.Bar')
-    refute @operation.key?('Foo')
-  end
-
-  def test_stringifying_nested_hash_values
-    @operation.store('Foo', bar: { baz: 1 })
-    assert_equal 1, @operation.fetch('Foo.Bar.Baz')
-    refute @operation.key?('Foo')
-  end
-
-  def test_stringifying_struct_values
-    @operation.store('Foo', Struct.new(:bar, :baz).new(1, 2))
-    assert_equal 1, @operation.fetch('Foo.Bar')
-    assert_equal 2, @operation.fetch('Foo.Baz')
-  end
-
-  def test_that_update_returns_delegator
-    assert_kind_of Peddler::Operation, @operation.add(foo: 'bar')
-  end
-end

data/test/unit/peddler/test_parser.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'peddler/parser'
-
-class TestPeddlerParser < MiniTest::Test
-  def assert_parser(klass, *content_types, body: '')
-    content_types.each do |content_type|
-      res = OpenStruct.new(
-        headers: { 'Content-Type' => content_type },
-        body: body
-      )
-      parser = Peddler::Parser.new(res, 'Cp1252')
-
-      assert_kind_of klass, parser
-    end
-  end
-
-  def test_parsing_xml
-    assert_parser Peddler::XMLParser,
-                  'text/xml',
-                  'text/xml; charset=UTF-8'
-  end
-
-  def test_parsing_incorrect_content_type
-    assert_parser Peddler::XMLParser,
-                  'xml; charset=UTF-8',
-                  body: '<?xml version="1.0"?><GetLowestOfferListingsForASINResponse>...'
-  end
-
-  def test_parsing_flat_files
-    assert_parser Peddler::FlatFileParser,
-                  'text/plain',
-                  'application/octet-stream'
-  end
-end

data/test/unit/peddler/test_structured_list.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'peddler/structured_list'
-
-class TestPeddlerStructuredList < MiniTest::Test
-  def setup
-    @list = Peddler::StructuredList.new('OrderStatus', 'Status')
-  end
-
-  def test_building_a_structured_list_for_a_single_value
-    exp = { 'OrderStatus.Status.1' => 'foo' }
-    assert_equal exp, @list.build('foo')
-  end
-
-  def test_building_a_structured_list_for_an_array_of_values
-    exp = { 'OrderStatus.Status.1' => 'foo', 'OrderStatus.Status.2' => 'bar' }
-    assert_equal exp, @list.build(%w[foo bar])
-  end
-
-  def test_flattening_nested_arrays_of_values
-    exp = { 'OrderStatus.Status.1' => 'foo', 'OrderStatus.Status.2' => 'bar' }
-    assert_equal exp, @list.build([%w[foo bar]])
-  end
-
-  def test_handling_single_key
-    list = Peddler::StructuredList.new('Foo')
-    exp = { 'Foo.1' => 'bar' }
-
-    assert_equal exp, list.build('bar')
-  end
-
-  def test_handling_more_than_two_keys
-    list = Peddler::StructuredList.new('QueryList', 'Query', '1', 'FilterOptions', 'FilterOption')
-    exp = { 'QueryList.Query.1.FilterOptions.FilterOption.1' => 'foo' }
-
-    assert_equal exp, list.build('foo')
-  end
-end

data/test/unit/peddler/test_vcr_matcher.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'helper'
-require 'null_client'
-require 'peddler/vcr_matcher'
-require 'recorder'
-
-class TestPeddlerVCRMatcher < MiniTest::Test
-  include Recorder
-  ::Peddler::VCRMatcher.ignore_seller!
-
-  def setup
-    VCR.insert_cassette(test_name)
-  end
-
-  def test_matching_recorded_post_without_body
-    client.run
-  end
-
-  def test_wont_match_unrecorded_post_without_body
-    client.operation.add(foo: 'bar')
-    assert_raises(VCR::Errors::UnhandledHTTPRequestError) do
-      client.run
-    end
-  end
-
-  def test_matching_recorded_post_with_body
-    client.body = 'content'
-    client.run
-  end
-
-  def test_that_it_wont_match_unrecorded_post_with_different_query_and_same_body
-    client.operation.add(foo: 'bar')
-    client.body = 'content'
-    assert_raises(VCR::Errors::UnhandledHTTPRequestError) do
-      client.run
-    end
-  end
-
-  def test_that_it_wont_match_unrecorded_post_with_same_query_and_different_body
-    client.body = 'other content'
-    assert_raises(VCR::Errors::UnhandledHTTPRequestError) do
-      client.run
-    end
-  end
-
-  def client
-    @client ||= begin
-      client = Class.new(Null::Client).new
-      client.configure_with_mock_data!
-      client.operation('Action')
-      client
-    end
-  end
-end