我正在使用 Cucumber + capybara 进行一些网络自动化测试。我希望能够连接我自己的标签(类似于场景之前的@all_browsers)并让它针对我设置的网络驱动程序列表运行(celerity，firefox 上的 selenium，ie 和 chrome)。我不想在前面用 4 个不同的标签写 4 次不同的场景。我已经研究过尝试使用我通过以下方式注册的新驱动程序来执行此操作:

Capybara.register_driver :all_browsers do |app|
 # What would even work in here? I don't think anything will.
end  

然后跟进:

Before('@all_browsers') do
 # Same problem here.
end

但我不太确定应该在 Before 方法中放入什么才可能真正起作用。

我试过使用 cucumber 钩子(Hook)，特别是:

Around('@all_browsers') do |scenario, block|
  Capybara.current_driver = :selenium_firefox
  block.call

  Capybara.current_driver = :selenium_chrome
  block.call
  # etc
end

但这并不像我希望的那样。它使用相同的驱动程序并用它运行场景两次。

沿着钩子(Hook)线， cucumber 文档中有这个:
您还可以提供一个 AfterConfiguration Hook ，它将在配置 Cucumber 后运行。这个钩子(Hook)只会运行一次；在加载支持之后但在加载功能之前。您可以使用此 Hook 来扩展 Cucumber，例如，您可以影响功能的加载方式...
这可能是解决此问题的潜在途径，但我也没有想出任何适用于此的方法。

我已经研究过自定义格式化程序，但它们实际上只是看起来像它们所做的那样 - 格式化输出，而不是指定功能的实际运行方式。

我研究过覆盖 Cucumber 的功能运行程序，但这看起来并不容易或不友好。
请帮忙？有人吗？

最佳答案

因此，我最终推出了自己的解决方案。不确定这是否是最好或最优雅的方法，但实际上我只是结束了:

1. 将所有常见的环境内容抽象到 env.rb
2. 使用需要特定环境文件(例如 firefox.rb)的 Cucumber 配置文件，该文件需要 env.rb，然后将 Capybara 的默认驱动程序设置为适当的驱动程序。
3. 写了一个大 ol' thor类的任务捆绑了一堆 cucumber 命令，并调用以正确的配置文件运行坏男孩。
4. 编写了一个捆绑命令的“all_browsers”任务，然后调出每个特定的驱动程序任务，这样我现在可以有一个任务运行我在所有支持的驱动程序上提供的任何一组场景。

像一个魅力一样工作，我认为最终可能比我在上面尝试的任何事情都要好，因为在 Thor 文件中我能够添加诸如基准测试选项之类的东西，以及是否拆分该功能运行到多个线程。 仍然很好奇是否还有其他人为此提出了解决方案。

cucumber .yaml:
在这里，all_features 文件只包含所有以 .feature 结尾的东西，因为如果我拉入整个功能目录，它会拉入它下面的所有，包括所有配置文件等，这是这是我想要的，因为每个配置文件都将默认的 capybara 驱动程序设置为不同的值。一旦将 -r 指定为 cucumber 的选项，所有 自动加载任何 文件都会停止。

default: --format pretty

chrome: --format pretty -r features/support/profiles/chrome.rb -r features/all_features -r features/step_definitions

firefox: --format pretty -r features/support/profiles/firefox.rb -r features/all_features -r features/step_definitions

celerity: --format pretty -r features/support/profiles/celerity.rb -r features/all_features -r features/step_definitions

firefox.rb(“配置文件”文件):

require File.dirname(__FILE__) + "/../env.rb"

Capybara.configure do |config|
  config.default_driver = :selenium_firefox
end

selenium_firefox.rb(我在其中注册了驱动程序，并设置了一些我现在不需要的标签功能，因为 @selenium_firefox 标签是我最初尝试的一部分问题):

# Register a specific selenium driver for firefox
Capybara.register_driver :selenium_firefox do |app|
  Capybara::Driver::Selenium.new(app, :browser => :firefox)
end

# Allows the use of a tag @selenium_firefox before a scenario to run it in selenium with firefox
Before('@selenium_firefox') do
  Capybara.current_driver = :selenium_firefox
end

feature_runner.thor:

require 'benchmark'

class FeatureRunner < Thor
  APP_ROOT = File.expand_path(File.dirname(__FILE__) + "/../")

  # One place to keep all the common feature runner options, since every runner in here uses them.
  # Modify here, and all runners below will reflect the changes, as they all call this proc.
  feature_runner_options = lambda { 
    method_option :verbose, :type => :boolean, :default => true, :aliases => "-v"
    method_option :tags, :type => :string
    method_option :formatter, :type => :string
    method_option :other_cucumber_args, :type => :string
  }


  desc "all_drivers_runner", "Run features in all available browsers"
  method_option :benchmark, :type => :boolean, :default => false
  method_option :threaded, :type => :boolean, :default => true
  feature_runner_options.call # Set up common feature runner options defined above
  def all_drivers_runner
    if options[:threaded]
      feature_run = lambda { 
        thread_pool = []

        t = Thread.new do |n|
          invoke :firefox_runner
        end
        thread_pool << t

        t = Thread.new do |n|
          invoke :chrome_runner
        end
        thread_pool << t

        t = Thread.new do |n|
          invoke :celerity_runner
        end
        thread_pool << t

        thread_pool.each {|th| th.join}
      }
    else
      feature_run = lambda { 
        invoke "feature_runner:firefox_runner", options
        invoke "feature_runner:chrome_runner", options
        invoke "feature_runner:celerity_runner", options
      }
    end

    if options[:benchmark]
      puts "Benchmarking feature run"
      measure = Benchmark.measure { feature_run.call }
      puts "Benchmark Results (in seconds):"
      puts "CPU Time: #{measure.utime}"
      puts "System CPU TIME: #{measure.stime}"
      puts "Elasped Real Time: #{measure.real}"
    else
      feature_run.call
    end
  end

  desc "firefox_runner", "Run features on firefox"
  feature_runner_options.call # Set up common feature runner options defined above
  def firefox_runner
    command = build_cucumber_command("firefox", options)
    run_command(command, options[:verbose])
  end

  desc "chrome_runner", "Run features on chrome"
  feature_runner_options.call # Set up common feature runner options defined above
  def chrome_runner
    command = build_cucumber_command("chrome", options)
    run_command(command, options[:verbose])
  end

  desc "celerity_runner", "Run features on celerity"
  feature_runner_options.call # Set up common feature runner options defined above
  def celerity_runner
    command = build_cucumber_command("celerity", options)
    run_command(command, options[:verbose])
  end

  private
  def build_cucumber_command(profile, options)
    command = "cd #{APP_ROOT} && ./bin/cucumber -p #{profile}"
    command += " --tags=#{options[:tags]}" if options[:tags]
    command += " --formatter=#{options[:formatter]}" if options[:formatter]
    command += " #{options[:other_cucumber_args]}" if options[:other_cucumber_args]
    command
  end

  def run_command(command, verbose)
    puts "Running: #{command}" if verbose
    output = `#{command}`
    puts output if verbose
  end

end

一切结束的地方，与根目录相关:

.
|____cucumber.yml
|____features
| |____all_features.rb
| |____google_search.feature
| |____step_definitions
| | |____google_steps.rb
| | |____web_steps.rb
| |____support
| | |____custom_formatters
| | | |____blah.rb
| | |____env.rb
| | |____paths.rb
| | |____profiles
| | | |____celerity.rb
| | | |____chrome.rb
| | | |____firefox.rb
| | |____selenium_drivers
| | | |____selenium_chrome.rb
| | | |____selenium_firefox.rb
| | | |____selenium_ie.rb
| | | |____selenium_remote.rb
| | |____selenium_drivers.rb
|____tasks
| |____feature_runner.thor
| |____server_task.rb  

thor -T 的输出

feature_runner
--------------
thor feature_runner:all_drivers_runner  # Run features in all available browsers
thor feature_runner:celerity_runner     # Run features on celerity
thor feature_runner:chrome_runner       # Run features on chrome
thor feature_runner:firefox_runner      # Run features on firefox  

现在我可以运行类似的东西:
雷神 feature_runner:all_drivers_runner --benchmark
这将在每个驱动程序的线程中运行所有 capybara 驱动程序的所有功能，对结果进行基准测试。

或者
雷神 feature_runner:celerity_runner
这将仅在速度上运行所有功能。

但我现在还可以为传递给 cucumber 的 thor 命令提供一些其他选项，例如:
--tags=@all_browsers
--formatter=hotpants
--other_cucumber_args="--dry-run --guess --etc"

特征文件现在的样子:

Feature: Start up browser
  @all_browsers
  Scenario: Search Google
   Given I am on the home page
   When I fill in the search bar with "Capybara"
   And I press "Search"
   Then I should see "Capybara"

似乎有很多设置，但现在如果我用@all_browsers 标记一个功能，我可以构建一个套件来测试所有 capybara 驱动程序，在多线程环境中，使用一个 thor 命令:
雷神 feature_runner:all_drivers_runner --threaded --tags=@all_browsers

或者构建一个快速运行的冒烟测试套件:
雷神 feature_runner:celerity_runner --tags=@smoke_test

关于ruby - 有没有人想出一种方法来在多个浏览器/网络驱动程序上运行相同的 cucumber 场景？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/4384346/