gherkin 2.12.2 → 3.2.0

data/spec/gherkin/formatter/filter_formatter_spec.rb

@@ -1,204 +0,0 @@
-# encoding: utf-8
-require 'stringio'
-require 'spec_helper'
-require 'gherkin/parser/parser'
-require 'gherkin/formatter/filter_formatter'
-require 'gherkin/formatter/pretty_formatter'
-
-module Gherkin
-  module Formatter
-    describe FilterFormatter do
-      attr_accessor :file
-
-      before do
-        self.file = 'complex_for_filtering.feature'
-      end
-
-      def verify_filter(filters, *line_ranges)
-        io = StringIO.new
-        pretty_formatter = Gherkin::Formatter::PrettyFormatter.new(io, true, false)
-        filter_formatter = Gherkin::Formatter::FilterFormatter.new(pretty_formatter, filters)
-        parser = Gherkin::Parser::Parser.new(filter_formatter)
-
-        path = File.dirname(__FILE__) + "/../fixtures/" + file
-        source = File.new(path).read + "# __EOF__"
-        parser.parse(source, path, 0)
-        
-        source_lines = source.split("\n")
-        expected = (line_ranges.map do |line_range|
-          source_lines[(line_range.first-1..line_range.last-1)]
-        end.flatten).join("\n").gsub(/# __EOF__/, '')
-        io.string.strip.should == expected.strip
-      end
-
-      context "invalid mix" do
-        it "should throw exception on different filters" do
-          lambda do
-            verify_filter(['@tag1', /regexp/, 88], 1..61)
-          end.should raise_exception(/Inconsistent filters/)
-        end
-      end
-
-      context "tags" do
-        it "should filter on feature tag" do
-          verify_filter(['@tag1'], 1..61)
-        end
-
-        it "should filter on scenario tag" do
-          verify_filter(['@tag4'], 1..19)
-        end
-
-        it "should filter on abother scenario tag" do
-          verify_filter(['@tag3'], 1..37)
-        end
-
-        it "should filter on scenario outline tag" do
-          verify_filter(['@more'], 1..14, 46..61)
-        end
-
-        it "should filter on first examples tag" do
-          verify_filter(['@neat'], 1..14, 46..55)
-        end
-
-        it "should filter on second examples tag" do
-          verify_filter(['@hamster'], 1..14, 46..49, 56..61)
-        end
-
-        it "should not replay examples from ignored scenario outline" do
-          self.file = 'scenario_outline_with_tags.feature'
-          verify_filter(['~@wip'], 1..2, 12..14)
-        end
-
-        it "should not replay examples from ignored scenario outline" do
-          self.file = 'scenario_outline_with_tags.feature'
-          verify_filter(['~@wip'], 1..2, 12..14)
-        end
-
-        it "should not choke on examples with only header" do
-          self.file = 'examples_with_only_header.feature'
-          verify_filter(['@failing'], 1..7, 12..15)
-        end
-      end
-
-      context "names" do
-        it "should filter on scenario name" do
-          verify_filter([/Reading a Scenario/], 1..19)
-        end
-
-        it "should filter on scenario outline name" do
-          verify_filter([/More/], 1..14, 46..61)
-        end
-
-        it "should filter on first examples name" do
-          verify_filter([/Neato/], 1..14, 46..55)
-        end
-
-        it "should filter on second examples name" do
-          verify_filter([/Rodents/], 1..14, 46..49, 56..61)
-        end
-
-        it "should filter on various names" do
-          self.file = 'hantu_pisang.feature'
-          verify_filter([/Pisang/], 1..8, 19..32)
-        end
-
-        it "should filter on background name" do
-          self.file = 'hantu_pisang.feature'
-          verify_filter([/The background/], 1..5)
-        end
-
-        it "should not choke on examples with only header" do
-          self.file = 'examples_with_only_header.feature'
-          verify_filter([/B/], 1..7, 12..15)
-        end
-      end
-
-      context "lines" do
-        context "on the same line as feature element keyword" do
-          it "should filter on scenario without line" do
-            self.file = 'scenario_without_steps.feature'
-            verify_filter([3], 1..4)
-          end
-
-          it "should filter on scenario line" do
-            verify_filter([16], 1..19)
-          end
-
-          it "should filter on scenario outline line" do
-            verify_filter([47], 1..14, 46..61)
-          end
-
-          it "should filter on first examples line" do
-            verify_filter([51], 1..14, 46..55)
-          end
-
-          it "should filter on second examples line" do
-            verify_filter([57], 1..14, 46..49, 56..61)
-          end
-
-          it "should not choke on examples with only header" do
-            self.file = 'examples_with_only_header.feature'
-            verify_filter([13], 1..7, 12..15)
-            verify_filter([14], 1..7, 12..15)
-          end
-
-          it "should fix issue 145" do
-            self.file = 'issue_145.feature'
-            verify_filter([14], 1..2, 6..12, 14..14)
-          end
-
-          it "should fix issue 145 more tests" do
-            self.file = 'issue_145.feature'
-            verify_filter([13,15,18], 1..2, 6..13, 15..15, 16..18)
-          end
-        end
-
-        context "on the same line as step keyword" do
-          it "should filter on step line" do
-            verify_filter([17], 1..19)
-          end
-
-          it "should filter on scenario outline line" do
-            verify_filter([48], 1..14, 46..61)
-          end
-        end
-
-        context "on examples header line" do
-          it "should filter on first table" do
-            verify_filter([52], 1..14, 46..55)
-          end
-
-          it "should filter on second table" do
-            verify_filter([58], 1..14, 46..49, 56..61)
-          end
-        end
-
-        context "on examples example line" do
-          it "should filter on first table" do
-            verify_filter([53], 1..14, 46..53, 55..55)
-          end
-        end
-
-        context "on tag line" do
-          it "should filter on first tag" do
-            verify_filter([15], 1..19)
-          end
-        end
-
-        context "multiline argument" do
-          it "should filter on table line" do
-            verify_filter([36], 1..14, 20..37)
-          end
-
-          it "should filter on first pystring quote" do
-            verify_filter([41], 1..14, 38..45)
-          end
-
-          it "should filter on last pystring quote" do
-            verify_filter([44], 1..14, 38..45)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/gherkin/formatter/json_formatter_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-require 'gherkin/formatter/json_formatter'
-require 'gherkin/formatter/model'
-require 'multi_json'
-require 'stringio'
-
-module Gherkin
-  module Formatter
-    describe JSONFormatter do
-      it "renders results" do
-        io = StringIO.new
-        f = JSONFormatter.new(io)
-        f.uri("f.feature")
-        f.feature(Model::Feature.new([], [], "Feature", "ff", "", 1, "ff"))
-        f.scenario(Model::Scenario.new([], [], "Scenario", "ss", "", 2, "ff/ss"))
-
-        f.step(Model::Step.new([], "Given ", "g", 3, nil, nil))
-        f.match(Model::Match.new([], "def.rb:33"))
-        data = "abc"
-        if defined?(JRUBY_VERSION)
-          data = data.to_java_bytes
-        end
-        f.embedding("mime-type", data)
-        f.write("step output")
-
-        f.result(Model::Result.new(:passed, 1, nil))
-
-        f.step(Model::Step.new([], "When ", "w", 4, nil, nil))
-        f.match(Model::Match.new([], "def.rb:44"))
-        f.result(Model::Result.new(:passed, 1, nil))
-
-        f.after(Model::Match.new([], "def.rb:55"), Model::Result.new(:passed, 22, nil))
-
-        f.eof
-        f.done
-
-        expected = %{
-          [
-            {
-              "id": "ff",
-              "uri": "f.feature",
-              "keyword": "Feature",
-              "name": "ff",
-              "line": 1,
-              "description": "",
-              "elements": [
-                {
-                  "id": "ff/ss",
-                  "keyword": "Scenario",
-                  "name": "ss",
-                  "line": 2,
-                  "description": "",
-                  "type": "scenario",
-                  "steps": [
-                    {
-                      "keyword": "Given ",
-                      "name": "g",
-                      "line": 3,
-                      "match": {
-                        "location": "def.rb:33"
-                      },
-                      "embeddings": [
-                        {
-                          "mime_type": "mime-type",
-                          "data": "YWJj"
-                        }
-                      ],
-                      "output": [
-                        "step output"
-                      ],
-                      "result": {
-                        "status": "passed",
-                        "duration": 1
-                      }
-                    },
-                    {
-                      "keyword": "When ",
-                      "name": "w",
-                      "line": 4,
-                      "match": {
-                        "location": "def.rb:44"
-                      },
-                      "result": {
-                        "status": "passed",
-                        "duration": 1
-                      }
-                    }
-                  ],
-                  "after": [
-                    {
-                      "match":{
-                        "location":"def.rb:55"
-                      },
-                      "result":{
-                        "status":"passed",
-                        "duration": 22
-                      }
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-        MultiJson.load(io.string).should == MultiJson.load(expected)
-      end
-
-      it "renders results as pretty json" do
-        io = StringIO.new
-        f = JSONFormatter.new(io)
-        f.uri("f.feature")
-        f.feature(Model::Feature.new([], [], "Feature", nil, nil, nil, nil))
-        f.eof
-        f.done
-
-        expected = %{
-          [
-            {
-              "keyword": "Feature",
-              "uri": "f.feature"
-            }
-          ]
-        }
-        io.string.should == MultiJson.dump(MultiJson.load(expected), :pretty => true)
-      end
-
-      it 'supports append_duration' do
-        io = StringIO.new
-        f = JSONFormatter.new(io)
-        f.uri("f.feature")
-        f.feature(Model::Feature.new([], [], "Feature", "ff", "", 1, "ff"))
-        f.scenario(Model::Scenario.new([], [], "Scenario", "ss", "", 2, "ff/ss"))
-        f.step(Model::Step.new([], "Given ", "g", 3, nil, nil))
-        f.match(Model::Match.new([], "def.rb:33"))
-        f.result(Model::Result.new(:passed, 3, nil))
-        f.append_duration(1)
-        f.eof
-        f.done
-        expected = %{
-          [
-            {
-              "id": "ff",
-              "uri": "f.feature",
-              "keyword": "Feature",
-              "name": "ff",
-              "line": 1,
-              "description": "",
-              "elements": [
-                {
-                  "id": "ff/ss",
-                  "keyword": "Scenario",
-                  "name": "ss",
-                  "line": 2,
-                  "description": "",
-                  "type": "scenario",
-                  "steps": [
-                    {
-                      "keyword": "Given ",
-                      "name": "g",
-                      "line": 3,
-                      "match": {
-                        "location": "def.rb:33"
-                      },
-                      "result": {
-                        "status": "passed",
-                        "duration": 1000000000
-                      }
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-        MultiJson.load(io.string).should == MultiJson.load(expected)
-      end
-    end
-  end
-end

data/spec/gherkin/formatter/model_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'gherkin/formatter/model'
-require 'gherkin/formatter/argument'
-
-module Gherkin
-  module Formatter
-    module Model
-      describe Tag do
-        it "should be equal when name is equal" do
-          tags = [Tag.new('@x', 1), Tag.new('@y', 2), Tag.new('@x', 3)]
-          tags.to_a.uniq.length.should == 2
-        end
-      end
-
-      describe Step do
-        it "should provide arguments for outline tokens" do
-          step = Step.new([], 'Given ', "I have <number> cukes in <whose> belly", 10, nil, nil)
-          step.outline_args.map{|arg| [arg.offset, arg.val]}.should == [[7, "<number>"], [25, "<whose>"]]
-        end
-
-        it "should provide no arguments when there are no outline tokens" do
-          step = Step.new([], 'Given ', "I have 33 cukes in my belly", 10, nil, nil)
-          step.outline_args.to_a.should == []
-        end
-      end
-    end
-  end
-end

data/spec/gherkin/formatter/pretty_formatter_spec.rb

@@ -1,184 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'gherkin/formatter/pretty_formatter'
-require 'gherkin/formatter/argument'
-require 'gherkin/formatter/model'
-require 'gherkin/listener/formatter_listener'
-require 'gherkin/parser/parser'
-require 'stringio'
-
-module Gherkin
-  module Formatter
-    describe PrettyFormatter do
-      include AnsiEscapes
-
-      def assert_io_include(s)
-        actual = @io.string
-        actual.gsub!(/\e\[m/, "\e[0m") # JANSI resets without the 0.
-        actual.should include(s)
-      end
-      
-      def assert_pretty(input, expected_output=input)
-        [true, false].each do |force_ruby|
-          io = StringIO.new
-          pf = Gherkin::Formatter::PrettyFormatter.new(io, true, false)
-          parser = Gherkin::Parser::Parser.new(pf, true, "root", force_ruby)
-          parser.parse(input, "test.feature", 0)
-          output = io.string
-          output.should == expected_output
-        end
-      end
-
-      before do
-        @io = StringIO.new
-        @f = Gherkin::Formatter::PrettyFormatter.new(@io, false, true)
-      end
-
-      it "should print comments when scenario is longer" do
-        @f.uri("features/foo.feature")
-        @f.feature(Model::Feature.new([], [], "Feature", "Hello", "World", 1, "hello"))
-
-        @f.scenario(Model::Scenario.new([], [], "Scenario", "The scenario", "", 4, "the-scenario"))
-        @f.step(Model::Step.new([], "Given ", "some stuff", 5, nil, nil))
-        @f.step(Model::Step.new([], "When ", "foo", 6, nil, nil))
-
-        @f.match(Model::Match.new([], "features/step_definitions/bar.rb:56"))
-        @f.result(Model::Result.new('passed', 22, nil))
-
-        @f.match(Model::Match.new([], "features/step_definitions/bar.rb:96"))
-        @f.result(Model::Result.new('passed', 33, nil))
-
-        @f.eof()
-
-        assert_io_include(%{Feature: Hello
-  World
-
-  Scenario: The scenario #{comments}# features/foo.feature:4#{reset}
-})
-        assert_io_include(%{    #{passed}Given #{reset}#{passed}some stuff#{reset}     #{comments}# features/step_definitions/bar.rb:56#{reset}
-})
-        assert_io_include(%{    #{passed}When #{reset}#{passed}foo#{reset}             #{comments}# features/step_definitions/bar.rb:96#{reset}
-})
-      end
-
-      it "should print comments when step is longer" do
-        @f.uri("features/foo.feature")
-        @f.feature(Model::Feature.new([], [], "Feature", "Hello", "World", 1, "hello"))
-        step = Model::Step.new([], "Given ", "some stuff that is longer", 5, nil, nil)
-        match = Model::Match.new([], "features/step_definitions/bar.rb:56")
-        result = Model::Result.new('passed', 0, nil)
-
-        @f.scenario(Model::Scenario.new([], [], "Scenario", "The scenario", "", 4, "the-scenario"))
-        @f.step(step)
-        @f.match(match)
-        @f.result(result)
-
-        @f.eof()
-
-        assert_io_include(%{Feature: Hello
-  World
-
-  Scenario: The scenario            #{comments}# features/foo.feature:4#{reset}
-})
-        assert_io_include(%{    #{passed}Given #{reset}#{passed}some stuff that is longer#{reset} #{comments}# features/step_definitions/bar.rb:56#{reset}
-})
-      end
-
-      it "should highlight arguments for regular steps" do
-        @f.uri("foo.feature")
-        @f.scenario(Model::Scenario.new([], [], "Scenario", "Lots of cukes", "", 3, "lots-of-cukes"))
-        @f.step(Model::Step.new([], "Given ", "I have 999 cukes in my belly", 3, nil, nil))
-        @f.match(Model::Match.new([Gherkin::Formatter::Argument.new(7, '999')], nil))
-        @f.result(Model::Result.new('passed', 6, nil))
-        @f.eof()
-
-        assert_io_include(
-          "\n" +
-          "  Scenario: Lots of cukes              \e[90m# foo.feature:3\e[0m\n")
-        assert_io_include(
-          "    #{passed}Given #{reset}#{passed}I have #{reset}#{passed_arg}999#{reset}#{passed} cukes in my belly#{reset}\n"
-        )
-      end
-
-      # See https://github.com/cucumber/gherkin/pull/171
-      it "should highlight arguments when there are optional arguments" do
-        @f.uri("foo.feature")
-        @f.scenario(Model::Scenario.new([], [], "Scenario", "Lots of cukes", "", 3, "lots-of-cukes"))
-        @f.step(Model::Step.new([], "Given ", "I have 999 cukes in my belly", 3, nil, nil))
-        @f.match(Model::Match.new([
-          Gherkin::Formatter::Argument.new(nil, nil), # An optional argument
-          Gherkin::Formatter::Argument.new(7, '999')
-        ], nil))
-        @f.result(Model::Result.new('passed', 6, nil))
-        @f.eof()
-
-        assert_io_include(
-          "\n" +
-          "  Scenario: Lots of cukes              \e[90m# foo.feature:3\e[0m\n"
-        )
-        assert_io_include(
-          "    #{passed}Given #{reset}#{passed}I have #{reset}#{passed_arg}999#{reset}#{passed} cukes in my belly#{reset}\n"
-        )
-      end
-
-      it "should prettify scenario" do
-        assert_pretty(%{Feature: Feature Description
-  Some preamble
-
-  Scenario: Scenario Description
-    description has multiple lines
-
-    Given there is a step
-      """
-      with
-        pystrings
-      """
-    And there is another step
-      | æ   | \\|o |
-      | \\|a | ø\\\\ |
-    Then we will see steps
-})
-      end
-
-
-      it "should prettify scenario outline with table" do
-        assert_pretty(%{# A feature comment
-@foo
-Feature: Feature Description
-  Some preamble
-  on several
-  lines
-
-  # A Scenario Outline comment
-  @bar
-  Scenario Outline: Scenario Ouline Description
-    Given there is a
-      """
-      string with <foo>
-      """
-    And a table with
-      | <bar> |
-      | <baz> |
-
-    @zap @boing
-    Examples: Examples Description
-      | foo    | bar  | baz         |
-      | Banana | I    | am hungry   |
-      | Beer   | You  | are thirsty |
-      | Bed    | They | are tired   |
-})
-      end
-
-      it "should preserve tabs" do
-        assert_pretty(IO.read(File.dirname(__FILE__) + '/tabs.feature'), IO.read(File.dirname(__FILE__) + '/spaces.feature'))
-      end
-
-      it "should escape backslashes and pipes" do
-        io = StringIO.new
-        f = Gherkin::Formatter::PrettyFormatter.new(io, true, false)
-        f.__send__(:table, [Gherkin::Formatter::Model::DataTableRow.new([], ['|', '\\'], 1)])
-        io.string.should == '      | \\| | \\\\ |' + "\n"
-      end
-    end
-  end
-end