← Back to branch summary

~ubuntu-branches/ubuntu/wily/cucumber/wily-proposed

« back to all changes in this revision

Viewing changes to spec/cucumber/formatter/pretty_spec.rb

  • Committer: Package Import Robot
  • Author(s): Cédric Boutillier, Antonio Terceiro, Cédric Boutillier
  • Date: 2015-06-20 16:52:32 UTC
  • mfrom: (1.1.7)
  • Revision ID: package-import@ubuntu.com-20150620165232-hznc8mxma08er27p
Tags: 2.0.0-1
http://bugs.debian.org/767215
[ Antonio Terceiro ]
* debian/cucumber.pod: fix typo in manpage (Closes: #767215)

[ Cédric Boutillier ]
* Imported Upstream version 2.0.0
* rename the file in debian/missing-source to remove -min suffix, and make
  lintian happy
* reproducibility: use last changelog date to build the manpage
* update 0004-Update_default_binary_path.patch
* drop 0001-Remove-rubygems-bundler-stuff-from-spec_helper.patch, not needed
  anymore
* build-depend on pry
* depend on ruby-cucumber-core

Show diffs side-by-side

added added

removed removed

Lines of Context:
spec/cucumber/formatter/pretty_spec.rb
13
13
        before(:each) do
14
14
          Cucumber::Term::ANSIColor.coloring = false
15
15
          @out = StringIO.new
16
 
          @formatter = Pretty.new(step_mother, @out, {})
 
16
          @formatter = Pretty.new(runtime, @out, {})
17
17
        end
18
18
 
19
19
        describe "given a single feature" do
21
21
            run_defined_feature
22
22
          end
23
23
 
24
 
          describe "basic feature" do
 
24
          describe "with a scenario with no steps" do
25
25
            define_feature <<-FEATURE
26
 
            Feature: Bananas
27
 
              In order to find my inner monkey
28
 
              As a human
29
 
              I must eat bananas
 
26
          Feature: Banana party
 
27
 
 
28
            Scenario: Monkey eats banana
30
29
            FEATURE
31
30
 
32
 
            it "prints out the feature description" do
33
 
              @out.string.should include "Feature: Bananas"
34
 
              @out.string.should include "I must eat bananas"
 
31
            it "outputs the scenario name" do
 
32
              expect(@out.string).to include "Scenario: Monkey eats banana"
35
33
            end
36
 
 
37
34
          end
38
35
 
 
36
 
39
37
          describe "with a scenario" do
40
38
            define_feature <<-FEATURE
41
39
          Feature: Banana party
45
43
            FEATURE
46
44
 
47
45
            it "outputs the scenario name" do
48
 
              @out.string.should include "Scenario: Monkey eats banana"
49
 
            end
50
 
            it "outputs the step" do
51
 
              @out.string.should include "Given there are bananas"
 
46
              expect(@out.string).to include "Scenario: Monkey eats banana"
 
47
            end
 
48
 
 
49
            it "outputs the step" do
 
50
              expect(@out.string).to include "Given there are bananas"
 
51
            end
 
52
          end
 
53
 
 
54
          describe "with a background" do
 
55
            define_feature <<-FEATURE
 
56
Feature: Banana party
 
57
 
 
58
  Background: 
 
59
    Given a tree
 
60
 
 
61
  Scenario: Monkey eats banana
 
62
    Given there are bananas
 
63
            FEATURE
 
64
 
 
65
            it "outputs the gherkin" do
 
66
              expect(@out.string).to include(self.class.feature_content)
 
67
            end
 
68
 
 
69
            it "outputs the scenario name" do
 
70
              expect(@out.string).to include "Scenario: Monkey eats banana"
 
71
            end
 
72
 
 
73
            it "outputs the step" do
 
74
              expect(@out.string).to include "Given there are bananas"
52
75
            end
53
76
          end
54
77
 
81
104
               | carrots  |
82
105
              OUTPUT
83
106
              lines.split("\n").each do |line|
84
 
                @out.string.should include line.strip
 
107
                expect(@out.string).to include line.strip
85
108
              end
86
109
            end
 
110
 
87
111
            it "has 4 undefined scenarios" do
88
 
              @out.string.should include "4 scenarios (4 undefined)"
 
112
              expect(@out.string).to include "4 scenarios (4 undefined)"
89
113
            end
 
114
 
90
115
            it "has 4 undefined steps" do
91
 
              @out.string.should include "4 steps (4 undefined)"
92
 
            end
93
 
 
 
116
              expect(@out.string).to include "4 steps (4 undefined)"
 
117
            end
 
118
 
 
119
            context 'when the examples table header is wider than the rows' do
 
120
              define_feature <<-FEATURE
 
121
          Feature: Monkey Business
 
122
 
 
123
            Scenario Outline: Types of monkey
 
124
              Given there are <Types of monkey>
 
125
 
 
126
              Examples:
 
127
               | Types of monkey |
 
128
               | Hominidae       |
 
129
              FEATURE
 
130
 
 
131
              it "outputs the scenario outline" do
 
132
                lines = <<-OUTPUT
 
133
              Examples:
 
134
               | Types of monkey |
 
135
               | Hominidae       |
 
136
                OUTPUT
 
137
                lines.split("\n").each do |line|
 
138
                  expect(@out.string).to include line.strip
 
139
                end
 
140
              end
 
141
            end
 
142
          end
 
143
 
 
144
          # To ensure https://rspec.lighthouseapp.com/projects/16211/tickets/475 remains fixed.
 
145
          describe "with a scenario outline with a pystring" do
 
146
            define_feature <<-FEATURE
 
147
          Feature:
 
148
            Scenario Outline: Monkey eats a balanced diet
 
149
              Given a multiline string:
 
150
                """
 
151
                Monkeys eat <things>
 
152
                """
 
153
 
 
154
              Examples:
 
155
               | things |
 
156
               | apples |
 
157
            FEATURE
 
158
 
 
159
            it "outputs the scenario outline" do
 
160
              lines = <<-OUTPUT
 
161
              Given a multiline string:
 
162
                """
 
163
                Monkeys eat <things>
 
164
                """
 
165
 
 
166
              Examples:
 
167
               | things |
 
168
               | apples |
 
169
              OUTPUT
 
170
              lines.split("\n").each do |line|
 
171
                expect(@out.string).to include line.strip
 
172
              end
 
173
            end
94
174
          end
95
175
 
96
176
          describe "with a step with a py string" do
105
185
            FEATURE
106
186
 
107
187
            it "displays the pystring nested" do
108
 
              @out.string.should include <<OUTPUT
 
188
              expect(@out.string).to include <<OUTPUT
109
189
      """
110
190
      foo
111
191
      """
125
205
            FEATURE
126
206
 
127
207
            it "displays the multiline string" do
128
 
              @out.string.should include <<OUTPUT
 
208
              expect(@out.string).to include <<OUTPUT
129
209
    Given there are monkeys:
130
210
      | name |
131
211
      | foo  |
149
229
            FEATURE
150
230
 
151
231
            it "displays the table for the background" do
152
 
              @out.string.should include <<OUTPUT
 
232
              expect(@out.string).to include <<OUTPUT
153
233
    Given table:
154
234
      | a | b |
155
235
      | c | d |
156
236
OUTPUT
157
237
            end
 
238
 
158
239
            it "displays the table for the scenario" do
159
 
              @out.string.should include <<OUTPUT
 
240
              expect(@out.string).to include <<OUTPUT
160
241
    Given another table:
161
242
      | e | f |
162
243
      | g | h |
181
262
            FEATURE
182
263
 
183
264
            it "displays the background py string" do
184
 
              @out.string.should include <<OUTPUT
 
265
              expect(@out.string).to include <<OUTPUT
185
266
    Given stuff:
186
267
      """
187
268
      foo
188
269
      """
189
270
OUTPUT
190
271
            end
 
272
 
191
273
            it "displays the scenario py string" do
192
 
              @out.string.should include <<OUTPUT
 
274
              expect(@out.string).to include <<OUTPUT
193
275
    Given more stuff:
194
276
      """
195
277
      bar
197
279
OUTPUT
198
280
            end
199
281
          end
 
282
 
 
283
          describe "with output from hooks" do
 
284
            define_feature <<-FEATURE
 
285
          Feature:
 
286
            Scenario:
 
287
              Given this step passes
 
288
            Scenario Outline:
 
289
              Given this step <status>
 
290
              Examples:
 
291
              | status |
 
292
              | passes  |
 
293
            FEATURE
 
294
 
 
295
            define_steps do
 
296
              Before do
 
297
                puts "Before hook"
 
298
              end
 
299
              AfterStep do
 
300
                puts "AfterStep hook"
 
301
              end
 
302
              After do
 
303
                puts "After hook"
 
304
              end
 
305
              Given(/^this step passes$/) {}
 
306
            end
 
307
 
 
308
            it "displays hook output appropriately " do
 
309
              expect( @out.string ).to include <<OUTPUT
 
310
Feature: 
 
311
 
 
312
  Scenario: 
 
313
      Before hook
 
314
    Given this step passes
 
315
      AfterStep hook
 
316
      After hook
 
317
 
 
318
  Scenario Outline: 
 
319
    Given this step <status>
 
320
 
 
321
    Examples: 
 
322
      | status |
 
323
      | passes |  Before hook, AfterStep hook, After hook
 
324
 
 
325
2 scenarios (2 passed)
 
326
2 steps (2 passed)
 
327
OUTPUT
 
328
            end
 
329
          end
 
330
 
 
331
          describe "with background and output from hooks" do
 
332
            define_feature <<-FEATURE
 
333
          Feature:
 
334
            Background:
 
335
              Given this step passes
 
336
            Scenario:
 
337
              Given this step passes
 
338
            FEATURE
 
339
 
 
340
            define_steps do
 
341
              Before do
 
342
                puts "Before hook"
 
343
              end
 
344
              AfterStep do
 
345
                puts "AfterStep hook"
 
346
              end
 
347
              After do
 
348
                puts "After hook"
 
349
              end
 
350
              Given(/^this step passes$/) {}
 
351
            end
 
352
 
 
353
            it "displays hook output appropriately " do
 
354
              expect( @out.string ).to include <<OUTPUT
 
355
Feature: 
 
356
 
 
357
  Background: 
 
358
      Before hook
 
359
    Given this step passes
 
360
      AfterStep hook
 
361
 
 
362
  Scenario: 
 
363
    Given this step passes
 
364
      AfterStep hook
 
365
      After hook
 
366
 
 
367
1 scenario (1 passed)
 
368
2 steps (2 passed)
 
369
OUTPUT
 
370
            end
 
371
          end
200
372
        end
201
373
      end
202
374
 
204
376
        before(:each) do
205
377
          Cucumber::Term::ANSIColor.coloring = false
206
378
          @out = StringIO.new
207
 
          @formatter = Pretty.new(step_mother, @out, {:no_multiline => true})
 
379
          @formatter = Pretty.new(runtime, @out, {:no_multiline => true})
208
380
        end
209
381
 
210
382
        describe "given a single feature" do
212
384
            run_defined_feature
213
385
          end
214
386
 
215
 
          describe "basic feature" do
216
 
            define_feature <<-FEATURE
217
 
            Feature: Bananas
218
 
              In order to find my inner monkey
219
 
              As a human
220
 
              I must eat bananas
221
 
            FEATURE
222
 
 
223
 
            it "prints out the feature description" do
224
 
              @out.string.should include "Feature: Bananas"
225
 
              @out.string.should include "I must eat bananas"
226
 
            end
227
 
 
228
 
          end
229
 
 
230
387
          describe "with a scenario" do
231
388
            define_feature <<-FEATURE
232
389
          Feature: Banana party
236
393
            FEATURE
237
394
 
238
395
            it "outputs the scenario name" do
239
 
              @out.string.should include "Scenario: Monkey eats banana"
 
396
              expect(@out.string).to include "Scenario: Monkey eats banana"
240
397
            end
 
398
 
241
399
            it "outputs the step" do
242
 
              @out.string.should include "Given there are bananas"
 
400
              expect(@out.string).to include "Given there are bananas"
243
401
            end
244
402
          end
245
403
 
272
430
               | carrots  |
273
431
              OUTPUT
274
432
              lines.split("\n").each do |line|
275
 
                @out.string.should include line.strip
 
433
                expect(@out.string).to include line.strip
276
434
              end
277
435
            end
 
436
 
278
437
            it "has 4 undefined scenarios" do
279
 
              @out.string.should include "4 scenarios (4 undefined)"
 
438
              expect(@out.string).to include "4 scenarios (4 undefined)"
280
439
            end
 
440
 
281
441
            it "has 4 undefined steps" do
282
 
              @out.string.should include "4 steps (4 undefined)"
 
442
              expect(@out.string).to include "4 steps (4 undefined)"
283
443
            end
284
 
 
285
444
          end
286
445
 
287
446
          describe "with a step with a py string" do
296
455
            FEATURE
297
456
 
298
457
            it "does not display the pystring" do
299
 
              @out.string.should_not include <<OUTPUT
 
458
              expect(@out.string).not_to include <<OUTPUT
300
459
      """
301
460
      foo
302
461
      """
316
475
            FEATURE
317
476
 
318
477
            it "does not display the multiline string" do
319
 
              @out.string.should_not include <<OUTPUT
 
478
              expect(@out.string).not_to include <<OUTPUT
320
479
      | name |
321
480
      | foo  |
322
481
      | bar  |
339
498
            FEATURE
340
499
 
341
500
            it "does not display the table for the background" do
342
 
              @out.string.should_not include <<OUTPUT
 
501
              expect(@out.string).not_to include <<OUTPUT
343
502
      | a | b |
344
503
      | c | d |
345
504
OUTPUT
346
505
            end
347
506
            it "does not display the table for the scenario" do
348
 
              @out.string.should_not include <<OUTPUT
 
507
              expect(@out.string).not_to include <<OUTPUT
349
508
      | e | f |
350
509
      | g | h |
351
510
OUTPUT
369
528
            FEATURE
370
529
 
371
530
            it "does not display the background py string" do
372
 
              @out.string.should_not include <<OUTPUT
 
531
              expect(@out.string).not_to include <<OUTPUT
373
532
      """
374
533
      foo
375
534
      """
376
535
OUTPUT
377
536
            end
378
537
            it "does not display the scenario py string" do
379
 
              @out.string.should_not include <<OUTPUT
 
538
              expect(@out.string).not_to include <<OUTPUT
380
539
      """
381
540
      bar
382
541
      """
386
545
        end
387
546
      end
388
547
 
 
548
      context "In --expand mode" do
 
549
        let(:runtime)   { Runtime.new({:expand => true})}
 
550
        before(:each) do
 
551
          Cucumber::Term::ANSIColor.coloring = false
 
552
          @out = StringIO.new
 
553
          @formatter = Pretty.new(runtime, @out, {})
 
554
        end
 
555
 
 
556
        describe "given a single feature" do
 
557
          before(:each) do
 
558
            run_defined_feature
 
559
          end
 
560
 
 
561
          describe "with a scenario outline" do
 
562
            define_feature <<-FEATURE
 
563
          Feature: Fud Pyramid
 
564
 
 
565
            Scenario Outline: Monkey eats a balanced diet
 
566
              Given there are <Things>
 
567
 
 
568
              Examples: Fruit
 
569
               | Things  |
 
570
               | apples  |
 
571
               | bananas |
 
572
              Examples: Vegetables
 
573
               | Things   |
 
574
               | broccoli |
 
575
               | carrots  |
 
576
            FEATURE
 
577
 
 
578
            it "outputs the instantiated scenarios" do
 
579
              lines = <<-OUTPUT
 
580
              Examples: Fruit
 
581
                Scenario: | apples |
 
582
                  Given there are apples
 
583
                Scenario: | bananas |
 
584
                  Given there are bananas
 
585
              Examples: Vegetables
 
586
                Scenario: | broccoli |
 
587
                  Given there are broccoli
 
588
                Scenario: | carrots |
 
589
                  Given there are carrots
 
590
              OUTPUT
 
591
              lines.split("\n").each do |line|
 
592
                expect(@out.string).to include line.strip
 
593
              end
 
594
            end
 
595
          end
 
596
 
 
597
          describe "with a scenario outline in en-lol" do
 
598
            define_feature <<-FEATURE
 
599
          # language: en-lol
 
600
          OH HAI: STUFFING
 
601
 
 
602
            MISHUN SRSLY: CUCUMBR
 
603
              I CAN HAZ IN TEH BEGINNIN <BEGINNIN> CUCUMBRZ
 
604
              WEN I EAT <EAT> CUCUMBRZ
 
605
              DEN I HAS <EAT> CUCUMBERZ IN MAH BELLY
 
606
              AN IN TEH END <KTHXBAI> CUCUMBRZ KTHXBAI
 
607
 
 
608
              EXAMPLZ:
 
609
               | BEGINNIN | EAT | KTHXBAI |
 
610
               |    3     |  2  |    1    |
 
611
            FEATURE
 
612
 
 
613
            it "outputs localized text" do
 
614
              lines = <<-OUTPUT
 
615
          OH HAI: STUFFING
 
616
 
 
617
            MISHUN SRSLY: CUCUMBR
 
618
              I CAN HAZ IN TEH BEGINNIN <BEGINNIN> CUCUMBRZ
 
619
              WEN I EAT <EAT> CUCUMBRZ
 
620
              DEN I HAS <EAT> CUCUMBERZ IN MAH BELLY
 
621
              AN IN TEH END <KTHXBAI> CUCUMBRZ KTHXBAI
 
622
              EXAMPLZ:
 
623
                MISHUN: | 3 | 2 | 1 |
 
624
                  I CAN HAZ IN TEH BEGINNIN 3 CUCUMBRZ
 
625
                  WEN I EAT 2 CUCUMBRZ
 
626
                  DEN I HAS 2 CUCUMBERZ IN MAH BELLY
 
627
                  AN IN TEH END 1 CUCUMBRZ KTHXBAI
 
628
              OUTPUT
 
629
              lines.split("\n").each do |line|
 
630
                expect(@out.string).to include line.strip
 
631
              end
 
632
            end
 
633
          end
 
634
        end
 
635
      end
 
636
 
 
637
      context "In --expand mode with --source as an option" do
 
638
        let(:runtime)   { Runtime.new({:expand => true})}
 
639
        before(:each) do
 
640
          Cucumber::Term::ANSIColor.coloring = false
 
641
          @out = StringIO.new
 
642
          @formatter = Pretty.new(runtime, @out, {:source => true})
 
643
        end
 
644
 
 
645
        describe "given a single feature" do
 
646
          before(:each) do
 
647
            run_defined_feature
 
648
          end
 
649
 
 
650
          describe "with a scenario outline" do
 
651
            define_feature <<-FEATURE
 
652
          Feature: Fud Pyramid
 
653
 
 
654
            Scenario Outline: Monkey eats a balanced diet
 
655
              Given there are <Things>
 
656
 
 
657
              Examples: Fruit
 
658
               | Things  |
 
659
               | apples  |
 
660
               | bananas |
 
661
              Examples: Vegetables
 
662
               | Things   |
 
663
               | broccoli |
 
664
               | carrots  |
 
665
            FEATURE
 
666
 
 
667
            it "includes the source in the output" do
 
668
              lines = <<-OUTPUT
 
669
              Scenario Outline: Monkey eats a balanced diet # spec.feature:3
 
670
                Given there are <Things>                    # spec.feature:4
 
671
                Examples: Fruit
 
672
                  Scenario: | apples |                          # spec.feature:8
 
673
                    Given there are apples                      # spec.feature:8
 
674
                  Scenario: | bananas |                         # spec.feature:9
 
675
                    Given there are bananas                     # spec.feature:9
 
676
                Examples: Vegetables
 
677
                  Scenario: | broccoli |                        # spec.feature:12
 
678
                    Given there are broccoli                    # spec.feature:12
 
679
                  Scenario: | carrots |                         # spec.feature:13
 
680
                    Given there are carrots                     # spec.feature:13
 
681
              OUTPUT
 
682
              lines.split("\n").each do |line|
 
683
                expect(@out.string).to include line.strip
 
684
              end
 
685
            end
 
686
 
 
687
            context "With very wide cells" do
 
688
              define_feature <<-FEATURE
 
689
            Feature: Monkey Business
 
690
 
 
691
              Scenario Outline: Types of monkey
 
692
                Given there are <Types of monkey>
 
693
 
 
694
                Examples:
 
695
                 | Types of monkey | Extra                  |
 
696
                 | Hominidae       | Very long cell content |
 
697
              FEATURE
 
698
 
 
699
              it "the scenario line controls the source indentation" do
 
700
                lines = <<-OUTPUT
 
701
              Examples:
 
702
                 Scenario: | Hominidae | Very long cell content | # spec.feature:8
 
703
                   Given there are Hominidae                      # spec.feature:8
 
704
 
 
705
                OUTPUT
 
706
                lines.split("\n").each do |line|
 
707
                  expect(@out.string).to include line.strip
 
708
                end
 
709
              end
 
710
            end
 
711
          end
 
712
        end
 
713
      end
 
714
 
 
715
      context "snippets contain relevant keyword replacements" do
 
716
 
 
717
        before(:each) do
 
718
          Cucumber::Term::ANSIColor.coloring = false
 
719
          @out = StringIO.new
 
720
          @formatter = Pretty.new(runtime, @out, {snippets: true})
 
721
          run_defined_feature
 
722
        end
 
723
 
 
724
        describe "With a scenario that has undefined steps" do
 
725
          define_feature <<-FEATURE
 
726
          Feature: Banana party
 
727
 
 
728
            Scenario: many monkeys eat many things
 
729
              Given there are bananas and apples
 
730
              And other monkeys are around
 
731
              When one monkey eats a banana
 
732
              And the other monkeys eat all the apples
 
733
              Then bananas remain
 
734
              But there are no apples left
 
735
            FEATURE
 
736
 
 
737
          it "containes snippets with 'And' or 'But' replaced by previous step name" do
 
738
            expect(@out.string).to include("Given(/^there are bananas and apples$/)")
 
739
            expect(@out.string).to include("Given(/^other monkeys are around$/)")
 
740
            expect(@out.string).to include("When(/^one monkey eats a banana$/)")
 
741
            expect(@out.string).to include("When(/^the other monkeys eat all the apples$/)")
 
742
            expect(@out.string).to include("Then(/^bananas remain$/)")
 
743
            expect(@out.string).to include("Then(/^there are no apples left$/)")
 
744
          end
 
745
        end
 
746
 
 
747
        describe "With a scenario that uses * and 'But'" do
 
748
          define_feature <<-FEATURE
 
749
          Feature: Banana party
 
750
 
 
751
            Scenario: many monkeys eat many things
 
752
              * there are bananas and apples
 
753
              * other monkeys are around
 
754
              When one monkey eats a banana
 
755
              * the other monkeys eat all the apples
 
756
              Then bananas remain
 
757
              * there are no apples left
 
758
          FEATURE
 
759
          it "replaces the first step with 'Given'" do
 
760
            expect(@out.string).to include("Given(/^there are bananas and apples$/)")
 
761
          end
 
762
          it "uses actual keywords as the 'previous' keyword for future replacements" do
 
763
            expect(@out.string).to include("Given(/^other monkeys are around$/)")
 
764
            expect(@out.string).to include("When(/^the other monkeys eat all the apples$/)")
 
765
            expect(@out.string).to include("Then(/^there are no apples left$/)")
 
766
          end
 
767
        end
 
768
 
 
769
        describe "With a scenario where the only undefined step uses 'And'" do
 
770
          define_feature <<-FEATURE
 
771
          Feature:
 
772
 
 
773
            Scenario:
 
774
              Given this step passes
 
775
              Then this step passes
 
776
              And this step is undefined
 
777
          FEATURE
 
778
          define_steps do
 
779
            Given(/^this step passes$/) {}
 
780
          end
 
781
          it "uses actual keyword of the previous passing step for the undefined step" do
 
782
            expect(@out.string).to include("Then(/^this step is undefined$/)")
 
783
          end
 
784
        end
 
785
 
 
786
        describe "With scenarios where the first step is undefined and uses '*'" do
 
787
          define_feature <<-FEATURE
 
788
          Feature:
 
789
 
 
790
            Scenario:
 
791
              * this step is undefined
 
792
              Then this step passes
 
793
 
 
794
            Scenario:
 
795
              * this step is also undefined
 
796
              Then this step passes
 
797
          FEATURE
 
798
          define_steps do
 
799
            Given(/^this step passes$/) {}
 
800
          end
 
801
          it "uses 'Given' as actual keyword the step in each scenario" do
 
802
            expect(@out.string).to include("Given(/^this step is undefined$/)")
 
803
            expect(@out.string).to include("Given(/^this step is also undefined$/)")
 
804
          end
 
805
        end
 
806
 
 
807
        describe "with a scenario in en-lol" do
 
808
          define_feature <<-FEATURE
 
809
          # language: en-lol
 
810
          OH HAI: STUFFING
 
811
 
 
812
            MISHUN: CUCUMBR
 
813
              I CAN HAZ IN TEH BEGINNIN CUCUMBRZ
 
814
              AN I EAT CUCUMBRZ
 
815
            FEATURE
 
816
          it "uses actual keyword of the previous passing step for the undefined step" do
 
817
            expect(@out.string).to include("ICANHAZ(/^I EAT CUCUMBRZ$/)")
 
818
          end
 
819
        end
 
820
      end
389
821
    end
390
822
  end
391
823
end