cucumber 3.0.0.pre.1 → 4.0.0.rc.4

data/features/lib/step_definitions/cli_steps.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-Then(/^I should see the CLI help$/) do
-  expect(all_output).to include("Usage:")
-end

data/features/lib/step_definitions/cucumber_steps.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-Given /^a directory without standard Cucumber project directory structure$/ do
-  in_current_dir do
-    FileUtils.rm_rf 'features' if File.directory?('features')
-  end
-end
-
-Given /^a scenario with a step that looks like this:$/ do |string|
-  create_feature do
-    create_scenario { string }
-  end
-end
-
-Given(/^a scenario with a step that looks like this in japanese:$/) do |string|
-  create_feature_ja do
-    create_scenario_ja { string }
-  end
-end
-
-Given(/^the standard step definitions$/) do
-  write_file 'features/step_definitions/steps.rb',
-
-  <<-STEPS
-  Given(/^this step passes$/)          { }
-  Given(/^this step raises an error$/) { raise 'error' }
-  Given(/^this step is pending$/)      { pending }
-  Given(/^this step fails$/)           { fail }
-  Given(/^this step is a table step$/) {|t| }
-  STEPS
-end
-
-Given /^a step definition that looks like this:$/ do |string|
-  create_step_definition { string }
-end
-
-Given /^a scenario "([^\"]*)" that passes$/ do |name|
-  write_file "features/#{name}.feature",
-  <<-FEATURE
-  Feature: #{name}
-    Scenario: #{name}
-      Given it passes
-  FEATURE
-
-  write_file "features/step_definitions/#{name}_steps.rb",
-  <<-STEPS
-  Given(/^it passes$/) { expect(true).to be true }
-  STEPS
-end
-
-Given /^a scenario "([^\"]*)" that fails$/ do |name|
-  write_file "features/#{name}.feature",
-  <<-FEATURE
-  Feature: #{name}
-    Scenario: #{name}
-      Given it fails
-  FEATURE
-
-  write_file "features/step_definitions/#{name}_steps.rb",
-  <<-STEPS
-  Given(/^it fails$/) { expect(false).to be true }
-  STEPS
-end
-
-When /^I run the feature with the (\w+) formatter$/ do |formatter|
-  expect(features.length).to eq 1
-  run_feature features.first, formatter
-end
-
-Then /^the stderr should contain a warning message$/ do
-  expect(all_stderr).to include("[warning]")
-end
-
-module CucumberHelper
-  def run_feature(filename = 'features/a_feature.feature', formatter = 'progress')
-    run_simple "#{Cucumber::BINARY} #{filename} --format #{formatter}", false
-  end
-end
-
-World(CucumberHelper)

data/features/lib/step_definitions/iso-8859-1_steps.rb

@@ -1,13 +0,0 @@
-# encoding: iso-8859-1
-# frozen_string_literal: true
-# Ideally we would use Norwegian keywords here, but that won't work unless this file is UTF-8 encoded.
-# Alternatively it would be possible to use Norwegian keywords and encode the file as UTF-8.
-#
-# In both cases, stepdef arguments will be sent in as UTF-8, regardless of what encoding is used.
-Given /^jeg drikker en "([^"]*)"$/ do |drink|
-  expect(drink).to eq '�l'.encode('UTF-8')
-end
-
-When /^skal de andre si "([^"]*)"$/ do |greeting|
-  expect(greeting).to eq 'sk�l'.encode('UTF-8')
-end

data/features/lib/step_definitions/json_steps.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-Then /^it should (pass|fail) with JSON:$/ do |pass_fail, json|
-  actual = normalise_json(MultiJson.load(all_stdout))
-  expected = MultiJson.load(json)
-
-  expect(actual).to eq expected
-  assert_success(pass_fail == 'pass')
-end

data/features/lib/step_definitions/junit_steps.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-Then(/^the junit output file "(.*?)" should contain:$/) do |actual_file, text|
-  actual = IO.read(current_dir + '/' + actual_file)
-  actual = replace_junit_time(actual)
-  expect(actual).to eq text
-end
-
-module JUnitHelper
-  def replace_junit_time(s)
-    s.gsub(/\d+\.\d\d+/m, '0.05')
-  end
-end
-
-World(JUnitHelper)

data/features/lib/step_definitions/language_steps.rb

@@ -1,9 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-Then(/^cucumber lists all the supported languages$/) do
-  sample_languages = ["Arabic", "български", "Pirate", "English", "日本語"]
-  sample_languages.each do |language|
-    expect(all_output.force_encoding('utf-8')).to include(language)
-  end
-end

data/features/lib/step_definitions/profile_steps.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-Given /^the following profiles? (?:are|is) defined:$/ do |profiles|
-  write_file 'cucumber.yml', profiles
-end
-
-Then /^the (.*) profile should be used$/ do |profile|
-  step 'the stdout should contain:', profile
-end
-
-Then /^exactly these files should be loaded:\s*(.*)$/ do |files|
-  expect(all_stdout.scan(/^  \* (.*\.rb)$/).flatten).to eq files.split(/,\s+/)
-end
-
-Then /^exactly these features should be run:\s*(.*)$/ do |files|
-  expect(all_stdout.scan(/^  \* (.*\.feature)$/).flatten).to eq files.split(/,\s+/)
-end

data/features/lib/step_definitions/retry_steps.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-Given /^a scenario "([^\"]*)" that fails once, then passes$/ do |full_name|
-  name = snake_case(full_name)
-  write_file "features/#{name}.feature",
-  <<-FEATURE
-  Feature: #{full_name} feature
-    Scenario: #{full_name}
-      Given it fails once, then passes
-  FEATURE
-
-  write_file "features/step_defnitions/#{name}_steps.rb",
-  <<-STEPS
-  Given(/^it fails once, then passes$/) do
-    $#{name} += 1
-    expect($#{name}).to be > 1
-  end
-  STEPS
-
-  write_file "features/support/#{name}_init.rb",
-  <<-INIT
-  $#{name} = 0
-  INIT
-end
-
-Given /^a scenario "([^\"]*)" that fails twice, then passes$/ do |full_name|
-  name = snake_case(full_name)
-  write_file "features/#{name}.feature",
-  <<-FEATURE
-  Feature: #{full_name} feature
-    Scenario: #{full_name}
-      Given it fails twice, then passes
-  FEATURE
-
-  write_file "features/step_definitions/#{name}_steps.rb",
-  <<-STEPS
-  Given(/^it fails twice, then passes$/) do
-    $#{name} ||= 0
-    $#{name} += 1
-    expect($#{name}).to be > 2
-  end
-  STEPS
-
-  write_file "features/support/#{name}_init.rb",
-  <<-INIT
-  $#{name} = 0
-  INIT
-end
-
-module SnakeCase
-  def snake_case(name)
-    name.downcase.gsub(/\W/, '_')
-  end
-end
-
-World(SnakeCase)

data/features/lib/step_definitions/ruby_steps.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-When(/^I run the following Ruby code:$/) do |code|
-  run_simple %{ruby -e "#{code}"}
-end

data/features/lib/step_definitions/wire_steps.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-Given /^there is a wire server (running |)on port (\d+) which understands the following protocol:$/ do |running, port, table|
-  protocol = table.hashes.map do |table_hash|
-    table_hash['response'] = table_hash['response'].gsub(/\n/, '\n')
-    table_hash
-  end
-
-  @server = FakeWireServer.new(port.to_i, protocol)
-  start_wire_server if running.strip == "running"
-end
-
-Given /^the wire server takes (.*) seconds to respond to the invoke message$/ do |timeout|
-  @server.delay_response(:invoke, timeout.to_f)
-  start_wire_server
-end
-
-Given /^I have environment variable (\w+) set to "([^"]*)"$/ do |variable, value|
-  set_env(variable, value)
-end
-
-Then(/^the wire server should have received the following messages:$/) do |expected_messages|
-  expect(messages_received).to eq expected_messages.raw.flatten
-end
-
-module WireHelper
-  attr_reader :messages_received
-
-  def start_wire_server
-    @messages_received = []
-    reader, writer = IO.pipe
-    @wire_pid = fork { 
-      reader.close
-      @server.run(writer)
-    }
-    writer.close
-    Thread.new do
-      while message = reader.gets
-        @messages_received << message.strip
-      end
-    end
-    at_exit { stop_wire_server }
-  end
-
-  def stop_wire_server
-    return unless @wire_pid
-    Process.kill('KILL', @wire_pid)
-    Process.wait(@wire_pid)
-  rescue Errno::ESRCH
-    # No such process - wire server has already been stopped by the After hook
-  end
-end
-
-Before('@wire') do
-  extend(WireHelper)
-end
-
-After('@wire') do
-  stop_wire_server
-end

data/features/lib/support/env.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require 'aruba/cucumber'
-require 'aruba/in_process'
-require 'aruba/spawn_process'
-require 'cucumber/cli/main'
-
-Before('@spawn') do
-  Aruba.process = Aruba::SpawnProcess
-end
-
-Before('~@spawn') do
-  Aruba::InProcess.main_class = Cucumber::Cli::Main
-  Aruba.process = Aruba::InProcess
-end
-
-Before do
-  # Make sure bin/cucumber runs with SimpleCov enabled
-  # set_env('SIMPLECOV', 'true')
-
-  # Set a longer timeout for aruba, and a really long one if running on JRuby
-  @aruba_timeout_seconds = Cucumber::JRUBY ? 60 : 15
-end

data/features/lib/support/fake_wire_server.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require 'multi_json'
-require 'socket'
-
-class FakeWireServer
-  def initialize(port, protocol_table)
-    @port, @protocol_table = port, protocol_table
-    @delays = {}
-  end
-
-  def run(io)
-    @server = TCPServer.open(@port)
-    loop { handle_connections(io) }
-  end
-
-  def delay_response(message, delay)
-    @delays[message] = delay
-  end
-
-  private
-
-  def handle_connections(io)
-    Thread.start(@server.accept) { |socket| open_session_on socket, io }
-  end
-
-  def open_session_on(socket, io)
-    begin
-      on_message = lambda { |message| io.puts message }
-      SocketSession.new(socket, @protocol_table, @delays, on_message).start
-    rescue Exception => e
-      raise e
-    ensure
-      socket.close
-    end
-  end
-
-  class SocketSession
-    def initialize(socket, protocol, delays, on_message)
-      @socket = socket
-      @protocol = protocol
-      @delays = delays
-      @on_message = on_message
-    end
-
-    def start
-      while message = @socket.gets
-        handle(message)
-      end
-    end
-
-    private
-
-    def handle(data)
-      if protocol_entry = response_to(data.strip)
-        sleep delay(data)
-        @on_message.call(MultiJson.load(protocol_entry['request'])[0])
-        send_response(protocol_entry['response'])
-      else
-        serialized_exception = { :message => "Not understood: #{data}", :backtrace => [] }
-        send_response(['fail', serialized_exception ].to_json)
-      end
-    rescue => e
-      send_response(['fail', { :message => e.message, :backtrace => e.backtrace, :exception => e.class } ].to_json)
-    end
-
-    def response_to(data)
-      @protocol.detect do |entry|
-        MultiJson.load(entry['request']) == MultiJson.load(data)
-      end
-    end
-
-    def send_response(response)
-      @socket.puts response + "\n"
-    end
-
-    def delay(data)
-      message = MultiJson.load(data.strip)[0]
-      @delays[message.to_sym] || 0
-    end
-  end
-end

data/features/lib/support/feature_factory.rb

@@ -1,68 +0,0 @@
-# -*- coding: utf-8 -*-
-# frozen_string_literal: true
-module FeatureFactory
-  def create_feature(name = generate_feature_name)
-    gherkin = <<-GHERKIN
-Feature: #{name}
-#{yield}
-    GHERKIN
-    write_file filename(name), gherkin
-  end
-
-  def create_feature_ja(name = generate_feature_name)
-    gherkin = <<-GHERKIN
-# language: ja
-機能: #{name}
-#{yield}
-    GHERKIN
-    write_file filename(name), gherkin
-  end
-
-  def create_scenario(name = generate_scenario_name)
-    <<-GHERKIN
-  Scenario: #{name}
-  #{yield}
-    GHERKIN
-  end
-
-  def create_scenario_ja(name = generate_scenario_name)
-    <<-GHERKIN
-  シナリオ: #{name}
-  #{yield}
-    GHERKIN
-  end
-
-  def create_step_definition
-    write_file generate_step_definition_filename, yield
-  end
-
-  def generate_feature_name
-    "Test Feature #{next_increment(:feature)}"
-  end
-
-  def generate_scenario_name
-    "Test Scenario #{next_increment(:scenario)}"
-  end
-
-  def next_increment(label)
-    @increments ||= {}
-    @increments[label] ||= 0
-    @increments[label] += 1
-  end
-
-  def generate_step_definition_filename
-    "features/step_definitions/steps#{next_increment(:step_defs)}.rb"
-  end
-
-  def filename(name)
-    "features/#{name.downcase.gsub(' ', '_')}.feature"
-  end
-
-  def features
-    in_current_dir do
-      Dir['features/*.feature']
-    end
-  end
-end
-
-World(FeatureFactory)