ciat 0.4.9 → 0.4.10

data/spec/ciat/processors/parrot_spec.rb

@@ -3,16 +3,6 @@ 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

data/spec/ciat/processors/shared_examples_for_element_names.rb

@@ -0,0 +1,27 @@
+shared_examples_for "Any element namer" do
+  describe "element-name hash" do
+    [CIAT::TrafficLight::RED, CIAT::TrafficLight::YELLOW, CIAT::TrafficLight::GREEN, CIAT::TrafficLight::UNSET].each do |light|
+      [:happy, :sad].each do |path|
+        it "should compute relevant elements for #{light.color} light and #{path} path" do
+          @namer.relevant_elements(light, path).should_not be_nil
+        end
+      end
+    end    
+  end
+  
+  it "should have an output name" do
+    @namer.output_name.should be_an_instance_of(Symbol)
+  end
+  
+  it "should have an input name" do
+    @namer.input_name.should be_an_instance_of(Symbol)
+  end
+  
+  it "should have an error name" do
+    @namer.error_name.should be_an_instance_of(Symbol)
+  end
+  
+  it "should have a happy_path?" do
+    @namer.happy_path_element.should be_an_instance_of(Symbol)
+  end
+end

data/spec/ciat/rake_task_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe CIAT::RakeTask do
+  it "should initialize" do
+    CIAT::RakeTask.new.should_not be_nil
+  end
+
+  it "should let me set processors" do
+    processors = mock("processors")
+    CIAT::RakeTask.new do |task|
+      task.processors = processors
+    end.processors.should == processors
+  end
+  
+  it "should let me append processors" do
+    processors = array_of_mocks(3, "processor")
+    CIAT::RakeTask.new do |task|
+      task.processors << processors[0]
+      task.processors << processors[1]
+      task.processors << processors[2]
+    end.processors.should == processors
+  end
+  
+  it "should let me set the files for input" do
+    files = mock("file")
+    CIAT::RakeTask.new do |task|
+      task.files = files
+    end.files.should == files
+  end
+  
+  it "should let me set the feedback" do
+    feedback = mock("feedback")
+    CIAT::RakeTask.new do |task|
+      task.feedback = feedback
+    end.feedback.should == feedback
+  end
+  
+  it "should let set the folder for input files" do
+    folder = mock("folder")
+    CIAT::RakeTask.new do |task|
+      task.folder = folder
+    end.folder.should == folder
+  end
+  
+  it "should let me set the report filename" do
+    report_filename = mock("report filename")
+    CIAT::RakeTask.new do |task|
+      task.report_filename = report_filename
+    end.report_filename.should == report_filename
+  end
+  
+  it "should let me set the report title" do
+    report_title = mock("report title")
+    CIAT::RakeTask.new do |task|
+      task.report_title = report_title
+    end.report_title.should == report_title
+  end
+
+  it "should let me set the output folder" do
+    output_folder = mock("output folder")
+    CIAT::RakeTask.new do |task|
+      task.output_folder = output_folder
+    end.output_folder.should == output_folder
+  end
+end

data/spec/ciat/subresult_spec.rb

@@ -3,10 +3,11 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe CIAT::Subresult do
   before(:each) do
     @elements = mock("elements")
+    @path_kind = mock("path kind")
     @light = mock("light")
-    @processor = mock("processor")
+    @subtest = mock("subtest")
     
-    @subtest_result = CIAT::Subresult.new(@elements, @light, @processor)
+    @subresult = CIAT::Subresult.new(@elements, @path_kind, @light, @subtest)
   end
   
   it "should look up relevant elements" do
@@ -14,7 +15,7 @@ describe CIAT::Subresult do
     names = [mock("name 0"), mock("name 1"), mock("name 2")]
     relevants = [mock("element 0"), mock("element 1"), mock("element 2")]
     
-    @subtest_result.should_receive(:relevant_element_names).and_return(names)
+    @subresult.should_receive(:relevant_element_names).and_return(names)
     @elements.should_receive(:element?).with(names[0]).and_return(true)
     @elements.should_receive(:element).with(names[0]).and_return(relevants[0])
     @elements.should_receive(:element?).with(names[1]).and_return(true)
@@ -22,19 +23,19 @@ describe CIAT::Subresult do
     @elements.should_receive(:element?).with(names[2]).and_return(true)
     @elements.should_receive(:element).with(names[2]).and_return(relevants[2])
     
-    @subtest_result.relevant_elements.should == relevants
+    @subresult.relevant_elements.should == relevants
   end
   
   it "should have relevant element names" do
-    kind, hash, setting = 
-      mock("kind"), mock("hash"), mock("setting")
+    kind = mock("kind")
+    path_kind = mock("path kind")
     names = mock("names")
+
+    @subtest.should_receive(:path_kind).and_return(path_kind)
+    @subtest.stub_chain(:processor, :kind).and_return(kind)
+    kind.should_receive(:relevant_elements).
+      with(@light, path_kind).and_return(names)
     
-    @processor.should_receive(:kind).and_return(kind)
-    kind.should_receive(:element_name_hash).and_return(hash)
-    @light.should_receive(:setting).and_return(setting)
-    hash.should_receive(:[]).with(setting).and_return(names)
-    
-    @subtest_result.relevant_element_names.should == names
+    @subresult.relevant_element_names.should == names
   end
 end

data/spec/ciat/subtest_spec.rb

@@ -0,0 +1,199 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe CIAT::Subtest do
+  before(:each) do
+    @ciat_file = mock("ciat file")
+    @processor = mock("processor")
+    @subtest = CIAT::Subtest.new(@ciat_file, @processor)
+  end
+  
+  describe "processing" do
+    it "should execute and diff normally" do
+      @subtest.should_receive(:execute).with().and_return(true)
+      @subtest.should_receive(:diff).with().and_return(true)
+      
+      @subtest.process.should == CIAT::TrafficLight::GREEN
+    end
+
+    it "should execute with an error" do
+      @subtest.should_receive(:execute).with().and_return(false)
+      
+      @subtest.process.should == CIAT::TrafficLight::YELLOW
+    end
+
+    it "should execute normally and diff with a failure" do
+      @subtest.should_receive(:execute).with().and_return(true)
+      @subtest.should_receive(:diff).with().and_return(false)
+      
+      @subtest.process.should == CIAT::TrafficLight::RED
+    end
+  end
+  
+  it "should determine a happy path" do
+    result = mock("result")
+    
+    @processor.stub_chain(:kind, :happy_path_element).and_return(:foobar)
+    @ciat_file.should_receive(:element?).with(:foobar).and_return(result)
+    
+    @subtest.happy_path?.should == result
+  end
+  
+  describe "path kind" do
+    it "should indicate happy path as path kind" do
+      @subtest.should_receive(:happy_path?).with().and_return(true)
+    
+      @subtest.path_kind.should == :happy
+    end
+
+    it "should indicate sad path as path kind" do
+      @subtest.should_receive(:happy_path?).with().and_return(false)
+    
+      @subtest.path_kind.should == :sad
+    end
+  end
+  
+  describe "executing a processor for a test" do
+    it "should run successful command line for happy path" do
+      kind =  mock("kind")
+      result = mock("result")
+      
+      @subtest.should_receive(:command_line).and_return("[command line]")
+      @subtest.should_receive(:happy_path?).with().and_return(true)
+      @subtest.should_receive(:sh).with("[command line]").
+        and_yield(true, result)
+      
+      @subtest.execute.should be_true
+    end
+    
+    it "should run erroring command line for happy path" do
+      test, kind = mock("test"), mock("kind")
+      result = mock("result")
+      
+      @subtest.should_receive(:command_line).and_return("[command line]")
+      @subtest.should_receive(:happy_path?).with().and_return(true)
+      @subtest.should_receive(:sh).with("[command line]").
+        and_yield(false, result)
+      
+      @subtest.execute.should be_false
+    end
+    
+    it "should prepare a command line" do
+      test = mock("test")
+      
+      @processor.should_receive(:executable).and_return("[executable]")
+      @subtest.should_receive(:input_file).with().
+        and_return("[input]")
+      @subtest.should_receive(:command_line_args).with().
+        and_return("[args]")
+      @subtest.should_receive(:output_file).with().
+        and_return("[output]")
+      @subtest.should_receive(:error_file).with().
+        and_return("[error]") 
+        
+      @subtest.command_line.should ==
+        "[executable] '[input]' [args] > '[output]' 2> '[error]'"
+    end
+  end
+  
+  describe "handling command-line arguments" do
+    it "should strip command-line arguments" do
+      command_line = mock("command_line")
+    
+      @ciat_file.should_receive(:element?).with(:command_line).
+        and_return(true)
+      @ciat_file.should_receive(:element).with(:command_line).
+        and_return(command_line)
+      command_line.should_receive(:content).
+        and_return("   argument1 \t argument2  \n\n")
+    
+      @subtest.command_line_args.should == "argument1 \t argument2"
+    end
+    
+    it "should return empty string if none provided" do   
+      @ciat_file.should_receive(:element?).
+        with(:command_line).and_return(false)
+      
+      @subtest.command_line_args.should == ''
+    end
+  end
+  
+  describe "computing a diff" do
+    it "should compute a diff in HTML for normal output" do
+      kind, result = mock("processor kind"), mock("result")
+      output_name = mock("output name")
+
+      @subtest.should_receive(:happy_path?).with().and_return(true)
+      @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(output_name)
+      generated_file = expect_element_as_file(output_name, :generated)
+      diff_file = expect_element_as_file(output_name, :diff)
+      @subtest.should_receive(:html_diff).
+        with(original_file, generated_file, diff_file).and_return(result)
+    
+      @subtest.diff.should == result
+    end
+
+    it "should compute a diff in HTML for error output" do
+      kind, result = mock("processor kind"), mock("result")
+      error_name = mock("error name")
+
+      @subtest.should_receive(:happy_path?).with().and_return(false)
+      @processor.should_receive(:kind).any_number_of_times.and_return(kind)
+      kind.should_receive(:error_name).any_number_of_times.
+        and_return(error_name)
+      original_file = expect_element_as_file(error_name)
+      generated_file = expect_element_as_file(error_name, :generated)
+      diff_file = expect_element_as_file(error_name, :diff)
+      @subtest.should_receive(:html_diff).
+        with(original_file, generated_file, diff_file).and_return(result)
+    
+      @subtest.diff.should == result
+    end
+    
+    def expect_element_as_file(*names)
+      element, filename = mock("#{names} element"), mock("#{names} filename")
+      @ciat_file.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
+    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)
+    @ciat_file.should_receive(:element).with(name).and_return(element)
+    element.should_receive(:as_file).and_return(filename)
+    
+    @subtest.input_file.should == filename
+  end
+
+  it "should get filename of output" do
+    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)
+    @ciat_file.should_receive(:element).with(name, :generated).and_return(element)
+    element.should_receive(:as_file).and_return(filename)
+    
+    @subtest.output_file.should == filename
+  end
+
+  it "should get filename of error" do
+    kind, element, name = mock("kind"), mock("element"), mock("name")
+    filename = mock("filename")
+    
+    @processor.should_receive(:kind).and_return(kind)
+    kind.should_receive(:error_name).and_return(name)
+    @ciat_file.should_receive(:element).
+      with(name, :generated).and_return(element)
+    element.should_receive(:as_file).and_return(filename)
+    
+    @subtest.error_file.should == filename
+  end
+end

data/spec/ciat/suite_builder_spec.rb

@@ -17,23 +17,23 @@ describe CIAT::SuiteBuilder do
     it "should make test files" do
       files = array_of_mocks(3, "files")
       output_folder = mock("output folder")
-      test_files = array_of_mocks(3, "test file")
+      ciat_files = array_of_mocks(3, "ciat file")
 
       @default_builder.should_receive(:build_output_folder).
         at_least(:once).and_return(output_folder)
-      CIAT::TestFile.should_receive(:new).
-        with(files[0], output_folder).and_return(test_files[0])
-      CIAT::TestFile.should_receive(:new).
-        with(files[1], output_folder).and_return(test_files[1])
-      CIAT::TestFile.should_receive(:new).
-        with(files[2], output_folder).and_return(test_files[2])
+      CIAT::CiatFile.should_receive(:new).
+        with(files[0], output_folder).and_return(ciat_files[0])
+      CIAT::CiatFile.should_receive(:new).
+        with(files[1], output_folder).and_return(ciat_files[1])
+      CIAT::CiatFile.should_receive(:new).
+        with(files[2], output_folder).and_return(ciat_files[2])
     
-      @default_builder.make_test_files(files).should == test_files
+      @default_builder.make_ciat_files(files).should == ciat_files
     end
 
     it "should complain if no test files to make" do
       lambda {
-        @default_builder.make_test_files([])
+        @default_builder.make_ciat_files([])
       }.should raise_error(IOError)
     end
   end
@@ -41,30 +41,30 @@ describe CIAT::SuiteBuilder do
   describe "getting and processing test files" do
     it "should get filename from filenames option" do
       files = mock("files")
-      test_files = mock("test files")
+      ciat_files = mock("ciat files")
       
       options[:files] = files
-      @default_builder.should_receive(:make_test_files).
-        with(files).and_return(test_files)
+      @default_builder.should_receive(:make_ciat_files).
+        with(files).and_return(ciat_files)
         
-      @default_builder.build_test_files.should == test_files
+      @default_builder.build_ciat_files.should == ciat_files
     end
     
     it "should get filenames from folder" do
       input_folder, pattern = mock("input folder"), mock("pattern")
       files = mock("files")
       output_folder = mock("output folder")
-      test_files = mock("test files")
+      ciat_files = mock("ciat files")
       
       options[:folder] = input_folder
       options[:pattern] = pattern
       File.should_receive(:join).with(input_folder, "**", pattern).
         and_return("the full path")
       Dir.should_receive(:[]).with("the full path").and_return(files)
-      @default_builder.should_receive(:make_test_files).
-        with(files).and_return(test_files)
+      @default_builder.should_receive(:make_ciat_files).
+        with(files).and_return(ciat_files)
       
-      @default_builder.build_test_files.should == test_files      
+      @default_builder.build_ciat_files.should == ciat_files      
     end
   end
 end

data/spec/ciat/suite_spec.rb

@@ -6,9 +6,9 @@ describe CIAT::Suite do
   it "should construct with suite builder" do
     options = mock("options")
     suite_builder = mock("suite builder")
-    processors, output_folder, test_files, feedback =
+    processors, output_folder, ciat_files, feedback =
       mock("processors"), mock("output folder"),
-      mock("test files"), mock("feedback")
+      mock("ciat files"), mock("feedback")
     suite = mock("suite")
     
     CIAT::SuiteBuilder.should_receive(:new).
@@ -16,10 +16,10 @@ describe CIAT::Suite do
     suite_builder.should_receive(:build_processors).and_return(processors)
     suite_builder.should_receive(:build_output_folder).
       and_return(output_folder)
-    suite_builder.should_receive(:build_test_files).and_return(test_files)
+    suite_builder.should_receive(:build_ciat_files).and_return(ciat_files)
     suite_builder.should_receive(:build_feedback).and_return(feedback)
     CIAT::Suite.should_receive(:new).
-      with(processors, output_folder, test_files, feedback).and_return(suite)
+      with(processors, output_folder, ciat_files, feedback).and_return(suite)
       
     CIAT::Suite.build(options).should == suite
   end
@@ -28,15 +28,15 @@ describe CIAT::Suite do
     before(:each) do
       @processors = array_of_mocks(3, "processor")
       @output_folder = mock("output folder")
-      @test_files = array_of_mocks(3, "test file")
+      @ciat_files = array_of_mocks(3, "ciat file")
       @feedback = mock("feedback")
       @suite = CIAT::Suite.new(
-                  @processors, @output_folder, @test_files, @feedback
+                  @processors, @output_folder, @ciat_files, @feedback
                   )
     end
     
     it "should have a size based on the number of test files" do
-      @suite.stub_chain(:test_files, :size).and_return(42)
+      @suite.stub_chain(:ciat_files, :size).and_return(42)
 
       @suite.size.should == 42
     end
@@ -46,18 +46,18 @@ describe CIAT::Suite do
       results = array_of_mocks(3, "result")
 
       @feedback.should_receive(:pre_tests).with(@suite)
-      expect_create_and_run_test(@test_files[0], results[0])
-      expect_create_and_run_test(@test_files[1], results[1])
-      expect_create_and_run_test(@test_files[2], results[2])
+      expect_create_and_run_test(@ciat_files[0], results[0])
+      expect_create_and_run_test(@ciat_files[1], results[1])
+      expect_create_and_run_test(@ciat_files[2], results[2])
       @feedback.should_receive(:post_tests).with(@suite)
     
       @suite.run.should == results
       @suite.results.should == results
     end
     
-    def expect_create_and_run_test(test_file, result)
-      test = mock("test for #{test_file}")
-      @suite.should_receive(:create_test).with(test_file).and_return(test)
+    def expect_create_and_run_test(ciat_file, result)
+      test = mock("test for #{ciat_file}")
+      @suite.should_receive(:create_test).with(ciat_file).and_return(test)
       test.should_receive(:run).and_return(result)
     end
   end