xspec 0.0.1

data/spec/all_specs.rb

@@ -0,0 +1,9 @@
+files = if ARGV.any? {|x| x.length > 0 }
+  ARGV
+else
+  Dir['spec/**/*_spec.rb']
+end
+
+files.each do |f|
+  load f
+end

data/spec/integration/rspec_expectations_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+require 'xspec/assertion_contexts'
+
+it 'integrates with rspec' do
+  opts = {
+    assertion_context: XSpec::AssertionContext.stack {
+      include XSpec::AssertionContext::RSpecExpectations
+    }
+  }
+
+  context = with_dsl(opts) do
+    it 'supports expect an eq' do
+      expect(1 + 1).to eq(3)
+    end
+  end
+
+  assert_errors_from_run context, [
+    "\nexpected: 3\n     got: 2\n\n(compared using ==)\n"
+  ]
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'xspec'
+
+extend XSpec.dsl(
+  notifier: XSpec::Notifier::ColoredDocumentation.new +
+            XSpec::Notifier::TimingsAtEnd.new +
+            XSpec::Notifier::FailuresAtEnd.new
+)
+
+autorun!
+
+def assert_errors_from_run(context, expected_error_messages)
+  context.run!
+
+  notifier = context.__xspec_opts.fetch(:notifier)
+  assert_equal expected_error_messages, notifier.errors.flatten.map(&:message)
+end
+
+def with_dsl(opts, &block)
+  c = Class.new do
+    notifier = Class.new(XSpec::Notifier::Null) do
+      attr_reader :errors
+
+      def initialize
+        @errors = []
+      end
+
+      def evaluate_finish(result)
+        @errors << result.errors
+      end
+    end.new
+
+    extend XSpec.dsl(opts.merge(notifier: notifier))
+
+    instance_exec(&block)
+  end
+end

data/spec/unit/assertion_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe 'simple assertion context' do
+  let(:subject) { Class.new { include XSpec::AssertionContext.stack {
+    include XSpec::AssertionContext::Simple
+  }}.new }
+
+  describe 'assert' do
+    it 'succeeds if parameter is true' do
+      subject.assert(true)
+    end
+
+    it 'fails with default message if parameter is false' do
+      begin
+        subject.assert(false)
+        fail "Assertion did not fail"
+      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+        assert_equal "assertion failed", e.message
+      end
+    end
+
+    it 'fails with custom message if parameter is false' do
+      begin
+        subject.assert(false, "nope")
+        fail "Assertion did not fail"
+      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+        assert_equal "nope", e.message
+      end
+    end
+  end
+
+  describe 'assert_equal' do
+    it 'succeeds if parameters are equal' do
+      subject.assert_equal("a", "a")
+    end
+
+    it 'fails if parameters are not equal' do
+      begin
+        subject.assert_equal("a", "b")
+        fail "Assertion did not fail"
+      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+        assert_include 'want: "a"', e.message
+        assert_include 'got: "b"', e.message
+      end
+    end
+  end
+
+  describe 'fail' do
+    it 'always fails' do
+      begin
+        subject.fail
+        assert false, "fail did not fail"
+      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+        assert_equal "failed", e.message
+      end
+    end
+
+    it 'can fail with a custom message' do
+      begin
+        subject.fail ":("
+        assert false, "fail did not fail"
+      rescue XSpec::AssertionContext::Simple::AssertionFailed => e
+        assert_equal ":(", e.message
+      end
+    end
+  end
+end

data/spec/unit/doubles_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+class LoadedClass
+  def instance_method; end
+  def self.class_method; end
+end
+
+describe 'doubles assertion context' do
+  let(:subject) { Class.new { include XSpec::AssertionContext.stack {
+    include XSpec::AssertionContext::Doubles
+  }}.new }
+
+  it 'converts double exceptions to failures' do
+    result = subject.call(XSpec::UnitOfWork.new(nil, ->{
+      raise XSpec::AssertionContext::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 {
+        double = instance_double('Bogus')
+        expect(double).foo
+        double.foo
+      }
+    end
+
+    it 'allows any return value to be specified' do
+      assert_equal 1, subject.instance_eval {
+        double = instance_double('Bogus')
+        expect(double).foo("a") { 2 }
+        expect(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
+    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
+    end
+  end
+
+  describe 'assert_exhausted' do
+    it 'passes if all expectations have been called' do
+      assert subject.instance_eval {
+        double = instance_double('Bogus')
+        expect(double).foo
+        double.foo
+        assert_exhausted double
+        true
+      }
+    end
+
+    it 'raises when not all expectations have been called' do
+      begin
+        subject.instance_eval {
+          double = instance_double('Bogus')
+          expect(double).foo(1, "abc")
+          assert_exhausted double
+        }
+        fail "no error raised"
+      rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
+        assert_include "did not receive", e.message
+        assert_include 'foo(1, "abc")', e.message
+      end
+    end
+  end
+
+  describe 'instance_double' do
+    describe 'when doubled class is loaded' do
+      it 'allows instance methods to be expected' do
+        assert subject.instance_eval {
+          double = instance_double('LoadedClass')
+          expect(double).instance_method { 123 }
+        }
+      end
+
+      it 'does not allow non-existing methods to be expected' do
+        begin
+          assert subject.instance_eval {
+            double = instance_double('LoadedClass')
+            expect(double).bogus_method { 123 }
+          }
+          fail "no error raised"
+        rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
+          assert_include "LoadedClass#bogus_method", e.message
+        end
+      end
+    end
+  end
+
+  describe 'class_double' do
+    describe 'when doubled class is loaded' do
+      it 'allows instance methods to be expected' do
+        assert subject.instance_eval {
+          double = class_double('LoadedClass')
+          expect(double).class_method { 123 }
+        }
+      end
+
+      it 'does not allow non-existing methods to be expected' do
+        begin
+          assert subject.instance_eval {
+            double = class_double('LoadedClass')
+            expect(double).bogus_method { 123 }
+          }
+          fail "no error raised"
+        rescue XSpec::AssertionContext::Doubles::DoubleFailure => e
+          assert_include "LoadedClass.bogus_method", e.message
+        end
+      end
+    end
+  end
+end
+
+describe 'strict doubles assertion context' do
+  let(:subject) { Class.new { include XSpec::AssertionContext.stack {
+    include XSpec::AssertionContext::Doubles.with(:strict)
+  }}.new }
+
+  it 'allows doubling of loaded classes' do
+    assert subject.instance_double("LoadedClass")
+  end
+
+  it 'prevents doubling of non-existing classes' do
+    begin
+      subject.instance_double("Bogus")
+      fail "no error raised"
+    rescue XSpec::AssertionContext::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/spec/unit/let_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+let(:root_value) { 3 }
+
+describe 'let' do
+  let(:parent_value) { 1 }
+  let(:array)        { [] }
+
+  it('creates an instance method') { assert parent_value == 1 }
+
+  describe do
+    it("inherits from parent") { assert parent_value == 1 }
+  end
+
+  describe do
+    let(:parent_value) { 2 }
+
+    it('allows overriding of parent') { assert parent_value == 2 }
+  end
+
+  describe do
+    def parent_value; 2; end
+
+    it('allows overriding of parent by method') { assert parent_value == 2 }
+  end
+
+  describe do
+    it('can be defined after an it') { assert my_value == 2 }
+
+    let(:my_value) { 2 }
+  end
+
+  it 'works with root context' do
+    assert root_value == 3
+  end
+
+  it 'memorizes the value' do
+    array << 1
+    assert array == [1]
+  end
+
+  it 'resets after each spec' do
+    assert array == []
+  end
+end
+

data/spec/unit/notifiers_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+require 'stringio'
+
+ComposableNotifier = shared_context do
+  it 'can be composed with itself' do
+    assert (notifier + notifier).run_finish
+  end
+end
+
+describe 'failures at end notifier' do
+  let(:out)      { StringIO.new }
+  let(:notifier) { XSpec::Notifier::FailuresAtEnd.new(out) }
+
+  it 'returns true when no errors are observed' do
+    assert notifier.run_finish
+  end
+
+  it 'includes full name in failure' do
+    failure = XSpec::Failure.new(
+      make_nested_test([nil, 'a', nil, 'b'], 'c'),
+      "failed",
+      []
+    )
+    notifier.evaluate_finish(make_executed_test errors: [failure])
+
+    assert !notifier.run_finish
+    assert_include "a b c:\n  failed", out.string
+  end
+
+  it 'cleans lib entries out of backtrace' do
+    failure = XSpec::Failure.new(
+      make_nested_test([nil, 'a', nil, 'b'], 'c'),
+      "failed",
+      [File.expand_path('../../../lib', __FILE__) + '/bogus.rb']
+    )
+    notifier.evaluate_finish(make_executed_test errors: [failure])
+
+    assert !notifier.run_finish
+    assert !out.string.include?('bogus.rb')
+  end
+
+  it_behaves_like_a ComposableNotifier
+end
+
+describe 'character notifier' do
+  let(:notifier) { XSpec::Notifier::Character.new(out) }
+  let(:out)      { StringIO.new }
+
+  it 'outputs a . for every successful test' do
+    notifier.evaluate_finish(make_executed_test)
+    notifier.evaluate_finish(make_executed_test)
+
+    assert notifier.run_finish
+    assert out.string == "..\n"
+  end
+
+  it 'outputs a F for every failed test' do
+    notifier.evaluate_finish(make_executed_test errors: [make_failure])
+
+    assert !notifier.run_finish
+    assert out.string == "F\n"
+  end
+
+  it 'outputs an E for every errored test' do
+    notifier.evaluate_finish(make_executed_test errors: [make_error])
+
+    assert !notifier.run_finish
+    assert out.string == "E\n"
+  end
+
+  it_behaves_like_a ComposableNotifier
+end
+
+describe 'documentation notifier' do
+  let(:notifier) { XSpec::Notifier::Documentation.new(out) }
+  let(:out)      { StringIO.new }
+
+  def evaluate_finish(args)
+    notifier.evaluate_finish(make_executed_test args)
+    out.string
+  end
+
+  it 'outputs each context with a header and individual tests' do
+    assert_equal "\na\n  0.001s b\n",
+      evaluate_finish(parents: ['a'], name: 'b')
+  end
+
+  it 'adds an indent for each nested context' do
+    assert_equal "\na\n  b\n    0.001s c\n",
+      evaluate_finish(parents: ['a', 'b'], name: 'c')
+  end
+
+  it 'does not repeat top level parents for multiple nested contexts' do
+    evaluate_finish(parents: ['a', 'b'], name: 'c')
+    evaluate_finish(parents: ['a', 'd'], name: 'e')
+
+    assert_equal "\na\n  b\n    0.001s c\n\n  d\n    0.001s e\n", out.string
+  end
+
+  it 'ignores contexts with no name' do
+    assert_equal "\na\n  0.001s b\n",
+      evaluate_finish(parents: [nil, 'a', nil], name: 'b')
+  end
+
+  it 'suffixes FAILED to tests when they fail' do
+
+    assert_include "a - FAILED",
+      evaluate_finish(errors: [make_failure], name: 'a')
+  end
+
+  it 'outputs FAILED for unnamed tests when they fail' do
+    assert_include "FAILED", evaluate_finish(name: nil, errors: [make_failure])
+  end
+
+  it 'outputs FAILED for unnamed tests when they error' do
+    assert_include "FAILED", evaluate_finish(errors: [make_error])
+  end
+
+  it_behaves_like_a ComposableNotifier
+end
+
+describe 'colored documentation notifier' do
+  let(:notifier) { XSpec::Notifier::ColoredDocumentation.new(out) }
+  let(:out)      { StringIO.new }
+
+  it 'colors successful tests green' do
+    notifier.evaluate_finish(make_executed_test errors: [])
+
+    assert_include "\e[32m\e[0m\n", out.string
+  end
+
+  it 'colors failed and errored tests red' do
+    notifier.evaluate_finish(make_executed_test errors: [make_failure])
+
+    assert_include "\e[31mFAILED\e[0m", out.string
+  end
+
+  it_behaves_like_a ComposableNotifier
+end
+
+describe 'composable notifier' do
+  let(:notifier) { XSpec::Notifier::Composite.new }
+
+  it_behaves_like_a ComposableNotifier
+end
+
+describe 'null notifier' do
+  let(:notifier) { XSpec::Notifier::Null.new }
+
+  it 'always returns true' do
+    assert notifier.run_finish
+  end
+
+  it_behaves_like_a ComposableNotifier
+end
+
+def make_nested_test(parent_names = [], work_name = nil)
+  XSpec::NestedUnitOfWork.new(
+    parent_names.map {|name| XSpec::Context.make(name, Module.new) },
+    XSpec::UnitOfWork.new(work_name, ->{})
+  )
+end
+
+def make_executed_test(parents: [], errors: [], duration: 0.001, name: nil)
+  XSpec::ExecutedUnitOfWork.new(
+    XSpec::NestedUnitOfWork.new(
+      parents.map {|name| XSpec::Context.make(name, Module.new) },
+      XSpec::UnitOfWork.new(name, ->{})
+    ),
+    errors,
+    duration
+  )
+end
+
+def make_failure
+  failure = XSpec::Failure.new(
+    make_nested_test([], 'failure'),
+    "failed",
+    []
+  )
+end
+
+def make_error
+  failure = XSpec::CodeException.new(
+    make_nested_test([], 'failure'),
+    "failed",
+    []
+  )
+end