kintama 0.1.11 → 0.1.12

metadata

@@ -1,46 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: kintama
 version: !ruby/object:Gem::Version
-  version: 0.1.11
-  prerelease: 
+  version: 0.1.12
 platform: ruby
 authors:
 - James Adam
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-18 00:00:00.000000000 Z
+date: 2015-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.13.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -51,61 +46,60 @@ extra_rdoc_files:
 - README.md
 files:
 - README.md
-- test/aliases_test.rb
-- test/assertions_test.rb
-- test/automatic_running_test.rb
-- test/exceptions_test.rb
-- test/kintama_test.rb
-- test/line_based_running_test.rb
-- test/matcher_test.rb
-- test/method_behaviour_test.rb
-- test/pending_test_and_context.rb
-- test/reporters/base_reporter_test.rb
-- test/reporters/inline_reporter_test.rb
-- test/reporters/verbose_reporter_test.rb
-- test/setup_test.rb
-- test/start_and_finish_test.rb
-- test/teardown_test.rb
-- test/test_and_subcontext_access_test.rb
-- test/test_helper.rb
+- lib/kintama.rb
 - lib/kintama/assertions.rb
 - lib/kintama/context.rb
 - lib/kintama/mocha.rb
+- lib/kintama/no_conflict.rb
 - lib/kintama/reporter.rb
 - lib/kintama/runnable.rb
 - lib/kintama/runner.rb
 - lib/kintama/test.rb
-- lib/kintama.rb
+- test/integration/automatic_running_test.rb
+- test/integration/line_based_running_test.rb
+- test/reporters/base_reporter_test.rb
+- test/reporters/inline_reporter_test.rb
+- test/reporters/verbose_reporter_test.rb
+- test/test_helper.rb
+- test/unit/assertions_test.rb
+- test/unit/context_test.rb
+- test/unit/runner_test.rb
+- test/unit/test_and_subcontext_access_test.rb
+- test/usage/01_basic_usage_test.rb
+- test/usage/02_setup_test.rb
+- test/usage/03_teardown_test.rb
+- test/usage/04_pending_tests_test.rb
+- test/usage/05_aliases_test.rb
+- test/usage/06_defining_methods_in_tests_test.rb
+- test/usage/07_exceptions_test.rb
+- test/usage/08_start_and_finish_test.rb
+- test/usage/09_expectations_and_mocking_test.rb
+- test/usage/10_let_and_subject_test.rb
+- test/usage/11_matcher_test.rb
+- test/usage/12_action_test.rb
 homepage: http://github.com/lazyatom
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2321837181279822201
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2321837181279822201
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: It's for writing tests.
 test_files: []

data/test/aliases_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-class AliasesTest < Test::Unit::TestCase
-
-  def test_should_provide_given_and_it_aliases_for_context_and_should
-    x = context "In a world without hope" do
-      given "a massive gun" do
-        it "should work out well in the end" do
-          assert true
-        end
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  def test_should_provide_testcase_alias_for_context
-    x = testcase "In a world without hope" do
-      should "work out well in the end" do
-        assert true
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-end

data/test/exceptions_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-class ExceptionsTest < Test::Unit::TestCase
-
-  def test_should_capture_exceptions_in_tests_as_failing_tests
-    x = context "Given a test" do
-      should "that raises an exception" do
-        raise "aaargh"
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_capture_exceptions_in_setups_as_failing_tests
-    x = context "Given a test with setup that fails" do
-      setup do
-        raise "aargh"
-      end
-      should "that would otherwise pass" do
-        assert true
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_capture_exceptions_in_teardowns_as_failing_tests
-    x = context "Given a test with teardown that fails" do
-      teardown do
-        raise "aargh"
-      end
-      should "that would otherwise pass" do
-        assert true
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-end

data/test/kintama_test.rb

@@ -1,114 +0,0 @@
-require 'test_helper'
-
-class KintamaTest < Test::Unit::TestCase
-
-  def test_should_pass_when_all_tests_pass
-    x = context "Given something" do
-      should "work" do
-        assert true
-      end
-    end
-    x.run
-    assert x.passed?
-  end
-
-  def test_should_fail_when_all_tests_fail
-    x = context "Given something" do
-      should "work" do
-        flunk
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_fail_when_any_tests_fail
-    x = context "Given something" do
-      should "work" do
-        flunk
-      end
-      should "also work" do
-        assert true
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_fail_when_any_assertion_within_a_test_fails
-    x = context "Given something" do
-      should "ultimately not work" do
-        flunk
-        assert true
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_not_run_any_code_beyond_a_failing_assertion
-    x = context "Given something" do
-      should "ultimately not work" do
-        flunk
-        raise "should not get here!"
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_allow_nesting_of_contexts
-    x = context "Given something" do
-      context "and another thing" do
-        should "work" do
-          flunk
-        end
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_allow_multiple_subcontexts
-    x = context "Given something" do
-      context "and another thing" do
-        should "work" do
-          flunk
-        end
-      end
-      context "and another different thing" do
-        should "work" do
-          assert true
-        end
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_allow_deep_nesting_of_subcontexts
-    x = context "Given something" do
-      context "and another thing" do
-        context "and one more thing" do
-          should "work" do
-            flunk
-          end
-        end
-      end
-    end
-    x.run
-    assert !x.passed?
-  end
-
-  def test_should_clear_previous_failure_when_running_test_again
-    $thing = 456
-    x = context "Given something" do
-      should "work" do
-        assert_equal 123, $thing
-      end
-    end
-    assert_equal false, x.run
-    $thing = 123
-    assert_equal true, x.run
-  end
-end

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