kintama 0.1.9 → 0.2

data/test/matcher_test.rb

@@ -1,80 +0,0 @@
-require "test_helper"
-
-class MatcherTest < Test::Unit::TestCase
-
-  class EqualMatcher
-    def initialize(expected)
-      @expected = expected
-    end
-
-    def matches?(provided_value)
-      @actual = provided_value
-      @actual == @expected
-    end
-
-    def failure_message
-      "Expected #{@expected}, but got #{@actual}"
-    end
-
-    def negative_failure_message
-      "Didn't expect #{@expected}, but got it anyway"
-    end
-
-    def description
-      "be equal to #{@expected.inspect}"
-    end
-  end
-
-  def test_should_allow_use_of_matchers_within_contexts
-    c = context "x" do
-      subject { 123 }
-      should EqualMatcher.new(456)
-    end
-    c.run
-    assert !c.passed?
-    assert_match /^Expected 456, but got 123/, c.failures.first.failure_message
-  end
-
-  def test_should_use_a_single_instance_of_the_subject_within_a_test
-    c = context "x" do
-      subject { Array.new }
-      should "allow me to poke around with subject like it was a variable" do
-        subject << 1
-        assert_equal [1], subject
-      end
-      should "now be empty again" do
-        assert subject.empty?
-      end
-    end
-    c.run
-    assert c.passed?
-  end
-
-  def test_should_allow_negation_of_matchers
-    c = context "x" do
-      subject { 123 }
-      should_not EqualMatcher.new(123)
-    end
-    c.run
-    assert !c.passed?
-    assert_match /^Didn't expect 123, but got it anyway/, c.failures.first.failure_message
-  end
-
-  module MatcherExtension
-    def be_equal_to(expected)
-      EqualMatcher.new(expected)
-    end
-  end
-
-  def test_should_allow_definition_of_matchers_in_contexts
-    Kintama.extend(MatcherExtension)
-    c = context "x" do
-      subject { 'abc' }
-      should be_equal_to('abc')
-      should_not be_equal_to('def')
-    end
-    c.run
-    assert c.passed?
-    assert_equal ["should be equal to \"abc\"", "should not be equal to \"def\""], c.tests.map { |t| t.name }
-  end
-end

data/test/method_behaviour_test.rb

@@ -1,176 +0,0 @@
-require 'test_helper'
-
-class MethodBehaviourTest < Test::Unit::TestCase
-
-  def test_should_allow_methods_defined_in_the_context_to_be_called_in_tests
-    x = context "Given I ran a method" do
-      should "set something" do
-        assert self.respond_to?(:do_something)
-        assert_equal 123, do_something
-      end
-      def do_something
-        123
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  def test_should_allow_methods_defined_in_the_context_to_be_called_in_tests_in_subcontexts
-    x = context "Given I ran a method" do
-      context "in a subcontext" do
-        should "set something" do
-          assert self.respond_to?(:do_something)
-          assert_equal 234, do_something
-        end
-      end
-      def do_something
-        234
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  module MyStuff
-    def do_something
-      456
-    end
-  end
-
-  def test_should_be_able_to_call_methods_from_included_modules_in_tests
-    x = context "Given I include a module" do
-      include MyStuff
-      should "allow calling methods from that module" do
-        assert_equal 456, do_something
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  def test_should_not_allow_methods_from_one_context_to_bleed_into_another
-    context "Given I define a method in one context" do
-      def do_another_thing
-      end
-    end
-    x = context "And I define another context" do
-      it "should not be possible to call that method" do
-        assert !self.respond_to?(:do_another_thing)
-        assert_raises("should not be able to call this") { do_another_thing }
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  module MoreMyStuff
-    def get_thing
-      @thing
-    end
-  end
-
-  def test_should_allow_defined_methods_to_refer_to_instance_variables_defined_in_setup_when_included_via_modules
-    c = context "Given I define an instance variable in my setup" do
-      include MoreMyStuff
-      setup do
-        @thing = 123
-      end
-      should "be able to call a method that refers to that variable in a test" do
-        assert_equal 123, get_thing
-      end
-    end
-    c.run
-    assert c.passed?, "Thing was not defined!"
-  end
-
-  module DefaultBehaviour
-    def something
-      'abc'
-    end
-  end
-
-  def test_should_allow_including_default_behaviour_in_all_contexts
-    Kintama.include DefaultBehaviour
-    c = context "Given a context" do
-      should "be able to call a method from the globally shared behaviour" do
-        assert_equal 'abc', something
-      end
-    end
-    c.run
-    assert c.passed?, "something was not defined!"
-  end
-
-  def test_should_be_able_to_compose_shoulds_into_methods
-    $ran = false
-    x = context "Given a context" do
-      def self.should_create_a_should_from_a_method
-        should "have created this test" do
-          $ran = true
-          assert true
-        end
-      end
-
-      should_create_a_should_from_a_method
-    end
-    x.run
-    assert x.passed?
-    assert $ran
-
-    assert_not_nil x.should_have_created_this_test
-  end
-
-  def test_should_be_able_to_call_methods_in_subcontexts_that_create_tests
-    x = context "Given a subcontext" do
-      def self.with_a_method
-        should "create this test in the subcontext" do
-          flunk
-        end
-      end
-      context "which calls a method defined at the top level" do
-        with_a_method
-      end
-    end
-    x.run
-    subcontext = x.subcontexts.first
-    assert_equal ["should create this test in the subcontext"], subcontext.tests.map { |t| t.name }
-  end
-
-  module TestCreatingBehaviour
-    def with_a_method
-      should "create this test in the subcontext" do
-        flunk
-      end
-    end
-  end
-
-  def test_should_be_able_to_call_methods_in_subcontexts_that_create_tests_when_defined_in_modules
-    x = context "Given a subcontext" do
-      extend TestCreatingBehaviour
-
-      context "which calls a method defined at the top level" do
-        with_a_method
-      end
-    end
-    x.run
-    subcontext = x.subcontexts.first
-    assert_equal ["should create this test in the subcontext"], subcontext.tests.map { |t| t.name }
-  end
-
-  module NewKintamaBehaviour
-    def define_a_test
-      should "define a test" do
-        flunk
-      end
-    end
-  end
-
-  def test_should_be_able_to_add_behaviour_to_kintama
-    Kintama.extend NewKintamaBehaviour
-    x = context "A context" do
-      define_a_test
-    end
-    x.run
-    assert !x.passed?
-  end
-end

data/test/pending_test_and_context.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-class PendingTest < Test::Unit::TestCase
-  
-  def test_should_pass_any_pending_tests
-    c = context "Given a context" do
-      test "that is not implemented"
-    end
-    c.run
-    assert c.passed?
-  end
-
-  def test_should_ignore_empty_contexts
-    c = context "Given an empty context" do
-      context "should ignore this"
-    end
-    c.run
-    assert c.passed?
-  end
-end

data/test/setup_test.rb

@@ -1,107 +0,0 @@
-require 'test_helper'
-
-class SetupTest < Test::Unit::TestCase
-
-  def test_should_allow_setup_to_provide_instance_variables
-    x = context "Given something" do
-      setup do
-        @name = "james"
-      end
-      should "work" do
-        assert_equal "james", @name
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  def test_should_run_setup_before_every_test
-    x = context "Given something" do
-      setup do
-        @name = "james"
-      end
-      should "work" do
-        @name += " is awesome"
-        assert_equal "james is awesome", @name
-      end
-      should "also work" do
-        @name += " is the best"
-        assert_equal "james is the best", @name
-      end
-    end
-    x.run
-    assert x.passed?, x.failures.join(", ")
-  end
-
-  def test_should_allow_call_all_setup_methods_when_running_tests_in_a_nested_context
-    x = context "Given something" do
-      setup do
-        @name = "james"
-      end
-      context "and another thing" do
-        setup do
-          @name += " is amazing"
-        end
-        should "work" do
-          assert_equal "james is amazing", @name
-        end
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  def test_should_only_run_necessary_setups_where_tests_at_different_nestings_exist
-    x = context "Given something" do
-      setup do
-        @name = "james"
-      end
-      context "and another thing" do
-        setup do
-          @name += " is amazing"
-        end
-        should "work" do
-          assert_equal "james is amazing", @name
-        end
-      end
-      should "work" do
-        assert_equal "james", @name
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  def test_should_run_setup_defined_on_kintama_itself_before_other_setups
-    Kintama.setup do
-      @thing = 'well then'
-    end
-    c = context "Given a context" do
-      setup do
-        assert_equal 'well then', @thing
-        @thing = 'now then'
-      end
-      should "have run the setup defined in the default behaviour" do
-        assert_equal 'now then', @thing
-      end
-    end
-    c.run
-    assert c.passed?, "@thing was not defined!"
-  end
-
-  def test_should_allow_multiple_setups_to_be_registered
-    Kintama.setup do
-      @thing = 1
-    end
-    Kintama.setup do
-      @thing += 1
-    end
-    c = context "Given multiple setups" do
-      should "run them all" do
-        assert_equal 2, @thing
-      end
-    end
-    c.run
-    assert c.passed?, "both setups didn't run - #{c.failures.inspect}"
-  end
-end

data/test/start_and_finish_test.rb

@@ -1,94 +0,0 @@
-require "test_helper"
-
-class StartAndFinishTest < Test::Unit::TestCase
-  
-  def test_should_call_any_on_start_block_when_running_a_context
-    $ran = 0
-    c = context "A context with a startup block" do
-      on_start { $ran += 1 }
-      should "have run the on_start block" do
-      end
-    end
-    c.run
-    assert_equal 1, $ran
-  end
-
-  def test_should_only_call_on_start_block_once_when_running_a_context
-    $ran = 0
-    c = context "A context with a startup block" do
-      on_start { $ran += 1 }
-      should "have run the on_start block" do
-      end
-      should "not run that block again" do
-      end
-    end
-    c.run
-    assert_equal 1, $ran
-  end
-
-  def test_should_only_call_on_start_block_before_any_test
-    $ran = 0
-    c = context "A context with a startup block" do
-      on_start { $ran += 1 }
-      should "have run the on_start block" do
-        assert_equal 1, $ran
-      end
-      should "not run that block again" do
-        assert_equal 1, $ran
-      end
-    end
-    c.run
-    assert c.passed?
-  end
-
-  def test_should_call_any_on_finish_block_when_running_a_context
-    $ran = 0
-    c = context "A context with a startup block" do
-      should "have run the on_start block" do
-      end
-      on_finish { $ran += 1 }
-    end
-    c.run
-    assert_equal 1, $ran
-  end
-
-  def test_should_only_call_on_finish_block_once_when_running_a_context
-    $ran = 0
-    c = context "A context with a startup block" do
-      should "have run the on_start block" do
-      end
-      should "not run that block again" do
-      end
-      on_finish { $ran += 1 }
-    end
-    c.run
-    assert_equal 1, $ran
-  end
-
-  def test_should_only_call_on_finish_block_after_all_tests
-    $ran = 0
-    c = context "A context with a startup block" do
-      should "have run the on_start block" do
-        assert_equal 0, $ran
-      end
-      should "not run that block again" do
-        assert_equal 0, $ran
-      end
-      on_finish { $ran += 1 }
-    end
-    c.run
-    assert c.passed?
-  end
-
-  def test_should_be_able_to_use_rspec_like_aliases
-    $ran = 0
-    c = context "A context with a startup block" do
-      before_all { $ran += 1 }
-      should "have run the on_start block" do
-      end
-      after_all { $ran += 1 }
-    end
-    c.run
-    assert_equal 2, $ran
-  end
-end