subprocess 0.1.6 → 0.15

data/features/popen_over_ssh.feature

@@ -1,44 +0,0 @@
-Feature: Run simple remote subprocesses over ssh in ruby
-
-  As a ruby hacker
-  I want to run remote system subprocesses over ssh
-  And I want to have them presented as objects
-  So that I can get more data about said subprocesses
-  And so that I can have more fine grained control of said subprocesses
-
-  Scenario Outline: run simple remote subprocesses
-    Given I have a new remote Subprocess instance initialized with "<command>"
-    When I invoke the run method of said remote subprocess
-    And I invoke the wait method of said remote subprocess
-    Then the remote instances exit status is "<exitstatus>"
-    And the remote instances stdout matches "<stdout>"
-    And the remote instances stderr matches "<stderr>"
-    And the remote instance should have a numerical pid
-
-    Scenarios: zero exit code remote subprocesses with stdout
-      | command | exitstatus | stdout | stderr |
-      | echo 1 | 0 | 1 |  |
-
-    Scenarios: zero exit code remote subprocesses with stderr
-      | command | exitstatus | stdout | stderr |
-      | echo 1 1>&2 | 0 |  | 1 |
-
-    Scenarios: zero exit code remote subprocesses with stdout and stderr
-      | command | exitstatus | stdout | stderr |
-      | echo 1 && echo 1 1>&2 | 0 | 1 | 1 |
-
-    Scenarios: nonzero exit code remote subprocesses with stdout
-      | command | exitstatus | stdout | stderr |
-      | echo 1 && exit 1 | 1 | 1 |  |
-      | echo 1 && exit 2 | 2 | 1 |  |
-      | echo 1 && exit 99 | 99 | 1 |  |
-
-    Scenarios: nonzero exit code remote subprocesses with stderr
-      | command | exitstatus | stdout | stderr |
-      | echo 1 1>&2 && exit 1 | 1 |  | 1 |
-
-    Scenarios: nonzero exit code remote subprocesses with stdout and stderr
-      | command | exitstatus | stdout | stderr |
-      | echo 1 && echo 1 1>&2 && exit 1 | 1 | 1 | 1 |
-
-

data/features/popen_over_ssh_without_blocking.feature

@@ -1,16 +0,0 @@
-Feature: Run simple remote subprocesses without blocking and over ssh in ruby
-
-  As a ruby hacker
-  I want to run remote system subprocesses that do not block over ssh
-  And I want to have them presented as objects
-  So that I can get more data about said subprocesses
-  And so that I can have more fine grained control of said subprocesses
-
-  Scenario: run simple remote nonblocking subprocess
-    Given I have a new remote nonblocking subprocess that takes a long time to run
-    When I invoke the run method of said nonblocking remote subprocess
-    Then the remote nonblocking subprocess should not block
-    And the remote nonblocking subprocess should report its run status
-    And the remote nonblocking subprocess should support being waited on till complete
-    And the remote nonblocking subprocess should have status info
-

data/features/popen_remote_fails_with_invalid_auth_data.feature

@@ -1,13 +0,0 @@
-Feature: Run simple remote subprocesses that has bad auth data
-
-  As a ruby hacker
-  I want to run system remote subprocesses that require auth data
-  So they can be secure
-  And actually remote :)
-
-  Scenario: run simple remote subprocess with bad auth data
-    Given I have a new remote subproces with invalid username
-    And invalid password
-    When I run the remote subprocess
-    Then the remote subprocess should return an error
-

data/features/popen_reports_runtime.feature

@@ -1,11 +0,0 @@
-Feature: Run simple subprocesses that report run time
-
-  As a ruby hacker
-  I want to run system subprocesses that report their run time
-  So that I know how long it took to run
-
-  Scenario: run simple subprocess that takes 3 seconds
-    Given I have a new subprocess that takes 3 seconds
-    When I wait on said 3 second process to complete
-    Then the subprocess should report a run time of around 3 seconds
-

data/features/popen_running.feature

@@ -1,11 +0,0 @@
-Feature: Run simple subprocesses that report running
-
-  As a ruby hacker
-  I want to run system subprocesses that report their running status
-  So that I know when said subprocess is finished without waiting
-
-  Scenario: run simple subprocess that finishes fast
-    Given I have a new subprocess that runs fast
-    When I invoke the run method of said fast subprocess
-    Then the subprocess should report running as false without waiting
-

data/features/popen_with_timeout.feature

@@ -1,19 +0,0 @@
-Feature: Run simple subprocesses stopping them at timeout if not complete
-
-  As a ruby hacker
-  I want to run system subprocesses 
-  And I want them to terminate by a set timeout
-  So that I don't end up with a bunch of zombies
-
-  Scenario: run simple subprocess that goes past timeout
-    Given I have a new subprocess that takes more than 5 seconds to run
-    And I set a timeout of 5 seconds
-    When I invoke the run method of said subprocess with timeout
-    Then the subprocess should exit with exitcode 1
-
-  Scenario: run simple subprocess that does not go past timeout
-    Given I have a new subprocess that takes less than 5 seconds to run
-    And I set a timeout of 5 seconds
-    When I invoke the run method of said subprocess with timeout
-    Then the subprocess should complete fine
-

data/features/popen_without_blocking.feature

@@ -1,16 +0,0 @@
-Feature: Run simple subprocesses without blocking in ruby
-
-  As a ruby hacker
-  I want to run system subprocesses that do not block
-  And I want to have them presented as objects
-  So that I can get more data about said subprocesses
-  And so that I can have more fine grained control of said subprocesses
-
-  Scenario: run simple subprocess without blocking
-    Given I have a new subprocess that takes a long time to run
-    When I invoke the run method of said nonblocking subprocess
-    Then the subprocess should not block
-    And the subprocess should report its run status
-    And the subprocess should support being waited on till complete
-    And the subprocess should have status info
-

data/features/step_definitions/common_steps.rb

@@ -1,168 +0,0 @@
-Given /^this project is active project folder/ do
-  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
-end
-
-Given /^env variable \$([\w_]+) set to "(.*)"/ do |env_var, value|
-  ENV[env_var] = value
-end
-
-Given /"(.*)" folder is deleted/ do |folder|
-  in_project_folder { FileUtils.rm_rf folder }
-end
-
-When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
-  @stdout = StringIO.new
-  in_project_folder do
-    if Object.const_defined?("APP_ROOT")
-      APP_ROOT.replace(FileUtils.pwd)
-    else 
-      APP_ROOT = FileUtils.pwd
-    end
-    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
-  end
-  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
-    @stdout.rewind
-    f << @stdout.read
-  end
-end
-
-When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
-  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
-  in_project_folder do
-    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
-  end
-end
-
-When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
-  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
-  in_project_folder do
-    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
-  end
-end
-
-When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
-  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
-  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
-  in_project_folder do
-    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
-  end
-end
-
-When /^I invoke task "rake (.*)"/ do |task|
-  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
-  in_project_folder do
-    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
-  end
-end
-
-Then /^folder "(.*)" (is|is not) created/ do |folder, is|
-  in_project_folder do
-    File.exists?(folder).should(is == 'is' ? be_true : be_false)
-  end
-end
-
-Then /^file "(.*)" (is|is not) created/ do |file, is|
-  in_project_folder do
-    File.exists?(file).should(is == 'is' ? be_true : be_false)
-  end
-end
-
-Then /^file with name matching "(.*)" is created/ do |pattern|
-  in_project_folder do
-    Dir[pattern].should_not be_empty
-  end
-end
-
-Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
-  in_project_folder do
-    actual_output = File.read(file)
-    (does == 'does') ?
-      actual_output.should(match(/#{regex}/)) :
-      actual_output.should_not(match(/#{regex}/))
-  end
-end
-
-Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
-  File.exists?(gem_file).should be_true
-  File.exists?(project_file).should be_true
-  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
-  project_file_contents = File.read(File.join(@active_project_folder, project_file))
-  project_file_contents.should == gem_file_contents
-end
-
-Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
-  actual_output = File.read(@stdout)
-  does_invoke == "does" ?
-    actual_output.should(match(/dependency\s+#{generator}/)) :
-    actual_output.should_not(match(/dependency\s+#{generator}/))
-end
-
-Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
-  actual_output = File.read(@stdout)
-  actual_output.should match(/#{opt1}/)
-  actual_output.should match(/#{opt2}/)
-end
-
-Then /^I should see "([^\"]*)"$/ do |text|
-  actual_output = File.read(@stdout)
-  actual_output.should contain(text)
-end
-
-Then /^I should see$/ do |text|
-  actual_output = File.read(@stdout)
-  actual_output.should contain(text)
-end
-
-Then /^I should not see$/ do |text|
-  actual_output = File.read(@stdout)
-  actual_output.should_not contain(text)
-end
-
-Then /^I should see exactly$/ do |text|
-  actual_output = File.read(@stdout)
-  actual_output.should == text
-end
-
-Then /^I should see all (\d+) tests pass/ do |expected_test_count|
-  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
-  actual_output = File.read(@stdout)
-  actual_output.should match(expected)
-end
-
-Then /^I should see all (\d+) examples pass/ do |expected_test_count|
-  expected = %r{^#{expected_test_count} examples?, 0 failures}
-  actual_output = File.read(@stdout)
-  actual_output.should match(expected)
-end
-
-Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
-  in_project_folder do
-    yaml = eval yaml
-    YAML.load(File.read(file)).should == yaml
-  end
-end
-
-Then /^Rakefile can display tasks successfully/ do
-  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
-  in_project_folder do
-    system "rake -T > #{@stdout} 2> #{@stdout}"
-  end
-  actual_output = File.read(@stdout)
-  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
-end
-
-Then /^task "rake (.*)" is executed successfully/ do |task|
-  @stdout.should_not be_nil
-  actual_output = File.read(@stdout)
-  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
-  actual_output.should_not match(/Error/i)
-end
-
-Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
-  in_project_folder do
-    gem_file = Dir["pkg/*.gem"].first
-    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
-    spec_value = gem_spec.send(key.to_sym)
-    spec_value.to_s.should match(/#{regex}/)
-  end
-end

data/features/step_definitions/multiple_popens_sequence_steps.rb

@@ -1,73 +0,0 @@
-Given /^I have a subprocess sequence with 2 subprocesses to run$/ do
-  @seq = Subprocess::PopenSequence.new
-  @seq.add_popen(Subprocess::Popen.new('echo "popen 1"'))
-  @seq.add_popen(Subprocess::Popen.new('echo "popen 2"'))
-end
-
-When /^I run the subprocesses sequence$/ do
-  @seq.perform
-end
-
-Then /^the subprocess sequence completes with success$/ do
-  @seq.status[:exitstatus].should == 0
-  @seq.completed?.should be_true
-  @seq.complete.length.should == 2
-  @seq.incomplete.length.should == 0
-  @seq.failed.length.should == 0
-end
-
-Then /^the subprocess sequence has stdout for each subprocess$/ do
-  @seq.complete.each do |popen|
-    popen.stdout.should_not == ""
-  end
-end
-
-Then /^the subprocess sequence has stderr for each subprocess$/ do
-  @seq.complete.each do |popen|
-    popen.stderr.should == ""
-  end
-end
-
-Then /^the subprocess sequence has status for each subprocess$/ do
-  @seq.complete.each do |popen|
-    popen.status.should be_kind_of Hash
-  end
-end
-
-Given /^I have a subprocess sequence with 2 subprocesses to run with a bad one first$/ do
-  @seq = Subprocess::PopenSequence.new
-  @seq.add_popen(Subprocess::Popen.new('exit 1'))
-  @seq.add_popen(Subprocess::Popen.new('echo "popen 2"'))
-end
-
-Then /^the subprocess sequence completes with failure$/ do
-  @seq.incomplete.length.should == 1
-  @seq.failed.length.should == 1
-  @seq.complete.length.should == 0
-  @seq.status[:exitstatus].should_not == 0
-end
-
-Given /^I have a subprocess sequence with 2 subprocesses sequences$/ do
-  seq1 = Subprocess::PopenSequence.new
-  seq1 << Subprocess::Popen.new('echo "seq 1 - popen 1"')
-  seq1 << Subprocess::Popen.new('echo "seq 1 - popen 2"')
-  seq2 = Subprocess::PopenSequence.new
-  seq2 << Subprocess::Popen.new('echo "seq 2 - popen 1"')
-  seq2 << Subprocess::Popen.new('echo "seq 2 - popen 2"')
-  @seq = Subprocess::PopenSequence.new
-  @seq << seq1
-  @seq << seq2
-end
-
-When /^I run the sequence$/ do
-  @seq.perform
-end
-
-Then /^the sequences run just like any other subprocess$/ do
-  @seq.status[:exitstatus].should == 0
-  @seq.completed?.should be_true
-  @seq.complete.length.should == 2
-  @seq.incomplete.length.should == 0
-  @seq.failed.length.should == 0
-end
-

data/features/step_definitions/popen_over_ssh_steps.rb

@@ -1,29 +0,0 @@
-
-Given /^I have a new remote Subprocess instance initialized with "([^\"]*)"$/ do |command|
-  @popen_remote = Subprocess::PopenRemote.new(command, 'localhost', 'popen', 10, :password => 'popen')
-end
-
-When /^I invoke the run method of said remote subprocess$/ do
-  @popen_remote.run
-end
-
-When /^I invoke the wait method of said remote subprocess$/ do
-  @popen_remote.wait
-end
-
-Then /^the remote instances exit status is "([^\"]*)"$/ do |exitstatus|
-  @popen_remote.status[:exitstatus].should == exitstatus.to_i
-end
-
-Then /^the remote instances stdout matches "([^\"]*)"$/ do |stdout|
-  @popen_remote.stdout.should match(stdout)
-end
-
-Then /^the remote instances stderr matches "([^\"]*)"$/ do |stderr|
-  @popen_remote.stderr.should match(stderr)
-end
-
-Then /^the remote instance should have a numerical pid$/ do
-  @popen_remote.pid.should be_a_kind_of Fixnum
-end
-

data/features/step_definitions/popen_over_ssh_without_blocking_steps.rb

@@ -1,30 +0,0 @@
-
-Given /^I have a new remote nonblocking subprocess that takes a long time to run$/ do
-  @popen = Subprocess::PopenRemote.new('sleep 3 && exit 1', 'localhost', nil, 10, 'popen', :password => 'popen')
-  @popen.should_not be_nil
-end
-
-When /^I invoke the run method of said nonblocking remote subprocess$/ do
-  start_time = Time.now.to_i
-  @popen.run
-  @total_time = Time.now.to_i - start_time
-end
-
-Then /^the remote nonblocking subprocess should not block$/ do
-  @total_time.should be_close(0, 2) 
-end
-
-Then /^the remote nonblocking subprocess should report its run status$/ do
-  @popen.should respond_to(:running?)
-end
-
-Then /^the remote nonblocking subprocess should support being waited on till complete$/ do
-  @popen.wait
-end
-
-Then /^the remote nonblocking subprocess should have status info$/ do
-  @popen.status[:exitstatus].should be_kind_of Numeric
-  @popen.status.should be_a_kind_of Hash
-end
-
-