jamm 0.0.1 → 1.0.1

data/lib/jamm/jamm_object.rb

@@ -1,249 +0,0 @@
-module Jamm
-  class JammObject
-    include Enumerable
-
-    @@permanent_attributes = Set.new([:id]) # rubocop:disable Style/ClassVars
-
-    # The default :id method is deprecated and isn't useful to us
-    undef :id if method_defined?(:id)
-
-    def initialize(id = nil)
-      # parameter overloading!
-      if id.is_a?(Hash)
-        @retrieve_params = id.dup
-        @retrieve_params.delete(:id)
-        id = id[:id]
-      else
-        @retrieve_params = {}
-      end
-
-      @values = {}
-      # This really belongs in APIResource, but not putting it there allows us
-      # to have a unified inspect method
-      @unsaved_values = Set.new
-      @transient_values = Set.new
-      @values[:id] = id if id
-    end
-
-    def self.construct_from(values)
-      new(values[:id]).refresh_from(values)
-    end
-
-    def to_s(*_args)
-      JSON.pretty_generate(@values)
-    end
-
-    def inspect
-      id_string = respond_to?(:id) && !id.nil? ? " id=#{id}" : ''
-      "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
-    end
-
-    def refresh_from(values, partial: false)
-      @original_values = Marshal.load(Marshal.dump(values)) # deep copy
-      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
-      added = Set.new(values.keys - @values.keys)
-      # Wipe old state before setting new.  This is useful for e.g. updating a
-      # customer, where there is no persistent card parameter.  Mark those values
-      # which don't persist as transient
-
-      instance_eval do
-        remove_accessors(removed)
-        add_accessors(added)
-      end
-      removed.each do |k|
-        @values.delete(k)
-        @transient_values.add(k)
-        @unsaved_values.delete(k)
-      end
-      values.each do |k, v|
-        @values[k] = Util.convert_to_jamm_object(v)
-        @transient_values.delete(k)
-        @unsaved_values.delete(k)
-      end
-
-      self
-    end
-
-    def [](k)
-      @values[k.to_sym]
-    end
-
-    def []=(k, v)
-      send(:"#{k}=", v)
-    end
-
-    def keys
-      @values.keys
-    end
-
-    def values
-      @values.values
-    end
-
-    def to_json(*_a)
-      JSON.generate(@values)
-    end
-
-    def as_json(*a)
-      @values.as_json(*a)
-    end
-
-    def to_hash
-      @values.transform_values do |value|
-        value.respond_to?(:to_hash) ? value.to_hash : value
-      end
-    end
-
-    def each(&blk)
-      @values.each(&blk)
-    end
-
-    def _dump(_level)
-      Marshal.dump(@values)
-    end
-
-    def self._load(args)
-      values = Marshal.load(args)
-      construct_from(values)
-    end
-
-    def serialize_nested_object(key)
-      new_value = @values[key]
-      return {} if new_value.is_a?(APIResource)
-
-      if @unsaved_values.include?(key)
-        # the object has been reassigned
-        # e.g. as object.key = {foo => bar}
-        update = new_value
-        new_keys = update.keys.map(&:to_sym)
-
-        # remove keys at the server, but not known locally
-        if @original_values.include?(key)
-          keys_to_unset = @original_values[key].keys - new_keys
-          keys_to_unset.each { |unset_key| update[unset_key] = '' }
-        end
-
-        update
-      else
-        # can be serialized normally
-        self.class.serialize_params(new_value)
-      end
-    end
-
-    def self.serialize_params(obj, original_value = nil)
-      case obj
-      when nil
-        ''
-      when JammObject
-        unsaved_keys = obj.instance_variable_get(:@unsaved_values)
-        obj_values = obj.instance_variable_get(:@values)
-        update_hash = {}
-
-        unsaved_keys.each do |k|
-          update_hash[k] = serialize_params(obj_values[k])
-        end
-
-        obj_values.each do |k, v|
-          if v.is_a?(JammObject) || v.is_a?(Hash)
-            update_hash[k] = obj.serialize_nested_object(k)
-          elsif v.is_a?(Array)
-            original_value = obj.instance_variable_get(:@original_values)[k]
-            if original_value && original_value.length > v.length
-              # url params provide no mechanism for deleting an item in an array,
-              # just overwriting the whole array or adding new items. So let's not
-              # allow deleting without a full overwrite until we have a solution.
-              raise ArgumentError, 'You cannot delete an item from an array, you must instead set a new array'
-            end
-
-            update_hash[k] = serialize_params(v, original_value)
-          end
-        end
-
-        update_hash
-      when Array
-        update_hash = {}
-        obj.each_with_index do |value, index|
-          update = serialize_params(value)
-          update_hash[index] = update if update != {} && (!original_value || update != original_value[index])
-        end
-
-        if update_hash == {}
-          nil
-        else
-          update_hash
-        end
-      else
-        obj
-      end
-    end
-
-    protected
-
-    def metaclass
-      class << self; self; end
-    end
-
-    def remove_accessors(keys)
-      metaclass.instance_eval do
-        keys.each do |k|
-          next if @@permanent_attributes.include?(k)
-
-          k_eq = :"#{k}="
-          remove_method(k) if method_defined?(k)
-          remove_method(k_eq) if method_defined?(k_eq)
-        end
-      end
-    end
-
-    def add_accessors(keys)
-      metaclass.instance_eval do
-        keys.each do |k|
-          next if @@permanent_attributes.include?(k)
-
-          k_eq = :"#{k}="
-          define_method(k) { @values[k] }
-          define_method(k_eq) do |v|
-            if v == ''
-              raise ArgumentError, "You cannot set #{k} to an empty string." \
-                'We interpret empty strings as nil in requests.' \
-                "You may set #{self}.#{k} = nil to delete the property."
-            end
-            @values[k] = v
-            @unsaved_values.add(k)
-          end
-        end
-      end
-    end
-
-    def method_missing(name, *args)
-      if name.to_s.end_with?('=')
-        attr = name.to_s[0...-1].to_sym
-        add_accessors([attr])
-        begin
-          mth = method(name)
-        rescue NameError
-          raise NoMethodError,
-                "Cannot set #{attr} on this object. HINT: you can't set: #{@@permanent_attributes.to_a.join(', ')}"
-        end
-        return mth.call(args[0])
-      elsif @values.key?(name)
-        return @values[name]
-      end
-
-      begin
-        super
-      rescue NoMethodError => e
-        if @transient_values.include?(name)
-          raise NoMethodError,
-                e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Jamm's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}"
-        end
-
-        raise
-      end
-    end
-
-    def respond_to_missing?(symbol, include_private = false)
-      @values&.key?(symbol) || super
-    end
-  end
-end

data/lib/jamm/payment.rb

@@ -1,18 +0,0 @@
-module Jamm
-  class Payment < APIResource
-    def self.create(params = {}, headers = {})
-      params[:redirect][:expired_at] = TimeUtil.relative_time_to_iso(params[:redirect][:expired_in]) if params[:redirect] && params[:redirect][:expired_in]
-
-      request_jamm_api(
-        method: :post,
-        path: resource_url,
-        params: params,
-        headers: headers
-      )
-    end
-
-    def self.resource_url
-      '/payments'
-    end
-  end
-end

data/lib/jamm/request.rb

@@ -1,13 +0,0 @@
-module Jamm
-  module Request
-    module ClassMethods
-      def request_jamm_api(method:, path:, params: {}, headers: {})
-        Jamm.request_jamm_api(method, path, params, headers)
-      end
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-  end
-end

data/lib/jamm/time_util.rb

@@ -1,41 +0,0 @@
-require 'time'
-module Jamm
-  class TimeUtil
-    def self.relative_time_to_iso(relative_time)
-      # Check if the input string is in ISO format
-      return relative_time if iso_format?(relative_time)
-
-      # Parse the relative time string
-      quantity, unit = relative_time.split
-      quantity = quantity.to_i
-
-      # Calculate the time delta
-      case unit.downcase
-      when 'second', 'seconds'
-        time_delta = quantity
-      when 'minute', 'minutes'
-        time_delta = quantity * 60
-      when 'hour', 'hours'
-        time_delta = quantity * 60 * 60
-      when 'day', 'days'
-        time_delta = quantity * 60 * 60 * 24
-      when 'week', 'weeks'
-        time_delta = quantity * 60 * 60 * 24 * 7
-      else
-        raise ArgumentError, "Unknown time unit: #{unit}"
-      end
-
-      # Calculate the ISO datetime string
-      iso_time = Time.now + time_delta
-      iso_time.strftime('%Y-%m-%dT%H:%M:%SZ')
-    end
-
-    def self.iso_format?(string)
-      # Check if the string matches the ISO 8601 datetime format
-
-      !!Time.iso8601(string)
-    rescue StandardError
-      false
-    end
-  end
-end

data/lib/jamm/token.rb

@@ -1,10 +0,0 @@
-module Jamm
-  class Token < APIResource
-    extend Jamm::APIOperations::List
-    extend Jamm::APIOperations::Get
-
-    def self.resource_url
-      '/payments/tokens'
-    end
-  end
-end

data/lib/jamm/util.rb

@@ -1,76 +0,0 @@
-module Jamm
-  module Util
-    def self.convert_to_jamm_object(response)
-      case response
-      when Array
-        response.map { |i| convert_to_jamm_object(i) }
-      when Hash
-        JammObject.construct_from(response)
-      else
-        response
-      end
-    end
-
-    def self.symbolize_names(object)
-      case object
-      when Hash
-        new_hash = {}
-        object.each do |key, value|
-          key = begin
-            key.to_sym
-          rescue StandardError
-            key
-          end || key
-          new_hash[key] = symbolize_names(value)
-        end
-        new_hash
-      when Array
-        object.map { |value| symbolize_names(value) }
-      else
-        object
-      end
-    end
-
-    def self.url_encode(key)
-      # URI.escape is obsolete, so just use the code fragment in URI library
-      # (from URI::RFC2396_Parser#escape)
-      key.to_s.gsub(Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")) do
-        us = ::Regexp.last_match(0)
-        tmp = ''
-        us.each_byte do |uc|
-          tmp << format('%%%02X', uc)
-        end
-        tmp
-      end.force_encoding(Encoding::US_ASCII)
-    end
-
-    def self.flatten_params(params, parent_key = nil)
-      result = []
-      params.each do |key, value|
-        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
-        if value.is_a?(Hash)
-          result += flatten_params(value, calculated_key)
-        elsif value.is_a?(Array)
-          result += flatten_params_array(value, calculated_key)
-        else
-          result << [calculated_key, value]
-        end
-      end
-      result
-    end
-
-    def self.flatten_params_array(value, calculated_key)
-      result = []
-      value.each do |elem|
-        if elem.is_a?(Hash)
-          result += flatten_params(elem, calculated_key)
-        elsif elem.is_a?(Array)
-          result += flatten_params_array(elem, calculated_key)
-        else
-          result << ["#{calculated_key}[]", elem]
-        end
-      end
-      result
-    end
-  end
-end

data/test/jamm/charge_test.rb

@@ -1,56 +0,0 @@
-require File.expand_path('../test_helper', __dir__)
-
-module Jamm
-  class ChargeTest < Test::Unit::TestCase
-    should 'return a list of charge when Charge.list return valid response' do
-      # Arrange
-      @mock.expects(:post).once.returns(test_response(test_cognito_response))
-      @mock.expects(:get).once.returns(test_response(test_charges))
-      # Act
-      actual = Jamm::Charge.list
-      # Assert
-      assert actual.is_a? Array
-      assert_equal actual[0].charge_id, 'ct_h5e599d3-0000-4d46-9a52-1a37e7b5b8ef'
-      assert_equal actual[0].contract_id, 'dt_f5e599d3-8b9e-4d46-9a52-1a37e7b5b8ef'
-      assert_equal actual[0].status, 'CREATED'
-      assert_equal actual[0].description, 'Gold Gym'
-      assert_equal actual[0].currency, 'JPY'
-      assert_equal actual[0].amount, 1000
-      assert_equal actual[0].amount_refunded, 800
-      assert_equal actual[0].merchant_metadata.key1, 'value1'
-      assert_equal actual[0].merchant_metadata.key2, 'value2'
-      assert_equal actual[0].created_at, '2023-11-07T15:30:00.000+03:00'
-      assert_equal actual[0].updated_at, '2023-11-11T15:30:00.000+03:00'
-    end
-
-    should 'raise an error when Charge.list return timeout' do
-      # Arrange
-      @mock.expects(:post).once.returns(test_response(test_cognito_response))
-      @mock.expects(:get).once.raises(RestClient::RequestTimeout)
-      # Assert
-      assert_raise ApiConnectionError do
-        Jamm::Charge.list
-      end
-    end
-
-    should 'return a charge when Charge.get return valid response' do
-      # Arrange
-      @mock.expects(:post).once.returns(test_response(test_cognito_response))
-      @mock.expects(:get).once.returns(test_response(test_charge))
-      # Act
-      actual = Jamm::Charge.get('ct_h5e599d3-0000-4d46-9a52-1a37e7b5b8ef')
-      # Assert
-      assert_equal actual.charge_id, 'ct_h5e599d3-0000-4d46-9a52-1a37e7b5b8ef'
-      assert_equal actual.contract_id, 'dt_f5e599d3-8b9e-4d46-9a52-1a37e7b5b8ef'
-      assert_equal actual.status, 'CREATED'
-      assert_equal actual.description, 'Gold Gym'
-      assert_equal actual.currency, 'JPY'
-      assert_equal actual.amount, 1000
-      assert_equal actual.amount_refunded, 800
-      assert_equal actual.merchant_metadata.key1, 'value1'
-      assert_equal actual.merchant_metadata.key2, 'value2'
-      assert_equal actual.created_at, '2023-11-07T15:30:00.000+03:00'
-      assert_equal actual.updated_at, '2023-11-11T15:30:00.000+03:00'
-    end
-  end
-end

data/test/jamm/oauth_test.rb

@@ -1,47 +0,0 @@
-require File.expand_path('../test_helper', __dir__)
-require 'rest-client'
-
-module Jamm
-  class OAuthTest < Test::Unit::TestCase
-    should 'raise an error when bad request was returned' do
-      @mock.expects(:post).once.raises(RestClient::ExceptionWithResponse)
-      assert_raise OAuthError do
-        Jamm::OAuth.oauth_token
-      end
-    end
-
-    should 'raise an error when SocketError happened' do
-      @mock.expects(:post).once.raises(SocketError)
-      assert_raise OAuthError do
-        Jamm::OAuth.oauth_token
-      end
-    end
-
-    should 'raise an error when timeout happened' do
-      @mock.expects(:post).once.raises(RestClient::RequestTimeout)
-      assert_raise OAuthError do
-        Jamm::OAuth.oauth_token
-      end
-    end
-
-    should 'raise an error when an unexpected exception happened' do
-      @mock.expects(:post).once.raises(RestClient::Exception)
-      assert_raise OAuthError do
-        Jamm::OAuth.oauth_token
-      end
-    end
-
-    should 'raise an error when unexpected response was returned' do
-      @mock.expects(:post).once.returns(test_response({}, 200))
-      assert_raise OAuthError do
-        Jamm::OAuth.oauth_token
-      end
-    end
-
-    should 'return an access token when valid response was returned' do
-      @mock.expects(:post).once.returns(test_response(test_cognito_response))
-      actual = Jamm::OAuth.oauth_token
-      assert_equal actual, 'access_token'
-    end
-  end
-end

data/test/jamm/payment_test.rb

@@ -1,17 +0,0 @@
-require File.expand_path('../test_helper', __dir__)
-
-module Jamm
-  class PaymentTest < Test::Unit::TestCase
-    should 'return a result when Payment.create return valid response' do
-      # Arrange
-      @mock.stubs(:post).returns(test_response(test_cognito_response)).then.returns(test_response(test_create_payment_response))
-      # Act
-      actual = Jamm::Payment.create(test_create_payment_request)
-      # Assert
-      assert_equal actual.token_id, 'dt_f5e599d3-8b9e-4d46-9a52-1a37e7b5b8ef'
-      assert_equal actual.charge_id, 'ct_h5e599d3-0000-4d46-9a52-1a37e7b5b8ef'
-      assert_equal actual.payment_url, 'https://jamm-pay.com/K5e599d3-8b9e-4d46-9a72-1a37e7b5b8ef'
-      assert_equal actual.created_at, '2023-11-07T15:30:00.000+03:00'
-    end
-  end
-end

data/test/jamm/time_util_test.rb

@@ -1,18 +0,0 @@
-require File.expand_path('../test_helper', __dir__)
-require 'time'
-
-module Jamm
-  class TimeUtilTest < Test::Unit::TestCase
-    should 'compute relative time when relative scale is specified' do
-      now = Time.now
-      Time.expects(:now).once.returns(now)
-      actual = Jamm::TimeUtil.relative_time_to_iso('6 minutes')
-      assert_equal actual, (now + 6 * 60).strftime('%Y-%m-%dT%H:%M:%SZ')
-    end
-
-    should 'return input when absolute scale is specified' do
-      actual = Jamm::TimeUtil.relative_time_to_iso('2024-04-11T16:28:07.420Z')
-      assert_equal actual, '2024-04-11T16:28:07.420Z'
-    end
-  end
-end

data/test/jamm/token_test.rb

@@ -1,52 +0,0 @@
-require File.expand_path('../test_helper', __dir__)
-
-module Jamm
-  class TokenTest < Test::Unit::TestCase
-    should 'return a list of contract tokens when Token.list return valid response' do
-      # Arrange
-      @mock.expects(:post).once.returns(test_response(test_cognito_response))
-      @mock.expects(:get).once.returns(test_response(test_token_list))
-      # Act
-      actual = Jamm::Token.list
-      # Assert
-      assert actual.is_a? Array
-      assert_equal actual[0].contract_id, 'dt_f5e599d3-8b9e-4d46-9a52-1a37e7b5b8ef'
-      assert_equal actual[0].status, 'CREATED'
-      assert_equal actual[0].description, 'Gold Gym'
-      assert_equal actual[0].currency, 'JPY'
-      assert_equal actual[0].initial_amount, 1000
-      assert_equal actual[0].metadata.key1, 'value1'
-      assert_equal actual[0].metadata.key2, 'value2'
-      assert_equal actual[0].created_at, '2023-11-07T15:30:00.000+03:00'
-      assert_equal actual[0].updated_at, '2023-11-11T15:30:00.000+03:00'
-    end
-
-    should 'raise an error when Token.list return timeout' do
-      # Arrange
-      @mock.expects(:post).once.returns(test_response(test_cognito_response))
-      @mock.expects(:get).once.raises(RestClient::RequestTimeout)
-      # Assert
-      assert_raise ApiConnectionError do
-        Jamm::Token.list
-      end
-    end
-
-    should 'return a contract tokens when Token.get return valid response' do
-      # Arrange
-      @mock.expects(:post).once.returns(test_response(test_cognito_response))
-      @mock.expects(:get).once.returns(test_response(test_token))
-      # Act
-      actual = Jamm::Token.get('dt_f5e599d3-8b9e-4d46-9a52-1a37e7b5b8ef')
-      # Assert
-      assert_equal actual.contract_id, 'dt_f5e599d3-8b9e-4d46-9a52-1a37e7b5b8ef'
-      assert_equal actual.status, 'CREATED'
-      assert_equal actual.description, 'Gold Gym'
-      assert_equal actual.currency, 'JPY'
-      assert_equal actual.initial_amount, 1000
-      assert_equal actual.metadata.key1, 'value1'
-      assert_equal actual.metadata.key2, 'value2'
-      assert_equal actual.created_at, '2023-11-07T15:30:00.000+03:00'
-      assert_equal actual.updated_at, '2023-11-11T15:30:00.000+03:00'
-    end
-  end
-end