automan 2.1.2

data/spec/cloudformation/terminator_spec.rb

@@ -0,0 +1,63 @@
+require 'automan'
+
+describe Automan::Cloudformation::Terminator do
+  it { should respond_to :name }
+  it { should respond_to :terminate }
+  it { should respond_to :stack_exists? }
+  it { should respond_to :stack_deleted? }
+  it { should respond_to :delete_stack }
+  it { should respond_to :wait_for_completion }
+
+  describe '#terminate' do
+    subject(:t) do
+      AWS.stub!
+      t = Automan::Cloudformation::Terminator.new
+      t.logger = Logger.new('/dev/null')
+      t
+    end
+
+    it 'should call #delete_stack if the stack exists' do
+      t.stub(:stack_exists?).and_return(true)
+      t.should_receive :delete_stack
+      t.terminate
+    end
+
+    it 'should not call #delete_stack if the stack does not exist' do
+      t.stub(:stack_exists?).and_return(false)
+      t.should_not_receive :delete_stack
+      t.terminate
+    end
+  end
+
+  describe '#stack_deleted?' do
+    subject(:t) do
+      AWS.stub!
+      t = Automan::Cloudformation::Terminator.new
+      t.logger = Logger.new('/dev/null')
+      t
+    end
+
+    it 'returns true if the stack does not exist' do
+      t.stub(:stack_exists?).and_return(false)
+      t.stub(:stack_status).and_raise StandardError
+      t.stack_deleted?('foo').should be_true
+    end
+
+    it 'returns true when status is DELETE_COMPLETE' do
+      t.stub(:stack_status).and_return('DELETE_COMPLETE')
+      t.stack_deleted?('foo').should be_true
+    end
+
+    it 'raises an error when the delete fails' do
+      t.stub(:stack_status).and_return('DELETE_FAILED')
+      expect {
+        t.stack_deleted?('foo')
+      }.to raise_error Automan::Cloudformation::StackDeletionError
+    end
+
+    it 'returns false for any other status' do
+      t.stub(:stack_status).and_return('foo')
+      t.stack_deleted?('foo').should be_false
+    end
+  end
+end

data/spec/cloudformation/uploader_spec.rb

@@ -0,0 +1,50 @@
+require 'automan'
+
+describe Automan::Cloudformation::Uploader do
+  subject(:u) do
+    AWS.stub!
+    u = Automan::Cloudformation::Uploader.new
+    u.logger = Logger.new('/dev/null')
+    u.stub(:templates).and_return(%w[a b c])
+    u
+  end
+
+  it { should respond_to :template_files }
+  it { should respond_to :s3_path }
+  it { should respond_to :all_templates_valid? }
+  it { should respond_to :upload_templates }
+
+  describe '#all_templates_valid?' do
+    it "raises error if there are no templates" do
+      u.stub(:templates).and_return([])
+      expect {
+        u.all_templates_valid?
+      }.to raise_error Automan::Cloudformation::NoTemplatesError
+    end
+
+    it 'returns true if templates are valid' do
+      u.should_receive(:template_valid?).exactly(3).times.and_return(true)
+      u.all_templates_valid?.should be_true
+    end
+
+    it 'returns false if any templates are invalid' do
+      u.stub(:template_valid?).and_return(false)
+      u.all_templates_valid?.should be_false
+    end
+  end
+
+  describe '#upload_templates' do
+    it 'raises error if any template fails validation' do
+      u.stub(:all_templates_valid?).and_return(false)
+      expect {
+        u.upload_templates
+      }.to raise_error(Automan::Cloudformation::InvalidTemplateError)
+    end
+
+    it 'uploads files if all are valid' do
+      u.stub(:all_templates_valid?).and_return(true)
+      u.should_receive(:upload_file).exactly(3).times
+      u.upload_templates
+    end
+  end
+end

data/spec/ec2/image_spec.rb

@@ -0,0 +1,158 @@
+require 'automan'
+require 'logger'
+
+describe Automan::Ec2::Image do
+  it { should respond_to :ec2 }
+  it { should respond_to :create }
+  it { should respond_to :prune }
+  it { should respond_to :default_image_name }
+  it { should respond_to :image_snapshot_exists? }
+  it { should respond_to :image_snapshot }
+  it { should respond_to :delete_snapshots }
+  it { should respond_to :is_more_than_month_old? }
+
+  describe '#default_image_name' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Ec2::Image.new
+      s.logger = Logger.new('/dev/null')
+      s.stub(:name).and_return('skee-lo')
+      s
+    end
+
+    it "never returns nil" do
+      s.default_image_name().should_not be_nil
+    end
+
+    it "returns name dash iso8601 string" do
+      name = s.default_image_name()
+      name.should match /^skee-lo-(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})[+-](\d{2})-(\d{2})/
+    end
+
+  end
+
+  describe '#image_snapshot' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Ec2::Image.new
+      s.logger = Logger.new('/dev/null')
+      s
+    end
+
+    it "returns id if the snapshot exists" do
+      fake_ami = double("ami")
+      fake_ami.stub(:block_devices) { [ { ebs: {snapshot_id: 'foo' } } ] }
+      s.image_snapshot(fake_ami).should eq('foo')
+    end
+
+    it "returns nil if the snapshot is nil" do
+      fake_ami = double("ami")
+      fake_ami.stub(:block_devices) { [ { ebs: {snapshot_id: nil } } ] }
+      s.image_snapshot(fake_ami).should be_nil
+    end
+
+    it "returns nil if the ebs is nil" do
+      fake_ami = double("ami")
+      fake_ami.stub(:block_devices) { [ { ebs: nil } ] }
+      s.image_snapshot(fake_ami).should be_nil
+    end
+
+    it "returns nil if the device is nil" do
+      fake_ami = double("ami")
+      fake_ami.stub(:block_devices) { [ nil ] }
+      s.image_snapshot(fake_ami).should be_nil
+    end
+  end
+
+  describe '#delete_snapshots' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Ec2::Image.new
+      s.logger = Logger.new('/dev/null')
+      s
+    end
+
+    it 'does not delete snapshots with status != :completed' do
+      snapshot = double(:snapshot)
+      snapshot.stub(:status).and_return(:foo)
+      snapshot.stub(:id)
+      snapshot.should_not_receive(:delete)
+      s.delete_snapshots( [ snapshot ])
+    end
+
+    it 'deletes snapshots with status == :completed' do
+      snapshot = double(:snapshot)
+      snapshot.stub(:status).and_return(:completed)
+      snapshot.stub(:id)
+      snapshot.should_receive(:delete)
+      s.delete_snapshots( [ snapshot ])
+    end
+  end
+
+  describe '#deregister_images' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Ec2::Image.new
+      s.logger = Logger.new('/dev/null')
+      s.stub(:image_snapshot).and_return('foo')
+      s
+    end
+
+    before(:each) do
+      @image = double(:image)
+      @image.stub(:id)
+      s.stub(:my_images).and_return( [ @image ] )
+    end
+
+    it 'does not deregister images with state != :available' do
+      @image.stub(:state).and_return(:foo)
+      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
+      @image.should_not_receive(:delete)
+      s.deregister_images( [ 'foo' ] )
+    end
+
+    it 'does not deregister images w/o prunable tag' do
+      @image.stub(:state).and_return(:available)
+      @image.stub(:tags).and_return( Hash.new )
+      @image.should_not_receive(:delete)
+      s.deregister_images( [ 'foo' ] )
+    end
+
+    it 'does not deregister images whose snapshots are not in the list' do
+      @image.stub(:state).and_return(:available)
+      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
+      @image.should_not_receive(:delete)
+      s.deregister_images( [ 'bar' ] )
+    end
+
+    it 'deletes available, prunable images on the list' do
+      @image.stub(:state).and_return(:available)
+      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
+      @image.should_receive(:delete)
+      s.deregister_images( [ 'foo' ] )
+    end
+  end
+
+  describe '#is_more_than_month_old?' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::Ec2::Image.new
+      s.logger = Logger.new('/dev/null')
+      s
+    end
+
+    it 'returns false if argument is not a Time object' do
+      s.is_more_than_month_old?(Object.new).should be_false
+    end
+
+    it 'returns true if time is more than 30 days in the past' do
+      days_of_yore = Time.now - (60*60*24*30)
+      s.is_more_than_month_old?(days_of_yore).should be_true
+    end
+
+    it 'returns false if time is in the last 30 days' do
+      just_yesterday = Time.now - (60*60*24)
+      s.is_more_than_month_old?(just_yesterday).should be_false
+    end
+  end
+end

data/spec/ec2/instance_spec.rb

@@ -0,0 +1,57 @@
+require "automan"
+
+describe Automan::Ec2::Instance do
+
+  it { should respond_to :windows_password }
+  it { should respond_to :password_data }
+  it { should respond_to :decrypt_password }
+  it { should respond_to :windows_name }
+  it { should respond_to :show_env }
+
+  describe '#windows_password' do
+    subject(:i) do
+      AWS.stub!
+      i = Automan::Ec2::Instance.new
+      i.logger = Logger.new('/dev/null')
+      i
+    end
+
+    it "returns nil if password could not be found" do
+      i.stub(:password_data).and_return nil
+      i.windows_password('foo','bar').should be_nil
+    end
+
+    it "returns nil if the aws request fails" do
+      i.stub(:password_data).and_raise Automan::Ec2::RequestFailedError
+      i.windows_password('foo','bar').should be_nil
+    end
+
+    it "returns nil if the decrypt fails" do
+      i.stub(:password_data).and_return 'foo'
+      i.stub(:decrypt_password).and_return nil
+      i.windows_password('foo','bar').should be_nil
+    end
+  end
+
+  describe '#windows_name' do
+    subject(:i) do
+      AWS.stub!
+      i = Automan::Ec2::Instance.new
+      i.logger = Logger.new('/dev/null')
+      i
+    end
+
+    it "returns nil if ip_address is nil" do
+      i.windows_name(nil).should be_nil
+    end
+
+    it "returns nil if ip_address is empty" do
+      i.windows_name("").should be_nil
+    end
+
+    it "converts ip_address to ip-xxxxxxxx" do
+      i.windows_name('54.56.78.90').should eq 'ip-36384e5a'
+    end
+  end
+
+end

data/spec/mixins/aws_caller_spec.rb

@@ -0,0 +1,39 @@
+require 'automan/mixins/aws_caller'
+
+describe Automan::Mixins::AwsCaller do
+  let(:s) { (Class.new { include Automan::Mixins::AwsCaller }).new }
+
+  services = [
+    :s3, :cfn, :as, :eb, :r53, :elb, :rds, :ec2
+  ]
+
+  services.each do |svc|
+    it { s.should respond_to svc }
+  end
+
+  it { s.should respond_to :parse_s3_path }
+
+  describe '#parse_s3_path' do
+    it "parses s3 path into bucket and key" do
+      bucket, key = s.parse_s3_path('s3://foo/bar/baz')
+      bucket.should eq('foo')
+      key.should eq ('bar/baz')
+    end
+
+    it "raises error if it doesn't start with s3://" do
+      expect {
+        s.parse_s3_path 'foo'
+      }.to raise_error ArgumentError
+    end
+  end
+
+  describe '#looks_like_s3_path?' do
+    it 'returns true if it begins with "s3://"' do
+      s.looks_like_s3_path?('s3://foo').should be_true
+    end
+
+    it 'returns false if it does not start with "s3://"' do
+      s.looks_like_s3_path?('foobar').should be_false
+    end
+  end
+end

data/spec/mixins/utils_spec.rb

@@ -0,0 +1,44 @@
+require 'automan/mixins/utils'
+
+describe Automan::Mixins::Utils do
+  let(:s) { (Class.new { include Automan::Mixins::Utils }).new }
+
+  it "adds String#underscore" do
+    s = String.new
+    s.should respond_to :underscore
+  end
+
+  describe "String#underscore" do
+    it "underscore's like a boss" do
+      "Namespace".underscore.should eq "namespace"
+      "OptionName".underscore.should eq "option_name"
+      "Value".underscore.should eq "value"
+    end
+  end
+
+  it { s.should respond_to :region_from_az }
+
+  it "returns az properly" do
+    s.region_from_az("us-east-1a").should eq 'us-east-1'
+    s.region_from_az("us-east-1b").should eq 'us-east-1'
+    s.region_from_az("us-east-1c").should eq 'us-east-1'
+    s.region_from_az("us-east-1d").should eq 'us-east-1'
+    s.region_from_az("ap-northeast-1a").should eq 'ap-northeast-1'
+    s.region_from_az("ap-northeast-1b").should eq 'ap-northeast-1'
+    s.region_from_az("ap-northeast-1c").should eq 'ap-northeast-1'
+    s.region_from_az("sa-east-1a").should eq 'sa-east-1'
+    s.region_from_az("sa-east-1b").should eq 'sa-east-1'
+    s.region_from_az("ap-southeast-1a").should eq 'ap-southeast-1'
+    s.region_from_az("ap-southeast-1b").should eq 'ap-southeast-1'
+    s.region_from_az("ap-southeast-2a").should eq 'ap-southeast-2'
+    s.region_from_az("ap-southeast-2b").should eq 'ap-southeast-2'
+    s.region_from_az("us-west-2a").should eq 'us-west-2'
+    s.region_from_az("us-west-2b").should eq 'us-west-2'
+    s.region_from_az("us-west-2c").should eq 'us-west-2'
+    s.region_from_az("us-west-1a").should eq 'us-west-1'
+    s.region_from_az("us-west-1c").should eq 'us-west-1'
+    s.region_from_az("eu-west-1a").should eq 'eu-west-1'
+    s.region_from_az("eu-west-1b").should eq 'eu-west-1'
+    s.region_from_az("eu-west-1c").should eq 'eu-west-1'
+  end
+end

data/spec/rds/snapshot_spec.rb

@@ -0,0 +1,152 @@
+require 'automan'
+require 'logger'
+
+ENV['MAX_SNAPSHOTS'] = "50"
+
+describe Automan::RDS::Snapshot do
+  it { should respond_to :rds }
+  it { should respond_to :create }
+  it { should respond_to :delete }
+  it { should respond_to :prune }
+  it { should respond_to :latest }
+  it { should respond_to :default_snapshot_name }
+
+  describe '#default_snapshot_name' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::RDS::Snapshot.new
+      s.logger = Logger.new('/dev/null')
+      s.stub(:db_environment).and_return('dev1')
+      s
+    end
+
+    it "never returns nil" do
+      s.default_snapshot_name('somedb').should_not be_nil
+    end
+
+    it "returns environment dash iso8601 string" do
+      name = s.default_snapshot_name('somedb')
+      name.should match /^dev1-(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})[+-](\d{2})-(\d{2})/
+    end
+
+  end
+
+  describe '#create' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::RDS::Snapshot.new
+      s.logger = Logger.new('/dev/null')
+      s
+    end
+
+    it "raises error if could not find database" do
+      s.stub(:find_db).and_return(nil)
+      expect {
+        s.create
+      }.to raise_error Automan::RDS::DatabaseDoesNotExistError
+    end
+
+    it "raises error if RDS says database does not exist" do
+      db = double(:db)
+      db.stub(:exists?).and_return(false)
+      s.stub(:find_db).and_return(db)
+
+      expect {
+        s.create
+      }.to raise_error Automan::RDS::DatabaseDoesNotExistError
+    end
+
+  end
+
+  describe '#tagged_can_prune?' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::RDS::Snapshot.new
+      s.logger = Logger.new('/dev/null')
+      s.stub(:snapshot_arn)
+      s
+    end
+
+    it 'returns true if snapshot is tagged with CanPrune=yes' do
+      s.stub(:tags).and_return( {'CanPrune' => 'yes'} )
+      s.tagged_can_prune?( double() ).should be_true
+    end
+
+    it 'returns false if snapshot is missing CanPrune tag' do
+      s.stub(:tags).and_return( {} )
+      s.tagged_can_prune?( double() ).should be_false
+    end
+
+    it 'returns false if snapshot is tagged with CanPrune=nil' do
+      s.stub(:tags).and_return( {'CanPrune' => nil} )
+      s.tagged_can_prune?( double() ).should be_false
+    end
+
+    it 'returns false if snapshot is tagged with CanPrune=foo' do
+      s.stub(:tags).and_return( {'CanPrune' => 'foo'} )
+      s.tagged_can_prune?( double() ).should be_false
+    end
+  end
+
+  describe '#available?' do
+    subject(:s) do
+      AWS.stub!
+      s = Automan::RDS::Snapshot.new
+      s.logger = Logger.new('/dev/null')
+      s
+    end
+
+    it 'returns true if status is "available"' do
+      snap = double(:snap)
+      snap.stub(:status).and_return('available')
+      s.available?(snap).should be_true
+    end
+
+    it 'returns false if status is foo' do
+      snap = double(:snap)
+      snap.stub(:status).and_return('foo')
+      s.available?(snap).should be_false
+    end
+  end
+
+  describe '#manual?' do
+    let(:snap) { double }
+    subject(:s) do
+      AWS.stub!
+      s = Automan::RDS::Snapshot.new
+      s.logger = Logger.new('/dev/null')
+      s
+    end
+
+    it 'returns true if type is "manual"' do
+      snap.stub(:snapshot_type).and_return('manual')
+      s.manual?(snap).should be_true
+    end
+
+    it 'returns false if type is foo' do
+      snap.stub(:snapshot_type).and_return('foo')
+      s.manual?(snap).should be_false
+    end
+  end
+
+  describe '#prunable_snapshots' do
+    let(:snap) { double }
+    subject(:s) do
+      AWS.stub!
+      s = Automan::RDS::Snapshot.new
+      s.logger = Logger.new('/dev/null')
+      s.stub(:get_all_snapshots).and_return( [ snap ] )
+      s
+    end
+
+    it 'includes snapshots which can be pruned' do
+      s.stub(:can_prune?).and_return(true)
+      s.prunable_snapshots.should include(snap)
+    end
+
+    it 'excludes snapshots which should not be pruned' do
+      s.stub(:can_prune?).and_return(false)
+      s.prunable_snapshots.should_not include(snap)
+    end
+  end
+end