cucumber-gherkin 27.0.0 → 30.0.4

data/spec/gherkin/dialect_spec.rb

@@ -1,13 +0,0 @@
-# coding: utf-8
-require 'rspec'
-require 'gherkin/dialect'
-
-module Gherkin
-  describe Dialect do
-    it 'provides an interface to the keywords of a dialect' do
-      dialect_en = Dialect.for('en')
-
-      expect(dialect_en.feature_keywords).to eq(['Feature', 'Business Need', 'Ability'])
-    end
-  end
-end

data/spec/gherkin/gherkin_line_spec.rb

@@ -1,36 +0,0 @@
-require 'rspec'
-require 'gherkin/gherkin_line'
-
-describe Gherkin::GherkinLine do
-  context '#tags' do
-    def tags(line)
-      Gherkin::GherkinLine.new(line, 12).tags.map(&:text)
-    end
-
-    it 'allows any non-space characters in a tag' do
-      expect(tags("   @foo:bar  @zap🥒yo")).to eq(['@foo:bar', '@zap🥒yo'])
-    end
-  end
-
-  context '#table_cells' do
-    def cells_text(line)
-      Gherkin::GherkinLine.new(line, 12).table_cells.map(&:text)
-    end
-
-    it 'trims white spaces before cell content' do
-      expect(cells_text("|   \t spaces before|")).to eq(['spaces before'])
-    end
-
-    it 'trims white spaces after cell content' do
-      expect(cells_text("|spaces after   |")).to eq(['spaces after'])
-    end
-
-    it 'trims white spaces around cell content' do
-      expect(cells_text("|   \t spaces everywhere   \t|")).to eq(['spaces everywhere'])
-    end
-
-    it 'does not drop white spaces inside a cell' do
-      expect(cells_text("| foo()\n  bar\nbaz |")).to eq(["foo()\n  bar\nbaz"])
-    end
-  end
-end

data/spec/gherkin/gherkin_spec.rb

@@ -1,45 +0,0 @@
-require 'rspec'
-require 'gherkin'
-
-describe Gherkin do
-  it "can process feature file paths" do
-    messages = Gherkin.from_paths(
-      ["../testdata/good/minimal.feature"],
-      {include_source: true,
-       include_gherkin_document: true,
-       include_pickles: true}
-    ).to_a
-
-    expect(messages.length).to eq(3)
-  end
-
-  it "can process feature file content" do
-    data = File.open("../testdata/good/minimal.feature", 'r:UTF-8', &:read)
-
-    messages = Gherkin.from_source(
-      "uri",
-      data,
-      {include_source: true,
-       include_gherkin_document: true,
-       include_pickles: true}
-    ).to_a
-
-    expect(messages.length).to eq(3)
-  end
-
-  it "can set the default dialect for the feature file content" do
-    data = File.open("../testdata/good/i18n_no.feature", 'r:UTF-8', &:read)
-    data_without_language_header = data.split("\n")[1..-1].join("\n")
-
-    messages = Gherkin.from_source(
-      "uri",
-      data,
-      {include_source: true,
-       include_gherkin_document: true,
-       include_pickles: true,
-       default_dialect: "no"}
-    ).to_a
-
-    expect(messages.length).to eq(3)
-  end
-end

data/spec/gherkin/parser_spec.rb

@@ -1,10 +0,0 @@
-require 'rspec'
-require 'gherkin'
-
-describe Gherkin::Parser do
-  context '.new' do
-    it 'can be invoked with no args' do
-      Gherkin::Parser.new
-    end
-  end
-end

data/spec/gherkin/query_spec.rb

@@ -1,208 +0,0 @@
-require 'rspec'
-require 'gherkin'
-require 'gherkin/query'
-
-describe Gherkin::Query do
-  let(:subject) { Gherkin::Query.new }
-
-  def filter_messages_by_attribute(messages, attribute)
-    messages.map do |message|
-      return unless message.respond_to?(attribute)
-      message.send(attribute)
-    end.compact
-  end
-
-  def find_message_by_attribute(messages, attribute)
-    filter_messages_by_attribute(messages, attribute).first
-  end
-
-  let(:gherkin_document) { find_message_by_attribute(messages, :gherkin_document) }
-
-  let(:messages) do
-    Gherkin.from_source(
-      "some/path",
-      feature_content,
-      {
-        include_gherkin_document: true
-      }
-    ).to_a
-  end
-
-  let(:feature_content) do
-    """
-    @feature-tag
-    Feature: my feature
-
-      Background:
-        Given a passed background step
-
-      @scenario-tag
-      Scenario: my scenario
-        Given a passed step
-
-      Scenario Outline: with examples
-        Given a <Status> step
-
-        @examples-tag
-        Examples:
-          | Status |
-          | passed |
-          | failed |
-
-      @rule-tag
-      Rule: this is a rule
-        Background:
-          Given the passed step in the rule background
-
-        @ruled-scenario-tag
-        Scenario: a ruled scenario
-          Given a step in the ruled scenario
-    """
-  end
-
-  describe '#update' do
-    context 'when the feature file is empty' do
-      let(:feature_content) { '' }
-
-      it 'does not fail' do
-        expect do
-          messages.each { |message| subject.update(message) }
-        end.not_to raise_exception
-      end
-    end
-  end
-
-  describe '#scenario_parent_locations' do
-    before do
-      messages.each { |message| subject.update(message) }
-    end
-
-    let(:background) { find_message_by_attribute(gherkin_document.feature.children, :background) }
-    let(:scenarios) { filter_messages_by_attribute(gherkin_document.feature.children, :scenario) }
-
-    context 'without rule' do
-      let(:scenario) { scenarios.first }
-
-      it 'provides the feature and background locations of a given scenario node id' do
-        expect(subject.scenario_parent_locations(scenario.id)).to eq([
-          gherkin_document.feature.location,
-          background.location,
-        ])
-      end
-    end
-
-    context 'with rule' do
-      let(:rule) { find_message_by_attribute(gherkin_document.feature.children, :rule) }
-      let(:rule_background) { find_message_by_attribute(rule.children, :background) }
-      let(:scenario) { find_message_by_attribute(rule.children, :scenario) }
-
-      it 'provides the feature, background, rule, and rule background locations of a given scenario node id' do
-        expect(subject.scenario_parent_locations(scenario.id)).to eq([
-          gherkin_document.feature.location,
-          background.location,
-          rule.location,
-          rule_background.location,
-        ])
-      end
-    end
-
-    context 'in a scenario outline' do
-      let(:scenario) { scenarios.last }
-
-      it 'provides the feature and background locations of a given scenario outline node id' do
-        expect(subject.scenario_parent_locations(scenario.id)).to eq([
-          gherkin_document.feature.location,
-          background.location,
-        ])
-      end
-    end
-
-    it 'raises an exception if called with an invalid id' do
-      expect { subject.scenario_parent_locations("BAD") }.to raise_error(Gherkin::AstNodeNotLocatedException)
-    end
-  end
-
-  describe '#location' do
-    before do
-      messages.each { |message| subject.update(message) }
-    end
-
-    let(:background) { find_message_by_attribute(gherkin_document.feature.children, :background) }
-    let(:rule) { find_message_by_attribute(gherkin_document.feature.children, :rule) }
-    let(:scenarios) { filter_messages_by_attribute(gherkin_document.feature.children, :scenario) }
-    let(:scenario) { scenarios.first }
-
-    it 'raises an exception when the AST node ID is unknown' do
-      expect { subject.location("this-id-may-not-exist-for-real") }.to raise_exception(Gherkin::AstNodeNotLocatedException)
-    end
-
-    it 'provides the location of a scenario' do
-      expect(subject.location(scenario.id)).to eq(scenario.location)
-    end
-
-    it 'provides the location of an examples table row' do
-      node = scenarios.last.examples.first.table_body.first
-      expect(subject.location(node.id)).to eq(node.location)
-    end
-
-    context 'when querying steps' do
-      let(:background_step) { background.steps.first }
-      let(:scenario_step) { scenario.steps.first }
-
-      it 'provides the location of a background step' do
-        expect(subject.location(background_step.id)).to eq(background_step.location)
-      end
-
-      it 'provides the location of a scenario step' do
-        expect(subject.location(scenario_step.id)).to eq(scenario_step.location)
-      end
-    end
-
-    context 'when querying tags' do
-      let(:feature_tag) { gherkin_document.feature.tags.first }
-      let(:rule_tag) { rule.tags.first }
-      let(:scenario_tag) { scenario.tags.first }
-      let(:examples_tag) { scenarios.last.examples.first.tags.first }
-
-      it 'provides the location of a feature tags' do
-        expect(subject.location(feature_tag.id)).to eq(feature_tag.location)
-      end
-
-      it 'provides the location of a scenario tags' do
-        expect(subject.location(scenario_tag.id)).to eq(scenario_tag.location)
-      end
-
-      it 'provides the location of scenario examples tags' do
-        expect(subject.location(examples_tag.id)).to eq(examples_tag.location)
-      end
-
-      it 'provides the location of a rule tag' do
-        expect(subject.location(rule_tag.id)).to eq(rule_tag.location)
-      end
-    end
-
-    context 'when children are scoped in a Rule' do
-      let(:rule_background) { find_message_by_attribute(rule.children, :background) }
-      let(:rule_background_step) { rule_background.steps.first }
-      let(:rule_scenario) { find_message_by_attribute(rule.children, :scenario) }
-      let(:rule_scenario_step) { rule_scenario.steps.first }
-      let(:rule_scenario_tag) { rule_scenario.tags.first }
-
-      it 'provides the location of a background step' do
-        expect(subject.location(rule_background_step.id)).to eq(rule_background_step.location)
-      end
-
-      it 'provides the location of a scenario' do
-        expect(subject.location(rule_scenario.id)).to eq(rule_scenario.location)
-      end
-
-      it 'provides the location of a scenario tag' do
-        expect(subject.location(rule_scenario_tag.id)).to eq(rule_scenario_tag.location)
-      end
-
-      it 'provides the location of a scenario step' do
-        expect(subject.location(rule_scenario_step.id)).to eq(rule_scenario_step.location)
-      end
-    end
-  end
-end

data/spec/gherkin/stream/parser_message_stream_spec.rb

@@ -1,67 +0,0 @@
-require 'rspec'
-require 'gherkin/stream/parser_message_stream'
-
-module Gherkin
-  module Stream
-    describe ParserMessageStream do
-      let(:feature_content) {
-        "Feature: my feature\n" \
-        "  Scenario: a scenario\n" \
-        "    Given some context"
-      }
-
-      let(:source_feature) {
-        Cucumber::Messages::Source.new(
-          uri: '//whatever/uri',
-          data: feature_content,
-          media_type: 'text/x.cucumber.gherkin+plain'
-        )
-      }
-
-      let(:options) {
-        {
-          include_gherkin_document: true,
-        }
-      }
-
-      let(:gherkin_document) {
-        ParserMessageStream.new([], [source_feature], options).messages.first.gherkin_document
-      }
-
-      let(:scenario_id) { gherkin_document.feature.children.first.scenario.id }
-
-      context '#messages' do
-        it "raises an exception on second iteration" do
-          messages = ParserMessageStream.new([], [source_feature], options).messages
-
-          expect { messages.map(&:to_s) }.not_to raise_exception
-          expect { messages.map(&:to_s) }.to raise_exception(Gherkin::DoubleIterationException)
-        end
-      end
-
-      context 'options.id_generator' do
-        context 'when not set' do
-          it 'generates random UUIDs' do
-            expect(scenario_id).to match(/[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/)
-          end
-        end
-
-
-        context 'when set' do
-          let(:id_generator) { double }
-          let(:options) {
-            {
-              include_gherkin_document: true,
-              id_generator: id_generator
-            }
-          }
-
-          it 'uses the generator instance to produce the IDs' do
-            allow(id_generator).to receive(:new_id).and_return('some-random-id')
-            expect(scenario_id).to eq('some-random-id')
-          end
-        end
-      end
-    end
-  end
-end