aruba 0.14.14 → 1.0.0

data/features/05_use_rspec_matchers/file/have_file_size.feature

@@ -1,107 +0,0 @@
-Feature: Check if path has size
-
-  If you need to check if a given path has file size, you can use the
-  `have_file_size`-matcher. It fails if the file does not exist.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if file has size', :type => :aruba do
-    let(:file) { 'file.txt' }
-    let(:size) { 1 }
-
-    before(:each) { write_fixed_size_file(file, size) }
-
-    it { expect(file).to have_file_size size }
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect file of given size
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:size) { 1 }
-
-      before(:each) { write_fixed_size_file(file, size) }
-
-      it { expect(file).to have_file_size size }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple files of given size
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:size) { 1 }
-
-      before :each do
-        files.each { |f| write_fixed_size_file(f, size) }
-      end
-
-      it { expect(files).to all have_file_size size }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one file of size
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:size) { 1 }
-
-      before :each do
-        write_fixed_size_file(files.first, size)
-      end
-
-      it { expect(files).to include a_file_of_size size }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Fails because file has different size than expected
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:size) { 1 }
-
-      before(:each) { write_fixed_size_file(file, size) }
-
-      it { expect(file).to have_file_size 2 }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass
-
-  Scenario: Fails if file does not exist
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:size) { 1 }
-
-      it { expect(file).to have_file_size size }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass

data/features/05_use_rspec_matchers/path/be_an_absolute_path.feature

@@ -1,74 +0,0 @@
-Feature: Check if path is absolute
-
-  If you need to check if a given path is absolute , you can use the
-  `be_an_absolute_path`-matcher. It doesn't care if the path is a directory or
-  a path.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if path is absolute', :type => :aruba do
-    let(:path) { 'file.txt' }
-    before(:each) { touch(path) }
-
-    it { expect(path).to be_an_absolute_path }
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect single existing path
-    Given a file named "spec/absolute_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path is absolute', :type => :aruba do
-      let(:path) { '/path/to/file.txt' }
-      it { expect(path).to be_an_absolute_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple absolute paths
-    Given a file named "spec/absolute_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path is absolute', :type => :aruba do
-      let(:paths) { %w(/path/to/path1.txt /path/to/path2.txt) }
-
-      it { expect(paths).to all be_an_absolute_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one existing path
-    Given a file named "spec/absolute_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path is absolute', :type => :aruba do
-      let(:paths) { %w(/path/to/path1.txt path2.txt) }
-
-      it { expect(paths).to include an_absolute_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect failure on relative path
-    Given a file named "spec/absolute_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path is absolute', :type => :aruba do
-      let(:paths) { %w(path2.txt) }
-
-      it { expect(paths).to be_an_absolute_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass

data/features/05_use_rspec_matchers/path/be_an_existing_path.feature

@@ -1,97 +0,0 @@
-Feature: Check if path exists
-
-  If you need to check if a given path exists, you can use the
-  `be_an_existing_path`-matcher. It doesn't care if the path is a directory or
-  a path.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if path exists', :type => :aruba do
-    let(:path) { 'file.txt' }
-    before(:each) { touch(path) }
-
-    it { expect(path).to be_an_existing_path }
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect single existing path
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:path) { 'file.txt' }
-      before(:each) { touch(path) }
-      it { expect(path).to be_an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect single existing directory
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:path) { 'dir.d' }
-      before(:each) { create_directory(path) }
-      it { expect(path).to be_an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect single non-existing path
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:path) { 'file.txt' }
-      it { expect(path).not_to be_an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple existing paths
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:paths) { %w(path1.txt path2.txt) }
-
-      before :each do
-        paths.each { |f| touch(f) }
-      end
-
-      it { expect(paths).to all be_an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one existing path
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:paths) { %w(path1.txt path2.txt) }
-
-      before :each do
-        touch(paths.first)
-      end
-
-      it { expect(paths).to include an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-

data/features/05_use_rspec_matchers/path/have_permissions.feature

@@ -1,118 +0,0 @@
-Feature: Check if path has permissions in filesystem
-
-  If you need to check if a given path has some permissions in filesystem, you
-  can use the `have_permissions`-matcher. It fails if the file or directory
-  does not exist. You need to pass it the permissions either as `Octal`
-  (`0700`) or `String` (`'0700'`).
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if path has permissions', :type => :aruba do
-    context 'when is file' do
-      let(:file) { 'file.txt' }
-      let(:permissions) { 0700 }
-
-      before(:each) { touch(file) }
-      before(:each) { chmod(permissions, file }
-
-      it { expect(file).to have_permissions permissions }
-    end
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect file with permissions
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:permissions) { 0600 }
-
-      before(:each) { touch(file) }
-      before(:each) { chmod(permissions, file) }
-
-      it { expect(file).to have_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect directory with permissions
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:directory) { 'directory.d' }
-      let(:permissions) { 0700 }
-
-      before(:each) { create_directory(directory) }
-      before(:each) { chmod(permissions, directory) }
-
-      it { expect(directory).to have_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple files with given permissions
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:permissions) { 0600 }
-
-      before :each do
-        files.each do |f|
-          touch(f)
-          chmod(permissions, f)
-        end
-      end
-
-      it { expect(files).to all have_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one file with permissions
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:permissions) { 0600 }
-
-      before :each do
-        touch(files.first)
-        chmod(permissions, files.first)
-      end
-
-      it { expect(files).to include a_path_having_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Fails if path does not exist
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:path) { 'file.txt' }
-      let(:permissions) { 0700 }
-
-      it { expect(path).to have_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass

data/features/06_use_aruba_cli/initialize_project_with_aruba.feature

@@ -1,79 +0,0 @@
-Feature: Initialize project with aruba
-
-  To add `aruba` to your project you can use the `aruba init`-command.
-
-  Background:
-    Given I use the fixture "empty-app"
-
-  Scenario: Create files for RSpec
-    When I successfully run `aruba init --test-framework rspec`
-    Then the following files should exist:
-      | spec/spec_helper.rb |
-    And the file "spec/support/aruba.rb" should contain:
-    """
-    require 'aruba/rspec'
-    """
-    And the file "Gemfile" should contain:
-    """
-    gem 'aruba'
-    """
-    When I successfully run `rspec`
-    Then the output should contain:
-    """
-    0 examples, 0 failures
-    """
-
-  Scenario: Create files for Cucumber
-    When I successfully run `aruba init --test-framework cucumber`
-    Then the file "features/support/aruba.rb" should contain:
-    """
-    require 'aruba/cucumber'
-    """
-    And the file "Gemfile" should contain:
-    """
-    gem 'aruba'
-    """
-    When I successfully run `cucumber`
-    Then the output should contain:
-    """
-    0 scenarios
-    0 steps
-    """
-
-  Scenario: Create files for Cucumber (Default)
-    When I successfully run `aruba init`
-    Then the file "features/support/aruba.rb" should contain:
-    """
-    require 'aruba/cucumber'
-    """
-    And the file "Gemfile" should contain:
-    """
-    gem 'aruba'
-    """
-    When I successfully run `cucumber`
-    Then the output should contain:
-    """
-    0 scenarios
-    0 steps
-    """
-
-  Scenario: Create files for Minitest
-    When I successfully run `aruba init --test-framework minitest`
-    Then the following files should exist:
-      | test/test_helper.rb |
-    And the file "Gemfile" should contain:
-    """
-    gem 'aruba'
-    """
-    When I successfully run `ruby -Ilib:test test/use_aruba_with_minitest.rb`
-    Then the output should contain:
-    """
-    0 runs, 0 assertions, 0 failures, 0 errors, 0 skips
-    """
-
-  Scenario: Unknown Test Framework
-    When I run `aruba init --test-framework unknown`
-    Then the output should contain:
-    """
-    got unknown
-    """

data/features/06_use_aruba_cli/open_console.feature

@@ -1,55 +0,0 @@
-Feature: Aruba Console
-
-  Background:
-    Given a mocked home directory
-
-  Scenario: Start console
-    Given I run `aruba console` interactively
-    When I close the stdin stream
-    Then the output should contain:
-    """
-    aruba:001:0>
-    """
-
-  @unsupported-on-platform-java
-  Scenario: Show help
-    Given I run `aruba console` interactively
-    And I type "aruba_help"
-    When I close the stdin stream
-    Then the output should contain:
-    """
-    Version:
-    """
-    And the output should contain:
-    """
-    Issue Tracker:
-    """
-    And the output should contain:
-    """
-    Documentation:
-    """
-
-  @unsupported-on-platform-java
-  Scenario: Show methods
-    Given I run `aruba console` interactively
-    And I type "aruba_methods"
-    When I close the stdin stream
-    Then the output should contain:
-    """
-    Methods:
-    """
-    And the output should contain:
-    """
-    * setup_aruba
-    """
-
-  @unsupported-on-platform-java
-  Scenario: Has its own history file
-    Given I run `aruba console` interactively
-    And I type "IRB.conf[:HISTORY_FILE]"
-    And I type "exit"
-    When I close the stdin stream
-    Then the output should contain:
-    """
-    ~/.aruba_history
-    """

data/features/08_other/improve_performance_if_using_jruby.feature

@@ -1,37 +0,0 @@
-Feature: Support for JRuby
-
-  Improve startup time by disabling JIT and forcing client JVM mode.  This can
-  be accomplished by adding
-
-  ```ruby
-  require 'aruba/config/jruby'
-  ```
-
-  *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.
-
-  Refer to http://blog.headius.com/2010/03/jruby-startup-time-tips.html for other tips on startup time.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  @requires-ruby-platform-java
-  Scenario:
-    Given a file named "spec/jruby_env_spec.rb" with:
-      """
-      require 'spec_helper'
-      require 'aruba/config/jruby'
-
-      RSpec.describe 'running commands with before :command hook', :type => :aruba do
-        it 'sets up for efficient JRuby startup' do
-          with_environment 'JRUBY_OPTS' => '-d' do
-            run_command_and_stop('env')
-
-            expect(last_command_started.output).to include 'JRUBY_OPTS=--dev -X-C -d'
-          end
-        end
-      end
-      """
-    When I run `rspec`
-    Then the specs should all pass