ciat 0.4.9 → 0.4.10

data/spec/ciat/test_result_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe CIAT::TestResult do
+  before(:each) do
+    @test = mock("test")
+    @subresults = array_of_mocks(3, "subresult")
+    @test_result = CIAT::TestResult.new(@test, @subresults)
+  end
+  
+  it "should defer grouping to the test" do
+    grouping = mock("grouping")
+    @test.should_receive(:grouping).and_return(grouping)
+    @test_result.grouping.should == grouping
+  end
+  
+  it "should defer filename" do
+    filename = mock("filename")
+    @test.should_receive(:filename).with(:ciat).and_return(filename)
+    @test_result.filename.should == filename
+  end
+  
+  it "should defer element accessor" do
+    element = mock("element")
+    @test.should_receive(:element).
+      with(:one, :two, :three).and_return(element)
+    @test_result.element(:one, :two, :three).should == element
+  end
+  
+  it "should get processors from subresults" do
+    processors = array_of_mocks(3, "processor")
+    @subresults[0].should_receive(:processor).and_return(processors[0])
+    @subresults[1].should_receive(:processor).and_return(processors[1])
+    @subresults[2].should_receive(:processor).and_return(processors[2])
+    @test_result.processors.should == processors
+  end
+end

data/spec/ciat/test_spec.rb

@@ -1,13 +1,15 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
 describe CIAT::Test do
+  include MockHelpers
+  
   before(:each) do
     @filename = mock("filename")
-    @test_file = mock("test file")
+    @ciat_file = mock("ciat file")
     @processors = [mock("p 0"), mock("p 1"), mock("p 2")]
     @differ = mock("differ")
     @feedback = mock("feedback")
-    @test = CIAT::Test.new(@test_file, @processors, @feedback)
+    @test = CIAT::Test.new(@ciat_file, @processors, @feedback)
   end
 
   describe "running a test" do
@@ -15,113 +17,101 @@ describe CIAT::Test do
       subresults = mock("subresults")
       result = mock("result")
       
-      @test.should_receive(:run_processors).and_return(subresults)
-      CIAT::TestResult.should_receive(:new).with(@test, subresults).
+      @test.should_receive(:run_subtests).and_return(subresults)
+      CIAT::TestResult.should_receive(:new).with(@ciat_file, subresults).
         and_return(result)
       
       @test.run.should == result
     end
   end
-
+  
   describe "running processors" do
     before(:each) do
-      @subresults = [mock("subresult 0"), 
-        mock("subresult 1"), mock("subresult 2")]
+      @subtests = array_of_mocks(3, "subtest")
+      @test.should_receive(:make_subtests).and_return(@subtests)
+      @subresults = array_of_mocks(3, "subresult")
     end
     
-    it "should run just the first processor" do
-      light = mock("light", :green? => false)
+    it "should run just the first processor because of a non-green subtest" do
+      expect_not_green(@subtests[0], @subresults[0])
+      expect_unset(@subtests[1], @subresults[1])
+      expect_unset(@subtests[2], @subresults[2])
       
-      @processors[0].should_receive(:process).with(@test).
-        and_return(light)
-      @test.should_receive(:subresult).with(@processors[0], light).
-        and_return(@subresults[0])
-      @test.should_receive(:subresult).with(@processors[1]).
-        and_return(@subresults[1])
-      @test.should_receive(:subresult).with(@processors[2]).
-        and_return(@subresults[2])
+      @test.run_subtests.should == @subresults
+    end
+    
+    it "should run just the first processor because of a sad subtest" do
+      expect_green(@subtests[0], @subresults[0])
+      expect_sad(@subtests[1], @subresults[1])
+      expect_unneeded(@subtests[2], @subresults[2])
       
-      @test.run_processors.should == @subresults
+      @test.run_subtests.should == @subresults
     end
-
+    
     it "should run just the first two processors" do
-      lights = [mock("light 0", :green? => true), 
-                mock("light 1", :green? => false)]
+      expect_green(@subtests[0], @subresults[0])
+      expect_not_green(@subtests[1], @subresults[1])
+      expect_unset(@subtests[2], @subresults[2])
       
-      @processors[0].should_receive(:process).with(@test).
-        and_return(lights[0])
-      @test.should_receive(:subresult).with(@processors[0], lights[0]).
-        and_return(@subresults[0])
-      @processors[1].should_receive(:process).with(@test).
-        and_return(lights[1])
-      @test.should_receive(:subresult).with(@processors[1], lights[1]).
-        and_return(@subresults[1])
-      @test.should_receive(:subresult).with(@processors[2]).
-        and_return(@subresults[2])
-      
-      @test.run_processors.should == @subresults
+      @test.run_subtests.should == @subresults
     end
 
-    it "should run just all processors" do
-      lights = [mock("light 0", :green? => true),
-                mock("light 1", :green? => true), mock("light 2")]
-
-      @processors[0].should_receive(:process).with(@test).
-        and_return(lights[0])
-      @test.should_receive(:subresult).with(@processors[0], lights[0]).
-        and_return(@subresults[0])
-      @processors[1].should_receive(:process).with(@test).
-        and_return(lights[1])
-      @test.should_receive(:subresult).with(@processors[1], lights[1]).
-        and_return(@subresults[1])
-      @processors[2].should_receive(:process).with(@test).
-        and_return(lights[2])
-      @test.should_receive(:subresult).with(@processors[2], lights[2]).
-        and_return(@subresults[2])
-      
-      @test.run_processors.should == @subresults
+    it "should run all processors" do
+      expect_green(@subtests[0], @subresults[0])
+      expect_green(@subtests[1], @subresults[1])
+      expect_green(@subtests[2], @subresults[2])
+            
+      @test.run_subtests.should == @subresults
     end
-  end
-  
-  it "should processor subresult" do
-    light, processor = mock("light"), mock("processor")
-    subresult = mock("subresult")
-    
-    CIAT::Subresult.should_receive(:new).with(@test, light, processor).
-      and_return(subresult)
-    @feedback.should_receive(:report_subresult).with(subresult)
 
-    @test.subresult(processor, light).should == subresult
-  end
-  
-  describe "processing elements" do
-    before(:each) do
-      @elements = mock("elements")
-      @test.should_receive(:elements).and_return(@elements)
+    def expect_green(subtest, subresult)
+      subtest.stub!(:sad_path?).and_return(false)
+      light = mock("light", :green? => true)
+      subtest.should_receive(:process).with().and_return(light)
+      @test.should_receive(:subresult).with(subtest, light).
+        and_return(subresult)
+      subresult.should_receive(:light).and_return(light)
     end
     
-    it "should return specified element" do
-      element = mock("element")
-    
-      @elements.should_receive(:[]).with(:foo).and_return(element)
+    def expect_sad(subtest, subresult)
+      light = mock("light")
+      subtest.should_receive(:process).with().and_return(light)
+      @test.should_receive(:subresult).with(subtest, light).
+        and_return(subresult)
+      subresult.stub!(:light).and_return(light)
+      subtest.should_receive(:sad_path?).and_return(true)
+    end
     
-      @test.element(:foo).should == element
+    def expect_not_green(subtest, subresult)
+      subtest.stub!(:sad_path?).and_return(false)
+      light = mock("light", :green? => false)
+      subtest.should_receive(:process).with().and_return(light)
+      @test.should_receive(:subresult).with(subtest, light).
+        and_return(subresult)
+      subresult.should_receive(:light).and_return(light)
     end
-
-    it "should return specified element with multi-word name" do
-      element = mock("element")
     
-      @elements.should_receive(:[]).with(:foo_bar_joe).and_return(element)
+    def expect_unset(subtest, subresult)
+      @test.should_receive(:subresult).
+        with(subtest, CIAT::TrafficLight::UNSET).and_return(subresult)
+    end
     
-      @test.element(:foo, :bar, :joe).should == element
+    def expect_unneeded(subtest, subresult)
+      @test.should_receive(:subresult).
+        with(subtest, CIAT::TrafficLight::UNNEEDED).and_return(subresult)
     end
+  end
   
-    it "should check to see if element exists" do
-      exists = mock("a boolean")
-    
-      @elements.should_receive(:has_key?).with(:foo_bar_joe).and_return(exists)
+  it "should build and report subresult" do
+    path_kind, light, subtest = 
+      mock("path kind"), mock("light"), mock("subtest")
+    subresult = mock("subresult")
     
-      @test.element?(:foo, :bar, :joe).should == exists
-    end
+    subtest.should_receive(:path_kind).and_return(path_kind)
+    CIAT::Subresult.should_receive(:new).
+      with(@ciat_file, path_kind, light, subtest).and_return(subresult)
+    @feedback.should_receive(:report_subresult).with(subresult)
+
+    @test.subresult(subtest, light).should == subresult
   end
 end

data/spec/ciat/traffic_light_spec.rb

@@ -1,41 +1,31 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
 describe CIAT::TrafficLight do
-  before(:each) do
-    @traffic_light = CIAT::TrafficLight.new
+  it "should respond to unset?" do
+    CIAT::TrafficLight::UNSET.unset?.should == true
+    CIAT::TrafficLight::RED.unset?.should == false
+    CIAT::TrafficLight::YELLOW.unset?.should == false
+    CIAT::TrafficLight::GREEN.unset?.should == false
   end
   
-  it "should initially be unset" do
-    @traffic_light.unset?.should == true
-    @traffic_light.green!
-    @traffic_light.unset?.should == false
-  end
-
-  it "should set and query green" do
-    @traffic_light.green?.should == false
-    @traffic_light.green!
-    @traffic_light.green?.should == true
-  end
-  
-  it "should set and query yellow" do
-    @traffic_light.yellow?.should == false
-    @traffic_light.yellow!
-    @traffic_light.yellow?.should == true    
+  it "should respond to red?" do
+    CIAT::TrafficLight::UNSET.red?.should == false
+    CIAT::TrafficLight::RED.red?.should == true
+    CIAT::TrafficLight::YELLOW.red?.should == false
+    CIAT::TrafficLight::GREEN.red?.should == false
   end
   
-  it "should set and query red" do
-    @traffic_light.red?.should == false
-    @traffic_light.red!
-    @traffic_light.red?.should == true    
+  it "should respond to yellow?" do
+    CIAT::TrafficLight::UNSET.yellow?.should == false
+    CIAT::TrafficLight::RED.yellow?.should == false
+    CIAT::TrafficLight::YELLOW.yellow?.should == true
+    CIAT::TrafficLight::GREEN.yellow?.should == false
   end
-  
-  it "should not switch away from yellow" do
-    @traffic_light.yellow!
-    @traffic_light.yellow?.should == true
-    @traffic_light.red!
-    @traffic_light.green!
-    @traffic_light.yellow?.should == true
-    @traffic_light.red?.should == false
-    @traffic_light.green?.should == false
+
+  it "should respond to green?" do
+    CIAT::TrafficLight::UNSET.green?.should == false
+    CIAT::TrafficLight::RED.green?.should == false
+    CIAT::TrafficLight::YELLOW.green?.should == false
+    CIAT::TrafficLight::GREEN.green?.should == true
   end
 end

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ rescue LoadError
   gem 'rspec'
   require 'spec'
 end
+require 'webrat'
 
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'ciat'
@@ -17,7 +18,7 @@ module ERBHelpers
   end
   
   def process_erb
-    Hpricot(erb.result(binding))
+    Webrat::XML.html_document(erb.result(binding))
   end
   
   def replace_tabs(string)
@@ -28,6 +29,10 @@ module ERBHelpers
     prefix
   end
   
+  def filename_to_id(filename)
+    filename
+  end
+  
   def title(text)
     text
   end
@@ -38,7 +43,11 @@ module ERBHelpers
 
   def fake(what, content)
     "<div class=\"fake\"><div id=\"#{what}\">#{content}</div></div>"
-  end  
+  end
+  
+  def fake_selector
+    "div.fake"
+  end
 end
 
 module MockHelpers
@@ -50,25 +59,6 @@ module MockHelpers
 end
 
 module CustomDetailRowMatchers
-  class HaveColSpan
-    def initialize(expected)
-      @expected = expected
-    end
-
-    def matches?(target)
-      @target = target
-      (@target/"//td").attr('colspan').eql?(@expected.to_s)
-    end
-
-    def failure_message
-      "expected #{@target.inspect} to have colspan #{@expected}"
-    end
-  
-    def negative_failure_message
-      "expected #{@target.inspect} not to have colspan #{@expected}"
-    end
-  end
-  
   class HaveInnerHtml
     def initialize(xpath, expected)
       @xpath = xpath
@@ -89,41 +79,10 @@ module CustomDetailRowMatchers
     end
   end
   
-  class HaveNone
-    def initialize(xpath)
-      @xpath = xpath
-    end
-    
-    def matches?(target)
-      @target = target
-      (@target/@xpath).size == 0
-    end
-    
-    def failure_message
-      "expected #{@target.inspect} to have nothing with #{@xpath}"
-    end
-    
-    def negative_failure_message
-      "expected #{@target.inspect} to have something with #{@xpath}"
-    end
-  end
-  
-  def have_colspan(expected)
-    HaveColSpan.new(expected)
-  end
-  
   def have_inner_html(xpath, expected)
     HaveInnerHtml.new(xpath, expected)
   end
-  
-  def have_none(xpath)
-    HaveNone.new(xpath)
-  end
-  
-  def have_description(header, expected)
-    have_inner_html("//#{header}", expected)
-  end
-  
+    
   def have_fake(type, expected)
     have_inner_html("//div[@class=\"fake\"]/div[@id=\"#{type}\"]", expected)
   end
@@ -132,3 +91,7 @@ module CustomDetailRowMatchers
     have_inner_html("table", /Expected(.|\s)*Generated(.|\s)*#{expected}/)
   end
 end
+
+Spec::Runner.configure do |config|
+  config.include(MockHelpers)
+end

data/spec/templates/detail_row/elements_html_erb_spec.rb

@@ -5,25 +5,24 @@ require 'hpricot'
 describe "element output in detail row" do
   include ERBHelpers
   include CustomDetailRowMatchers
+  include Webrat::Matchers
   
   attr_reader :erb
   attr_reader :recursion
   attr_reader :processor  
-  attr_reader :test_file
   attr_reader :elements
   
   before(:each) do
     @recursion = mock("recursion")
     @processor = mock('processor')
-    @test_file = mock("test file")
-    @erb = ERB.new(File.read("lib/templates/detail_row/elements.html.erb"))
+    @erb = build_erb("lib/templates/detail_row/elements.html.erb")
   end
 
   it "should handle no elements" do
     @elements = []
     
     doc = process_erb
-    doc.should have_inner_html("", /\s*/)
+    doc.should_not have_selector(fake_selector)
   end
   
   it "should process one used element" do

data/spec/templates/detail_row_html_erb_spec.rb

@@ -5,25 +5,23 @@ require 'hpricot'
 describe "detail row of test report" do
   include ERBHelpers
   include CustomDetailRowMatchers
+  include Webrat::Matchers
   
   attr_reader :erb
   attr_reader :recursion
   
   before(:each) do
     @result = mock('result')
-    @test_file = mock('test file')
+    @result.should_receive(:filename).and_return("foo/bar/filename.ciat")
+    @ciat_file = mock('ciat file')
     @recursion = mock('recursion')
     @erb = build_erb("lib/templates/detail_row.html.erb")
-
-    @result.should_receive(:test_file).
-      any_number_of_times.and_return(@test_file)
   end
   
   it "should work with no subresults" do
     @result.should_receive(:subresults).at_least(:once).and_return([])
     
-    doc = process_erb
-    doc.should have_colspan(1)
+    process_erb.should have_selector("td", :colspan => "1")
   end
 
   it "should work with one processor" do
@@ -31,42 +29,105 @@ describe "detail row of test report" do
     
     @result.should_receive(:subresults).
       any_number_of_times.and_return([subresult])
-    expect_red_or_green(subresult, "The Processor", "fake elements")
+    expect_set_and_needed_processor(subresult, "The Processor", :happy, "fake elements")
+
+    process_erb.should have_selector("body") do |body|
+      body.should have_selector("h3", :content => "Results from The Processor")
+      body.should have_fake(:elements, "fake elements")
+    end
+  end
+  
+  it "should work with many processors with all success" do
+    subresults = array_of_mocks(3, "subresult")
+    
+    @result.should_receive(:subresults).
+      any_number_of_times.and_return(subresults)
+    expect_set_and_needed_processor(subresults[0], "Processor 0", :happy, "fake elements 0")
+    expect_set_and_needed_processor(subresults[1], "Processor 1", :happy, "fake elements 1")
+    expect_set_and_needed_processor(subresults[2], "Processor 2", :sad, "fake elements 2")
+
+    process_erb.should have_selector("body") do |body|
+      body.should have_selector("h3", :content => "Results from Processor 0 (happy path)")
+      body.should have_fake(:elements, "fake elements 0")
+      body.should have_selector("h3", :content => "Results from Processor 1 (happy path)")
+      body.should have_fake(:elements, "fake elements 1")
+      body.should have_selector("h3", :content => "Results from Processor 2 (sad path)")
+      body.should have_fake(:elements, "fake elements 2")
+    end
+  end
+  
+  it "should work with many processors with some success and some unset" do
+    subresults = array_of_mocks(3, "subresult")
+    
+    @result.should_receive(:subresults).
+      any_number_of_times.and_return(subresults)
+    expect_set_and_needed_processor(subresults[0], "Processor 0", :happy, "fake elements 0")
+    expect_set_and_needed_processor(subresults[1], "Processor 1", :happy, "fake elements 1")
+    expect_unset_processor(subresults[2], "Processor 2", :happy)
 
-    doc = process_erb
-    doc.should have_description("h3", "Results from The Processor")
-    doc.should have_fake(:elements, "fake elements")
+    process_erb.should have_selector("body") do |body|
+      body.should have_selector("h3", :content => "Results from Processor 0 (happy path)")
+      body.should have_fake(:elements, "fake elements 0")
+      body.should have_selector("h3", :content => "Results from Processor 1 (happy path)")
+      body.should have_fake(:elements, "fake elements 1")
+      body.should have_selector("h3", :content => "Results from Processor 2 (happy path)")
+      body.should have_selector("p", :content => "Not executed.")
+    end
   end
   
-  it "should work with many processors" do
-    subresults = [mock('subresult 0'), mock('subresult 1'), mock('subresult 2')]
+  it "should work with many processors with some success and some unneeded" do
+    subresults = array_of_mocks(3, "subresult")
     
     @result.should_receive(:subresults).
       any_number_of_times.and_return(subresults)
-    expect_red_or_green(subresults[0], "Processor 0", "fake elements 0")
-    expect_red_or_green(subresults[1], "Processor 1", "fake elements 1")
-    expect_red_or_green(subresults[2], "Processor 2", "fake elements 2")
+    expect_set_and_needed_processor(subresults[0], "Processor 0", :happy, "fake elements 0")
+    expect_set_and_needed_processor(subresults[1], "Processor 1", :happy, "fake elements 1")
+    expect_unneeded_processor(subresults[2], "Processor 2", :happy)
 
-    doc = process_erb
-    doc.should have_description("h3", "Results from Processor 0")
-    doc.should have_fake(:elements, "fake elements 0")
-    doc.should have_description("h3", "Results from Processor 1")
-    doc.should have_fake(:elements, "fake elements 1")
-    doc.should have_description("h3", "Results from Processor 2")
-    doc.should have_fake(:elements, "fake elements 2")
+    process_erb.should have_selector("body") do |body|
+      body.should have_selector("h3", :content => "Results from Processor 0 (happy path)")
+      body.should have_fake(:elements, "fake elements 0")
+      body.should have_selector("h3", :content => "Results from Processor 1 (happy path)")
+      body.should have_fake(:elements, "fake elements 1")
+      body.should have_selector("h3", :content => "Results from Processor 2 (happy path)")
+      body.should have_selector("p", :content => "Not executed.")
+    end
   end
   
-  def expect_red_or_green(subresult, description, rendered_elements)
+  def expect_set_and_needed_processor(subresult, description, path_kind, rendered_elements)
     processor, elements = mock('processor'), mock('elements')
 
     subresult.should_receive(:processor).and_return(processor)
     processor.should_receive(:describe).with().and_return(description)
+    subresult.stub_chain(:light, :unset?).and_return(false)
+    subresult.stub_chain(:light, :unneeded?).and_return(false)
+    subresult.should_receive(:path_kind).and_return(path_kind)
     subresult.should_receive(:relevant_elements).and_return(elements)
     @recursion.should_receive(:render).
       with("detail_row/elements", :elements => elements).
       and_return(fake(:elements, rendered_elements))
   end
     
+  def expect_unset_processor(subresult, description, path_kind)
+    processor, elements = mock('processor'), mock('elements')
+
+    subresult.should_receive(:processor).and_return(processor)
+    processor.should_receive(:describe).with().and_return(description)
+    subresult.stub_chain(:light, :unset?).and_return(true)
+    subresult.stub_chain(:light, :unneeded?).and_return(false)
+    subresult.should_receive(:path_kind).and_return(path_kind)
+  end
+    
+  def expect_unneeded_processor(subresult, description, path_kind)
+    processor, elements = mock('processor'), mock('elements')
+
+    subresult.should_receive(:processor).and_return(processor)
+    processor.should_receive(:describe).with().and_return(description)
+    subresult.stub_chain(:light, :unset?).and_return(false)
+    subresult.stub_chain(:light, :unneeded?).and_return(true)
+    subresult.should_receive(:path_kind).and_return(path_kind)
+  end
+    
   def result
     @result
   end