vident 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2279071e93c86a27cab51ac5e30ce0d84ae5696434120043c6a2ebfaab40a4a3
-  data.tar.gz: 0e85654cb617dfffdfd42c6263f09c41c20a6d527dfb70d74fc71404b97cda13
+  metadata.gz: c2f2d014f440bdd33f9910c04ba79846825afb4c8a61bd6e5079079fd07c0473
+  data.tar.gz: fb730836ba6c63a582f97afcaceed12467a1b8ac92f2f5d9a0d871a4791c3de4
 SHA512:
-  metadata.gz: 127bf0f2146fed5560fac39c40ec15f967ca55e96af800cb128d1524ed91be7aef13078d070de1b06a7801af32d7f79563a583709dbd0a20e0f72913ea9c0c02
-  data.tar.gz: 75aee42b5f6942857bcbd3267914ec3aa031c9a2bfa3ef2b3489f57fde5d172f75508a17b8ce6a89a95791a2b270d182e1194906a1e21eee818ffdc8068f3c70
+  metadata.gz: da7e90adb10d5301803cde48f06685983478c01eec44bfe0c8db9a0909734572ccc1ee72490850655bc915f4c2de17d27b1191d3d649c53d7a23d2d1e40b83a2
+  data.tar.gz: 2626db1242b53e3abe20c75a8269125e564e1bc89a178f6e76feccda869ef2c41d671d0ece1a48f55441d6e4483e4962c76118ba48beba991529fe2e0ed322cc

data/Gemfile

@@ -27,5 +27,7 @@ gem "sqlite3"
 gem "rake", "~> 13.0"
 
 gem "minitest", "~> 5.0"
+gem "minitest-hooks"
+gem "faker"
 
 gem "standard", "~> 1.3"

data/lib/vident/test_case.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# TODO: what about when used with Phlex?
+module Vident
+  class TestCase < ::ViewComponent::TestCase
+    include Vident::Testing::AutoTest
+  end
+end

data/lib/vident/testing/attributes_tester.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Vident
+  module Testing
+    class AttributesTester
+      def initialize(test_configurations)
+        @test_configurations = test_configurations
+      end
+
+      # Generates attribute hashes for all permutations of the given valid values.
+      def valid_configurations
+        # Expands any auto generated values and returns all attributes and their values
+        test_attrs = prepare_attributes_to_test
+
+        # The first permutation is the initial state
+        initial_state = prepare_initial_test_state(test_attrs)
+
+        # Create remaining permutations
+        test_attrs.flat_map do |attr_name, values|
+          values.map { |v| initial_state.merge(attr_name => v) }
+        end
+      end
+
+      # Generates attribute hashes for all permutations of the given invalid values.
+      def invalid_configurations
+        return [] unless invalid_configured?
+
+        # prepare a valid initial state, then add any attrs that have :invalid
+        initial_state = prepare_initial_test_state(prepare_attributes_to_test)
+
+        # Merge in the invalid permutations
+        test_configurations.inject([]) do |memo, attr|
+          key, opts = attr
+          next memo += nil if opts == :strict_boolean
+          if opts.is_a?(Hash)
+            values = if opts[:invalid].nil? && opts[:valid].is_a?(Hash)
+              # If no invalid key specified we generate based on whats valid
+              config = invalid_attribute_test_values_for(opts[:valid][:type], opts[:valid])
+              (config&.fetch(:invalid, []) || []) + (config&.fetch(:converts, []) || [])
+            elsif opts[:invalid].is_a?(Array)
+              opts[:invalid]
+            end
+
+            memo += values.map { |i| initial_state.merge(key => i) } if values
+          end
+          memo
+        end
+      end
+
+      private
+
+      attr_reader :test_configurations
+
+      def invalid_configured?
+        test_configurations.values.any? { |v| v.respond_to?(:key?) && v.key?(:invalid) }
+      end
+
+      def prepare_attributes_to_test
+        test_configurations.transform_values do |attr_config|
+          next [true, false, nil] if attr_config == :boolean
+          next [true, false] if attr_config == :strict_boolean
+          valid = attr_config[:valid]
+          raise "Ensure :valid attributes configuration is provided" unless valid
+          next valid if valid.is_a?(Array)
+          attribute_test_values_for(valid)
+        end
+      end
+
+      def prepare_initial_test_state(test_attrs)
+        initial_state = {}
+        test_attrs.each { |attr_name, values| initial_state[attr_name] = values.first }
+        initial_state
+      end
+
+      def attribute_test_values_for(options)
+        type = parse_type(options[:type])
+        return options[:in] if options[:in]
+        values =
+          case type
+          when :string, "String"
+            s = (1..8).map { |l| ::Faker::String.random(length: l) }
+            s.prepend "test string"
+            s = s.select(&:present?)
+            s << "" if options[:allow_blank]
+            s
+          when :boolean
+            [false, true]
+          when :float, "Float"
+            (1..3).map { Faker::Number.positive } + (1..3).map { Faker::Number.negative }
+          when :numeric, "Numeric"
+            (1..3).map { Faker::Number.positive } + [1, 5]
+          when :integer, "Integer"
+            min = options[:min] || -10_000
+            max = options[:max] || 10_000
+            (1..3).map { Kernel.rand(min..max) }
+          when :array, "Array"
+            a =
+              if options[:sub_type] == Numeric
+                [[1, 2, 3], [0.3, 2, 0.002]]
+              elsif options[:sub_type]
+                [[options[:sub_type].new]]
+              else
+                [%i[a b c], [1, 2, 3], %w[a b]]
+              end
+            a << [] if options[:allow_blank]
+            a
+          when :any
+            [false, 1245, {}, :df, "hi"]
+          when :hash, "Hash"
+            a = [{a: 1}]
+            a << {} if options[:allow_blank]
+            a
+          when :symbol, "Symbol"
+            %i[a b c]
+          else
+            raise StandardError, "Attribute type not understood (#{type})"
+          end
+
+        if options[:allow_nil] || !options[:default].nil? || (options[:allow_blank] && options[:allow_nil].nil?)
+          values << nil
+        end
+        values
+      end
+
+      def invalid_attribute_test_values_for(type, options)
+        values = case parse_type(type)
+        when :string, "String"
+          # All values are also convertable to string
+          a = {converts: [false, 1245, 1.0, {}, :df, []], invalid: []}
+          a[:invalid] << "" if options[:allow_blank] == false
+          a
+        when :boolean
+          # All values are also convertable to boolean with !!
+          {converts: ["sdf", 234, 3.5, {}, :sdf, []], invalid: []}
+        when :float, "Float"
+          # Not all values are convertable to float
+          {converts: [234, "12.2"], invalid: ["sdf", 234, {}, :sdf, [], false]}
+        when :numeric, "Numeric"
+          {converts: ["12.2"], invalid: ["sdf", {}, :sdf, [], false]}
+        when :integer, "Integer"
+          # Not all values are convertable to integer
+          {converts: [234.0, "123", "sdf"], invalid: [{}, :sdf, [], false]}
+        when :array, "Array"
+          # Not all values are convertable to array
+          a = if options[:sub_type]
+            {converts: [{}, [{}]], invalid: ["sdf", [123], [Class.new]]}
+          else
+            {converts: [{}], invalid: ["sdf", 234, 3.5, :sdf, false]}
+          end
+          a[:invalid] << [] if options[:allow_blank] == false
+          a
+        when :any
+          # There are no invalid values
+          {converts: [], invalid: []}
+        when :hash, "Hash"
+          a = {converts: [[], [[:a, 1], [:b, 2]]], invalid: [:sdf, false, "boo", 123]}
+          a[:invalid] << {} if options[:allow_blank] == false
+          a
+        when :symbol, "Symbol"
+          {converts: ["foo"], invalid: [{}, false, [], 123]}
+        else
+          raise StandardError, "Attribute type not understood (#{type})"
+        end
+
+        if options[:default].nil? && (!options[:allow_nil] || (!options[:allow_blank] && options[:allow_nil] != true))
+          values[:invalid] << nil
+        end
+        values
+      end
+
+      def parse_type(type)
+        type.is_a?(Symbol) ? type : type.name
+      end
+    end
+  end
+end

data/lib/vident/testing/auto_test.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "minitest/hooks"
+
+module Vident
+  module Testing
+    module AutoTest
+      extend ActiveSupport::Concern
+
+      included do
+        include Minitest::Hooks
+
+        def before_all
+          @results_content = []
+          ::Vident::StableId.set_current_sequence_generator
+        end
+
+        def after_all
+          html = <<~HTML
+            <!doctype html>
+            <html lang="en">
+            <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+            <meta http-equiv="X-UA-Compatible" content="ie=edge">
+            <title>Test run output</title>
+            </head>
+            <body>
+              #{@results_content.map(&:to_s).join("<hr>\n").html_safe}
+            </body>
+            </html>
+          HTML
+
+          # TODO: configurable layout
+          filename = self.class.name.gsub("::", "_")
+          File.write("render_results_#{filename}.html", html) # TODO: path for outputs (eg default tmp/)
+        end
+      end
+
+      class_methods do
+        def auto_test(class_under_test, **param_config)
+          attribute_tester = Vident::Testing::AttributesTester.new(param_config)
+          attribute_tester.valid_configurations.each_with_index do |test, index|
+            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              def test_renders_with_valid_attrs_#{index}
+                test_attrs = #{test}
+                begin 
+                  render_inline(#{class_under_test}.new(**test_attrs))
+                rescue => error
+                  assert(false, "Should not raise with #{test.to_s.tr("\"", "'")} but did raise \#{error}")
+                end
+              end
+            RUBY
+          end
+
+          attribute_tester.invalid_configurations.each_with_index do |test, index|
+            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              def test_raises_with_invalid_attrs_#{index}
+                test_attrs = #{test}
+                assert_raises(StandardError, "Should raise with #{test.to_s.tr("\"", "'")}") do
+                  render_inline(#{class_under_test}.new(**test_attrs))
+                end
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vident/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vident
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/vident.rb

@@ -32,3 +32,9 @@ require_relative "vident/base"
 require_relative "vident/component"
 require_relative "vident/typed_component"
 require_relative "vident/caching/cache_key"
+
+require_relative "vident/testing/attributes_tester"
+require_relative "vident/testing/auto_test"
+
+# TODO: what if not using view_component?
+require_relative "vident/test_case"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vident
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-04 00:00:00.000000000 Z
+date: 2023-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -60,6 +60,9 @@ files:
 - lib/vident/root_component/using_phlex_html.rb
 - lib/vident/root_component/using_view_component.rb
 - lib/vident/stable_id.rb
+- lib/vident/test_case.rb
+- lib/vident/testing/attributes_tester.rb
+- lib/vident/testing/auto_test.rb
 - lib/vident/typed_component.rb
 - lib/vident/version.rb
 - sig/vident.rbs