inline_tests 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 57656c22e4b2934ea92a86653dceeea5eb02333bd4139aa0709a660be9537073
+  data.tar.gz: c6395566d89b424c025b70d268413d10055a547b97268332c1967d9e84433e9f
+SHA512:
+  metadata.gz: ae97052ba781000565e759e560b1dcda519e3f09268487a5a7519398f95e902b47f60f57e5fe893d7400d63a7e1e2282ebf7878e82b818c17d2ee9ba3ece5e3b
+  data.tar.gz: 24ba65e9aa604b095c66452b6300520d3860b25560fcd554917f9bd43f1254ad8ff937fc408cc3af0ce5a04710dc5cccd66c6c00f7e5324d87f82746fefacfed

data/lib/inline_test_failure.rb

@@ -0,0 +1,16 @@
+class InlineTestFailure < StandardError
+  attr_accessor :test_type, :lhs, :rhs, :description
+
+  def initialize(test_type=nil, lhs=nil, rhs=nil, description=nil)
+    super [
+      "#{description} FAILED:",
+      "      test_type: #{test_type}",
+      "      lhs: #{lhs}",
+      "      rhs: #{rhs}"
+    ].join "\n"
+    self.test_type = test_type
+    self.lhs = lhs
+    self.rhs = rhs
+    self.description = description
+  end
+end

data/lib/inline_tests.rb

@@ -0,0 +1,62 @@
+require_relative './kernel_extensions'
+require_relative './method_extensions'
+
+require_relative './inline_test_failure'
+
+class InlineTests
+  def self.run!
+    test_passes = 0
+    test_fails  = 0
+
+    puts "Starting inline test suite:"
+    all_tests_start_time = Time.now
+    METHODS_WITH_INLINE_TESTS.each do |method|
+      # Kernel.class_variable_set(:@@method_being_tested, method)
+      
+      method_signature = if method.receiver.class.name === Object.name
+        # If the receiver is an Object, it's probably #main, in which case we can just print it directly
+        "#{method.receiver}::#{method.name}"
+
+      elsif method.receiver.class.name == Class.name
+        # If the receiver is the base Class, then we're dealing with a class method so we have a class ref already
+        "#{method.receiver.name}::self.#{method.name}"
+
+      else
+        # If the receiver is some child class class, we want to use the class name in printable output
+        "#{method.receiver.class.name}::#{method.name}"
+      end
+
+      start_time  = Time.now
+      begin
+        # TODO: it'd actually be great if we could bind #run_inline_tests to some context where all our
+        #       asserts/testing stuff is defined so we don't have to clutter up the global Kernel namespace
+        method.run_inline_tests # Throws an exception on fail
+        test_time    = Time.now - start_time
+        test_passes += 1
+
+        puts "  #{method_signature} - PASSED (#{format_tiny_time test_time} seconds)"
+
+      rescue InlineTestFailure => failure_information
+        test_time   = Time.now - start_time
+        errors      = failure_information
+        test_fails += 1
+
+        puts "  #{method_signature} - FAILED (#{format_tiny_time test_time} seconds)"
+        puts errors
+      end
+    end
+    all_tests_end_time = Time.now
+
+    # Print overall test results & stats
+    # print_results(method_passing, method_errors)
+    puts "#{METHODS_WITH_INLINE_TESTS.count} inline tests ran in #{format_tiny_time all_tests_end_time - all_tests_start_time} seconds."
+    puts "  #{test_passes} PASSED"
+    puts "  #{test_fails} FAILS"
+  end
+
+  private
+
+  def self.format_tiny_time(time)
+    sprintf('%.15f', time).sub(/0+$/, '').sub(/\.$/, '.0')
+  end
+end

data/lib/kernel_extensions.rb

@@ -0,0 +1,117 @@
+module Kernel
+  METHODS_WITH_INLINE_TESTS     = []
+
+  RUN_TESTS_IN_THIS_ENVIRONMENT = true
+
+  def tested(method_name, _ignored, &inline_test_block)
+    return unless RUN_TESTS_IN_THIS_ENVIRONMENT
+
+    # Hoist the method variable outside of the block below so we can access it afterwards
+    method = nil
+
+    # The method definition exists in a different scope dependent on whether we're in a class or not.
+    if self.class.name === Object.name
+      # We're in `main` scope
+      method = method(method_name)
+      
+    elsif self.class.name == Class.name
+      # We're in a class -- hunt for that method
+
+      if instance_methods.include?(method_name)
+        method = self.instance_method(method_name)
+
+        # Since the method is defined at script startup, it's an UnboundMethod until there's an instance to
+        # call it on. Obviously, need an instance to call it from during a test anyway, so we bind one here
+        # manually.
+        # TODO: this would be a great place to read defaults for some classes and apply attributes/defaults
+        #       upon creation
+        instance = self.new
+        method   = method.bind(instance)
+
+      elsif self.singleton_class.instance_methods.include?(method_name)
+        method = self.singleton_class.instance_method(method_name).bind(self)
+
+      end
+    end
+
+    # Register the method's tests to be run with InlineTests
+    method.inline_tests = inline_test_block
+    METHODS_WITH_INLINE_TESTS << method
+
+    method
+  end
+  def tests; end
+
+  # This is just syntax sugar for decorating methods that are untested / need tests
+  def untested(method_name); end
+
+  def assert(some_statement, description = '')
+    passed = !!some_statement
+    raise InlineTestFailure.new('assert', some_statement, nil, description) unless passed
+
+    passed
+  end
+
+  def assert_equal(lhs, rhs, description = '')
+    passed = !!flexible_assert(lhs, rhs, "[lhs] == [rhs]")
+    raise InlineTestFailure.new('assert_equal', lhs, rhs, description) unless passed
+
+    passed
+  end
+
+  def assert_not_equal(lhs, rhs, description = '')
+    passed = !!flexible_assert(lhs, rhs, "[lhs] != [rhs]")
+    raise InlineTestFailure.new('assert_not_equal', lhs, rhs, description) unless passed
+
+    passed
+  end
+
+  def assert_less_than(lhs, rhs, description = '')
+    passed = !!flexible_assert(lhs, rhs, "[lhs] < [rhs]")
+    raise InlineTestFailure.new('assert_less_than', lhs, rhs, description) unless passed
+    
+    passed
+  end
+
+  def assert_greater_than(lhs, rhs, description = '')
+    passed = !!flexible_assert(lhs, rhs, "[lhs] > [rhs]")
+    raise InlineTestFailure.new('assert_greater_than', lhs, rhs, description) unless passed
+    
+    passed
+  end
+
+  def assert_divisible_by(lhs, rhs, description = '')
+    passed = !!flexible_assert(lhs, rhs, "[lhs] % [rhs] == 0")
+    raise InlineTestFailure.new('assert_divisible_by', lhs, rhs, description) unless passed
+    
+    passed
+  end
+
+  # TODO: assert_positive
+  # TODO: assert_negative
+
+  # dirty hacks for global constants :(
+  module Infinity; def to_s; Float::INFINITY;     end; end
+  module NaN;      def to_s; 0 * Float::INFINITY; end; end
+
+  private
+
+  def flexible_assert(lhs, rhs, assert_logic)
+    lhs_values = lhs
+    # todo: probably want a custom testresults class instead of hash
+    lhs_values = lhs.values if lhs.is_a? Hash
+    lhs_values = Array(lhs_values) unless lhs_values.is_a? Array
+
+    rhs_values = rhs
+    rhs_values = rhs.values if rhs.is_a? Hash
+    rhs_values = Array(rhs_values) unless rhs_values.is_a? Array
+
+    lhs_values.all? do |lhs|
+      rhs_values.all? do |rhs|
+        generated_source = assert_logic.gsub('[lhs]', lhs.to_s).gsub('[rhs]', rhs.to_s)
+        # puts "Debug: Evaluating #{generated_source}"
+        eval generated_source
+      end
+    end
+  end
+end

data/lib/method_extensions.rb

@@ -0,0 +1,37 @@
+class Method
+  attr_accessor :inline_tests
+
+  # Expose a shorthand for .call
+  def [](*parameters)
+    homogenized_parameters = homogenized_list_of_arrays(parameters)
+
+    permutation_lookup = {}
+
+    all_range_permutations = permutations_of_list_of_ranges(homogenized_parameters)
+    all_range_permutations.each do |parameter_permutation|
+      permutation_lookup[parameter_permutation] = call(*parameter_permutation)
+    end
+
+    should_reduce_results = permutation_lookup.values.uniq.count == 1
+    if should_reduce_results
+      permutation_lookup.values.first
+    else
+      permutation_lookup
+    end
+  end
+
+  def run_inline_tests
+    inline_tests.call self if inline_tests && inline_tests.respond_to?(:call)
+  end
+
+  private
+
+  def homogenized_list_of_arrays(heterogenous_list)
+    heterogenous_list.map { |param| Array(param) }
+  end
+
+  def permutations_of_list_of_ranges(list_of_ranges)
+    receiver, *method_arguments = list_of_ranges
+    receiver.product(*method_arguments)
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: inline_tests
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Andrew Brown
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-04-13 00:00:00.000000000 Z
+dependencies: []
+description: A gem for including tests inline with the methods they test.
+email: andrew@indentlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/inline_test_failure.rb
+- lib/inline_tests.rb
+- lib/kernel_extensions.rb
+- lib/method_extensions.rb
+homepage: https://github.com/drusepth/inline-tests-gem
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: A gem for including tests inline with the methods they test.
+test_files: []