aruba 0.11.0.pre4 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49dd222803f4cff003379e2972396f9df1cff2e6
-  data.tar.gz: 498409b90a251f6889a8db0abbc9edb38b2361b4
+  metadata.gz: 62427bdbd40bcd56afd8712d52200e7ade0a46a3
+  data.tar.gz: 1edaf0abe9e8d71651e9d891fe0f2a9dff81e5e8
 SHA512:
-  metadata.gz: 396fa4d9c8122b5b11901f97274bc05faf947b525b4d13df90540634571d2224a34b0f1b85ff298db7dfb4dadcae24781deabb88ec0c53593a69c5cca9b1d762
-  data.tar.gz: 1d34cc877d8aa44f50e297039e7ecc242682b59cd7bf13c1e27581b99943c537aab1e7d3c39485d9f2bbfabf695ce458f676f41c50765484bbe5bfdd769298b7
+  metadata.gz: 1576ea1206c4ab02384f227746e4344fc53a02278772a612e68aa16de5d62ada2f6da4406ff38c785ce84fe0409c8e512e0a20e12c5389fe1cd6ce652cbf7062
+  data.tar.gz: d7fc54d5f31c23b02073e6e1ea8879d2a7c7cca254cefc92504c9aac8835160310f36b3c9939c496b2facb99ebc234e51c62c87a424babfc0a89a2a8d6d8c012

data/History.md

@@ -1,17 +1,25 @@
 # Latest Release
 
+## [v0.11.1](https://github.com/cucumber/aruba/compare/v0.11.pre4...v0.11.1)
+
+* Use fixed version of event-bus
+* Refactored and improved documentation (feature tests) in PR #309
+
+# Old releases
+
+## [v0.11.0](https://github.com/cucumber/aruba/compare/v0.11.pre4...v0.11.0)
+
+* Accidently pushed to rubygems.org - yanked it afterwards
+
 ## [v0.11.0.pre4](https://github.com/cucumber/aruba/compare/v0.11.pre3...v0.11.0.pre4)
 
 * Fixed syntax for Hash on ruby 1.8.7
 * Reorder rubies in .travis.yml
 
-# Old releases
-
 ## [v0.11.0.pre3](https://github.com/cucumber/aruba/compare/v0.11.pre2...v0.11.0.pre3)
 
 * Fixed syntax for proc on ruby 1.8.7
 
-
 ## [v0.11.0.pre2](https://github.com/cucumber/aruba/compare/v0.11.pre...v0.11.0.pre2)
 
 * Integrate `EventBus` to decouple announcers from starting, stopping commands

data/README.md

@@ -82,325 +82,46 @@ well. One might want to use it together with `rspec`.
   end
   ```
 
-## API
+### Minitest
 
-`aruba` provides a wonderful API to be used in your tests:
-
-* Creating files/directories
-* Deleting files/directories
-* Checking file size
-* Checking file existence/absence
-* ...
-
-A full documentation of the API can be found [here](http://www.rubydoc.info/github/cucumber/aruba/master/frames).
-
-## Configuration
-
-Aruba has some default behaviour that you can change if you need to.
-
-### Use a different working directory
-
-Per default Aruba will create a directory `tmp/aruba` where it performs its file operations.
-If you want to change this behaviour put this into your `features/support/env.rb`:
-
-```ruby
-Before do
-  @dirs = ["somewhere/else"]
-end
-```
-
-### Modify the PATH
-
-Aruba will automatically add the `bin` directory of your project to the `PATH` environment variable for
-the duration of each Cucumber scenario. So if you're developing a Ruby gem with a binary command, you
-can test those commands as though the gem were already installed.
-
-If you need other directories to be added to the `PATH`, you can put the following in `features/support/env.rb`:
-
-```ruby
-Aruba.configure do |config|
-  config.command_search_paths = config.command_search_paths << '/my/special/bin/path'
-end
-```
-
-### Increasing timeouts
-
-A process sometimes takes longer than expected to terminate, and Aruba will kill them off (and fail your scenario) if it is still alive after 3 seconds. If you need more time you can modify the timeout by assigning a different value to `#exit_timeout` in a `Aruba.configure` block:
-
-```ruby
-Aruba.configure do |config|
-  config.exit_timeout = 5
-end
-```
-
-### Increasing IO wait time
-
-Running processes interactively can result in race conditions when Aruba executes an IO-related step
-but the interactive process has not yet flushed or read some content. To help prevent this Aruba waits
-before reading or writing to the process if it is still running. You can control the wait by setting
-`aruba.config.io_wait_timeout` to an appropriate value. This is particularly useful with tags:
-
-```ruby
-Before('@slow_process') do
-  aruba.config.io_wait_timeout = 5
-end
-```
-
-### Tags
-
-Aruba defines several tags that you can put on on individual scenarios, or on a feature.
-
-#### Seeing more output with `@announce-*`
-
-To get more information on what Aruba is doing, use these tags:
-
-* `@announce-command` - See what command is run
-* `@announce-stdout` - See the stdout
-* `@announce-stderr` - See the stderr
-* `@announce-output` - See the output of stdout and stderr
-* `@announce-directory` - See the current directory
-* `@announce-environment` - See environment variables set by Aruba
-* `@announce` - Does all of the above
-
-### Adding Hooks
-
-You can hook into Aruba's lifecycle just before it runs a command and after it has run the command:
-
-```ruby
-Aruba.configure do |config|
-  config.before :command do |cmd|
-    puts "About to run '#{cmd}'"
-  end
-
-  config.after :command do |cmd|
-    puts "After the run of '#{cmd}'"
-  end
-end
-```
-
-#### Keep files around with `@no-clobber`
-
-Aruba clobbers all files in its working directory before each scenario. -Unless you tag it with `@no-clobber`
-
-#### Making assertions about ANSI escapes with `@ansi`
-
-Aruba strips away ANSI escapes from the stdout and stderr of spawned child processes by default. It's usually rather cumbersome to
-make assertions about coloured output. Still, there might be cases where you want to leave the ANSI escapes intact. Just tag your
-scenario with `@ansi`. Alternatively you can add your own Before
-hook that sets `@aruba_keep_ansi = true`.
-
-### Testing Ruby CLI programs without spawning a new Ruby process.
-
-If your CLI program is written in Ruby you can speed up your suite of scenarios by running
-your CLI in the same process as Cucumber/Aruba itself. In order to be able to do this, the
-entry point for your CLI application must be a class that has a constructor with a particular
-signature and an `execute!` method:
-
-```ruby
-class MyMain
-  def initialize(argv, stdin=STDIN, stdout=STDOUT, stderr=STDERR, kernel=Kernel)
-    @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
-  end
-
-  def execute!
-    # your code here, assign a value to exitstatus
-    @kernel.exit(exitstatus)
-  end
-end
-```
-
-Your `bin/something` executable would look something like the following:
-
-```ruby
-require 'my_main'
-MyMain.new(ARGV.dup).execute!
-```
-
-Then wire it all up in your `features/support/env.rb` file:
-
-```ruby
-require 'aruba'
-require 'aruba/in_process'
+TBD :-)
 
-Aruba.process = Aruba::Processes::InProcess
-Aruba.process.main_class = MyMain
-```
-
-That's it! Everything will now run inside the same ruby process, making your suite
-a lot faster. Cucumber itself uses this approach to test itself, so check out the
-Cucumber source code for an example.
-
-*Pros*:
-
-* Very fast compared to spawning processes
-* You can use libraries like
-  [simplecov](https://github.com/colszowka/simplecov) more easily, because
-  there is only one "process" which adds data to `simplecov`'s database
-
-*Cons*:
-* You might oversee some bugs: You might forget to require libraries in your
-  "production" code, because you have required them in your testing code
-
-### JRuby Tips
-
-Improve startup time by disabling JIT and forcing client JVM mode.  This can be accomplished by adding
-
-```ruby
-require 'aruba/jruby'
-```
-
-or setting a hook like this example:
-
-```ruby
-Aruba.configure do |config|
-  config.before :command do |cmd|
-    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
-    set_env('JAVA_OPTS', "-d32 #{ENV['JAVA_OPTS']}") # force jRuby to use client JVM for faster startup times
-  end
-end if RUBY_PLATFORM == 'java'
-```
-
-*Note* - no conflict resolution on the JAVA/JRuby environment options is
-done; only merging. For more complex settings please manually set the
-environment variables in the hook or externally.
+## Documentation
 
-A larger process timeout for java may be needed
+### User Documentation
 
-```ruby
-Before do
-  @aruba_timeout_seconds = RUBY_PLATFORM == 'java' ? 60 : 10
-end
-```
-
-Refer to http://blog.headius.com/2010/03/jruby-startup-time-tips.html for other tips on startup time.
-
-## Fixtures
-
-Sometimes your tests need existing files to work - e.g binary data files you
-cannot create programmatically. Since `aruba` >= 0.6.3 includes some basic
-support for fixtures. All you need to do is the following:
-
-1. Create a `fixtures`-directory
-2. Create fixture files in this directory
-
-The `expand_path`-helper will expand `%` to the path of your fixtures
-directory:
-
-```ruby
-expand_path('%/song.mp3')
-# => /home/user/projects/my_project/fixtures/song.mp3
-```
-
-*Example*
-
-1. Create fixtures directory
+If you're interested in our steps and API, please browser our [feature
+files](https://github.com/cucumber/aruba/tree/master/features). You can find a
+lot of examples there. A good starting point are [Getting
+Started](https://github.com/cucumber/aruba/tree/master/features/getting_started)
+and [Step
+Overview](https://github.com/cucumber/aruba/blob/master/features/steps/overview.feature).
+A more or less full list of our steps can be found
+[here](https://github.com/cucumber/aruba/tree/master/features/steps). Our API
+is documentated
+[here](https://github.com/cucumber/aruba/tree/master/features/api) and some
+more information about how to configure `aruba`, can be found
+[here](https://github.com/cucumber/aruba/tree/master/features/configuration).
+The "RSpec" matchers provided by `aruba`, are documented
+[here](https://github.com/cucumber/aruba/tree/master/features/matchers).
 
-  ```bash
-  cd project
-  
-  mkdir -p fixtures/
-  # or
-  mkdir -p test/fixtures/
-  # or
-  mkdir -p spec/fixtures/
-  # or
-  mkdir -p features/fixtures/
-  ```
-
-2. Store `song.mp3` in `fixtures`-directory
-
-  ```bash
-  cp song.mp3 fixtures/
-  ```
+You can find our documentation on
+[Relish](http://www.relishapp.com/cucumber/aruba/docs) as well. Unfortunately
+"Relish" does not like the way we structered our feature tests. So this
+documentation found there may be not complete.
 
-3. Add fixture to vcs-repository - e.g. `git`, `mercurial`
+### Developer Documentation
 
-4. Create test
-
-  ```ruby
-  RSpec.describe 'My Feature' do
-    describe '#read_music_file' do
-      context 'when the file exists' do
-        let(:path) { expand_path('%/song.mp3') }
-
-        before :each do
-          cd('.') { FileUtils.cp path, 'file.mp3' }
-        end
-
-        before :each do
-          run 'my_command'
-        end
-
-        it { expect(all_stdout).to include('Rate is 128 KB') }
-      end
-    end
-  end
-  ```
-
-## Reporting
-
-*Important* - you need [Pygments](http://pygments.org/) installed to use this feature.
-
-Aruba can generate a HTML page for each scenario that contains:
-
-* The title of the scenario
-* The description from the scenario (You can use Markdown here)
-* The command(s) that were run
-* The output from those commands (in colour if the output uses ANSI escapes)
-* The files that were created (syntax highlighted in colour)
-
-In addition to this, it creates an `index.html` file with links to all individual report files.
-Reporting is off by default, but you can enable it by defining the `ARUBA_REPORT_DIR` environment variable, giving it the value
-where reports should be written:
-
-    ARUBA_REPORT_DIR=doc cucumber features
-
-This will use Aruba's built-in template by default (See the `templates` folder). If you want to use your own template you can override its location:
-
-    ARUBA_REPORT_TEMPLATES=templates ARUBA_REPORT_DIR=doc cucumber features
-
-The templates directory must contain a `main.erb` and `files.erb` template. It can also contain other assets such
-as css, javascript and images. All of these files will be copied over to the report dir well.
-
-### Escaping Markdown
-
-There are some edge cases where Gherkin and Markdown don't agree. Bullet lists using `*` is one example. The `*` is also an alias for
-step keywords in Gherkin. Markdown headers (the kind starting with a `#`) is another example. They are parsed as comments by Gherkin. To use either of these, just escape them with a backslash. So instead of writing:
-
-```gherkin
-Scenario: Make tea
-  ## Making tea
-  * Get a pot
-  * And some hot water
-
-  Given...
-```
-
-You'd write:
-
-```gherkin
-Scenario: Make tea
-  \## Making tea
-  \* Get a pot
-  \* And some hot water
-
-  Given...
-```
-
-This way Gherkin won't recognize these lines as special tokens, and the reporter will render them as Markdown. (The reporter strips
-away any leading the backslashes before handing it off to the Markdown parser).
-
-Another option is to use alternative Markdown syntax and omit conflicts and escaping altogether:
+`aruba` provides a wonderful API to be used in your tests:
 
-```gherkin
-Scenario: Make tea
-  Making tea
-  ----------
-  - Get a pot
-  - And some hot water
+* Creating files/directories
+* Deleting files/directories
+* Checking file size
+* Checking file existence/absence
+* ...
 
-  Given...
-```
+A full documentation of the API can be found
+[here](http://www.rubydoc.info/github/cucumber/aruba/master/frames).
 
 ## Contributing
 
@@ -408,4 +129,4 @@ Please see the `CONTRIBUTING.md`.
 
 ## Copyright
 
-Copyright (c) 2010,2011,2012,2013,2014 Aslak Hellesøy, David Chelimsky and Mike Sassak. See LICENSE for details.
+Copyright (c) 2010-2015 Aslak Hellesøy et al. See LICENSE for details.

data/aruba.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'rspec-expectations', '>= 2.99'
   s.add_runtime_dependency 'contracts', '~> 0.9'
   s.add_runtime_dependency 'thor', '~> 0.19'
-  s.add_runtime_dependency 'event-bus', '~> 0.2.0'
+  s.add_runtime_dependency 'event-bus', '~> 0.2'
 
   s.add_development_dependency 'bundler', '~> 1.10.2'
 

data/features/api/filesystem/fixtures.feature

@@ -0,0 +1,104 @@
+Feature: Use fixtures in your tests
+
+  Sometimes your tests need existing files to work - e.g binary data files you
+  cannot create programmatically. Since `aruba` >= 0.6.3 includes some basic
+  support for fixtures. All you need to do is the following:
+  
+  1. Create a `fixtures`-directory
+  2. Create fixture files in this directory
+  
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Use a fixture for your tests
+    Given a file named "features/fixtures.feature" with:
+    """
+    Feature: Fixture
+      Scenario: Fixture
+        Given a file named "fixtures_spec.rb" with:
+        \"\"\"
+        RSpec.describe 'My Feature' do
+          describe '#read_music_file' do
+            context 'when the file exists' do
+              before :each { copy '%/song.mp3', 'file.mp3' }
+
+              it { expect('file.mp3').to be_an_existing_file }
+            end
+          end
+        end
+        \"\"\"
+    """
+    And a directory named "fixtures"
+    And an empty file named "fixtures/fixtures-app/test.txt"
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Use a fixture for your tests in test/
+    Given a file named "features/fixtures.feature" with:
+    """
+    Feature: Fixture
+      Scenario: Fixture
+        Given a file named "fixtures_spec.rb" with:
+        \"\"\"
+        RSpec.describe 'My Feature' do
+          describe '#read_music_file' do
+            context 'when the file exists' do
+              before :each { copy '%/song.mp3', 'file.mp3' }
+
+              it { expect('file.mp3').to be_an_existing_file }
+            end
+          end
+        end
+        \"\"\"
+    """
+    And a directory named "test/fixtures"
+    And an empty file named "test/fixtures/fixtures-app/test.txt"
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Use a fixture for your tests in spec/
+    Given a file named "features/fixtures.feature" with:
+    """
+    Feature: Fixture
+      Scenario: Fixture
+        Given a file named "fixtures_spec.rb" with:
+        \"\"\"
+        RSpec.describe 'My Feature' do
+          describe '#read_music_file' do
+            context 'when the file exists' do
+              before :each { copy '%/song.mp3', 'file.mp3' }
+
+              it { expect('file.mp3').to be_an_existing_file }
+            end
+          end
+        end
+        \"\"\"
+    """
+    And a directory named "spec/fixtures"
+    And an empty file named "spec/fixtures/fixtures-app/test.txt"
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Use a fixture for your tests in features/
+    Given a file named "features/fixtures.feature" with:
+    """
+    Feature: Fixture
+      Scenario: Fixture
+        Given a file named "fixtures_spec.rb" with:
+        \"\"\"
+        RSpec.describe 'My Feature' do
+          describe '#read_music_file' do
+            context 'when the file exists' do
+              before :each { copy '%/song.mp3', 'file.mp3' }
+
+              it { expect('file.mp3').to be_an_existing_file }
+            end
+          end
+        end
+        \"\"\"
+    """
+    And a directory named "features/fixtures"
+    And an empty file named "features/fixtures/fixtures-app/test.txt"
+    When I run `rspec`
+    Then the specs should all pass