rubycut-babushka 0.10.8 → 0.15.6.1

data/spec/babushka/source_spec.rb

@@ -19,22 +19,20 @@ describe Source do
     it "should label nil paths as implicit" do
       Source.discover_uri_and_type(nil).should == [nil, :implicit]
     end
-    it "should treat URLs containing auth info as private" do
+    it "should treat git:// as public" do
       [
-        'http://ben@server.org/benhoskings/babushka.git',
-        'https://ben:secret@server.org/benhoskings/babushka.git'
+        'git://github.com/benhoskings/babushka-deps.git',
       ].each {|uri|
-        Source.discover_uri_and_type(uri).should == [uri, :private]
+        Source.discover_uri_and_type(uri).should == [uri, :public]
       }
     end
-    it "should treat git:// and friends as public" do
+    it "should treat other protocols as private" do
       [
-        'git://github.com/benhoskings/babushka-deps.git',
         'http://github.com/benhoskings/babushka-deps.git',
         'https://github.com/benhoskings/babushka-deps.git',
         'file:///Users/ben/babushka/deps'
       ].each {|uri|
-        Source.discover_uri_and_type(uri).should == [uri, :public]
+        Source.discover_uri_and_type(uri).should == [uri, :private]
       }
     end
     it "should treat ssh-style URLs as private" do
@@ -96,6 +94,52 @@ describe Source do
     end
   end
 
+  describe Source, '#cloneable?' do
+    it "should work for implicit sources" do
+      Source.new(nil).should_not be_cloneable
+    end
+    it "should work for local sources" do
+      Source.new('~/.babushka/deps').should_not be_cloneable
+    end
+    it "should work for public sources" do
+      Source.new('git://github.com/benhoskings/babushka-deps.git').should be_cloneable
+    end
+    it "should work for private sources" do
+      Source.new('git@github.com:benhoskings/babushka-deps.git').should be_cloneable
+    end
+  end
+
+  describe "#cloned?" do
+    it "should return false for implicit sources" do
+      Source.new(nil).should_not be_cloned
+    end
+    it "should return false for local sources" do
+      Source.new(nil).should_not be_cloned
+    end
+    context "for cloneable repos" do
+      subject { Source.new(*@remote_2) }
+      it "should not be cloned" do
+        subject.should_not be_cloned
+      end
+      it "should be cloned after loading" do
+        subject.load!
+        subject.should be_cloned
+      end
+      after {
+        subject.path.rm
+      }
+    end
+  end
+
+  describe '#clear!' do
+    let(:source) { Source.new(nil) }
+    it "should clear the deps and templates" do
+      source.deps.should_receive(:clear!)
+      source.templates.should_receive(:clear!)
+      source.clear!
+    end
+  end
+
   describe "loading deps" do
     context "with a good source" do
       before {
@@ -108,7 +152,7 @@ describe Source do
       end
       it "should not have defined the deps" do
         dep = @source.deps.for('test dep 1')
-        dep.dep_defined?.should be_false
+        dep.context.should_not be_loaded
       end
       it "should store the source the dep was loaded from" do
         @source.deps.for('test dep 1').dep_source.should == @source
@@ -117,23 +161,22 @@ describe Source do
     context "with a source with errors" do
       before {
         @source = Source.new('spec/deps/bad')
-        @source.load!
       }
-      it "should recover from load errors" do
-        @source.deps.names.should include('broken test dep 1')
-        @source.deps.names.should include('test dep 1')
+      it "should raise an error" do
+        expect { @source.load! }.to raise_error(Babushka::SourceLoadError)
+        @source.deps.count.should == 0
       end
     end
   end
 
   describe "loading deps with parameters" do
     let(:source) { Source.new('spec/deps/params').tap(&:load!) }
-    let(:requires) { source.deps.for('top-level dep with params').context.requires }
+    let(:requires) { source.deps.for('top-level dep with params').context.define!.requires }
     it "should store the right number of requirements" do
       requires.length.should == 2
     end
     it "should store the right kinds of objects" do
-      requires.map(&:class).should == [String, Babushka::Dep::Requirement]
+      requires.map(&:class).should == [String, Babushka::DepRequirement]
     end
     it "should store string requirements properly" do
       requires.first.should == 'a dep without params'
@@ -165,7 +208,7 @@ describe Source do
         @dep = @source.deps.for('test dep 1')
       }
       it "should not have defined the deps" do
-        @dep.dep_defined?.should == nil
+        @dep.context.should_not be_loaded
       end
     end
   end
@@ -183,6 +226,7 @@ describe Source do
   end
 
   describe Source, ".for_path" do
+    let(:source) { Source.for_path(source_path) }
     context "on a file" do
       before {
         `mkdir -p "#{tmp_prefix / 'sources'}"`
@@ -195,39 +239,48 @@ describe Source do
       end
     end
     context "on a dir" do
+      let(:source_path) { tmp_prefix / 'ad_hoc_source' }
       before {
         `mkdir -p "#{tmp_prefix / 'ad_hoc_source'}"`
-        @source = Source.for_path(tmp_prefix / 'ad_hoc_source')
       }
       it "should work on a dir" do
-        @source.should be_present
-        @source.path.should == tmp_prefix / 'ad_hoc_source'
-        @source.name.should == 'ad_hoc_source'
+        source.should be_present
+        source.path.should == tmp_prefix / 'ad_hoc_source'
+        source.name.should == 'ad_hoc_source'
+      end
+      it "should cache the source" do
+        Source.for_path(source_path).object_id.should == Source.for_path(source_path).object_id
       end
     end
     context "on a git repo" do
+      let(:source_path) { Source.source_prefix / 'remote_1' }
       before {
         Source.new(@remote_1.first).add!
-        @source = Source.for_path(Source.source_prefix / 'remote_1')
       }
       it "should work on a git repo" do
-        @source.should be_present
-        @source.path.should == Source.source_prefix / 'remote_1'
-        @source.name.should == 'remote_1'
+        source.should be_present
+        source.path.should == Source.source_prefix / 'remote_1'
+        source.name.should == 'remote_1'
+      end
+      it "should cache the source" do
+        Source.for_path(source_path).object_id.should == Source.for_path(source_path).object_id
       end
-      after { @source.remove! }
+      after { source.remove! }
     end
     context "on a git repo with a custom name" do
+      let(:source_path) { Source.source_prefix / 'custom_name_test' }
       before {
         Source.new(@remote_1.first, :name => 'custom_name_test').add!
-        @source = Source.for_path(Source.source_prefix / 'custom_name_test')
       }
       it "should work on a git repo" do
-        @source.should be_present
-        @source.path.should == Source.source_prefix / 'custom_name_test'
-        @source.name.should == 'custom_name_test'
+        source.should be_present
+        source.path.should == Source.source_prefix / 'custom_name_test'
+        source.name.should == 'custom_name_test'
       end
-      after { @source.remove! }
+      it "should cache the source" do
+        Source.for_path(source_path).object_id.should == Source.for_path(source_path).object_id
+      end
+      after { source.remove! }
     end
   end
 
@@ -241,7 +294,7 @@ describe Source do
       @source.deps.items.include?(@source.find('test dep 1')).should be_true
     end
     it "should find the specified template" do
-      @source.find_template('test_meta_1').should be_an_instance_of(MetaDep)
+      @source.find_template('test_meta_1').should be_an_instance_of(DepTemplate)
       @source.templates.items.include?(@source.find_template('test_meta_1')).should be_true
     end
   end
@@ -252,7 +305,7 @@ describe Source do
         Source.new('spec/deps/good').should be_present
       end
       it "should be false for invalid paths" do
-        Source.new('spec/deps/nonexistent').should_not be_present
+        Source.new('spec/deps/missing').should_not be_present
       end
     end
     context "for remote repos" do
@@ -282,7 +335,7 @@ describe Source do
   describe "cloning" do
     context "unreadable sources" do
       before {
-        @source = Source.new(tmp_prefix / "nonexistent.git", :name => 'unreadable')
+        @source = Source.new(tmp_prefix / "missing.git", :name => 'unreadable')
         @source.add!
       }
       it "shouldn't work" do
@@ -318,9 +371,8 @@ describe Source do
           @nameless = Source.new(@remote_1.first)
         }
         it "should use the basename as the name" do
-          File.directory?(tmp_prefix / 'sources/remote_1').should be_false
+          GitHelpers.should_receive(:git).with(@remote_1.first, :to => (tmp_prefix / 'sources/remote_1'), :log => true)
           @nameless.add!
-          File.directory?(tmp_prefix / 'sources/remote_1').should be_true
         end
         it "should set the name in the source" do
           @nameless.name.should == 'remote_1'
@@ -379,14 +431,45 @@ describe Source do
     end
   end
 
-  describe "classification" do
-    it "should treat file:// as public" do
-      (source = Source.new(*@remote_1)).add!
-      [source.uri, source.name, source.type].should == [@remote_1.first, 'remote_1', :public]
-    end
-    it "should treat local paths as local" do
-      (source = Source.new(@remote_1.first.gsub(/^file:\/\//, ''), @remote_1.last)).add!
-      [source.uri, source.name, source.type].should == [@remote_1.first.gsub(/^file:\/\//, ''), 'remote_1', :local]
+  describe "updating" do
+    before {
+      @source = Source.new(*@remote_2)
+    }
+    it "should update when the source isn't cloned" do
+      @source.should_receive(:update!)
+      @source.load!
+    end
+    it "should not update when the source is already cloned" do
+      @source.stub!(:cloned?).and_return(true)
+      @source.should_not_receive(:update!)
+      @source.load!
+    end
+    it "should update when the source is already cloned and update is true" do
+      @source.stub!(:cloned?).and_return(true)
+      @source.should_receive(:update!)
+      @source.load!(true)
+    end
+  end
+
+  describe '#remove!' do
+    it "should not delete a non-cloneable source" do
+      source = Source.new('spec/deps/good')
+      source.path.should_not_receive(:rm)
+      source.remove!
+    end
+    it "should not delete a nonexistent source" do
+      source = Source.new('spec/deps/nonexistent')
+      source.path.should_not_receive(:rm)
+      source.remove!
+    end
+    context 'on a cloneable source' do
+      let(:source) { Source.new(*@remote_2) }
+
+      it "should delete the source" do
+        source.path.should_receive(:rm)
+        source.update!
+        source.remove!
+      end
     end
   end
 end

data/spec/babushka/source_support.rb

@@ -4,7 +4,7 @@ def make_source_remote name = 'test'
   ["file://#{tmp_prefix / 'source_remotes' / name}", {:name => name}].tap {|source|
     source_path = source.first.gsub(/^file:\/\//, '')
     unless File.exists? source_path / '.git'
-      shell %Q{
+      ShellHelpers.shell %Q{
         mkdir -p "#{source_path}" &&
         cd "#{source_path}" &&
         git init &&

data/spec/babushka/system_profile_spec.rb

@@ -1,61 +1,98 @@
 require 'spec_helper'
 
-describe Babushka::SystemProfile, '.for_host' do
-  it "should return OSXSystemProfile on Darwin boxes" do
-    Babushka::SystemProfile.should_receive(:shell).with("uname -s").and_return("Darwin")
-    Babushka::SystemProfile.for_host.should be_an_instance_of(Babushka::OSXSystemProfile)
-  end
-  it "should return nil on unknown boxes" do
-    Babushka::SystemProfile.should_receive(:shell).with("uname -s").and_return("LolOS")
-    Babushka::SystemProfile.for_host.should be_nil
-  end
-  context "on BSD boxes" do
-    it "should return DragonFlySystemProfile on Dragonfly boxes" do
-      Babushka::SystemProfile.should_receive(:shell).with("uname -s").and_return("DragonFly")
-      Babushka::SystemProfile.for_host.should be_an_instance_of(Babushka::DragonFlySystemProfile)
+describe Babushka::SystemProfile do
+  subject {
+    Babushka::SystemDetector.profile_for_host
+  }
+
+  describe '#cpu_type' do
+    it "should return the type reported by `uname`" do
+      subject.should_receive(:shell).with('uname -m').and_return('x86')
+      subject.cpu_type.should == 'x86'
     end
-    it "should return FreeBSDSystemProfile on FreeBSD boxes" do
-      Babushka::SystemProfile.should_receive(:shell).with("uname -s").and_return("FreeBSD")
-      Babushka::SystemProfile.for_host.should be_an_instance_of(Babushka::FreeBSDSystemProfile)
+    it "should substitute 'x86_64' for 'amd64'" do
+      subject.should_receive(:shell).with('uname -m').and_return('amd64')
+      subject.cpu_type.should == 'x86_64'
     end
   end
-  context "on Linux boxes" do
-    before {
-      Babushka::SystemProfile.should_receive(:shell).with("uname -s").and_return("Linux")
-      File.stub!(:exists?).and_return(false)
-    }
-    it "should return DebianSystemProfile on Debian boxes" do
-      File.should_receive(:exists?).with("/etc/debian_version").and_return(true)
-      Babushka::AptHelper.stub!(:install!) # so an `lsb_release` install isn't attempted
-      Babushka::SystemProfile.for_host.should be_an_instance_of(Babushka::DebianSystemProfile)
-    end
-    it "should return RedhatSystemProfile on Red Hat boxes" do
-      File.should_receive(:exists?).with("/etc/redhat-release").and_return(true)
-      Babushka::SystemProfile.for_host.should be_an_instance_of(Babushka::RedhatSystemProfile)
-    end
-    it "should return LinuxSystemProfile on unknown Linux boxes" do
-      Babushka::SystemProfile.for_host.class.should == Babushka::LinuxSystemProfile
-    end
-    it "should return a proper description on unknown Linux boxes" do
-      Babushka::SystemProfile.for_host.description.should == "Linux unknown"
+
+  describe SystemProfile, '#public_ip' do
+    context "on OS X" do
+      before {
+        ShellHelpers.should_receive(:shell).with("uname -s").and_return("Darwin")
+        subject.should_receive(:shell).with('netstat -nr').and_return("
+Routing tables
+
+Internet:
+Destination        Gateway            Flags        Refs      Use   Netif Expire
+default            10.0.1.1           UGSc           17        0     en0
+10.0.1/24          link#4             UCS             3        0     en0
+10.0.1.1           0:24:36:9e:85:7a   UHLWIi         16        3     en0    621
+10.0.1.30          7c:c5:37:39:66:3e  UHLWIi          0     8397     en0    686
+10.0.1.31          127.0.0.1          UHS             0        0     lo0
+127                127.0.0.1          UCS             0        0     lo0
+127.0.0.1          127.0.0.1          UH              3    43559     lo0
+169.254            link#4             UCS             0        0     en0
+
+Internet6:
+Destination                             Gateway                         Flags         Netif Expire
+::1                                     link#1                          UHL             lo0
+fe80::%lo0/64                           fe80::1%lo0                     UcI             lo0
+fe80::1%lo0                             link#1                          UHLI            lo0
+fe80::%en0/64                           link#4                          UCI             en0
+fe80::21f:f3ff:fe05:4659%en0            0:1f:f3:5:46:59                 UHLWIi          en0
+fe80::223:6cff:fe82:3451%en0            0:23:6c:82:34:51                UHLWIi          en0
+fe80::62c5:47ff:fe03:5238%en0           60:c5:47:3:52:38                UHLWIi          en0
+fe80::62c5:47ff:fe03:5b6a%en0           60:c5:47:3:5b:6a                UHLI            lo0
+fe80::6aa8:6dff:fe08:6ea2%en0           68:a8:6d:8:6e:a2                UHLWIi          en0
+fe80::e6ce:8fff:fe17:53c%en0            e4:ce:8f:17:5:3c                UHLWIi          en0
+ff01::%lo0/32                           fe80::1%lo0                     UmCI            lo0
+ff01::%en0/32                           link#4                          UmCI            en0
+ff02::%lo0/32                           fe80::1%lo0                     UmCI            lo0
+ff02::%en0/32                           link#4                          UmCI            en0
+ff02::fb%en0                            link#4                          UHmW3I          en0    350
+        ")
+        subject.should_receive(:shell).with('ifconfig', 'en0').and_return("
+en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500
+	ether 60:c5:47:03:5b:6a
+	inet6 fe80::62c5:47ff:fe03:5b6a%en0 prefixlen 64 scopeid 0x4
+	inet 10.0.1.31 netmask 0xffffff00 broadcast 10.0.1.255
+	media: autoselect
+	status: active
+        ")
+      }
+      it "should return the correct IP" do
+        subject.public_ip.should == '10.0.1.31'
+      end
     end
-    context "version matching" do
+
+    context "on Linux" do
       before {
-        File.should_receive(:exists?).with("/etc/debian_version").and_return(true)
-        @profile = Babushka::SystemProfile.for_host
-        @profile.should_receive(:ensure_lsb_release).and_return(true)
-        @profile.should_receive(:shell).with("lsb_release -a").and_return(%Q{
-          No LSB modules are available.
-          Distributor ID:	Debian
-          Description:	Debian GNU/Linux 6.0.1 (squeeze)
-          Release:	6.0.1
-          Codename:	squeeze
-        }.strip)
+        ShellHelpers.should_receive(:shell).with("uname -s").and_return("Linux")
+        subject.should_receive(:shell).with('netstat -nr').and_return("
+Kernel IP routing table
+Destination     Gateway         Genmask         Flags   MSS Window  irtt Iface
+49.156.17.0     0.0.0.0         255.255.255.0   U         0 0          0 eth0
+10.0.0.0        0.0.0.0         255.0.0.0       U         0 0          0 eth1
+0.0.0.0         49.156.17.1     0.0.0.0         UG        0 0          0 eth0
+        ")
+        subject.should_receive(:shell).with('ifconfig', 'eth0').and_return("
+eth0      Link encap:Ethernet  HWaddr 00:16:31:9c:11:ad
+          inet addr:49.156.17.173  Bcast:49.156.17.255  Mask:255.255.255.0
+          inet6 addr: fe80::216:31ff:fe9c:11ad/64 Scope:Link
+          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
+          RX packets:1314347 errors:0 dropped:0 overruns:0 frame:0
+          TX packets:743081 errors:0 dropped:0 overruns:0 carrier:0
+          collisions:0 txqueuelen:1000
+          RX bytes:1044706658 (1.0 GB)  TX bytes:96454071 (96.4 MB)
+          Interrupt:16
+        ")
       }
-      it "should detect debian squeeze" do
-        @profile.match_list.should == [:squeeze, :debian, :apt, :linux, :all]
-        @profile.version.should == '6.0.1'
+      it "should return the correct IP" do
+        subject.public_ip.should == '49.156.17.173'
       end
     end
+
   end
+
 end

data/spec/babushka/task_spec.rb

@@ -16,7 +16,7 @@ describe Task, "process" do
       Dep('task spec').should_receive(:process)
     }
     it "should run a dep when just the name is passed" do
-      Base.task.process ['task spec']
+      Base.task.process ['task spec'], {}
     end
   end
   describe "variable assignment" do
@@ -33,22 +33,22 @@ describe Task, "process" do
   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']
+      the_dep = dep('task spec arg passing, no args')
+      the_dep.should_receive(:with).with({}).and_return(the_dep)
+      the_dep.should_receive(:process)
+      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})
+      the_dep = dep('task spec arg passing, 1 arg', :arg)
+      the_dep.should_receive(:with).with({:arg => 'something argy'}).and_return(the_dep)
+      the_dep.should_receive(:process)
       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)
+      the_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})
+      the_dep.should_receive(:with).with({:expected => 'something argy'}).and_return(the_dep)
+      the_dep.should_receive(:process)
       Base.task.process ['task spec arg passing, unexpected arg'], {'expected' => 'something argy', 'unexpected' => 'nobody expects the Spanish arg!'}
     end
   end
@@ -57,6 +57,73 @@ describe Task, "process" do
   }
 end
 
+describe Task, 'caching' do
+  it "should not cache outside a #cache block" do
+    counter = 0
+    Base.task.cached(:not_caching) { counter += 1 }
+    Base.task.cached(:not_caching) { counter += 1 }
+    counter.should == 2
+  end
+  it "should not yield #hit on a cache miss" do
+    hit = false
+    Base.task.cache {
+      Base.task.cached(:key_miss, :hit => lambda{ hit = true }) {
+        'a miss'
+      }.should == 'a miss'
+    }
+    hit.should be_false
+  end
+  it "should yield #hit on a cache hit" do
+    hit = false
+    Base.task.cache {
+      Base.task.cached(:key_hit) { 'a hit' }
+      Base.task.cached(:key_hit, :hit => lambda{|value| hit = value })
+    }
+    hit.should == 'a hit'
+  end
+  it "should maintain the cached value" do
+    result = nil
+    Base.task.cache {
+      Base.task.cached(:key_another_hit) { 'another hit' }
+      result = Base.task.cached(:key_another_hit) { 'a replacement' }
+    }
+    result.should == 'another hit'
+  end
+end
+
+describe Task, 'dep caching' do
+  before {
+    dep 'caching child b', :arg_b1, :arg_b2
+    dep 'caching child c', :arg_c1
+    dep 'caching child a', :arg_a do
+      requires 'caching child b'.with(:arg_b2 => 'a value')
+      requires 'caching child c'.with('some value')
+    end
+    dep 'caching parent' do
+      requires 'caching child a'
+      requires 'caching child b'.with('more', 'values')
+      requires 'caching child c'.with('some value')
+    end
+  }
+  it "should run the deps the right number of times" do
+    Dep('caching parent').should_receive(:process_self).once
+    Dep('caching child a').should_receive(:process_self).once.and_return(true)
+    Dep('caching child b').should_receive(:process_self).twice.and_return(true)
+    Dep('caching child c').should_receive(:process_self).once.and_return(true)
+    Base.task.process ['caching parent'], {}
+  end
+  it "should cache the dep requirements" do
+    Base.task.process ['caching parent'], {}
+    Base.task.caches.should == {
+      DepRequirement.new('caching parent', []) => true,
+      DepRequirement.new('caching child a', [nil]) => true,
+      DepRequirement.new('caching child b', [nil, 'a value']) => true,
+      DepRequirement.new('caching child b', ['more', 'values']) => true,
+      DepRequirement.new('caching child c', ['some value']) => true
+    }
+  end
+end
+
 describe Task, "saved vars" do
   before {
     Base.task.vars.stub!(:saved_vars).and_return(Hashish.hash.merge(
@@ -74,6 +141,7 @@ end
 
 describe Task, "vars_for_save" do
   before {
+    Base.task.process [], {} # Clear out Base.task.vars
     Base.task.vars.stub!(:vars).and_return(standard_vars)
     @vars_for_save = Base.task.vars.for_save
   }
@@ -99,10 +167,9 @@ describe Task, "vars_for_save" 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 == []
+      (@vars_for_save.keys - Base.task.vars.for_save.keys).should == []
     end
   end
   describe "referred values" do