gurke 1.0.1 → 2.0.0.dev.1.b17

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: ba96b511b63ade3b7846428a3af7a09c643b3551
-  data.tar.gz: 21cf019e6773067c52d53327865ecbb135a60e36
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDc3MWMyNWIzYzQ0MGRmMWFkMmIyMmFmMjYwMTgzN2I3NmQ0YTdmYQ==
+  data.tar.gz: !binary |-
+    ODQ4YWI3ZTUyZDhmYjk2YzQ2NWQwOWY1ZmM1YzFkNDQ5YWRhZTJjYQ==
 SHA512:
-  metadata.gz: 9d798023595db4dcf3b64bd1d6b93ff1644acea4b87493304100abf3c81ae0ab148648a157ef44923f4b968976421b8be3d8f19f9d8851b39687d1fcd1ba2463
-  data.tar.gz: 3d438d0bd1bcf5a065f7afb3c2755350038a64eb9417204c2b00bd25e38221ff615038846857a14f41f04e47d5ef92d94052c4564ae76b4ca97cc1791ef0f2e8
+  metadata.gz: !binary |-
+    OTcwMGYwOTM2NTEzNGQ0MWU0YmFiN2I3OWMxNjAxZTc4N2Q0OGEwYTdkOGY4
+    NDJkNmI0MjY0ZTYzYzcyMTVhNDZkYWY0MWE2MzVmYTc1ZjE1ZTMxYzZkMjQ2
+    OGU4ZTRmODkyZTQ2MWMzY2VjOTM0MWE5MTdhNWQwODdiYjEwZmQ=
+  data.tar.gz: !binary |-
+    MmUyOWRiZDQ3ZWYyMDU5ZGY0M2Y3ODk2MmIyYThjNGI2MGYzNTEyMTJiNzJl
+    ZTAzOGZlNzIwMGJmNGQzZDBlY2E5ZDBlZDk1ZDlhOWVlZDFhMzJiYjJjODJh
+    ZGNjMmU1OWFjOTdjMTkwNmFjNTE5ZDQ4NDI1MGViZTliNTA4ZjA=

data/README.md

@@ -1,74 +1,121 @@
 # Gurke
 
-**Gurke** is a highly opinionated cucumber toolkit overtaking cucumbers formatter to add webm flv video recording with headless (xvfb), multiple output formatters, global available current step and scenario and additional hooks.
+**Gurke** is an experimental, alternative cucumber runner. It ~~steals~~ borrows ideas and concepts from [turnip](https://github.com/jnicklas/turnip), [rspec](http://rspec.info) and tries to avoid [cucumber](https://github.com/cucumber/cucumber/).
 
-Unfinished, not recommended, highly dangerous!
+That includes * Step definitions in modules * Before, After and Around hooks * Formatters * Partial step inclusion (via modules) * etc. Also new ideas like keyword depended step definitions are planned.
+
+But still **Gurke** is unfinished, not recommended and highly dangerous!
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Or install it yourself as:
+
+    $ gem install gurke
 
-    gem 'gurke'
+Or add it to your `Gemfile` and install it using bundler.
 
-And then execute:
+## Usage
 
-    $ bundle
+1. Put features in `features/`.
 
-Or install it yourself as:
+2. Put support and configuration files as ruby into `features/support/**`.
 
-    $ gem install gurke
+e.g.
 
-## Usage
+```ruby
+# features/support/gurke.rb
+require 'gurke/rspec'
+require 'tmpdir'
 
+Gurke.configure do |c|
+  c.around(:scenario) do |scenario|
+    Dir.mktmpdir('gurke') do |dir|
+      @__root = Pathname.new(dir)
+      scenario.call
+    end
+  end
+end
 ```
-require 'gurke'
 
-require 'cucumber/formatter/pretty'
-require 'cucumber/formatter/junit'
-require 'gurke/formatters/headless'
+3. Put your step definitions into `features/support/**`.
 
-class MyExternalTool < ::Gurke::Formatters::Base
-  def quiet?
-    options[:quiet]
-  end
+```ruby
+# features/support/steps/file_steps.rb
+module FileSteps
+  step(/a file "(.*?)" with the following content exists/) do |path, step|
+    file = @__root.join(path)
 
-  def before_features(features)
-    puts 'BUUUH!' unless quiet?
+    FileUtils.mkdir_p(File.dirname(file))
+    File.write(file, step.doc_string)
   end
 end
 
-Gurke::Formatter.config do
-  use Cucumber::Formatter::Pretty
-  use Cucumber::Formatter::JUnit
-  use MyExternalTool, quiet: true
-  use Gurke::Formatters::Headless, dir: 'report/html', recording: true, record_all: true
-end
+Gurke.configure{|c| c.include FileSteps }
 ```
 
-```
-Gurke.current.step
-Gurke.current.scenario
+You can also use an existing method as a step:
 
-Gurke.before :features do |*args|
-  # ...
-end
+```ruby
+module MySteps
+  def do_something(arg)
+    # ...
+  end
 
-Gurke.before :feature_element do |*args|
-  # ...
+  step(/I do something: "(.*?)"/, :do_something)
+
+  # Easy call it from another step
+  step(/I do something else/) { do_something('abc') }
 end
+```
+
+### Keyword specific step definitions
+
+You can also define steps for only a specific keyword. This also allows you to use the same step pattern for different keywords, e.g.
 
-Gurke.after :step_result do |*args|
-  # ...
+```ruby
+module PathSteps
+  Given(/^I am on the start page$/) { visit '/' }
+  Then(/^I am on the start page$/) { assert current_path == '/' }
 end
+```
 
-#...
+Therefore you can write your scenarios in a documentary style of facts:
 
 ```
+Scenario: Use the back button
+  Given I am on the start page
+  When I click on "Go to another page"
+  And I click the back button
+  Then I am on the start page
+```
+
+`And` and `But` steps will inherit the keyword type from the step before, e.g. the `And` step above will be of the `when` type.
+
+### Use the command line runner
+
+Run all scenarios by just calling `bundle exec gurke`. By default scenarios and features tagged with `@wip` will be ignored.
+
+Specify one or more `--tags` or `-t` arguments to filter for specific tags, negate tag filters with `~`.
+
+Examples:
+
+* `--tags a,b` - only run scenarios with tags `@a` AND `@b`
+* `-t a -t b` - only run scenarios with tags `@a` OR `@b`
+* `-t a,~b` - only run scenarios with `@a` but not `@b`
 
 ## TODO
 
-* Headless Dir & HTML Template
+* Random run order (rspec)
+* Using strings with placeholders as step pattern (turnip)
+* Custom placeholders (turnip)
+* Define scenario specific after hook in a step (e.g. to close opened resource)
+* More reporters (NyanCat / JUnit / TeamCity / Adapter to run multiple reporters)
+* SimpleCov support (and use it in own tests)
+
+## History
+
+Now: * Can finally (start to) test itself.
 
 ## Contributing
 
-Don't even think about it.
+Send me code.

data/bin/gurke

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'gurke'
+require 'gurke/cli'
+
+Gurke::CLI.new.run(ARGV)

data/features/gurke.feature

@@ -0,0 +1,47 @@
+Feature: Use gurke
+  As a developer
+  In order to run my feature definitions
+  I want to use the gurke command line program
+
+  Background:
+    Given I am in a project using gurke
+
+  Scenario: Run a passing feature file
+    Given a file "features/test.feature" with the following content exists
+      """
+      Feature: F
+        Scenario: Scenario A
+          Given everything is ok
+      """
+    And a file "features/support/steps/test_steps.rb" with the following content exists
+      """
+      module TestSteps
+        step("everything is ok") { }
+      end
+      Gurke.configure{|c| c.include TestSteps }
+      """
+    When I execute "bundle exec gurke"
+    Then the program exit code should be null
+    And the program output should include "Feature: F"
+    And the program output should include "Scenario: Scenario A"
+    And the program output should include "Given everything is ok"
+    And the program output should include "1 scenarios: 0 failing, 0 pending"
+
+  Scenario: Run a failing feature file
+    Given a file "features/test.feature" with the following content exists
+      """
+      Feature: F
+        Scenario: Scenario A
+          Given nothing is ok
+
+      """
+    And a file "features/support/steps/test_steps.rb" with the following content exists
+      """
+      module TestSteps
+        step("nothing is ok") { raise RuntimeError }
+      end
+      Gurke.configure{|c| c.include TestSteps }
+      """
+    When I execute "bundle exec gurke"
+    And the program output should include "1 scenarios: 1 failing, 0 pending"
+    Then the program exit code should be non-null

data/features/gurke.rb

@@ -0,0 +1,12 @@
+require 'gurke/rspec'
+require 'tmpdir'
+
+Gurke.configure do |c|
+  c.around(:scenario) do |scenario|
+
+    Dir.mktmpdir('gurke') do |dir|
+      @__root = Pathname.new(dir)
+      scenario.call
+    end
+  end
+end

data/features/gurke/backtrace_filtering.feature

@@ -0,0 +1,36 @@
+Feature: Backtrace filtering
+  As a developer
+  In order to faster find the backtrace lines
+  I want to see modified backtraces with only non-library calls
+
+  Background:
+    Given I am in a project using gurke
+    And a file "features/test.feature" with the following content exists
+      """
+      Feature: F
+        Scenario: Scenario A
+          Given there is an error
+
+      """
+    And a file "features/support/steps/test_steps.rb" with the following content exists
+      """
+      module TestSteps
+        step("there is an error") { raise RuntimeError }
+      end
+      Gurke.configure{|c| c.include TestSteps }
+      """
+
+  Scenario: See backtrace without line from libraries
+    When I execute "bundle exec gurke"
+    Then the program output should include "features/support/steps/test_steps.rb:2"
+    Then the program output should not include "gurke/lib/gurke/runner.rb"
+
+  Scenario: See backtrace when run with --backtrace
+    When I execute "bundle exec gurke --backtrace"
+    Then the program output should include "features/support/steps/test_steps.rb:2"
+    Then the program output should include "gurke/lib/gurke/runner.rb"
+
+  Scenario: See backtrace when run with -b
+    When I execute "bundle exec gurke -b"
+    Then the program output should include "features/support/steps/test_steps.rb:2"
+    Then the program output should include "gurke/lib/gurke/runner.rb"

data/features/gurke/filter_by_tags.feature

@@ -0,0 +1,70 @@
+Feature: Backtrace filtering
+  In order to not always run every fukcin long scenario
+  As a tester
+  I want to filter features and scenarios by tags to only run a subset
+
+  Background:
+    Given I am in a project using gurke
+    And a file "features/support/steps/test_steps.rb" with the following content exists
+      """
+      module TestSteps
+        step("everything's ok") { true && true }
+      end
+      Gurke.configure{|c| c.include TestSteps }
+      """
+    And a file "features/feature_flag_a.feature" with the following content exists
+      """
+      @a @c @d
+      Feature: Feature Flagged little-A
+        Scenario: Best Scenario evvvarrr
+          Then everything's ok
+      """
+    And a file "features/feature_flag_b.feature" with the following content exists
+      """
+      @b @c @d
+      Feature: Feature Flagged little-B
+        Scenario: Best Scenario evvvarr, the second
+          Then everything's ok
+      """
+    And a file "features/feature_flag_wip.feature" with the following content exists
+      """
+      @wip
+      Feature: Feature Flagged little-WIP
+        Scenario: Best Scenario evvarr, the second
+          Then everything's ok
+      """
+
+  Scenario: Do not run @wip by default
+    When I execute "bundle exec gurke"
+    Then the program output should include "Feature Flagged little-A"
+    And the program output should include "Feature Flagged little-B"
+    And the program output should not include "Feature Flagged little-WIP"
+    And the program output should include "2 scenarios"
+
+  Scenario: Filter with positive tag match
+    When I execute "bundle exec gurke --tags a"
+    Then the program output should include "Feature Flagged little-A"
+    And the program output should not include "Feature Flagged little-B"
+    And the program output should not include "Feature Flagged little-WIP"
+    And the program output should include "1 scenarios"
+
+  Scenario: Filter with negative tag match
+    When I execute "bundle exec gurke -t ~b"
+    Then the program output should include "Feature Flagged little-A"
+    And the program output should not include "Feature Flagged little-B"
+    And the program output should include "Feature Flagged little-WIP"
+    And the program output should include "2 scenarios"
+
+  Scenario: Filter with multiple tag match and'ed
+    When I execute "bundle exec gurke --tags c,d"
+    Then the program output should include "Feature Flagged little-A"
+    And the program output should include "Feature Flagged little-B"
+    And the program output should not include "Feature Flagged little-WIP"
+    And the program output should include "2 scenarios"
+
+  Scenario: Filter with multiple tag match or'ed
+    When I execute "bundle exec gurke --tags b --tags wip"
+    Then the program output should not include "Feature Flagged little-A"
+    And the program output should include "Feature Flagged little-B"
+    And the program output should include "Feature Flagged little-WIP"
+    And the program output should include "2 scenarios"

data/features/gurke/step_specific_definitions.feature

@@ -0,0 +1,41 @@
+Feature: Step keyword specific definitions
+  In order to allow documentary style scenarios
+  As a user
+  I want to define same steps with different step keywords
+
+  Background:
+    Given I am in a project using gurke
+
+  Scenario: Use same step definition with different keyword
+    Given a file "features/test.feature" with the following content exists
+      """
+      Feature: F
+        Scenario: Scenario A
+          Given I am "John"
+          When I am "John"
+          Then I am "John"
+
+      """
+    And a file "features/support/steps/test_steps.rb" with the following content exists
+      """
+      require 'test/unit/assertions'
+
+      module Steps
+        include MiniTest::Assertions
+
+        Given(/^I am "(.+)"$/) do |name|
+          @me = name
+        end
+
+        When(/^I am "(.+)"$/) do |name|
+          @copy = @me
+        end
+
+        Then(/^I am "(.+)"$/) do |name|
+          assert name == @copy, "Expected #{name.inspect} but #{@me.inspect} given."
+        end
+      end
+      Gurke.world.send :include, Steps
+      """
+    When I execute all scenarios
+    Then all scenarios have passed

data/features/support/steps/cli_steps.rb

@@ -0,0 +1,50 @@
+require 'open3'
+
+#
+module CLISteps
+  def _execute(exec)
+    Dir.chdir(@__root) do
+      Bundler.with_clean_env do
+        Open3.popen2e(exec) do |_, stdout_err, wait_thr|
+          exit_status = wait_thr.value
+          stdout_err  = stdout_err.read
+
+          @last_process = [exit_status.to_i, stdout_err]
+        end
+      end
+    end
+  end
+
+  step(/I execute "(.*?)"/, :_execute)
+
+  step('I execute all scenarios') do
+    _execute 'bundle exec gurke'
+  end
+
+  step(/the program exit code should be null/) do
+    expect(@last_process[0]).to eq 0
+  end
+
+  step(/the program exit code should be non-null/) do
+    expect(@last_process[0]).to_not eq 0
+  end
+
+  def _cli_include_content(content)
+    expect(@last_process[1]).to include content
+  end
+
+  step(/the program output should include "(.*?)"/, :_cli_include_content)
+
+  def _cli_not_include_content(content)
+    expect(@last_process[1]).to_not include content
+  end
+
+  step(/the program output should not include "(.*?)"/,
+       :_cli_not_include_content)
+
+  step(/all scenarios have passed/) do
+    _cli_include_content 'scenarios: 0 failing, 0 pending'
+  end
+end
+
+Gurke.configure{|c| c.include CLISteps }