spex 0.6.0 → 0.7.0

data/README.md

@@ -1,9 +1,17 @@
 Spex
 ====
 
-A quick and dirty test harness for testing assertions before and after
+A quick and dirty harness for running system state checks before and after
 an executable is run.
 
+It can be used:
+* When developing an executable/configuration, to check real-world
+  results.
+* In production, to ensure the system is in a known state before an
+  executable is run.
+* In production, to provide independent logging/reporting of
+  executable status.
+
 Synopsis
 --------
 
@@ -16,7 +24,7 @@ be used to verify running `touch /tmp/foo` will create a new file:
 
     scenario "Creates a file" do
       executing 'touch /tmp/foo' do
-        assert '/tmp/foo', :created => true
+        check '/tmp/foo', :created => true
       end
     end
 
@@ -25,7 +33,7 @@ If this was in `run_touch.rb`, you could run this with spex:
     $ spex run_touch.rb
 
 You'll notice that this should pass the first time and fail on
-subsequent invocations -- because the assertion added by `:created => true` fails in the
+subsequent invocations -- because the check added by `:created => true` fails in the
 event a file exists *before* the command is run.
 
 If you want to see what command and scenarios are defined in a file,
@@ -45,20 +53,30 @@ Examples
 
 See the `examples/` directory.
 
-Assertions
-----------
+Checks
+------
+
+You can see the checks that are available with the following command:
 
-See the [wiki](http://wiki.github.com/bruce/spex/supported-assertions)
-for the list of supported assertions.
+    $ spex --checks
 
-To add an assertion, create a class that inherits from
-`Spex::Assertion` and implements all the neccessary methods.  See
-`Spex::Assertion` and the currently defined assertions for
+To add an check, create a class that inherits from
+`Spex::Check` and implements all the neccessary methods.  See
+`Spex::Check` and the currently defined checks for
 examples.
 
-Note: If you put your assertions in `~/.spex/assertions/*.rb`,
+Note: If you put your checks in `~/.spex/checks/*.rb`,
 they'll automatically be loaded.  If you create any interesting
-assertions, add them to the [wiki](http://wiki.github.com/bruce/spex/community-assertions)!
+checks, add them to the
+[wiki](http://wiki.github.com/bruce/spex/community-checks)!
+
+Other Resources
+---------------
+
+For more information, see the
+[wiki](http://wiki.github.com/bruce/spex).
+
+You can file bugs and features using the [issue tracker](http://github.com/bruce/spex/issues).
 
 Copyright
 ---------

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/examples/chgrp.rb

@@ -1,5 +1,5 @@
 scenario "Change group" do
   executing "sudo chgrp everyone /tmp/foo" do 
-    assert '/tmp/foo', :changed_group => {:to => 'everyone'}
+    check '/tmp/foo', :changed_group => {:to => 'everyone'}
   end
 end

data/examples/chmod.rb

@@ -1,5 +1,5 @@
 scenario "Change mode" do
   executing "chmod 700 /tmp/foo" do
-    assert '/tmp/foo', :changed_mode => {:to => 0700}
+    check '/tmp/foo', :changed_mode => {:to => 0700}
   end
 end

data/examples/chown.rb

@@ -1,5 +1,5 @@
 scenario "Change owner" do
   executing "sudo chown root /tmp/foo" do
-    assert '/tmp/foo', :changed_owner => {:to => 'root'}
+    check '/tmp/foo', :changed_owner => {:to => 'root'}
   end
 end

data/examples/postfix.rb

@@ -2,15 +2,15 @@
 # we don't confused with spex running this file (postfix.rb)
 scenario "Postfix process management" do
   executing "sudo postfix start" do
-    assert 'postfix/master', :started => true
+    check 'postfix/master', :started => true
   end
   executing "sudo postfix stop" do
-    assert 'postfix/master', :stopped => true
+    check 'postfix/master', :stopped => true
   end
   executing "sudo postfix start" do
-    assert 'postfix/master', :started => true
+    check 'postfix/master', :started => true
   end
   executing "sudo postfix stop && sudo postfix start" do
-    assert 'postfix/master', :restarted => true
+    check 'postfix/master', :restarted => true
   end
 end

data/examples/puppet.rb

@@ -4,6 +4,6 @@ end
 
 scenario "Creates a file" do
   executing "puppet /tmp/spex-manifest.pp" do
-    assert '/tmp/foo', :created => true
+    check '/tmp/foo', :created => true
   end
 end

data/examples/touch.rb

@@ -1,5 +1,5 @@
 scenario "Creates a file" do
   executing "touch /tmp/foo" do
-    assert '/tmp/foo', :created => true
+    check '/tmp/foo', :created => true
   end
 end

data/examples/writing.rb

@@ -1,5 +1,5 @@
 scenario "Modifies a file" do
   executing "echo 'foo' >> /tmp/foo" do
-    assert '/tmp/foo', :modified => true
+    check '/tmp/foo', :modified => true
   end
 end

data/lib/spex.rb

@@ -5,10 +5,10 @@ rescue LoadError
 end
 
 module Spex
-  autoload :Assertion,     'spex/assertion'
+  autoload :Check,         'spex/check'
   autoload :CLI,           'spex/cli'
   autoload :Execution,     'spex/execution'
-  autoload :FileAssertion, 'spex/assertions/file_assertion'
+  autoload :FileCheck,     'spex/checks/file_check'
   autoload :Runner,        'spex/runner'
   autoload :Scenario,      'spex/scenario'
   autoload :Script,        'spex/script'

data/lib/spex/{assertion.rb → check.rb}

@@ -1,7 +1,7 @@
 require 'test/unit/assertions'
 
 module Spex
-  class Assertion
+  class Check
     include Test::Unit::Assertions
     extend Enumerable
 
@@ -22,7 +22,7 @@ module Spex
     def self.as(name, description)
       self.name = name
       self.description = description
-      Assertion.registry[name.to_sym] = self
+      Check.registry[name.to_sym] = self
     end
 
     def self.example(description, text)
@@ -92,10 +92,10 @@ module Spex
   end
 end
 
-Dir.glob(File.join(File.dirname(__FILE__), 'assertions', '**/*.rb')) do |path|
+Dir.glob(File.join(File.dirname(__FILE__), 'checks', '**/*.rb')) do |path|
   require path
 end
 
-Dir.glob(File.join(ENV['HOME'], '.spex', 'assertions', '**/*.rb')) do |path|
+Dir.glob(File.join(ENV['HOME'], '.spex', 'checks', '**/*.rb')) do |path|
   require path
 end

data/lib/spex/{assertions/changed_group_assertion.rb → checks/changed_group_check.rb}

@@ -1,17 +1,17 @@
 require 'etc'
 
 module Spex
-  class ChangedGroupAssertion < FileAssertion
+  class ChangedGroupCheck < FileCheck
     as :changed_group, 'file group change'
     option :to, "To group name or gid"
     option :from, "From group name or gid"
     
-    example "Changed the file group", "assert '/tmp/foo', :changed_group => true"
-    example "Did not change the file group", "assert '/tmp/foo', :changed_group => false"
-    example "Changed the file group from 'wheel' to 'www-users'", "assert '/tmp/foo', :changed_group => {:from => 'wheel', :to => 'www-users'}"
-    example "Changed the file group from gid 210 to gid 288", "assert '/tmp/foo', :changed_group => {:from => 210, :to => 288}"
-    example "Changed the file group to 'users'", "assert '/tmp/foo', :changed_group => {:to => 'users'}"
-    example "Changed the file group to gid 203", "assert '/tmp/foo', :changed_group => {:to => 203}"
+    example "Changed the file group", "check '/tmp/foo', :changed_group => true"
+    example "Did not change the file group", "check '/tmp/foo', :changed_group => false"
+    example "Changed the file group from 'wheel' to 'www-users'", "check '/tmp/foo', :changed_group => {:from => 'wheel', :to => 'www-users'}"
+    example "Changed the file group from gid 210 to gid 288", "check '/tmp/foo', :changed_group => {:from => 210, :to => 288}"
+    example "Changed the file group to 'users'", "check '/tmp/foo', :changed_group => {:to => 'users'}"
+    example "Changed the file group to gid 203", "check '/tmp/foo', :changed_group => {:to => 203}"
     
     def before
       assert File.exist?(target), "File does not exist at #{target}"

data/lib/spex/{assertions/changed_mode_assertion.rb → checks/changed_mode_check.rb}

@@ -1,13 +1,13 @@
 module Spex
-  class ChangedModeAssertion < FileAssertion
+  class ChangedModeCheck < FileCheck
     as :changed_mode, "file mode change"
     option :from, "Mode changed from (octal, eg 0600)"
     option :to, "Mode changed to (octal, eg 0700)"
     
-    example "Changed the file mode", "assert '/tmp/foo', :changed_mode => true"
-    example "Did not change the file mode", "assert '/tmp/foo', :changed_mode => false"
-    example "Changed the file mode from 0666 to 0755", "assert '/tmp/foo', :changed_mode => {:from => 0666, :to => 0755}"
-    example "Changed the file mode to 0750", "assert '/tmp/foo', :changed_mode => {:to => 0750}"
+    example "Changed the file mode", "check '/tmp/foo', :changed_mode => true"
+    example "Did not change the file mode", "check '/tmp/foo', :changed_mode => false"
+    example "Changed the file mode from 0666 to 0755", "check '/tmp/foo', :changed_mode => {:from => 0666, :to => 0755}"
+    example "Changed the file mode to 0750", "check '/tmp/foo', :changed_mode => {:to => 0750}"
 
     def before
       assert File.exist?(target), "File does not exist at #{target}"

data/lib/spex/{assertions/changed_owner_assertion.rb → checks/changed_owner_check.rb}

@@ -1,17 +1,17 @@
 require 'etc'
 
 module Spex
-  class ChangedOwnerAssertion < FileAssertion
+  class ChangedOwnerCheck < FileCheck
     as :changed_owner, 'file owner change'
     option :from, "From username or uid"
     option :to, "To username or uid"
 
-    example "Changed the file owner", "assert '/tmp/foo', :changed_owner => true"
-    example "Did not change the file owner", "assert '/tmp/foo', :changed_owner => false"
-    example "Changed the file owner from 'root' to 'bruce'", "assert '/tmp/foo', :changed_owner => {:from => 'root', :to => 'bruce'}"
-    example "Changed the file owner from uid 501 to uid 503", "assert '/tmp/foo', :changed_owner => {:from => 501, :to => 503}"
-    example "Changed the file owner to 'jim'", "assert '/tmp/foo', :changed_owner => {:to => 'jim'}"
-    example "Changed the file owner to uid 506", "assert '/tmp/foo', :changed_owner => {:to => 506}"
+    example "Changed the file owner", "check '/tmp/foo', :changed_owner => true"
+    example "Did not change the file owner", "check '/tmp/foo', :changed_owner => false"
+    example "Changed the file owner from 'root' to 'bruce'", "check '/tmp/foo', :changed_owner => {:from => 'root', :to => 'bruce'}"
+    example "Changed the file owner from uid 501 to uid 503", "check '/tmp/foo', :changed_owner => {:from => 501, :to => 503}"
+    example "Changed the file owner to 'jim'", "check '/tmp/foo', :changed_owner => {:to => 'jim'}"
+    example "Changed the file owner to uid 506", "check '/tmp/foo', :changed_owner => {:to => 506}"
     
     def before
       assert File.exist?(target), "File does not exist at #{target}"

data/lib/spex/{assertions/created_assertion.rb → checks/created_check.rb}

@@ -1,11 +1,11 @@
 module Spex
-  class CreatedAssertion < FileAssertion
+  class CreatedCheck < FileCheck
     as :created, 'file creation'
     option :type, "Type ('file' or 'directory'), optional"
-    example "File was created", "assert '/tmp/foo', :created => true"
-    example "File was not created", "assert '/tmp/foo', :created => false"
-    example "Regular file was created", "assert '/tmp/foo', :created => {:type => 'file'}"
-    example "Directory was created", "assert '/tmp/foo', :created => {:type => 'directory'}"    
+    example "File was created", "check '/tmp/foo', :created => true"
+    example "File was not created", "check '/tmp/foo', :created => false"
+    example "Regular file was created", "check '/tmp/foo', :created => {:type => 'file'}"
+    example "Directory was created", "check '/tmp/foo', :created => {:type => 'directory'}"    
 
     def before
       assert !File.exist?(target), "File already exists at #{target}"

data/lib/spex/{assertions/file_assertion.rb → checks/file_check.rb}

@@ -1,5 +1,5 @@
 module Spex
-  class FileAssertion < Assertion
+  class FileCheck < Check
 
     def kind
       options[:type] ? options[:type].to_sym : :any

data/lib/spex/{assertions/modified_assertion.rb → checks/modified_check.rb}

@@ -5,16 +5,16 @@ require 'diff/lcs/array'
 module Spex
 
   # With no option, just verifies a change occurs
-  class ModifiedAssertion < FileAssertion
+  class ModifiedCheck < FileCheck
     as :modified, 'file modification'
     option :added, "Added content (string or regexp)"
     option :removed, "Removed content (string or regexp)"
-    example "Modified a file", "assert '/tmp/foo', :modified => true"
-    example "Did not modify a file", "assert '/tmp/foo', :modified => false"
-    example "Added a line with 'a substring' in it", "assert '/tmp/foo', :modified => {:added => 'a substring'}"
-    example "Added a line matching /a substring pattern/", "assert '/tmp/foo', :modified => {:added => /a substring pattern/}"
-    example "Removed a line with 'a substring' in it", "assert '/tmp/foo', :modified => {:removed => 'a substring'}"
-    example "Removed a line matching /a substring pattern/", "assert '/tmp/foo', :modified => {:removed => /a substring pattern/}"
+    example "Modified a file", "check '/tmp/foo', :modified => true"
+    example "Did not modify a file", "check '/tmp/foo', :modified => false"
+    example "Added a line with 'a substring' in it", "check '/tmp/foo', :modified => {:added => 'a substring'}"
+    example "Added a line matching /a substring pattern/", "check '/tmp/foo', :modified => {:added => /a substring pattern/}"
+    example "Removed a line with 'a substring' in it", "check '/tmp/foo', :modified => {:removed => 'a substring'}"
+    example "Removed a line matching /a substring pattern/", "check '/tmp/foo', :modified => {:removed => /a substring pattern/}"
 
     def prepare
       track_checksum!

data/lib/spex/{assertions/process_assertion.rb → checks/process_check.rb}

@@ -1,5 +1,5 @@
 module Spex
-  class ProcessAssertion < Assertion
+  class ProcessCheck < Check
 
     def pattern
       @pattern ||= target.is_a?(Regexp) ? target : Regexp.new(target)

data/lib/spex/{assertions/removed_assertion.rb → checks/removed_check.rb}

@@ -1,11 +1,11 @@
 module Spex
-  class RemovedAssertion < FileAssertion
+  class RemovedCheck < FileCheck
     as :removed, 'file removal'
     option :type, "Type (:file or :directory), optional"
-    example "File was removed", "assert '/tmp/foo', :removed => true"
-    example "File was not removed", "assert '/tmp/foo', :removed => false"
-    example "Regular file was removed", "assert '/tmp/foo', :removed => {:type => 'file'}"
-    example "Directory was removed", "assert '/tmp/foo', :removed => {:type => 'directory'}"    
+    example "File was removed", "check '/tmp/foo', :removed => true"
+    example "File was not removed", "check '/tmp/foo', :removed => false"
+    example "Regular file was removed", "check '/tmp/foo', :removed => {:type => 'file'}"
+    example "Directory was removed", "check '/tmp/foo', :removed => {:type => 'directory'}"    
     
     def before
       assert File.exist?(target), "File does not exist at #{target}"

data/lib/spex/{assertions/restarted_assertion.rb → checks/restarted_check.rb}

@@ -1,8 +1,8 @@
 module Spex
-  class RestartedAssertion < ProcessAssertion
+  class RestartedCheck < ProcessCheck
     as :restarted, 'process restart'
-    example "Process was restarted", "assert 'postfix', :restarted => true"
-    example "Process was not restarted", "assert 'postfix', :restarted => false"
+    example "Process was restarted", "check 'postfix', :restarted => true"
+    example "Process was not restarted", "check 'postfix', :restarted => false"
 
     def before
       @before_pid = current_pid

data/lib/spex/{assertions/started_assertion.rb → checks/started_check.rb}

@@ -1,8 +1,8 @@
 module Spex
-  class StartedAssertion < ProcessAssertion
+  class StartedCheck < ProcessCheck
     as :started, 'process start'
-    example "Process was started", "assert 'postfix', :started => true"
-    example "Process was not started", "assert 'postfix', :started => false"
+    example "Process was started", "check 'postfix', :started => true"
+    example "Process was not started", "check 'postfix', :started => false"
 
     def before
       pid = current_pid

data/lib/spex/{assertions/stopped_assertion.rb → checks/stopped_check.rb}

@@ -1,8 +1,8 @@
 module Spex
-  class StoppedAssertion < ProcessAssertion
+  class StoppedCheck < ProcessCheck
     as :stopped, 'process stop'
-    example "Process was stopped", "assert 'postfix', :stopped => true"
-    example "Process was not stopped", "assert 'postfix', :stopped => false"
+    example "Process was stopped", "check 'postfix', :stopped => true"
+    example "Process was not stopped", "check 'postfix', :stopped => false"
 
     def before
       assert current_pid, "Process '#{target}' is not running (will not be stopped)"

data/lib/spex/cli.rb

@@ -23,8 +23,8 @@ module Spex
         opts.on('--describe', '-d', 'Describe DEFINITION_FILE') do
           options.describe = true
         end
-        opts.on('--assertions', '-a', "List supported assertions") do
-          display_assertions
+        opts.on('--checks', '-c', "List supported checks") do
+          display_checks
           exit
         end
       end
@@ -53,9 +53,9 @@ module Spex
       end
     end
 
-    def display_assertions
-      Assertion.registry.each_value do |klass|
-        line = "Assertion: :#{klass.name} (#{klass.description})"
+    def display_checks
+      Check.registry.each_value do |klass|
+        line = "Check: :#{klass.name} (#{klass.description})"
         puts line
         if klass.options.any? || klass.examples.any?
           puts('=' * line.size)
@@ -82,8 +82,8 @@ module Spex
         puts %(In scenario "#{scenario.name}")
         scenario.executions.each do |execution|
           puts "  When executing `#{execution.command}`"
-          execution.assertions.each do |assertion|
-            puts "    assert #{assertion}"
+          execution.checks.each do |check|
+            puts "    assert #{check}"
           end
         end
       end

data/lib/spex/execution.rb

@@ -9,16 +9,16 @@ module Spex
       Builder.new(self, &block)
     end
 
-    def assertions
-      @assertions ||= []
+    def checks
+      @checks ||= []
     end
 
-    def <<(assertion)
-      assertions << assertion
+    def <<(check)
+      checks << check
     end
 
     def each(&block)
-      assertions.each(&block)
+      checks.each(&block)
     end
 
     class Builder
@@ -27,9 +27,9 @@ module Spex
         instance_eval(&block) if block_given?
       end
 
-      def assert(target, assertion_names = {})
-        assertion_names.each do |name, options|
-          @execution << Assertion[name].new(target, options)
+      def check(target, check_names = {})
+        check_names.each do |name, options|
+          @execution << Check[name].new(target, options)
         end
       end
     end

data/lib/spex/runner.rb

@@ -19,10 +19,10 @@ module Spex
       proceed = true
       scenario.each do |execution|
         puts %(Preparing to execute "#{execution.command}").bold
-        execution.assertions.each do |assertion|
-          print "Pre-assertions for #{assertion}: "
-          assertion.prepare
-          proceed = report { assertion.before }
+        execution.checks.each do |check|
+          print "Pre-checks for #{check}: "
+          check.prepare
+          proceed = report { check.before }
           break unless proceed
         end
         if proceed
@@ -32,13 +32,13 @@ module Spex
           elapsed = Time.now - start
           puts 'DONE (%.2fs)' % elapsed
           passed = true
-          execution.assertions.reverse.each do |assertion|
-            print "Post-assertions for #{assertion}: "
-            passed = report { assertion.after }
+          execution.checks.reverse.each do |check|
+            print "Post-checks for #{check}: "
+            passed = report { check.after }
             break unless passed
           end
           unless passed
-            abort "SCENARIO ASSERTIONS FAILED".red.bold
+            abort "SCENARIO CHECKS FAILED".red.bold
           end
           output_log(execution, log)
         else
@@ -96,13 +96,13 @@ module Spex
           setup do
             @executed ||= self.class.spex_runner.execute(self.class.execution)
           end
-          order = parent.execution.assertions.reverse
+          order = parent.execution.checks.reverse
         when :before
-          order = parent.execution.assertions
+          order = parent.execution.checks
         end
-        order.each do |assertion|
-          should "pass assertion #{assertion.inspect}" do
-            assertion.__send__(event, self)
+        order.each do |check|
+          should "pass check #{check.inspect}" do
+            check.__send__(event, self)
           end
         end
       end

data/test/helper.rb

@@ -17,34 +17,34 @@ class Test::Unit::TestCase
     @script = Spex::Script.evaluate(&block)
   end
 
-  def assertion_passes(&block)
-    @assertion.prepare
-    @assertion.before
+  def check_passes(&block)
+    @check.prepare
+    @check.before
     yield if block_given?
-    @assertion.after
+    @check.after
   end
 
-  def assertion_fails_before
+  def check_fails_before
     assert_raises Test::Unit::AssertionFailedError do
-      @assertion.prepare
-      @assertion.before
+      @check.prepare
+      @check.before
     end
   end
 
-  def assertion_fails(&block)
+  def check_fails(&block)
     assert_raises Test::Unit::AssertionFailedError do
-      assertion_passes(&block)
+      check_passes(&block)
     end
   end
 
   def start_process!(pid = '100')
-    flexmock(@assertion).flexmock_teardown
-    flexmock(@assertion).should_receive(:current_pid).and_return(pid)
+    flexmock(@check).flexmock_teardown
+    flexmock(@check).should_receive(:current_pid).and_return(pid)
   end
 
   def stop_process!
-    flexmock(@assertion).flexmock_teardown
-    flexmock(@assertion).should_receive(:current_pid).and_return(nil)    
+    flexmock(@check).flexmock_teardown
+    flexmock(@check).should_receive(:current_pid).and_return(nil)    
   end
   
 end

data/test/{test_assertion.rb → test_check.rb}

@@ -1,14 +1,14 @@
 require 'helper'
 
-class TestAssertion < Test::Unit::TestCase
-  context "Assertion" do
+class TestCheck < Test::Unit::TestCase
+  context "Check" do
     setup do
-      @klass = Class.new(Spex::Assertion)
+      @klass = Class.new(Spex::Check)
     end
 
     context "instances" do
       should "raise an exception if instantiated with an unknown option" do
-        assert_raises Spex::Assertion::UnknownOptionError do
+        assert_raises Spex::Check::UnknownOptionError do
           @klass.new('/tmp/foo', :unknown => 'option')
         end
       end
@@ -20,8 +20,8 @@ class TestAssertion < Test::Unit::TestCase
           @klass.as :something, "Something being added"
         end
         
-        should "be added to the list of assertions" do
-          assert_equal @klass, Spex::Assertion[:something]
+        should "be added to the list of checks" do
+          assert_equal @klass, Spex::Check[:something]
         end    
       end
       
@@ -41,7 +41,7 @@ class TestAssertion < Test::Unit::TestCase
           end
           
           should "be of the correct class" do
-            assert_kind_of Spex::Assertion::Option, @option
+            assert_kind_of Spex::Check::Option, @option
           end
           
           should "have a name" do

data/test/{test_modified_assertion.rb → test_modified_check.rb}

@@ -1,9 +1,9 @@
 require 'helper'
 
-class TestModifiedAssertion < Test::Unit::TestCase
+class TestModifiedCheck < Test::Unit::TestCase
 
-  def set_assertion(options = {})
-    @assertion = Spex::ModifiedAssertion.new(@filename, options)
+  def set_check(options = {})
+    @check = Spex::ModifiedCheck.new(@filename, options)
   end
 
   def non_blank_file!(text = 'test')
@@ -14,7 +14,7 @@ class TestModifiedAssertion < Test::Unit::TestCase
     File.open(@filename, 'w') { |f| f.puts }
   end
   
-  context "Modified Assertion" do
+  context "Modified Check" do
     setup do
       FakeFS.activate!
       @filename = '/tmp/modified-test'
@@ -27,56 +27,56 @@ class TestModifiedAssertion < Test::Unit::TestCase
     context "instances" do
       context "without options" do
         setup do
-          set_assertion
+          set_check
           blank_file!
         end
         should "pass when modifications happen" do
-          assertion_passes { non_blank_file! }
+          check_passes { non_blank_file! }
         end
         should "when modifications don't happen" do
-          assertion_fails
+          check_fails
         end
       end
       context "with :added" do
         context "as a string" do
           setup do
-            set_assertion(:added => 'test')
+            set_check(:added => 'test')
             blank_file!
           end
           context "when the text is added" do
             should "pass" do
-              assertion_passes { non_blank_file! }
+              check_passes { non_blank_file! }
             end
           end
           context "when different text is added" do
             should "fail" do
-              assertion_fails { non_blank_file!('other') }
+              check_fails { non_blank_file!('other') }
             end
           end
           context "when modifications don't happen" do
             should "fail when modifications don't happen" do
-              assertion_fails
+              check_fails
             end
           end
         end
         context "as a regexp" do
           setup do
-            set_assertion(:added => /t.st/)
+            set_check(:added => /t.st/)
             blank_file!
           end
           context "when the text is added" do
             should "pass" do
-              assertion_passes { non_blank_file! }
+              check_passes { non_blank_file! }
             end
           end
           context "when different text is added" do
             should "fail" do
-              assertion_fails { non_blank_file!('other') }
+              check_fails { non_blank_file!('other') }
             end
           end
           context "when modifications don't happen" do
             should "fail when modifications don't happen" do
-              assertion_fails
+              check_fails
             end
           end
         end
@@ -84,14 +84,14 @@ class TestModifiedAssertion < Test::Unit::TestCase
       context "with :removed" do
         context "as a string" do
           setup do
-            set_assertion(:removed => 'test')
+            set_check(:removed => 'test')
           end
           context "when the text is removed" do
             setup do
               non_blank_file!
             end
             should "pass" do
-              assertion_passes { blank_file! }
+              check_passes { blank_file! }
             end
           end
           context "when different text is removed" do
@@ -99,25 +99,25 @@ class TestModifiedAssertion < Test::Unit::TestCase
               non_blank_file!('other')
             end
             should "fail" do
-              assertion_fails { blank_file! }
+              check_fails { blank_file! }
             end
           end
           context "when modifications don't happen" do
             should "fail when modifications don't happen" do
-              assertion_fails
+              check_fails
             end
           end
         end
         context "as a regexp" do
           setup do
-            set_assertion(:removed => /t.st/)
+            set_check(:removed => /t.st/)
           end
           context "when the text is removed" do
             setup do
               non_blank_file!
             end
             should "pass" do
-              assertion_passes { blank_file! }
+              check_passes { blank_file! }
             end
           end
           context "when different text is removed" do
@@ -125,12 +125,12 @@ class TestModifiedAssertion < Test::Unit::TestCase
               non_blank_file!('other')
             end
             should "fail" do
-              assertion_fails { blank_file! }
+              check_fails { blank_file! }
             end
           end
           context "when modifications don't happen" do
             should "fail when modifications don't happen" do
-              assertion_fails
+              check_fails
             end
           end
         end

data/test/{test_restarted_assertion.rb → test_restarted_check.rb}

@@ -1,16 +1,16 @@
 require 'helper'
 
-class TestRestartedAssertion < Test::Unit::TestCase
+class TestRestartedCheck < Test::Unit::TestCase
 
-  def set_assertion(options = {})
-    @assertion = Spex::RestartedAssertion.new('testproc', options)
+  def set_check(options = {})
+    @check = Spex::RestartedCheck.new('testproc', options)
   end
 
-  context "Restarted Assertion" do
+  context "Restarted Check" do
     context "instances" do
       context "set to true" do
         setup do
-          set_assertion(true)
+          set_check(true)
         end
         context "process running before execution" do
           setup do
@@ -19,30 +19,30 @@ class TestRestartedAssertion < Test::Unit::TestCase
           context "and process running after execution" do
             context "with the same pid" do
               should 'fail' do
-                assertion_fails
+                check_fails
               end
             end
             context "with a different pid" do
               should 'pass' do
-                assertion_passes { start_process!('101') }
+                check_passes { start_process!('101') }
               end
             end
           end
           context "but process not running after execution" do
             should "fail" do
-              assertion_fails
+              check_fails
             end
           end
         end
         context "process not running before execution" do
           should "fail" do
-            assertion_fails_before
+            check_fails_before
           end
         end
       end
       context "set to false" do
         setup do
-          set_assertion(false)
+          set_check(false)
         end
         context "process running before execution" do
           setup do
@@ -51,24 +51,24 @@ class TestRestartedAssertion < Test::Unit::TestCase
           context "and process running after execution" do
             context "with the same pid" do
               should 'pass' do
-                assertion_passes
+                check_passes
               end
             end
             context "with a different pid" do
               should 'fail' do
-                assertion_fails { start_process!('101') }
+                check_fails { start_process!('101') }
               end
             end
           end
           context "but process not running after execution" do
             should "fail" do
-              assertion_fails { stop_process! }
+              check_fails { stop_process! }
             end
           end
         end
         context "process not running before execution" do
           should "fail" do
-            assertion_fails_before
+            check_fails_before
           end
         end
       end

data/test/test_script.rb

@@ -28,25 +28,25 @@ class TestScript < Test::Unit::TestCase
       end
     end
     
-    context "a scenario and execution definition with an assertion" do
+    context "a scenario and execution definition with an check" do
       setup do
         script do
           scenario("name") do
             executing('foo') do
-              assert '/tmp/foo', :created => true
+              check '/tmp/foo', :created => true
             end
           end
         end
       end
       
-      should "create an assertion instance" do
+      should "create an check instance" do
         execution = @script.scenarios.first.executions.first
-        assert_equal 1, execution.assertions.size
-        assertion = execution.assertions.first
-        assert_kind_of Spex::Assertion, assertion
-        assert_equal '/tmp/foo', assertion.target
-        assert assertion.active?
-        assert_equal({}, assertion.options)
+        assert_equal 1, execution.checks.size
+        check = execution.checks.first
+        assert_kind_of Spex::Check, check
+        assert_equal '/tmp/foo', check.target
+        assert check.active?
+        assert_equal({}, check.options)
       end
     end
 

data/test/{test_started_assertion.rb → test_started_check.rb}

@@ -1,59 +1,59 @@
 require 'helper'
 
-class TestStartedAssertion < Test::Unit::TestCase
+class TestStartedCheck < Test::Unit::TestCase
 
-  def set_assertion(options = {})
-    @assertion = Spex::StartedAssertion.new('testproc', options)
+  def set_check(options = {})
+    @check = Spex::StartedCheck.new('testproc', options)
   end
 
-  context "Started Assertion" do
+  context "Started Check" do
     context "instances" do
       context "set to true" do
         setup do
-          set_assertion(true)
+          set_check(true)
         end
         context "process running before execution" do
           setup do
             start_process!
           end
           should "fail" do
-            assertion_fails_before
+            check_fails_before
           end
         end
         context "process not running before execution" do
           context "process running after execution" do
             should "pass" do
-              assertion_passes { start_process! }
+              check_passes { start_process! }
             end
           end
           context "process not running after execution" do
             should 'fail' do
-              assertion_fails
+              check_fails
             end
           end
         end
       end
       context "set to false" do
         setup do
-          set_assertion(false)
+          set_check(false)
         end
         context "process running before execution" do
           setup do
             start_process!
           end
           should "fail" do
-            assertion_fails_before
+            check_fails_before
           end
         end
         context "process not running before execution" do
           context "but process running after execution" do
             should "fail" do
-              assertion_fails { start_process! }
+              check_fails { start_process! }
             end
           end
           context "but process not running after execution" do
             should 'pass' do
-              assertion_passes
+              check_passes
             end
           end
         end

data/test/{test_stopped_assertion.rb → test_stopped_check.rb}

@@ -1,16 +1,16 @@
 require 'helper'
 
-class TestStoppedAssertion < Test::Unit::TestCase
+class TestStoppedCheck < Test::Unit::TestCase
 
-  def set_assertion(options = {})
-    @assertion = Spex::StoppedAssertion.new('testproc', options)
+  def set_check(options = {})
+    @check = Spex::StoppedCheck.new('testproc', options)
   end
 
-  context "Stopped Assertion" do
+  context "Stopped Check" do
     context "instances" do
       context "set to true" do
         setup do
-          set_assertion(true)
+          set_check(true)
         end
         context "process running before execution" do
           setup do
@@ -18,24 +18,24 @@ class TestStoppedAssertion < Test::Unit::TestCase
           end
           context "and process running after execution" do
             should 'fail' do
-              assertion_fails
+              check_fails
             end
           end
           context "but process not running after execution" do
             should "pass" do
-              assertion_passes { stop_process! }
+              check_passes { stop_process! }
             end
           end
         end
         context "process not running before execution" do
           should "fail" do
-            assertion_fails_before
+            check_fails_before
           end
         end
       end
       context "set to false" do
         setup do
-          set_assertion(false)
+          set_check(false)
         end
         context "process running before execution" do
           setup do
@@ -43,18 +43,18 @@ class TestStoppedAssertion < Test::Unit::TestCase
           end
           context "and process running after execution" do
             should 'pass' do
-              assertion_passes
+              check_passes
             end
           end
           context "but process not running after execution" do
             should "fail" do
-              assertion_fails { stop_process! }
+              check_fails { stop_process! }
             end
           end
         end
         context "process not running before execution" do
           should "fail" do
-            assertion_fails_before
+            check_fails_before
           end
         end
       end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 6
+  - 7
   - 0
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Bruce Williams
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-15 00:00:00 -07:00
+date: 2010-04-22 00:00:00 -07:00
 default_executable: spex
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,30 +78,30 @@ files:
 - examples/touch.rb
 - examples/writing.rb
 - lib/spex.rb
-- lib/spex/assertion.rb
-- lib/spex/assertions/changed_group_assertion.rb
-- lib/spex/assertions/changed_mode_assertion.rb
-- lib/spex/assertions/changed_owner_assertion.rb
-- lib/spex/assertions/created_assertion.rb
-- lib/spex/assertions/file_assertion.rb
-- lib/spex/assertions/modified_assertion.rb
-- lib/spex/assertions/process_assertion.rb
-- lib/spex/assertions/removed_assertion.rb
-- lib/spex/assertions/restarted_assertion.rb
-- lib/spex/assertions/started_assertion.rb
-- lib/spex/assertions/stopped_assertion.rb
+- lib/spex/check.rb
+- lib/spex/checks/changed_group_check.rb
+- lib/spex/checks/changed_mode_check.rb
+- lib/spex/checks/changed_owner_check.rb
+- lib/spex/checks/created_check.rb
+- lib/spex/checks/file_check.rb
+- lib/spex/checks/modified_check.rb
+- lib/spex/checks/process_check.rb
+- lib/spex/checks/removed_check.rb
+- lib/spex/checks/restarted_check.rb
+- lib/spex/checks/started_check.rb
+- lib/spex/checks/stopped_check.rb
 - lib/spex/cli.rb
 - lib/spex/execution.rb
 - lib/spex/runner.rb
 - lib/spex/scenario.rb
 - lib/spex/script.rb
 - test/helper.rb
-- test/test_assertion.rb
-- test/test_modified_assertion.rb
-- test/test_restarted_assertion.rb
+- test/test_check.rb
+- test/test_modified_check.rb
+- test/test_restarted_check.rb
 - test/test_script.rb
-- test/test_started_assertion.rb
-- test/test_stopped_assertion.rb
+- test/test_started_check.rb
+- test/test_stopped_check.rb
 has_rdoc: true
 homepage: http://github.com/bruce/spex
 licenses: []
@@ -134,12 +134,12 @@ specification_version: 3
 summary: A test harness for executables
 test_files: 
 - test/helper.rb
-- test/test_assertion.rb
-- test/test_modified_assertion.rb
-- test/test_restarted_assertion.rb
+- test/test_check.rb
+- test/test_modified_check.rb
+- test/test_restarted_check.rb
 - test/test_script.rb
-- test/test_started_assertion.rb
-- test/test_stopped_assertion.rb
+- test/test_started_check.rb
+- test/test_stopped_check.rb
 - examples/chgrp.rb
 - examples/chmod.rb
 - examples/chown.rb