speq 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32ff60fc943c04afc5c85f9b49c020a08f0e38720eed9f02c7be16aa9e4c1777
-  data.tar.gz: b5622c58ca6fd050185092fc4a6fda473393ebdf6d33dc1a8cd1a176c2cbcce6
+  metadata.gz: ca948589baaf3fd6d4385aec6da046cb0b96595ea1cc78af59787bf76112abe0
+  data.tar.gz: 5879601e06032198afc0675b44130900b3fdbb895f207cab7c2cfc94b70638fb
 SHA512:
-  metadata.gz: e088259968e6271760e885a1aef4e90b23b93073633c9828d8e2c241735ae79d4be980f0055b21aabfbf4883f79aec37632ac8e27987b5cf6c099f6aeda6ec2a
-  data.tar.gz: 316856e55388a2baf6b919da7c017a7bf3fcdabbac396a3adeabad8842ae675d57a53a5ee1c03a932d38f6e4c97955bd6c1b23b9c5c9f43742c50b53bdae576c
+  metadata.gz: 8f999677ac2de3f9e9760cfebe7180d1cb91215060a6f424f0c856f981ba9818715105b13dc1353d1b43d1fb9382b6c2189a0f31f64d50b21999b8ecb4bd4e23
+  data.tar.gz: 1f674c4b2593df191a9d036b0f458cf1aee46f342066667f5df33504bd70e5cfb30858f3fdc208229f0a87741d36fd9b7785e5a05234bb2a0e4f85556c8ffb18

data/.gitignore

@@ -6,3 +6,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+.vscode

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    speq (0.2.0)
+    speq (0.2.1)
       colorize (~> 0.8.1)
 
 GEM

data/README.md

@@ -16,21 +16,24 @@ gem 'speq'
 
 And then execute:
 
-    $ bundle
+    bundle
 
 Or install it yourself as:
 
-    $ gem install speq
+    gem install speq
+
+## Design
+
+Speq's design choices are influenced by the competing motivations of having tests be as short and simple as possible while maintaining the flexibility to be as descriptive as needed.
+
+Speq is loosely based on the given-when-then or arrange-act-assert testing pattern. Whereas one would typically need to make each step explicit, Speq tests focus on making it easy to simply assert the expected behavior with an implicit arrangement and action.
 
 ## Syntax
 
-Speq excels at running many similar tests and checks. It omits explicit descriptions and outputs simple reports.
+Speq's syntax is still in flux and likely to change dramatically until an effective setup is established.
 
 ```ruby
-does :prime? do
-  given 0, 1, 8, match: false
-  given 2, 3, 97, match: true
-end
+test_unit :sort, on: [3, 2, 1], eq: [1, 2, 3]
 ```
 
 ## Usage
@@ -40,30 +43,24 @@ end
 ```ruby
 require 'speq'
 
-class Array
-  def my_map
-    Array.new(length) { |index| yield(self[index])}
-  end
+Speq.test do
+  # Tests here can access local variables.
+  # Test results are printed to $stdout.
+  # The method returns true if all tests pass, false otherwise.
 end
-
-# Speq.test...
 ```
 
 ### With dedicated spec files
 
 Speq also offers a simple CLI that lets you run tests written in dedicated spec files.
 
-Executing the following command:
-
-    $ bundle exec speq
-
-will recursively search the working directory and run all files that end with `_speq.rb`.
+Executing `bundle exec speq` will recursively search the working directory and run all files that end with `_speq.rb`.
 
 To run individual files, specify a list of speq file prefixes. For example, to run tests that are within the files `example_speq.rb` and `sample_speq.rb`, simply execute:
 
-    $ bundle exec speq example sample
+    bundle exec speq example sample
 
-Speq files are not expected to require `speq`, but they should require other files that may be needed to run the speqs.
+Speq files are not expected to require `speq`, but they should require other files that may be needed to run the specs.
 
 ## Contributing
 

data/bin/console

@@ -4,6 +4,5 @@ require 'bundler/setup'
 require 'pry'
 
 require 'speq'
-include Speq
 
 Pry.start

data/exe/speq

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 
-require 'speq/cli'
+require 'speq'
 Speq::CLI.new(ARGV).run

data/lib/speq/cli.rb

@@ -1,6 +1,5 @@
 require 'find'
 require 'colorize'
-require 'speq/test'
 
 # Provides a CLI for running Speq
 module Speq
@@ -18,12 +17,8 @@ module Speq
       Dir.glob("#{Dir.pwd}/**/{#{file_prefixes.join(',')}}_speq.rb")
     end
 
-    def does(subject, &block)
-      tests << Test.new(subject, self, &block)
-    end
-
     def run
-      @files.each { |file| instance_eval(File.read(file), file) }
+      @files.each { |file| Speq.module_eval(File.read(file), file) }
       @tests.each(&:report)
       @tests.all?(&:passed?)
     end

data/lib/speq/fake.rb

@@ -1,5 +1,18 @@
 # The Fake class inludes a variety of doubles, mocks, stubs, etc.
 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
   end
 end

data/lib/speq/matcher.rb

@@ -0,0 +1,50 @@
+# 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(expected)
+      @expected = expected
+    end
+
+    def match(actual)
+      @expected[actual]
+    end
+
+    def self.truthy
+      Matcher.new(->(actual_value) { actual_value ? true : false })
+    end
+
+    def self.falsey
+      Matcher.new(->(actual_value) { actual_value ? false : true })
+    end
+
+    def self.eq(expected_value)
+      Matcher.new(->(actual_value) { expected_value.eql?(actual_value) })
+    end
+
+    def self.is(expected_object)
+      Matcher.new(->(actual_object) { expected_object.equal?(actual_object) })
+    end
+
+    def self.raises(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

@@ -0,0 +1,31 @@
+# The Report class produces and prints a report per test group
+module Speq
+  class Report
+    def initialize(units)
+      @units = units
+    end
+
+    def print_report
+      report_string = ''
+
+      @units.each do |unit|
+        if unit.passed?
+          outcome = 'PASSED: '
+          color = :green
+        else
+          outcome = 'FAILED: '
+          color = :red
+        end
+
+        method = "calling '#{unit.message}' "
+        arguments = unit.arguments ? "with arguments: '#{unit.arguments}'" : ''
+        receiver = unit.receiver == Object ? '' : "on: #{unit.receiver} "
+
+        report_string <<
+          [outcome, method, arguments, receiver, "\n"].join.colorize(color)
+      end
+
+      puts report_string
+    end
+  end
+end

data/lib/speq/test.rb

@@ -1,61 +1,12 @@
-require 'speq/match'
-
 # The Test class is a simple implementation of unit test block
 module Speq
   class Test
-    attr_reader :method, :reciever, :report
-
-    def initialize(method_symbol, class_name = Object, &block)
-      @method = method_symbol
-      @reciever = class_name
+    def initialize
       @units = []
-
-      instance_eval(&block)
-      print_report
-    end
-
-    def given(*args, match:)
-      args.each do |arg|
-        return_value = reciever.send(method, *arg)
-
-        @units << Match.new(return_value, :eql?, arg, match)
-      end
-    end
-
-    def on(*receivers, match:)
-      receivers.each do |receiver|
-        return_value = receiver.send(method)
-
-        @units << Match.new(return_value, :eql?, arg, match)
-      end
     end
 
     def passed?
       @units.all?(&:passed?)
     end
-
-    def print_report
-      report_string = "Testing: #{method}\n"
-
-      @units.each do |one_test|
-        if one_test.passed?
-          outcome_text = 'PASSED'
-          color = :green
-        else
-          outcome_text = 'FAILED'
-          color = :red
-        end
-
-        indent = ' ' * @method.to_s.length
-
-        report_string <<
-          ["\n#{outcome_text} when given: #{one_test.args}\n".colorize(color),
-           "        returned: #{one_test.actual}\n".colorize(color),
-           "        expected: #{one_test.expected}\n".colorize(color)].join
-      end
-      puts report_string
-
-      passed?
-    end
   end
 end

data/lib/speq/unit.rb

@@ -0,0 +1,20 @@
+# The Unit class is responsible for running a test and storing the result
+module Speq
+  class Unit
+    attr_reader :message, :receiver, :arguments
+
+    def initialize(message, receiver = Object, arguments = [], matcher)
+      @result = matcher.match(receiver.send(message, *arguments))
+    rescue StandardError => exception
+      @result = matcher.match(exception)
+    ensure
+      @message = message
+      @receiver = receiver
+      @arguments = arguments
+    end
+
+    def passed?
+      @result
+    end
+  end
+end

data/lib/speq/version.rb

@@ -1,3 +1,3 @@
 module Speq
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.2.1'.freeze
 end

data/lib/speq.rb

@@ -1,13 +1,29 @@
 require 'speq/version'
 require 'speq/test'
-require 'speq/match'
+require 'speq/matcher'
+require 'speq/report'
+require 'speq/unit'
 require 'speq/fake'
 require 'speq/cli'
 
 module Speq
   module_function
 
-  def does(subject, &block)
-    Test.new(subject, self, &block).report
+  def method_missing(method, *args)
+    if Matcher.respond_to?(method)
+      Matcher.send(method, *args)
+    else
+      super
+    end
+  end
+
+  def unit_test(message, **kwargs)
+    matcher_method = kwargs.keys.find { |key| Matcher.respond_to?(key) }
+    matcher = send(matcher_method, kwargs[matcher_method])
+
+    unit = Unit.new(message, kwargs[:on], kwargs[:with], matcher)
+    Report.new([unit]).print_report
+
+    unit.passed?
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: speq
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - zaniar moradian
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-13 00:00:00.000000000 Z
+date: 2018-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,8 +86,10 @@ files:
 - lib/speq.rb
 - lib/speq/cli.rb
 - lib/speq/fake.rb
-- lib/speq/match.rb
+- lib/speq/matcher.rb
+- lib/speq/report.rb
 - lib/speq/test.rb
+- lib/speq/unit.rb
 - lib/speq/version.rb
 - speq.gemspec
 homepage: https://github.com/znrm/speq

data/lib/speq/match.rb

@@ -1,26 +0,0 @@
-# The Match class includes a variety of matchers
-module Speq
-  class Match
-    attr_reader :actual, :expected, :passed, :args
-
-    def initialize(actual, match_sym, args, expected = nil)
-      @actual = actual
-      @expected = expected
-      @passed = false
-      @args = args
-
-      evaluate_match(match_sym)
-    end
-
-    def evaluate_match(match_sym)
-      case match_sym
-      when :eql?, :equal?
-        @passed = actual.send(match_sym, expected)
-      end
-    end
-
-    def passed?
-      @passed
-    end
-  end
-end