ciat 0.4.9 → 0.4.10

data/spec/ciat/erb_helpers_spec.rb

@@ -4,49 +4,44 @@ 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"
+      @helper.light_to_word(CIAT::TrafficLight::UNSET).should == "n/a"
     end
     
     it "should handle green light" do
-      @helper.light_to_word(@green).should == "passed"
+      @helper.light_to_word(CIAT::TrafficLight::GREEN).should == "passed"
     end
 
     it "should handle yellow light" do
-      @helper.light_to_word(@yellow).should == "ERROR"
+      @helper.light_to_word(CIAT::TrafficLight::YELLOW).should == "ERROR"
     end
 
     it "should handle red light" do
-      @helper.light_to_word(@red).should == "FAILURE"
+      @helper.light_to_word(CIAT::TrafficLight::RED).should == "FAILURE"
     end
   end
 
   describe "converting light to sentence" do
     it "should handle unset light" do
-      @helper.light_to_sentence("prefix", @unset).should ==
+      @helper.light_to_sentence("prefix", CIAT::TrafficLight::UNSET).should ==
         "<span class=\"unset\">prefix not run.</span>"
     end
     
     it "should handle green light" do
-      @helper.light_to_sentence("prefix", @green).should ==
+      @helper.light_to_sentence("prefix", CIAT::TrafficLight::GREEN).should ==
         "<span class=\"green\">prefix passed.</span>"
     end
 
     it "should handle yellow light" do
-      @helper.light_to_sentence("prefix", @yellow).should ==
+      @helper.light_to_sentence("prefix", CIAT::TrafficLight::YELLOW).should ==
         "<span class=\"yellow\">prefix errored.</span>"
     end
 
     it "should handle red light" do
-      @helper.light_to_sentence("prefix", @red).should ==
+      @helper.light_to_sentence("prefix", CIAT::TrafficLight::RED).should ==
         "<span class=\"red\">prefix failed.</span>"
     end
   end

data/spec/ciat/feedback/feedback_counter_spec.rb

@@ -7,85 +7,65 @@ describe CIAT::Feedback::FeedbackCounter 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)
+  describe "error count" do
+    it "should be zero initially" do
+      @feedback.error_count.should == 0
     end
     
-    it "should report a red light" do
-      expect_light(:red)
-      @feedback.should_receive(:increment_failure_count)
+    it "should increment" do      
+      @feedback.report_subresult(yellow_subresult)
       
-      @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)
+      @feedback.error_count.should == 1
     end
 
-    it "should report an unset light" do      
-      expect_light(:unset)
+    it "should increment lots" do
+      666.times { @feedback.report_subresult(yellow_subresult) }
       
-      @feedback.report_subresult(@subresult)
-    end
-    
-    def expect_light(setting)
-      @light.should_receive(:setting).at_least(:once).and_return(setting)
+      @feedback.error_count.should == 666
     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
+    it "should increment" do      
+      @feedback.report_subresult(red_subresult)
       
       @feedback.failure_count.should == 1
     end
 
     it "should increment lots" do
-      1000.times { @feedback.increment_failure_count }
+      666.times { @feedback.report_subresult(red_subresult) }
       
-      @feedback.failure_count.should == 1000
+      @feedback.failure_count.should == 666
     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 keep distinct counts" do
+    666.times { @feedback.report_subresult(yellow_subresult) }
+    777.times { @feedback.report_subresult(red_subresult) }
+    111.times { @feedback.report_subresult(unset_subresult) }
+    444.times { @feedback.report_subresult(green_subresult) }
     
-    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
+    @feedback.failure_count.should == 777
+    @feedback.error_count.should == 666
+  end
+  
+  def red_subresult
+    mock("red subresult", :light => CIAT::TrafficLight::RED)
+  end
+
+  def yellow_subresult
+    mock("yellow subresult", :light => CIAT::TrafficLight::YELLOW)
+  end
+
+  def green_subresult
+    mock("green subresult", :light => CIAT::TrafficLight::GREEN)
+  end
+
+  def unset_subresult
+    mock("unset subresult", :light => CIAT::TrafficLight::UNSET)
   end
 end

data/spec/ciat/feedback/return_status_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 require 'ciat/feedback/return_status'
 
 describe CIAT::Feedback::ReturnStatus do
-  GREEN = CIAT::TrafficLight.new(:green)
+  GREEN = CIAT::TrafficLight::GREEN
   YELLOW = CIAT::TrafficLight.new(:yellow)
   RED = CIAT::TrafficLight.new(:red)
   
@@ -11,80 +11,86 @@ describe CIAT::Feedback::ReturnStatus do
     @feedback = CIAT::Feedback::ReturnStatus.new
   end
   
-  it "should be okay without any tests" do
-    lambda { @feedback.post_tests(mock("suite")) }.should_not raise_error
-  end
-  
-  it "should ignore a green light" do
-    @feedback.report_subresult(mock("processor", :light => GREEN))
-    
-    lambda { @feedback.post_tests(mock("suite")) }.should_not raise_error
+  describe "notification after tests have been run" do
+    it "should be okay without any tests" do
+      lambda { @feedback.post_tests(mock("suite")) }.should_not raise_error
+    end
   end
 
-  it "should ignore many green lights" do
-    @feedback.report_subresult(mock("processor", :light => GREEN))
-    @feedback.report_subresult(mock("processor", :light => GREEN))
-    @feedback.report_subresult(mock("processor", :light => GREEN))
+  describe "reporting a subresult with a happy path" do
+    it "should ignore a green light" do
+      @feedback.report_subresult(mock("subtest", :light => GREEN))
     
-    lambda { @feedback.post_tests(mock("suite")) }.should_not raise_error
-  end
-  
-  it "should fail after yellow processor" do
-    @feedback.report_subresult(mock("processor", :light => YELLOW))
+      lambda { @feedback.post_tests(mock("suite")) }.should_not raise_error
+    end
 
-    lambda { @feedback.post_tests(mock("suite")) }.
-      should raise_error(RuntimeError)
-  end
+    it "should fail after yellow subtest" do
+      @feedback.report_subresult(mock("subtest", :light => YELLOW))
+
+      lambda { @feedback.post_tests(mock("suite")) }.
+        should raise_error(RuntimeError)
+    end
   
-  it "should fail after many yellow processors" do
-    @feedback.report_subresult(mock("processor", :light => YELLOW))
-    @feedback.report_subresult(mock("processor", :light => YELLOW))
-    @feedback.report_subresult(mock("processor", :light => YELLOW))
+    it "should fail after red subtest" do
+      @feedback.report_subresult(mock("subtest", :light => RED))
 
-    lambda { @feedback.post_tests(mock("suite")) }.
-      should raise_error(RuntimeError)
+      lambda { @feedback.post_tests(mock("suite")) }.
+        should raise_error(RuntimeError)
+    end
   end
 
-  it "should fail after red processor" do
-    @feedback.report_subresult(mock("processor", :light => RED))
-
-    lambda { @feedback.post_tests(mock("suite")) }.
-      should raise_error(RuntimeError)
-  end
+  describe "reporting multiple subresults" do
+    it "should ignore many green lights" do
+      @feedback.report_subresult(mock("subtest", :light => GREEN))
+      @feedback.report_subresult(mock("subtest", :light => GREEN))
+      @feedback.report_subresult(mock("subtest", :light => GREEN))
+    
+      lambda { @feedback.post_tests(mock("suite")) }.should_not raise_error
+    end
   
-  it "should fail after many red processors" do
-    @feedback.report_subresult(mock("processor", :light => RED))
-    @feedback.report_subresult(mock("processor", :light => RED))
-    @feedback.report_subresult(mock("processor", :light => RED))
+    it "should fail after many yellow subtests" do
+      @feedback.report_subresult(mock("subtest", :light => YELLOW))
+      @feedback.report_subresult(mock("subtest", :light => YELLOW))
+      @feedback.report_subresult(mock("subtest", :light => YELLOW))
 
-    lambda { @feedback.post_tests(mock("suite")) }.
-      should raise_error(RuntimeError)
-  end
+      lambda { @feedback.post_tests(mock("suite")) }.
+        should raise_error(RuntimeError)
+    end
 
-  it "should fail after many different processors (red last)" do
-    @feedback.report_subresult(mock("processor", :light => GREEN))
-    @feedback.report_subresult(mock("processor", :light => YELLOW))
-    @feedback.report_subresult(mock("processor", :light => RED))
+    it "should fail after many red subtests" do
+      @feedback.report_subresult(mock("subtest", :light => RED))
+      @feedback.report_subresult(mock("subtest", :light => RED))
+      @feedback.report_subresult(mock("subtest", :light => RED))
 
-    lambda { @feedback.post_tests(mock("suite")) }.
-      should raise_error(RuntimeError)
-  end
+      lambda { @feedback.post_tests(mock("suite")) }.
+        should raise_error(RuntimeError)
+    end
 
-  it "should fail after many different processors (yellow last)" do
-    @feedback.report_subresult(mock("processor", :light => GREEN))
-    @feedback.report_subresult(mock("processor", :light => RED))
-    @feedback.report_subresult(mock("processor", :light => YELLOW))
+    it "should fail after many different subtests (red last)" do
+      @feedback.report_subresult(mock("subtest", :light => GREEN))
+      @feedback.report_subresult(mock("subtest", :light => YELLOW))
+      @feedback.report_subresult(mock("subtest", :light => RED))
 
-    lambda { @feedback.post_tests(mock("suite")) }.
-      should raise_error(RuntimeError)
-  end
+      lambda { @feedback.post_tests(mock("suite")) }.
+        should raise_error(RuntimeError)
+    end
+
+    it "should fail after many different subtests (yellow last)" do
+      @feedback.report_subresult(mock("subtest", :light => GREEN))
+      @feedback.report_subresult(mock("subtest", :light => RED))
+      @feedback.report_subresult(mock("subtest", :light => YELLOW))
+
+      lambda { @feedback.post_tests(mock("suite")) }.
+        should raise_error(RuntimeError)
+    end
 
-  it "should fail after many different processors (green last)" do
-    @feedback.report_subresult(mock("processor", :light => YELLOW))
-    @feedback.report_subresult(mock("processor", :light => RED))
-    @feedback.report_subresult(mock("processor", :light => GREEN))
+    it "should fail after many different subtests (green last)" do
+      @feedback.report_subresult(mock("subtest", :light => YELLOW))
+      @feedback.report_subresult(mock("subtest", :light => RED))
+      @feedback.report_subresult(mock("subtest", :light => GREEN))
 
-    lambda { @feedback.post_tests(mock("suite")) }.
-      should raise_error(RuntimeError)
+      lambda { @feedback.post_tests(mock("suite")) }.
+        should raise_error(RuntimeError)
+    end
   end
-end
+end

data/spec/ciat/feedback/standard_output_spec.rb

@@ -66,43 +66,49 @@ describe CIAT::Feedback::StandardOutput do
     end
   end
   
-  describe "reporting on a processor" do
+  describe "reporting on a subresult" do
     before(:each) do
-      @light = mock("light")
-      @processor = mock("processor")
-      @processor.should_receive(:light).at_least(:once).and_return(@light)
+      @subresult = mock("subresult")
     end
     
     it "should report a green light" do
-      expect_light(:green)
+      @subresult.should_receive(:light).at_least(:once).
+        and_return(CIAT::TrafficLight::GREEN)
       @feedback.should_receive(:putc).with(".")
       
-      @feedback.report_subresult(@processor)
+      @feedback.report_subresult(@subresult)
     end
     
     it "should report a red light" do
-      expect_light(:red)
+      @subresult.should_receive(:light).at_least(:once).
+        and_return(CIAT::TrafficLight::RED)
       @feedback.should_receive(:putc).with("F")
       
-      @feedback.report_subresult(@processor)
+      @feedback.report_subresult(@subresult)
     end
     
     it "should report a yellow light" do      
-      expect_light(:yellow)
+      @subresult.should_receive(:light).at_least(:once).
+        and_return(CIAT::TrafficLight::YELLOW)
       @feedback.should_receive(:putc).with("E")
 
-      @feedback.report_subresult(@processor)
+      @feedback.report_subresult(@subresult)
     end
 
     it "should report an unset light" do      
-      expect_light(:unset)
+      @subresult.should_receive(:light).at_least(:once).
+        and_return(CIAT::TrafficLight::UNSET)
       @feedback.should_receive(:putc).with("-")
       
-      @feedback.report_subresult(@processor)
+      @feedback.report_subresult(@subresult)
     end
-    
-    def expect_light(setting)
-      @light.should_receive(:setting).at_least(:once).and_return(setting)
+
+    it "should report an unneeded light" do      
+      @subresult.should_receive(:light).at_least(:once).
+        and_return(CIAT::TrafficLight::UNNEEDED)
+      @feedback.should_receive(:putc).with(".")
+      
+      @feedback.report_subresult(@subresult)
     end
   end
   

data/spec/ciat/processors/compilation_interpreter_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + "/shared_examples_for_element_names"
+
+require 'ciat/processors/compilation_interpreter'
+
+describe CIAT::Processors::CompilationInterpreter do
+  it_should_behave_like "Any element namer"
+  
+  before(:each) do
+    @namer = CIAT::Processors::CompilationInterpreter.new
+  end
+end

data/spec/ciat/processors/compiler_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + "/shared_examples_for_element_names"
+
+require 'ciat/processors/compiler'
+
+describe CIAT::Processors::Compiler do
+  it_should_behave_like "Any element namer"
+  
+  before(:each) do
+    @namer = CIAT::Processors::Compiler.new
+  end
+end

data/spec/ciat/processors/interpreter_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + "/shared_examples_for_element_names"
+
+require 'ciat/processors/interpreter'
+
+describe CIAT::Processors::Interpreter do
+  it_should_behave_like "Any element namer"
+  
+  before(:each) do
+    @namer = CIAT::Processors::Interpreter.new
+  end
+end

data/spec/ciat/processors/java_spec.rb

@@ -3,16 +3,6 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 require 'ciat/processors/java'
 
 describe CIAT::Processors::Java do
-  describe "mixins" do
-    it "should use basic processing module" do
-      CIAT::Processors::Java.should include(CIAT::Processors::BasicProcessing)
-    end
-
-    it "should use HTML differ" do
-      CIAT::Processors::Java.should include(CIAT::Differs::HtmlDiffer)
-    end
-  end
-
   it "should have settable options" do
     CIAT::Processors::Java.new(mock("classpath"), mock("interpreter class")) do |executor|
       executor.kind = mock("processor kind")