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

data/spec/patch/system_patch.rb

@@ -0,0 +1,12 @@
+module SystemPatch    
+  attr_accessor :system_command
+  
+  def system(cmd)
+    @system_command = cmd
+    return !@fail
+  end
+
+  def force_failure
+    @fail = true
+  end
+end

data/spec/platform_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe Albacore::Support::Platform do
+  it "should quote strings" do
+    Albacore::Support::Platform.quote("test").should eq("\"test\"")
+  end
+
+  it "should double-backslash Windows paths" do
+    Albacore::Support::Platform.windows_path("a/windows/path").should eq("a\\windows\\path")
+  end
+
+  it "should single-forwardslash Linux paths" do
+    Albacore::Support::Platform.linux_path("a\\linux\\path").should eq("a/linux/path")
+  end
+end

data/spec/plink_spec.rb

@@ -1,62 +1,56 @@
-require 'spec_helper'
-require 'albacore/plink'
-
-describe PLink, 'when executing a command over plink' do
-  before :each do
-    @cmd = PLink.new
-    @cmd.extend(SystemPatch)
-    @cmd.extend(FailPatch)
-    @cmd.command ="C:\\plink.exe"
-    @cmd.host = "testhost"
-
-  end
-
-  it "should attempt to execute plink.exe" do
-    @cmd.run
-    @cmd.system_command.should include("plink.exe")
-  end
-
-  it "should attempt to connect to the test host on the default port (22)"  do
-    @cmd.run
-    @cmd.system_command.should include("@testhost")
-    @cmd.system_command.should include("-P 22")
-  end
-
-  it "should connect to the test host on a non default port 2200" do
-    @cmd.port = 2200
-    @cmd.run
-    @cmd.system_command.should include("-P 2200")
-  end
-
-  it "should connect to the host with a username" do
-    expected_user = "dummyuser"
-    @cmd.user = expected_user
-    @cmd.run
-    @cmd.system_command.should include("#{expected_user}@")
-  end
-
-  it "should run remote commands in batch mode" do
-    @cmd.run
-    @cmd.system_command.should include("-batch")
-  end
-
-  it "should run commands in verbose mode" do
-    @cmd.verbose = true
-    @cmd.run
-    @cmd.system_command.should include("-v")
-  end
-
-  it "should include the remote command" do
-    expected_remote_exe = "C:\ThisIsTheRemoteExe.exe"
-    @cmd.commands expected_remote_exe
-    @cmd.run
-    @cmd.system_command.should include(expected_remote_exe)
-  end
-
-  it "should include the remote command with parameters" do
-    expected_remote_exe = "C:\\ThisIsTheRemoteExe.exe --help -o -p"
-    @cmd.commands expected_remote_exe
-    @cmd.run
-    @cmd.system_command.should include(expected_remote_exe)
-  end
-end
+require "spec_helper"
+
+describe PLink do
+  subject(:task) do
+    task = PLink.new()
+    task.extend(SystemPatch)
+    task.command = "plink"
+    task.host = "host"
+    task.port = 443
+    task.user = "username"
+    task.key = "key"
+    task.verbose
+    task.commands = ["foo", "bar"]
+    task
+  end
+
+  let(:cmd) { task.system_command }
+
+  before :each do
+    task.execute
+  end
+
+  it "should use the command" do
+    cmd.should include("plink")
+  end
+
+  it "should use the correct connection" do
+    cmd.should include("username@host -P 443")
+  end
+
+  it "should use the key" do
+    cmd.should include("-i key")
+  end
+
+  it "should batch the commands" do
+    cmd.should include("-batch")
+  end
+
+  it "should be verbose" do
+    cmd.should include("-v")
+  end
+
+  it "should send the remote commands" do
+    cmd.should include("foo bar")
+  end
+
+  context "when plinking without a user" do
+    before :each do
+      task.user = nil
+    end
+
+    it "should use the correct connection" do
+      cmd.should include("host -P 443")
+    end
+  end
+end

data/spec/runcommand_spec.rb

@@ -1,94 +1,92 @@
-require 'spec_helper'
-require 'albacore/albacoretask'
-require 'system_patch'
-
-class RunCommandObject
-  include Albacore::Task
-  include Albacore::RunCommand
-
-  def execute
-    result = run_command "Run Command Test Object"
-  end
-end
-
-describe "when setting the command" do
-  before :all do
-    @runme = RunCommandObject.new
-    @runme.extend SystemPatch
-
-    @runme.command = "test.exe"
-    @runme.execute
-  end
-
-  it "should execute the specified command, quoted" do
-    @runme.system_command.should == "\"test.exe\""
-  end
-end
-
-describe "when specifying a parameter to a command" do
-  before :all do
-    @runme = RunCommandObject.new
-    @runme.extend SystemPatch
-    @runme.command = "test.exe"
-    @runme.parameters "param1"
-    @runme.execute
-  end
-
-  it "should separate the parameters from the command" do
-    @runme.system_command.should == "\"test.exe\" param1"
-  end
-end
-
-describe "when specifying multiple parameters to a command" do
-  before :all do
-    @runme = RunCommandObject.new
-    @runme.extend SystemPatch
-    @runme.command = "test.exe"
-    @runme.parameters "param1", "param2", "param3"
-    @runme.execute
-  end
-
-  it "should separate all parameters by a space" do
-    @runme.system_command.should == "\"test.exe\" param1 param2 param3"
-  end
-end
-
-describe "when executing a runcommand object twice" do
-  before :all do
-    @runmeone = RunCommandObject.new
-    @runmetwo = @runmeone
-    @runmeone.extend SystemPatch
-    @runmeone.command = "test.exe"
-    @runmeone.parameters "1", "2", "3"
-
-    @runmeone.execute
-    @runmetwo.execute
-  end
-
-  it "should only pass the parameters to the command once for the first execution" do
-    @runmeone.system_command.should == "\"test.exe\" 1 2 3"
-  end
-
-  it "should only pass the parameters to the command once for the second execution" do
-    @runmetwo.system_command.should == "\"test.exe\" 1 2 3"
-  end
-end
-
-describe "when the command exists relative to the project root" do
-  before :all do
-    @runme = RunCommandObject.new
-    @runme.extend SystemPatch
-
-    File.open('test.exe', 'w') {}
-    @runme.command = "test.exe"
-    @runme.execute
-  end
-
-  after :all do
-    FileUtils.rm_f('test.exe')
-  end
-
-  it "should expand the path" do
-    @runme.system_command.should == "\"#{File.expand_path('test.exe')}\""
-  end
-end
+require "spec_helper"
+
+class RunCommandObject
+  include Albacore::Task
+  include Albacore::RunCommand
+
+  def execute
+    result = run_command "Run Command Test Object"
+  end
+end
+
+describe "when setting the command" do
+  before :all do
+    @runme = RunCommandObject.new
+    @runme.extend SystemPatch
+
+    @runme.command = "test.exe"
+    @runme.execute
+  end
+
+  it "should execute the specified command, quoted" do
+    @runme.system_command.should == "\"test.exe\""
+  end
+end
+
+describe "when specifying a parameter to a command" do
+  before :all do
+    @runme = RunCommandObject.new
+    @runme.extend SystemPatch
+    @runme.command = "test.exe"
+    @runme.parameters "param1"
+    @runme.execute
+  end
+
+  it "should separate the parameters from the command" do
+    @runme.system_command.should == "\"test.exe\" param1"
+  end
+end
+
+describe "when specifying multiple parameters to a command" do
+  before :all do
+    @runme = RunCommandObject.new
+    @runme.extend SystemPatch
+    @runme.command = "test.exe"
+    @runme.parameters "param1", "param2", "param3"
+    @runme.execute
+  end
+
+  it "should separate all parameters by a space" do
+    @runme.system_command.should == "\"test.exe\" param1 param2 param3"
+  end
+end
+
+describe "when executing a runcommand object twice" do
+  before :all do
+    @runmeone = RunCommandObject.new
+    @runmetwo = @runmeone
+    @runmeone.extend SystemPatch
+    @runmeone.command = "test.exe"
+    @runmeone.parameters "1", "2", "3"
+
+    @runmeone.execute
+    @runmetwo.execute
+  end
+
+  it "should only pass the parameters to the command once for the first execution" do
+    @runmeone.system_command.should == "\"test.exe\" 1 2 3"
+  end
+
+  it "should only pass the parameters to the command once for the second execution" do
+    @runmetwo.system_command.should == "\"test.exe\" 1 2 3"
+  end
+end
+
+describe "when the command exists relative to the project root" do
+  before :all do
+    @runme = RunCommandObject.new
+    @runme.extend SystemPatch
+
+    File.open('test.exe', 'w') {}
+    @runme.command = "test.exe"
+    @runme.execute
+  end
+
+  after :all do
+    FileUtils.rm_f('test.exe')
+  end
+
+  it "should expand the path" do
+    @runme.system_command.should == "\"#{File.expand_path('test.exe')}\""
+  end
+end

data/spec/spec_helper.rb

@@ -1,16 +1,20 @@
-@root_dir = File.expand_path(File.join(File.dirname(__FILE__), "../"))
-
-$: << './'
-$: << File.join(@root_dir, "lib")
-$: << File.join(@root_dir, "spec")
-$: << File.join(@root_dir, "spec/patches")
-$: << File.join(@root_dir, "spec/support")
-$: << File.join(@root_dir, "lib/albacore/config")
-
-require 'rubygems'
-require 'rake/tasklib'
-require 'lib/albacore/support/createtask.rb'
-require 'lib/albacore/config/config.rb'
-require 'lib/albacore'
-require 'system_patch'
-require 'fail_patch'
+require "albacore"
+require "patch/system_patch"
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+end

data/spec/specflow_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe SpecFlow do
+  subject(:task) do
+    task = SpecFlow.new()
+    task.extend(SystemPatch)
+    task.command = "specflow"
+    task.report = :nunitexecutionreport
+    task.project = "myproject.csproj"
+    task
+  end
+
+  let(:cmd) { task.system_command }
+
+  before :each do
+    task.execute
+  end
+
+  it "should use the command" do
+    cmd.should include("specflow")
+  end 
+
+  it "should use the given report" do
+    cmd.should include("nunitexecutionreport")
+  end 
+
+  it "should use the given project" do
+    cmd.should include("\"myproject.csproj\"")
+  end 
+end

data/spec/sqlcmd_spec.rb

@@ -1,334 +1,66 @@
-require 'spec_helper'
-require 'albacore/sqlcmd'
-
-describe SQLCmd, "when running a script the easy way" do
-  before :all do
-    @cmd = SQLCmd.new
-    @cmd.log_level = :verbose
-    @cmd.extend(SystemPatch)
-    @cmd.disable_system = true
-    
-    @cmd.scripts "somescript.sql"
-    
-    @cmd.execute
-  end
-
-  it "should use localhost as server default" do
-	@cmd.system_command.should include("-S \".\"")
-  end
-  
-  it "should have no database designation (because it could be embedded in the sql file)" do
-	@cmd.system_command.should_not include("-d")
-  end
-  
-  it "should use integrated security instead of username/password" do
-	@cmd.system_command.should include("-E")
-  end
-
-  it "should not include username" do
-	@cmd.system_command.should_not include("-U")
-  end
-
-  it "should not include password" do
-	@cmd.system_command.should_not include("-P")
-  end
-
-  it "should find the location of the sqlcmd exe for the user" do
-    @cmd.system_command.downcase.should include("sqlcmd.exe")
-  end
-  
-  it "should specify the script file" do
-    @cmd.system_command.should include("-i \"somescript.sql\"")
-  end
-  
-  it "should not contain the -b option" do
-    @cmd.system_command.should_not include("-b")
-  end
-end
-
-describe SQLCmd, "when turning off trusted_connection" do
-  before :all do
-    @cmd = SQLCmd.new
-    @cmd.log_level = :verbose
-    @cmd.extend(SystemPatch)
-    @cmd.disable_system = true
-    
-    @cmd.scripts "somescript.sql"
-    @cmd.trusted_connection = false
-    
-    @cmd.execute
-  end
-
-  it "should not specify the -E option" do
-    @cmd.system_command.should_not include("-E")
-  end
-end
-
-describe SQLCmd, "when using a trusted connection with a username and password" do
-  before :all do
-    @cmd = SQLCmd.new
-    @cmd.log_level = :verbose
-    @cmd.extend(SystemPatch)
-    @cmd.disable_system = true
-    
-    @cmd.scripts "somescript.sql"
-    @cmd.trusted_connection = true
-    @cmd.username = "user"
-    @cmd.password = "password"
-    
-    @cmd.execute
-  end
-
-  it "should override the trusted connection and not specify the -E option" do
-    @cmd.system_command.should_not include("-E")
-  end
-
-  it "should specify the username" do
-    @cmd.system_command.should include("-U \"user\"")
-  end
-  
-  it "should specify the password" do
-    @cmd.system_command.should include("-P \"password\"")
-  end
-end
-
-describe SQLCmd, "when running a script file against a database with authentication information" do
-  before :all do
-    @cmd = SQLCmd.new
-    @cmd.command = "sqlcmd.exe"
-    @cmd.log_level = :verbose
-    @cmd.extend(SystemPatch)
-    @cmd.disable_system = true
-    
-    @cmd.server="a server"
-    @cmd.database="a database"
-    @cmd.username="some user"
-    @cmd.password="shh! it's a secret!"
-    @cmd.scripts "somescript.sql"
-    
-    @cmd.execute
-  end
-  
-  it "should specify the location of the sqlcmd exe" do
-    @cmd.system_command.downcase.should include("sqlcmd.exe")
-  end
-  
-  it "should specify the script file" do
-    @cmd.system_command.should include("-i \"somescript.sql\"")
-  end
-  
-  it "should specify the server" do
-    @cmd.system_command.should include("-S \"a server\"")
-  end
-  
-  it "should specify the database" do
-    @cmd.system_command.should include("-d \"a database\"")
-  end
-
-  it "should specify the username" do
-    @cmd.system_command.should include("-U \"some user\"")
-  end
-  
-  it "should specify the password" do
-    @cmd.system_command.should include("-P \"shh! it's a secret!\"")
-  end
-  
-  it "should not contain the -b option" do
-    @cmd.system_command.should_not include("-b")
-  end
-end
-
-describe SQLCmd, "when running with no command path specified" do
-  before :all do
-    strio = StringIO.new
-    @cmd = SQLCmd.new
-    @cmd.log_level = :verbose
-    @cmd.log_device = strio
-    @cmd.extend(SystemPatch)
-    @cmd.extend(FailPatch)
-    @cmd.disable_system = true
-
-    @cmd.execute
-    @log_data = strio.string
-
-    @all_possible_sqlcmd_paths = []
-
-    ["program files", "program files (x86)"].each do |program_files|
-      ["90", "100", "110"].each do |sql_version|
-        sqlcmd_path = File.join(ENV['SystemDrive'], program_files,'microsoft sql server', sql_version, 'tools','binn', 'sqlcmd.exe')
-        @all_possible_sqlcmd_paths << sqlcmd_path
-      end
-    end
-  end
-
-  it "should find sqlcmd in the standard places or bail" do
-    any_sqlcmd_exists = false
-
-    @all_possible_sqlcmd_paths.each do |sqlcmd_path|
-      sqlcmd_exists = File.exists?(sqlcmd_path)
-      any_sqlcmd_exists = true if sqlcmd_exists
-      $task_failed.should be_false if sqlcmd_exists
-    end
-    $task_failed.should be_true if any_sqlcmd_exists == false
-  end
-
-  it "should log a failure message if it cannot find sqlcmd in the standard places" do
-    any_sqlcmd_exists = false
-
-    @all_possible_sqlcmd_paths.each do |sqlcmd_path|
-      sqlcmd_exists = File.exists?(sqlcmd_path)
-      any_sqlcmd_exists = true if File.exists?(sqlcmd_path)
-    end
-    @log_data.should include('SQLCmd.command cannot be nil.') if any_sqlcmd_exists == false
-  end
-end
-
-describe SQLCmd, "when execution of sqlcmd fails" do
-  before :all do
-    strio = StringIO.new
-    @cmd = SQLCmd.new
-    @cmd.command="sqlcmd.exe"
-    @cmd.log_level = :verbose
-    @cmd.log_device = strio
-    @cmd.extend(SystemPatch)
-    @cmd.extend(FailPatch)
-    @cmd.disable_system = true
-    @cmd.force_system_failure = true
-    
-    @cmd.execute
-    @log_data = strio.string
-  end
-  
-  
-  it "should fail" do
-    $task_failed.should be_true
-  end
-  
-  it "should log a failure message" do
-    @log_data.should include('SQLCmd Failed. See Build Log For Detail.')
-  end
-end
-
-describe SQLCmd, "when running multiple script files" do
-  before :all do
-    @cmd = SQLCmd.new
-    @cmd.command = "sqlcmd.exe"
-    @cmd.log_level = :verbose
-    @cmd.extend(SystemPatch)
-    @cmd.disable_system = true
-    
-    scriptnames = Array.new
-    scriptnames << "did you get.sql\r\n"
-    scriptnames << "that thing.sql"
-    scriptnames << "i sent you.sql\r\n"
-    @cmd.scripts = scriptnames
-    
-    @cmd.execute
-  end
-  
-  it "should specify the first script file" do
-    @cmd.system_command.should include("-i \"did you get.sql\"")
-  end
-
-  it "should specify the second script file" do
-    @cmd.system_command.should include("-i \"that thing.sql\"")
-  end
-  
-  it "should specify the third script file" do
-    @cmd.system_command.should include("-i \"i sent you.sql\"")
-  end
-  
-  it "should include the -b option" do
-    @cmd.system_command.should include("-b")
-  end
-  
-end
-
-describe SQLCmd, "when running multiple script files with batch_abort set to false" do
-  before :all do
-    @cmd = SQLCmd.new
-    @cmd.command = "sqlcmd.exe"
-    @cmd.log_level = :verbose
-    @cmd.extend(SystemPatch)
-    @cmd.disable_system = true
-    @cmd.batch_abort = false
-    
-    scriptnames = Array.new
-    scriptnames << "did you get.sql\r\n"
-    scriptnames << "that thing.sql"
-    scriptnames << "i sent you.sql\r\n"
-    @cmd.scripts = scriptnames
-    
-    @cmd.execute
-  end
-  
-  it "should specify the first script file" do
-    @cmd.system_command.should include("-i \"did you get.sql\"")
-  end
-
-  it "should specify the second script file" do
-    @cmd.system_command.should include("-i \"that thing.sql\"")
-  end
-  
-  it "should specify the third script file" do
-    @cmd.system_command.should include("-i \"i sent you.sql\"")
-  end
-  
-  it "should not include the -b option" do
-    @cmd.system_command.should_not include("-b")
-  end
-  
-end
-
-describe SQLCmd, "when running with variables specified" do
-  before :all do
-    @cmd = SQLCmd.new
-    @cmd.command = "sqlcmd.exe"
-    @cmd.log_level = :verbose
-    @cmd.extend(SystemPatch)
-    @cmd.disable_system = true
-    @cmd.scripts "somescript.sql"
-    
-    @cmd.variables :myvar => "my value", :another_var => :another_value
-    
-    @cmd.execute
-  end
-  
-  it "should supply the variables to sqlcmd" do
-    @cmd.system_command.should include("-v myvar=my value")
-    @cmd.system_command.should include("-v another_var=another_value")
-  end
-end
-
-describe SQLCmd, "when providing configuration" do
-  let :sqlcmd do
-    Albacore.configure do |config|
-      config.sqlcmd.command = "configured"
-    end
-    sqlcmd = SQLCmd.new
-  end
-
-  it "should use the configured values" do
-    sqlcmd.command.should == "configured"
-  end
-end
-
-describe SQLCmd, "when severity it set" do
-  before :all do
-    @cmd = SQLCmd.new
-    @cmd.extend(SystemPatch)
-    @cmd.disable_system = true
-    @cmd.scripts "somescript.sql"
-
-    @cmd.severity = 1
-    
-    @cmd.execute
-  end
-
-  it "should have severity option set" do
-    @cmd.system_command.should include("-V")
-  end
-  it "should have severity set to correct value" do
-    @cmd.system_command.should include("-V \"1\"")
-  end
-end    
+require "spec_helper"
+
+describe SQLCmd do
+  subject(:task) do
+    task = SQLCmd.new
+    task.extend(SystemPatch)
+    task.command = "sqlcmd"
+    task.server = "server"
+    task.database = "database"
+    task.username = "user"
+    task.password = "password"
+    task.severity = 1
+    task.scripts = ["a.sql", "b.sql"]
+    task.variables = {:foo => "foo", :bar => "bar"}
+    task.batch_abort
+    task.ignore_variables
+    task.trusted_connection
+    task
+  end
+
+  let(:cmd) { task.system_command }
+
+  before :each do
+    task.execute
+  end
+
+  it "should use the command" do
+    cmd.should include("sqlcmd")
+  end
+  
+  it "should use the server" do
+    cmd.should include("-S \"server\"")
+  end
+  
+  it "should use the database" do
+    cmd.should include("-d \"database\"")
+  end
+
+  it "should set batch abort" do
+    cmd.should include("-b")
+  end
+
+  it "should run the scripts" do
+    cmd.should include("-i \"a.sql\" -i \"b.sql\"")
+  end
+  
+  it "should set the variables" do
+    cmd.should include("-v foo=\"foo\" -v bar=\"bar\"")
+  end
+
+  it "should set the username and password" do
+    cmd.should include("-U \"user\" -P \"password\"")
+  end
+  
+  it "should be severe" do
+    cmd.should include("-V 1")
+  end
+  
+  it "should ignore variables" do 
+    cmd.should include("-x")
+  end
+  
+  it "should use a trusted connection" do 
+    cmd.should include("-E")
+  end
+end