picolena 0.1.8 → 0.2.0

data/rails_plugins/rspec/spec/spec/story/runner/story_runner_spec.rb

@@ -1,256 +0,0 @@
-require File.dirname(__FILE__) + '/../story_helper'
-
-module Spec
-  module Story
-    module Runner
-      describe StoryRunner do
-        it 'should collect all the stories' do
-          # given
-          story_runner = StoryRunner.new(stub('scenario_runner'))
-
-          # when
-          story_runner.Story 'title1', 'narrative1' do end
-          story_runner.Story 'title2', 'narrative2' do end
-          stories = story_runner.stories
-
-          # then
-          story_runner.should have(2).stories
-          stories.first.title.should == 'title1'
-          stories.first.narrative.should == 'narrative1'
-          stories.last.title.should == 'title2'
-          stories.last.narrative.should == 'narrative2'
-        end
-
-        it 'should gather all the scenarios in the stories' do
-          # given
-          story_runner = StoryRunner.new(stub('scenario_runner'))
-
-          # when
-          story_runner.Story "story1", "narrative1" do
-            Scenario "scenario1" do end
-            Scenario "scenario2" do end
-          end
-          story_runner.Story "story2", "narrative2" do
-            Scenario "scenario3" do end
-          end
-          scenarios = story_runner.scenarios
-
-          # then
-          story_runner.should have(3).scenarios
-          scenarios[0].name.should == 'scenario1'
-          scenarios[1].name.should == 'scenario2'
-          scenarios[2].name.should == 'scenario3'
-        end
-
-        # captures worlds passed into a ScenarioRunner
-        class ScenarioWorldCatcher
-          attr_accessor :worlds
-          def run(scenario, world)
-           (@worlds ||= [])  << world
-          end
-        end
-
-        it 'should run each scenario in a separate object' do
-          # given
-          scenario_world_catcher = ScenarioWorldCatcher.new
-          story_runner = StoryRunner.new(scenario_world_catcher)
-          story_runner.Story 'story', 'narrative' do
-            Scenario 'scenario1' do end
-            Scenario 'scenario2' do end
-          end
-
-          # when
-          story_runner.run_stories
-
-          # then
-          worlds = scenario_world_catcher.worlds
-          scenario_world_catcher.should have(2).worlds
-          worlds[0].should_not == worlds[1]
-        end
-
-        it 'should use the provided world creator to create worlds' do
-          # given
-          stub_scenario_runner = stub_everything
-          mock_world_creator = mock('world creator')
-          story_runner = StoryRunner.new(stub_scenario_runner, mock_world_creator)
-          story_runner.Story 'story', 'narrative' do
-            Scenario 'scenario1' do end
-            Scenario 'scenario2' do end
-          end
-
-          # expect
-          mock_world_creator.should_receive(:create).twice
-
-          # when
-          story_runner.run_stories
-
-          # then
-        end
-
-        it 'should notify listeners of the scenario count when the run starts' do
-          # given
-          story_runner = StoryRunner.new(stub_everything)
-          mock_listener1 = stub_everything('listener1')
-          mock_listener2 = stub_everything('listener2')
-          story_runner.add_listener(mock_listener1)
-          story_runner.add_listener(mock_listener2)
-
-          story_runner.Story 'story1', 'narrative1' do
-            Scenario 'scenario1' do end
-          end
-          story_runner.Story 'story2', 'narrative2' do
-            Scenario 'scenario2' do end
-            Scenario 'scenario3' do end
-          end
-
-          # expect
-          mock_listener1.should_receive(:run_started).with(3)
-          mock_listener2.should_receive(:run_started).with(3)
-
-          # when
-          story_runner.run_stories
-
-          # then
-        end
-
-        it 'should notify listeners when a story starts' do
-          # given
-          story_runner = StoryRunner.new(stub_everything)
-          mock_listener1 = stub_everything('listener1')
-          mock_listener2 = stub_everything('listener2')
-          story_runner.add_listener(mock_listener1)
-          story_runner.add_listener(mock_listener2)
-
-          story_runner.Story 'story1', 'narrative1' do
-            Scenario 'scenario1' do end
-          end
-          story_runner.Story 'story2', 'narrative2' do
-            Scenario 'scenario2' do end
-            Scenario 'scenario3' do end
-          end
-
-          # expect
-          mock_listener1.should_receive(:story_started).with('story1', 'narrative1')
-          mock_listener1.should_receive(:story_ended).with('story1', 'narrative1')
-          mock_listener2.should_receive(:story_started).with('story2', 'narrative2')
-          mock_listener2.should_receive(:story_ended).with('story2', 'narrative2')
-
-          # when
-          story_runner.run_stories
-
-          # then
-        end
-
-        it 'should notify listeners when the run ends' do
-          # given
-          story_runner = StoryRunner.new(stub_everything)
-          mock_listener1 = stub_everything('listener1')
-          mock_listener2 = stub_everything('listener2')
-          story_runner.add_listener mock_listener1
-          story_runner.add_listener mock_listener2
-          story_runner.Story 'story1', 'narrative1' do
-            Scenario 'scenario1' do end
-          end
-
-          # expect
-          mock_listener1.should_receive(:run_ended)
-          mock_listener2.should_receive(:run_ended)
-
-          # when
-          story_runner.run_stories
-
-          # then
-        end
-
-        it 'should run a story in an instance of a specified class' do
-          # given
-          scenario_world_catcher = ScenarioWorldCatcher.new
-          story_runner = StoryRunner.new(scenario_world_catcher)
-          story_runner.Story 'title', 'narrative', :type => String do
-            Scenario 'scenario' do end
-          end
-
-          # when
-          story_runner.run_stories
-
-          # then
-          scenario_world_catcher.worlds[0].should be_kind_of(String)
-          scenario_world_catcher.worlds[0].should be_kind_of(World)
-        end
-
-        it 'should pass initialization params through to the constructed instance' do
-          # given
-          scenario_world_catcher = ScenarioWorldCatcher.new
-          story_runner = StoryRunner.new(scenario_world_catcher)
-          story_runner.Story 'title', 'narrative', :type => Array, :args => [3]  do
-            Scenario 'scenario' do end
-          end
-
-          # when
-          story_runner.run_stories
-
-          # then
-          scenario_world_catcher.worlds[0].should be_kind_of(Array)
-          scenario_world_catcher.worlds[0].size.should == 3
-        end
-
-        it 'should find a scenario in the current story by name' do
-          # given
-          story_runner = StoryRunner.new(ScenarioRunner.new)
-          $scenario = nil
-
-          story_runner.Story 'title', 'narrative' do
-            Scenario 'first scenario' do
-            end
-            Scenario 'second scenario' do
-              $scenario = StoryRunner.scenario_from_current_story 'first scenario'
-            end
-          end
-
-          # when
-          story_runner.run_stories
-
-          # then
-          $scenario.name.should == 'first scenario'
-        end
-
-        it "should clean the steps between stories" do
-          #given
-          story_runner = StoryRunner.new(ScenarioRunner.new)
-          result = mock 'result'
-
-          step1 = Step.new('step') do
-            result.one
-          end
-          steps1 = StepGroup.new
-          steps1.add :when, step1
-
-          story_runner.Story 'title', 'narrative', :steps => steps1 do
-            Scenario 'first scenario' do
-              When 'step'
-            end
-          end
-
-          step2 = Step.new('step') do
-            result.two
-          end
-          steps2 = StepGroup.new
-          steps2.add :when, step2
-
-          story_runner.Story 'title2', 'narrative', :steps => steps2 do
-            Scenario 'second scenario' do
-              When 'step'
-            end
-          end
-
-          #then
-          result.should_receive(:one)
-          result.should_receive(:two)
-
-          #when
-          story_runner.run_stories
-        end
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/story/runner_spec.rb

@@ -1,106 +0,0 @@
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
-  module Story
-    describe Runner, "module" do
-      def dev_null
-        io = StringIO.new
-        def io.write(str)
-          str.to_s.size
-        end
-        return io
-      end
-
-      before :each do
-        Kernel.stub!(:at_exit)
-        @stdout, $stdout = $stdout, dev_null
-        @argv = Array.new(ARGV)
-        @runner_module = Runner.dup
-        @world_creator = World.dup
-        @runner_module.module_eval { @run_options = @story_runner = @scenario_runner = @world_creator = nil }
-      end
-
-      after :each do
-        $stdout = @stdout
-        ARGV.replace @argv
-        @runner_module.module_eval { @run_options = @story_runner = @scenario_runner = @world_creator = nil }
-      end
-
-      it 'should wire up a singleton StoryRunner' do
-        @runner_module.story_runner.should_not be_nil
-      end
-
-      it 'should set its options based on ARGV' do
-        # given
-        ARGV << '--dry-run'
-
-        # when
-        options = @runner_module.run_options
-
-        # then
-        options.dry_run.should be_true
-      end
-
-      it 'should add a reporter to the runner classes' do
-        # given
-        story_runner = mock('story runner', :null_object => true)
-        scenario_runner = mock('scenario runner', :null_object => true)
-        world_creator = mock('world', :null_object => true)
-
-        @runner_module::class_eval { @world_creator = world_creator }
-        @runner_module::StoryRunner.stub!(:new).and_return(story_runner)
-        @runner_module::ScenarioRunner.stub!(:new).and_return(scenario_runner)
-
-        # expect
-        world_creator.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
-        story_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
-        scenario_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
-
-        # when
-        @runner_module.story_runner
-      end
-
-      it 'should add a documenter to the runner classes if one is specified' do
-        # given
-        ARGV << "--format" << "html"
-        story_runner = mock('story runner', :null_object => true)
-        scenario_runner = mock('scenario runner', :null_object => true)
-        world_creator = mock('world', :null_object => true)
-
-        @runner_module::class_eval { @world_creator = world_creator }
-        @runner_module::StoryRunner.stub!(:new).and_return(story_runner)
-        @runner_module::ScenarioRunner.stub!(:new).and_return(scenario_runner)
-
-        # expect
-        world_creator.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
-        story_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
-        scenario_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
-
-        # when
-        @runner_module.story_runner
-      end
-
-      it 'should add any registered listener to the runner classes' do
-        # given
-        ARGV << "--format" << "html"
-        story_runner = mock('story runner', :null_object => true)
-        scenario_runner = mock('scenario runner', :null_object => true)
-        world_creator = mock('world', :null_object => true)
-
-        @runner_module::class_eval { @world_creator = world_creator }
-        @runner_module::StoryRunner.stub!(:new).and_return(story_runner)
-        @runner_module::ScenarioRunner.stub!(:new).and_return(scenario_runner)
-
-        listener = Object.new
-
-        # expect
-        world_creator.should_receive(:add_listener).with(listener)
-        story_runner.should_receive(:add_listener).with(listener)
-        scenario_runner.should_receive(:add_listener).with(listener)
-
-        # when
-        @runner_module.register_listener listener
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/story/scenario_spec.rb

@@ -1,20 +0,0 @@
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
-  module Story
-    describe Scenario do
-      it 'should not raise an error if no body is supplied' do
-        # given
-        story = StoryBuilder.new.to_story
-
-        # when
-        error = exception_from do
-          Scenario.new story, 'name'
-        end
-
-        # then
-        error.should be_nil
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/story/step_group_spec.rb

@@ -1,157 +0,0 @@
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
-  module Story
-    describe StepGroup do
-      before(:each) do
-        @step_group = StepGroup.new
-      end
-
-      it "should not find a matcher if empty" do
-        @step_group.find(:given, "this and that").should be_nil
-      end
-
-      it "should create a given_scenario matcher" do
-        step = @step_group.given_scenario("this and that") {}
-        @step_group.find(:given_scenario, "this and that").should_not be_nil
-        @step_group.find(:given_scenario, "this and that").should equal(step)
-      end
-
-      it "should create a given matcher" do
-        step = @step_group.given("this and that") {}
-        @step_group.find(:given, "this and that").should equal(step)
-      end
-
-      it "should create a when matcher" do
-        step = @step_group.when("this and that") {}
-        @step_group.find(:when, "this and that").should equal(step)
-      end
-
-      it "should create a them matcher" do
-        step = @step_group.then("this and that") {}
-        @step_group.find(:then, "this and that").should equal(step)
-      end
-
-      it "should add a matcher object" do
-        step = Step.new("this and that") {}
-        @step_group.add(:given, step)
-        @step_group.find(:given, "this and that").should equal(step)
-      end
-
-      it "should add it matchers to another StepGroup (with one given)" do
-        source = StepGroup.new
-        target = StepGroup.new
-        step = source.given("this and that") {}
-        source.add_to target
-        target.find(:given, "this and that").should equal(step)
-      end
-
-      it "should add it matchers to another StepGroup (with some of each type)" do
-        source = StepGroup.new
-        target = StepGroup.new
-        given_scenario = source.given_scenario("1") {}
-        given = source.given("1") {}
-        when1 = source.when("1") {}
-        when2 = source.when("2") {}
-        then1 = source.then("1") {}
-        then2 = source.then("2") {}
-        then3 = source.then("3") {}
-        source.add_to target
-        target.find(:given_scenario, "1").should equal(given_scenario)
-        target.find(:given, "1").should equal(given)
-        target.find(:when, "1").should equal(when1)
-        target.find(:when, "2").should equal(when2)
-        target.find(:then, "1").should equal(then1)
-        target.find(:then, "2").should equal(then2)
-        target.find(:then, "3").should equal(then3)
-      end
-
-      it "should append another collection" do
-        matchers_to_append = StepGroup.new
-        step = matchers_to_append.given("this and that") {}
-        @step_group << matchers_to_append
-        @step_group.find(:given, "this and that").should equal(step)
-      end
-
-      it "should append several other collections" do
-        matchers_to_append = StepGroup.new
-        more_matchers_to_append = StepGroup.new
-        first_matcher = matchers_to_append.given("this and that") {}
-        second_matcher = more_matchers_to_append.given("and the other") {}
-        @step_group << matchers_to_append
-        @step_group << more_matchers_to_append
-        @step_group.find(:given, "this and that").should equal(first_matcher)
-        @step_group.find(:given, "and the other").should equal(second_matcher)
-      end
-
-      it "should yield itself on initialization" do
-        begin
-          $step_group_spec_step = nil
-          matchers = StepGroup.new do |matchers|
-            $step_group_spec_step = matchers.given("foo") {}
-          end
-          $step_group_spec_step.matches?("foo").should be_true
-        ensure
-          $step_group_spec_step = nil
-        end
-      end
-
-      it "should support defaults" do
-        class StepGroupSubclass < StepGroup
-          steps do |add|
-            add.given("foo") {}
-          end
-        end
-        StepGroupSubclass.new.find(:given, "foo").should_not be_nil
-      end
-
-      it "should create a Given" do
-        sub = Class.new(StepGroup).new
-        step = sub.Given("foo") {}
-        sub.find(:given, "foo").should == step
-      end
-
-      it "should create a When" do
-        sub = Class.new(StepGroup).new
-        step = sub.When("foo") {}
-        sub.find(:when, "foo").should == step
-      end
-
-      it "should create a Then" do
-        sub = Class.new(StepGroup).new
-        step = sub.Then("foo") {}
-        sub.find(:then, "foo").should == step
-      end
-
-      it "should create steps in a block" do
-        sub = Class.new(StepGroup).new do
-          Given("a given") {}
-          When("a when") {}
-          Then("a then") {}
-        end
-        sub.find(:given, "a given").should_not be_nil
-        sub.find(:when, "a when").should_not be_nil
-        sub.find(:then, "a then").should_not be_nil
-      end
-
-      it "should clear itself" do
-        step = @step_group.given("this and that") {}
-        @step_group.clear
-        @step_group.find(:given, "this and that").should be_nil
-      end
-
-      it "should tell you when it is empty" do
-        @step_group.should be_empty
-      end
-
-      it "should tell you when it is not empty" do
-        @step_group.given("this and that") {}
-        @step_group.should_not be_empty
-      end
-
-      it "should handle << nil" do
-        @step_group << nil
-      end
-    end
-  end
-end

data/rails_plugins/rspec/spec/spec/story/step_mother_spec.rb

@@ -1,72 +0,0 @@
-require File.dirname(__FILE__) + '/story_helper'
-
-module Spec
-  module Story
-    describe StepMother do
-      it 'should store a step by name and type' do
-        # given
-        step_mother = StepMother.new
-        step = Step.new("a given", &lambda {})
-        step_mother.store(:given, step)
-
-        # when
-        found = step_mother.find(:given, "a given")
-
-        # then
-        found.should == step
-      end
-
-      it 'should NOT raise an error if a step is missing' do
-        # given
-        step_mother = StepMother.new
-
-        # then
-        lambda do
-          # when
-          step_mother.find(:given, "doesn't exist")
-        end.should_not raise_error
-      end
-
-      it "should create a default step which raises a pending error" do
-        # given
-        step_mother = StepMother.new
-
-        # when
-        step = step_mother.find(:given, "doesn't exist")
-
-        # then
-        step.should be_an_instance_of(Step)
-
-        lambda do
-          step.perform(Object.new, "doesn't exist")
-        end.should raise_error(Spec::Example::ExamplePendingError, /Unimplemented/)
-      end
-
-      it 'should clear itself' do
-        # given
-        step_mother = StepMother.new
-        step = Step.new("a given") do end
-        step_mother.store(:given, step)
-
-        # when
-        step_mother.clear
-
-        # then
-        step_mother.should be_empty
-      end
-
-      it "should use assigned steps" do
-        step_mother = StepMother.new
-
-        step = Step.new('step') {}
-        step_group = StepGroup.new
-        step_group.add(:given, step)
-
-        step_mother.use(step_group)
-
-        step_mother.find(:given, "step").should equal(step)
-      end
-
-    end
-  end
-end