ciat 0.4.8 → 0.4.9

data/lib/ciat/suite_builder.rb

@@ -0,0 +1,54 @@
+require 'ciat/io'
+
+class CIAT::SuiteBuilder
+  include CIAT::IO
+  
+  attr_reader :options
+  
+  def initialize(options)
+    @options = options
+  end
+  
+  def build_processors
+    options[:processors]
+  end
+  
+  def build_output_folder
+    options[:output_folder] || OUTPUT_FOLDER
+  end
+  
+  def build_test_files
+    if options[:files]
+      make_test_files(options[:files])
+    else  
+      folder = options[:folder] || "ciat"
+      pattern = options[:pattern] || "*.ciat"
+      make_test_files(Dir[File.join(folder, "**", pattern)])
+    end
+  end
+  
+  def make_test_files(filenames)
+    if filenames.empty?
+      raise IOError.new("no test files specified")
+    end
+    filenames.map do |filename|
+      CIAT::TestFile.new(filename, build_output_folder)
+    end
+  end
+  
+  def build_feedback
+    CIAT::Feedback::Composite.new(
+        options[:feedback] || default_feedback,
+        CIAT::Feedback::ReturnStatus.new
+      )
+  end
+
+  def default_feedback
+    counter = CIAT::Feedback::FeedbackCounter.new
+    CIAT::Feedback::Composite.new(counter,
+      CIAT::Feedback::StandardOutput.new(counter),
+      CIAT::Feedback::HtmlFeedback.new(counter, options)
+      )
+  end
+
+end

data/lib/ciat/test.rb

@@ -1,36 +1,50 @@
 require 'set'
+require 'ciat/test_result'
+require 'ciat/subresult'
 
 class CIAT::Test
-  attr_reader :filename
   attr_reader :processors
-  attr_reader :elements
 
-  def initialize(filename, elements, options={}) #:nodoc:
-    @filename = filename
-    @elements = elements
-    @processors = options[:processors]
-    @feedback = options[:feedback]
+  def initialize(test_file, processors, feedback) #:nodoc:
+    @test_file = test_file
+    @processors = processors
+    @feedback = feedback
+  end
+  
+  def elements
+    @elements ||= @test_file.process
+  end
+  
+  def filename
+    @test_file.filename(:ciat)
   end
   
   def run
-    run_processors
-    report_lights
-    self
+    CIAT::TestResult.new(self, run_processors)
+  end
+  
+  def grouping
+    @test_file.grouping
   end
   
   def run_processors #:nodoc:
-    processors.each do |processor|
-      processor.process(self)
-      break unless processor.light.green?
+    light = CIAT::TrafficLight::GREEN
+    processors.map do |processor|
+      if light.green?
+        light = processor.process(self)
+        subresult(processor, light)
+      else
+        subresult(processor)
+      end
     end
   end
   
-  def report_lights #:nodoc:
-    processors.each do |processor|
-      @feedback.processor_result(processor)
-    end
+  def subresult(processor, light = CIAT::TrafficLight::UNSET)
+    subresult = CIAT::Subresult.new(self, light, processor)
+    @feedback.report_subresult(subresult)
+    subresult
   end
-
+  
   def element(*names)
     elements[names.compact.join("_").to_sym]
   end

data/lib/ciat/test_element.rb

@@ -1,6 +1,10 @@
 require "yaml"
+require 'ciat/io'
 
 class CIAT::TestElement
+  
+  include CIAT::IO
+  
   attr_reader :name
   attr_reader :filename
   
@@ -26,12 +30,12 @@ class CIAT::TestElement
   end
   
   def content
-    @content ||= CIAT::Cargo.read_file(@filename)
+    @content ||= read_file(@filename)
   end
   
   def as_file
     if @content
-      CIAT::Cargo.write_file(@filename, @content)
+      write_file(@filename, @content)
     end
     @filename
   end
@@ -41,4 +45,5 @@ class CIAT::TestElement
   def metadata
     @@metadata ||= YAML.load_file(File.join(File.dirname(__FILE__), "..", "data", "elements.yml"))
   end
+  
 end

data/lib/ciat/{crate.rb → test_file.rb}

@@ -1,38 +1,38 @@
-class CIAT::Crate #:nodoc:all
-  attr_reader :test_file
-  attr_reader :stub
-  attr_reader :output_folder
+class CIAT::TestFile #:nodoc:all
     
   def initialize(test_file, output_folder)
+    unless File.exists?(test_file)
+      raise IOError.new(test_file + " does not exist")
+    end
     @test_file = test_file
     @output_folder = output_folder
   end
-  
-  def stub
-    test_file.gsub(File.extname(test_file), "")
-  end
 
   def filename(*modifiers)
-    File.join(output_folder, [stub, *modifiers].compact.join("_"))
+    if modifiers == [:ciat]
+      @test_file
+    else
+      File.join(@output_folder, [stub, *modifiers].compact.join("_"))
+    end
   end
   
-  def read_test_file
-    File.readlines(test_file)
-  end  
+  def grouping
+    File.dirname(@test_file)
+  end
   
-  def process_test_file #:nodoc:
+  def process #:nodoc:
     elements = empty_elements_hash
-    split_test_file.each do |name, contents|
+    split.each do |name, contents|
       elements[name] = CIAT::TestElement.new(name, filename(name), contents)
     end
     elements
   end
   
-  def split_test_file #:nodoc:
+  def split #:nodoc:
     tag = :description
     content = ""
     raw_elements = {}
-    read_test_file.each do |line|
+    read.each do |line|
       if line =~ /^==== ((\w|\s)+?)\W*$/
         raw_elements[tag] = content
         tag = $1.gsub(" ", "_").to_sym
@@ -50,9 +50,17 @@ class CIAT::Crate #:nodoc:all
   #
   private
   
+  def read
+    File.readlines(@test_file)
+  end  
+  
   def empty_elements_hash
     Hash.new do |hash, name|
       hash[name] = CIAT::TestElement.new(name, filename(name), nil)
     end
   end
+  
+  def stub
+    @test_file.gsub(File.extname(@test_file), "")
+  end
 end

data/lib/ciat/test_result.rb

@@ -0,0 +1,24 @@
+class CIAT::TestResult
+  attr_reader :subresults
+  
+  def initialize(test, subresults)
+    @test = test
+    @subresults = subresults
+  end
+  
+  def grouping
+    @test.grouping
+  end
+  
+  def processors
+    @test.processors
+  end
+  
+  def filename
+    @test.filename
+  end
+  
+  def element(*args)
+    @test.element(*args)
+  end
+end

data/lib/ciat/traffic_light.rb

@@ -1,10 +1,16 @@
 class CIAT::TrafficLight
+  
   attr_reader :setting
   
   def initialize(setting = :unset) #:nodoc:
     @setting = setting
   end
   
+  GREEN = CIAT::TrafficLight.new(:green)
+  RED = CIAT::TrafficLight.new(:red)
+  YELLOW = CIAT::TrafficLight.new(:yellow)
+  UNSET = CIAT::TrafficLight.new(:unset)
+  
   def unset?
     @setting == :unset
   end

data/lib/templates/detail_row.html.erb

@@ -1,9 +1,10 @@
 <tr class="details" style="display:none">
-  <td colspan="<%= result.processors.size + 1 %>">
+  <td colspan="<%= result.subresults.size + 1 %>">
 	
-	<% result.processors.each do |processor| %>
-	  <h3>Results from <%= processor.describe %></h3>
-		<%= render "detail_row/elements", :elements => processor.relevant_elements(result) %>
+	<% result.subresults.each do |subresult| %>
+	  <h3>Results from <%= subresult.processor.describe %></h3>
+		<%= render "detail_row/elements", 
+			:elements => subresult.relevant_elements %>
 	<% end %>
 
 </tr>

data/lib/templates/group_header.html.erb

@@ -1,7 +1,7 @@
-<% if new_path?(result) %>
+<% if new_grouping?(result) %>
 	<tr>
 		<td colspan="<%= result.processors.size + 1 %>">
-	  		<strong><%= File.dirname(result.filename).gsub("/", " / ") %></strong>
+	  		<strong><%= result.grouping.gsub("/", " / ") %></strong>
 		</td>
 	</tr>
 <% end %>

data/lib/templates/report.html.erb

@@ -27,7 +27,7 @@
   		</tr>
 
   		<% results.each do |result| %>
-			<% if new_path?(result) %>
+			<% if new_grouping?(result) %>
 				<%= render "group_header", :result => result %>
 			<% end %>
 			<%= render "summary_row", :result => result %>

data/lib/templates/summary_row.html.erb

@@ -4,9 +4,9 @@
 	  <%= result.element(:description).content %>
 	  </a>
   </td>
-	<% result.processors.each do |processor| %>
-	  <td class="<%= processor.light.setting %>">
-	    <%= light_to_word(processor.light) %>
-		</td>
+	<% result.subresults.each do |subresult| %>
+	  <td class="<%= subresult.light.setting %>">
+	    <%= light_to_word(subresult.light) %>
+	  </td>
 	<% end %>
 </tr>

data/spec/ciat/erb_helpers_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe CIAT::ERBHelpers do
+  before(:each) do
+    @helper = Object.new
+    @helper.extend(CIAT::ERBHelpers)
+    
+    @unset = CIAT::TrafficLight.new(:unset)
+    @green = CIAT::TrafficLight.new(:green)
+    @yellow = CIAT::TrafficLight.new(:yellow)
+    @red = CIAT::TrafficLight.new(:red)
+  end
+  
+  describe "converting light to word" do
+    it "should handle unset light" do
+      @helper.light_to_word(@unset).should == "n/a"
+    end
+    
+    it "should handle green light" do
+      @helper.light_to_word(@green).should == "passed"
+    end
+
+    it "should handle yellow light" do
+      @helper.light_to_word(@yellow).should == "ERROR"
+    end
+
+    it "should handle red light" do
+      @helper.light_to_word(@red).should == "FAILURE"
+    end
+  end
+
+  describe "converting light to sentence" do
+    it "should handle unset light" do
+      @helper.light_to_sentence("prefix", @unset).should ==
+        "<span class=\"unset\">prefix not run.</span>"
+    end
+    
+    it "should handle green light" do
+      @helper.light_to_sentence("prefix", @green).should ==
+        "<span class=\"green\">prefix passed.</span>"
+    end
+
+    it "should handle yellow light" do
+      @helper.light_to_sentence("prefix", @yellow).should ==
+        "<span class=\"yellow\">prefix errored.</span>"
+    end
+
+    it "should handle red light" do
+      @helper.light_to_sentence("prefix", @red).should ==
+        "<span class=\"red\">prefix failed.</span>"
+    end
+  end
+  
+  it "should render another template" do
+    template = mock("template")
+    locals = mock("locals")
+    binder = mock("binder")
+    bindings = mock("bindings")
+    erb = mock("erb")
+    result = mock("result")
+
+    @helper.should_receive(:read).with("phile.html.erb").and_return(template)
+    ERB.should_receive(:new).with(template).and_return(erb)
+    CIAT::TemplateBinder.should_receive(:new).with(locals).and_return(binder)
+    binder.should_receive(:get_binding).and_return(bindings)
+    erb.should_receive(:filename=).with("phile.html.erb")
+    erb.should_receive(:result).with(bindings).and_return(result)
+    
+    @helper.render("phile.html.erb", locals).should == result
+  end
+end

data/spec/ciat/feedback/composite_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'ciat/feedback/composite'
+
+describe CIAT::Feedback::Composite do
+  before(:each) do
+    @subfeedbacks = [mock("feedback 1"), mock("feedback 2"), mock("feedback 3")]
+    @feedback = CIAT::Feedback::Composite.new(*@subfeedbacks)
+  end
+  
+  it "should report at the end" do
+    suite = mock("suite")
+    
+    @subfeedbacks.each { |feedback| feedback.should_receive(:post_tests).with(suite) }
+    
+    @feedback.post_tests(suite)
+  end
+  
+  it "should report a light" do
+    subresult = mock("subresult")
+    
+    @subfeedbacks.each do |feedback|
+      feedback.should_receive(:report_subresult).with(subresult)
+    end
+
+    @feedback.report_subresult(subresult)
+  end
+end

data/spec/ciat/feedback/feedback_counter_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'ciat/feedback/standard_output'
+
+describe CIAT::Feedback::FeedbackCounter do
+  before(:each) do
+    @feedback = CIAT::Feedback::FeedbackCounter.new
+  end
+  
+  describe "reporting on a processor" do
+    before(:each) do
+      @light = mock("light")
+      @subresult = mock("subresult")
+      @subresult.should_receive(:light).at_least(:once).and_return(@light)
+    end
+    
+    it "should report a green light" do
+      expect_light(:green)
+      
+      @feedback.report_subresult(@subresult)
+    end
+    
+    it "should report a red light" do
+      expect_light(:red)
+      @feedback.should_receive(:increment_failure_count)
+      
+      @feedback.report_subresult(@subresult)
+    end
+    
+    it "should report a yellow light" do      
+      expect_light(:yellow)
+      @feedback.should_receive(:increment_error_count)
+
+      @feedback.report_subresult(@subresult)
+    end
+
+    it "should report an unset light" do      
+      expect_light(:unset)
+      
+      @feedback.report_subresult(@subresult)
+    end
+    
+    def expect_light(setting)
+      @light.should_receive(:setting).at_least(:once).and_return(setting)
+    end
+  end
+  
+  describe "failure count" do
+    it "should be zero initially" do
+      @feedback.failure_count.should == 0
+    end
+    
+    it "should increment" do
+      @feedback.increment_failure_count
+      
+      @feedback.failure_count.should == 1
+    end
+
+    it "should increment lots" do
+      1000.times { @feedback.increment_failure_count }
+      
+      @feedback.failure_count.should == 1000
+    end
+  end
+
+  describe "error count" do
+    it "should be zero initially" do
+      @feedback.error_count.should == 0
+    end
+    
+    it "should increment" do
+      @feedback.increment_error_count
+      
+      @feedback.error_count.should == 1
+    end
+
+    it "should increment lots" do
+      666.times { @feedback.increment_error_count }
+      
+      @feedback.error_count.should == 666
+    end
+    
+    it "should not interfere with failure count" do
+      666.times { @feedback.increment_failure_count }
+      777.times { @feedback.increment_error_count }
+      
+      @feedback.failure_count.should == 666
+      @feedback.error_count.should == 777
+    end
+  end
+end