spex 0.4.0 → 0.5.0

data/lib/spex/assertions/file_assertion.rb

@@ -1,17 +1,8 @@
 module Spex
   class FileAssertion < Assertion
 
-    def initialize(path, options = {})
-      @path = path
-      @options = options
-    end
-    
     def kind
-      if @options[:directory]
-        :directory
-      elsif @options[:file]
-        :file
-      end
+      options[:type] ? options[:type].to_sym : :any
     end
 
     def kind_name

data/lib/spex/assertions/modified_assertion.rb

@@ -0,0 +1,56 @@
+require 'digest/md5'
+
+module Spex
+
+  # With no option, just verifies a change occurs
+  class ModifiedAssertion < FileAssertion
+    as :modified, 'file modification'
+
+    def prepare
+      track_checksum!
+    end
+
+    def before
+      assert File.exist?(target), "File does not exist at '#{target}'"
+    end
+    
+    def after
+      assert File.exist?(target), "File does not exist at '#{target}'"
+      checksum = current_checksum
+      if active?
+        assert_not_equal @before_checksum, checksum, "Checksum did not change"
+      else
+        assert_equal @before_checksum, checksum, "Checksum changed"
+      end
+    end
+
+    private
+
+    def track_checksum!
+      @before_checksum = current_checksum
+    end
+
+    def current_checksum
+      if File.exist?(target)
+        generate_checksum
+      else
+        nil
+      end
+    end
+
+    def generate_checksum
+      digest = Digest::MD5.new
+      File.open(target) do |file|
+        while content = file.read(4096)
+          digest << content
+        end
+      end
+      digest.hexdigest
+    end
+
+    def same_checksum?
+      @before_checksum == current_checksum
+    end
+    
+  end
+end

data/lib/spex/assertions/removed_assertion.rb

@@ -0,0 +1,27 @@
+module Spex
+  class RemovesFileAssertion < FileAssertion
+    as :removes, 'file removal'
+    option :mode, "Mode, in octal (eg: 0600), optional"
+    option :type, "Type (:file or :directory), optional"
+
+    def before
+      assert File.exist?(target), "File does not exist at #{target}"
+      check_type
+    end
+
+    def after
+      assert !File.exist?(target), "File still exists at #{target}"
+    end
+
+    private
+
+    def check_type
+      case kind
+      when :file
+        assert File.file?(target), "File to remove at #{target} is not a regular file"
+      when :directory
+        assert File.file?(target), "File to remove at #{target} is not a directory"
+      end
+    end
+  end
+end

data/lib/spex/cli.rb

@@ -1,50 +1,79 @@
-begin
-  require 'thor'
-rescue LoadError
-  abort "Requires 'thor'"
-end
+require 'optparse'
+require 'ostruct'
 
 module Spex
-  class CLI < Thor
-
-    desc "info FILE", "Display defined command and scenarios in FILE"
-    def info(path)
-      script = path_to_script(path)
-      puts "FILE\n\n  #{path}\n\n"
-      puts "COMMAND\n\n  #{script.command}\n\n"
-      puts "SCENARIOS\n\n"
-      script.scenarios.sort_by { |k, v| k.to_s }.each do |_, scenario|
-        puts "  #{scenario.name}: #{scenario.description}"
-        [:before, :after].each do |event|
-          puts "    #{event.to_s.upcase}"
-          scenario.assertions.each do |assertion|
-            puts "      should #{assertion.describe_should_at(event)}"
-          end
+  class CLI
+
+    def initialize(args = [])
+      @args = args
+    end
+
+    def options
+      @options ||= OpenStruct.new
+    end
+    
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = 'spex DEFINITION_FILE [OPTIONS]'
+        opts.separator "\nOPTIONS:"
+        opts.on_tail('--help', '-h', 'Show this message') do
+          puts opts
+          exit
+        end
+        opts.on('--describe', '-d', 'Describe DEFINITION_FILE') do
+          options.describe = true
         end
       end
     end
-    
-    method_option :scenario, :aliases => '-s', :description => "Scenario to run", :default => 'default'
-    desc "execute FILE [ARGS_FOR_COMMAND]", "Execute a scenario in FILE"
-    def execute(path, *args)
-      script = path_to_script(path)
-      scenario = script[options[:scenario]]
-      unless scenario
-        abort "Could not find scenario: #{options[:scenario]}"
+
+    def run
+      parser.parse!(@args)
+      filename = @args.shift
+      if !filename
+        refuse "No definition file given"
+      elsif !File.exist?(filename)
+        refuse "Definition file not found: #{filename}"
+      else
+        accept(filename)
+      end
+    end
+
+    private
+
+    def accept(filename)
+      script = evaluate(filename)
+      if options.describe
+        describe(script)
+      else
+        execute(script)
       end
-      Runner.new(script, scenario, *args).run
     end
 
-    no_tasks do
-      def path_to_script(path)
-        unless File.exist?(path)
-          abort "No spex file found at #{path}"
+    def describe(script)
+      script.scenarios.each do |scenario|
+        puts %(In scenario "#{scenario.name}")
+        scenario.executions.each do |execution|
+          puts "  When executing `#{execution.command}`"
+          execution.assertions.each do |assertion|
+            puts "    assert #{assertion}"
+          end
         end
-        script = Script.evaluate_file(path)
-        script.validate!
-        script
       end
     end
+
+    def execute(script)
+      script.each do |scenario|
+        Runner.new(script, scenario).run
+      end
+    end
+    
+    def refuse(error)
+      abort "ERROR: #{error}\n\n#{parser}"
+    end
+
+    def evaluate(filename)
+      Script.evaluate_file(filename)
+    end
     
   end
 end

data/lib/spex/execution.rb

@@ -0,0 +1,37 @@
+module Spex
+  class Execution
+    include Enumerable
+    
+    attr_reader :command
+    
+    def initialize(command, &block)
+      @command = command
+      Builder.new(self, &block)
+    end
+
+    def assertions
+      @assertions ||= []
+    end
+
+    def <<(assertion)
+      assertions << assertion
+    end
+
+    def each(&block)
+      assertions.each(&block)
+    end
+
+    class Builder
+      def initialize(execution, &block)
+        @execution = execution
+        instance_eval(&block) if block_given?
+      end
+
+      def assert(target, assertion_names = {})
+        assertion_names.each do |name, options|
+          @execution << Assertion[name].new(target, options)
+        end
+      end
+    end
+  end
+end

data/lib/spex/runner.rb

@@ -1,89 +1,111 @@
 require 'open3'
-
-begin
-  require 'shoulda'
-rescue LoadError
-  abort "Requires 'shoulda'"
-end
-
 begin
-  require 'test/unit'
+  require 'colored'
 rescue LoadError
-  abort "Requires 'test/unit'.  On Ruby 1.9 you may need to install the 'test-unit' gem."
+  abort "Required the 'colored' library"
 end
 
-require 'test/unit/ui/console/testrunner'
-
 module Spex
   class Runner
     
     attr_reader :script, :scenario
-    def initialize(script, scenario, *args)
+    def initialize(script, scenario)
       @script = script
       @scenario = scenario
-      @args = args
-      @log = ''
     end
     
     def run
-      Test::Unit.run = false
-      suite = Test::Unit::TestSuite.new("#{scenario.description} (`#{command}`)")
-      suite << test(:before).suite
-      suite << test(:after).suite
-      Test::Unit::UI::Console::TestRunner.run(suite)
-      output_log
+      puts %(Running scenario "#{scenario.name}").bold
+      proceed = true
+      scenario.each do |execution|
+        puts "Checking pre-assertions"
+        execution.assertions.each do |assertion|
+          print "Pre-assertions for #{assertion}: "
+          assertion.prepare
+          proceed = report { assertion.before }
+          break unless proceed
+        end
+        if proceed
+          puts %(Executing "#{execution.command}")
+          log = execute(execution)
+          passed = true
+          execution.assertions.reverse.each do |assertion|
+            print "Post-assertions for #{assertion}: "
+            passed = report { assertion.after }
+            break unless passed
+          end
+          if passed
+            puts "SCENARIO PASSED".green.bold
+          else
+            abort "SCENARIO FAILED".red.bold
+          end
+          output_log(execution, log)
+        else
+          abort "SCENARIO FAILED (EXECUTION ABORTED)".red.bold
+        end
+      end
+    end
+
+    def report(&block)
+      yield
+      puts 'PASSED'.green
+      true
+    rescue Test::Unit::AssertionFailedError => e
+      puts 'FAILED'.red
+      puts e.message.yellow
+      puts "At #{find_source(e)}".yellow
+      false
+    end
+
+    def find_source(e)
+      e.backtrace.detect { |line| !line.include?('test/unit') }
     end
 
-    def output_log
-      if @log.empty?
-        puts "NO OUTPUT FROM `#{command}`"
-      else
-        line = "\nOUTPUT FROM `#{command}`"
+    def output_log(execution, log)
+      log.each do |stream, content|
+        next if content.empty?
+        line = "\n#{stream.to_s.upcase} FOR `#{execution.command}`"
         puts line, ('=' * line.size)
-        puts @log
+        puts content
       end
     end
 
-    def run_command
-      Open3.popen3(command) do |stdin, stdout, stderr|
+    def execute(execution)
+      log = {:stdout => '', :stderr => ''}
+      Open3.popen3(execution.command) do |stdin, stdout, stderr|
         stdin.close
-        @log << stdout.read
-        @log << stderr.read
+        log[:stdout] << stdout.read
+        log[:stderr] << stderr.read
       end
-      true
+      log
     end
 
-    def test(event)
+    def test(execution, event)
       klass = Class.new(Test::Unit::TestCase) do
-        class << self; attr_accessor :spex, :name, :event; end
+        class << self; attr_accessor :execution, :spex_runner, :name, :event; end
       end
-      klass.name = "Spex::Test::Order#{event == :after ? 1 : 0}::#{event.to_s.capitalize}Puppet"
-      klass.spex = self
+      klass.name = "Spex::Test::Order#{event == :after ? 1 : 0}::#{event.to_s.capitalize}Execution"
+      klass.spex_runner = self
+      klass.execution = execution
       klass.event = event
-      klass.context "#{event} `#{command}`" do
-        if parent.event == :after
+      klass.context "#{event} executing `#{execution.command}`" do
+        case parent.event
+        when :after
           setup do
-            @ran_puppet ||= self.class.spex.run_command
+            @executed ||= self.class.spex_runner.execute(self.class.execution)
           end
+          order = parent.execution.assertions.reverse
+        when :before
+          order = parent.execution.assertions
         end
-        parent.spex.scenario.assertions.each do |assertion|
-          if assertion.send("#{event}?")
-            should assertion.describe_should_at(event) do
-              assertion.__send__(event, self)
-            end
+        order.each do |assertion|
+          should "pass assertion #{assertion.inspect}" do
+            assertion.__send__(event, self)
           end
         end
       end
       klass
     end
 
-    private
-
-    def command
-      @command ||= @script.command % @args
-    rescue ArgumentError
-      abort "You provided the wrong number of arguments for command: #{@script.command}"
-    end
-
   end
 end

data/lib/spex/scenario.rb

@@ -1,24 +1,34 @@
 module Spex
   class Scenario
+    include Enumerable
 
-    attr_reader :name, :description
-    def initialize(name, description = name.to_s.capitalize, &block)
+    attr_reader :name
+    def initialize(name, &block)
       @name = name
-      @description = description
-      instance_eval(&block)
+      Builder.new(self, &block)
     end
 
-    def assertions
-      @assertions ||= []
+    def executions
+      @executions ||= []
     end
 
-    Assertion.each do |name, klass|
-      class_eval %{
-        def assert_#{name}(*args, &block)
-          assertions << Assertion[:#{name}].new(*args, &block)
-        end
-      }
+    def <<(execution)
+      executions << execution
     end
 
+    def each(&block)
+      executions.each(&block)
+    end
+
+    class Builder
+      def initialize(scenario, &block)
+        @scenario = scenario
+        instance_eval(&block) if block_given?
+      end
+
+      def executing(command, &block)
+        @scenario << Execution.new(command, &block)
+      end
+    end
   end
 end