rcomp 0.1.0

data/features/test.feature

@@ -0,0 +1,169 @@
+Feature: Test
+  Users should have the ability to run tests
+
+  # faulty configuration
+  Scenario: Test without command
+    When I run `rcomp test`
+    Then the output should contain "No command present"
+    And the exit status should be 1
+
+  Scenario: Test without init
+    Given I run `rcomp c ./exec`
+    When I run `rcomp test`
+    Then the output should contain "No RComp directory"
+    And the exit status should be 1
+
+  Scenario: Test with partial init
+    Given I run `rcomp c ./exec`
+    And a directory named "rcomp"
+    And a directory named "rcomp/tests"
+    When I run `rcomp test`
+    Then the output should contain "Missing RComp directories"
+    And the exit status should be 1
+  
+  # no tests
+  @basic-conf
+  Scenario: Test with no tests
+    When I run `rcomp test`
+    Then the output should contain "0 tests ()"
+    And the exit status should be 0
+
+  # stdout single test
+  @basic-conf
+  Scenario: Test with single test passing
+    Given a file named "rcomp/tests/test1.test" with:
+      """
+      ABC
+
+      """
+    And a file named "rcomp/expected/test1.out" with:
+      """
+      ABC
+
+      """
+    When I run `rcomp test`
+    Then the output should contain "1 test (1 passed)"
+    And the exit status should be 0
+
+  @basic-conf
+  Scenario: Test with single test skipped
+    Given a file named "rcomp/tests/test1.test" with:
+      """
+      ABC
+
+      """
+    When I run `rcomp test`
+    Then the output should contain "1 test (1 skipped)"
+    And the exit status should be 0
+
+  @basic-conf
+  Scenario: Test with single test failing
+    Given a file named "rcomp/tests/test1.test" with:
+      """
+      ABC
+
+      """
+    And a file named "rcomp/expected/test1.out" with:
+      """
+      XYZ
+
+      """
+    When I run `rcomp test`
+    Then the output should contain "1 test (1 failed)"
+    And the exit status should be 1
+
+  # stdout multiple tests
+  @basic-conf
+  @load-assorted-tests
+  Scenario: Test multiple
+    When I run `rcomp test`
+    Then the output should contain "3 tests (1 failed, 1 skipped, 1 passed)"
+    And the exit status should be 1
+
+  # stderr single test
+  @err-conf
+  Scenario: Test err with single test passing
+    Given a file named "rcomp/tests/test1.test" with:
+      """
+      ABC
+
+      """
+    And a file named "rcomp/expected/test1.err" with:
+      """
+      ABC
+
+      """
+    When I run `rcomp test`
+    Then the output should contain "1 test (1 passed)"
+    And the exit status should be 0
+
+  @err-conf
+  Scenario: Test err with single test failing
+    Given a file named "rcomp/tests/test1.test" with:
+      """
+      ABC
+
+      """
+    And a file named "rcomp/expected/test1.err" with:
+      """
+      XYZ
+
+      """
+    When I run `rcomp test`
+    Then the output should contain "1 test (1 failed)"
+    And the exit status should be 1
+
+  # stderr multiple tests
+  @err-conf
+  @load-assorted-err-tests
+  Scenario: Test multiple err: passing, skipped and failing
+    When I run `rcomp test`
+    Then the output should contain "3 tests (1 failed, 1 skipped, 1 passed)"
+    And the exit status should be 1
+
+  # alias
+  @basic-conf
+  @load-assorted-tests
+  Scenario: Test alias t
+    When I run `rcomp t`
+    Then the output should contain "3 tests (1 failed, 1 skipped, 1 passed)"
+    And the exit status should be 1
+
+  # filters
+  @basic-conf
+  @load-assorted-tests
+  Scenario: Test with filter: catches all
+    When I run `rcomp test --grep=test`
+    Then the output should contain "3 tests (1 failed, 1 skipped, 1 passed)"
+    And the exit status should be 1
+
+  @basic-conf
+  @load-assorted-tests
+  Scenario: Test with filter: catches some
+    When I run `rcomp t --grep=dir`
+    Then the output should contain "2 tests (1 failed, 1 skipped)"
+    And the exit status should be 1
+
+  @basic-conf
+  @load-assorted-tests
+  Scenario: Test with filter: catches none
+    When I run `rcomp t --grep=xyz`
+    Then the output should contain "0 tests ()"
+    And the exit status should be 0
+
+  # custom tests directory
+  @custom-conf
+  Scenario: Custom conf test
+    Given a file named "test/integration/rcomp/tests/test1.test" with:
+      """
+      ABC
+
+      """
+    And a file named "test/integration/rcomp/expected/test1.out" with:
+      """
+      ABC
+
+      """
+    When I run `rcomp test`
+    Then the output should contain "1 test (1 passed)"
+    And the exit status should be 0

data/features/version.feature

@@ -0,0 +1,6 @@
+Feature: Version
+  A user should be able to find out RComp's version number
+
+  Scenario: run version
+    When I run `rcomp version`
+    Then the output should contain "0.1.0"

data/lib/rcomp/actions.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+module RComp
+  module Actions
+    def rm_rf(directory)
+      if File.exist? directory
+        FileUtils.rm_rf directory
+      end
+    end
+
+    def rm(file)
+      if File.exist? file
+        FileUtils.rm file
+      end
+    end
+
+    def mkdir(path)
+      unless File.exist? path
+        FileUtils.mkdir path
+      end
+    end
+
+    def mkpath_to(path)
+      unless File.exists? path
+        FileUtils.mkpath File.dirname(path)
+      end
+    end
+
+    def touch(path)
+      unless File.exist? path
+        FileUtils.touch path
+      end
+    end
+  end
+end

data/lib/rcomp/cli.rb

@@ -0,0 +1,124 @@
+require 'thor'
+
+module RComp
+  class CLI < Thor
+
+    include RComp::Actions
+    include RComp::Runner
+    include RComp::Suite
+
+    def initialize(args=[], options={}, config={})
+      super
+      # load Conf singleton
+      @conf = Conf.instance
+    end
+
+    ##
+    ## CLI Commands
+    ##
+    
+    # init
+    desc "init", "Setup rcomp test directory"
+    def init
+      if initialized?
+        puts "RComp already initialized"
+        exit 1
+      end
+
+      unless Dir.exists?(File.dirname(@conf.root))
+        puts "No directory #{File.dirname(@conf.root)}"
+        exit 1
+      end
+
+      # Create RComp directories
+      mkdir @conf.root
+      mkdir @conf.test_root
+      mkdir @conf.expected_root
+      mkdir @conf.result_root
+
+      puts "RComp successfully initialized"
+    end
+
+    # version
+    desc "version", "Prints RComp's version information"
+    def version
+      puts "RComp version #{RComp::VERSION}"
+    end
+    map %w(-v --version) => :version
+
+    # set-command
+    desc "set_command COMMAND", "Sets the command RComp will run tests with"
+    def set_command(command)
+      @conf.set_conf_value("command", command)
+    end
+    map "c" => :set_command
+
+    # set-directory
+    desc "set_directory PATH", "Set the directory RComp will store files"
+    def set_directory(path)
+      @conf.set_conf_value("directory", path)
+    end
+    map "d" => :set_directory
+
+    # test
+    desc "test", "Run all tests"
+    method_option :grep,
+      :type => :string,
+      :desc => "Only test files that match pattern"
+    def test
+      @conf.require_basic_conf
+      if @options[:grep]
+        run_suite(load_suite(@options[:grep]), :test)
+      else
+        run_suite(load_suite, :test)
+      end
+    end
+    map "t" => :test
+
+    # generate
+    desc "generate", "Generate expected output for all tests"
+    method_option :grep,
+      :type => :string,
+      :desc => "Only test files that match pattern"
+    method_option :overwrite, 
+      :type => :boolean,
+      :default => false,
+      :aliases => "-O",
+      :desc => "Overwrite expected output file for test if present"
+    def generate
+      @conf.require_basic_conf
+
+      # Display confirmation dialouge when -O is passed without filter
+      if !@options[:grep] && options.overwrite
+        confirm_action "This will overwrite all existing expected results."
+      end
+
+      if @options[:grep]
+        run_suite(load_suite(@options[:grep]), :generate, @options)
+      else
+        run_suite(load_suite, :generate, @options)
+      end
+    end
+    map "g" => :generate
+
+    private
+
+    def confirm_action(warning)
+      puts warning
+      print 'Are you sure? (Y/N) '
+      confirm = STDIN.gets.chomp
+
+      unless confirm.downcase == 'y'
+        say 'Aborting...'
+        exit 1
+      end
+    end
+
+    def initialized?
+      File.exists?(@conf.root) && 
+      File.exists?(@conf.test_root) && 
+      File.exists?(@conf.result_root) && 
+      File.exists?(@conf.expected_root)
+    end
+  end
+end

data/lib/rcomp/conf.rb

@@ -0,0 +1,128 @@
+require 'singleton'
+require 'yaml'
+
+module RComp
+  class Conf
+
+    include Singleton
+    include RComp::Actions
+
+    attr_reader :root, :test_root, :result_root, :expected_root, 
+                :command
+
+    # Initialize a new config object
+    #
+    # Loads options from config file, merges with defaults
+    # and stores everything in memory
+    def initialize
+      # Config file path
+      @path = '.rcomp'
+    
+      # Set valid keys for config file
+      @valid_keys = ['directory',
+                     'command']
+
+      # Set default options and overwrite with config file options
+      @default = { 'directory' => 'rcomp' }
+      @custom = read_conf_file
+      @conf = @default.merge(@custom)
+
+      # Load configuration values into attributes
+      @command = @conf['command']
+      @root = @conf['directory']
+      @test_root = @root + '/tests'
+      @result_root = @root + '/results'
+      @expected_root = @root + '/expected'
+    end
+
+    # Set a configuration value and write it to the config file
+    #
+    # Returns nothing
+    def set_conf_value(key, value)
+      @custom[key] = value
+      puts "#{key} set to #{value}"
+      write_conf_file
+    end
+    
+    # Emit error unless all required conf keys are present in conf file
+    #
+    # Returns nothing
+    def require_basic_conf
+      require_command
+      require_root_exists
+      require_root_subdirs
+    end
+
+
+    private
+
+    # Write the current config options to the config file
+    #
+    # Returns nothing
+    def write_conf_file
+      exit 1 unless @path
+      touch @path unless File.exists?(@path)
+      conf_file = File.open(@path, 'w')
+      conf_file.puts YAML.dump @custom
+    end
+    
+    # Read the config options from RComp's configuration file
+    #
+    # Returns a Hash of config options
+    def read_conf_file
+      conf = {}
+
+      if File.exists?(@path) && File.size?(@path)
+
+        # Store valid conf keys
+        YAML.load_file(@path).each do |key, value|
+
+          if @valid_keys.include? key
+            conf[key] = value
+          else
+            say "Invalid configuration key: #{key}"
+          end
+        end
+      end
+
+      conf
+    end
+
+    # Require the command config option to be set
+    # Print error and exit otherwise
+    #
+    # Returns nothing
+    def require_command
+      unless @command
+        puts "No command present"
+        puts "Run rcomp c COMMAND to add a command to test with"
+        exit 1
+      end
+    end
+
+    # Require the existance of the root directory
+    # Print error and exit otherwise
+    #
+    # Returns nothing
+    def require_root_exists
+      unless File.exists? @root
+        puts "No RComp directory. Run rcomp init to create"
+        exit 1
+      end
+    end
+
+    # Require all sudirectories of the root directory to exist
+    # Print error and exit otherwise
+    #
+    # Returns nothing
+    def require_root_subdirs
+      unless File.exists?(@test_root) && 
+        File.exists?(@result_root) && 
+        File.exists?(@expected_root)
+        puts "Missing RComp directories at #{@root}"
+        puts "Run rcomp init to repair"
+        exit 1
+      end
+    end
+  end
+end

data/lib/rcomp/helper.rb

@@ -0,0 +1,22 @@
+module RComp
+  module Helper
+
+    ##
+    # Pluralizes a number / phrase pair
+    #
+    # ex: 
+    # plural(1, noun) # '1 noun'
+    # plural(3, noun) # '3 nouns'
+    # plural(3, geese, geese) # '3 geese'
+
+    def plural(n, singular, plural=nil)
+      if n == 1
+        "1 #{singular}"
+      elsif plural
+        "#{n} #{plural}"
+      else
+        "#{n} #{singular}s"
+      end
+    end
+  end
+end

data/lib/rcomp/path.rb

@@ -0,0 +1,28 @@
+module RComp
+  module Path
+    def rel_path(test_path)
+      test_path.gsub(Conf.instance.test_root, '')
+    end
+
+    def result_path(test_path, type)
+      cmpnts = []
+      cmpnts << Conf.instance.result_root
+      cmpnts << rel_path(File.dirname(test_path))
+      cmpnts << File.basename(test_path, ".*") + (type == :out ? '.out' : '.err')
+      File.join(cmpnts)
+    end
+
+    def expected_path(test_path, type)
+      puts Conf.instance.expected_root
+      puts rel_path(File.dirname(test_path))
+      puts File.basename(test_path, ".*") + (type == :out ? '.out' : '.err')
+
+      cmpnts = []
+      cmpnts << Conf.instance.expected_root
+      cmpnts << rel_path(File.dirname(test_path))
+      cmpnts << File.basename(test_path, ".*") + (type == :out ? '.out' : '.err')
+      puts File.join(cmpnts)
+      File.join(cmpnts)
+    end
+  end
+end

data/lib/rcomp/reporter.rb

@@ -0,0 +1,81 @@
+module RComp
+  class Reporter
+
+    include RComp::Helper
+
+    # Initialize a new Reporter
+    #
+    # type - The type (Symbol) of the suite
+    #
+    # Initialize counters for all result types
+    def initialize(type)
+      @type = type
+      @success = 0
+      @skipped = 0
+      @failed = 0
+    end
+
+    def report(test)
+      case test.result
+      # success
+      when :success
+        case @type
+        when :test
+          puts "\t passed : #{test.relative_path}"
+        when :generate
+          puts "\tgenerated : #{test.relative_path}"
+        end
+        @success += 1
+
+      # skipped
+      when :skipped
+        case @type
+        when :test
+          puts "\tskipped : #{test.relative_path}"
+        when :generate
+          puts "\t  skipped : #{test.relative_path}"
+        end
+        @skipped += 1
+
+      # failed
+      when :failed
+        case @type
+        when :test
+          puts "\t failed : #{test.relative_path}"
+        end
+        @failed += 1
+      end
+    end
+
+    def summary
+      case @type
+      when :test
+        print_test_summary
+      when :generate
+        print_generate_summary
+      end
+      exit 1 if @failed > 0
+    end
+
+    private
+
+    def print_test_summary
+      desc = []
+      summary = "#{plural((@failed + @skipped + @success), 'test')} ("
+      desc << "#{@failed} failed" unless @failed == 0
+      desc << "#{@skipped} skipped" unless @skipped == 0
+      desc << "#{@success} passed" unless @success == 0
+      summary += desc.join(", ") + ")"
+      puts summary
+    end
+
+    def print_generate_summary
+      desc = []
+      summary = "#{plural((@skipped + @success), 'file')} ("
+      desc << "#{@skipped} skipped" unless @skipped == 0
+      desc << "#{@success} generated" unless @success == 0
+      summary += desc.join(", ") + ")"
+      puts summary
+    end
+  end
+end

data/lib/rcomp/runner.rb

@@ -0,0 +1,104 @@
+require 'fileutils'
+
+module RComp
+  module Runner
+
+    include RComp::Actions
+    
+    # Run a suite of tests
+    #
+    # suite - An Array of Test objects
+    # type - The type (Symbol) of the suite
+    # options - A Hash of runner options
+    #
+    # Returns nothing
+    def run_suite(suite, type, options={})
+      @conf = Conf.instance
+      reporter = Reporter.new(type)
+
+      suite.each do |test|
+        case type
+        when :test
+          if expected_exists?(test)
+            run_test(test)
+          end
+
+        when :generate
+          if expected_exists?(test)
+            run_generate(test) if options[:overwrite]
+          else
+            run_generate(test)
+          end
+        end
+
+        reporter.report(test)
+      end
+
+      reporter.summary
+    end
+
+
+    private
+
+    # Check the existance of expected out/err for a test
+    #
+    # test - A Test object
+    #
+    # Returns a boolean
+    def expected_exists?(test)
+      File.exists?(test.expected_out_path) ||
+        File.exists?(test.expected_err_path)
+    end
+
+    # Run a test storing it's result out and err
+    #
+    # test - A Test object
+    #
+    # Returns nothing
+    def run_test(test)
+      mkpath_to test.result_out_path
+      mkpath_to test.result_err_path
+      system "#{@conf.command} #{test.test_path} > #{test.result_out_path} 2> #{test.result_err_path}"
+      test.result = compare_output(test) 
+    end
+
+    # Generate expected output for a test
+    #
+    # test - A Test object
+    #
+    # Returns nothing
+    def run_generate(test)
+      mkpath_to test.expected_out_path
+      mkpath_to test.expected_err_path
+      system "#{@conf.command} #{test.test_path} > #{test.expected_out_path} 2> #{test.expected_err_path}"
+      test.result = :success
+    end
+
+    # Compare the result and expected output of a test that has been run
+    #
+    # test - A Test object that has been run
+    # precondition: expected_exists?(test) is true
+    #
+    # Returns a Symbol, :success or :failure, conditionally if the test passed
+    def compare_output(test)
+      exp_out_exists = File.exists?(test.expected_out_path)
+      exp_err_exists = File.exists?(test.expected_err_path)
+
+      if exp_out_exists && exp_err_exists # test out and err
+        if FileUtils.identical?(test.expected_out_path, test.result_out_path) &&
+          FileUtils.identical?(test.expected_err_path, test.result_err_path)
+          return :success
+        end
+      elsif exp_out_exists # test only out
+        if FileUtils.identical?(test.expected_out_path, test.result_out_path)
+          return :success
+        end
+      else # test only err
+        if FileUtils.identical?(test.expected_err_path, test.result_err_path)
+          return :success
+        end
+      end
+      return :failed
+    end
+  end
+end