cuke_modeler 2.0.0 → 3.3.0

data/testing/rspec/spec/integration/nested_integration_spec.rb

@@ -1,91 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'Nested, Integration' do
-
-  let(:nodule) { CukeModeler::Nested }
-  let(:nested_model) { Object.new.extend(nodule) }
-
-
-  describe 'unique behavior' do
-
-    describe 'an object including the module' do
-
-      describe 'getting ancestors' do
-
-        context 'with a background ancestor' do
-
-          let(:background) { CukeModeler::Background.new }
-
-          before(:each) do
-            nested_model.parent_model = background
-          end
-
-
-          it "will find its background as a 'test' ancestor" do
-            ancestor = nested_model.get_ancestor(:test)
-
-            expect(ancestor).to equal(background)
-          end
-
-          it "will find its background as a 'background' ancestor" do
-            ancestor = nested_model.get_ancestor(:background)
-
-            expect(ancestor).to equal(background)
-          end
-
-        end
-
-        context 'with a scenario ancestor' do
-
-          let(:scenario) { CukeModeler::Scenario.new }
-
-          before(:each) do
-            nested_model.parent_model = scenario
-          end
-
-
-          it "will find its scenario as a 'test' ancestor" do
-            ancestor = nested_model.get_ancestor(:test)
-
-            expect(ancestor).to equal(scenario)
-          end
-
-          it "will find its scenario as a 'scenario' ancestor" do
-            ancestor = nested_model.get_ancestor(:scenario)
-
-            expect(ancestor).to equal(scenario)
-          end
-
-        end
-
-        context 'with an outline ancestor' do
-
-          let(:outline) { CukeModeler::Outline.new }
-
-          before(:each) do
-            nested_model.parent_model = outline
-          end
-
-
-          it "will find its outline as a 'test' ancestor" do
-            ancestor = nested_model.get_ancestor(:test)
-
-            expect(ancestor).to equal(outline)
-          end
-
-          it "will find its outline as a 'outline' ancestor" do
-            ancestor = nested_model.get_ancestor(:outline)
-
-            expect(ancestor).to equal(outline)
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/testing/rspec/spec/integration/parsing_integration_spec.rb

@@ -1,122 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'Parsing, Integration' do
-
-  let(:nodule) { CukeModeler::Parsing }
-
-
-  describe 'unique behavior' do
-
-    it 'will complain if using an unknown version of `gherkin`' do
-      original_version = Gem.loaded_specs['gherkin'].version
-      unknown_version  = Gem::Version.new('0.0.0')
-
-      begin
-        Gem.loaded_specs['gherkin'].instance_variable_set(:@version, unknown_version)
-
-        expect { load "#{File.dirname(__FILE__)}/../../../../lib/cuke_modeler/parsing.rb" }.to raise_error("Unknown Gherkin version: '0.0.0'")
-      ensure
-        Gem.loaded_specs['gherkin'].instance_variable_set(:@version, original_version)
-      end
-    end
-
-    it 'loads the correct dialects based on the version of Gherkin used', :gherkin6 => true do
-      expect(nodule.dialects).to equal(Gherkin::DIALECTS)
-    end
-
-    it 'loads the correct dialects based on the version of Gherkin used', :gherkin3 => true, :gherkin4_5 => true do
-      expect(nodule.dialects).to equal(Gherkin::DIALECTS)
-    end
-
-    it 'loads the correct dialects based on the version of Gherkin used', :gherkin2 => true do
-      expect(nodule.dialects).to equal(Gherkin::I18n::LANGUAGES)
-    end
-
-    it 'can parse text that uses a non-default dialect' do
-      source_text = "# language: en-au
-                     Pretty much:
-
-                       First off:
-                         Y'know foo
-
-                       Awww, look mate:
-                         It's just unbelievable that zip
-                         But at the end of the day I reckon bar
-
-                       Reckon it's like:
-                         Yeah nah zen
-                         Too right baz
-                         You'll wanna:
-                           | param |
-                           | value |"
-
-      expect { nodule.parse_text(source_text) }.to_not raise_error
-    end
-
-    it 'raises and error if given something to parse besides a string' do
-      expect { nodule.parse_text(5) }.to raise_error(ArgumentError, /Text to parse must be a String but got/)
-      expect { nodule.parse_text("#{FEATURE_KEYWORD}:") }.to_not raise_error
-    end
-
-    it 'includes the type of object provided when raising an non-string exception' do
-      expect { nodule.parse_text(:not_a_string) }.to raise_error(ArgumentError, /Symbol/)
-    end
-
-    # todo - Stop doing this. Just return a feature file rooted AST. (Will require major version number change)
-    it 'returns an Array' do
-      result = nodule.parse_text("#{FEATURE_KEYWORD}:")
-      expect(result).to be_a(Array)
-    end
-
-    it 'raises an error if an error is encountered while parsing text' do
-      expect { nodule.parse_text('bad file') }.to raise_error(ArgumentError, /Error encountered while parsing '.*'/)
-    end
-
-    it 'includes the file parsed in the error that it raises' do
-      expect { nodule.parse_text('bad file', 'file foo.txt') }.to raise_error(/'file foo\.txt'/)
-    end
-
-    it 'has a default file name used while parsing if one is not provided' do
-      expect { nodule.parse_text('bad file') }.to raise_error(ArgumentError, /'cuke_modeler_fake_file\.feature'/)
-    end
-
-    it 'includes the underlying error message in the error that it raises' do
-      begin
-        $old_method = CukeModeler::Parsing.method(:parsing_method)
-
-        # Custom error type in order to ensure that we are throwing the correct thing
-        module CukeModeler
-          class TestError < StandardError
-          end
-        end
-
-        # Monkey patch the parsing method to throw the error that we need for testing
-        module CukeModeler
-          module Parsing
-            class << self
-              def parsing_method(*args)
-                raise(CukeModeler::TestError, 'something went wrong')
-              end
-            end
-          end
-        end
-
-
-        expect { nodule.parse_text('bad file') }.to raise_error(/CukeModeler::TestError.*something went wrong/)
-      ensure
-        # Making sure that our changes don't escape a test and ruin the rest of the suite
-        module CukeModeler
-          module Parsing
-            class << self
-              define_method(:parsing_method, $old_method)
-            end
-          end
-        end
-      end
-
-    end
-
-  end
-
-end

data/testing/rspec/spec/integration/shared/models_integration_specs.rb

@@ -1,18 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-shared_examples_for 'a model, integration' do
-
-  # clazz must be defined by the calling file
-
-  let(:model) { clazz.new }
-
-
-  describe 'unique behavior' do
-
-    it 'inherits from the common model class' do
-      expect(model).to be_a(CukeModeler::Model)
-    end
-
-  end
-
-end

data/testing/rspec/spec/spec_helper.rb

@@ -1,136 +0,0 @@
-unless RUBY_VERSION.to_s < '1.9.0'
-  require 'simplecov'
-  SimpleCov.command_name('rspec_tests')
-end
-
-
-# Ruby 1.8.x seems to have trouble if relative paths get too nested, so resolving the path before using it here
-this_dir = File.expand_path(File.dirname(__FILE__))
-require "#{this_dir}/../../../lib/cuke_modeler"
-
-require "#{this_dir}/unit/shared/models_unit_specs"
-require "#{this_dir}/integration/shared/models_integration_specs"
-require "#{this_dir}/unit/shared/named_models_unit_specs"
-require "#{this_dir}/unit/shared/described_models_unit_specs"
-require "#{this_dir}/unit/shared/stepped_models_unit_specs"
-require "#{this_dir}/unit/shared/stringifiable_models_unit_specs"
-require "#{this_dir}/unit/shared/nested_models_unit_specs"
-require "#{this_dir}/unit/shared/tagged_models_unit_specs"
-require "#{this_dir}/unit/shared/containing_models_unit_specs"
-require "#{this_dir}/unit/shared/bare_bones_models_unit_specs"
-require "#{this_dir}/unit/shared/prepopulated_models_unit_specs"
-require "#{this_dir}/unit/shared/sourced_models_unit_specs"
-require "#{this_dir}/unit/shared/parsed_models_unit_specs"
-require "#{this_dir}/unit/shared/keyworded_models_unit_specs"
-
-require "#{this_dir}/../../dialect_helper"
-require "#{this_dir}/../../file_helper"
-
-require 'rubygems/mock_gem_ui'
-
-
-# Use a random dialect for testing in order to avoid hard coded language assumptions in the
-# implementation and making the test dialect the default dialect so that language headers
-# aren't needed for all of the test code. Only possible with some versions of Gherkin.
-
-gherkin_version = Gem.loaded_specs['gherkin'].version.version
-
-case gherkin_version
-  when /^6\./
-    # gherkin 6 does not preload the dialect module
-    require 'gherkin/dialect' if Gem.loaded_specs['gherkin'].version.version[/^6\./]
-
-    # TODO: choose randomly from Gherkin::DIALECTS once I figure out how to handle encodings...
-    test_dialect = ['en', 'en-lol', 'en-pirate', 'en-Scouse'].sample
-    puts "Testing with dialect '#{test_dialect}'..."
-
-
-    CukeModeler::DialectHelper.set_dialect(Gherkin::DIALECTS[test_dialect])
-    CukeModeler::Parsing.dialect = test_dialect
-  when /^[543]\./
-# TODO: stop using test dialect and just randomize for all version of `gherkin`
-    dialect_file_path = "#{this_dir}/../../test_languages.json"
-    test_dialects = JSON.parse File.open(dialect_file_path, 'r:UTF-8').read
-
-    Gherkin::DIALECTS.merge!(test_dialects)
-
-
-    module Gherkin
-      class Parser
-
-        alias_method :original_parse, :parse
-
-        def parse(token_scanner, token_matcher = TokenMatcher.new('cm-test'))
-          original_parse(token_scanner, token_matcher)
-        end
-
-      end
-    end
-
-    CukeModeler::DialectHelper.set_dialect(test_dialects['cm-test'])
-    CukeModeler::Parsing.dialect = 'cm-test'
-  when /^2\./
-    CukeModeler::DialectHelper.set_dialect(Gherkin::I18n::LANGUAGES['en'])
-    CukeModeler::Parsing.dialect = 'en'
-  else
-    raise("Unknown Gherkin version: '#{gherkin_version}'")
-end
-
-
-RSpec.configure do |config|
-  gherkin_version = Gem.loaded_specs['gherkin'].version.version
-
-  case gherkin_version
-    when /^6\./
-      config.filter_run_excluding :gherkin2 => true,
-                                  :gherkin3 => true,
-                                  :gherkin4_5 => true,
-                                  :gherkin6 => false
-    when /^[54]\./
-      config.filter_run_excluding :gherkin2 => true,
-                                  :gherkin3 => true,
-                                  :gherkin4_5 => false,
-                                  :gherkin6 => true
-    when /^3\./
-      config.filter_run_excluding :gherkin2 => true,
-                                  :gherkin3 => false,
-                                  :gherkin4_5 => true,
-                                  :gherkin6 => true
-    when /^2\./
-      config.filter_run_excluding :gherkin2 => false,
-                                  :gherkin3 => true,
-                                  :gherkin4_5 => true,
-                                  :gherkin6 => true
-    else
-      raise("Unknown Gherkin version: '#{gherkin_version}'")
-  end
-
-  config.before(:suite) do
-    FEATURE_KEYWORD = CukeModeler::DialectHelper.feature_keyword
-    BACKGROUND_KEYWORD = CukeModeler::DialectHelper.background_keyword
-    SCENARIO_KEYWORD = CukeModeler::DialectHelper.scenario_keyword
-    OUTLINE_KEYWORD = CukeModeler::DialectHelper.outline_keyword
-    EXAMPLE_KEYWORD = CukeModeler::DialectHelper.example_keyword
-    STEP_KEYWORD = CukeModeler::DialectHelper.step_keyword
-    GIVEN_KEYWORD = CukeModeler::DialectHelper.given_keyword
-    THEN_KEYWORD = CukeModeler::DialectHelper.then_keyword
-  end
-
-  config.after(:suite) do
-    CukeModeler::FileHelper.created_directories.each do |dir_path|
-      FileUtils.remove_entry(dir_path, true)
-    end
-  end
-
-
-  def assert_bidirectional_equality(base_thing, compared_thing)
-    expect(base_thing).to eq(compared_thing)
-    expect(compared_thing).to eq(base_thing)
-  end
-
-  def assert_bidirectional_inequality(base_thing, compared_thing)
-    expect(base_thing).to_not eq(compared_thing)
-    expect(compared_thing).to_not eq(base_thing)
-  end
-
-end

data/testing/rspec/spec/unit/cuke_modeler_unit_spec.rb

@@ -1,25 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'the gem' do
-
-  let(:gemspec) { eval(File.read "#{File.dirname(__FILE__)}/../../../../cuke_modeler.gemspec") }
-
-
-  it 'validates cleanly' do
-    mock_ui = Gem::MockGemUi.new
-    Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
-
-    expect(mock_ui.error).to_not match(/warn/i)
-  end
-
-end
-
-
-describe CukeModeler do
-
-  it "has a version number" do
-    expect(CukeModeler::VERSION).not_to be nil
-  end
-
-end

data/testing/rspec/spec/unit/described_unit_spec.rb

@@ -1,23 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'Described, Unit', :unit_test => true do
-
-  let(:nodule) { CukeModeler::Described }
-  let(:described_model) { Object.new.extend(nodule) }
-
-
-  it 'has a description' do
-    expect(described_model).to respond_to(:description)
-  end
-
-  it 'can change its description' do
-    expect(described_model).to respond_to(:description=)
-
-    described_model.description = :some_description
-    expect(described_model.description).to eq(:some_description)
-    described_model.description = :some_other_description
-    expect(described_model.description).to eq(:some_other_description)
-  end
-
-end

data/testing/rspec/spec/unit/models/background_unit_spec.rb

@@ -1,83 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'Background, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::Background }
-  let(:background) { clazz.new }
-
-
-  describe 'common behavior' do
-
-    it_should_behave_like 'a model'
-    it_should_behave_like 'a keyworded model'
-    it_should_behave_like 'a named model'
-    it_should_behave_like 'a described model'
-    it_should_behave_like 'a stepped model'
-    it_should_behave_like 'a sourced model'
-    it_should_behave_like 'a parsed model'
-
-  end
-
-
-  describe 'unique behavior' do
-
-    it 'contains steps' do
-      steps = [:step_1, :step_2]
-      everything = steps
-
-      background.steps = steps
-
-      expect(background.children).to match_array(everything)
-    end
-
-
-    describe 'comparison' do
-
-      it 'can gracefully be compared to other types of objects' do
-        # Some common types of object
-        [1, 'foo', :bar, [], {}].each do |thing|
-          expect { background == thing }.to_not raise_error
-          expect(background == thing).to be false
-        end
-      end
-
-    end
-
-
-    describe 'background output' do
-
-      context 'from abstract instantiation' do
-
-        let(:background) { clazz.new }
-
-
-        it 'can output an empty background' do
-          expect { background.to_s }.to_not raise_error
-        end
-
-        it 'can output a background that has only a keyword' do
-          background.keyword = 'foo'
-
-          expect(background.to_s).to eq('foo:')
-        end
-
-        it 'can output a background that has only a name' do
-          background.name = 'a name'
-
-          expect { background.to_s }.to_not raise_error
-        end
-
-        it 'can output a background that has only a description' do
-          background.description = 'a description'
-
-          expect { background.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-end