ciat 0.4.8 → 0.4.9

data/spec/ciat/feedback/html_feedback_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'ciat/feedback/html_feedback'
+
+describe CIAT::Feedback::HtmlFeedback do
+  before(:each) do
+    @counter = mock("counter")
+    @feedback = CIAT::Feedback::HtmlFeedback.new(@counter, {})
+  end
+
+  it "should have a pre-test action" do
+    suite, output_folder = mock("suite"), mock("output folder")
+
+    suite.should_receive(:output_folder).
+      at_least(:once).and_return(output_folder)
+    FileUtils.should_receive(:mkdir_p).with(output_folder)
+    FileUtils.should_receive(:cp).with(/.*\/data\/ciat.css/, output_folder)
+    FileUtils.should_receive(:cp).with(/.*\/data\/prototype.js/, output_folder)
+    
+    @feedback.pre_tests(suite)
+  end
+  
+  it "should generate a report" do
+    suite = mock("suite")
+    html, report_filename = mock("html"), mock("report filename")
+
+    @feedback.should_receive(:generate_html).with(suite).and_return(html)
+    @feedback.should_receive(:report_filename).and_return(report_filename)
+    @feedback.should_receive(:write_file).with(report_filename, html)
+    
+    @feedback.post_tests(suite)
+  end
+  
+  it "should generate html" do
+    suite = mock("suite")
+    erb_template, binding = mock("erb_template"), mock("binding")
+    filename = mock("filename")
+    
+    suite.should_receive(:results).and_return(mock("results"))
+    suite.should_receive(:processors).and_return(mock("processors"))
+    suite.should_receive(:size).and_return(mock("size"))
+    @feedback.should_receive(:build_erb).and_return(erb_template)
+    @feedback.should_receive(:binding).with().and_return(binding)
+    erb_template.should_receive(:result).with(binding)
+    
+    @feedback.generate_html(suite)
+  end
+end

data/spec/ciat/feedback/return_status_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'ciat/feedback/return_status'
+
+describe CIAT::Feedback::ReturnStatus do
+  GREEN = CIAT::TrafficLight.new(:green)
+  YELLOW = CIAT::TrafficLight.new(:yellow)
+  RED = CIAT::TrafficLight.new(:red)
+  
+  before(:each) 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
+  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))
+    
+    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 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))
+
+    lambda { @feedback.post_tests(mock("suite")) }.
+      should raise_error(RuntimeError)
+  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
+  
+  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))
+
+    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))
+
+    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))
+
+    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))
+
+    lambda { @feedback.post_tests(mock("suite")) }.
+      should raise_error(RuntimeError)
+  end
+end

data/spec/ciat/feedback/standard_output_spec.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'ciat/feedback/standard_output'
+
+describe CIAT::Feedback::StandardOutput do
+  before(:each) do
+    @counter = mock("counter")
+    @feedback = CIAT::Feedback::StandardOutput.new(@counter)
+  end
+  
+  describe "the post-test report" do
+    it "should report just the total number of tests" do
+      suite = mock("suite")
+    
+      suite.should_receive(:size).and_return(88)
+      @counter.should_receive(:failure_count).and_return(0)
+      @counter.should_receive(:error_count).and_return(0)
+      @feedback.should_receive(:print).with("\n")
+      @feedback.should_receive(:print).with("88 tests executed")
+      @feedback.should_receive(:print).with(".\n")
+    
+      @feedback.post_tests(suite)
+    end
+    
+    it "should report the number of tests and failures" do
+      suite = mock("suite")
+    
+      suite.should_receive(:size).and_return(30)
+      @counter.should_receive(:failure_count).at_least(:once).and_return(12)
+      @counter.should_receive(:error_count).and_return(0)
+      @feedback.should_receive(:print).with("\n")
+      @feedback.should_receive(:print).with("30 tests executed")
+      @feedback.should_receive(:print).with(", 12 failures")
+      @feedback.should_receive(:print).with(".\n")
+    
+      @feedback.post_tests(suite)      
+    end
+
+    it "should report the number of tests and errors" do
+      suite = mock("suite")
+    
+      suite.should_receive(:size).and_return(3)
+      @counter.should_receive(:failure_count).and_return(0)
+      @counter.should_receive(:error_count).at_least(:once).and_return(1)
+      @feedback.should_receive(:print).with("\n")
+      @feedback.should_receive(:print).with("3 tests executed")
+      @feedback.should_receive(:print).with(", 1 errors")
+      @feedback.should_receive(:print).with(".\n")
+    
+      @feedback.post_tests(suite)      
+    end
+
+    it "should report the number of tests, failures, and errors" do
+      suite = mock("suite")
+    
+      suite.should_receive(:size).and_return(78)
+      @counter.should_receive(:failure_count).at_least(:once).and_return(9)
+      @counter.should_receive(:error_count).at_least(:once).and_return(3)
+      @feedback.should_receive(:print).with("\n")
+      @feedback.should_receive(:print).with("78 tests executed")
+      @feedback.should_receive(:print).with(", 9 failures")
+      @feedback.should_receive(:print).with(", 3 errors")
+      @feedback.should_receive(:print).with(".\n")
+    
+      @feedback.post_tests(suite)      
+    end
+  end
+  
+  describe "reporting on a processor" do
+    before(:each) do
+      @light = mock("light")
+      @processor = mock("processor")
+      @processor.should_receive(:light).at_least(:once).and_return(@light)
+    end
+    
+    it "should report a green light" do
+      expect_light(:green)
+      @feedback.should_receive(:putc).with(".")
+      
+      @feedback.report_subresult(@processor)
+    end
+    
+    it "should report a red light" do
+      expect_light(:red)
+      @feedback.should_receive(:putc).with("F")
+      
+      @feedback.report_subresult(@processor)
+    end
+    
+    it "should report a yellow light" do      
+      expect_light(:yellow)
+      @feedback.should_receive(:putc).with("E")
+
+      @feedback.report_subresult(@processor)
+    end
+
+    it "should report an unset light" do      
+      expect_light(:unset)
+      @feedback.should_receive(:putc).with("-")
+      
+      @feedback.report_subresult(@processor)
+    end
+    
+    def expect_light(setting)
+      @light.should_receive(:setting).at_least(:once).and_return(setting)
+    end
+  end
+  
+end

data/spec/ciat/processors/basic_processing_spec.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CIAT::Processors::BasicProcessing do
+  class Processor
+    include CIAT::Processors::BasicProcessing
+  end
+  
+  before(:each) do
+    @processor = Processor.new
+  end
+  
+  describe "processing" do
+    before(:each) do
+      @test = mock("test")
+    end
+    
+    it "should execute and diff normally" do
+      @processor.should_receive(:execute).with(@test).and_return(true)
+      @processor.should_receive(:diff).with(@test).and_return(true)
+      
+      @processor.process(@test).should == CIAT::TrafficLight::GREEN
+    end
+
+    it "should execute with an error" do
+      @processor.should_receive(:execute).with(@test).and_return(false)
+      
+      @processor.process(@test).should == CIAT::TrafficLight::YELLOW
+    end
+
+    it "should execute normally and diff with a failure" do
+      @processor.should_receive(:execute).with(@test).and_return(true)
+      @processor.should_receive(:diff).with(@test).and_return(false)
+      
+      @processor.process(@test).should == CIAT::TrafficLight::RED
+    end
+  end
+  
+  describe "executing a processor for a test" do
+    it "should put together and execute a shell command" do
+      test, ok, result = mock("test"), mock("ok"), mock("result")
+      
+      @processor.should_receive(:executable).and_return("[executable]")
+      @processor.should_receive(:input_file).with(test).
+        and_return("[input]")
+      @processor.should_receive(:command_line_args).with(test).
+        and_return("[args]")
+      @processor.should_receive(:output_file).with(test).
+        and_return("[output]")
+      @processor.should_receive(:error_file).with(test).
+        and_return("[error]") 
+      @processor.should_receive(:sh).
+        with("[executable] '[input]' [args] > '[output]' 2> '[error]'").
+        and_yield(ok, result)
+      
+      @processor.execute(test).should == ok
+    end
+  end
+  
+  describe "handling command-line arguments" do
+    it "should strip command-line arguments" do
+      test = mock("test")
+      command_line = mock("command_line")
+    
+      test.should_receive(:element?).with(:command_line).and_return(true)
+      test.should_receive(:element).with(:command_line).
+        and_return(command_line)
+      command_line.should_receive(:content).
+        and_return("   argument1 \t argument2  \n\n")
+    
+      @processor.command_line_args(test).should == "argument1 \t argument2"
+    end
+    
+    it "should return empty string if none provided" do
+      test = mock("test")
+      
+      test.should_receive(:element?).with(:command_line).and_return(false)
+      
+      @processor.command_line_args(test).should == ''
+    end
+  end
+  
+  describe "computing a diff" do
+    it "should compute a diff in HTML" do
+      test, kind, result = 
+        mock("test"), mock("processor kind"), mock("result")
+      output_name = mock("output name")
+
+      @processor.should_receive(:kind).any_number_of_times.and_return(kind)
+      kind.should_receive(:output_name).any_number_of_times.
+        and_return(output_name)
+      original_file = expect_element_as_file(test, output_name)
+      generated_file = expect_element_as_file(test, output_name, :generated)
+      diff_file = expect_element_as_file(test, output_name, :diff)
+      @processor.should_receive(:html_diff).
+        with(original_file, generated_file, diff_file).and_return(result)
+    
+      @processor.diff(test).should eql(result)
+    end
+    
+    def expect_element_as_file(test, *names)
+      element, filename = mock("#{names} element"), mock("#{names} filename")
+      test.should_receive(:element).with(*names).and_return(element)
+      element.should_receive(:as_file).and_return(filename)
+      filename
+    end
+  end
+  
+  it "should get filename of input" do
+    test = mock("test")
+    kind, element, name = mock("kind"), mock("element"), mock("name")
+    filename = mock("filename")
+    
+    @processor.should_receive(:kind).and_return(kind)
+    kind.should_receive(:input_name).and_return(name)
+    test.should_receive(:element).with(name).and_return(element)
+    element.should_receive(:as_file).and_return(filename)
+    
+    @processor.input_file(test).should eql(filename)
+  end
+
+  it "should get filename of input" do
+    test = mock("test")
+    kind, element, name = mock("kind"), mock("element"), mock("name")
+    filename = mock("filename")
+    
+    @processor.should_receive(:kind).and_return(kind)
+    kind.should_receive(:output_name).and_return(name)
+    test.should_receive(:element).with(name, :generated).and_return(element)
+    element.should_receive(:as_file).and_return(filename)
+    
+    @processor.output_file(test).should eql(filename)
+  end
+
+  it "should get filename of input" do
+    test = mock("test")
+    kind, element, name = mock("kind"), mock("element"), mock("name")
+    filename = mock("filename")
+    
+    @processor.should_receive(:kind).and_return(kind)
+    kind.should_receive(:output_name).and_return(name)
+    test.should_receive(:element).with(name, :error).and_return(element)
+    element.should_receive(:as_file).and_return(filename)
+    
+    @processor.error_file(test).should eql(filename)
+  end
+end

data/spec/ciat/processors/java_spec.rb

@@ -0,0 +1,31 @@
+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")
+      executor.description = mock("description")
+    end
+  end
+  
+  it "should have an executable" do
+    @classpath = mock("classpath", :to_s => 'the classpath')
+    @interpreter_class = mock("interpreter", :to_s => 'the interpreter')
+    
+    @processor = CIAT::Processors::Java.new(@classpath, @interpreter_class)
+    @processor.executable.should == "java -cp 'the classpath' the interpreter"
+  end
+  
+end

data/spec/ciat/processors/parrot_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'ciat/processors/parrot'
+
+describe CIAT::Processors::Parrot do
+  describe "mixins" do
+    it "should use basic processing module" do
+      CIAT::Processors::Parrot.should include(CIAT::Processors::BasicProcessing)
+    end
+
+    it "should use basic processing module" do
+      CIAT::Processors::Parrot.should include(CIAT::Differs::HtmlDiffer)
+    end
+  end
+  
+  describe "default executor" do
+    before(:each) do
+      @executor = CIAT::Processors::Parrot.new
+    end
+
+    it "should have an executable" do
+      @executor.executable.should == "parrot"
+    end
+  end
+  
+  it "should have settable options" do
+    CIAT::Processors::Parrot.new do |executor|
+      executor.kind = mock("processor kind")
+      executor.description = mock("description")
+      executor.libraries = mock("libraries")
+    end
+  end
+  
+  it "should use system libraries" do
+    executor = CIAT::Processors::Parrot.new do |e|
+      e.libraries = ["/usr/local/foo", "../bar"]
+    end
+    executor.executable.should == "parrot -L/usr/local/foo -L../bar"
+  end
+end