xspec 0.0.2 → 0.1.0

data/lib/xspec/notifiers.rb

@@ -180,6 +180,8 @@ module XSpec
         false
       end
 
+      private
+
       def full_name(unit_of_work)
         (unit_of_work.parents + [unit_of_work]).map(&:name).compact.join(' ')
       end

data/lib/xspec/schedulers.rb

@@ -0,0 +1,39 @@
+# # Schedulers
+
+# Schedulers are responsible for collecting all units of work to be run and
+# scheduling them.
+module XSpec
+  module Scheduler
+    # The serial scheduler, unsurprisingly, runs all units of works serially in
+    # a loop. It is about as simple a scheduler as you can imagine. Parents
+    # are responsible for actually executing the work.
+    class Serial
+      def initialize(opts = {})
+        @clock = opts.fetch(:clock, ->{ Time.now.to_f })
+      end
+
+      def run(context, notifier)
+        notifier.run_start
+
+        context.nested_units_of_work.each do |x|
+          notifier.evaluate_start(x)
+
+          start_time  = clock.()
+          errors      = x.immediate_parent.execute(x)
+          finish_time = clock.()
+
+          result = ExecutedUnitOfWork.new(x, errors, finish_time - start_time)
+          notifier.evaluate_finish(result)
+        end
+
+        notifier.run_finish
+      end
+
+      protected
+
+      attr_reader :clock
+    end
+
+    DEFAULT = Serial.new
+  end
+end

data/spec/integration/rspec_expectations_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-require 'xspec/assertion_contexts'
+require 'xspec/evaluators'
 
 it 'integrates with rspec' do
   opts = {
-    assertion_context: XSpec::AssertionContext.stack {
-      include XSpec::AssertionContext::RSpecExpectations
+    evaluator: XSpec::Evaluator.stack {
+      include XSpec::Evaluator::RSpecExpectations
     }
   }
 

data/spec/spec_helper.rb

@@ -9,8 +9,6 @@ extend XSpec.dsl(
             XSpec::Notifier::FailuresAtEnd.new
 )
 
-autorun!
-
 def assert_errors_from_run(context, expected_error_messages)
   context.run!
 

data/spec/unit/assertion_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe 'simple assertion context' do
-  let(:subject) { Class.new { include XSpec::AssertionContext.stack {
-    include XSpec::AssertionContext::Simple
+  let(:subject) { Class.new { include XSpec::Evaluator.stack {
+    include XSpec::Evaluator::Simple
   }}.new }
 
   describe 'assert' do
@@ -14,7 +14,7 @@ describe 'simple assertion context' do
       begin
         subject.assert(false)
         fail "Assertion did not fail"
-      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::Simple::AssertionFailed => e
         assert_equal "assertion failed", e.message
       end
     end
@@ -23,7 +23,7 @@ describe 'simple assertion context' do
       begin
         subject.assert(false, "nope")
         fail "Assertion did not fail"
-      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::Simple::AssertionFailed => e
         assert_equal "nope", e.message
       end
     end
@@ -38,7 +38,7 @@ describe 'simple assertion context' do
       begin
         subject.assert_equal("a", "b")
         fail "Assertion did not fail"
-      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::Simple::AssertionFailed => e
         assert_include 'want: "a"', e.message
         assert_include 'got: "b"', e.message
       end
@@ -50,7 +50,7 @@ describe 'simple assertion context' do
       begin
         subject.fail
         assert false, "fail did not fail"
-      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::Simple::AssertionFailed => e
         assert_equal "failed", e.message
       end
     end
@@ -59,7 +59,7 @@ describe 'simple assertion context' do
       begin
         subject.fail ":("
         assert false, "fail did not fail"
-      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+      rescue XSpec::Evaluator::Simple::AssertionFailed => e
         assert_equal ":(", e.message
       end
     end

data/spec/unit/doubles_spec.rb

@@ -6,127 +6,135 @@ class LoadedClass
 end
 
 describe 'doubles assertion context' do
-  let(:subject) { Class.new { include XSpec::AssertionContext.stack {
-    include XSpec::AssertionContext::Doubles
+  let(:subject) { Class.new { include XSpec::Evaluator.stack {
+    include XSpec::Evaluator::Doubles
   }}.new }
 
   it 'converts double exceptions to failures' do
     result = subject.call(XSpec::UnitOfWork.new(nil, ->{
-      raise XSpec::AssertionContext::Doubles::DoubleFailure, "nope"
+      raise XSpec::Evaluator::Doubles::DoubleFailure, "nope"
     }))
     assert_equal "nope", result[0].message
   end
 
   describe 'doubles of unloaded classes' do
-    it 'allows any method to be expected' do
-      assert_equal nil, subject.instance_eval {
+    it 'allows a stub to be used multiple times' do
+      assert_equal 1, subject.instance_eval {
         double = instance_double('Bogus')
-        expect(double).foo
-        double.foo
+        stub(double).foo("a") { 1 }
+        double.foo("a")
+        double.foo("a")
       }
     end
 
-    it 'allows any return value to be specified' do
+    it 'allows any return value to be stubbed' do
       assert_equal 1, subject.instance_eval {
         double = instance_double('Bogus')
-        expect(double).foo("a") { 2 }
-        expect(double).foo("b") { 3 }
+        stub(double).foo("a") { 2 }
+        stub(double).foo("b") { 3 }
         double.foo("b") - double.foo("a")
       }
     end
 
     it 'requires matching method name' do
-      begin
-        subject.instance_eval {
-          double = instance_double('Bogus')
-          expect(double).foo("a")
-          double.bar("a")
-        }
-        fail "no error raised"
-      rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
-        assert_include "Unexpectedly received", e.message
-        assert_include 'bar("a")', e.message
-      end
+      assert_equal nil, subject.instance_eval {
+        double = instance_double('Bogus')
+        stub(double).foo("a") { 1 }
+        double.bar("a")
+      }
     end
 
     it 'requires exact arguments' do
-      begin
-        subject.instance_eval {
-          double = instance_double('Bogus')
-          expect(double).foo("a")
-          double.foo("b")
-        }
-        fail "no error raised"
-      rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
-        assert_include "Unexpectedly received", e.message
-        assert_include 'foo("b")', e.message
-      end
+      assert_equal nil, subject.instance_eval {
+        double = instance_double('Bogus')
+        stub(double).foo("a") { 1 }
+        double.foo("b")
+      }
     end
   end
 
-  describe 'assert_exhausted' do
-    it 'passes if all expectations have been called' do
+  describe 'verify' do
+    it 'can verify a method was called with no setup' do
       assert subject.instance_eval {
         double = instance_double('Bogus')
-        expect(double).foo
         double.foo
-        assert_exhausted double
+        verify(double).foo
         true
       }
     end
 
-    it 'raises when not all expectations have been called' do
+    it 'can verify a method that was stubbed' do
+      assert subject.instance_eval {
+        double = instance_double('Bogus')
+        stub(double).foo { 1 }
+        double.foo
+        verify(double).foo
+        true
+      }
+    end
+
+    it 'raises if method was not called' do
       begin
         subject.instance_eval {
           double = instance_double('Bogus')
-          expect(double).foo(1, "abc")
-          assert_exhausted double
+          double.bar
+          verify(double).foo("b")
         }
         fail "no error raised"
-      rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
-        assert_include "did not receive", e.message
-        assert_include 'foo(1, "abc")', e.message
+      rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+        assert_include "Did not receive", e.message
+        assert_include 'foo("b")', e.message
       end
     end
 
-    it 'does not raise on uncalled allows' do
-      assert subject.instance_eval {
-        double = instance_double('Bogus')
-        allow(double).foo
-        assert_exhausted double
-        true
-      }
-    end
-
-    it 'gives precendence to expect' do
-      assert_equal 1, subject.instance_eval {
-        double = instance_double('Bogus')
-        allow(double).foo
-        expect(double).foo { 1 }
-        ret = double.foo
-        assert_exhausted double
-        ret
-      }
+    it 'raises if method was not called with right arguments' do
+      begin
+        subject.instance_eval {
+          double = instance_double('Bogus')
+          double.foo("a")
+          double.foo("b")
+          verify(double).foo("c")
+        }
+        fail "no error raised"
+      rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+        assert_include "Did not receive", e.message
+        assert_include 'foo("b")', e.message
+        assert_include "Did receive", e.message
+        assert_include 'foo("a")', e.message
+        assert_include 'foo("b")', e.message
+      end
     end
   end
 
   describe 'instance_double' do
     describe 'when doubled class is loaded' do
-      it 'allows instance methods to be expected' do
+      it 'allows instance methods to be stubbed' do
         assert subject.instance_eval {
           double = instance_double('LoadedClass')
-          expect(double).instance_method { 123 }
+          stub(double).instance_method { 123 }
         }
       end
 
-      it 'does not allow non-existing methods to be expected' do
+      it 'does not allow non-existing methods to be stubbed' do
+        begin
+          assert subject.instance_eval {
+            double = instance_double('LoadedClass')
+            stub(double).bogus_method { 123 }
+          }
+          fail "no error raised"
+        rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+          assert_include "LoadedClass#bogus_method", e.message
+        end
+      end
+
+      it 'does not allow non-existing methods to be verified' do
         begin
           assert subject.instance_eval {
             double = instance_double('LoadedClass')
-            expect(double).bogus_method { 123 }
+            verify(double).bogus_method { 123 }
           }
           fail "no error raised"
-        rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
+        rescue XSpec::Evaluator::Doubles::DoubleFailure => e
           assert_include "LoadedClass#bogus_method", e.message
         end
       end
@@ -135,21 +143,33 @@ describe 'doubles assertion context' do
 
   describe 'class_double' do
     describe 'when doubled class is loaded' do
-      it 'allows instance methods to be expected' do
+      it 'allows instance methods to be stubbed' do
         assert subject.instance_eval {
           double = class_double('LoadedClass')
-          expect(double).class_method { 123 }
+          stub(double).class_method { 123 }
         }
       end
 
-      it 'does not allow non-existing methods to be expected' do
+      it 'does not allow non-existing methods to be stubbed' do
         begin
           assert subject.instance_eval {
             double = class_double('LoadedClass')
-            expect(double).bogus_method { 123 }
+            stub(double).bogus_method { 123 }
           }
           fail "no error raised"
-        rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
+        rescue XSpec::Evaluator::Doubles::DoubleFailure => e
+          assert_include "LoadedClass.bogus_method", e.message
+        end
+      end
+
+      it 'does not allow non-existing methods to be verified' do
+        begin
+          assert subject.instance_eval {
+            double = class_double('LoadedClass')
+            verify(double).bogus_method
+          }
+          fail "no error raised"
+        rescue XSpec::Evaluator::Doubles::DoubleFailure => e
           assert_include "LoadedClass.bogus_method", e.message
         end
       end
@@ -158,8 +178,8 @@ describe 'doubles assertion context' do
 end
 
 describe 'strict doubles assertion context' do
-  let(:subject) { Class.new { include XSpec::AssertionContext.stack {
-    include XSpec::AssertionContext::Doubles.with(:strict)
+  let(:subject) { Class.new { include XSpec::Evaluator.stack {
+    include XSpec::Evaluator::Doubles.with(:strict)
   }}.new }
 
   it 'allows doubling of loaded classes' do
@@ -170,50 +190,8 @@ describe 'strict doubles assertion context' do
     begin
       subject.instance_double("Bogus")
       fail "no error raised"
-    rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
+    rescue XSpec::Evaluator::Doubles::DoubleFailure => e
       assert_include "Bogus", e.message
     end
   end
 end
-
-describe 'auto-verifying doubles assertion context' do
-  let(:subject) { Class.new { include XSpec::AssertionContext.stack {
-    include XSpec::AssertionContext::Doubles.with(:auto_verify)
-  }}.new }
-
-  it 'verifies all used instance doubles on successful result' do
-    result = subject.call(XSpec::UnitOfWork.new(nil, ->{
-      double = instance_double('Bogus')
-      expect(double).foo
-    }))
-
-    assert_equal 1, result.length
-    assert_include "did not receive", result[0].message
-    assert_include "foo()", result[0].message
-  end
-
-  it 'verifies all used class doubles on successful result' do
-    result = subject.call(XSpec::UnitOfWork.new(nil, ->{
-      double = class_double('Bogus')
-      expect(double).foo
-    }))
-
-    assert_equal 1, result.length
-    assert_include "did not receive", result[0].message
-    assert_include "foo()", result[0].message
-  end
-
-  it 'does not verify doubles if errors occurred' do
-    result = subject.call(XSpec::UnitOfWork.new(nil, ->{
-      double = instance_double('Bogus')
-      expect(double).foo
-      fail "nope"
-    }))
-    assert_equal 1, result.length
-    assert_include "nope", result[0].message
-  end
-
-  it 'returns successful result if all doubles are valid' do
-    assert_equal [], subject.call(XSpec::UnitOfWork.new(nil, ->{}))
-  end
-end

data/xspec.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |gem|
   gem.homepage      = "http://github.com/xaviershay/xspec"
 
   gem.executables   = []
-  gem.required_ruby_version = '>= 1.9.0'
+  gem.required_ruby_version = '>= 2.1.0'
   gem.files         = Dir.glob("{spec,lib}/**/*.rb") + %w(
                         README.md
                         xspec.gemspec
@@ -22,6 +22,6 @@ Gem::Specification.new do |gem|
   gem.bindir        = "bin"
   gem.executables  << "xspec"
   gem.license       = "Apache 2.0"
-  gem.version       = "0.0.2"
+  gem.version       = "0.1.0"
   gem.has_rdoc      = false
 end