attestify 0.1.0.pre.1

data/lib/attestify/assertions/output_assertion.rb

@@ -0,0 +1,62 @@
+module Attestify
+  module Assertions
+    # A helper class for Attestify::Assertions#assert_output.
+    class OutputAssertion
+      def initialize(expected_stdout, expected_stderr, stdout, stderr, message)
+        @expected_stdout = expected_stdout
+        @expected_stderr = expected_stderr
+        @stdout = stdout
+        @stderr = stderr
+        @message = message
+      end
+
+      def assert
+        assert_stdout && assert_stderr
+      end
+
+      def message
+        return @message if @message
+        messages = [stdout_message, stderr_message]
+        "Expected #{messages.compact.join(", and ")}"
+      end
+
+      private
+
+      def assert_stdout
+        assert_output(@expected_stdout, @stdout)
+      end
+
+      def assert_stderr
+        assert_output(@expected_stderr, @stderr)
+      end
+
+      def assert_output(expected, actual)
+        return true unless expected
+
+        if expected.is_a?(String)
+          expected == actual
+        else
+          actual =~ expected
+        end
+      end
+
+      def stdout_message
+        output_message("$stdout", @expected_stdout, @stdout)
+      end
+
+      def stderr_message
+        output_message("$stderr", @expected_stderr, @stderr)
+      end
+
+      def output_message(label, expected, actual)
+        return nil unless expected
+
+        if expected.is_a?(String)
+          "#{label}: #{expected.inspect} == #{actual.inspect}"
+        else
+          "#{label}: #{actual.inspect} =~ #{expected.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/attestify/cli.rb

@@ -0,0 +1,84 @@
+require "attestify"
+require "optparse"
+
+module Attestify
+  # Command Line Interface for running Attestify tests.
+  class CLI
+    def initialize(args = ARGV)
+      @args = args
+      @exit_code = true
+    end
+
+    def self.start
+      new.start
+    end
+
+    def test_list
+      @test_list ||= Attestify::TestList.new(@args, dir: options[:directory])
+    end
+
+    def reporter
+      @reporter ||=
+        if options[:color]
+          Attestify::ColorReporter.new
+        else
+          Attestify::Reporter.new
+        end
+    end
+
+    def options
+      @options ||= {
+        color: true
+      }
+    end
+
+    def option_parser # rubocop:disable Metrics/MethodLength
+      @option_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: attestify [options] [test_files ...]"
+
+        opts.on("-c", "--color", "Run with color") do
+          options[:color] = true
+        end
+
+        opts.on("-C", "--no-color", "Run without color") do
+          options[:color] = false
+        end
+
+        opts.on("-d", "--directory [DIR]", "Run the tests in the provided DIR") do |dir|
+          options[:directory] = dir
+        end
+
+        opts.on("-h", "--help", "Output this help") do
+          puts opts
+          ignore_reporting
+          exit
+        end
+      end
+    end
+
+    def ignore_reporting
+      @ignore_reporting = true
+    end
+
+    def parse_arguments
+      option_parser.parse!(@args)
+    end
+
+    def start
+      timer = Attestify::Timer.time { run }
+    rescue => e
+      @exit_code = 2
+      STDERR.puts("Error running tests: #{e}\n  #{e.backtrace.join("\n  ")}")
+    ensure
+      reporter.timer = timer
+      reporter.report unless @ignore_reporting
+      exit(@exit_code)
+    end
+
+    def run
+      parse_arguments
+      Attestify::TestRunner.new(test_list, reporter).run
+      @exit_code = 1 unless reporter.passed?
+    end
+  end
+end

data/lib/attestify/color_reporter.rb

@@ -0,0 +1,127 @@
+require "attestify"
+
+module Attestify
+  # Reports results to the console, with color!
+  class ColorReporter < Attestify::Reporter # rubocop:disable Metrics/ClassLength
+    private
+
+    def puts_failure_header(result, number)
+      print color_code(color_for(result))
+      super
+      print color_code(:reset)
+    end
+
+    def puts_failure_detail(failure_detail, number, sub_number)
+      print color_code(color_for_detail(failure_detail))
+      super
+      print color_code(:reset)
+    end
+
+    def print_result_code(result)
+      print color_code(color_for(result))
+      super
+      print color_code(:reset)
+    end
+
+    def total_tests
+      colorize_from_totals(super)
+    end
+
+    def total_failures
+      colorize_if_positive(super, @total_failures, :red)
+    end
+
+    def total_errors
+      colorize_if_positive(super, @total_errors, :bold_red)
+    end
+
+    def total_skips
+      colorize_if_positive(super, @total_skips, :yellow)
+    end
+
+    def total_assertions
+      colorize_from_totals(super)
+    end
+
+    def total_failed_assertions
+      colorize_if_positive(super, @total_failed_assertions, :red)
+    end
+
+    def rerun_test_command(result)
+      colorize(super, color_for(result))
+    end
+
+    def comment(message)
+      colorize(super, :cyan)
+    end
+
+    def colorize_from_totals(text) # rubocop:disable Metrics/MethodLength
+      color =
+        if @total_errors > 0
+          :bold_red
+        elsif @total_failures > 0
+          :red
+        elsif @total_skips > 0
+          :yellow
+        else
+          :green
+        end
+
+      colorize(text, color)
+    end
+
+    def colorize_if_positive(text, amount, color)
+      if amount > 0
+        colorize(text, color)
+      else
+        text
+      end
+    end
+
+    def colorize(text, color)
+      "#{color_code(color)}#{text}#{color_code(:reset)}"
+    end
+
+    def color_code(color) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      case color
+      when :reset
+        "\e[0m"
+      when :bold_red
+        "\e[1;31m"
+      when :red
+        "\e[31m"
+      when :yellow
+        "\e[33m"
+      when :green
+        "\e[32m"
+      when :cyan
+        "\e[36m"
+      end
+    end
+
+    def color_for(result) # rubocop:disable Metrics/MethodLength
+      if result.skipped?
+        :yellow
+      elsif result.passed?
+        :green
+      elsif result.errored?
+        :bold_red
+      elsif result.failed?
+        :red
+      else
+        :none
+      end
+    end
+
+    def color_for_detail(failure_detail)
+      case failure_detail.type
+      when :error
+        :bold_red
+      when :failure
+        :red
+      else
+        :none
+      end
+    end
+  end
+end

data/lib/attestify/mock.rb

@@ -0,0 +1,118 @@
+module Attestify
+  # Simple class for mocking objects.
+  class Mock
+    def initialize(test_or_assertions)
+      @assertions = test_or_assertions
+      @assertions = test_or_assertions.assertions if test_or_assertions.respond_to?(:assertions)
+      @expectations_hash = Hash.new { |hash, key| hash[key] = [] }
+      @expectations = []
+      @called_expectations = []
+    end
+
+    def expect(name, return_value, args = [], &block)
+      name = name.to_sym
+      expectation = Attestify::Mock::ExpectedCall.new(name, return_value, args, block)
+      @expectations << expectation
+      @expectations_hash[name.to_sym] << expectation
+      self
+    end
+
+    def verify
+      @called_expectations.each { |x| x.verify(@assertions) }
+      @expectations.reject(&:called?).each { |x| x.verify(@assertions) }
+    end
+
+    def method_missing(method, *args, &block)
+      expectation =
+        if @expectations_hash[method].empty?
+          UnexpectedCall.new(method, args, block)
+        else
+          @expectations_hash[method].shift
+        end
+
+      @called_expectations << expectation
+      expectation.call(args, block)
+    end
+
+    # A base class for both ExpectedCall and UnexpectedCall.
+    class CallExpectation
+      attr_reader :name, :return_value, :args, :block, :actual_args, :actual_block
+
+      def initialize(name, return_value, args, block)
+        @called = false
+        @name = name
+        @return_value = return_value
+        @args = args
+        @block = block
+      end
+
+      def called?
+        @called
+      end
+
+      def call(actual_args, actual_block)
+        @called = true
+        @actual_args = actual_args
+        @actual_block = actual_block
+        block.call(*actual_args, &actual_block) if block
+        return_value
+      end
+
+      def to_s(style = :expected)
+        if style == :expected
+          "#{name}(#{args.map(&:inspect).join(", ")})"
+        else
+          with_block = " { ... }" if actual_block
+          "#{name}(#{actual_args.map(&:inspect).join(", ")})#{with_block}"
+        end
+      end
+    end
+
+    # Contains a mock's method call expectation.
+    class ExpectedCall < CallExpectation
+      def call(args, block)
+        result = super
+        @caller_locations = caller_locations(2) unless arguments_valid?
+        result
+      end
+
+      def verify(assertions)
+        if !called?
+          assertions.record(false, "Missing expected call to mock: #{self}", @caller_locations)
+        elsif !arguments_valid?
+          assertions.record(false, "Expected call to mock: #{self}, but got: #{to_s(:actual)}", @caller_locations)
+        else
+          assertions.record(true)
+        end
+      end
+
+      private
+
+      def arguments_valid?
+        return false unless args.size == actual_args.size
+
+        args.each_with_index do |arg, i|
+          return false unless arg === actual_args[i] # rubocop:disable Style/CaseEquality
+        end
+
+        true
+      end
+    end
+
+    # A method call that wasn't expected.
+    class UnexpectedCall < CallExpectation
+      def initialize(name, args, block)
+        super(name, nil, args, block)
+      end
+
+      def call(args, block)
+        @caller_locations = caller_locations(2)
+        super
+      end
+
+      def verify(assertions)
+        assertions.record(false, "Unexpected call to mock: #{to_s(:actual)}", @caller_locations)
+      end
+    end
+  end
+end

data/lib/attestify/rake_task.rb

@@ -0,0 +1,29 @@
+require "rake"
+require "rake/tasklib"
+
+module Attestify
+  # Rake task to run Attestify tests.
+  class RakeTask < Rake::TaskLib
+    attr_reader :name
+
+    def initialize(*args, &block)
+      @name = args.shift || :test
+      define(args, &block)
+    end
+
+    def run_task
+      Attestify::CLI.new([]).start
+    end
+
+    private
+
+    def define(args)
+      desc "Run Attestify tests" unless Rake.application.last_description
+
+      task name, *args do |_, task_args|
+        yield(self, task_args) if block_given?
+        run_task
+      end
+    end
+  end
+end

data/lib/attestify/reporter.rb

@@ -0,0 +1,171 @@
+require "pathname"
+
+module Attestify
+  # Reports results to the console.
+  class Reporter # rubocop:disable Metrics/ClassLength
+    attr_accessor :timer
+
+    def initialize
+      @failures = []
+      @total_tests = 0
+      @total_assertions = 0
+      @total_failed_assertions = 0
+      @total_failures = 0
+      @total_errors = 0
+      @total_skips = 0
+    end
+
+    def passed?
+      @total_failures + @total_errors == 0
+    end
+
+    def record(result)
+      add_to_totals(result)
+      @failures << result if !result.skipped? && !result.passed?
+      print_result_code(result)
+    end
+
+    def report
+      puts_failures
+      puts_footer
+    end
+
+    private
+
+    def add_to_totals(result)
+      @total_tests += 1
+      @total_assertions += result.assertions.total
+      @total_failed_assertions += result.assertions.failed
+
+      if result.skipped?
+        @total_skips += 1
+      elsif result.errored?
+        @total_errors += 1
+      elsif result.failed?
+        @total_failures += 1
+      end
+    end
+
+    def print_result_code(result)
+      print result.result_code
+    end
+
+    def record_failure(result)
+      @failures << result
+
+      if result.assertions.errored?
+        @total_errors += 1
+      else
+        @total_failures += 1
+      end
+    end
+
+    def puts_failures
+      puts
+
+      @failures.each_with_index do |failure, i|
+        puts_failure(failure, i + 1)
+      end
+    end
+
+    def puts_failure(failure, number)
+      puts
+      puts_failure_header(failure, number)
+      puts_failure_details(failure, number)
+    end
+
+    def puts_failure_header(failure, number)
+      puts "#{number}) #{failure.name}"
+    end
+
+    def puts_failure_details(failure, number)
+      failure.assertions.failure_details.each_with_index do |failure_detail, i|
+        puts_failure_detail(failure_detail, number, i + 1)
+      end
+    end
+
+    def puts_failure_detail(failure_detail, number, sub_number)
+      puts
+      puts "  #{number}.#{sub_number}) #{failure_detail.message}"
+      puts "    #{failure_detail.backtrace_locations.join("\n    ")}"
+    end
+
+    def puts_footer
+      puts
+      puts "Finished in #{elapsed_time}, #{tests_per_second}, #{assertions_per_second}"
+      puts "#{total_tests}, #{total_failures}, #{total_errors}, #{total_skips}, " \
+           "#{total_assertions}, #{total_failed_assertions}"
+      puts_failure_reruns
+    end
+
+    def elapsed_time
+      timer || "?"
+    end
+
+    def tests_per_second
+      if timer
+        format("%.1f tests/second", @total_tests.to_f / timer.duration)
+      else
+        "? tests/second"
+      end
+    end
+
+    def assertions_per_second
+      if timer
+        format("%.1f assertions/second", @total_assertions.to_f / timer.duration)
+      else
+        "? assertions/second"
+      end
+    end
+
+    def total_tests
+      "#{@total_tests} tests"
+    end
+
+    def total_failures
+      "#{@total_failures} failures"
+    end
+
+    def total_errors
+      "#{@total_errors} errors"
+    end
+
+    def total_skips
+      "#{@total_skips} skips"
+    end
+
+    def total_assertions
+      "#{@total_assertions} assertions"
+    end
+
+    def total_failed_assertions
+      "#{@total_failed_assertions} failed assertions"
+    end
+
+    def puts_failure_reruns
+      puts
+      puts "Failed tests:"
+      puts
+
+      @failures.each do |failure|
+        puts_failure_rerun(failure)
+      end
+    end
+
+    def puts_failure_rerun(failure)
+      puts "#{rerun_test_command(failure)} #{comment(failure.name)}"
+    end
+
+    def rerun_test_command(failure)
+      # TODO: Should I create a new method to get the test method...?
+      test_method = failure.instance_variable_get(:@_test_method)
+      source = failure.method(test_method).source_location
+      source[0] = Pathname.new(File.realpath(source[0])).relative_path_from(Pathname.new(File.realpath(".")))
+      "attestify #{source.join(":")}"
+    end
+
+    def comment(message)
+      "# #{message}"
+    end
+  end
+end