cf_deployer 1.3.8 → 1.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99837edd085628d600239c517e9384c05dd2186e
-  data.tar.gz: ff5b6d33be922e3aeaa0f609991f799e0064e623
+  metadata.gz: 6d5da90ce16ae1b8de132cba6d1359e3a643d4c9
+  data.tar.gz: 8d34ac5950b1ce737da92f384c86dc72a0b8128c
 SHA512:
-  metadata.gz: 7ba8da26ac2cfb06a31fa2acff9ff3fce51c2a2328c79dc6c9542d78b9741d84bf8296e10945eb5a50b631014ae9c9ea8463ee13ab0d2ff6a6ccd7fbd1714941
-  data.tar.gz: 8b18b73a9110ba2d0dbcb953207770e2d83dd92bfcbf72db7a4a7a855f62042ea035141ff7f4a6523871166f8a214c3a594cd8c4d8e8a2f8eb7b9b87ce08308d
+  metadata.gz: 05f26ca292c10038313d724d7a24e5b875179aa41f986fa0b757bd7ea16038cd65fa585950bf18282bde4db042dede93dbc7e2d5fe1b6c1f3749bdceab967f12
+  data.tar.gz: 843e008b514878929b1a1d2802ae2b42b5fe638acc9898f7ca6bdb0d11af0c52d8db541fad2c55f331988dac1ac2b57cd25ca866ccd322607ea3a284ed885635

data/.gitignore

@@ -28,3 +28,5 @@ tags
 .rbenv-version
 .ruby-version
 Gemfile.lock
+.idea
+*.iml

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.7
+  - 2.2.3
+  - ruby-head
+  - jruby-19mode
+  - jruby-9.0.1.0
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx-2
+    - rvm: jruby-9.0.1.0
+  fast_finish: true
+script:
+  - bundle exec rake

data/ChangeLog.md

@@ -46,3 +46,7 @@ version 1.3.7
 version 1.3.8
   - Moved dependencies out of Gemfile and into gemspec
   - Removed Gemfile.lock
+
+version 1.3.9
+  - Allow new ASGs to be added to template (See: https://github.com/manheim/cf_deployer/issues/31)
+

data/README.md

@@ -1,3 +1,8 @@
+[![Gem Version](https://badge.fury.io/rb/cf_deployer.svg)](https://badge.fury.io/rb/cf_deployer)
+[![Build Status](https://travis-ci.org/manheim/cf_deployer.svg?branch=master)](https://travis-ci.org/manheim/cf_deployer)
+[![Code Climate](https://codeclimate.com/github/manheim/cf_deployer/badges/gpa.svg)](https://codeclimate.com/github/manheim/cf_deployer)
+[![License](http://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
 ##### [README](README.md) - [QUICKSTART](QUICKSTART.md) - [DETAILS](DETAILS.md) - [FAQ](FAQ.md)
 
 CFDeployer

data/lib/cf_deployer/deployment_strategy/auto_scaling_group_swap.rb

@@ -2,7 +2,6 @@ module CfDeployer
   module DeploymentStrategy
     class AutoScalingGroupSwap < BlueGreen
 
-      
       def deploy
         check_blue_green_not_both_active 'Deployment'
         Log.info "Found active stack #{active_stack.name}" if active_stack
@@ -15,7 +14,6 @@ module CfDeployer
         Log.info "#{component_name} deployed successfully"
       end
 
-
       def kill_inactive
         check_blue_green_not_both_active 'Kill Inactive'
         raise ApplicationError.new('Only one color stack exists, cannot kill a non-existant version!') unless both_stacks_exist?
@@ -25,15 +23,13 @@ module CfDeployer
       def switch
         check_blue_green_not_both_active 'Switch'
         raise ApplicationError.new('Only one color stack exists, cannot switch to a non-existent version!') unless both_stacks_exist?
-        warm_up_cooled = true
-        swap_group warm_up_cooled
+        swap_group true
       end
 
       private
 
-
       def check_blue_green_not_both_active action
-        active_stacks = get_active_asg(active_stack) + get_active_asg(inactive_stack)
+        active_stacks = get_active_asgs(active_stack) + get_active_asgs(inactive_stack)
         raise BothStacksActiveError.new("Found both auto-scaling-groups, #{active_stacks}, in green and blue stacks are active. #{action} aborted!") if both_stacks_active?
       end
 
@@ -56,32 +52,25 @@ module CfDeployer
         active_stack && stack_active?(inactive_stack)
       end
 
-
       def warm_up_cooled_stack
-        group_ids(active_stack).each_with_index do |id, index|
-          min_max_desired = asg_driver(id).describe
-          asg_driver(group_ids(inactive_stack)[index]).warm_up_cooled_group min_max_desired
-        end
+        warm_up_stack(inactive_stack, active_stack, true)
       end
 
       def cool_down_active_stack
-        group_ids(active_stack).each do |id|
+        get_active_asgs(active_stack).each do |id|
           asg_driver(id).cool_down
         end
-
       end
 
       def stack_active?(stack)
-        return false unless stack.exists?
-        get_active_asg(stack).any?
+        stack.exists? && get_active_asgs(stack).any?
       end
 
-
-      def get_active_asg stack
-        return [] unless stack && stack.exists?
-        group_ids(stack).select do |id|
+      def get_active_asgs stack
+        return [] unless stack && stack.exists? && stack.resource_statuses[:asg_instances]
+        stack.resource_statuses[:asg_instances].keys.select do |id|
           result = asg_driver(id).describe
-          result[:min] > 0  && result[:max] > 0 && result[:desired] > 0
+          result[:min] > 0 && result[:max] > 0 && result[:desired] > 0
         end
       end
 
@@ -89,7 +78,7 @@ module CfDeployer
         @auto_scaling_group_drivers[name] ||= CfDeployer::Driver::AutoScalingGroup.new name
       end
 
-      def asg_id_outputs
+      def asg_name_outputs
         @context[:settings][:'auto-scaling-group-name-output']
       end
 

data/lib/cf_deployer/deployment_strategy/base.rb

@@ -1,4 +1,3 @@
-
 module CfDeployer
   module DeploymentStrategy
 
@@ -74,29 +73,38 @@ module CfDeployer
       end
 
       def warm_up_inactive_stack
-        group_ids(inactive_stack).each_with_index do |id, index|
-          asg_driver(id).warm_up get_desired(id, index)
-        end
+        warm_up_stack(inactive_stack, active_stack)
       end
 
-      def get_desired(id, index)
-        group_id =  active_stack ? group_ids(active_stack)[index] : id
-        asg_driver(group_id).describe[:desired]
+      def warm_up_stack stack, previous_stack = nil, adjust_min_max = false
+        previous_ids = previous_stack ? template_asg_name_to_ids(previous_stack) : {}
+        template_asg_name_to_ids(stack).each do |name, id|
+          driver = asg_driver(id)
+          description = asg_driver(previous_ids[name] || id).describe
+          if adjust_min_max
+            driver.warm_up_cooled_group(description)
+          else
+            driver.warm_up(description[:desired])
+          end
+        end
       end
 
-      def group_ids(stack)
-        return [] unless asg_id_outputs
-        asg_id_outputs.map { |id| stack.output id }
+      def template_asg_name_to_ids(stack)
+        {}.tap do |result|
+          (asg_name_outputs || []).each do |name|
+            id = stack.find_output(name)
+            result[name] = id if id
+          end
+        end
       end
 
       def asg_driver name
         @auto_scaling_group_drivers[name] ||= CfDeployer::Driver::AutoScalingGroup.new name
       end
 
-      def asg_id_outputs
+      def asg_name_outputs
         @context[:settings][:'auto-scaling-group-name-output']
       end
-
     end
   end
 end

data/lib/cf_deployer/deployment_strategy/blue_green.rb

@@ -67,8 +67,6 @@ module CfDeployer
         return blue_stack if stack_active?(blue_stack)
         nil
       end
-
-
     end
   end
 end

data/lib/cf_deployer/driver/auto_scaling_group.rb

@@ -29,7 +29,7 @@ module CfDeployer
 
       def warm_up_cooled_group options
         CfDeployer::Driver::DryRun.guard 'Skipping update of ASG min & max instance count' do
-          aws_group.update :min_size =>  options[:min], :max_size => options[:max]
+          aws_group.update :min_size => options[:min], :max_size => options[:max]
         end
         warm_up options[:desired]
       end
@@ -81,11 +81,9 @@ module CfDeployer
         }
       end
 
-
       def aws_group
         @my_group ||= AWS::AutoScaling.new.groups[group_name]
       end
-
     end
   end
 end

data/lib/cf_deployer/stack.rb

@@ -38,8 +38,12 @@ module CfDeployer
     end
 
     def output key
+      find_output(key) || (raise ApplicationError.new("'#{key}' is empty from stack #{name} output"))
+    end
+
+    def find_output key
       begin
-        @cf_driver.query_output(key) || (raise ApplicationError.new("'#{key}' is empty from stack #{name} output"))
+        @cf_driver.query_output(key)
       rescue AWS::CloudFormation::Errors::ValidationError => e
         raise ResourceNotInReadyState.new("Resource stack not in ready state yet, perhaps you should provision it first?")
       end

data/lib/cf_deployer/version.rb

@@ -1,3 +1,3 @@
 module CfDeployer
-  VERSION = "1.3.8"
+  VERSION = "1.3.9"
 end

data/spec/fakes/stack.rb

@@ -1,12 +1,15 @@
 module Fakes
   class Stack
     attr_reader :outputs, :parameters
+    attr_accessor :resource_statuses
+
     def initialize(options)
       @exists = options[:exists?].nil? ? true : options[:exists?]
       @outputs = options[:outputs] || {}
       @parameters = options[:parameters] || {}
       @name = options[:name] || 'Unnamed'
       @status = options[:status] || :ready
+      @resource_statuses = {}
     end
 
     def inspect
@@ -18,6 +21,7 @@ module Fakes
       raise 'Stack is dead' unless @exists
       @outputs[key]
     end
+    alias_method :find_output, :output
 
     def set_output(key, value)
       @outputs[key] = value

data/spec/functional/deploy_spec.rb

@@ -61,6 +61,8 @@ describe 'Deploy' do
       allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-asg-swap-dev-base', 'base', anything) { base_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(blue_stack).to receive(:resource_statuses) { asg_ids 'blueASG' }
+      allow(green_stack).to receive(:resource_statuses) { asg_ids 'greenASG' }
       allow(blue_asg_driver).to receive(:describe) {{desired: 0, min: 0, max: 0}}
       allow(green_asg_driver).to receive(:describe) {{desired: 2, min: 1, max: 5}}
       expect(blue_asg_driver).to receive(:warm_up).with(2)

data/spec/functional/kill_inactive_spec.rb

@@ -35,23 +35,39 @@ describe 'Kill Inactive' do
   end
 
   context 'asg-swap' do
-    let(:blue_stack)  { Fakes::Stack.new(name: 'BLUE', outputs: {'ELBName' => 'BLUE-elb', 'AutoScalingGroupName' => 'blueASG'}, parameters: {:name => 'blue'}) }
+    let(:blue_stack) { Fakes::Stack.new(name: 'BLUE', outputs: {'ELBName' => 'BLUE-elb', 'AutoScalingGroupName' => 'templateBlueASG'}, parameters: {:name => 'blue'}) }
     let(:green_stack) { Fakes::Stack.new(name: 'GREEN', outputs: {'ELBName' => 'GREEN-elb', 'AutoScalingGroupName' => 'greenASG'}, parameters: {:name => 'green'}) }
-    let(:blue_asg_driver) { double('blue_asg_driver') }
+    let(:template_blue_asg_driver) { double('template_blue_asg_driver') }
+    let(:actual_blue_asg_driver) { double('actual_blue_asg_driver') }
     let(:green_asg_driver) { double('green_asg_driver') }
 
-    it 'should delete the stack that has no active instances' do
+    before :each do
       blue_stack.live!
       green_stack.live!
       allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-asg-swap-test-web-B', 'web', anything) { blue_stack }
       allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-asg-swap-test-web-G', 'web', anything) { green_stack }
       allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
-      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('blueASG') { blue_asg_driver }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('templateBlueASG') { template_blue_asg_driver }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('actualBlueASG') { actual_blue_asg_driver }
+    end
+
+    it 'should delete the stack that has no active instances' do
+      allow(blue_stack).to receive(:resource_statuses) { asg_ids 'actualBlueASG' }
+      allow(actual_blue_asg_driver).to receive(:'exists?').and_return(true)
       allow(green_asg_driver).to receive(:describe) { {desired: 0, min: 0, max: 0} }
-      allow(blue_asg_driver).to receive(:describe) { {desired: 1, min: 1, max: 2} }
+      allow(actual_blue_asg_driver).to receive(:describe) { {desired: 1, min: 1, max: 2} }
       CfDeployer::CLI.start(['kill_inactive', 'test', 'web', '-f', 'samples/simple/cf_deployer.yml'])
       expect(green_stack).to be_deleted
       expect(blue_stack).not_to be_deleted
     end
+
+    it 'should determine active instances from CF stack' do
+      allow(blue_stack).to receive(:resource_statuses) { asg_ids 'actualBlueASG' }
+      allow(template_blue_asg_driver).to receive(:describe) { {desired: 0, min: 0, max: 0} }
+      allow(actual_blue_asg_driver).to receive(:describe) { {desired: 1, min: 1, max: 1} }
+
+      CfDeployer::CLI.start(['kill_inactive', 'test', 'web', '-f', 'samples/simple/cf_deployer.yml'])
+      expect(blue_stack).not_to be_deleted
+    end
   end
 end

data/spec/functional_spec_helper.rb

@@ -1,3 +1,10 @@
 require 'spec_helper'
 
 ARGV.clear
+
+def asg_ids(*ids)
+  values = Hash[ids.zip([nil] * ids.length)]
+  {
+      asg_instances: values
+  }
+end

data/spec/unit/deployment_strategy/auto_scaling_group_swap_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'functional_spec_helper'
 
 describe 'Auto Scaling Group Swap Deployment Strategy' do
   let(:app) { 'myapp' }
@@ -6,12 +6,12 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
   let(:component) { 'worker' }
 
   let(:context) {
-        {
-          :'deployment-strategy' => 'auto-scaling-group-swap',
-          :settings => {
+    {
+        :'deployment-strategy' => 'auto-scaling-group-swap',
+        :settings => {
             :'auto-scaling-group-name-output' => ['AutoScalingGroupID']
-          }
         }
+    }
   }
 
   let(:blue_asg_driver) { double('blue_asg_driver') }
@@ -23,6 +23,10 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
   before :each do
     allow(blue_stack).to receive(:output).with('AutoScalingGroupID'){'blueASG'}
     allow(green_stack).to receive(:output).with('AutoScalingGroupID'){'greenASG'}
+    allow(blue_stack).to receive(:find_output).with('AutoScalingGroupID'){'blueASG'}
+    allow(green_stack).to receive(:find_output).with('AutoScalingGroupID'){'greenASG'}
+    allow(blue_stack).to receive(:resource_statuses) { asg_ids('blueASG') }
+    allow(green_stack).to receive(:resource_statuses) { asg_ids('greenASG') }
     allow(CfDeployer::Stack).to receive(:new).with('myapp-dev-worker-B', 'worker', context) { blue_stack }
     allow(CfDeployer::Stack).to receive(:new).with('myapp-dev-worker-G', 'worker', context) { green_stack }
   end
@@ -59,7 +63,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
       CfDeployer::DeploymentStrategy.create(app, env, component, context).deploy
     end
 
-     it 'should deploy blue stack if green stack is not active' do
+    it 'should deploy blue stack if green stack is not active' do
       blue_stack.die!
       green_stack.live!
       allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
@@ -137,7 +141,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
       CfDeployer::DeploymentStrategy.create(app, env, component, context).deploy
     end
 
-     it 'should deploy green stack if blue stack is active' do
+    it 'should deploy green stack if blue stack is active' do
       blue_stack.live!
       green_stack.live!
       allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
@@ -196,17 +200,17 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
 
     context 'multiple ASG' do
       let(:context) {
-            {
-              :'deployment-strategy' => 'auto-scaling-group-swap',
-              :settings => {
+        {
+            :'deployment-strategy' => 'auto-scaling-group-swap',
+            :settings => {
                 :'auto-scaling-group-name-output' => ['AutoScalingGroupID', 'AlternateASGID']
-              }
             }
+        }
       }
 
       it 'should get error containing only "active" ASG if both blue and green stacks are active' do
-        allow(blue_stack).to receive(:output).with('AlternateASGID'){'AltblueASG'}
-        allow(green_stack).to receive(:output).with('AlternateASGID'){'AltgreenASG'}
+        allow(blue_stack).to receive(:find_output).with('AlternateASGID'){'AltblueASG'}
+        allow(green_stack).to receive(:find_output).with('AlternateASGID'){'AltgreenASG'}
         blue_stack.live!
         green_stack.live!
         alt_blue_asg_driver = double('alt_blue_asg_driver')
@@ -215,6 +219,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
         allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('blueASG') { blue_asg_driver }
         allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('AltgreenASG') { alt_green_asg_driver }
         allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
+        allow(blue_stack).to receive(:resource_statuses) { asg_ids('blueASG', 'AltblueASG') }
         allow(alt_blue_asg_driver).to receive(:describe) {{desired: 1, min: 1, max: 2}}
         allow(alt_green_asg_driver).to receive(:describe) {{desired: 0, min: 0, max: 0}}
         allow(blue_asg_driver).to receive(:describe) {{desired: 1, min: 1, max: 2}}
@@ -345,6 +350,21 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
     end
   end
 
+  context '#cool_down_active_stack' do
+    it 'should cool down only those ASGs which actually exist' do
+      blue_stack.live!
+      green_stack.die!
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('blueASG') { blue_asg_driver }
+      allow(green_asg_driver).to receive(:describe) { {desired: 0, min: 0, max: 0 } }
+      allow(blue_asg_driver).to receive(:describe) { {desired: 1, min: 1, max: 3 } }
+
+      strategy = CfDeployer::DeploymentStrategy.create(app, env, component, context)
+      expect(blue_asg_driver).to receive(:cool_down)
+      strategy.send(:cool_down_active_stack)
+    end
+  end
+
   describe '#asg_driver' do
     it 'returns the same driver for the same aws_group_name' do
       strategy = CfDeployer::DeploymentStrategy.create(app, env, component, context)
@@ -358,7 +378,6 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
   end
 
   context '#output_value' do
-
     it 'should get stack output if active stack exists' do
       blue_stack.live!
       green_stack.live!
@@ -383,53 +402,90 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
   end
 
   context '#status' do
-     before :each do
+    before :each do
       blue_stack.live!
       green_stack.live!
       allow(blue_stack).to receive(:status) { 'blue deployed' }
       allow(green_stack).to receive(:status) { 'green deployed' }
-      allow(blue_stack).to receive(:resource_statuses) { 'blue resources' }
-      allow(green_stack).to receive(:resource_statuses) { 'green resources' }
-      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
       allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('blueASG') { blue_asg_driver }
-      allow(green_asg_driver).to receive(:describe) {{desired: 0, min: 0, max: 0}}
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
       allow(blue_asg_driver).to receive(:describe) {{desired: 3, min: 1, max: 5}}
+      allow(green_asg_driver).to receive(:describe) {{desired: 0, min: 0, max: 0}}
       asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
 
     end
 
     it 'should get status for both green and blue stacks' do
       asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
-      expected_result = { 
-        'BLUE' => {
-          :active => true,
-          :status => 'blue deployed'
-        },
-         'GREEN' => {
-          :active => false,
-          :status => 'green deployed'
-        }
+      expected_result = {
+          'BLUE' => {
+              :active => true,
+              :status => 'blue deployed'
+          },
+          'GREEN' => {
+              :active => false,
+              :status => 'green deployed'
+          }
       }
       asg_swap.status.should eq(expected_result)
     end
 
     it 'should get status for both green and blue stacks including resources info' do
       asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
-      expected_result = { 
-        'BLUE' => {
-          :active => true,
-          :status => 'blue deployed',
-          :resources => 'blue resources'
-        },
-         'GREEN' => {
-          :active => false,
-          :status => 'green deployed',
-          :resources => 'green resources'
-        }
+      expected_result = {
+          'BLUE' => {
+              :active => true,
+              :status => 'blue deployed',
+              :resources => {
+                  :asg_instances => {
+                      'blueASG' => nil
+                  }
+              }
+          },
+          'GREEN' => {
+              :active => false,
+              :status => 'green deployed',
+              :resources => {
+                  :asg_instances => {
+                      'greenASG' => nil
+                  }
+              }
+          }
       }
       asg_swap.status(true).should eq(expected_result)
     end
+  end
+
+  context 'new ASG' do
+    let(:foo_asg_driver) { double('foo_asg_driver') }
+    let(:bar_asg_driver) { double('bar_asg_driver') }
+
+    before :each do
+      allow(foo_asg_driver).to receive(:describe) { {min: 1, desired: 2, max: 3} }
+      allow(bar_asg_driver).to receive(:describe) { {min: 0, desired: 0, max: 0} }
+    end
+
+    it 'should get active ASGs from CF stack' do
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('foo') { foo_asg_driver }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('bar') { bar_asg_driver }
+      allow(blue_stack).to receive(:resource_statuses) { asg_ids('foo', 'bar') }
+
+      asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
+      asg_swap.send(:get_active_asgs, blue_stack).should eq(['foo'])
+    end
+  end
 
+  context '#stack_active' do
+    it 'should consider a stack active if it has any active ASGs' do
+      allow(CfDeployer::Stack).to receive(:new).with('myapp-dev-worker-B', 'worker', context) { blue_stack }
+      allow(CfDeployer::Stack).to receive(:new).with('myapp-dev-worker-G', 'worker', context) { green_stack }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('greenASG') { green_asg_driver }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('blueASG') { blue_asg_driver }
+      allow(blue_asg_driver).to receive(:describe) { {min: 1, desired: 2, max: 3} }
+      allow(green_asg_driver).to receive(:describe) { {min: 0, desired: 0, max: 0} }
 
+      asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
+      asg_swap.send(:stack_active?, blue_stack).should be(true)
+    end
   end
 end

data/spec/unit/deployment_strategy/base_spec.rb

@@ -134,4 +134,78 @@ describe 'Base Deployment Strategy' do
       strategy.run_hook(:some_hook)
     end
   end
+
+  context '#warm_up_stack' do
+    let(:context) {
+      {
+          :'deployment-strategy' => 'base',
+          :settings => {
+              :'auto-scaling-group-name-output' => ['ASG1', 'ASG2']
+          }
+      }
+    }
+    let(:blue_stack) { double('blue_stack') }
+    let(:green_stack) { double('green_stack') }
+    let(:blue_asg_driver_1) { double('blue_asg_driver_1') }
+    let(:blue_asg_driver_2) { double('blue_asg_driver_2') }
+    let(:green_asg_driver_1) { double('green_asg_driver_1') }
+    let(:green_asg_driver_2) { double('green_asg_driver_2') }
+
+    before :each do
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('blue_asg_driver_1') { blue_asg_driver_1 }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('blue_asg_driver_2') { blue_asg_driver_2 }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('green_asg_driver_1') { green_asg_driver_1 }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('green_asg_driver_2') { green_asg_driver_2 }
+
+      allow(green_stack).to receive(:find_output).with('ASG1') { 'green_asg_driver_1' }
+      allow(green_stack).to receive(:find_output).with('ASG2') { 'green_asg_driver_2' }
+    end
+
+    it 'should warm up ASG with previous stack ASG values when present' do
+      allow(blue_stack).to receive(:resource_statuses) { { 'blueASG1' => nil, 'blueASG2' => nil } }
+      allow(blue_stack).to receive(:find_output).with('ASG1') { 'blue_asg_driver_1' }
+      allow(blue_stack).to receive(:find_output).with('ASG2') { 'blue_asg_driver_2' }
+      allow(blue_asg_driver_1).to receive(:describe) { {min: 1, desired: 2, max: 3} }
+      allow(blue_asg_driver_2).to receive(:describe) { {min: 2, desired: 3, max: 4} }
+      strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', context)
+
+      expect(green_asg_driver_1).to receive(:warm_up).with(2)
+      expect(green_asg_driver_2).to receive(:warm_up).with(3)
+      strategy.send(:warm_up_stack, green_stack, blue_stack)
+    end
+
+    it 'should warm up ASG with own values when previous stack does not contain ASG' do
+      allow(blue_stack).to receive(:find_output).with(anything) { nil }
+      allow(green_asg_driver_1).to receive(:describe) { {min: 3, desired: 4, max: 5} }
+      allow(green_asg_driver_2).to receive(:describe) { {min: 4, desired: 5, max: 6} }
+      strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', context)
+
+      expect(green_asg_driver_1).to receive(:warm_up).with(4)
+      expect(green_asg_driver_2).to receive(:warm_up).with(5)
+      strategy.send(:warm_up_stack, green_stack, blue_stack)
+    end
+  end
+
+  context '#template_asg_name_to_ids' do
+    let(:context) {
+      {
+          :'deployment-strategy' => 'base',
+          :settings => {
+              :'auto-scaling-group-name-output' => ['ASG1', 'ASG2']
+          }
+      }
+    }
+
+    it 'should map names in templates to stack outputs' do
+      allow(blue_stack).to receive(:find_output).with('ASG1') { 'blue_asg_driver_1' }
+      allow(blue_stack).to receive(:find_output).with('ASG2') { 'blue_asg_driver_2' }
+      expected = {
+          'ASG1' => 'blue_asg_driver_1',
+          'ASG2' => 'blue_asg_driver_2',
+      }
+
+      strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', context)
+      expect(strategy.send(:template_asg_name_to_ids, blue_stack)).to eq(expected)
+    end
+  end
 end

data/spec/unit/deployment_strategy/create_or_update_spec.rb

@@ -61,7 +61,7 @@ describe 'CreateOrUpdate Strategy' do
       context[:settings] = {}
       context[:settings][:'auto-scaling-group-name-output'] = ['AutoScalingGroupID']
       @stack.should_receive(:exists?).and_return(false)
-      allow(@stack).to receive(:output).with('AutoScalingGroupID') { 'asg_name' }
+      allow(@stack).to receive(:find_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)

data/spec/unit/driver/cloud_formation_spec.rb

@@ -1,10 +1,28 @@
 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(:resource_summaries) { [
+      {
+          :resource_type => 'AWS::AutoScaling::AutoScalingGroup',
+          :physical_resource_id => 'asg_1',
+          :resource_status => 'STATUS_1'
+      },
+      {
+          :resource_type => 'AWS::AutoScaling::LaunchConfiguration',
+          :physical_resource_id => 'launch_config_1',
+          :resource_status => 'STATUS_2'
+      },
+      {
+          :resource_type => 'AWS::AutoScaling::AutoScalingGroup',
+          :physical_resource_id => 'asg_2',
+          :resource_status => 'STATUS_2'
+      }
+  ] }
+  let(:stack) { double('stack', :outputs => outputs, :parameters => parameters, :resource_summaries => resource_summaries) }
   let(:cloudFormation) {
     double('cloudFormation',
            :stacks =>
@@ -25,8 +43,18 @@ describe 'CloudFormation' do
   end
 
   context 'resource_statuses' do
-    it 'should be tested' do
-      false
+    it 'should get resource statuses' do
+      expected = {
+          'AWS::AutoScaling::AutoScalingGroup' => {
+              'asg_1' => 'STATUS_1',
+              'asg_2' => 'STATUS_2'
+          },
+          'AWS::AutoScaling::LaunchConfiguration' => {
+              'launch_config_1' => 'STATUS_2'
+          }
+      }
+
+      CfDeployer::Driver::CloudFormation.new('testStack').resource_statuses.should eq(expected)
     end
   end
 end

data/spec/unit/stack_spec.rb

@@ -59,8 +59,31 @@ describe CfDeployer::Stack do
     end
   end
 
-  context "#ready?" do
+  context '#output' do
+    it 'should get output value' do
+      expect(@cf_driver).to receive(:query_output).with('mykey'){ 'myvalue'}
+      @stack.output('mykey').should eq('myvalue')
+    end
 
+    it 'should get error if output is empty' do
+      expect(@cf_driver).to receive(:query_output).with('mykey'){ nil }
+      expect{@stack.output('mykey')}.to raise_error("'mykey' is empty from stack test output")
+    end
+  end
+
+  context '#find_output' do
+    it 'should get output value' do
+      expect(@cf_driver).to receive(:query_output).with('mykey'){ 'myvalue'}
+      @stack.find_output('mykey').should eq('myvalue')
+    end
+
+    it 'should return nil for non-existent value' do
+      expect(@cf_driver).to receive(:query_output).with('mykey'){ nil }
+      @stack.find_output('mykey').should be(nil)
+    end
+  end
+
+  context "#ready?" do
     CfDeployer::Stack::READY_STATS.each do |status|
       it "should be ready when in #{status} status" do
         allow(@cf_driver).to receive(:stack_status) { status }
@@ -72,16 +95,6 @@ describe CfDeployer::Stack do
       allow(@cf_driver).to receive(:stack_status) { :my_fake_status }
       expect(@stack).not_to be_ready
     end
-
-    it "should get error if output is empty" do
-      expect(@cf_driver).to receive(:query_output).with('mykey'){ nil }
-      expect{@stack.output('mykey')}.to raise_error("'mykey' is empty from stack test output")
-    end
-
-    it "should get output value" do
-      expect(@cf_driver).to receive(:query_output).with('mykey'){ 'myvalue'}
-      @stack.output('mykey').should eq('myvalue')
-    end
   end
 
   describe '#delete' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cf_deployer
 version: !ruby/object:Gem::Version
-  version: 1.3.8
+  version: 1.3.9
 platform: ruby
 authors:
 - Jame Brechtel
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-27 00:00:00.000000000 Z
+date: 2015-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -151,6 +151,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - ChangeLog.md
 - DETAILS.md
 - FAQ.md