omu-support 0.1.1

data/lib/omu_support/minitest.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'minitest/association_helper'
+require_relative 'minitest/callback_helper'
+require_relative 'minitest/enumeration_helper'
+require_relative 'minitest/validation_helper'

data/lib/omu_support/minitest/association_helper.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module OMU
+  module Support
+    module Minitest
+      module AssociationHelper
+        SUFFIX = 'Test'
+        RELATIONS = %i[belongs_to has_many has_one has_and_belongs_to_many].freeze
+
+        RELATIONS.each do |relation|
+          define_method(relation) do |attribute, **options|
+            association = relations_for(relation, attribute)
+
+            test "can respond to #{relation} #{attribute}" do
+              assert association
+              options.each do |key, value|
+                assert_equal association.options[key], value, "Option: #{key}"
+              end
+            end
+          end
+        end
+
+        def accepts_nested_attributes_for(attribute, **options)
+          nested_attributes_options = klass.nested_attributes_options[attribute]
+
+          test "#{attribute} must be nested attribute" do
+            assert nested_attributes_options
+            options.each do |key, value|
+              assert_equal nested_attributes_options[key], value, "Option: #{key}"
+            end
+          end
+        end
+
+        private
+
+        def relations_for(relation, attribute)
+          klass.reflect_on_all_associations(relation).find do |association|
+            association.name == attribute
+          end
+        end
+
+        def klass
+          to_s.delete_suffix(SUFFIX).constantize
+        end
+      end
+    end
+  end
+end

data/lib/omu_support/minitest/callback_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module OMU
+  module Support
+    module Minitest
+      module CallbackHelper
+        CALLBACKS = %i[
+          after_commit
+          after_create
+          after_destroy
+          after_find
+          after_initialize
+          after_rollback
+          after_save
+          after_touch
+          after_update
+          after_validation
+          around_create
+          around_destroy
+          around_save
+          around_update
+          before_create
+          before_destroy
+          before_save
+          before_update
+          before_validation
+        ].freeze
+
+        CALLBACKS.each do |callback|
+          define_method(callback) do |action|
+            test "has #{callback} for #{action}" do
+              kind, method = callback.to_s.split('_')
+              klass        = class_name.delete_suffix('Test').constantize
+              callbacks    = klass.public_send("_#{method}_callbacks")
+              assert callbacks.select { |cb| cb.filter.eql?(action.to_sym) && cb.kind.eql?(kind.to_sym) }.any?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omu_support/minitest/enumeration_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module OMU
+  module Support
+    module Minitest
+      module EnumerationHelper
+        def enum(definitions)
+          definitions.each do |attribute, values|
+            values.each do |key, value|
+              test "has a enum key (#{key}) with a value of #{value}" do
+                klass         = class_name.delete_suffix('Test').constantize
+                defined_value = klass.defined_enums.dig(attribute.to_s, key.to_s)
+                assert_equal defined_value, value, "Enum: #{attribute}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omu_support/minitest/validation_helper.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module OMU
+  module Support
+    module Minitest
+      module ValidationHelper
+        SUFFIX = 'Test'
+
+        def validates_presence_of(*attributes)
+          attributes.each do |attribute|
+            test "#{attribute} must be present (presence: true)" do
+              object.public_send("#{attribute}=", nil)
+              assert_not object.valid?
+              assert_not_empty object.errors[attribute]
+            end
+          end
+        end
+
+        def validates_presence_of_nested_model(attribute, ids: nil)
+          test "nested model (#{attribute}) must be present" do
+            ids ||= "#{attribute.to_s.singularize}_ids"
+            object.public_send("#{ids}=", nil)
+            assert_not object.valid?
+            assert_not_empty object.errors[attribute]
+          end
+        end
+
+        def validates_uniqueness_of(*attributes)
+          attributes.each do |attribute|
+            test "#{attribute} must be unique (uniqueness: true)" do
+              duplicate_object = object.dup
+              assert_not duplicate_object.valid?
+              assert_not_empty duplicate_object.errors[attribute]
+            end
+          end
+        end
+
+        def validates_length_of(attribute, **option) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          option[:maximum] = 255 if option.blank?
+
+          controls = {
+            is:      { value: 1, error_key: :wrong_length },
+            minimum: { value: -1, error_key: :too_short },
+            maximum: { value: 1, error_key: :too_long }
+          }
+
+          key       = option.keys.first
+          value     = option[key].to_i + controls.dig(key, :value).to_i
+          error_key = controls.dig(key, :error_key)
+
+          test "#{attribute} length must be #{option}" do
+            object.public_send("#{attribute}=", (0..value).map { ('a'..'z').to_a[rand(26)] }.join)
+            assert_not object.valid?
+            assert object.errors.details[attribute].pluck(:error).include?(error_key)
+          end
+        end
+
+        def validates_numericality_of(attribute)
+          test "#{attribute} must be a number" do
+            object.public_send("#{attribute}=", 'some string')
+            assert_not object.valid?
+            assert object.errors.details[attribute].pluck(:error).include?(:not_a_number)
+          end
+        end
+
+        def validates_numerical_range(attribute, **option) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          controls = {
+            greater_than:             0,
+            less_than:                0,
+            greater_than_or_equal_to: -1,
+            less_than_or_equal_to:    1
+          }
+
+          key   = option.keys.first
+          value = option[key].to_i + controls[key].to_i
+
+          test "#{attribute} must be #{key} #{value}" do
+            object.public_send("#{attribute}=", value)
+            assert_not object.valid?
+            assert object.errors.details[attribute].pluck(:error).include?(key)
+          end
+        end
+
+        def self.extended(base)
+          super
+
+          base.define_method :object do
+            @object ||= class_name.delete_suffix(SUFFIX).constantize.take
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omu_support/rest_client.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module OMU
+  module Support
+    module RestClient
+      SUPPORTED_HTTP_METHODS = %i[
+        delete
+        get
+        patch
+        post
+        put
+      ].freeze
+
+      private_constant :SUPPORTED_HTTP_METHODS
+
+      class Error < StandardError; end
+
+      class HTTPMethodError < Error; end
+
+      class UnsupportedHTTPOptionError < Error; end
+
+      class HTTPError < Error; end
+
+      class Request
+        SUPPORTED_HTTP_OPTIONS = {
+          open_timeout: 10,
+          read_timeout: 10,
+          use_ssl:      false,
+          verify_mode:  OpenSSL::SSL::VERIFY_NONE
+        }.freeze
+
+        HEADERS = {
+          'Content-Type' => 'application/json'
+        }.freeze
+
+        private_constant :SUPPORTED_HTTP_OPTIONS, :HEADERS
+
+        # rubocop:disable Style/IfUnlessModifier
+        def initialize(method, url, headers = {}, **http_options)
+          @method  = method
+          @url     = url
+          @headers = HEADERS.merge(headers)
+
+          unless method.in?(SUPPORTED_HTTP_METHODS)
+            raise HTTPMethodError, "unsupported HTTP method: #{method}"
+          end
+
+          build_http_object http_options
+        end
+        # rubocop:enable Style/IfUnlessModifier
+
+        def execute(payload = nil)
+          klass = "Net::HTTP::#{method.capitalize}".constantize
+          request = klass.new url, headers
+          Response.new @http.request(request, payload)
+        end
+
+        protected
+
+        attr_reader :method, :url, :headers
+
+        private
+
+        def build_http_object(http_options)
+          uri   = URI.parse(url)
+          @http = Net::HTTP.new uri.host, uri.port
+
+          unsupported_options = http_options.keys - SUPPORTED_HTTP_OPTIONS.keys
+          unless unsupported_options.empty?
+            raise UnsupportedHTTPOptionError, "unsupported HTTP options: #{unsupported_options}"
+          end
+
+          http_options.each { |option, value| @http.public_send "#{option}=", value }
+        end
+      end
+
+      private_constant :Request
+
+      Response = Struct.new(:http_response) do
+        delegate :body, to: :http_response
+
+        def decode
+          body && JSON.parse(body, symbolize_names: true)
+        rescue JSON::JSONError => e
+          Rails.logger.warn("JSON parse error: #{e}")
+          nil
+        end
+
+        def error!
+          http_response.error! unless ok?
+        rescue Net::HTTPError, Net::HTTPFatalError => e
+          Rails.logger.warn("HTTP error: #{e}")
+          raise HTTPError
+        end
+
+        def ok?
+          http_response.is_a?(Net::HTTPOK)
+        end
+      end
+
+      private_constant :Response
+
+      module_function
+
+      SUPPORTED_HTTP_METHODS.each do |method|
+        define_method(method) do |url, headers: {}, payload: nil, **http_options|
+          Request.new(method, url, headers, **http_options).execute(payload)
+        end
+      end
+    end
+  end
+end

data/lib/omu_support/sensitive.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module OMU
+  module Support
+    # Sensitive file read/write
+    module Sensitive
+      module_function
+
+      def read(path)
+        encryptor(expand_path(path)).read
+      end
+
+      def readlines(path)
+        read(path).split "\n"
+      end
+
+      def write(path, content)
+        unless Dir.exist?(dir = File.dirname(file = expand_path(path)))
+          FileUtils.mkdir_p(dir)
+        end
+        encryptor(file).write(content)
+      end
+
+      def writelines(path, contents)
+        write(path, contents.join("\n"))
+      end
+
+      def read_write(path)
+        write(path, File.read(path))
+      end
+
+      def content_decrypt(content)
+        encryptor('').__send__(:decrypt, content)
+      end
+
+      EXT = '.enc'
+
+      def expand_path(path)
+        File.expand_path(path, Rails.root) + EXT
+      end
+
+      def encryptor(file)
+        ActiveSupport::EncryptedFile.new(
+          content_path:         file,
+          env_key:              'RAILS_MASTER_KEY',
+          key_path:             Rails.root.join('config/master.key'),
+          raise_if_missing_key: true
+        )
+      end
+    end
+  end
+end

data/lib/omu_support/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module OMU
+  module Support
+    VERSION = '0.1.1'
+  end
+end

data/test/core_ext/array_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ArrayTest < ActiveSupport::TestCase
+  test 'clip works' do
+    assert_equal %w[foo bar], %w[foo bar baz quux].clip(2)
+  end
+
+  test 'join_affixed works' do
+    assert_equal 'aaa.foo-bar-baz-quux_zzz',
+                 %w[foo bar baz quux].join_affixed(prefix: 'aaa.', interfix: '-', suffix: '_zzz')
+  end
+end

data/test/core_ext/class_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ClassTest < ActiveSupport::TestCase
+  module TestClassesOne
+    class NonConveyedBase
+      class_attribute :array_attr, default: %w[foo bar]
+      class_attribute :hash_attr, default: { x: 'foo', y: 'bar' }
+    end
+
+    class ConveyedBase
+      class_attribute :array_attr, default: %w[foo bar]
+      class_attribute :hash_attr, default: { x: 'foo', y: 'bar' }
+
+      inherited_by_conveying_attributes :array_attr, :hash_attr
+    end
+
+    class ChildFromNonConveyedBase < NonConveyedBase
+      array_attr << 'child_addition'
+      hash_attr.merge! z: 'child_addition'
+    end
+
+    class ChildFromConveyedBase < ConveyedBase
+      array_attr << 'child_addition'
+      hash_attr.merge! z: 'child_addition'
+    end
+  end
+
+  test 'inherited_by_conveying_attributes works' do
+    assert_equal %w[foo bar child_addition], TestClassesOne::NonConveyedBase.array_attr
+    assert_equal %w[foo bar],                TestClassesOne::ConveyedBase.array_attr
+    assert_equal %w[foo bar child_addition], TestClassesOne::ChildFromNonConveyedBase.array_attr
+    assert_equal %w[foo bar child_addition], TestClassesOne::ChildFromConveyedBase.array_attr
+
+    assert_equal Hash[x: 'foo', y: 'bar', z: 'child_addition'], TestClassesOne::NonConveyedBase.hash_attr
+    assert_equal Hash[x: 'foo', y: 'bar'],                      TestClassesOne::ConveyedBase.hash_attr
+    assert_equal Hash[x: 'foo', y: 'bar', z: 'child_addition'], TestClassesOne::ChildFromNonConveyedBase.hash_attr
+    assert_equal Hash[x: 'foo', y: 'bar', z: 'child_addition'], TestClassesOne::ChildFromConveyedBase.hash_attr
+  end
+
+  module TestClassesTwo
+    class ConveyedBase
+      class_attribute :array_attr, default: %w[foo bar]
+
+      inherited_by_conveying_attributes :array_attr do |child|
+        child.class_attribute :other, default: 'ok'
+      end
+    end
+
+    class ChildFromConveyedBase < ConveyedBase
+      array_attr << 'child_addition'
+    end
+  end
+
+  test 'inherited_by_conveying_attributes with block works' do
+    assert_equal %w[foo bar],                TestClassesTwo::ConveyedBase.array_attr
+    assert_equal %w[foo bar child_addition], TestClassesTwo::ChildFromConveyedBase.array_attr
+
+    assert_not TestClassesTwo::ConveyedBase.respond_to? :other
+    assert_equal 'ok', TestClassesTwo::ChildFromConveyedBase.other
+  end
+end