rubycut-babushka 0.10.6

data/spec/babushka/task_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'source_support'
+
+standard_vars = {
+  "rails_root" => {:default => "~/current", :value => "~/projects/corkboard/current"},
+  "extra_domains" => {:default => "", :value => ""},
+  "username" => {:default => "ben"},
+  "versions" => {:value => {:nginx => "0.7.61", :upload_module => "2.0.9"}},
+  "vhost_type" => {:default => "passenger", :value => "passenger"}
+}
+
+describe Task, "process" do
+  describe "with a dep name" do
+    before {
+      dep 'task spec'
+      Dep('task spec').should_receive(:process)
+    }
+    it "should run a dep when just the name is passed" do
+      Base.task.process ['task spec']
+    end
+  end
+  describe "variable assignment" do
+    it "should set the values in with_vars as vars" do
+      var_value = nil
+      dep 'task spec with_vars' do
+        met? {
+          var_value = var(:task_var)
+        }
+      end
+      Base.task.process ['task spec with_vars'], {'task_var' => 'something tasky'}
+      var_value.should == 'something tasky'
+    end
+  end
+  describe "argument assignment" do
+    it "should work when with_vars contains no arguments" do
+      @dep = dep('task spec arg passing, no args')
+      @dep.should_receive(:with).with({}).and_return(@dep)
+      @dep.should_receive(:process).with({:top_level => true})
+      Base.task.process ['task spec arg passing, no args']
+    end
+    it "should provide the values in with_vars as dep arguments with symbol names" do
+      @dep = dep('task spec arg passing, 1 arg', :arg)
+      @dep.should_receive(:with).with({:arg => 'something argy'}).and_return(@dep)
+      @dep.should_receive(:process).with({:top_level => true})
+      Base.task.process ['task spec arg passing, 1 arg'], {'arg' => 'something argy'}
+    end
+    it "should print a warning about unexpected arguments, and not pass them to Dep#with" do
+      @dep = dep('task spec arg passing, unexpected arg', :expected)
+      Base.task.should_receive(:log_warn).with(%{Ignoring unexpected argument "unexpected", which the dep 'task spec arg passing, unexpected arg' would reject.})
+      @dep.should_receive(:with).with({:expected => 'something argy'}).and_return(@dep)
+      @dep.should_receive(:process).with({:top_level => true})
+      Base.task.process ['task spec arg passing, unexpected arg'], {'expected' => 'something argy', 'unexpected' => 'nobody expects the Spanish arg!'}
+    end
+  end
+  after {
+    Base.task.vars.saved_vars.clear
+  }
+end
+
+describe Task, "saved vars" do
+  before {
+    Base.task.vars.stub!(:saved_vars).and_return(Hashish.hash.merge(
+      'domain' => {:value => "lol.org"}
+    ))
+    Base.task.vars.stub!(:vars).and_return(Hashish.hash.merge(
+      'domain' => {:default => :username},
+      'username' => {:default => 'ben'}
+    ))
+  }
+  it "should return the saved value over the set default" do
+    Base.task.vars.var(:domain, :ask => false).should == 'lol.org'
+  end
+end
+
+describe Task, "vars_for_save" do
+  before {
+    Base.task.vars.stub!(:vars).and_return(standard_vars)
+    @vars_for_save = Base.task.vars.for_save
+  }
+  it "should create a saved_var for every var" do
+    (Base.task.vars.vars.keys - @vars_for_save.keys).should == []
+  end
+  describe "rejecting invalid input" do
+    before {
+      Base.task.vars.stub!(:vars).and_return(standard_vars.merge({
+        "www_aliases" => {:default => L{ 'stub' }, :value => "www.test3.org"},
+        "db_password" => {:value => 'sekret'}
+      }))
+      @vars_for_save = Base.task.vars.for_save
+    }
+    it "should exclude invalid data types" do
+      @vars_for_save['www_aliases'].has_key?(:default).should be_false
+    end
+    it "should reject passwords" do
+      @vars_for_save.has_key?('db_password').should be_false
+    end
+  end
+  describe "subsequent saves" do
+    before {
+      Base.task.vars.stub!(:saved_vars).and_return(standard_vars)
+      Base.task.vars.stub!(:vars).and_return(standard_vars.reject {|k,v| %w[username versions vhost_type].include? k })
+      @new_vars_for_save = Base.task.vars.for_save
+    }
+    it "should preserve old values" do
+      (@vars_for_save.keys - @new_vars_for_save.keys).should == []
+    end
+  end
+  describe "referred values" do
+    before {
+      Base.task.vars.stub!(:vars).and_return(standard_vars.merge({
+        "domain" => {:default => :username, :value => "test3.org"},
+        "db_domain" => {:default => :domain},
+        "db_name" => {:default => :username, :value => 'corkboard'},
+        "db_user" => {:default => :db_name, :value => 'corkboard_user'},
+        "app_name" => {:default => :username},
+        "rake_root" => {:default => :rails_root},
+        "static_root" => {:default => :rails_root, :value => "~/projects/corkboard/current/static"}
+      }))
+      @vars_for_save = Base.task.vars.for_save
+    }
+    it "should create saved_vars" do
+      %w[domain db_name db_user rake_root static_root].each {|key|
+        @vars_for_save.has_key?(key).should be_true
+      }
+    end
+    it "should not create a :value" do
+      %w[domain db_name db_user rake_root static_root].each {|key|
+        @vars_for_save[key].has_key?(:value).should be_false
+      }
+    end
+    it "should store the referenced var's value in :values" do
+      @vars_for_save['domain'][:values].should == {nil => 'test3.org'}
+      @vars_for_save['db_domain'][:values].should == {}
+      @vars_for_save['db_name'][:values].should == {nil => 'corkboard'}
+      @vars_for_save['db_user'][:values].should == {'corkboard' => 'corkboard_user'}
+      @vars_for_save['app_name'][:values].should == {}
+      @vars_for_save['rake_root'][:values].should == {}
+      @vars_for_save['static_root'][:values].should == {'~/projects/corkboard/current' => '~/projects/corkboard/current/static'}
+    end
+  end
+end

data/spec/babushka/uri_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe URI, "escaping" do
+  it "should escape URLs" do
+    URI.escape("http://babushka.me/babushka snapshot.tgz").should == "http://babushka.me/babushka%20snapshot.tgz"
+  end
+  it "should not escape twice" do
+    URI.escape("http://babushka.me/babushka%20snapshot.tgz").should == "http://babushka.me/babushka%20snapshot.tgz"
+  end
+  it "should handle partially escaped urls" do
+    URI.escape("http://babushka.me/ok this is%20just%20a mess.tgz").should == "http://babushka.me/ok%20this%20is%20just%20a%20mess.tgz"
+  end
+end

data/spec/babushka/vars_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Vars do
+  before {
+    Base.task.vars.define_var :username, :default => shell('whoami')
+    Base.task.vars.define_var :domain, :default => :username
+    Base.task.vars.define_var :db_name
+    Base.task.vars.define_var :test_user, :default => :db_name
+    Base.task.vars.set :nginx_version, '0.7.64'
+  }
+  describe "without values" do
+    it "should return a direct value" do
+      Base.task.vars.var(:nginx_version).should == '0.7.64'
+    end
+    it "should return a direct default" do
+      Base.task.vars.default_for(:username).should == `whoami`.chomp
+    end
+    it "should return a referenced default" do
+      Base.task.vars.default_for(:domain).should == `whoami`.chomp
+    end
+    it "should return nothing when no default is set" do
+      Base.task.vars.default_for(:db_name).should be_nil
+    end
+    it "should return nothing when no default is set on the referred var" do
+      Base.task.vars.default_for(:test_user).should be_nil
+    end
+  end
+  describe "with values" do
+    before {
+      Base.task.vars.set :username, 'bob'
+      Base.task.vars.set :db_name, 'bobs_database'
+    }
+    it "should return a direct value, overriding default" do
+      Base.task.vars.var(:username).should == 'bob'
+    end
+    it "should return a referenced value as a default" do
+      Base.task.vars.default_for(:domain).should == 'bob'
+    end
+    it "should return a direct value when there is no default" do
+      Base.task.vars.var(:db_name).should == 'bobs_database'
+    end
+    it "should return a referenced value when there is no referenced default" do
+      Base.task.vars.default_for(:test_user).should == 'bobs_database'
+    end
+  end
+  describe "with values" do
+    before {
+      Base.task.vars.set :username, 'bob'
+      Base.task.vars.set :db_name, 'bobs_database'
+      Base.task.vars.set :test_user, 'senor_bob'
+    }
+    it "should return a direct value when there is no default" do
+      Base.task.vars.var(:db_name).should == 'bobs_database'
+    end
+    it "should return a direct value, overriding the referenced default" do
+      Base.task.vars.default_for(:test_user).should == 'bobs_database'
+    end
+  end
+end

data/spec/babushka/version_of_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+def version_of *args
+  Babushka::VersionOf::Helpers.VersionOf *args
+end
+
+describe "creation" do
+  it "should store name" do
+    version_of('ruby').name.should == 'ruby'
+  end
+  it "should accept versions, optionally" do
+    version_of('ruby').version.should == nil
+    version_of('ruby', '1.8').version.to_s.should == '1.8'
+    version_of('ruby', '1.8'.to_version).version.to_s.should == '1.8'
+  end
+  it "should accept name & version in one string" do
+    version_of('ruby 1.8').version.to_s.should == '1.8'
+    version_of('ruby >= 1.9').version.to_s.should == '>= 1.9'
+  end
+  it "should handle array args" do
+    version_of(['ruby', '1.8']).version.to_s.should == '1.8'
+  end
+  it "should accept existing VersionOf instances" do
+    version_of(version_of('ruby')).should == version_of('ruby')
+    version_of(version_of('ruby', '1.8')).should == version_of('ruby', '1.8')
+    version_of(version_of('ruby', '1.8'), '1.9').should == version_of('ruby', '1.9')
+  end
+end
+
+describe "to_s" do
+  describe "versionless" do
+    it "should be just the name" do
+      version_of('ruby').to_s.should == 'ruby'
+    end
+  end
+  describe "nameless" do
+    it "should be just the version" do
+      version_of(nil, '1.8').to_s.should == '1.8'
+    end
+  end
+  describe "versioned" do
+    it "should be separated with -" do
+      version_of('ruby', '1.8').to_s.should == 'ruby-1.8'
+    end
+  end
+end
+
+describe "equality" do
+  it "should compare to versionless strings" do
+    version_of('ruby'       ).should     == version_of('ruby')
+    version_of('ruby', '1.8').should_not == version_of('ruby')
+  end
+  it "should compare to versioned strings" do
+    version_of('ruby'       ).should_not == version_of('ruby', '1.8')
+    version_of('ruby', '1.8').should     == version_of('ruby', '1.8')
+    version_of('ruby', '1.8').should_not == version_of('ruby', '1.9')
+  end
+  it "should compare to versionless VersionOfs" do
+    version_of('ruby'       ).should     == version_of('ruby')
+    version_of('ruby', '1.8').should_not == version_of('ruby')
+  end
+  it "should compare to versioned VersionOfs" do
+    version_of('ruby'       ).should_not == version_of('ruby', '1.8')
+    version_of('ruby', '1.8').should     == version_of('ruby', '1.8')
+    version_of('ruby', '1.8').should_not == version_of('ruby', '1.9')
+  end
+end
+
+describe "comparisons" do
+  it "should fail when the names don't match" do
+    L{
+      version_of('ruby', '1.8') <=> version_of('mongo', '1.4.2')
+    }.should raise_error(ArgumentError, "You can't compare the versions of two different things (ruby, mongo).")
+  end
+  it "should defer to VersionStr#<=>" do
+    (version_of('ruby', '1.8') <=> version_of('ruby', '1.9')).should == -1
+    (version_of('ruby', '1.8') <=> version_of('ruby', '1.8')).should == 0
+    (version_of('ruby', '1.8.7') <=> version_of('ruby', '1.8')).should == 1
+    (version_of('ruby', '1.8.7') <=> version_of('ruby', '1.9.1')).should == -1
+  end
+end
+
+describe "matching" do
+  describe "against strings" do
+    it "should match all versions when unversioned" do
+      version_of('ruby').matches?('1.8').should be_true
+      version_of('ruby').matches?('1.9').should be_true
+    end
+    it "should only match the correct version" do
+      version_of('ruby', '1.8').matches?('1.8').should be_true
+      version_of('ruby', '1.9').matches?('1.8').should be_false
+      version_of('ruby', '>= 1.7').matches?('1.8').should be_true
+      version_of('ruby', '~> 1.8').matches?('1.9').should be_true
+      version_of('ruby', '~> 1.8').matches?('2.0').should be_false
+    end
+  end
+  describe "against VersionStrs" do
+    it "should match all versions when unversioned" do
+      version_of('ruby').matches?('1.8'.to_version).should be_true
+      version_of('ruby').matches?('1.9'.to_version).should be_true
+    end
+    it "should only match the correct version" do
+      version_of('ruby', '1.8').matches?('1.8'.to_version).should be_true
+      version_of('ruby', '1.9').matches?('1.8'.to_version).should be_false
+      version_of('ruby', '>= 1.7').matches?('1.8'.to_version).should be_true
+      version_of('ruby', '~> 1.8').matches?('1.9'.to_version).should be_true
+      version_of('ruby', '~> 1.8').matches?('2.0'.to_version).should be_false
+    end
+  end
+end

data/spec/babushka/version_str_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'version_str_support'
+
+def compare_with operator
+  pairs.zip(results[operator]).each {|pair,expected|
+    result = VersionStr.new(pair.first).send operator, VersionStr.new(pair.last)
+    it "#{pair.first} #{operator} #{pair.last}: #{result}" do
+      result.should == expected
+    end
+  }
+end
+
+%w[== != > < >= <= ~>].each do |operator|
+  describe operator do
+    compare_with operator
+  end
+end
+
+describe "comparing" do
+  it "should work with other VersionStrs" do
+    (VersionStr.new('0.3.1') > VersionStr.new('0.2.9')).should be_true
+  end
+  
+  it "should work with strings" do
+    (VersionStr.new('0.3.1') > '0.2.9').should be_true
+  end
+  
+  it "should treat word pieces as less than no piece" do
+    (VersionStr.new('3.0.0') > VersionStr.new('3.0.0.beta')).should be_true
+    (VersionStr.new('3.0.0') > VersionStr.new('3.0.0.beta1')).should be_true
+    (VersionStr.new('1.0.0') > VersionStr.new('1.0.0.rc.5')).should be_true
+  end
+
+  it "should compare word pieces alphabetically" do
+    (VersionStr.new('3.0.0.beta') < VersionStr.new('3.0.0.pre')).should be_true
+    (VersionStr.new('3.0.0.pre') < VersionStr.new('3.0.0.rc')).should be_true
+  end
+
+  it "should treat word pieces with a number as more than without one" do
+    (VersionStr.new('3.0.0.beta1') > VersionStr.new('3.0.0.beta')).should be_true
+  end
+
+  it "should compare number parts of word pieces numerically" do
+    (VersionStr.new('3.0.0.beta2') > VersionStr.new('3.0.0.beta1')).should be_true
+    (VersionStr.new('3.0.0.beta10') > VersionStr.new('3.0.0.beta1')).should be_true
+  end
+  
+  it "should allow for integers in strings and sort correctly" do
+    (VersionStr.new('3.0.0.beta12') > VersionStr.new('3.0.0.beta2')).should be_true
+    (VersionStr.new('R13B04') > VersionStr.new('R2B9')).should be_true
+  end
+end
+
+describe "parsing" do
+  it "should parse the version number" do
+    VersionStr.new('0.2').pieces.should == [0, 2]
+    VersionStr.new('0.3.10.2').pieces.should == [0, 3, 10, 2]
+    VersionStr.new('1.9.1-p243').pieces.should == [1, 9, 1, 'p', 243]
+    VersionStr.new('3.0.0.beta').pieces.should == [3, 0, 0, 'beta']
+    VersionStr.new('3.0.0.beta3').pieces.should == [3, 0, 0, 'beta', 3]
+    VersionStr.new('R13B04').pieces.should == ['R', 13, 'B', 4]
+  end
+  it "should parse the operator if supplied" do
+    v = VersionStr.new('>0.2')
+    v.pieces.should == [0, 2]
+    v.operator.should == '>'
+
+    v = VersionStr.new('>= 0.2')
+    v.pieces.should == [0, 2]
+    v.operator.should == '>='
+
+    v = VersionStr.new(' ~>  0.3.10.2')
+    v.pieces.should == [0, 3, 10, 2]
+    v.operator.should == '~>'
+  end
+  it "should convert = to ==" do
+    v = VersionStr.new('= 0.2')
+    v.pieces.should == [0, 2]
+    v.operator.should == '=='
+
+    v = VersionStr.new('== 0.2')
+    v.pieces.should == [0, 2]
+    v.operator.should == '=='
+  end
+  it "should ignore a leading 'v' for 'version'" do
+    v = VersionStr.new('V0.5.0')
+    v.pieces.should == [0, 5, 0]
+    v.operator.should == '=='
+
+    v = VersionStr.new('>= v1.9.2p180')
+    v.pieces.should == [1, 9, 2, 'p', 180]
+    v.operator.should == '>='
+  end
+  it "should reject invalid operators" do
+    L{
+      VersionStr.new('~ 0.2')
+    }.should raise_error(InvalidVersionOperator, "VersionStr.new('~ 0.2'): invalid operator '~'.")
+
+    L{
+      VersionStr.new('>> 0.2')
+    }.should raise_error(InvalidVersionOperator, "VersionStr.new('>> 0.2'): invalid operator '>>'.")
+  end
+  it "should reject bad version numbers" do
+    L{
+      VersionStr.new('0. 2')
+    }.should raise_error(InvalidVersionStr, "VersionStr.new('0. 2'): couldn't parse a version number.")
+
+    L{
+      VersionStr.new('0.2!')
+    }.should raise_error(InvalidVersionStr, "VersionStr.new('0.2!'): couldn't parse a version number.")
+  end
+end
+
+describe 'rendering' do
+  it "should render just the version number with no operator" do
+    VersionStr.new('0.3.1').to_s.should == '0.3.1'
+  end
+  it "should render the full string with an operator" do
+    VersionStr.new('= 0.3.1').to_s.should == '0.3.1'
+    VersionStr.new('== 0.3.1').to_s.should == '0.3.1'
+    VersionStr.new('~> 0.3.1').to_s.should == '~> 0.3.1'
+  end
+  it "should keep string pieces" do
+    VersionStr.new('3.0.0.beta').to_s.should == '3.0.0.beta'
+  end
+  it "should preserve the original formatting" do
+    VersionStr.new('1.8.7-p174-src').to_s.should == '1.8.7-p174-src'
+    VersionStr.new('3.0.0-beta').to_s.should == '3.0.0-beta'
+  end
+end