speq 0.3.0 → 0.4.0

data/lib/speq/action.rb

@@ -1,97 +0,0 @@
-require 'speq'
-
-module Speq
-  class Action
-    attr_accessor :test_group, :message_queue, :receiver, :arguments_queue
-
-    def initialize(
-      test_group,
-      receiver = Object,
-      messages = [:itself],
-      arguments = [{ args: [], block: nil }]
-    )
-      @test_group = test_group
-
-      @message_queue = messages
-      @arguments_queue = arguments
-      @receiver = receiver
-    end
-
-    def method_missing(method, *args, &block)
-      if method.to_s.end_with?('?')
-        matcher = Matcher.send(method, *args, &block)
-        @test_group << Unit.new(clone, matcher)
-      else
-        super
-      end
-    end
-
-    def clone
-      self.class.new(
-        test_group,
-        receiver,
-        message_queue.clone,
-        arguments_queue.clone
-      )
-    end
-
-    def result
-      until @message_queue.empty?
-        args = arguments_queue.shift
-        message = message_queue.shift
-
-        @receiver = receiver.send(message, *args[:args], &args[:block])
-      end
-
-      @receiver
-    end
-
-    def on(receiver, description = nil)
-      @receiver = receiver
-      Speq.descriptions[receiver] = description || receiver
-      self
-    end
-
-    def does(*messages)
-      messages.each do |message|
-        message_queue.push(message)
-        arguments_queue.push(args: [], block: nil)
-      end
-
-      self
-    end
-
-    def with(*args, &block)
-      arguments_queue.last[:args] = args
-      arguments_queue.last[:block] = block
-
-      self
-    end
-
-    def format_arguments
-      arguments = arguments_queue.last
-      argument_description = ''
-
-      unless arguments[:args].empty?
-        argument_description << "with '#{arguments[:args].join(', ')}'"
-      end
-
-      argument_description << ' and a block' if arguments[:block]
-
-      argument_description
-    end
-
-    def format_receiver
-      Speq.descriptions[receiver] ? "on '#{Speq.descriptions[receiver]}'" : ''
-    end
-
-    def to_s
-      [message_queue.last, format_arguments, format_receiver]
-        .reject(&:empty?)
-        .join(' ')
-    end
-
-    alias is does
-    alias of with
-  end
-end

data/lib/speq/fake.rb

@@ -1,22 +0,0 @@
-# The Fake class is a lightweight, general-purpose test double
-module Speq
-  class Fake
-    def initialize(mapping)
-      mapping.each do |method_name, return_value|
-        define_singleton_method(method_name, &infer_method_body(return_value))
-      end
-    end
-
-    def infer_method_body(return_value)
-      if return_value.respond_to?(:call)
-        return_value
-      else
-        -> { return_value }
-      end
-    end
-
-    def to_s
-      description = send(:class) == self.class ? 'a fake' : "a fake#{send(:class)}"
-    end
-  end
-end

data/lib/speq/matcher.rb

@@ -1,93 +0,0 @@
-# The Match class includes factory methods for generating objects that
-# respond to match, returning true for an expected return value of a unit test
-module Speq
-  class Matcher
-    def initialize(expectation, phrase)
-      @expectation = expectation
-      @phrase = phrase
-    end
-
-    def match?(actual)
-      @actual = actual
-      @expectation[actual]
-    end
-
-    def to_s
-      @phrase[@actual]
-    end
-
-    def self.method_missing(method_name, *args, &block)
-      if method_name.to_s.end_with?('?')
-        dynamic_matcher(method_name, *args, &block)
-
-      else
-        super
-      end
-    end
-
-    def self.dynamic_matcher(method_name, *args, &block)
-      Matcher.new(
-        ->(object) { object.send(method_name, *args, &block) },
-        proc { "passes: #{method_name}" }
-      )
-    end
-
-    def self.pass?(&prc)
-      Matcher.new(prc)
-    end
-
-    def self.true?
-      Matcher.eq?(true)
-    end
-
-    def self.truthy?
-      Matcher.new(->(actual_value) { actual_value ? true : false })
-    end
-
-    def self.falsy?
-      Matcher.new(->(actual_value) { actual_value ? false : true })
-    end
-
-    def self.eq?(expected_value)
-      Matcher.new(
-        ->(actual_value) { expected_value.eql?(actual_value) },
-        ->(actual_value) { "equals #{actual_value}" }
-      )
-    end
-
-    def self.have?(*symbols, **key_value_pairs)
-      new(
-        lambda do |object|
-          symbols.each { |symbol| return false unless object.respond_to?(symbol) }
-          key_value_pairs.each { |key, value| return false unless object.send(key) == value }
-        end,
-        proc do
-          properties = symbols.empty? ? '' : symbols.join(' ') + ', '
-          values = key_value_pairs.map { |key, value| "#{key}: #{value}" }.join(' ')
-          "has #{properties}#{values}"
-        end
-      )
-    end
-
-    def self.raise?(expected_except)
-      case expected_except
-      when Class
-        raise_class(expected_except)
-      when String
-        raise_message(expected_except)
-      else
-        raise ArgumentError
-      end
-    end
-
-    def self.raise_class(expected_error)
-      Matcher.new(->(actual_except) { actual_except.class <= expected_error })
-    end
-
-    def self.raise_message(expected_message)
-      Matcher.new(
-        ->(actual_except) { actual_except.message == expected_message }
-      )
-    end
-  end
-end

data/lib/speq/report.rb

@@ -1,24 +0,0 @@
-# The Report class produces and prints a report per test group
-module Speq
-  class Report
-    def initialize(tests)
-      @units = tests.flat_map(&:units)
-      @passed = []
-      @failed = []
-    end
-
-    def print_report
-      @units.each do |unit|
-        if unit.passed?
-          @passed << unit.to_s.colorize(:green)
-        else
-          @failed << unit.to_s.colorize(:red)
-        end
-      end
-
-      puts "Passed (#{@passed.length}/#{@units.length})" unless @passed.empty?
-      puts @passed
-      puts "Failed (#{@failed.length}/#{@units.length})" unless @failed.empty?
-    end
-  end
-end

data/lib/speq/test.rb

@@ -1,21 +0,0 @@
-require 'speq/action'
-
-# A
-module Speq
-  class Test
-    attr_reader :units
-
-    def initialize
-      @units = []
-    end
-
-    def passed?
-      @units.all?(&:passed?)
-    end
-
-    def <<(unit)
-      @units << unit
-      self
-    end
-  end
-end

data/lib/speq/unit.rb

@@ -1,24 +0,0 @@
-require 'speq/action'
-
-# The Unit class is responsible for running a test and storing the result
-module Speq
-  class Unit
-    attr_reader :result, :action, :matcher
-
-    def initialize(action, matcher)
-      @action = action
-      @matcher = matcher
-      @result = matcher.match?(action.clone.result)
-    rescue StandardError => exception
-      @result = matcher.match?(exception)
-    end
-
-    def passed?
-      @result
-    end
-
-    def to_s
-      "#{action} #{matcher}"
-    end
-  end
-end