test_runner-assert 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2ad4a61cd4c9e7215b788fc7e00d56c845ea72c
+  data.tar.gz: 3b875c966207c7deccf95176bf046202c8aafa6f
+SHA512:
+  metadata.gz: f9e864c1933698e42c931e154a4b81fd1fd06b9fc17c636e561622574c9a7e5ea6c025df3a91d588c27da46d272a349ab3f1f51629850e5a67babe506b0fbb07
+  data.tar.gz: b7a313ef50f282b5705ee14518b14e2465a7e6efc592d28e7aaafec2fc0bd5b49cacfa213b04ddc9a0a564b0f44a4c1a7bf85e3e8f1f156da9ed1715919ded18

data/lib/test_runner/assert.rb

@@ -0,0 +1,21 @@
+require "test_runner"
+
+require_relative "assert/assertion"
+require_relative "assert/check"
+require_relative "assert/checks"
+require_relative "assert/errors"
+require_relative "assert/syntax"
+
+module TestRunner
+  module Assert
+    def self.inspect object, truncate = 100
+      raw = object.inspect
+      return raw if raw.size <= truncate
+      "#{raw[0..truncate - 2]} …\""
+    end
+  end
+
+  def self.included target
+    Assert::Syntax.infect target
+  end
+end

data/lib/test_runner/assert/assertion.rb

@@ -0,0 +1,116 @@
+module TestRunner
+  module Assert
+    class Assertion
+      attr_reader :fails
+      attr_reader :passes
+      attr_accessor :source
+
+      def initialize subject_proc, checks
+        @subject_proc = subject_proc
+        @checks = checks
+        @passes = []
+        @fails  = []
+        @trace = caller_locations
+      end
+
+      def call
+        perform_checks
+        freeze
+        raise to_error if failed?
+        subject
+      end
+
+      def build_checks
+        @checks.map do |check_name, argument|
+          TestRunner::Config.internal_logger.debug "Resolving check #{check_name.inspect}, arg=#{argument.inspect}"
+          resolve_check check_name, argument
+        end
+      end
+
+      def failed?
+        fails.any?
+      end
+
+      def file
+        @trace[0].path
+      end
+
+      def freeze
+        passes.freeze
+        fails.freeze
+      end
+
+      def line
+        @trace[0].lineno
+      end
+
+      def passed?
+        not failed?
+      end
+
+      def perform_checks
+        build_checks.each do |check|
+          check.evaluate
+          ary = if check.passed? then passes else fails end
+          ary.push check
+        end
+      end
+
+      def resolve_check check_name, argument
+        check = Checks.resolve check_name do
+          check_name = :include if check_name == :includes
+          argument = [check_name, *argument]
+          Checks[:predicate]
+        end
+        check.new subject_thunk, argument
+      end
+
+      def subject
+        subject_thunk.call
+      end
+
+      def subject_thunk
+        @subject_thunk ||= SubjectThunk.new @subject_proc
+      end
+
+      def to_error
+        AssertionFailed.new self
+      end
+
+      def trace
+        BacktraceFilter.(@trace)
+      end
+
+      class Refutation < Assertion
+        def build_checks
+          super.each &:negate
+        end
+      end
+
+      class SubjectThunk
+        def initialize block
+          @block = block
+        end
+
+        def call
+          return @subject if subject_resolved?
+          @subject = @block.call
+        end
+
+        def expect_error
+          raise "called after initially fetched" if subject_resolved?
+          @block.call
+          nothing_raised = true
+        rescue => error
+          @subject = error
+        ensure
+          raise NothingRaised.new if nothing_raised
+        end
+
+        def subject_resolved?
+          instance_variable_defined? :@subject
+        end
+      end
+    end
+  end
+end

data/lib/test_runner/assert/check.rb

@@ -0,0 +1,53 @@
+module TestRunner
+  module Assert
+    class Check
+      singleton_class.send :attr_reader, :block, :name
+
+      attr :argument
+
+      def initialize subject_thunk, argument
+        @argument = argument
+        @subject_thunk = subject_thunk
+      end
+
+      def evaluate
+        self.class.block.call self, @argument
+        freeze
+      end
+
+      def expect_error
+        @subject_thunk.expect_error
+      end
+
+      def fail message
+        passed = negated? ^ yield
+        @fail_message = message unless passed
+      end
+
+      def fail_message
+        "expected #{Assert.inspect subject} to#{" not" if negated?} #{@fail_message}"
+      end
+
+      def failed?
+        @fail_message ? true : false
+      end
+
+      def negated?
+        @negated ? true : false
+      end
+
+      def negate
+        @negated = !@negated
+      end
+
+      def passed?
+        not failed?
+      end
+
+      def subject
+        @expected_error or @subject_thunk.call
+      end
+
+    end
+  end
+end

data/lib/test_runner/assert/checks.rb

@@ -0,0 +1,76 @@
+module TestRunner
+  module Assert
+    module Checks
+      require_relative "checks/registry"
+      extend Registry
+
+      register :equals do |check, object|
+        obj_inspect = Assert.inspect object
+
+        if Assert.inspect(check.subject) == obj_inspect and not check.negated?
+          fail_message = "equal other object (no difference in #inspect output)"
+        else
+          fail_message = "equal #{obj_inspect}"
+        end
+
+        check.fail fail_message do check.subject == object end
+      end
+
+      register :included_in do |check, list|
+        check.fail "be included in #{Assert.inspect list}" do
+          list.include? check.subject
+        end
+      end
+
+      register :kind_of do |check, type|
+        check.fail "be a kind of #{type}" do
+          check.subject.kind_of? type
+        end
+      end
+
+      register :matches do |check, matcher|
+        check.fail "match #{Assert.inspect matcher}" do
+          check.subject.match matcher
+        end
+      end
+
+      register :predicate do |check, argument|
+        name, *args = argument
+        method_name =  "#{name}?"
+        method = check.subject.method method_name
+
+        if method.arity == 0
+          expect_truth = args.all?
+          message = "be #{name}"
+          result = check.subject.public_send method_name
+          result = result ^ !expect_truth
+        else
+          result = check.subject.public_send method_name, *args
+          args = args.map &Assert.method(:inspect)
+          message = "#{name} #{args * ', '}"
+        end
+
+        check.fail message do result end
+      end
+
+      register :raises do |check, error_type|
+        check.expect_error
+        check.fail "be a #{Assert.inspect error_type}" do
+          check.subject.is_a? error_type
+        end
+      end
+
+      register :responds_to do |check, method_name|
+        check.fail "respond to ##{method_name}" do
+          check.subject.respond_to? method_name
+        end
+      end
+
+      register :truthy do |check, arg|
+        check.fail "be #{arg ? "truthy" : "falsey"}" do
+          !arg ^ check.subject
+        end
+      end
+    end
+  end
+end

data/lib/test_runner/assert/checks/registry.rb

@@ -0,0 +1,31 @@
+module TestRunner
+  module Assert
+    module Checks
+      module Registry
+        def self.extended base
+          base.instance_variable_set :@registry, {}
+        end
+
+        def self.define check_name, block
+          klass = Class.new Check
+          klass.instance_variable_set :@block, block
+          constant_name = Util.to_camel_case check_name
+          const_set constant_name, klass
+          klass
+        end
+
+        attr :registry
+
+        def register check_name, &block
+          registry[check_name] = Registry.define check_name, block
+        end
+
+        def resolve check_name, &block
+          block ||= -> * do raise MissingCheck.new check_name end
+          registry.fetch check_name, &block
+        end
+        alias_method :[], :resolve
+      end
+    end
+  end
+end

data/lib/test_runner/assert/errors.rb

@@ -0,0 +1,46 @@
+module TestRunner
+  module Assert
+    Error ||= Class.new StandardError
+
+    class AssertionFailed < Error
+      attr :assertion
+
+      def initialize assertion
+        @assertion = assertion
+      end
+
+      def backtrace
+        assertion.trace.map &:to_s
+      end
+
+      def to_s
+        failures = assertion.fails.map do |failed_check|
+          failed_check.fail_message
+        end
+        if failures.size > 1
+          "Assertion failure:\n\n    * #{failures * "\n    * "}\n"
+        else
+          "Assertion failure: #{failures * ", "}"
+        end
+      end
+    end
+
+    class MissingCheck < Error
+      attr :check_name
+
+      def initialize check_name
+        @check_name = check_name
+      end
+
+      def to_s
+        "could not resolve check #{check_name.inspect}"
+      end
+    end
+
+    class NothingRaised < Error
+      def to_s
+        "expected subject block to raise an error"
+      end
+    end
+  end
+end

data/lib/test_runner/assert/syntax.rb

@@ -0,0 +1,94 @@
+module TestRunner
+  module Assert
+    class Syntax < Module
+      MISSING = :__test_runner_assert_arg_missing__
+
+      class << self
+        def infect target
+          instance = new
+          if target.is_a? Class
+            target.send :include, instance
+          else
+            target.extend instance
+          end
+        end
+
+        # Public: assert is designed to be called a number of different ways,
+        # from 0 to 2 positional arguments, and maybe a block.
+        #
+        # subject_or_checks - the first optional argument passed in
+        # checks - the second optional argument passed in
+        # block - the &block parameter
+        #
+        # Valid examples:
+        #
+        #   assert :raises => Error do … end
+        #   assert "foo"
+        #   assert 3, :included_in => [6, 3]
+        #   assert [6, 3], :includes => 3
+        #   assert :equal => 4 do 2 + 2 end
+        #
+        # Invalid examples:
+        #
+        #   # Can't determine if the block or 2 is the subject
+        #   assert 2, :equals => 4 do ̒… end 
+        #   # There's no subject at all
+        #   assert :incuded_in => 4
+        #
+        # Returns two arguments, the subject, and a checks hash. If the checks
+        # would be empty, returns { :truthy => true }. The subject will always be
+        # a Proc that gets lazy evaluated when the assertion is checked.
+        def decode_assert_arguments subject_or_checks, checks, block
+          if checks == MISSING
+            if subject_or_checks == MISSING
+              missing_subject! unless block
+              subject_thunk = block
+              checks = { :truthy => true }
+            elsif block
+              ambiguous_subject! unless subject_or_checks.is_a? Hash
+              subject_thunk = block
+              checks = subject_or_checks
+            else
+              subject_thunk = -> do subject_or_checks end
+              checks = { :truthy => true }
+            end
+          else
+            ambiguous_subject! if block
+            subject_thunk = -> do subject_or_checks end
+          end
+          [subject_thunk, checks]
+        end
+
+        def ambiguous_subject!
+          raise ArgumentError, "cannot supply a block subject *and* a positional subject"
+        end
+
+        def missing_subject!
+          raise ArgumentError, "must supply either a positional subject *or* a block subject (but not both)"
+        end
+      end
+
+      def extended base
+        graft base.singleton_class
+      end
+
+      def included base
+        graft base
+      end
+
+      def graft base
+        method_body = -> method_name, assertion_class, syntax do
+          define_method method_name do |arg1 = MISSING, arg2 = MISSING, &block|
+            subject_thunk, checks = syntax.decode_assert_arguments arg1, arg2, block
+            assertion = assertion_class.new subject_thunk, checks
+            assertion.source = self
+            assertion.()
+          end
+        end
+
+        base.class_exec :assert, Assertion, self.class, &method_body
+        base.class_exec :refute, Assertion::Refutation, self.class, &method_body
+      end
+    end
+  end
+end

data/lib/test_runner/plugin.rb

@@ -0,0 +1 @@
+require "test_runner/assert"

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: test_runner-assert
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nathan Ladd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-runner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds a powerful and simple assert implementation to test-runner
+email: nathanladd+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/test_runner/assert.rb
+- lib/test_runner/assert/assertion.rb
+- lib/test_runner/assert/check.rb
+- lib/test_runner/assert/checks.rb
+- lib/test_runner/assert/checks/registry.rb
+- lib/test_runner/assert/errors.rb
+- lib/test_runner/assert/syntax.rb
+- lib/test_runner/plugin.rb
+homepage: https://github.com/ntl/test-runner
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Adds a powerful and simple assert implementation to test-runner
+test_files: []