vendor/gems/rspec-1.1.2/spec/spec/story/runner/story_parser_spec.rb

   1 require File.dirname(__FILE__) + '/../story_helper'
   2
   3 module Spec
   4         module Story
   5                 module Runner
   6
   7                         describe StoryParser do
   8                           before(:each) do
   9                             @story_mediator = mock("story_mediator")
  10                         @parser = StoryParser.new(@story_mediator)
  11                           end
  12
  13                           it "should parse no lines" do
  14                                         @parser.parse([])
  15                           end
  16
  17                           it "should ignore text before the first Story: begins" do
  18                             @story_mediator.should_not_receive(:create_scenario)
  19                             @story_mediator.should_not_receive(:create_given)
  20                             @story_mediator.should_not_receive(:create_when)
  21                             @story_mediator.should_not_receive(:create_then)
  22                             @story_mediator.should_receive(:create_story).with("simple addition", "")
  23                                         @parser.parse(["Here is a bunch of text", "about a calculator and all the things", "that it will do", "Story: simple addition"])
  24                     end
  25
  26                           it "should create a story" do
  27                             @story_mediator.should_receive(:create_story).with("simple addition", "")
  28                                         @parser.parse(["Story: simple addition"])
  29                           end
  30
  31                           it "should create a story when line has leading spaces" do
  32                             @story_mediator.should_receive(:create_story).with("simple addition", "")
  33                                         @parser.parse(["    Story: simple addition"])
  34                           end
  35
  36                           it "should add a one line narrative to the story" do
  37                             @story_mediator.should_receive(:create_story).with("simple addition","narrative")
  38                                         @parser.parse(["Story: simple addition","narrative"])
  39                           end
  40
  41                           it "should add a multi line narrative to the story" do
  42                             @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2\nline 3")
  43                                         @parser.parse(["Story: simple addition","narrative line 1", "line 2", "line 3"])
  44                           end
  45
  46                           it "should exclude blank lines from the narrative" do
  47                             @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2")
  48                                         @parser.parse(["Story: simple addition","narrative line 1", "", "line 2"])
  49                           end
  50
  51                           it "should exclude Scenario from the narrative" do
  52                             @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2")
  53                             @story_mediator.should_receive(:create_scenario)
  54                                         @parser.parse(["Story: simple addition","narrative line 1", "line 2", "Scenario: add one plus one"])
  55                           end
  56
  57                         end
  58
  59                         describe StoryParser, "in Story state" do
  60                           before(:each) do
  61                             @story_mediator = mock("story_mediator")
  62                         @parser = StoryParser.new(@story_mediator)
  63                             @story_mediator.stub!(:create_story)
  64                           end
  65
  66                           it "should create a second Story for Story" do
  67           @story_mediator.should_receive(:create_story).with("number two","")
  68                                         @parser.parse(["Story: s", "Story: number two"])
  69                           end
  70
  71                           it "should include And in the narrative" do
  72           @story_mediator.should_receive(:create_story).with("s","And foo")
  73           @story_mediator.should_receive(:create_scenario).with("bar")
  74                                         @parser.parse(["Story: s", "And foo", "Scenario: bar"])
  75                           end
  76
  77                           it "should create a Scenario for Scenario" do
  78           @story_mediator.should_receive(:create_scenario).with("number two")
  79                                         @parser.parse(["Story: s", "Scenario: number two"])
  80                           end
  81
  82                           it "should include Given in the narrative" do
  83           @story_mediator.should_receive(:create_story).with("s","Given foo")
  84           @story_mediator.should_receive(:create_scenario).with("bar")
  85                                         @parser.parse(["Story: s", "Given foo", "Scenario: bar"])
  86                           end
  87
  88                           it "should include Given: in the narrative" do
  89           @story_mediator.should_receive(:create_story).with("s","Given: foo")
  90           @story_mediator.should_receive(:create_scenario).with("bar")
  91                                         @parser.parse(["Story: s", "Given: foo", "Scenario: bar"])
  92                           end
  93
  94                           it "should include When in the narrative" do
  95           @story_mediator.should_receive(:create_story).with("s","When foo")
  96           @story_mediator.should_receive(:create_scenario).with("bar")
  97                                         @parser.parse(["Story: s", "When foo", "Scenario: bar"])
  98                           end
  99
 100                           it "should include Then in the narrative" do
 101           @story_mediator.should_receive(:create_story).with("s","Then foo")
 102           @story_mediator.should_receive(:create_scenario).with("bar")
 103                                         @parser.parse(["Story: s", "Then foo", "Scenario: bar"])
 104                           end
 105
 106                           it "should include other in the story" do
 107           @story_mediator.should_receive(:create_story).with("s","narrative")
 108                                         @parser.parse(["Story: s", "narrative"])
 109                           end
 110                         end
 111
 112                         describe StoryParser, "in Scenario state" do
 113                           before(:each) do
 114                             @story_mediator = mock("story_mediator")
 115                         @parser = StoryParser.new(@story_mediator)
 116                             @story_mediator.stub!(:create_story)
 117                             @story_mediator.stub!(:create_scenario)
 118                           end
 119
 120                           it "should create a Story for Story" do
 121           @story_mediator.should_receive(:create_story).with("number two","")
 122                                         @parser.parse(["Story: s", "Scenario: s", "Story: number two"])
 123                           end
 124
 125                           it "should create a Scenario for Scenario" do
 126           @story_mediator.should_receive(:create_scenario).with("number two")
 127                                         @parser.parse(["Story: s", "Scenario: s", "Scenario: number two"])
 128                           end
 129
 130                           it "should raise for And" do
 131                             lambda {
 132                                         @parser.parse(["Story: s", "Scenario: s", "And second"])
 133                             }.should raise_error(IllegalStepError, /^Illegal attempt to create a And after a Scenario/)
 134                           end
 135
 136                           it "should create a Given for Given" do
 137           @story_mediator.should_receive(:create_given).with("gift")
 138                                         @parser.parse(["Story: s", "Scenario: s", "Given gift"])
 139                           end
 140
 141                           it "should create a Given for Given:" do
 142           @story_mediator.should_receive(:create_given).with("gift")
 143                                         @parser.parse(["Story: s", "Scenario: s", "Given: gift"])
 144                           end
 145
 146                           it "should create a GivenScenario for GivenScenario" do
 147           @story_mediator.should_receive(:create_given_scenario).with("previous")
 148                                         @parser.parse(["Story: s", "Scenario: s", "GivenScenario previous"])
 149                           end
 150
 151                           it "should create a GivenScenario for GivenScenario:" do
 152           @story_mediator.should_receive(:create_given_scenario).with("previous")
 153                                         @parser.parse(["Story: s", "Scenario: s", "GivenScenario: previous"])
 154                           end
 155
 156                           it "should transition to Given state after GivenScenario" do
 157           @story_mediator.stub!(:create_given_scenario)
 158                                         @parser.parse(["Story: s", "Scenario: s", "GivenScenario previous"])
 159                                         @parser.instance_eval{@state}.should be_an_instance_of(StoryParser::GivenState)
 160                           end
 161
 162                           it "should transition to Given state after GivenScenario:" do
 163           @story_mediator.stub!(:create_given_scenario)
 164                                         @parser.parse(["Story: s", "Scenario: s", "GivenScenario: previous"])
 165                                         @parser.instance_eval{@state}.should be_an_instance_of(StoryParser::GivenState)
 166                           end
 167
 168                           it "should create a When for When" do
 169           @story_mediator.should_receive(:create_when).with("ever")
 170                                         @parser.parse(["Story: s", "Scenario: s", "When ever"])
 171                           end
 172
 173                           it "should create a When for When:" do
 174           @story_mediator.should_receive(:create_when).with("ever")
 175                                         @parser.parse(["Story: s", "Scenario: s", "When: ever"])
 176                           end
 177
 178                           it "should create a Then for Then" do
 179           @story_mediator.should_receive(:create_then).with("and there")
 180                                         @parser.parse(["Story: s", "Scenario: s", "Then and there"])
 181                           end
 182
 183                           it "should create a Then for Then:" do
 184           @story_mediator.should_receive(:create_then).with("and there")
 185                                         @parser.parse(["Story: s", "Scenario: s", "Then: and there"])
 186                           end
 187
 188                           it "should ignore other" do
 189                                         @parser.parse(["Story: s", "Scenario: s", "this is ignored"])
 190                           end
 191                         end
 192
 193                         describe StoryParser, "in Given state" do
 194                           before(:each) do
 195                             @story_mediator = mock("story_mediator")
 196                         @parser = StoryParser.new(@story_mediator)
 197                             @story_mediator.stub!(:create_story)
 198                             @story_mediator.stub!(:create_scenario)
 199                             @story_mediator.should_receive(:create_given).with("first")
 200                           end
 201
 202                           it "should create a Story for Story" do
 203           @story_mediator.should_receive(:create_story).with("number two","")
 204                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "Story: number two"])
 205                           end
 206
 207                           it "should create a Scenario for Scenario" do
 208           @story_mediator.should_receive(:create_scenario).with("number two")
 209                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "Scenario: number two"])
 210                           end
 211
 212                           it "should create a second Given for Given" do
 213           @story_mediator.should_receive(:create_given).with("second")
 214                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "Given second"])
 215                           end
 216
 217                           it "should create a second Given for And" do
 218           @story_mediator.should_receive(:create_given).with("second")
 219                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "And second"])
 220                           end
 221
 222                           it "should create a second Given for And:" do
 223           @story_mediator.should_receive(:create_given).with("second")
 224                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "And: second"])
 225                           end
 226
 227                           it "should create a When for When" do
 228           @story_mediator.should_receive(:create_when).with("ever")
 229                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When ever"])
 230                           end
 231
 232                           it "should create a When for When:" do
 233           @story_mediator.should_receive(:create_when).with("ever")
 234                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When: ever"])
 235                           end
 236
 237                           it "should create a Then for Then" do
 238           @story_mediator.should_receive(:create_then).with("and there")
 239                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "Then and there"])
 240                           end
 241
 242                           it "should create a Then for Then:" do
 243           @story_mediator.should_receive(:create_then).with("and there")
 244                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "Then: and there"])
 245                           end
 246
 247                           it "should ignore other" do
 248                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "this is ignored"])
 249                           end
 250                         end
 251
 252                         describe StoryParser, "in When state" do
 253                           before(:each) do
 254                             @story_mediator = mock("story_mediator")
 255                         @parser = StoryParser.new(@story_mediator)
 256                             @story_mediator.stub!(:create_story)
 257                             @story_mediator.stub!(:create_scenario)
 258                             @story_mediator.should_receive(:create_given).with("first")
 259                             @story_mediator.should_receive(:create_when).with("else")
 260                           end
 261
 262                           it "should create a Story for Story" do
 263           @story_mediator.should_receive(:create_story).with("number two","")
 264                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When: else", "Story: number two"])
 265                           end
 266
 267                           it "should create a Scenario for Scenario" do
 268           @story_mediator.should_receive(:create_scenario).with("number two")
 269                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Scenario: number two"])
 270                           end
 271
 272                           it "should create Given for Given" do
 273           @story_mediator.should_receive(:create_given).with("second")
 274                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Given second"])
 275                           end
 276
 277                           it "should create Given for Given:" do
 278           @story_mediator.should_receive(:create_given).with("second")
 279                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Given: second"])
 280                           end
 281
 282                           it "should create a second When for When" do
 283           @story_mediator.should_receive(:create_when).with("ever")
 284                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "When ever"])
 285                           end
 286
 287                           it "should create a second When for When:" do
 288           @story_mediator.should_receive(:create_when).with("ever")
 289                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "When: ever"])
 290                           end
 291
 292                           it "should create a second When for And" do
 293           @story_mediator.should_receive(:create_when).with("ever")
 294                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "And ever"])
 295                           end
 296
 297                           it "should create a second When for And:" do
 298           @story_mediator.should_receive(:create_when).with("ever")
 299                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "And: ever"])
 300                           end
 301
 302                           it "should create a Then for Then" do
 303           @story_mediator.should_receive(:create_then).with("and there")
 304                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then and there"])
 305                           end
 306
 307                           it "should create a Then for Then:" do
 308           @story_mediator.should_receive(:create_then).with("and there")
 309                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: and there"])
 310                           end
 311
 312                           it "should ignore other" do
 313                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "this is ignored"])
 314                           end
 315                         end
 316
 317                         describe StoryParser, "in Then state" do
 318                           before(:each) do
 319                             @story_mediator = mock("story_mediator")
 320                         @parser = StoryParser.new(@story_mediator)
 321                             @story_mediator.stub!(:create_story)
 322                             @story_mediator.stub!(:create_scenario)
 323                             @story_mediator.should_receive(:create_given).with("first")
 324                             @story_mediator.should_receive(:create_when).with("else")
 325                             @story_mediator.should_receive(:create_then).with("what")
 326                           end
 327
 328                           it "should create a Story for Story" do
 329           @story_mediator.should_receive(:create_story).with("number two","")
 330                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Story: number two"])
 331                           end
 332
 333                           it "should create a Scenario for Scenario" do
 334           @story_mediator.should_receive(:create_scenario).with("number two")
 335                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Scenario: number two"])
 336                           end
 337
 338                           it "should create Given for Given" do
 339           @story_mediator.should_receive(:create_given).with("second")
 340                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Given second"])
 341                           end
 342
 343                           it "should create Given for Given:" do
 344           @story_mediator.should_receive(:create_given).with("second")
 345                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "Given: second"])
 346                           end
 347
 348                           it "should create When for When" do
 349           @story_mediator.should_receive(:create_when).with("ever")
 350                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "When ever"])
 351                           end
 352
 353                           it "should create When for When:" do
 354           @story_mediator.should_receive(:create_when).with("ever")
 355                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "When: ever"])
 356                           end
 357
 358                           it "should create a Then for Then" do
 359           @story_mediator.should_receive(:create_then).with("and there")
 360                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Then and there"])
 361                           end
 362
 363                           it "should create a Then for Then:" do
 364           @story_mediator.should_receive(:create_then).with("and there")
 365                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "Then: and there"])
 366                           end
 367
 368                           it "should create a second Then for And" do
 369           @story_mediator.should_receive(:create_then).with("ever")
 370                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "And ever"])
 371                           end
 372
 373                           it "should create a second Then for And:" do
 374           @story_mediator.should_receive(:create_then).with("ever")
 375                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "And: ever"])
 376                           end
 377
 378                           it "should ignore other" do
 379                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "this is ignored"])
 380                           end
 381                         end
 382                 end
 383         end
 384 end