aruba-win-fix 0.14.2

data/features/matchers/file/be_existing_executable.feature

@@ -0,0 +1,88 @@
+Feature: Check if path exists and is an executable file
+
+  If you need to check if a given path exists and is a file, you can use the
+  `be_an_existing_executable`-matcher.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+    let(:file) { 'file.txt' }
+    before(:each) { touch(file) }
+    before(:each) { chmod(0755, file) }
+
+    it { expect(file).to be_an_existing_executable }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Expect single existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:file) { 'file.txt' }
+      before(:each) { touch(file) }
+      before(:each) { chmod(0755, file) }
+
+      it { expect(file).to be_an_existing_executable }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect single non-existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:file) { 'file.txt' }
+      it { expect(file).not_to be_an_existing_executable }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple existing executable files
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+
+      before :each do
+        files.each do |f|
+          touch(f)
+          chmod(0755, f)
+        end
+      end
+
+      it { expect(files).to all be_an_existing_executable }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect a least one existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+
+      before :each do
+        touch(files.first)
+        chmod(0755, files.first)
+      end
+
+      it { expect(files).to include an_existing_executable }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/matchers/file/be_existing_file.feature

@@ -0,0 +1,82 @@
+Feature: Check if path exists and is file
+
+  If you need to check if a given path exists and is a file, you can use the
+  `be_an_existing_file`-matcher.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.describe 'Check if file exists and is file', :type => :aruba do
+    let(:file) { 'file.txt' }
+    before(:each) { touch(file) }
+
+    it { expect(file).to be_an_existing_file }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Expect single existing file
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is file', :type => :aruba do
+      let(:file) { 'file.txt' }
+      before(:each) { touch(file) }
+      it { expect(file).to be_an_existing_file }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect single non-existing file
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is file', :type => :aruba do
+      let(:file) { 'file.txt' }
+      it { expect(file).not_to be_an_existing_file }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple existing files
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is file', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+
+      before :each do
+        files.each { |f| touch(f) }
+      end
+
+      it { expect(files).to all be_an_existing_file }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect a least one existing file
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is file', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+
+      before :each do
+        touch(files.first)
+      end
+
+      it { expect(files).to include an_existing_file }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+

data/features/matchers/file/have_file_content.feature

@@ -0,0 +1,123 @@
+Feature: Check if file has content
+
+  If you need to check if a given file has content, you can use the
+  `have_file_content`-matcher. It accepts `Object`, `Regexp` or any other
+  `RSpec::Matcher`-matchers. It fails if file does not exist.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.describe 'Check if file has content', :type => :aruba do
+    let(:file) { 'file.txt' }
+    let(:content) { 'Hello World' }
+
+    before(:each) { write_file(file, content) }
+
+    it { expect(file).to have_file_content content }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Expect existing file with content
+    Given a file named "spec/file_with_content_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check file content', :type => :aruba do
+      let(:file) { 'file.txt' }
+      let(:content) { 'Hello World' }
+
+      before(:each) { write_file(file, content) }
+
+      it { expect(file).to have_file_content content }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect existing file with partial content
+    Given a file named "spec/file_with_content_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check file content', :type => :aruba do
+      let(:file) { 'file.txt' }
+      let(:content) { 'Hello World' }
+
+      before(:each) { write_file(file, content) }
+
+      it { expect(file).to have_file_content /Hello/ }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect existing file with partial content described by another matcher
+    Given a file named "spec/file_with_content_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check file content', :type => :aruba do
+      let(:file) { 'file.txt' }
+      let(:content) { 'Hello World' }
+
+      before(:each) { write_file(file, content) }
+
+      it { expect(file).to have_file_content a_string_starting_with('Hello') }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple existing files with content
+    Given a file named "spec/file_with_content_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check file content', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+      let(:content) { 'Hello World' }
+
+      before :each do
+        files.each { |f| write_file(f, content) }
+      end
+
+      it { expect(files).to all have_file_content content }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect at least one file with content
+    Given a file named "spec/file_with_content_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check file content', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+      let(:content) { 'Hello World' }
+
+      before(:each) { write_file(files.first, content) }
+
+      it { expect(files).to include a_file_having_content content }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Fails if file does not exist
+    Given a file named "spec/file_with_content_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check file content', :type => :aruba do
+      let(:file) { 'file.txt' }
+      let(:content) { 'Hello World' }
+
+      it { expect(file).to have_file_content content }
+    end
+    """
+    When I run `rspec`
+    Then the specs should not all pass

data/features/matchers/file/have_file_size.feature

@@ -0,0 +1,107 @@
+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/matchers/path/be_an_absolute_path.feature

@@ -0,0 +1,74 @@
+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