heirloom 0.3.1 → 0.4.0

data/spec/archive/reader_spec.rb

@@ -5,102 +5,113 @@ describe Heirloom do
   before do
     @sdb_mock = mock 'sdb'
     @config_mock = double 'config'
-    @logger_mock = double 'logger'
-    @config_mock.should_receive(:logger).and_return @logger_mock
+    @logger_stub = stub :debug => true
+    @config_mock.should_receive(:logger).and_return @logger_stub
     Heirloom::AWS::SimpleDB.should_receive(:new).and_return @sdb_mock
     @reader = Heirloom::Reader.new :config => @config_mock,
                                    :name   => 'tim',
                                    :id     => '123'
   end
 
-  it "should show the item record" do
-    @sdb_mock.should_receive(:select).
-             with("select * from tim where itemName() = '123'").
-             and_return( { '123' => { 'value' => [ 'details' ] } } )
-    @reader.show.should == { 'value' => 'details' }
-  end
+  context "domain does exist" do
+    before do
+      @sdb_mock.stub :domain_exists? => true
+    end
 
-  it "should return an empty hash if item does not exist" do
-    @sdb_mock.should_receive(:select).
-              with("select * from tim where itemName() = '123'").
-              and_return({})
-    @reader.show.should == {}
-  end
+    it "should show the item record" do
+      @sdb_mock.should_receive(:select).
+               with("select * from heirloom_tim where itemName() = '123'").
+               and_return( { '123' => { 'value' => [ 'details' ] } } )
+      @reader.show.should == { 'value' => 'details' }
+    end
 
-  it "should return true if the record exists" do
-    @sdb_mock.should_receive(:select).
-              with("select * from tim where itemName() = '123'").
-              and_return( { '123' => { 'value' => [ 'details' ] } } )
-    @logger_mock.should_receive(:debug).exactly(1).times
-    @reader.exists?.should == true
-  end
+    it "should return an empty hash if item does not exist" do
+      @sdb_mock.should_receive(:select).
+                with("select * from heirloom_tim where itemName() = '123'").
+                and_return({})
+      @reader.show.should == {}
+    end
 
-  it "should return false if the recrod does not exist" do
-    @sdb_mock.should_receive(:select).
-              with("select * from tim where itemName() = '123'").
-              and_return({})
-    @logger_mock.should_receive(:debug).exactly(1).times
-    @reader.exists?.should == false
-  end
+    it "should return true if the record exists" do
+      @sdb_mock.should_receive(:select).
+                with("select * from heirloom_tim where itemName() = '123'").
+                and_return( { '123' => { 'value' => [ 'details' ] } } )
+      @reader.exists?.should == true
+    end
 
-  it "should return the bucket if it exists" do
-    @logger_mock.should_receive(:debug).exactly(5).times
-    @sdb_mock.should_receive(:select).
-              exactly(3).times.
-              with("select * from tim where itemName() = '123'").
-              and_return( { '123' => 
-                            { 'us-west-1-s3-url' => 
-                              [ 's3://the-bucket/the-buck/the-key' ]  
-                            }
-                          } )
-    @reader.get_bucket(:region => 'us-west-1').should == 'the-bucket'
-  end
+    it "should return false if the record does not exist" do
+      @sdb_mock.should_receive(:select).
+                with("select * from heirloom_tim where itemName() = '123'").
+                and_return({})
+      @reader.exists?.should == false
+    end
 
-  it "should return nil if the bucket does not exist" do
-    @logger_mock.should_receive(:debug).exactly(3).times
-    @sdb_mock.should_receive(:select).
-              exactly(1).times.
-              with("select * from tim where itemName() = '123'").
-              and_return( { } )
-    @reader.get_bucket(:region => 'us-west-1').should == nil
-  end
+    it "should return the bucket if it exists" do
+      @sdb_mock.should_receive(:select).
+                exactly(3).times.
+                with("select * from heirloom_tim where itemName() = '123'").
+                and_return( { '123' => 
+                              { 'us-west-1-s3-url' => 
+                                [ 's3://the-bucket/the-buck/the-key' ]  
+                              }
+                            } )
+      @reader.get_bucket(:region => 'us-west-1').should == 'the-bucket'
+    end
 
-  it "should return the key if it exists" do
-    @logger_mock.should_receive(:debug).exactly(8).times
-    @sdb_mock.should_receive(:select).
-              exactly(6).times.
-              with("select * from tim where itemName() = '123'").
-              and_return( { '123' => 
-                            { 'us-west-1-s3-url' => 
-                              ['s3://the-url/the-bucket/the-key'] 
-                            }
-                          } )
-    @reader.get_key(:region => 'us-west-1').should == 'the-bucket/the-key'
-  end
+    it "should return nil if the key does not exist" do
+      @sdb_mock.should_receive(:select).
+                exactly(1).times.
+                with("select * from heirloom_tim where itemName() = '123'").
+                and_return( { } )
+      @reader.get_key(:region => 'us-west-1').should == nil
+    end
+
+    it "should return nil if the bucket does not exist" do
+      @sdb_mock.should_receive(:select).
+                exactly(1).times.
+                with("select * from heirloom_tim where itemName() = '123'").
+                and_return( { } )
+      @reader.get_bucket(:region => 'us-west-1').should == nil
+    end
+
+    it "should return the key if it exists" do
+      @sdb_mock.should_receive(:select).
+                exactly(6).times.
+                with("select * from heirloom_tim where itemName() = '123'").
+                and_return( { '123' => 
+                              { 'us-west-1-s3-url' => 
+                                ['s3://the-url/the-bucket/the-key'] 
+                              }
+                            } )
+      @reader.get_key(:region => 'us-west-1').should == 'the-bucket/the-key'
+    end
+
+    it "should return the regions the archive has been uploaded to" do
+      @sdb_mock.should_receive(:select).
+                exactly(1).times.
+                with("select * from heirloom_tim where itemName() = '123'").
+                and_return( { '123' => 
+                              { 'us-west-1-s3-url' => 
+                                ['s3://the-url-us-west-1/the-bucket/the-key'],
+                                'build_by' => 
+                                ['user'], 
+                                'us-east-1-s3-url' => 
+                                ['s3://the-url-us-east-1/the-bucket/the-key'] 
+                              }
+                            } )
+      @reader.regions.should == ['us-west-1', 'us-east-1']
+    end
 
-  it "should return nil if the key does not exist" do
-    @logger_mock.should_receive(:debug).exactly(1).times
-    @sdb_mock.should_receive(:select).
-              exactly(1).times.
-              with("select * from tim where itemName() = '123'").
-              and_return( { } )
-    @reader.get_key(:region => 'us-west-1').should == nil
   end
 
-  it "should return the regions the archive has been uploaded to" do
-    @sdb_mock.should_receive(:select).
-              exactly(1).times.
-              with("select * from tim where itemName() = '123'").
-              and_return( { '123' => 
-                            { 'us-west-1-s3-url' => 
-                              ['s3://the-url-us-west-1/the-bucket/the-key'],
-                              'build_by' => 
-                              ['user'], 
-                              'us-east-1-s3-url' => 
-                              ['s3://the-url-us-east-1/the-bucket/the-key'] 
-                            }
-                          } )
-    @reader.regions.should == ['us-west-1', 'us-east-1']
+  context "domain does not exist" do
+    before do
+      @sdb_mock.stub :domain_exists? => false
+    end
+
+    it "should return false if the simpledb domain does not exist" do
+      @reader.exists?.should == false
+    end
   end
 
 end

data/spec/archive/updater_spec.rb

@@ -18,7 +18,7 @@ describe Heirloom do
                             with(:config => @config_mock).
                             and_return sdb_mock
     sdb_mock.should_receive(:put_attributes).
-             with('tim', '123', { 'attr' => 'val' }, { :replace => 'attr' })
+             with('heirloom_tim', '123', { 'attr' => 'val' }, { :replace => 'attr' })
     @updater.update :attribute => 'attr',
                     :value     => 'val'
   end

data/spec/archive_spec.rb

@@ -3,12 +3,10 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-      @config_mock = mock 'config'
-      @logger_mock = mock 'logger'
-      Heirloom::Config.should_receive(:new).and_return @config_mock
-      @archive = Heirloom::Archive.new :logger => @logger_mock,
-                                       :name   => 'chef',
-                                       :id     => '123'
+    @config_mock = mock 'config'
+    @archive = Heirloom::Archive.new :config => @config_mock,
+                                     :name   => 'chef',
+                                     :id     => '123'
   end
 
 
@@ -191,5 +189,16 @@ describe Heirloom do
       mock.should_receive(:regions)
       @archive.regions
     end
+
+    it "should call the count method for an archive" do
+      mock = double('Mock')
+      Heirloom::Reader.should_receive(:new).
+                          with(:config => @config_mock,
+                               :name   => 'chef',
+                               :id     => '123').
+                          and_return mock
+      mock.should_receive(:count)
+      @archive.count
+    end
   end
 end

data/spec/aws/simpledb_spec.rb

@@ -30,6 +30,11 @@ describe Heirloom do
     @sdb.create_domain('new_domain')
   end
 
+  it "should destroy the specified domain" do
+    @fog_mock.should_receive(:delete_domain).with('new_domain')
+    @sdb.delete_domain('new_domain')
+  end
+
   it "should not create a new domain when already exists" do
     @sdb.should_receive(:domains).and_return(['new_domain'])
     @fog_mock.should_receive(:create_domain).exactly(0).times
@@ -47,4 +52,34 @@ describe Heirloom do
     @sdb.delete('domain', 'key')
   end
 
+  it "should count the number of entries in the domain" do
+    body_mock = mock 'return body'
+    data = { 'Items' => { 'Domain' => { 'Count' => ['1'] } } }
+    @fog_mock.should_receive(:select).
+              with('SELECT count(*) FROM heirloom_domain').
+              and_return body_mock
+    body_mock.should_receive(:body).and_return data
+    @sdb.count('heirloom_domain').should == 1
+  end
+
+  it "should return true if no entries for the domain" do
+    body_mock = mock 'return body'
+    data = { 'Items' => { 'Domain' => { 'Count' => ['0'] } } }
+    @fog_mock.should_receive(:select).
+              with('SELECT count(*) FROM heirloom_domain').
+              and_return body_mock
+    body_mock.should_receive(:body).and_return data
+    @sdb.domain_empty?('heirloom_domain').should be_true
+  end
+
+  it "should return false if entries exist for the domain" do
+    body_mock = mock 'return body'
+    data = { 'Items' => { 'Domain' => { 'Count' => ['50'] } } }
+    @fog_mock.should_receive(:select).
+              with('SELECT count(*) FROM heirloom_domain').
+              and_return body_mock
+    body_mock.should_receive(:body).and_return data
+    @sdb.domain_empty?('heirloom_domain').should be_false
+  end
+
 end

data/spec/cli/authorize_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'heirloom/cli'
+
+describe Heirloom do
+
+  before do
+    options = { :level    => 'info',
+                :accounts => ['test@test.com'],
+                :name     => 'archive_name',
+                :id       => '1.0.0' }
+    @logger_mock = mock 'logger'
+    @config_mock = mock 'config'
+    @archive_mock = mock 'archive'
+    Trollop.stub(:options).and_return options
+    Heirloom::HeirloomLogger.should_receive(:new).with(:log_level => 'info').
+                             and_return @logger_mock
+    Heirloom::CLI::Authorize.any_instance.should_receive(:load_config).
+                             with(:logger => @logger_mock,
+                                  :opts   => options).
+                             and_return @config_mock
+    Heirloom::Archive.should_receive(:new).
+                      with(:id   => '1.0.0',
+                           :name => 'archive_name',
+                           :config => @config_mock).
+                      and_return @archive_mock
+    @cli_authorize = Heirloom::CLI::Authorize.new
+  end
+
+  it "should authorize an account" do
+    @archive_mock.should_receive(:authorize).with ['test@test.com']
+    @cli_authorize.authorize
+  end
+
+end

data/spec/cli/build_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'heirloom/cli'
+
+describe Heirloom do
+
+  before do
+    options = { :level       => 'info',
+                :base_prefix => 'base',
+                :git         => false,
+                :exclude     => ['exclude1', 'exclude2'],
+                :region      => ['us-west-1', 'us-west-2'],
+                :directory   => '/buildme',
+                :public      => false,
+                :name        => 'archive_name',
+                :id          => '1.0.0' }
+
+    @logger_stub = stub :error => true, :info => true
+    @config_mock = mock 'config'
+    @archive_mock = mock 'archive'
+    Trollop.stub(:options).and_return options
+    Heirloom::HeirloomLogger.should_receive(:new).with(:log_level => 'info').
+                             and_return @logger_stub
+    Heirloom::CLI::Build.any_instance.should_receive(:load_config).
+                         with(:logger => @logger_stub,
+                              :opts   => options).
+                         and_return @config_mock
+    Heirloom::Archive.should_receive(:new).
+                      with(:id   => '1.0.0',
+                           :name => 'archive_name',
+                           :config => @config_mock).
+                      and_return @archive_mock
+    @build = Heirloom::CLI::Build.new
+  end
+
+  it "should build an account" do
+    @archive_mock.should_receive(:buckets_exist?).
+                  with(:bucket_prefix => 'base',
+                       :regions       => ["us-west-1", "us-west-2"]).
+                  and_return true
+    @archive_mock.stub :exists? => false
+    @archive_mock.should_receive(:build).
+                  with(:bucket_prefix => 'base',
+                       :directory     => '/buildme',
+                       :exclude       => ["exclude1", "exclude2"],
+                       :git           => false).
+                  and_return '/tmp/build123.tar.gz'
+    @archive_mock.should_receive(:upload).
+                  with(:bucket_prefix   => 'base',
+                       :regions         => ['us-west-1', 'us-west-2'],
+                       :public_readable => false,
+                       :file            => '/tmp/build123.tar.gz')
+    @archive_mock.should_receive(:cleanup)
+
+    @build.build
+  end
+
+end

data/spec/cli/destroy_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'heirloom/cli'
+
+describe Heirloom do
+
+  before do
+    options = { :name  => 'archive_name',
+                :id    => '1.0.0',
+                :level => 'info' }
+    @logger_mock = mock 'logger'
+    @config_mock = mock 'config'
+    @archive_mock = mock 'archive'
+    Trollop.stub(:options).and_return options
+    Heirloom::HeirloomLogger.should_receive(:new).with(:log_level => 'info').
+                             and_return @logger_mock
+    Heirloom::CLI::Destroy.any_instance.should_receive(:load_config).
+                             with(:logger => @logger_mock,
+                                  :opts   => options).
+                             and_return @config_mock
+    Heirloom::Archive.should_receive(:new).
+                      with(:id   => '1.0.0',
+                           :name => 'archive_name',
+                           :config => @config_mock).
+                      and_return @archive_mock
+    @cli_destroy = Heirloom::CLI::Destroy.new
+  end
+
+  it "should destroy an archive" do
+    @archive_mock.should_receive(:destroy)
+    @cli_destroy.destroy
+  end
+
+end

data/spec/cli/download_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'heirloom/cli'
+
+describe Heirloom do
+
+  before do
+    options = { :name   => 'archive_name',
+                :id     => '1.0.0',
+                :level  => 'info',
+                :output => '/tmp/test123',
+                :region => 'us-east-1' }
+    @logger_mock = mock 'logger'
+    @config_mock = mock 'config'
+    @archive_mock = mock 'archive'
+    Trollop.stub(:options).and_return options
+    Heirloom::HeirloomLogger.should_receive(:new).
+                             with(:log_level => 'info').
+                             and_return @logger_mock
+    Heirloom::CLI::Download.any_instance.should_receive(:load_config).
+                            with(:logger => @logger_mock,
+                                 :opts   => options).
+                            and_return @config_mock
+    Heirloom::Archive.should_receive(:new).
+                      with(:id   => '1.0.0',
+                           :name => 'archive_name',
+                           :config => @config_mock).
+                      and_return @archive_mock
+    @cli_download = Heirloom::CLI::Download.new
+  end
+
+  it "should download an archive" do
+    @archive_mock.should_receive(:download).with :output => '/tmp/test123',
+                                                 :region => 'us-east-1'
+    @cli_download.download
+  end
+
+end

data/spec/cli/list_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'heirloom/cli'
+
+describe Heirloom do
+
+  before do
+    options = { :name  => 'archive_name',
+                :level => 'info',
+                :count => 100 }
+    @logger_stub = stub :debug => true
+    @config_mock = mock 'config'
+    @archive_mock = mock 'archive'
+    Trollop.stub(:options).and_return options
+    Heirloom::HeirloomLogger.should_receive(:new).with(:log_level => 'info').
+                             and_return @logger_stub
+    Heirloom::CLI::List.any_instance.should_receive(:load_config).
+                        with(:logger => @logger_stub,
+                             :opts   => options).
+                        and_return @config_mock
+    Heirloom::Archive.should_receive(:new).
+                      with(:name   => 'archive_name',
+                           :config => @config_mock).
+                      and_return @archive_mock
+    @archive_mock.should_receive(:count)
+    @cli_list = Heirloom::CLI::List.new
+  end
+
+  it "should list ids for given archive" do
+    @archive_mock.should_receive(:list).with(100).and_return(['1','2'])
+    @cli_list.should_receive(:jj).with ['1','2']
+    @cli_list.list
+  end
+
+end

data/spec/cli/shared_spec.rb

@@ -1,45 +1,79 @@
 require 'spec_helper'
 
-require 'heirloom/cli/shared'
+require 'heirloom/cli'
 
 describe Heirloom do
-  before do 
-    @logger_mock = mock 'logger'
-  end
 
-  it "should return false if a required array is emtpy" do
-    @logger_mock.should_receive(:error)
-    Heirloom::CLI::Shared.valid_options?(:provided => { :array  => [],
-                                                        :string => 'present' },
-                                         :required => [:array, :string],
-                                         :logger   => @logger_mock).
-                          should be_false
-  end
+  context "testing valid_options?" do
 
-  it "should return false if a required string is nil" do
-    @logger_mock.should_receive(:error)
-    Heirloom::CLI::Shared.valid_options?(:provided => { :array  => ['present'],
-                                                        :string => nil },
-                                         :required => [:array, :string],
-                                         :logger   => @logger_mock).
-                          should be_false
-  end
+    before do
+      @logger_mock = mock 'logger' 
+      @object = Object.new
+      @object.extend Heirloom::CLI::Shared
+    end
+
+    it "should return false if a required array is emtpy" do
+      @logger_mock.should_receive(:error)
+      @object.valid_options?(:provided => { :array  => [],
+                                            :string => 'present' },
+                             :required => [:array, :string],
+                             :logger   => @logger_mock).should be_false
+    end
+
+    it "should return false if a required string is nil" do
+      @logger_mock.should_receive(:error)
+      @object.valid_options?(:provided => { :array  => ['present'],
+                                            :string => nil },
+                             :required => [:array, :string],
+                             :logger   => @logger_mock).should be_false
+    end
+
+    it "should return false if a require string is nil & array is empty" do
+      @logger_mock.should_receive(:error).exactly(2).times
+      @object.valid_options?(:provided => { :array  => [],
+                                            :string => nil },
+                             :required => [:array, :string],
+                             :logger   => @logger_mock).should be_false
+    end
 
-  it "shoudl return false if a require string is nil & array is empty" do
-    @logger_mock.should_receive(:error).exactly(2).times
-    Heirloom::CLI::Shared.valid_options?(:provided => { :array  => [],
-                                                        :string => nil },
-                                         :required => [:array, :string],
-                                         :logger   => @logger_mock).
-                          should be_false
+    it "should return true if all options are present" do
+      @logger_mock.should_receive(:error).exactly(0).times
+      @object.valid_options?(:provided => { :array  => ['present'],
+                                            :string => 'present' },
+                             :required => [:array, :string],
+                             :logger   => @logger_mock).should be_true
+    end
   end
 
-  it "shoudl return true if all options are present" do
-    @logger_mock.should_receive(:error).exactly(0).times
-    Heirloom::CLI::Shared.valid_options?(:provided => { :array  => ['present'],
-                                                        :string => 'present' },
-                                         :required => [:array, :string],
-                                         :logger   => @logger_mock).
-                          should be_true
+  context "testing load_config" do
+
+    before do
+      @config_mock = mock 'config'
+      @logger_mock = mock 'logger'
+      @object = Object.new
+      @object.extend Heirloom::CLI::Shared
+      Heirloom::Config.should_receive(:new).with(:logger => @logger_mock).
+                       and_return @config_mock
+    end
+
+    it "should return the configuration" do
+      @object.load_config(:logger => @logger_mock,
+                          :opts => {}).should == @config_mock
+    end
+
+    it "should set the access key if specified" do
+      opts = { :key       => 'the_key',
+               :key_given => true }
+      @config_mock.should_receive(:access_key=).with 'the_key'
+      @object.load_config :logger => @logger_mock, :opts => opts
+    end
+
+    it "should set the secret key if specified" do
+      opts = { :secret       => 'the_secret',
+               :secret_given => true }
+      @config_mock.should_receive(:secret_key=).with 'the_secret'
+      @object.load_config :logger => @logger_mock, :opts => opts
+    end
   end
+
 end

data/spec/cli/show_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'heirloom/cli'
+
+describe Heirloom do
+
+  before do
+    options = { :name  => 'archive_name',
+                :id    => '1.0.0',
+                :level => 'info' }
+    @logger_stub = stub :debug => true
+    @config_mock = mock 'config'
+    @archive_mock = mock 'archive'
+    Trollop.stub(:options).and_return options
+    Heirloom::HeirloomLogger.should_receive(:new).with(:log_level => 'info').
+                             and_return @logger_stub
+    Heirloom::CLI::Show.any_instance.should_receive(:load_config).
+                        with(:logger => @logger_stub,
+                             :opts   => options).
+                        and_return @config_mock
+    Heirloom::Archive.should_receive(:new).
+                      with(:name   => 'archive_name',
+                           :id     => '1.0.0',
+                           :config => @config_mock).
+                      and_return @archive_mock
+    @cli_show = Heirloom::CLI::Show.new
+  end
+
+  it "should show a given id" do
+    @archive_mock.should_receive(:show).and_return( { 'id' => '1.0.0' } )
+    @cli_show.should_receive(:jj).with 'id' => '1.0.0'
+    @cli_show.show
+  end
+
+end