rasta 0.1.8-x86-mswin32-60

data/lib/rasta/fixture/base_fixture.rb

@@ -0,0 +1,138 @@
+
+module Rasta
+  module Fixture
+    module BaseFixture
+      def initialize_run(sheet)
+        @sheet = sheet
+        @metrics = Metrics.new
+      end
+       
+      # Called by fixture.rb on each worksheet
+      def run
+        generate_rspec_tests
+        teardown_tests
+      end
+
+      # Call into rspec to run the current set of tests
+      # and then remove the example from the group which
+      # if we dont will run test 1 then test 1,2 then test 1,2,3
+      # and we'll get duplicate test results accordingly
+      def run_rspec_test
+         Spec::Runner.options.run_examples
+         Spec::Runner.options.remove_example_group(Spec::Runner.options.example_groups[0]) 
+      end
+      
+      # This is called after all testcases are run 
+      # for the worksheet. 
+      def teardown_tests
+        @sheet.select_home_cell
+      end
+      
+      # Allow access to the current failure count from RSpec
+      # which will let us change the tab color based on the test results
+      def current_failure_count
+        Spec::Runner.options.reporter.failure_count
+      end
+      
+      # Iterate over spreadsheet cells, create the
+      # test fixtures and call your test. Generally
+      # you will need to iterate over the spreadsheet
+      # cells and once you have the information you need
+      # to actually run the rspec test you should 
+      # use:
+      #   select_output_cell(cell)
+      #      This tells the reporter which spreadsheet
+      #      cell should get the results
+      #   create_rspec_test(test_fixture, cell)
+      #      This is a method you create which will create
+      #      rspec testcase(s) based on the inputs
+      #   run_rspec_test
+      #      This will run the test set up by create_test
+      def generate_rspec_tests
+      end
+      
+      # This is the guts of the rspec test you want to call
+      # so for example something like 
+      #
+      # describe 'test' do 
+      #   before(:all) do
+      #   end
+      #   it "testcase 1" do
+      #   end
+      #   it "testcase 2" do
+      #   end
+      #   ... etc ...
+      #   after(:all) do
+      #   end
+      # end
+      def create_rspec_test(args)
+      end 
+      
+      # This is how the fixture notifies the rspec reporter 
+      # which spreadsheet cell to dump the results into
+      def select_output_cell(c)
+        Spec::Runner.options.reporter.set_current_spreadsheet_cell = c
+      end
+      
+      # ==================================================
+      # Dont enable these, even in the base fixture or
+      # it could fail if the function is in a superclass of
+      # the test fixture. These are here to show what could
+      # be in the test fixture and if so we'll call them 
+
+      # This is called by the fixture before any test 
+      # is run on the worksheet so you can perform any 
+      # setup needed
+      #def before_all
+      #end
+      
+      # This method is called before each set of tests
+      # typically a row or column of tests or potentially
+      # before each cell, depending on the fixture 
+      #def before_each
+      #end
+      
+      # This method is called after each set of tests
+      # typically a row or column of tests or potentially
+      # after each cell, depending on the fixture 
+      #def after_each
+      #end
+      
+      # This is called by the fixture after all tests
+      # are run on the worksheet so you can perform any 
+      # teardown needed
+      #def after_all
+      #end
+      # ==================================================
+
+
+      # Store metrics as the fixture is running
+      class Metrics
+        attr_accessor :attribute_count, :method_count, :record_count
+        def initialize
+          reset_page_counts
+          reset_record_counts
+        end
+        # Counts tracked on a worksheet scope
+        def reset_page_counts
+          @record_count = 0
+        end
+        # Counts tracked on a record scope
+        def reset_record_counts
+          @attribute_count = 0
+          @method_count = 0
+        end
+        def inc(attribute_name)
+           eval("@#{attribute_name.to_s} += 1")
+        end
+      end
+
+      # Store any extention in the tab name. This can be used to pass
+      # additional information to the fixture
+      def tab_extension=(x)
+        @tab_extension = x
+      end
+      
+    end
+  end  
+end 

data/lib/rasta/fixture/rasta_fixture.rb

@@ -0,0 +1,183 @@
+require 'spec'
+require 'rasta/fixture/base_fixture'
+
+module Rasta
+  module Fixture
+    module RastaFixture 
+      include Rasta::Fixture::BaseFixture
+      attr_accessor :pending, :comment
+      
+      GREEN  = 35
+      RED    = 40 
+      
+      def generate_rspec_tests
+        @metrics.reset_page_counts
+        @test_fixture = self        
+        initial_failure_count = current_failure_count
+        
+        try(:before_all)
+        @sheet.each do |record|
+          @metrics.reset_record_counts
+          @current_record = record
+          @metrics.inc(:record_count)
+          @test_fixture = self.dup #make a copy so attributes don't bleed between rows
+          try(:before_each)
+          record.each do |cell|
+            call_test_fixture(cell)
+          end 
+          try(:after_each)
+          @test_fixture = self
+        end
+        try(:after_all)
+        
+        update_tab_color(current_failure_count > initial_failure_count)
+      end
+      
+      # Check to see if the cell's header is an attribute
+      # or a method and call it or raise an error
+      def call_test_fixture(cell)
+        name = cell.header
+        return if cell.value.nil? || cell.header.nil?
+        if cell.header == 'pending'
+          @test_fixture.pending = cell.value
+        elsif self.methods.include?(name + '=') 
+          call_fixture_attribute(name, cell.value)
+        else
+          # don't specifically check that the method
+          # exists so we can allow for things like
+          # dynamic methods. An exception still gets thrown
+          # so we should be able to handle missing methods
+          call_fixture_method(cell)
+        end
+      end
+      
+      # For cell headers detected as test fixture 
+      # attributes, set the attribute
+      def call_fixture_attribute(name, value)
+        @metrics.inc(:attribute_count)
+        @test_fixture.send("#{name}=", value)
+      end
+      
+      # For cell headers detected as test fixture 
+      # methods, call the method and run the rspec test
+      def call_fixture_method(cell)
+        @metrics.inc(:method_count)
+        create_rspec_test(cell)
+        run_rspec_test
+      end
+      
+      # Given a cell that is a method call
+      # create an rspec test that can check the 
+      # return value and handle any exceptions
+      def create_rspec_test(cell)
+        select_output_cell(cell)
+        test_method_name = "#{cell.header}()"
+        test_fixture = @test_fixture
+        describe "#{cell.sheet.name}[#{cell.name}]" do 
+          include TestCaseHelperMethods
+          
+          before(:all) do
+            @fixture = test_fixture
+            @cell = cell
+            @@actual_value = nil
+            # If the cell's value is an exception, parse it out so we can handle properly
+            @exception_expected = !(@cell.value.to_s =~ /^error\s*((?:(?!:\s).)*):?\s*(.*)/).nil?
+            if @exception_expected
+              @exception = eval($1) if $1 != ''
+              @exception_message = $2 if $2 != ''
+            end
+          end
+          
+          it "#{test_method_name} should handle exceptions" do
+            set_pending_status
+            check_for_errors
+          end
+          it "#{test_method_name} should == #{cell.value.to_s}" do 
+            set_pending_status
+            check_test_result
+          end
+          
+          after(:all) do
+            @fixture = nil
+          end
+        end
+      end
+       
+      def update_tab_color(result)
+        result ? @sheet.ole_object.Tab.ColorIndex = RED : @sheet.ole_object.Tab.ColorIndex = GREEN
+      end 
+      private :update_tab_color
+      
+      module TestCaseHelperMethods
+        @@actual_value = nil
+        def check_for_errors
+          if @exception_expected
+            if @exception
+              lambda{ @fixture.send @cell.header }.should raise_error(@exception, @exception_message)
+            else
+              lambda{ @fixture.send @cell.header }.should raise_error
+            end
+          else
+            lambda{ @@actual_value = @fixture.send @cell.header }.should_not raise_error
+          end
+        end
+        
+        def check_test_result
+          return if @exception_expected
+          # Allow spreadsheet values of nil be captured to 
+          # run methods that do not have a return. This is done 
+          # this way because if we tranlated the cell value to nil then
+          # we couldn't tell the difference between a cell=nil vs an empty cell
+          if @cell.value == 'nil'
+            expected_value = nil
+          else
+            expected_value = @cell.value
+          end
+          case expected_value
+          when /^(<=|>=|>|<)(.+)/  
+            eval("@@actual_value.should #{$1} #{$2}")
+          when Regexp
+            @@actual_value.should =~ expected_value
+          else
+            @@actual_value.should == expected_value
+          end
+        end
+        
+        def set_pending_status
+          if @fixture.methods.include?('pending') and @fixture.pending
+            pending(@fixture.pending)
+          end  
+        end
+        
+      end 
+      
+      # Call a method in the test fixture and if it 
+      # throws an exception, create an rspec test. This
+      # is not for standard tests, but for setup and 
+      # teardown tasks that should happen but are not part
+      # of the actual test cases. 
+      def try(method)
+        return if !method
+        if @test_fixture.methods.include?(method.to_s)
+          begin
+            @test_fixture.send method
+          rescue SystemExit
+            exit
+          rescue Interrupt
+            exits
+          rescue => error_message
+            # If the method gets an error, re-raise the error
+            # in the context of rspec so the results pick it up
+            describe "#{@test_fixture.class}[#{@current_record.to_s}] #{method.to_s}()" do
+              it "should not throw an exception" do
+                lambda{raise error_message}.should_not raise_error
+              end
+            end
+            run_rspec_test
+          end
+        end  
+      end
+    end 
+  end  
+end
+

data/lib/rasta/fixture_runner.rb

@@ -0,0 +1,195 @@
+require 'fileutils'
+ 
+module Rasta
+  
+  module Fixture
+    
+    # Load and run a fixture, indicated by the spreadsheet tab name
+    class FixtureLoader
+      
+      def initialize(sheet, loaded_classes)
+        
+        # We're making an assumption here
+        # that the fixture class matches the 
+        # spreadsheet tab name for the fixture
+        base_sheet_name = sheet.name.dup
+        base_sheet_name.gsub!(/#.*/, '')
+        
+        # If the tab name has a dotted extension, grab it
+        tab_extension = base_sheet_name[/\..*/].sub(/^./,'') if base_sheet_name[/\..*/]
+        
+        # Remove any extension found from the name 
+        base_sheet_name.gsub!(/\..*/, '')
+        
+        # Get a reference to the loaded class
+        classname = find_class_by_name(base_sheet_name, loaded_classes)
+        
+        # Instantiate the test fixture
+        begin
+          fixture = classname.new
+          fixture.initialize_run(sheet)
+          fixture.tab_extension = tab_extension
+        rescue ArgumentError => e
+          raise ArgumentError, "Unable to load class #{@classname}. Make sure the class includes the Rasta fixture: #{e.inspect + e.backtrace.join("\n")}"
+        end
+        
+        # Run the test fixture
+        fixture.run
+        fixture = nil
+      end
+      
+      def find_class_by_name(classname, loaded_classes)
+        config = Configuration.instance
+        ObjectSpace.each_object(Class) do |klass| 
+          # don't try to load a class unless it is 
+          # something we actually loaded ourselves
+          next unless loaded_classes.include?(klass.name)
+          if config.module
+            return klass if klass.name =~ /#{config.module}::#{classname}$/
+          else
+            return klass if klass.name =~ /(^|:)#{classname}$/
+          end
+        end
+        raise ArgumentError, "Class '#{config.module}::#{classname}' not found!"
+      end
+    end
+    
+    # Manage requests to run spreadsheets and send each to the FixtureLoader
+    class FixtureRunner
+      def initialize
+        @workbooks = []
+        prepare_results_directory
+      end
+      
+      def add(spreadsheet)
+        require 'rasta/spreadsheet'
+        raise IOError, "File not found: #{spreadsheet}" if ! File.exists?(File.expand_path(spreadsheet))
+        workingfile = copy(spreadsheet)
+        config = Configuration.instance
+        @excel = Rasta::Spreadsheet::Excel.instance
+        @excel.pagecount = config.pagecount.to_i
+        @excel.recordcount = config.recordcount.to_i
+        @excel.continue = config.continue
+        @excel.visible = config.visible
+        @workbooks << workingfile
+      end
+      
+      ##
+      # Copies the spreadsheet with results in the [results_path] parameter
+      # provided when calling runxls.rb. If no parameter is provided, the results
+      # are saved into the results folder within the working dir. 
+      def copy(spreadsheet)
+        config = Configuration.instance
+        testfilename = generate_testfile(spreadsheet)
+        while File.exists?(File.expand_path(testfilename))
+          testfilename = generate_testfile(spreadsheet)
+        end
+        FileUtils.cp(spreadsheet, testfilename)
+        return testfilename
+      end
+      def generate_testfile(spreadsheet)
+        config = Configuration.instance
+        config.result_index += 1
+        filename = config.results_path + '/' + File.basename(spreadsheet) 
+        filename.sub!(/(\.\w{3})$/, ".#{config.result_index}" + '\1')
+        return filename
+      end
+      def prepare_results_directory
+        config = Configuration.instance
+        if File.expand_path(config.results_path) != config.results_path
+          config.results_path = Dir.getwd + '/' + config.results_path
+        end
+        # Remove the existing results 
+        begin
+          FileUtils.rm(Dir.glob(File.join(config.results_path, "*"))) if File.exists?(config.results_path)
+        rescue Errno::EACCES
+          # The file is probably open so ignore and we'll create a new file
+        end
+        # Create a new results directory
+        begin
+          FileUtils.mkdir_p(config.results_path) if !File.exists?(config.results_path)
+        rescue => e
+          puts "Creating directory #{config.results_path}"
+          raise IOError, e.message
+        end
+      end
+      # Load the files in the fixture path and 
+      # track which classes got loaded so we can hopefully
+      # reduce the chance of namespace issues. There may 
+      # be a better way to handle this
+      def load_test_fixtures
+        before_classes = []
+        after_classes = []
+        ObjectSpace.each_object(Class) { |x| before_classes << x.name } 
+        config = Configuration.instance
+        if config.require.size > 0
+          config.require.each { |file| do_require file }
+        else
+          # Look through all of the .rb files in the fixture path to see if 
+          # we can find the file that has the class specified
+          if File.directory?(config.fixture_path)
+            fixture_files = File.join(config.fixture_path.gsub('\\','/'), "**", "*.rb")
+            Dir.glob(fixture_files).each {|f| do_require f }
+          else
+            do_require config.fixture_path
+          end  
+        end
+        ObjectSpace.each_object(Class) { |x| after_classes << x.name } 
+        return (after_classes - before_classes)
+      end
+
+      def do_require(filename)
+        raise LoadError, "Unable to require file '#{filename}'" unless require filename
+      end
+
+      def execute
+        loaded_classes = load_test_fixtures
+        initialize_rspec
+        begin
+          start_rspec
+          @workbooks.each do |workbook| 
+            begin
+              book = Rasta::Spreadsheet::Book.new(workbook)
+              book.each do |sheet| 
+                FixtureLoader.new(sheet, loaded_classes)
+              end
+            ensure
+              book.save
+            end
+          end
+          # move this in the loop once I work out the 
+          # way to do this in rspec properly
+          stop_rspec
+        ensure
+          @excel.cleanup
+        end
+      end
+      
+      def initialize_rspec
+        require 'rasta/extensions/rspec_extensions'
+        require 'rasta/formatter/spreadsheet_formatter'
+        require 'spec/runner/formatter/progress_bar_formatter'
+        require 'spec/runner/formatter/html_formatter'
+      end
+      private :initialize_rspec
+      
+      def start_rspec
+        config = Configuration.instance
+        Spec::Runner.options.backtrace_tweaker = Spec::Runner::NoisyBacktraceTweaker.new
+        Spec::Runner.options.parse_format("Formatter::ProgressBarFormatter")
+        Spec::Runner.options.parse_format("Formatter::BaseTextFormatter:#{config.results_path}/results.txt")
+        Spec::Runner.options.parse_format("Formatter::HtmlFormatter:#{config.results_path}/results.html")
+        Spec::Runner.options.parse_format("Formatter::SpreadsheetFormatter:#{config.results_path}/spreadsheet.out")
+        Spec::Runner.options.reporter.initialize_spreadsheet
+      end
+      private :start_rspec
+      
+      def stop_rspec
+        Spec::Runner.options.reporter.original_dump if Spec::Runner.options
+        Spec::Runner.options.clear_format_options;
+      end
+      private :stop_rspec
+
+    end
+  end
+end 

data/lib/rasta/formatter/spreadsheet_formatter.rb

@@ -0,0 +1,32 @@
+require 'spec/runner/formatter/base_formatter'
+module Spec
+  module Runner
+    module Formatter
+      class SpreadsheetFormatter <  Spec::Runner::Formatter::BaseFormatter
+        GREEN  = 35
+        RED    = 40
+        YELLOW = 19
+        NONE   = -4142
+        
+        def cell=(c)
+          @cell = c
+        end
+        
+        def example_failed(example, counter, failure)
+          if @cell 
+            failure.exception.backtrace ? @cell.color = YELLOW : @cell.color = RED
+            comment = "method: " + @cell.header + "()\n"
+            comment += failure.exception.message.gsub(/,\s+/,",\n")  
+            comment += "\n" + failure.exception.backtrace.join("\n") if failure.exception.backtrace
+            @cell.comment = comment
+          end
+        end
+        
+        def example_passed(example)
+          @cell.color = GREEN if @cell && @cell.color == NONE 
+        end
+
+      end        
+    end
+  end
+end