subprocess 0.1.6

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2010-03-13
+
+* 1 major enhancement:
+  * Initial release of Subprocess!

data/Manifest.txt

@@ -0,0 +1,46 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+TODO.rdoc
+examples/simple.irb
+examples/simple_timeout.irb
+features/multiple_popens_sequence.feature
+features/popen.feature
+features/popen_over_ssh.feature
+features/popen_over_ssh_without_blocking.feature
+features/popen_remote_fails_with_invalid_auth_data.feature
+features/popen_reports_runtime.feature
+features/popen_running.feature
+features/popen_with_timeout.feature
+features/popen_without_blocking.feature
+features/step_definitions/common_steps.rb
+features/step_definitions/multiple_popens_sequence_steps.rb
+features/step_definitions/popen_over_ssh_steps.rb
+features/step_definitions/popen_over_ssh_without_blocking_steps.rb
+features/step_definitions/popen_remote_fails_with_invalid_auth_dat_steps.rb
+features/step_definitions/popen_reports_runtime_steps.rb
+features/step_definitions/popen_running_steps.rb
+features/step_definitions/popen_steps.rb
+features/step_definitions/popen_with_timeout_steps.rb
+features/step_definitions/popen_without_blocking_steps.rb
+features/support/common.rb
+features/support/env.rb
+features/support/matchers.rb
+lib/core_ext/hash.rb
+lib/core_ext/process_status.rb
+lib/subprocess.rb
+lib/subprocess/popen.rb
+lib/subprocess/popen_factory.rb
+lib/subprocess/popen_remote.rb
+lib/subprocess/popen_sequence.rb
+script/console
+script/destroy
+script/generate
+spec/spec.opts
+spec/spec_helper.rb
+spec/subprocess/popen_spec.rb
+spec/subprocess_spec.rb
+subprocess.gemspec
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on subprocess, see http://subprocess.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,77 @@
+= subprocess
+
+* http://github.com/bramswenson/subprocess
+
+== DESCRIPTION:
+
+* Subprocess provides a clean wrapper class around the Kernel.exec method.
+
+== FEATURES/PROBLEMS:
+
+* Provides working Subprocess::Popen class used to call system commands in and object oriented manner.
+
+== SYNOPSIS:
+
+=== Simple Popen
+
+  >> require 'subprocess'
+  => true
+  >> 
+  ?> # a process to get the current version of ruby from ruby command
+  ?> ruby_version = Subprocess::Popen.new('ruby -v')
+  => #<Subprocess::Popen:0x7f9220bda3a8 @running=false, @command="ruby -v", @timeout=30, @ipc_parsed=false>
+  >> 
+  ?> # run the process
+  ?> ruby_version.run
+  => true
+  >> 
+  ?> # wait on process to complete (blocking method)
+  ?> ruby_version.wait
+  => true
+  >> 
+  ?> # the process will have stdout
+  ?> ruby_version.stdout
+  => "ruby 1.8.7 (2009-06-12 patchlevel 174) [x86_64-linux]"
+  >> 
+  ?> # and in this case no stderr
+  ?> ruby_version.stderr
+  => ""
+  >> 
+  ?> # the complete process info is in status
+  ?> ruby_version.status
+  => {:run_time=>0.0611081123352051, :stopsig=>nil, :exited?=>true, :pid=>16744, :termsig=>nil, :timed_out?=>false, :stopped?=>false, :success?=>true, :exitstatus=>0}
+
+
+
+== REQUIREMENTS:
+
+tested on ruby 1.8.7
+
+== INSTALL:
+
+[sudo] gem install subprocess
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Bram Swenson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+#gem 'rspec', '<= 1.3.0'
+require 'hoe'
+require 'fileutils'
+require './lib/subprocess'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+Hoe.plugin :cucumberfeatures
+
+$hoe = Hoe.spec 'subprocess' do
+  self.developer 'Bram Swenson', 'bram@craniumisajar.com'
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+remove_task :default
+task :default => [:spec, :features]

data/TODO.rdoc

@@ -0,0 +1 @@
+* make sure rails config.gem 'subprocess' works

data/examples/simple.irb

@@ -0,0 +1,22 @@
+#!/usr/bin/env irb
+
+begin
+  require 'subprocess'
+rescue LoadError
+  require 'rubygems'
+  require 'subprocess'
+end
+
+# a process to get the current version of ruby from ruby command
+ruby_version = Subprocess::Popen.new('ruby -v')
+# run the process
+ruby_version.run
+# wait on process to complete (blocking method)
+ruby_version.wait
+# the process will have stdout
+ruby_version.stdout
+# and in this case no stderr
+ruby_version.stderr
+# the complete process info is in status
+ruby_version.status
+

data/examples/simple_timeout.irb

@@ -0,0 +1,22 @@
+#!/usr/bin/env irb
+
+begin
+  require 'subprocess'
+rescue LoadError
+  require 'rubygems'
+  require 'subprocess'
+end
+
+# a process to get the current version of ruby from ruby command
+ruby_version = Subprocess::Popen.new('ruby -v')
+# run the process
+ruby_version.run
+# wait on process to complete (blocking method)
+ruby_version.wait
+# the process will have stdout
+ruby_version.stdout
+# and in this case no stderr
+ruby_version.stderr
+# the complete process info is in status
+ruby_version.status
+

data/features/multiple_popens_sequence.feature

@@ -0,0 +1,23 @@
+Feature: Run a sequence of simple subprocesses in order
+
+  As a ruby hacker
+  I want to run a sequence of system subprocesses in a sequential order
+  So I can run complex sequences of commands in a simple way
+
+  Scenario: run a sequence of 2 sequential subprocess successfully
+    Given I have a subprocess sequence with 2 subprocesses to run
+    When I run the subprocesses sequence
+    Then the subprocess sequence completes with success
+    And the subprocess sequence has stdout for each subprocess
+    And the subprocess sequence has stderr for each subprocess
+    And the subprocess sequence has status for each subprocess
+
+  Scenario: run a sequence of 2 sequential subprocess where the first fails
+    Given I have a subprocess sequence with 2 subprocesses to run with a bad one first
+    When I run the subprocesses sequence
+    Then the subprocess sequence completes with failure
+
+  Scenario: run a sequence of sequences
+    Given I have a subprocess sequence with 2 subprocesses sequences
+    When I run the sequence
+    Then the sequences run just like any other subprocess

data/features/popen.feature

@@ -0,0 +1,45 @@
+Feature: Run simple subprocesses in ruby
+
+  As a ruby hacker
+  I want to run system subprocesses 
+  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 subprocesses
+    Given I have a new Subprocess instance initialized with "<command>"
+    When I invoke the run method of said subprocess
+    And I invoke the wait method of said subprocess
+    Then the instance should have a status attribute
+    And the instances exit status is "<exitstatus>"
+    And the instances stdout matches "<stdout>"
+    And the instances stderr matches "<stderr>"
+    And the instance should have a numerical pid
+
+    Scenarios: zero exit code subprocesses with stdout
+      | command | exitstatus | stdout | stderr |
+      | echo 1 | 0 | 1 |  |
+
+    Scenarios: zero exit code subprocesses with stderr
+      | command | exitstatus | stdout | stderr |
+      | echo 1 1>&2 | 0 |  | 1 |
+
+    Scenarios: zero exit code subprocesses with stdout and stderr
+      | command | exitstatus | stdout | stderr |
+      | echo 1 && echo 1 1>&2 | 0 | 1 | 1 |
+
+    Scenarios: nonzero exit code 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 subprocesses with stderr
+      | command | exitstatus | stdout | stderr |
+      | echo 1 1>&2 && exit 1 | 1 |  | 1 |
+
+    Scenarios: nonzero exit code 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.feature

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

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

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

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

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

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

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

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

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