cuke_modeler 1.5.0 → 3.1.0

data/testing/cucumber/step_definitions/tag_steps.rb

@@ -1,3 +0,0 @@
-When(/^all of the \w+'s tags are requested$/) do |code_text|
-  @result = eval(code_text)
-end

data/testing/cucumber/step_definitions/verification_steps.rb

@@ -1,173 +0,0 @@
-Then(/^all of them can be output as text appropriate to the model type$/) do |code_text|
-  original_text = code_text
-
-  @available_model_classes.each do |clazz|
-    code_text = original_text.gsub('<model_class>', clazz.to_s)
-
-    expect(clazz.instance_method(:to_s).owner).to equal(clazz), "#{clazz} does not override #to_s"
-
-    # Make sure that the example code is valid
-    expect { eval(code_text) }.to_not raise_error
-  end
-end
-
-Then(/^the following text is provided:$/) do |expected_text|
-  expected_text = expected_text.sub('<path_to>', @root_test_directory)
-
-  expect(@output).to eq(expected_text)
-end
-
-Then(/^all of them can be contained inside of another model$/) do |code_text|
-  original_text = code_text
-
-  @available_model_classes.each do |clazz|
-    code_text = original_text.gsub('<model_class>', clazz.to_s)
-
-    expect(clazz.new).to respond_to(:parent_model)
-
-    # Make sure that the example code is valid
-    expect { eval(code_text) }.to_not raise_error
-  end
-end
-
-And(/^all of them can contain other models$/) do |code_text|
-  original_text = code_text
-
-  @available_model_classes.each do |clazz|
-    code_text = original_text.gsub('<model_class>', clazz.to_s)
-
-    expect(clazz.new).to respond_to(:children)
-
-    # Make sure that the example code is valid
-    expect { eval(code_text) }.to_not raise_error
-  end
-end
-
-Then(/^all of them can be created without further context$/) do |code_text|
-  original_text = code_text
-
-  @available_model_classes.each do |clazz|
-    code_text = original_text.gsub('<model_class>', clazz.to_s)
-
-    expect { clazz.new }.to_not raise_error
-
-    # Make sure that the example code is valid
-    expect { eval(code_text) }.to_not raise_error
-  end
-end
-
-Then(/^the model returns "([^"]*)"$/) do |value|
-  value.gsub!('path_to', @root_test_directory) if value.is_a?(String)
-  value = value.to_i if value =~ /^\d+$/
-
-  expect(@result).to eq(value)
-end
-
-Then(/^the model returns$/) do |value|
-  value = value.gsub('path_to', @root_test_directory) if value.is_a?(String)
-
-  expect(@result).to eq(value)
-end
-
-Then(/^the model returns models for the following feature files:$/) do |file_names|
-  file_names = file_names.raw.flatten
-
-  expect(@result.collect { |file_model| file_model.name }).to match_array(file_names)
-end
-
-Then(/^the model returns models for the following directories:$/) do |directory_names|
-  directory_names = directory_names.raw.flatten
-
-  expect(@result.collect { |directory_model| directory_model.name }).to match_array(directory_names)
-end
-
-And(/^the output can be used to make an equivalent model$/) do |code_text|
-  clazz = @model.class
-
-  base_output = @model.to_s
-  remodeled_output = clazz.new(base_output).to_s
-
-  expect(remodeled_output).to eq(base_output)
-
-  # Make sure that the example code is valid
-  expect { eval(code_text) }.to_not raise_error
-end
-
-Then(/^all of them provide access to the parsing data that was used to create them$/) do |code_text|
-  original_text = code_text
-  unparsed_models = [CukeModeler::Model, CukeModeler::Directory]
-
-  @available_model_classes.each do |clazz|
-    next if unparsed_models.include?(clazz)
-
-    expect(clazz.new).to respond_to(:parsing_data)
-
-    # Make sure that the example code is valid
-    code_text = original_text.gsub('<model_class>', clazz.to_s)
-    code_text.gsub!('<source_text>', '')
-
-    expect { eval(code_text) }.to_not raise_error
-  end
-end
-
-Then(/^the model returns models for the following steps:$/) do |step_names|
-  step_names = step_names.raw.flatten
-
-  expect(@result.collect { |step_model| step_model.text }).to eq(step_names)
-end
-
-Then(/^the model returns models for the following rows:$/) do |rows|
-  rows = rows.raw
-
-  expect(@result.collect { |row_model| row_model.cells.collect { |cell| cell.value } }).to eq(rows)
-end
-
-Then(/^the model returns a model for the following feature:$/) do |feature_name|
-  feature_name = feature_name.raw.flatten.first
-
-  expect(@result.name).to eq(feature_name)
-end
-
-Then(/^the model returns a model for the following table:$/) do |table_rows|
-  table_rows = table_rows.raw
-
-  expect(@result.rows.collect { |row| row.cells.collect { |cell| cell.value } }).to eq(table_rows)
-end
-
-Then(/^the model returns a model for the following doc string:$/) do |string_text|
-  expect(@result.content).to eq(string_text)
-end
-
-Then(/^the model returns a model for the background "([^"]*)"$/) do |background_name|
-  expect(@result.name).to eq(background_name)
-end
-
-Then(/^the model returns models for the following (?:scenario|outline|tag|example)s:$/) do |model_names|
-  model_names = model_names.raw.flatten
-
-  expect(@result.collect { |model| model.name }).to eq(model_names)
-end
-
-Then(/^the model returns models for the following cells:$/) do |model_values|
-  model_values = model_values.raw.flatten
-
-  expect(@result.collect { |model| model.value }).to eq(model_values)
-end
-
-Then(/^all of them are equivalent$/) do
-  expect(@results).to_not include(false)
-end
-
-But(/^none of the models are equivalent with a model for the following scenario:$/) do |gherkin_text|
-  model = CukeModeler::Scenario.new(gherkin_text)
-
-  @models.each do |other_model|
-    expect(model == other_model).to_not be true
-  end
-end
-
-Then(/^the model returns models for the following comments:$/) do |model_values|
-  model_values = model_values.raw.flatten
-
-  expect(@result.collect { |model| model.text }).to eq(model_values)
-end

data/testing/cucumber/support/env.rb

@@ -1,30 +0,0 @@
-unless RUBY_VERSION.to_s < '1.9.0'
-  require 'simplecov'
-  SimpleCov.command_name('cucumber_tests')
-end
-
-require 'test/unit/assertions'
-include Test::Unit::Assertions
-
-this_dir = File.dirname(__FILE__)
-
-require "#{this_dir}/../../../lib/cuke_modeler"
-
-require "#{this_dir}/../../file_helper"
-
-
-Before do
-  begin
-    @root_test_directory = CukeModeler::FileHelper.create_directory
-  rescue => e
-    $stdout.puts 'Problem caught in Before hook!'
-    $stdout.puts "Type: #{e.class}"
-    $stdout.puts "Message: #{e.message}"
-  end
-end
-
-at_exit {
-  CukeModeler::FileHelper.created_directories.each do |dir_path|
-    FileUtils.remove_entry(dir_path, true)
-  end
-}

data/testing/dialect_helper.rb

@@ -1,48 +0,0 @@
-module CukeModeler
-  module DialectHelper
-
-    def self.set_dialect(dialect)
-      @dialect = dialect
-    end
-
-    def self.feature_keyword
-      get_word(@dialect['feature'])
-    end
-
-    def self.background_keyword
-      get_word(@dialect['background'])
-    end
-
-    def self.scenario_keyword
-      get_word(@dialect['scenario'])
-    end
-
-    def self.outline_keyword
-      get_word(@dialect['scenarioOutline'] || @dialect['scenario_outline'])
-    end
-
-    def self.example_keyword
-      get_word(@dialect['examples'])
-    end
-
-    def self.step_keyword
-      get_word(@dialect['given']).strip
-    end
-
-    def self.given_keyword
-      get_word(@dialect['given']).strip
-    end
-
-    def self.then_keyword
-      get_word(@dialect['then']).strip
-    end
-
-    def self.get_word(word_set)
-      word_set.is_a?(Array) ? word_set.first : word_set.split('|').first
-    end
-
-
-    private_class_method :get_word
-
-  end
-end

data/testing/file_helper.rb

@@ -1,47 +0,0 @@
-require 'tmpdir'
-
-
-module CukeModeler
-  module FileHelper
-
-    class << self
-
-      def create_feature_file(options = {})
-        options[:text] ||= 'Feature:'
-        options[:name] ||= 'test_file'
-
-        create_file(:text => options[:text], :name => options[:name], :extension => '.feature', :directory => options[:directory])
-      end
-
-      def create_file(options = {})
-        options[:text] ||= ''
-        options[:name] ||= 'test_file'
-        options[:extension] ||= '.txt'
-        options[:directory] ||= create_directory
-
-        file_path = "#{options[:directory]}/#{options[:name]}#{options[:extension]}"
-        File.open(file_path, 'w') { |file| file.write(options[:text]) }
-
-        file_path
-      end
-
-      def created_directories
-        @created_directories ||= []
-      end
-
-      def create_directory(options = {})
-        options[:name] ||= 'test_directory'
-        options[:directory] ||= Dir.mktmpdir
-
-        path = "#{options[:directory]}/#{options[:name]}"
-
-        Dir::mkdir(path)
-        created_directories << options[:directory]
-
-        path
-      end
-
-    end
-
-  end
-end

data/testing/gemfiles/gherkin2.gemfile

@@ -1,32 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec :path => "../../"
-gem "gherkin", "~> 2.0"
-
-# cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
-
-if RUBY_VERSION =~ /^1\./
-
-  if RbConfig::CONFIG['host_os'].downcase =~ /mswin|msys|mingw32/
-    gem 'ffi', '< 1.9.15' # The 'ffi' gem, for Windows, requires Ruby 2.x on/after this version
-  end
-
-  gem 'unf_ext', '< 0.0.7.3' # Requires Ruby 2.x on/after this version
-  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
-  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
-  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
-
-  if RUBY_VERSION =~ /^1\.8/
-    gem 'cucumber', '~> 1.0' # Ruby 1.8.x support dropped after this version
-    gem 'rake', '< 11.0' # Ruby 1.8.x support dropped after this version
-  else
-    gem 'rake', '< 12.3.0' # Ruby 1.9.x support dropped after this version
-  end
-
-elsif RUBY_VERSION =~ /^2\./
-
-  if RUBY_VERSION =~ /^2\.[23456789]/
-    gem 'test-unit'
-  end
-
-end

data/testing/gemfiles/gherkin3.gemfile

@@ -1,26 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec :path => "../../"
-gem "gherkin", "~> 3.0"
-
-# cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
-
-if RUBY_VERSION =~ /^1\./
-
-  if RbConfig::CONFIG['host_os'].downcase =~ /mswin|msys|mingw32/
-    gem 'ffi', '< 1.9.15' # The 'ffi' gem, for Windows, requires Ruby 2.x on/after this version
-  end
-
-  gem 'unf_ext', '< 0.0.7.3' # Requires Ruby 2.x on/after this version
-  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
-  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
-  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
-  gem 'rake', '< 12.3.0' # Ruby 1.9.x support dropped after this version
-
-elsif RUBY_VERSION =~ /^2\./
-
-  if RUBY_VERSION =~ /^2\.[23456789]/
-    gem 'test-unit'
-  end
-
-end

data/testing/gemfiles/gherkin4.gemfile

@@ -1,27 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec :path => "../../"
-gem "gherkin", "~> 4.0"
-
-# cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
-
-if RUBY_VERSION =~ /^1\./
-
-  if RbConfig::CONFIG['host_os'].downcase =~ /mswin|msys|mingw32/
-    gem 'ffi', '< 1.9.15' # The 'ffi' gem, for Windows, requires Ruby 2.x on/after this version
-  end
-
-  gem 'unf_ext', '< 0.0.7.3' # Requires Ruby 2.x on/after this version
-  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
-  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
-  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
-  gem 'rake', '< 12.3.0' # Ruby 1.9.x support dropped after this version
-  gem 'cucumber', '< 3.0.0' # Ruby 1.9.x support dropped after this version
-
-elsif RUBY_VERSION =~ /^2\./
-
-  if RUBY_VERSION =~ /^2\.[23456789]/
-    gem 'test-unit'
-  end
-
-end

data/testing/gemfiles/gherkin5.gemfile

@@ -1,27 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec :path => "../../"
-gem "gherkin", "~> 5.0"
-
-# cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
-
-if RUBY_VERSION =~ /^1\./
-
-  if RbConfig::CONFIG['host_os'].downcase =~ /mswin|msys|mingw32/
-    gem 'ffi', '< 1.9.15' # The 'ffi' gem, for Windows, requires Ruby 2.x on/after this version
-  end
-
-  gem 'unf_ext', '< 0.0.7.3' # Requires Ruby 2.x on/after this version
-  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
-  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
-  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
-  gem 'rake', '< 12.3.0' # Ruby 1.9.x support dropped after this version
-  gem 'cucumber-core', '< 3.0.0' # Ruby 1.9.x support dropped after this version
-
-elsif RUBY_VERSION =~ /^2\./
-
-  if RUBY_VERSION =~ /^2\.[23456789]/
-    gem 'test-unit'
-  end
-
-end

data/testing/gemfiles/gherkin6.gemfile

@@ -1,10 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec :path => "../../"
-
-gem "gherkin", "~> 6.0"
-gem 'cucumber', '~>4.0.rc' # TODO: Upgrade to Cucumber 4.0 when it is finally released
-
-if RUBY_VERSION =~ /^2\.[23456789]/
-  gem 'test-unit'
-end

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

@@ -1,442 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'Background, Integration' do
-
-  let(:clazz) { CukeModeler::Background }
-
-
-  describe 'common behavior' do
-
-    it_should_behave_like 'a model, integration'
-
-  end
-
-  describe 'unique behavior' do
-
-    it 'can be instantiated with the minimum viable Gherkin' do
-      source = "#{BACKGROUND_KEYWORD}:"
-
-      expect { clazz.new(source) }.to_not raise_error
-    end
-
-    it 'can parse text that uses a non-default dialect' do
-      original_dialect = CukeModeler::Parsing.dialect
-      CukeModeler::Parsing.dialect = 'en-au'
-
-      begin
-        source_text = 'First off: Background name'
-
-        expect { @model = clazz.new(source_text) }.to_not raise_error
-
-        # Sanity check in case modeling failed in a non-explosive manner
-        expect(@model.name).to eq('Background name')
-      ensure
-        # Making sure that our changes don't escape a test and ruin the rest of the suite
-        CukeModeler::Parsing.dialect = original_dialect
-      end
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin6 => true do
-      background = clazz.new("#{BACKGROUND_KEYWORD}: test background\ndescription\n#{STEP_KEYWORD} a step")
-      data = background.parsing_data
-
-      expect(data.keys).to match_array([:background, :rule, :scenario])
-      expect(data[:background][:name]).to eq('test background')
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin4_5 => true do
-      background = clazz.new("#{BACKGROUND_KEYWORD}: test background\ndescription\n#{STEP_KEYWORD} a step")
-      data = background.parsing_data
-
-      expect(data.keys).to match_array([:type, :location, :keyword, :name, :steps, :description])
-      expect(data[:type]).to eq(:Background)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      background = clazz.new("#{BACKGROUND_KEYWORD}: test background\ndescription\n#{STEP_KEYWORD} a step")
-      data = background.parsing_data
-
-      expect(data.keys).to match_array([:type, :location, :keyword, :name, :steps, :description])
-      expect(data[:type]).to eq(:Background)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      background = clazz.new("#{BACKGROUND_KEYWORD}: test background\ndescription\n#{STEP_KEYWORD} a step")
-      data = background.parsing_data
-
-      expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'steps', 'type'])
-      expect(data['keyword']).to eq('Background')
-    end
-
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = "bad background text \n #{BACKGROUND_KEYWORD}:\n #{STEP_KEYWORD} a step\n @foo "
-
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_background\.feature'/)
-    end
-
-    it 'properly sets its child models' do
-      source = "#{BACKGROUND_KEYWORD}: Test background
-                  #{STEP_KEYWORD} a step"
-
-      background = clazz.new(source)
-      step = background.steps.first
-
-      expect(step.parent_model).to equal(background)
-    end
-
-    it 'trims whitespace from its source description' do
-      source = ["#{BACKGROUND_KEYWORD}:",
-                '  ',
-                '        description line 1',
-                '',
-                '   description line 2',
-                '     description line 3               ',
-                '',
-                '',
-                '',
-                "  #{STEP_KEYWORD} a step"]
-      source = source.join("\n")
-
-      background = clazz.new(source)
-      description = background.description.split("\n", -1)
-
-      expect(description).to eq(['     description line 1',
-                                 '',
-                                 'description line 2',
-                                 '  description line 3'])
-    end
-
-
-    describe 'getting ancestors' do
-
-      before(:each) do
-        CukeModeler::FileHelper.create_feature_file(:text => source_gherkin, :name => 'background_test_file', :directory => test_directory)
-      end
-
-
-      let(:test_directory) { CukeModeler::FileHelper.create_directory }
-      let(:source_gherkin) { "#{FEATURE_KEYWORD}: Test feature
-
-                                #{BACKGROUND_KEYWORD}: Test background
-                                  #{STEP_KEYWORD} a step"
-      }
-
-      let(:directory_model) { CukeModeler::Directory.new(test_directory) }
-      let(:background_model) { directory_model.feature_files.first.feature.background }
-
-
-      it 'can get its directory' do
-        ancestor = background_model.get_ancestor(:directory)
-
-        expect(ancestor).to equal(directory_model)
-      end
-
-      it 'can get its feature file' do
-        ancestor = background_model.get_ancestor(:feature_file)
-
-        expect(ancestor).to equal(directory_model.feature_files.first)
-      end
-
-      it 'can get its feature' do
-        ancestor = background_model.get_ancestor(:feature)
-
-        expect(ancestor).to equal(directory_model.feature_files.first.feature)
-      end
-
-      it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = background_model.get_ancestor(:example)
-
-        expect(ancestor).to be_nil
-      end
-
-    end
-
-
-    describe 'model population' do
-
-      context 'from source text' do
-
-        let(:source_text) { "#{BACKGROUND_KEYWORD}:" }
-        let(:background) { clazz.new(source_text) }
-
-
-        it "models the background's keyword" do
-          expect(background.keyword).to eq("#{BACKGROUND_KEYWORD}")
-        end
-
-        it "models the background's source line" do
-          source_text = "#{FEATURE_KEYWORD}:
-
-                           #{BACKGROUND_KEYWORD}: foo
-                             #{STEP_KEYWORD} step"
-          background = CukeModeler::Feature.new(source_text).background
-
-          expect(background.source_line).to eq(3)
-        end
-
-        context 'a filled background' do
-
-          let(:source_text) { "#{BACKGROUND_KEYWORD}: Background name
-
-                               Background description.
-
-                             Some more.
-                                 Even more.
-
-                                 #{STEP_KEYWORD} a step
-                                 #{STEP_KEYWORD} another step" }
-          let(:background) { clazz.new(source_text) }
-
-
-          it "models the background's name" do
-            expect(background.name).to eq('Background name')
-          end
-
-          it "models the background's description" do
-            description = background.description.split("\n", -1)
-
-            expect(description).to eq(['  Background description.',
-                                       '',
-                                       'Some more.',
-                                       '    Even more.'])
-          end
-
-          it "models the background's steps" do
-            step_names = background.steps.collect { |step| step.text }
-
-            expect(step_names).to eq(['a step', 'another step'])
-          end
-
-        end
-
-        context 'an empty background' do
-
-          let(:source_text) { "#{BACKGROUND_KEYWORD}:" }
-          let(:background) { clazz.new(source_text) }
-
-
-          it "models the background's name" do
-            expect(background.name).to eq('')
-          end
-
-          it "models the background's description" do
-            expect(background.description).to eq('')
-          end
-
-          it "models the background's steps" do
-            expect(background.steps).to eq([])
-          end
-
-        end
-
-      end
-
-    end
-
-
-    describe 'comparison' do
-
-      it 'is equal to a background with the same steps' do
-        source = "#{BACKGROUND_KEYWORD}:
-                    #{STEP_KEYWORD} step 1
-                    #{STEP_KEYWORD} step 2"
-        background_1 = clazz.new(source)
-
-        source = "#{BACKGROUND_KEYWORD}:
-                    #{STEP_KEYWORD} step 1
-                    #{STEP_KEYWORD} step 2"
-        background_2 = clazz.new(source)
-
-        source = "#{BACKGROUND_KEYWORD}:
-                    #{STEP_KEYWORD} step 2
-                    #{STEP_KEYWORD} step 1"
-        background_3 = clazz.new(source)
-
-
-        expect(background_1).to eq(background_2)
-        expect(background_1).to_not eq(background_3)
-      end
-
-      it 'is equal to a scenario with the same steps' do
-        source = "#{BACKGROUND_KEYWORD}:
-                    #{STEP_KEYWORD} step 1
-                    #{STEP_KEYWORD} step 2"
-        background = clazz.new(source)
-
-        source = "#{SCENARIO_KEYWORD}:
-                    #{STEP_KEYWORD} step 1
-                    #{STEP_KEYWORD} step 2"
-        scenario_1 = CukeModeler::Scenario.new(source)
-
-        source = "#{SCENARIO_KEYWORD}:
-                    #{STEP_KEYWORD} step 2
-                    #{STEP_KEYWORD} step 1"
-        scenario_2 = CukeModeler::Scenario.new(source)
-
-
-        expect(background).to eq(scenario_1)
-        expect(background).to_not eq(scenario_2)
-      end
-
-      it 'is equal to an outline with the same steps' do
-        source = "#{BACKGROUND_KEYWORD}:
-                    #{STEP_KEYWORD} step 1
-                    #{STEP_KEYWORD} step 2"
-        background = clazz.new(source)
-
-        source = "#{OUTLINE_KEYWORD}:
-                    #{STEP_KEYWORD} step 1
-                    #{STEP_KEYWORD} step 2
-                  #{EXAMPLE_KEYWORD}:
-                    | param |
-                    | value |"
-        outline_1 = CukeModeler::Outline.new(source)
-
-        source = "#{OUTLINE_KEYWORD}:
-                    #{STEP_KEYWORD} step 2
-                    #{STEP_KEYWORD} step 1
-                  #{EXAMPLE_KEYWORD}:
-                    | param |
-                    | value |"
-        outline_2 = CukeModeler::Outline.new(source)
-
-
-        expect(background).to eq(outline_1)
-        expect(background).to_not eq(outline_2)
-      end
-
-    end
-
-
-    describe 'background output' do
-
-      it 'can be remade from its own output' do
-        source = "#{BACKGROUND_KEYWORD}: A background with everything it could have
-
-                  Including a description
-                  and then some.
-
-                    #{STEP_KEYWORD} a step
-                      | value |
-                    #{STEP_KEYWORD} another step
-                      \"\"\"
-                      some string
-                      \"\"\""
-        background = clazz.new(source)
-
-        background_output = background.to_s
-        remade_background_output = clazz.new(background_output).to_s
-
-        expect(remade_background_output).to eq(background_output)
-      end
-
-
-      context 'from source text' do
-
-        it 'can output an empty background' do
-          source = ["#{BACKGROUND_KEYWORD}:"]
-          source = source.join("\n")
-          background = clazz.new(source)
-
-          background_output = background.to_s.split("\n", -1)
-
-          expect(background_output).to eq(["#{BACKGROUND_KEYWORD}:"])
-        end
-
-        it 'can output a background that has a name' do
-          source = ["#{BACKGROUND_KEYWORD}: test background"]
-          source = source.join("\n")
-          background = clazz.new(source)
-
-          background_output = background.to_s.split("\n", -1)
-
-          expect(background_output).to eq(["#{BACKGROUND_KEYWORD}: test background"])
-        end
-
-        it 'can output a background that has a description' do
-          source = ["#{BACKGROUND_KEYWORD}:",
-                    'Some description.',
-                    'Some more description.']
-          source = source.join("\n")
-          background = clazz.new(source)
-
-          background_output = background.to_s.split("\n", -1)
-
-          expect(background_output).to eq(["#{BACKGROUND_KEYWORD}:",
-                                           '',
-                                           'Some description.',
-                                           'Some more description.'])
-        end
-
-        it 'can output a background that has steps' do
-          source = ["#{BACKGROUND_KEYWORD}:",
-                    "#{STEP_KEYWORD} a step",
-                    '|value|',
-                    "#{STEP_KEYWORD} another step",
-                    '"""',
-                    'some string',
-                    '"""']
-          source = source.join("\n")
-          background = clazz.new(source)
-
-          background_output = background.to_s.split("\n", -1)
-
-          expect(background_output).to eq(["#{BACKGROUND_KEYWORD}:",
-                                           "  #{STEP_KEYWORD} a step",
-                                           '    | value |',
-                                           "  #{STEP_KEYWORD} another step",
-                                           '    """',
-                                           '    some string',
-                                           '    """'])
-        end
-
-        it 'can output a background that has everything' do
-          source = ["#{BACKGROUND_KEYWORD}: A background with everything it could have",
-                    'Including a description',
-                    'and then some.',
-                    "#{STEP_KEYWORD} a step",
-                    '|value|',
-                    "#{STEP_KEYWORD} another step",
-                    '"""',
-                    'some string',
-                    '"""']
-          source = source.join("\n")
-          background = clazz.new(source)
-
-          background_output = background.to_s.split("\n", -1)
-
-          expect(background_output).to eq(["#{BACKGROUND_KEYWORD}: A background with everything it could have",
-                                           '',
-                                           'Including a description',
-                                           'and then some.',
-                                           '',
-                                           "  #{STEP_KEYWORD} a step",
-                                           '    | value |',
-                                           "  #{STEP_KEYWORD} another step",
-                                           '    """',
-                                           '    some string',
-                                           '    """'])
-        end
-
-      end
-
-
-      context 'from abstract instantiation' do
-
-        let(:background) { clazz.new }
-
-
-        it 'can output a background that has only steps' do
-          background.steps = [CukeModeler::Step.new]
-
-          expect { background.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-end