paynow_sdk 0.1.7 → 0.1.8

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.6/vendor/cache/ruby/2.7.0/gems/minitest-5.14.1/lib/minitest/expectations.rb

@@ -1,303 +0,0 @@
-##
-# It's where you hide your "assertions".
-#
-# Please note, because of the way that expectations are implemented,
-# all expectations (eg must_equal) are dependent upon a thread local
-# variable +:current_spec+. If your specs rely on mixing threads into
-# the specs themselves, you're better off using assertions or the new
-# _(value) wrapper. For example:
-#
-#     it "should still work in threads" do
-#       my_threaded_thingy do
-#         (1+1).must_equal 2                  # bad
-#         assert_equal 2, 1+1                 # good
-#         _(1 + 1).must_equal 2               # good
-#         value(1 + 1).must_equal 2           # good, also #expect
-#         _ { 1 + "1" }.must_raise TypeError  # good
-#       end
-#     end
-
-module Minitest::Expectations
-
-  ##
-  # See Minitest::Assertions#assert_empty.
-  #
-  #    _(collection).must_be_empty
-  #
-  # :method: must_be_empty
-
-  infect_an_assertion :assert_empty, :must_be_empty, :unary
-
-  ##
-  # See Minitest::Assertions#assert_equal
-  #
-  #    _(a).must_equal b
-  #
-  # :method: must_equal
-
-  infect_an_assertion :assert_equal, :must_equal
-
-  ##
-  # See Minitest::Assertions#assert_in_delta
-  #
-  #    _(n).must_be_close_to m [, delta]
-  #
-  # :method: must_be_close_to
-
-  infect_an_assertion :assert_in_delta, :must_be_close_to
-
-  infect_an_assertion :assert_in_delta, :must_be_within_delta # :nodoc:
-
-  ##
-  # See Minitest::Assertions#assert_in_epsilon
-  #
-  #    _(n).must_be_within_epsilon m [, epsilon]
-  #
-  # :method: must_be_within_epsilon
-
-  infect_an_assertion :assert_in_epsilon, :must_be_within_epsilon
-
-  ##
-  # See Minitest::Assertions#assert_includes
-  #
-  #    _(collection).must_include obj
-  #
-  # :method: must_include
-
-  infect_an_assertion :assert_includes, :must_include, :reverse
-
-  ##
-  # See Minitest::Assertions#assert_instance_of
-  #
-  #    _(obj).must_be_instance_of klass
-  #
-  # :method: must_be_instance_of
-
-  infect_an_assertion :assert_instance_of, :must_be_instance_of
-
-  ##
-  # See Minitest::Assertions#assert_kind_of
-  #
-  #    _(obj).must_be_kind_of mod
-  #
-  # :method: must_be_kind_of
-
-  infect_an_assertion :assert_kind_of, :must_be_kind_of
-
-  ##
-  # See Minitest::Assertions#assert_match
-  #
-  #    _(a).must_match b
-  #
-  # :method: must_match
-
-  infect_an_assertion :assert_match, :must_match
-
-  ##
-  # See Minitest::Assertions#assert_nil
-  #
-  #    _(obj).must_be_nil
-  #
-  # :method: must_be_nil
-
-  infect_an_assertion :assert_nil, :must_be_nil, :unary
-
-  ##
-  # See Minitest::Assertions#assert_operator
-  #
-  #    _(n).must_be :<=, 42
-  #
-  # This can also do predicates:
-  #
-  #    _(str).must_be :empty?
-  #
-  # :method: must_be
-
-  infect_an_assertion :assert_operator, :must_be, :reverse
-
-  ##
-  # See Minitest::Assertions#assert_output
-  #
-  #    _ { ... }.must_output out_or_nil [, err]
-  #
-  # :method: must_output
-
-  infect_an_assertion :assert_output, :must_output, :block
-
-  ##
-  # See Minitest::Assertions#assert_raises
-  #
-  #    _ { ... }.must_raise exception
-  #
-  # :method: must_raise
-
-  infect_an_assertion :assert_raises, :must_raise, :block
-
-  ##
-  # See Minitest::Assertions#assert_respond_to
-  #
-  #    _(obj).must_respond_to msg
-  #
-  # :method: must_respond_to
-
-  infect_an_assertion :assert_respond_to, :must_respond_to, :reverse
-
-  ##
-  # See Minitest::Assertions#assert_same
-  #
-  #    _(a).must_be_same_as b
-  #
-  # :method: must_be_same_as
-
-  infect_an_assertion :assert_same, :must_be_same_as
-
-  ##
-  # See Minitest::Assertions#assert_silent
-  #
-  #    _ { ... }.must_be_silent
-  #
-  # :method: must_be_silent
-
-  infect_an_assertion :assert_silent, :must_be_silent, :block
-
-  ##
-  # See Minitest::Assertions#assert_throws
-  #
-  #    _ { ... }.must_throw sym
-  #
-  # :method: must_throw
-
-  infect_an_assertion :assert_throws, :must_throw, :block
-
-  ##
-  # See Minitest::Assertions#assert_path_exists
-  #
-  #   _(some_path).path_must_exist
-  #
-  # :method: path_must_exist
-
-  infect_an_assertion :assert_path_exists, :path_must_exist, :unary
-
-  ##
-  # See Minitest::Assertions#refute_path_exists
-  #
-  #   _(some_path).path_wont_exist
-  #
-  # :method: path_wont_exist
-
-  infect_an_assertion :refute_path_exists, :path_wont_exist, :unary
-
-  ##
-  # See Minitest::Assertions#refute_empty
-  #
-  #    _(collection).wont_be_empty
-  #
-  # :method: wont_be_empty
-
-  infect_an_assertion :refute_empty, :wont_be_empty, :unary
-
-  ##
-  # See Minitest::Assertions#refute_equal
-  #
-  #    _(a).wont_equal b
-  #
-  # :method: wont_equal
-
-  infect_an_assertion :refute_equal, :wont_equal
-
-  ##
-  # See Minitest::Assertions#refute_in_delta
-  #
-  #    _(n).wont_be_close_to m [, delta]
-  #
-  # :method: wont_be_close_to
-
-  infect_an_assertion :refute_in_delta, :wont_be_close_to
-
-  infect_an_assertion :refute_in_delta, :wont_be_within_delta # :nodoc:
-
-  ##
-  # See Minitest::Assertions#refute_in_epsilon
-  #
-  #    _(n).wont_be_within_epsilon m [, epsilon]
-  #
-  # :method: wont_be_within_epsilon
-
-  infect_an_assertion :refute_in_epsilon, :wont_be_within_epsilon
-
-  ##
-  # See Minitest::Assertions#refute_includes
-  #
-  #    _(collection).wont_include obj
-  #
-  # :method: wont_include
-
-  infect_an_assertion :refute_includes, :wont_include, :reverse
-
-  ##
-  # See Minitest::Assertions#refute_instance_of
-  #
-  #    _(obj).wont_be_instance_of klass
-  #
-  # :method: wont_be_instance_of
-
-  infect_an_assertion :refute_instance_of, :wont_be_instance_of
-
-  ##
-  # See Minitest::Assertions#refute_kind_of
-  #
-  #    _(obj).wont_be_kind_of mod
-  #
-  # :method: wont_be_kind_of
-
-  infect_an_assertion :refute_kind_of, :wont_be_kind_of
-
-  ##
-  # See Minitest::Assertions#refute_match
-  #
-  #    _(a).wont_match b
-  #
-  # :method: wont_match
-
-  infect_an_assertion :refute_match, :wont_match
-
-  ##
-  # See Minitest::Assertions#refute_nil
-  #
-  #    _(obj).wont_be_nil
-  #
-  # :method: wont_be_nil
-
-  infect_an_assertion :refute_nil, :wont_be_nil, :unary
-
-  ##
-  # See Minitest::Assertions#refute_operator
-  #
-  #    _(n).wont_be :<=, 42
-  #
-  # This can also do predicates:
-  #
-  #    str.wont_be :empty?
-  #
-  # :method: wont_be
-
-  infect_an_assertion :refute_operator, :wont_be, :reverse
-
-  ##
-  # See Minitest::Assertions#refute_respond_to
-  #
-  #    _(obj).wont_respond_to msg
-  #
-  # :method: wont_respond_to
-
-  infect_an_assertion :refute_respond_to, :wont_respond_to, :reverse
-
-  ##
-  # See Minitest::Assertions#refute_same
-  #
-  #    _(a).wont_be_same_as b
-  #
-  # :method: wont_be_same_as
-
-  infect_an_assertion :refute_same, :wont_be_same_as
-end

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.6/vendor/cache/ruby/2.7.0/gems/minitest-5.14.1/lib/minitest/hell.rb

@@ -1,11 +0,0 @@
-require "minitest/parallel"
-
-class Minitest::Test
-  parallelize_me!
-end
-
-begin
-  require "minitest/proveit"
-rescue LoadError
-  warn "NOTE: `gem install minitest-proveit` for even more hellish tests"
-end

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.6/vendor/cache/ruby/2.7.0/gems/minitest-5.14.1/lib/minitest/mock.rb

@@ -1,240 +0,0 @@
-class MockExpectationError < StandardError; end # :nodoc:
-
-module Minitest # :nodoc:
-
-  ##
-  # A simple and clean mock object framework.
-  #
-  # All mock objects are an instance of Mock
-
-  class Mock
-    alias :__respond_to? :respond_to?
-
-    overridden_methods = %w[
-      ===
-      class
-      inspect
-      instance_eval
-      instance_variables
-      object_id
-      public_send
-      respond_to_missing?
-      send
-      to_s
-    ]
-
-    instance_methods.each do |m|
-      undef_method m unless overridden_methods.include?(m.to_s) || m =~ /^__/
-    end
-
-    overridden_methods.map(&:to_sym).each do |method_id|
-      define_method method_id do |*args, &b|
-        if @expected_calls.key? method_id then
-          method_missing(method_id, *args, &b)
-        else
-          super(*args, &b)
-        end
-      end
-    end
-
-    def initialize delegator = nil # :nodoc:
-      @delegator = delegator
-      @expected_calls = Hash.new { |calls, name| calls[name] = [] }
-      @actual_calls   = Hash.new { |calls, name| calls[name] = [] }
-    end
-
-    ##
-    # Expect that method +name+ is called, optionally with +args+ or a
-    # +blk+, and returns +retval+.
-    #
-    #   @mock.expect(:meaning_of_life, 42)
-    #   @mock.meaning_of_life # => 42
-    #
-    #   @mock.expect(:do_something_with, true, [some_obj, true])
-    #   @mock.do_something_with(some_obj, true) # => true
-    #
-    #   @mock.expect(:do_something_else, true) do |a1, a2|
-    #     a1 == "buggs" && a2 == :bunny
-    #   end
-    #
-    # +args+ is compared to the expected args using case equality (ie, the
-    # '===' operator), allowing for less specific expectations.
-    #
-    #   @mock.expect(:uses_any_string, true, [String])
-    #   @mock.uses_any_string("foo") # => true
-    #   @mock.verify  # => true
-    #
-    #   @mock.expect(:uses_one_string, true, ["foo"])
-    #   @mock.uses_one_string("bar") # => raises MockExpectationError
-    #
-    # If a method will be called multiple times, specify a new expect for each one.
-    # They will be used in the order you define them.
-    #
-    #   @mock.expect(:ordinal_increment, 'first')
-    #   @mock.expect(:ordinal_increment, 'second')
-    #
-    #   @mock.ordinal_increment # => 'first'
-    #   @mock.ordinal_increment # => 'second'
-    #   @mock.ordinal_increment # => raises MockExpectationError "No more expects available for :ordinal_increment"
-    #
-
-    def expect name, retval, args = [], &blk
-      name = name.to_sym
-
-      if block_given?
-        raise ArgumentError, "args ignored when block given" unless args.empty?
-        @expected_calls[name] << { :retval => retval, :block => blk }
-      else
-        raise ArgumentError, "args must be an array" unless Array === args
-        @expected_calls[name] << { :retval => retval, :args => args }
-      end
-      self
-    end
-
-    def __call name, data # :nodoc:
-      case data
-      when Hash then
-        "#{name}(#{data[:args].inspect[1..-2]}) => #{data[:retval].inspect}"
-      else
-        data.map { |d| __call name, d }.join ", "
-      end
-    end
-
-    ##
-    # Verify that all methods were called as expected. Raises
-    # +MockExpectationError+ if the mock object was not called as
-    # expected.
-
-    def verify
-      @expected_calls.each do |name, expected|
-        actual = @actual_calls.fetch(name, nil)
-        raise MockExpectationError, "expected #{__call name, expected[0]}" unless actual
-        raise MockExpectationError, "expected #{__call name, expected[actual.size]}, got [#{__call name, actual}]" if
-          actual.size < expected.size
-      end
-      true
-    end
-
-    def method_missing sym, *args, &block # :nodoc:
-      unless @expected_calls.key?(sym) then
-        if @delegator && @delegator.respond_to?(sym)
-          return @delegator.public_send(sym, *args, &block)
-        else
-          raise NoMethodError, "unmocked method %p, expected one of %p" %
-            [sym, @expected_calls.keys.sort_by(&:to_s)]
-        end
-      end
-
-      index = @actual_calls[sym].length
-      expected_call = @expected_calls[sym][index]
-
-      unless expected_call then
-        raise MockExpectationError, "No more expects available for %p: %p" %
-          [sym, args]
-      end
-
-      expected_args, retval, val_block =
-        expected_call.values_at(:args, :retval, :block)
-
-      if val_block then
-        # keep "verify" happy
-        @actual_calls[sym] << expected_call
-
-        raise MockExpectationError, "mocked method %p failed block w/ %p" %
-          [sym, args] unless val_block.call(*args, &block)
-
-        return retval
-      end
-
-      if expected_args.size != args.size then
-        raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
-          [sym, expected_args.size, args.size]
-      end
-
-      zipped_args = expected_args.zip(args)
-      fully_matched = zipped_args.all? { |mod, a|
-        mod === a or mod == a
-      }
-
-      unless fully_matched then
-        raise MockExpectationError, "mocked method %p called with unexpected arguments %p" %
-          [sym, args]
-      end
-
-      @actual_calls[sym] << {
-        :retval => retval,
-        :args => zipped_args.map! { |mod, a| mod === a ? mod : a },
-      }
-
-      retval
-    end
-
-    def respond_to? sym, include_private = false # :nodoc:
-      return true if @expected_calls.key? sym.to_sym
-      return true if @delegator && @delegator.respond_to?(sym, include_private)
-      __respond_to?(sym, include_private)
-    end
-  end
-end
-
-module Minitest::Assertions
-  ##
-  # Assert that the mock verifies correctly.
-
-  def assert_mock mock
-    assert mock.verify
-  end
-end
-
-##
-# Object extensions for Minitest::Mock.
-
-class Object
-
-  ##
-  # Add a temporary stubbed method replacing +name+ for the duration
-  # of the +block+. If +val_or_callable+ responds to #call, then it
-  # returns the result of calling it, otherwise returns the value
-  # as-is. If stubbed method yields a block, +block_args+ will be
-  # passed along. Cleans up the stub at the end of the +block+. The
-  # method +name+ must exist before stubbing.
-  #
-  #     def test_stale_eh
-  #       obj_under_test = Something.new
-  #       refute obj_under_test.stale?
-  #
-  #       Time.stub :now, Time.at(0) do
-  #         assert obj_under_test.stale?
-  #       end
-  #     end
-  #
-
-  def stub name, val_or_callable, *block_args
-    new_name = "__minitest_stub__#{name}"
-
-    metaclass = class << self; self; end
-
-    if respond_to? name and not methods.map(&:to_s).include? name.to_s then
-      metaclass.send :define_method, name do |*args|
-        super(*args)
-      end
-    end
-
-    metaclass.send :alias_method, new_name, name
-
-    metaclass.send :define_method, name do |*args, &blk|
-      if val_or_callable.respond_to? :call then
-        val_or_callable.call(*args, &blk)
-      else
-        blk.call(*block_args) if blk
-        val_or_callable
-      end
-    end
-
-    yield self
-  ensure
-    metaclass.send :undef_method, name
-    metaclass.send :alias_method, name, new_name
-    metaclass.send :undef_method, new_name
-  end
-end