Updated to latest rspec
[gitorious:georgyos-clone.git] / vendor / plugins / rspec / 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 lines beginning with '#'" do
248                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "#this is ignored"])
249                           end
250
251                           it "should not ignore lines beginning with non-keywords" do
252           @story_mediator.should_receive(:add_to_last).with("\nthis is not ignored")
253                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "this is not ignored"])
254                           end
255                           
256                         end
257
258                         describe StoryParser, "in When state" do
259                           before(:each) do
260                             @story_mediator = mock("story_mediator")
261                         @parser = StoryParser.new(@story_mediator)
262                             @story_mediator.stub!(:create_story)
263                             @story_mediator.stub!(:create_scenario)
264                             @story_mediator.should_receive(:create_given).with("first")
265                             @story_mediator.should_receive(:create_when).with("else")
266                           end
267                           
268                           it "should create a Story for Story" do
269           @story_mediator.should_receive(:create_story).with("number two","")
270                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When: else", "Story: number two"])
271                           end
272                           
273                           it "should create a Scenario for Scenario" do
274           @story_mediator.should_receive(:create_scenario).with("number two")
275                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Scenario: number two"])
276                           end
277
278                           it "should create Given for Given" do
279           @story_mediator.should_receive(:create_given).with("second")
280                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Given second"])
281                           end
282                           
283                           it "should create Given for Given:" do
284           @story_mediator.should_receive(:create_given).with("second")
285                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Given: second"])
286                           end
287                           
288                           it "should create a second When for When" do
289           @story_mediator.should_receive(:create_when).with("ever")
290                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "When ever"])
291                           end
292                           
293                           it "should create a second When for When:" do
294           @story_mediator.should_receive(:create_when).with("ever")
295                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "When: ever"])
296                           end
297                           
298                           it "should create a second When for And" do
299           @story_mediator.should_receive(:create_when).with("ever")
300                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "And ever"])
301                           end
302                           
303                           it "should create a second When for And:" do
304           @story_mediator.should_receive(:create_when).with("ever")
305                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "And: ever"])
306                           end
307                           
308                           it "should create a Then for Then" do
309           @story_mediator.should_receive(:create_then).with("and there")
310                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then and there"])
311                           end
312                           
313                           it "should create a Then for Then:" do
314           @story_mediator.should_receive(:create_then).with("and there")
315                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: and there"])
316                           end
317                           
318                           it "should ignore lines beginning with '#'" do
319                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "#this is ignored"])
320                           end
321
322                           it "should not ignore lines beginning with non-keywords" do
323           @story_mediator.should_receive(:add_to_last).with("\nthis is not ignored")
324                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When else", "this is not ignored"])
325                           end
326                         end
327
328                         describe StoryParser, "in Then state" do
329                           before(:each) do
330                             @story_mediator = mock("story_mediator")
331                         @parser = StoryParser.new(@story_mediator)
332                             @story_mediator.stub!(:create_story)
333                             @story_mediator.stub!(:create_scenario)
334                             @story_mediator.should_receive(:create_given).with("first")
335                             @story_mediator.should_receive(:create_when).with("else")
336                             @story_mediator.should_receive(:create_then).with("what")
337                           end
338                           
339                           it "should create a Story for Story" do
340           @story_mediator.should_receive(:create_story).with("number two","")
341                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Story: number two"])
342                           end
343                           
344                           it "should create a Scenario for Scenario" do
345           @story_mediator.should_receive(:create_scenario).with("number two")
346                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Scenario: number two"])
347                           end
348
349                           it "should create Given for Given" do
350           @story_mediator.should_receive(:create_given).with("second")
351                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Given second"])
352                           end
353                           
354                           it "should create Given for Given:" do
355           @story_mediator.should_receive(:create_given).with("second")
356                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "Given: second"])
357                           end
358                           
359                           it "should create When for When" do
360           @story_mediator.should_receive(:create_when).with("ever")
361                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "When ever"])
362                           end
363                           
364                           it "should create When for When:" do
365           @story_mediator.should_receive(:create_when).with("ever")
366                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "When: ever"])
367                           end
368
369                           it "should create a Then for Then" do
370           @story_mediator.should_receive(:create_then).with("and there")
371                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Then and there"])
372                           end
373                           
374                           it "should create a Then for Then:" do
375           @story_mediator.should_receive(:create_then).with("and there")
376                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "Then: and there"])
377                           end
378
379                           it "should create a second Then for And" do
380           @story_mediator.should_receive(:create_then).with("ever")
381                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "And ever"])
382                           end
383                           
384                           it "should create a second Then for And:" do
385           @story_mediator.should_receive(:create_then).with("ever")
386                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "And: ever"])
387                           end
388
389                           
390                           it "should ignore lines beginning with '#'" do
391                                         @parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "#this is ignored"])
392                           end
393
394                           it "should not ignore lines beginning with non-keywords" do
395           @story_mediator.should_receive(:add_to_last).with("\nthis is not ignored")
396                                         @parser.parse(["Story: s", "Scenario: s", "Given: first", "When else", "Then what", "this is not ignored"])
397                           end
398                         end
399                 end
400         end
401 end