automan 2.3.6 → 2.3.7

data/spec/ec2/image_spec.rb

@@ -2,37 +2,37 @@ 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? }
+  it { is_expected.to respond_to :ec2 }
+  it { is_expected.to respond_to :create }
+  it { is_expected.to respond_to :prune }
+  it { is_expected.to respond_to :default_image_name }
+  it { is_expected.to respond_to :image_snapshot_exists? }
+  it { is_expected.to respond_to :image_snapshot }
+  it { is_expected.to respond_to :delete_snapshots }
+  it { is_expected.to respond_to :is_more_than_month_old? }
 
   describe '#default_image_name' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:name).and_return('skee-lo')
+      allow(s).to receive(:name).and_return('skee-lo')
       s
     end
 
     it "never returns nil" do
-      s.default_image_name().should_not be_nil
+      expect(subject.default_image_name()).to_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})/
+      name = subject.default_image_name()
+      expect(name).to match /^skee-lo-(\d{4})-(\d{2})-(\d{2})T(\d{2})(\d{2})(\d{2})Z/
     end
 
   end
 
   describe '#image_snapshot' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
@@ -41,31 +41,31 @@ describe Automan::Ec2::Image do
 
     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')
+      allow(fake_ami).to receive(:block_devices) { [ { ebs: {snapshot_id: 'foo' } } ] }
+      expect(subject.image_snapshot(fake_ami)).to 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
+      allow(fake_ami).to receive(:block_devices) { [ { ebs: {snapshot_id: nil } } ] }
+      expect(subject.image_snapshot(fake_ami)).to 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
+      allow(fake_ami).to receive(:block_devices) { [ { ebs: nil } ] }
+      expect(subject.image_snapshot(fake_ami)).to 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
+      allow(fake_ami).to receive(:block_devices) { [ nil ] }
+      expect(subject.image_snapshot(fake_ami)).to be_nil
     end
   end
 
   describe '#delete_snapshots' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
@@ -74,67 +74,67 @@ describe Automan::Ec2::Image do
 
     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 ])
+      allow(snapshot).to receive(:status).and_return(:foo)
+      allow(snapshot).to receive(:id)
+      expect(snapshot).to_not receive(:delete)
+      subject.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 ])
+      allow(snapshot).to receive(:status).and_return(:completed)
+      allow(snapshot).to receive(:id)
+      expect(snapshot).to receive(:delete)
+      subject.delete_snapshots( [ snapshot ])
     end
   end
 
   describe '#deregister_images' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:image_snapshot).and_return('foo')
+      allow(s).to receive(:image_snapshot).and_return('foo')
       s
     end
 
     before(:each) do
       @image = double(:image)
-      @image.stub(:id)
-      s.stub(:my_images).and_return( [ @image ] )
+      allow(@image).to receive(:id)
+      allow(subject).to receive(: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' ] )
+      allow(@image).to receive(:state).and_return(:foo)
+      allow(@image).to receive(:tags).and_return( {'CanPrune' => 'yes'} )
+      expect(@image).to_not receive(:delete)
+      subject.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' ] )
+      allow(@image).to receive(:state).and_return(:available)
+      allow(@image).to receive(:tags).and_return( Hash.new )
+      expect(@image).to_not receive(:delete)
+      subject.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' ] )
+      allow(@image).to receive(:state).and_return(:available)
+      allow(@image).to receive(:tags).and_return( {'CanPrune' => 'yes'} )
+      expect(@image).to_not receive(:delete)
+      subject.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' ] )
+      allow(@image).to receive(:state).and_return(:available)
+      allow(@image).to receive(:tags).and_return( {'CanPrune' => 'yes'} )
+      expect(@image).to receive(:delete)
+      subject.deregister_images( [ 'foo' ] )
     end
   end
 
   describe '#is_more_than_month_old?' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
@@ -142,17 +142,17 @@ describe Automan::Ec2::Image do
     end
 
     it 'returns false if argument is not a Time object' do
-      s.is_more_than_month_old?(Object.new).should be_false
+      expect(subject.is_more_than_month_old?(Object.new)).to be_falsey
     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
+      expect(subject.is_more_than_month_old?(days_of_yore)).to be_truthy
     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
+      expect(subject.is_more_than_month_old?(just_yesterday)).to be_falsey
     end
   end
 end

data/spec/ec2/instance_spec.rb

@@ -2,14 +2,14 @@ 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 }
+  it { is_expected.to respond_to :windows_password }
+  it { is_expected.to respond_to :password_data }
+  it { is_expected.to respond_to :decrypt_password }
+  it { is_expected.to respond_to :windows_name }
+  it { is_expected.to respond_to :show_env }
 
   describe '#windows_password' do
-    subject(:i) do
+    subject() do
       AWS.stub!
       i = Automan::Ec2::Instance.new
       i.logger = Logger.new('/dev/null')
@@ -17,24 +17,24 @@ describe Automan::Ec2::Instance do
     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
+      allow(subject).to receive(:password_data).and_return nil
+      expect(subject.windows_password('foo','bar')).to 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
+      allow(subject).to receive(:password_data).and_raise Automan::Ec2::RequestFailedError
+      expect(subject.windows_password('foo','bar')).to 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
+      allow(subject).to receive(:password_data).and_return 'foo'
+      allow(subject).to receive(:decrypt_password).and_return nil
+      expect(subject.windows_password('foo','bar')).to be_nil
     end
   end
 
   describe '#windows_name' do
-    subject(:i) do
+    subject() do
       AWS.stub!
       i = Automan::Ec2::Instance.new
       i.logger = Logger.new('/dev/null')
@@ -42,15 +42,15 @@ describe Automan::Ec2::Instance do
     end
 
     it "returns nil if ip_address is nil" do
-      i.windows_name(nil).should be_nil
+      expect(subject.windows_name(nil)).to be_nil
     end
 
     it "returns nil if ip_address is empty" do
-      i.windows_name("").should be_nil
+      expect(subject.windows_name("")).to be_nil
     end
 
     it "converts ip_address to ip-xxxxxxxx" do
-      i.windows_name('54.56.78.90').should eq 'ip-36384e5a'
+      expect(subject.windows_name('54.56.78.90')).to eq 'ip-36384e5a'
     end
   end
 

data/spec/elasticache/router_spec.rb

@@ -0,0 +1,29 @@
+require 'automan'
+
+describe Automan::ElastiCache::Router do
+  it { is_expected.to respond_to :run }
+  it { is_expected.to respond_to :environment }
+  it { is_expected.to respond_to :hosted_zone_name }
+  it { is_expected.to respond_to :redis_host }
+
+  describe '#run' do
+    subject() do
+      AWS.stub!
+      r = Automan::ElastiCache::Router.new
+      r.ec = AWS::ElastiCache::Client.new
+      r.environment = 'foo'
+      r.hosted_zone_name = 'foo.com'
+      r.redis_host       = 'redis.foo.com'
+      r.logger = Logger.new('/dev/null')
+      r
+    end
+
+    it "raises error if it never finds a name" do
+      allow(subject).to receive(:node_name_from_elasticache_environment).and_return(nil)
+      expect {
+        subject.run
+      }.not_to raise_error
+    end
+
+  end
+end

data/spec/mixins/aws_caller_spec.rb

@@ -1,39 +1,39 @@
 require 'automan/mixins/aws_caller'
 
 describe Automan::Mixins::AwsCaller do
-  let(:s) { (Class.new { include Automan::Mixins::AwsCaller }).new }
+  subject() { (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 }
+    it { is_expected.to respond_to svc }
   end
 
-  it { s.should respond_to :parse_s3_path }
+  it { is_expected.to 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')
+      bucket, key = subject.parse_s3_path('s3://foo/bar/baz')
+      expect(bucket).to eq('foo')
+      expect(key).to eq ('bar/baz')
     end
 
     it "raises error if it doesn't start with s3://" do
       expect {
-        s.parse_s3_path 'foo'
+        subject.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
+      expect(subject.looks_like_s3_path?('s3://foo')).to be_truthy
     end
 
     it 'returns false if it does not start with "s3://"' do
-      s.looks_like_s3_path?('foobar').should be_false
+      expect(subject.looks_like_s3_path?('foobar')).to be_falsey
     end
   end
 end

data/spec/mixins/utils_spec.rb

@@ -1,44 +1,43 @@
 require 'automan/mixins/utils'
 
 describe Automan::Mixins::Utils do
-  let(:s) { (Class.new { include Automan::Mixins::Utils }).new }
+  subject() { (Class.new { include Automan::Mixins::Utils }).new }
 
   it "adds String#underscore" do
-    s = String.new
-    s.should respond_to :underscore
+    expect(String.new).to 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"
+      expect("Namespace".underscore).to eq "namespace"
+      expect("OptionName".underscore).to eq "option_name"
+      expect("Value".underscore).to eq "value"
     end
   end
 
-  it { s.should respond_to :region_from_az }
+  it { is_expected.to 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'
+    expect(subject.region_from_az("us-east-1a")).to eq 'us-east-1'
+    expect(subject.region_from_az("us-east-1b")).to eq 'us-east-1'
+    expect(subject.region_from_az("us-east-1c")).to eq 'us-east-1'
+    expect(subject.region_from_az("us-east-1d")).to eq 'us-east-1'
+    expect(subject.region_from_az("ap-northeast-1a")).to eq 'ap-northeast-1'
+    expect(subject.region_from_az("ap-northeast-1b")).to eq 'ap-northeast-1'
+    expect(subject.region_from_az("ap-northeast-1c")).to eq 'ap-northeast-1'
+    expect(subject.region_from_az("sa-east-1a")).to eq 'sa-east-1'
+    expect(subject.region_from_az("sa-east-1b")).to eq 'sa-east-1'
+    expect(subject.region_from_az("ap-southeast-1a")).to eq 'ap-southeast-1'
+    expect(subject.region_from_az("ap-southeast-1b")).to eq 'ap-southeast-1'
+    expect(subject.region_from_az("ap-southeast-2a")).to eq 'ap-southeast-2'
+    expect(subject.region_from_az("ap-southeast-2b")).to eq 'ap-southeast-2'
+    expect(subject.region_from_az("us-west-2a")).to eq 'us-west-2'
+    expect(subject.region_from_az("us-west-2b")).to eq 'us-west-2'
+    expect(subject.region_from_az("us-west-2c")).to eq 'us-west-2'
+    expect(subject.region_from_az("us-west-1a")).to eq 'us-west-1'
+    expect(subject.region_from_az("us-west-1c")).to eq 'us-west-1'
+    expect(subject.region_from_az("eu-west-1a")).to eq 'eu-west-1'
+    expect(subject.region_from_az("eu-west-1b")).to eq 'eu-west-1'
+    expect(subject.region_from_az("eu-west-1c")).to eq 'eu-west-1'
   end
 end

data/spec/rds/snapshot_spec.rb

@@ -4,35 +4,35 @@ 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 }
+  it { is_expected.to respond_to :rds }
+  it { is_expected.to respond_to :create }
+  it { is_expected.to respond_to :delete }
+  it { is_expected.to respond_to :prune }
+  it { is_expected.to respond_to :latest }
+  it { is_expected.to respond_to :default_snapshot_name }
 
   describe '#default_snapshot_name' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::RDS::Snapshot.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:db_environment).and_return('dev1')
+      allow(s).to receive(:db_environment).and_return('dev1')
       s
     end
 
     it "never returns nil" do
-      s.default_snapshot_name('somedb').should_not be_nil
+      expect(subject.default_snapshot_name('somedb')).to_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})/
+    it "returns environment dash time string" do
+      name = subject.default_snapshot_name('somedb')
+      expect(name).to match /^dev1-(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})/
     end
 
   end
 
   describe '#create' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::RDS::Snapshot.new
       s.logger = Logger.new('/dev/null')
@@ -40,56 +40,56 @@ describe Automan::RDS::Snapshot do
     end
 
     it "raises error if could not find database" do
-      s.stub(:find_db).and_return(nil)
+      allow(subject).to receive(:find_db).and_return(nil)
       expect {
-        s.create
+        subject.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)
+      allow(db).to receive(:exists?).and_return(false)
+      allow(subject).to receive(:find_db).and_return(db)
 
       expect {
-        s.create
+        subject.create
       }.to raise_error Automan::RDS::DatabaseDoesNotExistError
     end
 
   end
 
   describe '#tagged_can_prune?' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::RDS::Snapshot.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:snapshot_arn)
+      allow(s).to receive(: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
+      allow(subject).to receive(:tags).and_return( {'CanPrune' => 'yes'} )
+      expect(subject.tagged_can_prune?( double() )).to be_truthy
     end
 
     it 'returns false if snapshot is missing CanPrune tag' do
-      s.stub(:tags).and_return( {} )
-      s.tagged_can_prune?( double() ).should be_false
+      allow(subject).to receive(:tags).and_return( {} )
+      expect(subject.tagged_can_prune?( double() )).to be_falsey
     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
+      allow(subject).to receive(:tags).and_return( {'CanPrune' => nil} )
+      expect(subject.tagged_can_prune?( double() )).to be_falsey
     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
+      allow(subject).to receive(:tags).and_return( {'CanPrune' => 'foo'} )
+      expect(subject.tagged_can_prune?( double() )).to be_falsey
     end
   end
 
   describe '#available?' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::RDS::Snapshot.new
       s.logger = Logger.new('/dev/null')
@@ -97,21 +97,19 @@ describe Automan::RDS::Snapshot do
     end
 
     it 'returns true if status is "available"' do
-      snap = double(:snap)
-      snap.stub(:status).and_return('available')
-      s.available?(snap).should be_true
+      snap = double(status: 'available')
+      expect(subject.available?(snap)).to be_truthy
     end
 
     it 'returns false if status is foo' do
-      snap = double(:snap)
-      snap.stub(:status).and_return('foo')
-      s.available?(snap).should be_false
+      snap = double(status: 'foo')
+      expect(subject.available?(snap)).to be_falsey
     end
   end
 
   describe '#manual?' do
     let(:snap) { double }
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::RDS::Snapshot.new
       s.logger = Logger.new('/dev/null')
@@ -119,34 +117,34 @@ describe Automan::RDS::Snapshot do
     end
 
     it 'returns true if type is "manual"' do
-      snap.stub(:snapshot_type).and_return('manual')
-      s.manual?(snap).should be_true
+      allow(snap).to receive(:snapshot_type).and_return('manual')
+      expect(subject.manual?(snap)).to be_truthy
     end
 
     it 'returns false if type is foo' do
-      snap.stub(:snapshot_type).and_return('foo')
-      s.manual?(snap).should be_false
+      allow(snap).to receive(:snapshot_type).and_return('foo')
+      expect(subject.manual?(snap)).to be_falsey
     end
   end
 
   describe '#prunable_snapshots' do
     let(:snap) { double }
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::RDS::Snapshot.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:get_all_snapshots).and_return( [ snap ] )
+      allow(s).to receive(: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)
+      allow(subject).to receive(:can_prune?).and_return(true)
+      expect(subject.prunable_snapshots).to 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)
+      allow(subject).to receive(:can_prune?).and_return(false)
+      expect(subject.prunable_snapshots).to_not include(snap)
     end
   end
 end

data/templates/stacker/.env.example

@@ -0,0 +1,14 @@
+#
+# example .env file
+# cp .env.example .env
+#
+# Set environment variables for all template parameters here.
+# This .env file is in gitignore to help keep application
+# secrets from leaking out into source code control.
+#
+export VPC_ID=vpc-foo
+export SUBNET_ID=subnet-foo
+export REMOTE_ACCESS_SG=sg-foo
+export KEYPAIR_NAME=fookey
+export INSTANCE_TYPE=m3.medium
+export IMAGE_ID=ami-foo

data/templates/stacker/.gitignore

@@ -0,0 +1,2 @@
+.env
+*.json

data/templates/stacker/.ruby-gemset.tt

@@ -0,0 +1 @@
+<%= @app_name %>

data/templates/stacker/.ruby-version

@@ -0,0 +1 @@
+2.2.2