invoca-utils 0.4.0 → 0.5.0

data/test/unit/guaranteed_utf8_string_test.rb

@@ -1,263 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/invoca/utils/guaranteed_utf8_string'
-require_relative '../test_helper'
-
-class GuaranteedUTF8StringTest < Minitest::Test
-  class HasNoTo_sMethod
-    undef :to_s
-  end
-
-  class BasicObjectWithKernelMethods
-  end
-
-  class ConvertibleToString
-    attr_reader :to_s
-
-    def initialize(string)
-      @to_s = string
-    end
-  end
-
-  context Invoca::Utils::GuaranteedUTF8String do
-    context '.normalize_string' do
-      should 'raise an error if called with an object with no to_s method' do
-        ex = assert_raises ArgumentError do
-          Invoca::Utils::GuaranteedUTF8String.normalize_string(HasNoTo_sMethod.new)
-        end
-
-        assert_match(/must be passed a string or an object with a non-Kernel \.to_s method but instead was GuaranteedUTF8StringTest::HasNoTo_sMethod/, ex.message)
-      end
-
-      should 'raise an error if called with a basic Ruby object' do
-        ex = assert_raises ArgumentError do
-          Invoca::Utils::GuaranteedUTF8String.normalize_string(BasicObjectWithKernelMethods.new)
-        end
-
-        assert_match(/must be passed a string or an object with a non-Kernel \.to_s method but instead was GuaranteedUTF8StringTest::BasicObjectWithKernelMethods/, ex.message)
-      end
-
-      should 'not mutate the original string' do
-        ascii_string = 'new string'.encode('ASCII')
-        encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(ascii_string)
-
-        assert_equal ascii_string, encoded_string
-        assert_equal Encoding::ASCII, ascii_string.encoding
-        assert_equal Encoding::UTF_8, encoded_string.encoding
-      end
-
-      should 'return UTF-8 encoded string' do
-        original_string = "this,is,a,valid,utf-8,csv,string\none,two,three,four,five,six,seven\n"
-
-        encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(original_string)
-
-        assert_equal original_string, encoded_string
-        assert_equal Encoding::UTF_8, encoded_string.encoding
-      end
-
-      context "normalize_utf16" do
-        UTF16_LE_BOM = "\xFF\xFE"
-        UTF16_BE_BOM = "\xFE\xFF"
-        UTF16_LE_TEST_STRING = (UTF16_LE_BOM + "v\x00a\x00l\x00i\x00d\x00,\x00u\x00t\x00f\x00-\x001\x006\x00\n\x00s\x00e\x00c\x00o\x00n\x00d\x00").force_encoding('BINARY').freeze
-        UTF16_BE_TEST_STRING = (UTF16_BE_BOM + "\x00v\x00a\x00l\x00i\x00d\x00,\x00u\x00t\x00f\x00-\x001\x006\x00\n\x00s\x00e\x00c\x00o\x00n\x00d").force_encoding('BINARY').freeze
-
-        should 'accept UTF-16LE in BINARY and return UTF-8 encoded string when true' do
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(UTF16_LE_TEST_STRING, normalize_utf16: true)
-
-          assert_equal "valid,utf-16\nsecond", encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-
-        should 'not check for UTF-16LE in BINARY and return UTF-8 encoded string when false' do
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(UTF16_LE_TEST_STRING, normalize_utf16: false)
-          expected = "ÿþv\u0000a\u0000l\u0000i\u0000d\u0000,\u0000u\u0000t\u0000f\u0000-\u00001\u00006\u0000\n\u0000s\u0000e\u0000c\u0000o\u0000n\u0000d\u0000"
-          assert_equal expected, encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-
-        should 'accept UTF-16BE in BINARY and return UTF-8 encoded string when true' do
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(UTF16_BE_TEST_STRING, normalize_utf16: true)
-
-          assert_equal "valid,utf-16\nsecond", encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-
-        should 'not check for UTF-16BE in BINARY and return UTF-8 encoded string when false' do
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(UTF16_BE_TEST_STRING, normalize_utf16: false)
-          expected = "þÿ\u0000v\u0000a\u0000l\u0000i\u0000d\u0000,\u0000u\u0000t\u0000f\u0000-\u00001\u00006\u0000\n\u0000s\u0000e\u0000c\u0000o\u0000n\u0000d"
-          assert_equal expected, encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-
-        context "containing embedded CP1252" do
-          should 'accept UTF-16LE in BINARY and return UTF-8 encoded string with "private" CP1252 when normalize_utf16: true, normalize_cp1252: false' do
-            original_string = (UTF16_LE_BOM + "\x91\x00s\x00m\x00a\x00r\x00t\x00 \x00q\x00u\x00o\x00t\x00e\x00s\x00\x92\x00\n\x00s\x00e\x00c\x00o\x00n\x00d\x00").force_encoding('BINARY')
-
-            encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(original_string, normalize_utf16: true, normalize_cp1252: false)
-
-            assert_equal "\u0091smart quotes\u0092\nsecond", encoded_string
-            assert_equal Encoding::UTF_8, encoded_string.encoding
-          end
-
-          should 'accept UTF-16LE in BINARY and return UTF-8 encoded string with normalized CP1252 when normalize_utf16: true, normalize_cp1252: true' do
-            original_string = (UTF16_LE_BOM + "\x91\x00s\x00m\x00a\x00r\x00t\x00 \x00q\x00u\x00o\x00t\x00e\x00s\x00\x92\x00\n\x00s\x00e\x00c\x00o\x00n\x00d\x00").force_encoding('BINARY')
-
-            encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(original_string, normalize_utf16: true)
-
-            assert_equal "‘smart quotes’\nsecond", encoded_string
-            assert_equal Encoding::UTF_8, encoded_string.encoding
-          end
-
-          should 'accept UTF-16BE in BINARY and return UTF-8 encoded string when normalize_utf16: true, normalize_cp1252: false' do
-            original_string = (UTF16_BE_BOM + "\x00\x91\x00s\x00m\x00a\x00r\x00t\x00 \x00q\x00u\x00o\x00t\x00e\x00s\x00\x92\x00\n\x00s\x00e\x00c\x00o\x00n\x00d").force_encoding('BINARY')
-
-            encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(original_string, normalize_utf16: true, normalize_cp1252: false)
-
-            assert_equal "\u0091smart quotes\u0092\nsecond", encoded_string
-            assert_equal Encoding::UTF_8, encoded_string.encoding
-          end
-
-          should 'accept UTF-16BE in BINARY and return UTF-8 encoded string when normalize_utf16: true, normalize_cp1252: true' do
-            original_string = (UTF16_BE_BOM + "\x00\x91\x00s\x00m\x00a\x00r\x00t\x00 \x00q\x00u\x00o\x00t\x00e\x00s\x00\x92\x00\n\x00s\x00e\x00c\x00o\x00n\x00d").force_encoding('BINARY')
-
-            encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(original_string, normalize_utf16: true, normalize_cp1252: true)
-
-            assert_equal "‘smart quotes’\nsecond", encoded_string
-            assert_equal Encoding::UTF_8, encoded_string.encoding
-          end
-        end
-      end
-
-      context 'normalize_cp1252' do
-        setup do
-          @string = "This,is,NOT,a,valid,utf-8,csv,string\r\none,two,three,four,\x81five,\x91smart quotes\x92,\x93suck!\x94\n"
-        end
-
-        should 'raise ArgumentError when false' do
-          assert_raises(ArgumentError, /xxyy/) do
-            Invoca::Utils::GuaranteedUTF8String.normalize_string(@string, normalize_cp1252: false)
-          end
-        end
-
-        should 'return UTF-8 encoded string after falling back to CP1252 encoding when true' do
-          expected_string = "This,is,NOT,a,valid,utf-8,csv,string\none,two,three,four,~five,‘smart quotes’,“suck!”\n"
-
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(@string)
-
-          assert_equal expected_string, encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-
-        should "encode all 255 UTF-8 characters, returning ~ when the character isn't mapped in CP1252" do
-          all_8_bit_characters = (1..255).map(&:chr).join
-
-          final_utf_8_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(all_8_bit_characters)
-          expected_string = "\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000A\u000B\u000C\u000A\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\u001B\u001C\u001D\u001E\u001F !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u007F€~‚ƒ„…†‡ˆ‰Š‹Œ~Ž~~‘’“”•–—˜™š›œ~žŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ"
-
-          assert_equal expected_string, final_utf_8_string
-        end
-      end
-
-      context 'normalize_newlines' do
-        setup do
-          @string = "This string\n\n\n has line feeds\ncarriage\r\r returns\rand Windows\r\n\r\n new line chars\r\nend of \n\r\r\r\nstring"
-        end
-
-        should 'return UTF-8 encoded string without normalized return chars when false' do
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(@string, normalize_newlines: false)
-
-          assert_equal @string, encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-
-        should 'return UTF-8 encoded string with normalized return chars when true' do
-          expected_string = "This string\n\n\n has line feeds\ncarriage\n\n returns\nand Windows\n\n new line chars\nend of \n\n\n\nstring"
-
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(@string, normalize_newlines: true)
-
-          assert_equal expected_string, encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-      end
-
-      context 'remove_utf8_bom' do
-        setup do
-          @original_string = "\xEF\xBB\xBFthis,is,a,valid,utf-8,csv,string\none,two,three,four,five,six,seven\n"
-        end
-
-        should 'return UTF-8 encoded string with BOM intact when false' do
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(@original_string, remove_utf8_bom: false)
-
-          assert_equal "\xEF\xBB\xBFthis,is,a,valid,utf-8,csv,string\none,two,three,four,five,six,seven\n", encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-
-        should 'return UTF-8 encoded string without BOM when true' do
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(@original_string, remove_utf8_bom: true)
-
-          assert_equal "this,is,a,valid,utf-8,csv,string\none,two,three,four,five,six,seven\n", encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-      end
-
-      context 'replace_unicode_beyond_ffff' do
-        setup do
-          @string = "This string has some ✓ valid UTF-8 but also some 😹 emoji \xf0\x9f\x98\xb9 that are > U+FFFF"
-        end
-
-        should "consider UTF-8 code points that take > 3 bytes (above U+FFFF) to be invalid (since MySQL can't store them unless column is declared mb4) and encode them as ~ when false" do
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(@string, replace_unicode_beyond_ffff: false)
-
-          assert_equal @string, encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-
-        should "consider UTF-8 code points that take > 3 bytes (above U+FFFF) to be invalid (since MySQL can't store them unless column is declared mb4) and encode them as ~ when true" do
-          expected_string = 'This string has some ✓ valid UTF-8 but also some ~ emoji ~ that are > U+FFFF'
-
-          encoded_string = Invoca::Utils::GuaranteedUTF8String.normalize_string(@string, replace_unicode_beyond_ffff: true)
-
-          assert_equal expected_string, encoded_string
-          assert_equal Encoding::UTF_8, encoded_string.encoding
-        end
-      end
-
-      context ".normalize_strings" do
-        should "walk json doc, replacing strings in: values, inside array elements, and hash keys and values" do
-          json_doc = {
-            '😹' => "\xE2\x9C\x93 laughing cat",
-            ['😹'] => ["\xE2", "\xf0\x9f\x98\xb9", { "newline" => "\r\n" }],
-            'cp1252' => "\x91smart quotes\x92"
-          }
-
-          normalized_json = Invoca::Utils::GuaranteedUTF8String.normalize_all_strings(json_doc,
-                                                                                      normalize_utf16:              true,
-                                                                                      normalize_cp1252:             true,
-                                                                                      normalize_newlines:           true,
-                                                                                      remove_utf8_bom:              true,
-                                                                                      replace_unicode_beyond_ffff:  true)
-
-          assert_equal({
-                         '~' => "✓ laughing cat",
-                         ['~'] => ["â", "~", { "newline" => "\n" }],
-                         'cp1252' => "‘smart quotes’"
-                       }, normalized_json)
-        end
-      end
-    end
-
-    context 'constructor' do
-      should 'call normalize_string with the default conversions' do
-        mock(Invoca::Utils::GuaranteedUTF8String).normalize_string('')
-
-        Invoca::Utils::GuaranteedUTF8String.new('').to_string
-      end
-
-      should 'do the same when using to_s alias' do
-        mock(Invoca::Utils::GuaranteedUTF8String).normalize_string('')
-
-        Invoca::Utils::GuaranteedUTF8String.new('').to_s
-      end
-    end
-  end
-end

data/test/unit/hash_test.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/invoca/utils/hash.rb'
-require_relative '../test_helper'
-
-class HashTest < Minitest::Test
-
-  context 'select_hash' do
-    should 'return a hash containing key/values identified by the block' do
-      assert_equal({ 1 => 2, 3 => 4 }, { 1 => 2, 3 => 4, 6 => 5 }.select_hash { |key, value| key < value })
-    end
-
-    should 'handle blocks that only check values' do
-      assert_equal({ 3 => 4, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 }.select_hash { |value| value != 2 })
-    end
-  end
-
-  context 'map_hash' do
-    should 'return a hash containing values updated by the block' do
-      assert_equal({ 1 => true, 3 => true, 6 => false }, { 1 => 2, 3 => 4, 6 => 5 }.map_hash { |key, value| key < value })
-    end
-
-    should 'handle blocks that only receive values' do
-      assert_equal({ 1 => 4, 3 => 8, 6 => 10 }, { 1 => 2, 3 => 4, 6 => 5 }.map_hash { |value| value * 2 })
-    end
-  end
-
-  context 'partition_hash' do
-    should 'return two hashes, the first contains the pairs with matching keys, the second contains the rest' do
-      assert_equal([{ 1 => 2, 3 => 4 }, { 6 => 5 }], { 1 => 2, 3 => 4, 6 => 5 }.partition_hash([1, 3]))
-    end
-
-    should 'return two hashes, the first contains the pairs with identified by the block, the second contains the rest' do
-      assert_equal([{ 1 => 2, 3 => 4 }, { 6 => 5 }], { 1 => 2, 3 => 4, 6 => 5 }.partition_hash { |key, value| key < value })
-    end
-
-    should 'handle no matches' do
-      assert_equal([{}, { 1 => 2, 3 => 4, 6 => 5 }], { 1 => 2, 3 => 4, 6 => 5 }.partition_hash([100]))
-    end
-
-    should 'handle all matches' do
-      assert_equal([{ 1 => 2, 3 => 4, 6 => 5 }, {}], { 1 => 2, 3 => 4, 6 => 5 }.partition_hash { |_key, _value| true })
-    end
-  end
-
-  context '- operator' do
-    should 'return a hash with pairs removed that match the keys in rhs array' do
-      assert_equal({ 3 => 4 }, { 1 => 2, 3 => 4, 6 => 5 } - [1, 6])
-    end
-
-    should 'handle empty rhs array' do
-      assert_equal({ 1 => 2, 3 => 4, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 } - [])
-    end
-
-    should 'handle no matches in rhs array' do
-      assert_equal({ 1 => 2, 3 => 4, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 } - [100, 600])
-    end
-
-    should 'handle all matches in rhs array' do
-      assert_equal({}, { 1 => 2, 3 => 4, 6 => 5 } - [1, 3, 6])
-    end
-  end
-
-  context '& operator' do
-    should 'return a hash with pairs removed that do NOT match the keys in rhs array' do
-      assert_equal({ 1 => 2, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 } & [1, 6])
-    end
-
-    should 'handle empty rhs array' do
-      assert_equal({}, { 1 => 2, 3 => 4, 6 => 5 } & [])
-    end
-
-    should 'handle no matches in rhs array' do
-      assert_equal({}, { 1 => 2, 3 => 4, 6 => 5 } & [100, 600])
-    end
-
-    should 'handle all matches in rhs array' do
-      assert_equal({ 1 => 2, 3 => 4, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 } & [1, 3, 6])
-    end
-  end
-end

data/test/unit/hash_with_indifferent_access_test.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-require_relative '../../lib/invoca/utils/hash_with_indifferent_access.rb'
-require_relative '../test_helper'
-
-class HashWithIndifferentAccessTest < Minitest::Test
-
-  context 'partition_hash' do
-    setup do
-      @hash_to_test = HashWithIndifferentAccess.new('one' => 2, :three => 4, 'six' => 5)
-    end
-
-    should 'return two hashes, the first contains the pairs with matching keys, the second contains the rest' do
-      assert_equal([{ 'one' => 2, 'three' => 4 }, { 'six' => 5 }], @hash_to_test.partition_hash(['one', 'three']))
-    end
-
-    should 'return two hashes, the first contains the pairs with identified by the block, the second contains the rest' do
-      assert_equal([{ 'one' => 2, 'three' => 4 }, { 'six' => 5 }], @hash_to_test.partition_hash { |key, _value| ['one', 'three'].include?(key) })
-    end
-
-    should 'handle no matches' do
-      assert_equal([{}, @hash_to_test], @hash_to_test.partition_hash([:not_found]))
-    end
-
-    should 'handle all matches' do
-      assert_equal([@hash_to_test, {}], @hash_to_test.partition_hash { |_key, _value| true })
-    end
-
-    should 'handle symbols for key matching' do
-      assert_equal([{ 'one' => 2, 'three' => 4 }, { 'six' => 5 }], @hash_to_test.partition_hash([:one, :three]))
-    end
-
-    should 'return HashWithIndifferentAccess objects' do
-      matched, unmatched = @hash_to_test.partition_hash([:one, :three])
-      assert(matched.is_a?(HashWithIndifferentAccess))
-      assert(unmatched.is_a?(HashWithIndifferentAccess))
-    end
-  end
-
-  context '- operator' do
-    setup do
-      @hash_to_test = HashWithIndifferentAccess.new('one' => 2, :three => 4, 'six' => 5)
-    end
-
-    should 'return a hash with pairs removed that match the keys in rhs array' do
-      assert_equal({ 'three' => 4 }, @hash_to_test - ['one', 'six'])
-    end
-
-    should 'handle empty rhs array' do
-      assert_equal(@hash_to_test, @hash_to_test - [])
-    end
-
-    should 'handle no matches in rhs array' do
-      assert_equal(@hash_to_test, @hash_to_test - ['100', '600'])
-    end
-
-    should 'handle all matches in rhs array' do
-      assert_equal({}, @hash_to_test - ['one', 'three', 'six'])
-    end
-
-    should 'handle symbols for key matching' do
-      assert_equal({ 'six' => 5 }, @hash_to_test - [:one, :three])
-    end
-
-    should 'return HashWithIndifferentAccess object' do
-      assert((@hash_to_test - [:one, :three]).is_a?(HashWithIndifferentAccess))
-    end
-  end
-
-  context '& operator' do
-    setup do
-      @hash_to_test = HashWithIndifferentAccess.new('one' => 2, :three => 4, 'six' => 5)
-    end
-
-    should 'return a hash with pairs removed that do NOT match the keys in rhs array' do
-      assert_equal({ 'one' => 2, 'six' => 5 }, @hash_to_test & ['one', 'six'])
-    end
-
-    should 'handle empty rhs array' do
-      assert_equal({}, @hash_to_test & [])
-    end
-
-    should 'handle no matches in rhs array' do
-      assert_equal({}, @hash_to_test & ['100', '600'])
-    end
-
-    should 'handle all matches in rhs array' do
-      assert_equal(@hash_to_test, @hash_to_test & ['one', 'three', 'six'])
-    end
-
-    should 'handle symbols for key matching' do
-      assert_equal({ 'one' => 2, 'three' => 4 }, @hash_to_test & [:one, :three])
-    end
-
-    should 'return HashWithIndifferentAccess object' do
-      assert((@hash_to_test & [:one, :three]).is_a?(HashWithIndifferentAccess))
-    end
-  end
-end

data/test/unit/map_compact_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../test_helper'
-
-class MapCompactTest < Minitest::Test
-  should "map_compact" do
-    assert_equal [1, 9], [1, 2, nil, 3, 4].map_compact { |item| item**2 if (nil == item ? nil : item.odd?) }
-  end
-
-  should "map_compact to empty if nothing matches" do
-    assert_equal [], {:a => 'aaa', :b => 'bbb'}.map_compact { |key, value| value if key == :c }
-  end
-
-  should "map_compact a hash" do
-    assert_equal ['bbb'], {:a => 'aaa', :b => 'bbb'}.map_compact { |key, value| value if key == :b }
-  end
-
-  should "map_compact empty collection" do
-    assert_equal [], [].map_compact { |item| true }
-  end
-
-  should "not map_compact false" do
-    assert_equal [false], [nil, false].map_compact { |a| a }
-  end
-end

data/test/unit/multi_sender_test.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/invoca/utils/multi_sender.rb'
-require_relative '../test_helper'
-
-class MultiSenderTest < Minitest::Test
-  # create enumerable class for testing
-  class LinkedList
-    include Enumerable
-
-    def initialize(head, tail = nil)
-      @head, @tail = head, tail
-    end
-
-    def <<(item)
-      LinkedList.new(item, self)
-    end
-
-    def inspect
-      [@head, @tail].inspect
-    end
-
-    def each(&block)
-      if block_given?
-        block.call(@head)
-        @tail&.each(&block)
-      else
-        to_enum(:each)
-      end
-    end
-  end
-
-  context 'MultiSender' do
-    context 'with custom Enumerable' do
-      setup do
-        linked_list = LinkedList.new('some') << 'short' << 'words'
-        @multi_sender = Invoca::Utils::MultiSender.new(linked_list, :map)
-      end
-
-      should 'call the same method on each item in an Enumerable and return the results as an array' do
-        assert_equal([5, 5, 4], @multi_sender.length)
-      end
-
-      should 'handle methods with arguments' do
-        assert_equal(['or', 'ho', 'om'], @multi_sender.slice(1, 2))
-      end
-    end
-
-    context 'with built-in Array' do
-      should 'call the same method on each item in an Array and return the results as an array' do
-        multi_sender = Invoca::Utils::MultiSender.new(['some', 'short', 'words'], :map)
-        assert_equal([4, 5, 5], multi_sender.length)
-      end
-    end
-  end
-end

data/test/unit/time_calculations_test.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../test_helper'
-
-class TimeCalculationsTest < Minitest::Test
-  context "beginning_of_hour" do
-    Time.zone = 'Pacific Time (US & Canada)'
-    [
-      Time.now,
-      Time.zone.now,
-      Time.local(2009),
-      Time.local(2009,3,4,5),
-      Time.local(2001,12,31,23,59),
-      Time.local(1970,1,1)
-    ].each_with_index do |time, index|
-      should "give back a time with no minutes, seconds, or msec: #{time} (#{index})" do
-        t = time.beginning_of_hour
-        assert_equal t.year,  time.year
-        assert_equal t.month, time.month
-        assert_equal t.day,   time.day
-        assert_equal t.hour,  time.hour
-        assert_equal 0, t.min
-        assert_equal 0, t.sec
-        assert_equal 0, t.usec
-      end
-    end
-  end
-
-  context "end_of_day_whole_sec" do
-    should "return the end of day with whole_sec" do
-      t = Time.now
-      end_of_day = t.end_of_day
-      end_whole_sec = t.end_of_day_whole_sec
-      assert_equal 0.0, end_whole_sec.usec
-      assert_equal end_of_day.to_i, end_whole_sec.to_i
-      assert_equal end_of_day.sec, end_whole_sec.sec
-    end
-  end
-end