albacore 1.0.0.rc.2 → 1.0.0.rc.3

data/spec/unzip_spec.rb

@@ -1,5 +1,4 @@
-require 'spec_helper'
-require 'albacore/unzip'
+require "spec_helper"
 
 describe Unzip, "when providing configuration" do
   let :uz do

data/spec/xbuild_spec.rb

@@ -1,15 +1,40 @@
-require 'spec_helper'
-require 'albacore/xbuild'
-
-describe XBuild, "when providing configuration values" do
-  let :xbuild do
-    Albacore.configure do |config|
-      config.xbuild.command = "configured"
-    end
-    xbuild = XBuild.new
-  end
-
-  it "should use the configured values" do
-    xbuild.command.should == "configured"
-  end
-end
+require "spec_helper"
+
+describe XBuild do
+  subject(:task) do
+    task = XBuild.new()
+    task.extend(SystemPatch)
+    task.command = "xbuild"
+    task.solution = "solution"
+    task.verbosity = "minimal"
+    task.targets = [:clean, :build]
+    task.properties = {:foo => "foo", :bar => "bar"}
+    task
+  end
+
+  let(:cmd) { task.system_command }
+
+  before :each do
+    task.execute
+  end
+  
+  it "should use the command" do 
+    cmd.should include("xbuild")
+  end
+  
+  it "should build the solution" do
+    cmd.should include("\"solution\"")
+  end
+  
+  it "should be verbose" do 
+    cmd.should include("/verbosity:minimal")
+  end
+  
+  it "should use the targets" do 
+    cmd.should include("/target:clean;build")
+  end
+  
+  it "should set the properties" do
+    cmd.should include("/p:foo=\"foo\" /p:bar=\"bar\"")
+  end
+end

data/spec/xunit_spec.rb

@@ -1,200 +1,30 @@
-require 'spec_helper'
-require 'albacore/xunittestrunner'
-
-describe "xunit with defined paths" do
-  before :all do
-    @xunitpath = File.join(File.dirname(__FILE__), 'support', 'Tools', 'XUnit-v1.9', 'xunit.console.clr4.exe')
-    @test_assembly = File.join(File.expand_path(File.dirname(__FILE__)), 'support', 'CodeCoverage', 'xunit', 'assemblies', 'TestSolution.XUnitTests.dll')
-    @output_option = "/out=xunit.results.html"
-    @working_dir =File.join(File.dirname(__FILE__), 'support','xunit')
-    @html_output = File.join(@working_dir,'TestSolution.XUnitTests.dll.html')
-  end
-
-  describe XUnitTestRunner, "the command parameters for an xunit runner" do
-    before :each do
-      xunit = XUnitTestRunner.new(@xunitpath)
-      xunit.assembly = @test_assembly
-      xunit.options @output_option
-
-      @command_parameters = xunit.get_command_parameters
-    end
-
-    it "should not include the path to the command" do
-      @command_parameters.should_not include(@xunitpath)
-    end
-
-    it "should include the list of options" do
-      @command_parameters.should include(@output_option)
-    end
-  end
-
-  describe XUnitTestRunner, "the command line string for an xunit runner" do
-    before :all do
-      xunit = XUnitTestRunner.new(@xunitpath)
-      xunit.assembly = @test_assembly
-      xunit.options @output_option
-
-      @command_line = xunit.get_command_line
-      @command_parameters = xunit.get_command_parameters.join(" ")
-    end
-
-    it "should start with the path to the command" do
-      @command_line.split(" ").first.should == @xunitpath
-    end
-
-    it "should include the command parameters" do
-      @command_line.should include(@command_parameters)
-    end
-  end
-
-  describe XUnitTestRunner, "when configured correctly" do
-    before :all do
-      xunit = XUnitTestRunner.new(@xunitpath)
-      xunit.assembly = @test_assembly
-      xunit.options '/noshadow /trait "type=passing"'
-      xunit.extend(FailPatch)
-      xunit.log_level = :verbose
-
-      xunit.execute
-    end
-
-    it "should execute" do
-      $task_failed.should be_false
-    end
-  end
-
-  describe XUnitTestRunner, "when multiple assemblies are passed to xunit runner" do
-    before :all do
-      xunit = XUnitTestRunner.new(@xunitpath)
-      xunit.assemblies = @test_assembly, @test_assembly
-      xunit.options '/noshadow /trait "type=passing"'
-      xunit.extend(FailPatch)
-      xunit.log_level = :verbose
-
-      xunit.execute
-    end
-
-    it "should execute" do
-      $task_failed.should be_false
-    end
-  end
-
-  describe XUnitTestRunner, "when zero assemblies are passed to xunit runner" do
-    before :all do
-      xunit = XUnitTestRunner.new(@xunitpath)    
-      xunit.options '/noshadow'
-      xunit.extend(FailPatch)
-
-      xunit.execute
-    end
-
-    it "should fail" do
-      $task_failed.should be_true
-    end
-  end
-
-  describe XUnitTestRunner, 'when skipping test fail' do
-    before :all do
-      xunit = XUnitTestRunner.new @xunitpath
-
-      xunit.extend FailPatch
-      xunit.extend SystemPatch
-      xunit.disable_system = true
-
-      xunit.assembly = 'xyz'
-      xunit.skip_test_fail = true
-      
-      xunit.execute
-    end
-
-    it 'should not fail' do
-      $task_failed.should be_false
-    end
-  end
-
-  describe XUnitTestRunner, 'when skipping test failures' do
-    before :all do
-      xunit = XUnitTestRunner.new @xunitpath
-      
-      xunit.extend FailPatch
-      xunit.extend SystemPatch
-      xunit.disable_system = true
-      
-      xunit.assembly = 'xyz'
-      xunit.skip_test_failures
-      
-      xunit.execute
-    end
-
-    it 'should not fail' do
-      $task_failed.should be_false
-    end
-  end
-
-  describe XUnitTestRunner, "when html_output is specified" do
-    before :each do
-      FileUtils.mkdir @working_dir unless File.exist?(@working_dir)
-      xunit = XUnitTestRunner.new(@xunitpath)
-      xunit.assembly = @test_assembly    
-      xunit.html_output = File.dirname(@html_output)
-      xunit.extend(FailPatch)
-      xunit.options '/noshadow /trait "type=passing"'
-
-      xunit.execute
-    end
-
-    it "should execute" do
-      $task_failed.should be_false
-    end
-
-    it "should write output html" do
-      sleep(2)
-      File.exist?(@html_output).should be_true
-    end
-
-    after:each do
-      FileUtils.rm_r @working_dir if File.exist? @working_dir
-    end
-  end
-
-  describe XUnitTestRunner, "when html_output is not a directory" do
-    before :each do
-      FileUtils.mkdir @working_dir unless File.exist?(@working_dir)
-      strio = StringIO.new
-      xunit = XUnitTestRunner.new(@xunitpath)
-      xunit.log_level = :verbose
-      xunit.log_device = strio
-      xunit.assembly = @test_assembly    
-      xunit.html_output = @html_output
-      xunit.extend(FailPatch)
-
-      xunit.execute
-      @log_data = strio.string
-    end
-
-    it "should fail" do
-      $task_failed.should be_true
-    end
-
-    it "should log a message" do
-      @log_data.should include('Directory is required for html_output')    
-    end
-
-    after:each do
-      FileUtils.rm_r @working_dir if File.exist? @working_dir
-    end
-  end
-
-  describe XUnitTestRunner, "when providing configuration" do
-    let :xunit do
-      Albacore.configure do |config|
-        config.xunit.command = "configured"
-      end
-      xunit = XUnitTestRunner.new
-    end
-
-    it "should use the configured values" do
-      xunit.command.should == "configured"
-    end
-  end
-end
+require "spec_helper"
+
+describe XUnit do
+  subject(:task) do
+    task = XUnit.new()
+    task.extend(SystemPatch)
+    task.command = "xunit"
+    task.assembly = "a.dll"
+    task.results_path = {:html => "output.html"}
+    task
+  end
+
+  let(:cmd) { task.system_command }
+
+  before :each do
+    task.execute
+  end
+
+  it "should use the command" do
+    cmd.should include("xunit")
+  end
+
+  it "should test one assembly" do
+    cmd.should include("\"a.dll\"")
+  end
+
+  it "should output to an unedited path" do
+    cmd.should include("/html \"output.html\"")
+  end
+end

data/spec/yaml/test.yml

@@ -0,0 +1,3 @@
+foo: foo
+bar: {foo: foo, bar: bar}
+baz: :baz

data/spec/yamlconfig_spec.rb

@@ -1,49 +1,53 @@
-require 'spec_helper'
-require 'albacore/albacoretask'
-
-class ::YamlTest
-  include Albacore::Task
-  attr_accessor :some_name, :another_name, :a_hash, :what_ever
-end
-
-describe "when configuring with yaml" do
-  before :all do
-    @yml = YamlTest.new
-    @yml.configure File.join(File.dirname(__FILE__), 'support', 'test.yml')
-  end
-  
-  it "should set the value of some_name" do
-    @yml.some_name.should == "some value"
-  end
-  
-  it "should create and set the value of another_name" do
-    @yml.another_name.should == "another value"
-  end
-      
-  it "should allow hash tables" do
-    @yml.a_hash.length.should == 2
-    @yml.a_hash['name'].should == "value"
-    @yml.a_hash['foo'].should == "bar"
-  end
-  
-  it "should allow symbols" do
-    @yml.what_ever.should == :a_symbol
-  end  
-end
-
-describe "when specifying a yaml config folder and configuring" do
-  class ::YAML_AutoConfig_Test
-    include Albacore::Task
-    attr_accessor :some_attribute
-  end
-  
-  before :all do
-    Albacore.configure.yaml_config_folder = File.join(File.dirname(__FILE__), 'support', 'yamlconfig')
-    @yamltest = YAML_AutoConfig_Test.new
-    @yamltest.load_config_by_task_name("yaml_autoconfig_test")
-  end
-  
-  it "should automatically configure the class from the yaml file in the specified folder" do
-    @yamltest.some_attribute.should == "this value was loaded from a folder, specified by Albacore.configure.yaml_config_folder"
-  end
-end
+require "spec_helper"
+
+class Test
+  include Albacore::Task
+
+  attr_accessor :foo,
+                :bar,
+                :baz
+end
+
+describe "yaml configuration" do
+  subject(:yml) { Test.new() }
+
+  before :each do  
+    yml.configure("spec/yaml/test.yml")
+  end
+  
+  it "should set the property" do
+    yml.foo.should == "foo"
+  end
+      
+  it "should set the hashtable" do
+    yml.bar["foo"].should == "foo"
+    yml.bar["bar"].should == "bar"
+  end
+  
+  it "should set a symbol value" do
+    yml.baz.should == :baz
+  end  
+end
+
+describe "yaml configuration by folder" do
+  Albacore.configure.yaml_config_folder = "spec/yaml"
+
+  subject(:yml) { Test.new() }
+
+  before :each do
+    yml.load_config_by_task_name("test")
+  end
+  
+  it "should set the property" do
+    yml.foo.should == "foo"
+  end
+      
+  it "should set the hashtable" do
+    yml.bar["foo"].should == "foo"
+    yml.bar["bar"].should == "bar"
+  end
+  
+  it "should set a symbol value" do
+    yml.baz.should == :baz
+  end  
+end

data/spec/zip_spec.rb

@@ -1,221 +1,97 @@
-require 'spec_helper'
-require 'albacore/zipdirectory'
-require 'albacore/unzip'
-require 'ziptestdata'
+require "spec_helper"
+require "fileutils"
 
-describe ZipDirectory, 'when zipping a directory of files' do
-  before :each do
-    zip = ZipDirectory.new
-    zip.flatten_zip
-    zip.directories_to_zip ZipTestData.folder
-    zip.output_file = "test.zip"
-    zip.execute
-  end
-  
-  it "should produce a zip file" do
-    File.exist?(File.join(ZipTestData.folder, "test.zip")).should be_true
-  end
-end
+describe ZipDirectory do
+  let(:output_path) { File.join(Dir.mktmpdir(), "test.zip") }
+  let(:unzip_path)  { Dir.mktmpdir() }
 
-describe ZipDirectory, 'when zipping a directory with string exclusions' do
-  before :each do
-    zip = ZipDirectory.new
-    zip.flatten_zip
-    zip.directories_to_zip ZipTestData.folder
-    zip.output_file = 'test.zip'
-    zip.exclusions File.join(ZipTestData.folder, 'files', 'testfile.txt')
-    zip.execute
-    
-    unzip = Unzip.new
-    unzip.file = File.join(ZipTestData.folder, 'test.zip')
-    unzip.destination = ZipTestData.output_folder
-    unzip.execute
-  end
-  
-  after :each do
-    FileUtils.rm_rf ZipTestData.output_folder if File.exist? ZipTestData.output_folder
-  end
-  
-  it 'should not zip files with the same name as any exclusions' do
-    File.exist?(File.join(ZipTestData.output_folder, 'files', 'testfile.txt')).should be_false
-  end
-end
+  let(:unzip) do
+    unzip = Unzip.new()
+    unzip.file = output_path
+    unzip.destination = unzip_path
+    unzip
+  end    
 
-describe ZipDirectory, 'when zipping a directory of files with regexp exclusions' do
-  before :each do
-    zip = ZipDirectory.new
-    zip.flatten_zip
-    zip.directories_to_zip ZipTestData.folder
-    zip.output_file = 'test.zip'
-    zip.exclusions /testfile/
-    zip.execute
-    
-    unzip = Unzip.new
-    unzip.file = File.join(ZipTestData.folder, 'test.zip')
-    unzip.destination = ZipTestData.output_folder
-    unzip.execute
-  end
-  
-  after :each do
-    FileUtils.rm_rf ZipTestData.output_folder if File.exist? ZipTestData.output_folder
-  end
-  
-  it 'should not zip files that match any of the exclusions regexps' do
-    File.exist?(File.join(ZipTestData.output_folder, 'files', 'testfile.txt')).should be_false
-  end
-end
-
-describe ZipDirectory, 'when zipping a directory of files with glob string exclusions' do
-  before :each do
-    zip = ZipDirectory.new
-    zip.flatten_zip
-    zip.directories_to_zip ZipTestData.folder
-    zip.output_file = 'test.zip'
-    zip.exclusions "**/subfolder/*"
-    zip.execute
-
-    unzip = Unzip.new
-    unzip.file = File.join(ZipTestData.folder, 'test.zip')
-    unzip.destination = ZipTestData.output_folder
-    unzip.execute
+  subject(:task) do
+    task = ZipDirectory.new()
+    task.flatten
+    task.dirs = ["spec/zip/foo"]
+    task.files = ["spec/zip/baz.txt"]
+    task.output_path = output_path
+    task
   end
 
   after :each do
-    FileUtils.rm_rf ZipTestData.output_folder if File.exists? ZipTestData.output_folder
+    FileUtils.rm_rf(output_path)
+    FileUtils.rm_rf(unzip_path)
   end
 
-  it 'should not zip files that match the expanded globs' do
-    File.exist?(File.join(ZipTestData.output_folder, 'files', 'subfolder', 'sub file.txt')).should be_false
-  end
-
-  it 'should zip the files that don\'t match the globs' do
-    File.exist?(File.join(ZipTestData.output_folder, 'files', 'subfolder')).should be_true
-    File.exist?(File.join(ZipTestData.output_folder, 'files', 'testfile.txt')).should be_true
-  end
-end
-
-describe ZipDirectory, "when providing configuration" do
-  let :zip do
-    Albacore.configure do |config|
-      config.zip.output_file = "configured"
+  context "when zipping" do
+    before :each do
+      task.execute()
+      unzip.execute()
+    end
+    
+    it "should make a zip" do
+      File.exist?(output_path).should be_true
     end
-    zip = ZipDirectory.new
-  end
 
-  it "should use the configured values" do
-    zip.output_file.should == "configured"
-  end
-end
+    it "should zip the additional file" do
+      File.exist?(File.join(unzip_path, "baz.txt")).should be_true
+    end
 
-describe ZipDirectory, 'when zipping a directory of files with additional files' do
-  describe 'and additional file is given as an array' do
-    before :each do
-      zip = ZipDirectory.new
-      zip.flatten_zip
-      zip.directories_to_zip ZipTestData.folder
-      zip.output_file = 'test.zip'
-      zip.exclusions "**/subfolder/*"
-      zip.additional_files = [File.join(File.dirname(__FILE__), 'support', 'test.yml')]
-      zip.execute
-      
-      unzip = Unzip.new
-      unzip.file = File.join(ZipTestData.folder, 'test.zip')
-      unzip.destination = ZipTestData.output_folder
-      unzip.execute
+    it "should zip the root file" do
+      File.exist?(File.join(unzip_path, "foo.txt")).should be_true
     end
 
-    after :each do
-      FileUtils.rm_rf ZipTestData.output_folder if File.exist? ZipTestData.output_folder
+    it "should zip the subfolder" do
+      File.exist?(File.join(unzip_path, "bar")).should be_true
     end
 
-    it "should add additional file" do
-      File.exist?(File.join(ZipTestData.folder, "test.zip")).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'files', 'subfolder')).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'files', 'testfile.txt')).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'test.yml')).should be_true
+    it "should zip the subfolder file" do
+      File.exist?(File.join(unzip_path, "bar/bar.txt")).should be_true
     end
   end
-  
-  describe 'and additional file is given as a string' do
+
+  context "when zipping with string exclusions" do
     before :each do
-      zip = ZipDirectory.new
-      zip.flatten_zip
-      zip.directories_to_zip ZipTestData.folder
-      zip.output_file = 'test.zip'
-      zip.exclusions "**/subfolder/*"
-      zip.additional_files = File.join(File.dirname(__FILE__), 'support', 'test.yml')
-      zip.execute
-      
-      unzip = Unzip.new
-      unzip.file = File.join(ZipTestData.folder, 'test.zip')
-      unzip.destination = ZipTestData.output_folder
-      unzip.execute
+      task.exclusions = ["spec/zip/foo/bar/bar.txt"]
+      task.execute()
+      unzip.execute()
     end
 
-    after :each do
-      FileUtils.rm_rf ZipTestData.output_folder if File.exist? ZipTestData.output_folder
-    end
-    
-    it "should add additional file" do
-      File.exist?(File.join(ZipTestData.folder, "test.zip")).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'files', 'subfolder')).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'files', 'testfile.txt')).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'test.yml')).should be_true
+    it "should skip matching files" do
+      File.exist?(File.join(unzip_path, "bar/bar.txt")).should be_false
     end
   end
-end
 
-describe ZipDirectory, "without flatten_zip set" do
+  context "when zipping with regex exclusions" do
     before :each do
-      zip = ZipDirectory.new
-      zip.directories_to_zip File.join('spec', 'support', 'yamlconfig')
-      zip.output_file = 'test.zip'
-      zip.output_path = ZipTestData.folder
-      zip.additional_files = [File.join('spec', 'support', 'test.yml'), File.join('spec', 'support', 'AssemblyInfo', 'assemblyinfo.yml')]
-      zip.execute
-
-      unzip = Unzip.new
-      unzip.file = File.join(ZipTestData.folder, 'test.zip')
-      unzip.destination = ZipTestData.output_folder
-      unzip.execute
-    end
-
-    after :each do
-      FileUtils.rm_rf ZipTestData.output_folder if File.exist? ZipTestData.output_folder
+      task.exclusions = [/bar/]
+      task.execute()
+      unzip.execute()
     end
-
-    it "should add additional file" do
-      File.exist?(File.join(ZipTestData.folder, "test.zip")).should be_true
-      Dir.exist?(File.join(ZipTestData.output_folder, 'spec', 'support', 'yamlconfig')).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'spec', 'support', 'yamlconfig', 'msbuild.yml')).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'spec', 'support', 'test.yml')).should be_true
+      
+    it "should skip matching files" do
+      File.exist?(File.join(unzip_path, "bar/bar.txt")).should be_false
     end
-end
+  end
 
-describe ZipDirectory, "with flatten_zip set" do
+  context "when zipping with glob exclusions" do
     before :each do
-      zip = ZipDirectory.new
-      zip.flatten_zip
-      zip.directories_to_zip File.join('spec', 'support', 'yamlconfig')
-      zip.output_file = 'test.zip'
-      zip.output_path = ZipTestData.folder
-      zip.additional_files = [File.join('spec', 'support', 'test.yml'), File.join('spec', 'support', 'AssemblyInfo', 'assemblyinfo.yml')]
-      zip.execute
-
-      unzip = Unzip.new
-      unzip.file = File.join(ZipTestData.folder, 'test.zip')
-      unzip.destination = ZipTestData.output_folder
-      unzip.execute
+      task.exclusions = ["**/bar/*"]
+      task.execute()
+      unzip.execute()
     end
 
-    after :each do
-      FileUtils.rm_rf ZipTestData.output_folder if File.exist? ZipTestData.output_folder
+    it "should skip matching files" do
+      File.exist?(File.join(unzip_path, "bar/bar.txt")).should be_false
     end
+  end
 
-    it "should add additional file" do
-      File.exist?(File.join(ZipTestData.folder, "test.zip")).should be_true
-      Dir.exist?(File.join(ZipTestData.output_folder, 'spec', 'support', 'yamlconfig')).should be_false
-      File.exist?(File.join(ZipTestData.output_folder, 'msbuild.yml')).should be_true
-      File.exist?(File.join(ZipTestData.output_folder, 'test.yml')).should be_true
+  context "without flatten" do
+    it "should zip" do
+      pending("needs some thought")
     end
+  end
 end