cf_deployer 1.2.8

data/spec/unit/deployment_strategy/cname_swap_spec.rb

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+describe CfDeployer::DeploymentStrategy::CnameSwap do
+
+  let(:dns_driver) { double('route53') }
+  let(:elb_driver) { double('elb') }
+  let(:blue_asg_driver) { double('blue_asg_driver') }
+  let(:green_asg_driver) { double('green_asg_driver') }
+  let(:blue_stack)  { Fakes::Stack.new(name: 'BLUE', outputs: {'web-elb-name' => 'BLUE-elb', 'AutoScalingGroupID' => 'blueASG'}, parameters: {:name => 'blue'}) }
+  let(:green_stack) { Fakes::Stack.new(name: 'GREEN', outputs: {'web-elb-name' => 'GREEN-elb', 'AutoScalingGroupID' => 'greenASG'}, parameters: {:name => 'green'}) }
+
+  before do
+    allow(Kernel).to receive(:sleep)
+    @context =
+        {
+          :'deployment-strategy' => 'cname-swap',
+          :dns_driver => dns_driver,
+          :elb_driver => elb_driver,
+          :settings              => {
+            :'dns-fqdn'        => 'test.foobar.com',
+            :'dns-zone'        => 'foobar.com',
+            :'elb-name-output' => 'web-elb-name',
+            :'dns-driver'      => CfDeployer::Defaults::DNSDriver
+          }
+        }
+
+    allow(CfDeployer::Stack).to receive(:new).with('myapp-dev-web-B', 'web', anything()) { blue_stack }
+    allow(CfDeployer::Stack).to receive(:new).with('myapp-dev-web-G', 'web', anything()) { green_stack }
+    allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('blueASG') { blue_asg_driver }
+    allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
+    allow(elb_driver).to receive(:find_dns_and_zone_id).with('BLUE-elb') { {:dns_name => 'blue-elb.aws.amazon.com', :canonical_hosted_zone_name_id => 'BLUE111'}}
+    allow(elb_driver).to receive(:find_dns_and_zone_id).with('GREEN-elb') { {:dns_name => 'green-elb.aws.amazon.com', :canonical_hosted_zone_name_id => 'GREEN111'}}
+  end
+
+  context "hooks" do
+    let(:before_destroy_hook) { double('before_destroy_hook') }
+    let(:after_create_hook) { double('after_create_hook') }
+    let(:after_swap_hook) { double('after_swap_hook') }
+
+    before :each do
+      allow(CfDeployer::Hook).to receive(:new).with(:'before-destroy', 'before-destroy'){ before_destroy_hook }
+      allow(CfDeployer::Hook).to receive(:new).with(:'after-create', 'after-create'){ after_create_hook }
+      allow(CfDeployer::Hook).to receive(:new).with(:'after-swap', 'after-swap'){ after_swap_hook }
+      allow(dns_driver).to receive(:set_alias_target)
+      @context[:'before-destroy'] = 'before-destroy'
+      @context[:'after-create'] = 'after-create'
+      @context[:'after-swap'] = 'after-swap'
+    end
+
+    it "should call hooks" do
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      expect(before_destroy_hook).to receive(:run).with(@context).twice
+      expect(after_create_hook).to receive(:run).with(@context)
+      expect(after_swap_hook).to receive(:run).with(@context)
+      cname_swap.deploy
+    end
+
+    it 'should call hooks when destroying green and blue stacks' do
+      @log = ''
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      allow(blue_stack).to receive(:delete)
+      allow(green_stack).to receive(:delete)
+      allow(before_destroy_hook).to receive(:run) do |arg|
+        @log += "#{arg[:parameters][:name]} deleted."
+      end
+      cname_swap.destroy
+      @log.should eq('green deleted.blue deleted.')
+    end
+  end
+
+  context "deploy" do
+
+    it "deploys green when blue is active" do
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+      expect(dns_driver).to receive(:set_alias_target).with('foobar.com', 'test.foobar.com', 'GREEN111', 'green-elb.aws.amazon.com')
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+
+      expect(green_stack).to be_deployed
+      expect(blue_stack).to_not be_deployed
+    end
+
+    it "deletes blue after deploying green" do
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+      allow(dns_driver).to receive(:set_alias_target).with('foobar.com', 'test.foobar.com', 'GREEN111', 'green-elb.aws.amazon.com')
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+
+      expect(blue_stack).to be_deleted
+    end
+
+    it "should not delete blue after deploying green if keep-previous-stack is specified" do
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+      allow(dns_driver).to receive(:set_alias_target).with('foobar.com', 'test.foobar.com', 'GREEN111', 'green-elb.aws.amazon.com')
+      @context[:settings][:'keep-previous-stack'] = true
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+
+      expect(blue_stack).to_not be_deleted
+    end
+
+    it "deploys blue when green is active" do
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'GREEN-elb.aws.amazon.com' }
+      expect(dns_driver).to receive(:set_alias_target).with('foobar.com', 'test.foobar.com', 'BLUE111', 'blue-elb.aws.amazon.com')
+
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+
+      cname_swap.deploy
+
+      expect(blue_stack).to be_deployed
+      expect(green_stack).to_not be_deployed
+    end
+
+    it "deletes the inactive stack before deployment" do
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+      allow(dns_driver).to receive(:set_alias_target).with('foobar.com', 'test.foobar.com', 'GREEN111', 'green-elb.aws.amazon.com')
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+
+      expect(green_stack).to be_deleted
+      expect(green_stack).to be_deployed
+    end
+
+    it "does not delete the green-inactive stack before deployment if that stack does not exist" do
+      green_stack.die!
+
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+      allow(dns_driver).to receive(:set_alias_target)
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+
+      expect(green_stack).to_not be_deleted
+    end
+
+    it "does not delete the blue-inactive stack before deployment if that stack does not exist" do
+      blue_stack.die!
+
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'GREEN-elb.aws.amazon.com' }
+      allow(dns_driver).to receive(:set_alias_target)
+
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+
+      expect(blue_stack).to_not be_deleted
+    end
+
+    it 'should warm up any auto scaling groups to previous colors levels' do
+      blue_stack.die!
+      green_stack.live!
+
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'GREEN-elb.aws.amazon.com' }
+      allow(dns_driver).to receive(:set_alias_target)
+      allow(green_asg_driver).to receive(:describe) { { desired: 3, min: 1, max: 5 } }
+      @context[:settings][:'auto-scaling-group-name-output'] = ['AutoScalingGroupID']
+      expect(blue_asg_driver).to receive(:warm_up).with 3
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+    end
+
+    it 'should warm up any auto scaling groups to desired number when no previous color exists' do
+      blue_stack.die!
+      green_stack.die!
+
+      allow(dns_driver).to receive(:set_alias_target)
+      allow(blue_asg_driver).to receive(:describe) { { desired: 2, min: 1, max: 5 } }
+      @context[:settings][:'auto-scaling-group-name-output'] = ['AutoScalingGroupID']
+      expect(blue_asg_driver).to receive(:warm_up).with 2
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+    end
+
+    it 'should not warm up if there are no auto scaling groups given' do
+      blue_stack.die!
+      green_stack.die!
+
+      allow(dns_driver).to receive(:set_alias_target)
+      allow(blue_asg_driver).to receive(:describe) { { desired: 2, min: 1, max: 5 } }
+      expect(blue_asg_driver).not_to receive(:warm_up)
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.deploy
+    end
+  end
+
+  context 'exists?' do
+    it 'no, if green stack and blue stack do not exist' do
+      blue_stack.die!
+      green_stack.die!
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.exists?.should be_false
+    end
+
+    it 'yes, if green stack exists and blue stack does not' do
+      blue_stack.die!
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.exists?.should be_true
+    end
+
+    it 'yes, if blue stack exists and green stack does not' do
+      green_stack.die!
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.exists?.should be_true
+    end
+  end
+
+  context '#destroy' do
+    it 'should destroy green and blue stacks' do
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      expect(blue_stack).to receive(:delete)
+      expect(green_stack).to receive(:delete)
+      cname_swap.destroy
+    end
+  end
+
+  context 'dns_driver' do
+    it 'should use a different driver class if the dns-driver setting is used' do
+      my_context = @context.clone
+      my_context.delete :dns_driver
+      my_context[:settings][:'dns-driver'] = 'CfDeployer::Driver::Verisign'
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', my_context)
+      cname_swap.send(:dns_driver).class.to_s.should eq(my_context[:settings][:'dns-driver'])
+    end
+  end
+
+  describe '#kill_inactive' do
+    let(:cname_swap) { CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context) }
+
+    context 'when blue stack is active' do
+      it 'should destroy the green stack' do
+        green_stack.live!
+        blue_stack.live!
+        allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+        expect(green_stack).to receive(:delete)
+        cname_swap.kill_inactive
+      end
+    end
+
+    context 'when green stack is active' do
+      it 'should destroy the blue stack' do
+        green_stack.live!
+        blue_stack.live!
+        allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'GREEN-elb.aws.amazon.com' }
+        expect(blue_stack).to receive(:delete)
+        cname_swap.kill_inactive
+      end
+    end
+
+    context 'when green stack is active and blue stack does not exist' do
+      it 'should raise an error' do
+        green_stack.live!
+        blue_stack.die!
+        allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'GREEN-elb.aws.amazon.com' }
+        expect(blue_stack).not_to receive(:delete)
+        expect { cname_swap.kill_inactive }.to raise_error CfDeployer::ApplicationError
+      end
+    end
+  end
+
+  describe '#switch' do
+    let(:cname_swap) { CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context) }
+    context 'if no inactive version exists' do
+      it 'should raise an error' do
+        green_stack.die!
+        blue_stack.live!
+        expect { cname_swap.switch }.to raise_error 'There is only one color stack active, you cannot switch back to a non-existent version'
+      end
+    end
+
+    context 'if an inactive version exists' do
+      it 'should swap the cname to the inactive version' do
+        green_stack.live!
+        blue_stack.live!
+        allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+        expect(dns_driver).to receive(:set_alias_target).with('foobar.com', 'test.foobar.com', 'GREEN111', 'green-elb.aws.amazon.com')
+        cname_swap.switch
+      end
+    end
+  end
+
+  context '#output_value' do
+
+    it 'should get stack output if active stack exists' do
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
+       cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.output_value("AutoScalingGroupID").should eq("blueASG")
+    end
+
+    it 'should get the information where the value comes from if the active stack does not exist' do
+      allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ '' }
+       cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      cname_swap.output_value(:a_key).should eq("The value will be referenced from the output a_key of undeployed component web")
+    end
+  end
+end

data/spec/unit/deployment_strategy/create_or_update_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe 'CreateOrUpdate Strategy' do
+  before :each do
+    @after_create_hook = double('after_create_hook')
+    @before_destroy_hook = double('before_destroy_hook')
+    allow(CfDeployer::Hook).to receive(:new).with(:'after-create', 'after-create'){ @after_create_hook }
+    allow(CfDeployer::Hook).to receive(:new).with(:'before-destroy', 'before-destroy') { @before_destroy_hook }
+    @context = {
+      :application => 'myApp',
+      :environment => 'uat',
+      :components =>
+        { :base => {
+          :settings => {},
+          :'deployment-strategy' => 'create-or-update',
+          :'after-create' => 'after-create',
+          :'before-destroy' => 'before-destroy'
+        }
+      }
+    }
+    @stack = double('stack')
+    @create_or_update = CfDeployer::DeploymentStrategy.create(@context[:application], @context[:environment], 'base', @context[:components][:base])
+    allow(CfDeployer::Stack).to receive(:new).with('myApp-uat-base','base', @context[:components][:base]){ @stack}
+    allow(@stack).to receive(:parameters){ {'vpc' => 'myvpc'}}
+    allow(@stack).to receive(:outputs){ {'ELBName' => 'myelb'}}
+  end
+
+  it 'should deploy stack' do
+    hook_context = nil
+    expect(@after_create_hook).to receive(:run) do |given_context|
+      hook_context = given_context
+    end
+    expect(@stack).to receive(:deploy)
+    @create_or_update.deploy
+    expect(hook_context[:parameters]).to eq( {'vpc' => 'myvpc'} )
+    expect(hook_context[:outputs]).to eq( {'ELBName' => 'myelb'} )
+    
+  end
+
+  context 'warm up auto scaling group' do
+
+    let(:asg_driver) { double('asg_driver') }
+
+    it 'should warm up the stack if any auto-scaling groups are given' do
+      context = @context[:components][:base]
+      context[:settings] = {}
+      context[:settings][:'auto-scaling-group-name-output'] = ['AutoScalingGroupID']
+      allow(@stack).to receive(:output).with('AutoScalingGroupID') { 'asg_name' }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('asg_name') { asg_driver }
+      allow(asg_driver).to receive(:describe) { {desired:2, min:1, max:3} }
+      allow(@after_create_hook).to receive(:run).with(anything)
+      allow(@stack).to receive(:deploy)
+      create_or_update = CfDeployer::DeploymentStrategy.create(@context[:application], @context[:environment], 'base', context)
+      expect(asg_driver).to receive(:warm_up).with 2
+      create_or_update.deploy
+    end
+  end
+
+  it 'should tell if stack exists' do
+    expect(@stack).to receive(:exists?){true}
+    @create_or_update.exists?.should eq(true)
+  end
+
+  it 'should get stack output' do
+    allow(@stack).to receive(:exists?){true}
+    expect(@stack).to receive(:output).with(:a_key){ "output_value" }
+    @create_or_update.output_value(:a_key).should eq("output_value")
+  end
+
+  it 'should get the information where the value comes from if the stack does not exist' do
+    allow(@stack).to receive(:exists?){false}
+    expect(@stack).not_to receive(:output).with(anything)
+    @create_or_update.output_value(:a_key).should eq("The value will be referenced from the output a_key of undeployed component base")
+  end
+
+  context '#destroy' do
+    it 'should destroy stack' do
+      allow(@stack).to receive(:exists?){ true}
+      allow(@stack).to receive(:parameters) { {}}
+      allow(@stack).to receive(:outputs) {{}}
+      expect(@before_destroy_hook).to receive(:run).with(anything)
+      expect(@stack).to receive(:delete)
+      @create_or_update.destroy
+    end
+  end
+
+  describe '#kill_inactive' do
+    it 'should raise an error' do
+      expect { @create_or_update.kill_inactive }.to raise_error CfDeployer::ApplicationError
+    end
+  end
+
+  context '#switch' do
+    it 'should raise an error' do
+      expect{ @create_or_update.switch }.to raise_error 'There is no inactive version to switch to for Create or Update Deployments.  Redeploy the version you want'
+    end
+  end
+
+  context '#status' do
+    before :each do
+      allow(@stack).to receive(:status) { 'deployed' }
+      allow(@stack).to receive(:name) { 'base-uat' }
+      allow(@stack).to receive(:exists?) { true }
+    end
+    it 'should get status from stack' do
+      @create_or_update.status.should eq({ 'base-uat' => {status: 'deployed'}})
+    end
+    it 'should get status from stack including resource info' do
+      allow(@stack).to receive(:resource_statuses) { 'resource1' }
+      @create_or_update.status(true).should eq({ 'base-uat' => {status: 'deployed', resources: 'resource1'}})
+    end
+  end
+end

data/spec/unit/deployment_strategy/deployment_strategy_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Deployment Strategy' do
+  before :each do
+    @context = {
+      application: 'myApp',
+      environment: 'uat',
+      components:
+      { base: {:'deployment-strategy' => 'create-or-update'},
+        db:  {:'deployment-strategy' => 'auto-scaling-group-swap'},
+        web: { :'deployment-strategy' => 'cname-swap' }
+        }
+      }
+  end
+
+  it "should create Create-Or-Update strategy" do
+    expect(CfDeployer::DeploymentStrategy::CreateOrUpdate).to receive(:new)
+    CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'base', @context[:components][:base])
+  end
+
+  it "should create Auto-Scaling-Group-Swap strategy" do
+    expect(CfDeployer::DeploymentStrategy::AutoScalingGroupSwap).to receive(:new)
+    CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'db', @context[:components][:db])
+  end
+  it "should create Cname-Swap strategy" do
+    expect(CfDeployer::DeploymentStrategy::CnameSwap).to receive(:new)
+    CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', @context[:components][:web])
+  end
+end

data/spec/unit/driver/auto_scaling_group_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe 'Autoscaling group driver' do
+  let(:group) { double('group', :desired_capacity => 2, :min_size => 1, :max_size => 4)}
+  let(:scaling) { double('scaling', :groups => { 'myAsg' => group}) }
+  let(:ec2_instance1) { double('ec2_instance1') }
+  let(:ec2_instance2) { double('ec2_instance2') }
+  let(:ec2_instance3) { double('ec2_instance3') }
+  let(:ec2_instance4) { double('ec2_instance4') }
+  let(:instance1) { double('instance1', :health_status => 'HEALTHY', :ec2_instance => ec2_instance1)}
+  let(:instance2) { double('instance2', :health_status => 'HEALTHY', :ec2_instance => ec2_instance2)}
+  let(:instance3) { double('instance3', :health_status => 'HEALTHY', :ec2_instance => ec2_instance3)}
+  let(:instance4) { double('instance4', :health_status => 'HEALTHY', :ec2_instance => ec2_instance4)}
+  let(:load_balancer) { double('load_balancer', :instances => [instance1, instance2, instance3, instance4]) }
+
+  before :each do
+    allow(AWS::AutoScaling).to receive(:new) { scaling }
+    allow(group).to receive(:load_balancers) { [] }
+    allow(group).to receive(:auto_scaling_instances) { [] }
+    allow(group).to receive(:ec2_instances) { [] }
+    @driver = CfDeployer::Driver::AutoScalingGroup.new('myAsg', 1)
+  end
+
+  it 'should describe group' do
+    @driver.describe.should eq({ min: 1, max: 4, desired: 2})
+  end
+
+  describe '#warm_up' do
+    it 'should warm up the group to the desired size' do
+      expect(group).to receive(:auto_scaling_instances){[instance1, instance2]}
+      expect(group).to receive(:set_desired_capacity).with(2)
+      @driver.warm_up 2
+    end
+
+    it 'should wait for the warm up of the group even if desired is the same as the minimum' do
+      expect(group).to receive(:auto_scaling_instances){[instance2]}
+      expect(group).to receive(:set_desired_capacity).with(1)
+      @driver.warm_up 1
+    end
+
+    it 'should ignore warming up if desired number is less than min size of the group' do
+      expect(group).not_to receive(:set_desired_capacity)
+      @driver.warm_up 0
+    end
+
+    it 'should warm up to maximum if desired number is greater than maximum size of group' do
+      expect(group).to receive(:auto_scaling_instances){[instance1, instance2, instance3, instance4]}
+      expect(group).to receive(:set_desired_capacity).with(4)
+      @driver.warm_up 5
+    end
+  end
+
+  describe '#healthy_instance_count' do
+    it 'should respond with the number of instances that are HEALTHY' do
+      instance5 =  double('instance1', :health_status => 'UNHEALTHY')
+      allow(group).to receive(:auto_scaling_instances){[instance1, instance2, instance3, instance4, instance5]}
+      expect(@driver.send(:healthy_instance_count)).to eql 4
+    end
+
+    context 'when an elb is associated with the auto scaling group' do
+      it 'should not include instances that are HEALTHY but not associated with the elb' do
+        instance_collection = double('instance_collection', :health => [{:instance => ec2_instance1, :state => 'InService'}])
+        load_balancer = double('load_balancer', :instances => instance_collection)
+        allow(group).to receive(:load_balancers) { [load_balancer] }
+        allow(group).to receive(:auto_scaling_instances) { [instance1, instance2] }
+
+        expect(@driver.send(:healthy_instance_count)).to eql 1
+      end
+
+      it 'should only include instances registered with an elb that are InService' do
+        allow(group).to receive(:auto_scaling_instances) { [instance1, instance2, instance3] }
+        instance_collection = double('instance_collection', :health => [{:instance => ec2_instance1, :state => 'InService'},
+                                                                        {:instance => ec2_instance2, :state => 'OutOfService'},
+                                                                        {:instance => ec2_instance3, :state => 'OutOfService'}])
+        load_balancer = double('load_balancer', :instances => instance_collection)
+        allow(group).to receive(:load_balancers) { [load_balancer] }
+
+        expect(@driver.send(:healthy_instance_count)).to eql 1
+      end
+    end
+
+    context 'when there are multiple elbs for an auto scaling group' do
+      it 'should not include instances that are not registered with all load balancers' do
+        instance_collection1 = double('instance_collection1', :health => [{:instance => ec2_instance1, :state => 'InService'}])
+        instance_collection2 = double('instance_collection2', :health => [])
+        load_balancer1 = double('load_balancer1', :instances => instance_collection1)
+        load_balancer2 = double('load_balancer2', :instances => instance_collection2)
+        allow(group).to receive(:load_balancers) { [load_balancer1, load_balancer2] }
+        allow(group).to receive(:auto_scaling_instances) { [instance1] }
+
+        expect(@driver.send(:healthy_instance_count)).to eql 0
+      end
+    end
+  end
+
+  describe '#cool_down' do
+    it 'should cool down group' do
+      expect(group).to receive(:update).with({min_size: 0, max_size: 0})
+      expect(group).to receive(:set_desired_capacity).with(0)
+      @driver.cool_down
+    end
+  end
+
+  describe '#warm_up_cooled_group' do
+    it 'should set min, max, and desired from a hash' do
+      hash = {:max => 5, :min => 2, :desired => 3}
+      allow(group).to receive(:auto_scaling_instances){[instance1, instance2, instance3]}
+      expect(group).to receive(:update).with({:min_size => 2, :max_size => 5})
+      expect(group).to receive(:set_desired_capacity).with(3)
+      @driver.warm_up_cooled_group hash
+    end
+  end
+
+  describe '#instance_statuses' do
+    it 'should get the status for any EC2 instances' do
+      aws_instance = double AWS::EC2::Instance
+      expect(aws_instance).to receive(:id) { 'i-abcd1234' }
+      allow(@driver).to receive(:ec2_instances) { [ aws_instance ] }
+
+      returned_status = { :status => :some_status }
+      cfd_instance = double CfDeployer::Driver::Instance
+      expect(CfDeployer::Driver::Instance).to receive(:new).with(aws_instance) { cfd_instance }
+      expect(cfd_instance).to receive(:status) { returned_status }
+      expect(@driver.instance_statuses).to eq( { 'i-abcd1234' => returned_status } )
+    end
+  end
+end

data/spec/unit/driver/cloud_formation_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+describe 'CloudFormation' do
+  let(:outputs) { [output1, output2] }
+  let(:output1) { double('output1', :key => 'key1', :value => 'value1')}
+  let(:output2) { double('output2', :key => 'key2', :value => 'value2')}
+  let(:parameters) { double('parameters')}
+  let(:stack) { double('stack', :outputs => outputs, :parameters => parameters) }
+  let(:cloudFormation) {
+    double('cloudFormation',
+           :stacks =>
+           {'testStack' => stack
+           })
+  }
+
+  before(:each) do
+    allow(AWS::CloudFormation).to receive(:new) { cloudFormation }
+  end
+
+  it 'should get outputs of stack' do
+    CfDeployer::Driver::CloudFormation.new('testStack').outputs.should eq({'key1' => 'value1', 'key2' => 'value2'})
+  end
+
+  it 'should get parameters of stack' do
+    CfDeployer::Driver::CloudFormation.new('testStack').parameters.should eq(parameters)
+  end
+
+  context 'resource_statuses' do
+    it 'should be tested' do
+      false
+    end
+  end
+end

data/spec/unit/driver/elb_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe CfDeployer::Driver::Elb do
+  it 'should get dns name and hosted zone id' do
+    elb = double('elb', :dns_name => 'mydns', :canonical_hosted_zone_name_id => 'zone_id')
+    aws = double('aws', :load_balancers => {'myelb' => elb})
+    elb_name = 'myelb'
+    expect(AWS::ELB).to receive(:new){aws}
+    CfDeployer::Driver::Elb.new.find_dns_and_zone_id(elb_name).should eq({:dns_name => 'mydns', :canonical_hosted_zone_name_id => 'zone_id'})
+  end
+end

data/spec/unit/driver/instance_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe CfDeployer::Driver::Instance do
+  context '#status' do
+    it 'should build the right hash of instance info' do
+      expected = { :status => :pending,
+                   :public_ip_address => '4.3.2.1',
+                   :private_ip_address => '192.168.1.10',
+                   :image_id => 'ami-testami',
+                   :key_pair => 'test_pair'
+                 }
+
+
+      aws = double AWS::EC2
+      expect(AWS::EC2).to receive(:new) { aws }
+
+      instance_collection = double AWS::EC2::InstanceCollection
+      expect(aws).to receive(:instances) { instance_collection }
+
+      instance = Fakes::Instance.new expected.merge( { :id => 'i-wxyz1234' } )
+      expect(instance_collection).to receive(:[]).with(instance.id) { instance }
+
+      instance_status = CfDeployer::Driver::Instance.new('i-wxyz1234').status
+
+      expected.each do |key, val|
+        expect(instance_status[key]).to eq(val)
+      end
+    end
+  end
+end