cf_deployer 1.2.8

data/spec/fakes/stack.rb

@@ -0,0 +1,65 @@
+module Fakes
+  class Stack
+    attr_reader :outputs, :parameters
+    def initialize(options)
+      @exists = options[:exists?].nil? ? true : options[:exists?]
+      @outputs = options[:outputs] || {}
+      @parameters = options[:parameters] || {}
+      @name = options[:name] || 'Unnamed'
+      @status = options[:status] || :ready
+    end
+
+    def inspect
+      "#{self.class}<#{@name}>"
+    end
+    alias_method :to_s, :inspect
+
+    def output(key)
+      raise 'Stack is dead' unless @exists
+      @outputs[key]
+    end
+
+    def set_output(key, value)
+      @outputs[key] = value
+    end
+
+    def live!
+      @exists = true
+    end
+
+    def die!
+      @exists = false
+    end
+
+    def exists?
+      @exists
+    end
+
+    def delete
+      @exists = false
+      @deployed = false
+      @deleted = true
+    end
+
+    def deploy
+      @exists = true
+      @deployed = true
+    end
+
+    def deployed?
+      @deployed
+    end
+
+    def deleted?
+      @deleted
+    end
+
+    def name
+      @name
+    end
+
+    def status
+      @status
+    end
+  end
+end

data/spec/functional/deploy_spec.rb

@@ -0,0 +1,73 @@
+require 'functional_spec_helper'
+
+describe 'Deploy' do
+  context 'create-or-update' do
+
+    let(:asg_driver) { double('asg_driver') }
+    let(:stack) { Fakes::Stack.new(name: 'stack', outputs: {'AutoScalingGroupID' => 'myASG'})}
+
+    it 'should create a stack in Cloud Formation' do
+      stack.die!
+      allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-create-or-update-test-web', 'web', anything()) { stack }
+      allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('myASG') { asg_driver }
+      allow(asg_driver).to receive(:describe) {{desired: 1, min: 1, max: 2}}
+      allow(asg_driver).to receive(:warm_up).with(1)
+      CfDeployer::CLI.start(['deploy', 'test', 'web', '-f', 'samples/create-or-update/cf_deployer.yml'])
+      expect(stack).to be_deployed
+    end
+  end
+
+  context 'cname-swap' do
+    let(:blue_asg_driver) { double('blue_asg_driver') }
+    let(:green_asg_driver) { double('green_asg_driver') }
+    let(:dns_driver) { double('route53') }
+    let(:elb_driver) { double('elb') }
+    let(:blue_stack)  { Fakes::Stack.new(name: 'BLUE', outputs: {'ELBName' => 'BLUE-elb', 'AutoScalingGroupName' => 'blueASG'}, parameters: {:name => 'blue'}) }
+    let(:green_stack) { Fakes::Stack.new(name: 'GREEN', outputs: {'ELBName' => 'GREEN-elb', 'AutoScalingGroupName' => 'greenASG'}, parameters: {:name => 'green'}) }
+
+    before :each do
+      allow(Kernel).to receive(:sleep)
+    end
+    it 'should recreate inactive stack and set CNAME map to its ELB dns' do
+      allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-cname-swap-dev-web-B', 'web', anything()) { blue_stack }
+      allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-cname-swap-dev-web-G', 'web', anything()) { green_stack }
+      allow(CfDeployer::Driver::Elb).to receive(:new) { elb_driver }
+      allow(CfDeployer::Driver::Route53).to receive(:new) { dns_driver }
+      allow(dns_driver).to receive(:find_alias_target).with('zhao.com', 'test1.zhao.com'){ 'BLUE-elb.zhao.com' }
+      allow(elb_driver).to receive(:find_dns_and_zone_id).with('BLUE-elb') { {:dns_name => 'blue-elb.zhao.com', :canonical_hosted_zone_name_id => 'BLUE111'}}
+      allow(elb_driver).to receive(:find_dns_and_zone_id).with('GREEN-elb') { {:dns_name => 'green-elb.zhao.com', :canonical_hosted_zone_name_id => 'GREEN111'}}
+      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(green_asg_driver).to receive(:describe) {{desired: 0, min: 0, max: 0}}
+      allow(blue_asg_driver).to receive(:describe) {{desired: 2, min: 1, max: 5}}
+      allow(dns_driver).to receive(:set_alias_target).with('zhao.com', 'test1.zhao.com', 'GREEN111', 'green-elb.zhao.com')
+      expect(green_asg_driver).to receive(:warm_up).with(2)
+      CfDeployer::CLI.start(['deploy', 'dev', 'web', '-f', 'samples/cname-swap/cf_deployer.yml'])
+      expect(green_stack).to be_deleted
+      expect(green_stack).to be_deployed
+    end
+  end
+
+  context 'autoscaling-swap' do
+    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', 'AutoScalingGroupName' => 'blueASG'}, parameters: { name: 'blue'}) }
+    let(:green_stack)  { Fakes::Stack.new(name: 'GREEN', outputs: {'web-elb-name' => 'GREEN-elb', 'AutoScalingGroupName' => 'greenASG'}, parameters: { name: 'green'}) }
+    let(:base_stack)  { Fakes::Stack.new(name: 'base') }
+
+    it 'should re-create and warm up inactive stack and cool down the active stack' do
+      allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-asg-swap-dev-web-B', 'web', anything) { blue_stack }
+      allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-asg-swap-dev-web-G', 'web', anything) { green_stack }
+      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_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)
+
+      CfDeployer::CLI.start(['deploy', 'dev', 'web', '-f', 'samples/simple/cf_deployer.yml'])
+      expect(blue_stack).to be_deleted
+      expect(blue_stack).to be_deployed
+    end
+  end
+end

data/spec/functional/kill_inactive_spec.rb

@@ -0,0 +1,57 @@
+require 'functional_spec_helper'
+
+describe 'Kill Inactive' do
+  context 'create-or-update' do
+    let(:stack) { Fakes::Stack.new(name: 'stack', outputs: {'AutoScalingGroupID' => 'myASG'})}
+
+    it 'should raise an error that there is no inactive for create-or-update staks' do
+      stack.die!
+      allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-create-or-update-test-web', 'web', anything()) { stack }
+      expect { CfDeployer::CLI.start(['kill_inactive', 'test', 'web', '-f', 'samples/create-or-update/cf_deployer.yml']) }.to raise_error CfDeployer::ApplicationError, 'There is no inactive version to kill for Create or Update Deployments.'
+    end
+  end
+
+  context 'cname-swap' do
+    let(:blue_stack)  { Fakes::Stack.new(name: 'BLUE', outputs: {'ELBName' => 'BLUE-elb', 'AutoScalingGroupID' => 'blueASG'}, parameters: {:name => 'blue'}) }
+    let(:green_stack) { Fakes::Stack.new(name: 'GREEN', outputs: {'ELBName' => 'GREEN-elb', 'AutoScalingGroupID' => 'greenASG'}, parameters: {:name => 'green'}) }
+
+    it 'should delete the stack that is not being pointed to by dns' do
+      blue_stack.live!
+      green_stack.live!
+      elb_driver = double('elb_driver')
+      allow(CfDeployer::Driver::Elb).to receive(:new) { elb_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'}}
+      allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-cname-swap-test-web-B', 'web', anything) { blue_stack }
+      allow(CfDeployer::Stack).to receive(:new).with('cf-deployer-sample-cname-swap-test-web-G', 'web', anything) { green_stack }
+      dns_driver = double('route53 driver')
+      allow(CfDeployer::Driver::Route53).to receive(:new) { dns_driver }
+      allow(dns_driver).to receive(:find_alias_target).with('zhao.com', 'test1.zhao.com'){ 'BLUE-elb.aws.amazon.com' }
+
+      CfDeployer::CLI.start(['kill_inactive', 'test', 'web', '-f', 'samples/cname-swap/cf_deployer.yml'])
+      expect(green_stack).to be_deleted
+      expect(blue_stack).not_to be_deleted
+    end
+  end
+
+  context 'asg-swap' do
+    let(:blue_stack)  { Fakes::Stack.new(name: 'BLUE', outputs: {'ELBName' => 'BLUE-elb', 'AutoScalingGroupName' => 'blueASG'}, 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(:green_asg_driver) { double('green_asg_driver') }
+
+    it 'should delete the stack that has no active instances' 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(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} }
+      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
+  end
+end

data/spec/functional_spec_helper.rb

@@ -0,0 +1,3 @@
+require 'spec_helper'
+
+ARGV.clear

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require_relative '../lib/cf_deployer'
+Dir.glob("#{File.dirname File.absolute_path(__FILE__)}/fakes/*.rb") { |file| require file }
+
+CfDeployer::Log.log.outputters = nil
+
+def puts *args
+
+end

data/spec/unit/application_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe "application" do
+  before :each do
+    @context = {
+      :application => 'myApp',
+      :environment => 'dev',
+      :targets => ['queue', 'web', 'db', 'base'],
+      :components => {
+          :queue => {
+            :'depends-on' => [ 'base', 'db' ]
+          },
+          :web => {
+            :'depends-on' => [ 'db', 'queue' ]
+          },
+          :db => {
+            :'depends-on' => [ 'base']
+          },
+          :base => {
+          }
+        }
+    }
+    @app = CfDeployer::Application.new(@context)
+    @base = @app.components.find{ |c| c.name == 'base' }
+    @db = @app.components.find{ |c| c.name == 'db' }
+    @queue = @app.components.find{ |c| c.name == 'queue' }
+    @web = @app.components.find{ |c| c.name == 'web' }
+  end
+
+  it "application should get all components" do
+    @app.components.length.should eq(4)
+    @base.should_not be_nil
+    @db.should_not be_nil
+    @queue.should_not be_nil
+    @web.should_not be_nil
+  end
+
+  context "order components by dependencies" do
+    it "should get components ordered by dependencies" do
+        expect(@app.components).to eq([@base, @db, @queue, @web])
+    end
+  end
+
+  context 'destroy' do
+    it 'should destroy components starting with components without dependents' do
+      log = ""
+      allow(@base).to receive(:destroy) { log += "base "}
+      allow(@db).to receive(:destroy) { log += "db "}
+      allow(@queue).to receive(:destroy) { log += "queue "}
+      allow(@web).to receive(:destroy) { log += "web "}
+      @app.destroy
+      expect(log).to eql("web queue db base ")
+    end
+
+    it 'should destroy specified components' do
+      log = ""
+      allow(@base).to receive(:destroy) { log += "base "}
+      allow(@db).to receive(:destroy) { log += "db "}
+      allow(@queue).to receive(:destroy) { log += "queue "}
+      allow(@web).to receive(:destroy) { log += "web "}
+      @context[:targets] = ['db', 'web', 'queue']
+      @app.destroy
+      expect(log).to eql("web queue db ")
+    end
+  end
+
+  it "application should get components with their dependencies" do
+    expect(@base.dependencies).to match_array([])
+    expect(@db.dependencies).to match_array([@base])
+    expect(@queue.dependencies).to match_array([@base, @db])
+    expect(@web.dependencies).to match_array([@db, @queue])
+  end
+
+  it 'should get add components with their children' do
+    expect(@base.children).to match_array([@db, @queue])
+    expect(@db.children).to match_array([@web, @queue])
+    expect(@queue.children).to match_array([@web])
+    expect(@web.children).to match_array([])
+  end
+
+  describe '#switch' do
+
+    let(:app) { CfDeployer::Application.new(@context.merge(:targets => ['base'])) }
+
+    it 'should switch the specified component' do
+      base = app.components.find { |c| c.name == 'base' }
+      expect(base).to receive :switch
+      app.switch
+    end
+
+    it 'should not switch components not specified' do
+      db = app.components.find { |c| c.name == 'db' }
+      queue = app.components.find { |c| c.name == 'queue' }
+      web = app.components.find { |c| c.name == 'web' }
+      base = app.components.find { |c| c.name == 'base' }
+      allow(base).to receive :switch
+      expect(db).not_to receive :switch
+      expect(queue).not_to receive :switch
+      expect(web).not_to receive :switch
+      app.switch
+    end
+  end
+
+  describe '#kill_inactive' do
+    it 'should kill the inactive piece of a component' do
+      @context[:targets] = ['base']
+      app = CfDeployer::Application.new(@context)
+      base = app.components.find{ |c| c.name == 'base' }
+      expect(base).to receive(:kill_inactive)
+      app.kill_inactive
+    end
+  end
+
+  describe '#status' do
+    it "should get each component's status" do
+      expect(@base).to receive(:status)
+      expect(@db).to receive(:status)
+      expect(@queue).to receive(:status)
+      expect(@web).to receive(:status)
+
+      @app.status nil, 'all'
+    end
+
+    it 'should pass the get_resource_statuses flag down to the components' do
+      expect(@base).to receive(:status).with(true)
+      expect(@db).to receive(:status).with(true)
+      expect(@queue).to receive(:status).with(true)
+      expect(@web).to receive(:status).with(true)
+
+      @app.status nil, 'all'
+    end
+
+    it 'should filter by component if specified' do
+      expect(@base).not_to receive(:status)
+      expect(@db).not_to receive(:status)
+      expect(@queue).not_to receive(:status)
+
+      expect(@web).to receive(:status).with(true)
+
+      @app.status 'web', 'all'
+    end
+  end
+
+  context "deploy components" do
+     before :each do
+        @log = ""
+        allow(@base).to receive(:deploy) { @log += "base "}
+        allow(@db).to receive(:deploy) { @log += "db "}
+        allow(@queue).to receive(:deploy) { @log += "queue "}
+        allow(@web).to receive(:deploy) { @log += "web "}
+     end
+
+
+    context "deploy all components" do
+      it "should deploy all components if no component specified" do
+        @app.deploy
+        @log.should eq("base db queue web ")
+      end
+    end
+
+    context "deploy some components" do
+      it "should deploy specified components" do
+        @context[:targets] = ['web', 'db']
+        @app.deploy
+        @log.should eq("db web ")
+      end
+    end
+  end
+
+  context '#json' do
+
+    before :each do
+      @log = ''
+      allow(@base).to receive(:json) { @log += "base " }
+      allow(@db).to receive(:json) { @log += "db " }
+      allow(@queue).to receive(:json) { @log += "queue " }
+      allow(@web).to receive(:json) { @log += "web " }
+    end
+
+    it 'should get json templates for all components' do
+      @app.json
+      @log.should eq("base db queue web ")
+    end
+
+    it 'should get json templates for components specified' do
+      @context[:targets] = ['web', 'db']
+      @app.json
+      @log.should eq('db web ')
+    end
+  end
+end

data/spec/unit/component_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe "component" do
+  before :each do
+    @strategy = double('deployment_strategy')
+
+    allow(CfDeployer::DeploymentStrategy).to receive(:create).and_return(@strategy)
+
+       @context = {
+          :'deployment-strategy' => 'create-or-update',
+          :inputs => {
+            :'vpc-subnets' => {
+              :component => 'base',
+              :'output-key' => 'subnets'
+            }
+           }
+          }
+    @base = CfDeployer::Component.new('myApp', 'uat', 'base', {})
+    @db = CfDeployer::Component.new('myApp', 'uat', 'db', {})
+
+    @web = CfDeployer::Component.new('myApp', 'uat', 'web', @context)
+    @web.dependencies << @base
+    @web.dependencies << @db
+    @base.children << @web
+    @db.children << @web
+  end
+
+  context 'json' do
+
+    it 'should revolve settings from parent components if parent components has been deployed' do
+      allow(@base).to receive(:exists?){ true }
+      allow(@base).to receive(:output_value).with('subnets') { 'abcd1234, edfas1234' }
+      expect(CfDeployer::ConfigLoader).to receive(:component_json).with('web', @context)
+      @web.json
+
+      expect(@context[:inputs][:'vpc-subnets']).to eq('abcd1234, edfas1234')
+    end
+  end
+
+
+  it "should destroy component" do
+    expect(@strategy).to receive(:destroy)
+    @web.destroy
+  end
+
+  it 'should not destroy a component that is depended on' do
+    allow(@web).to receive(:exists?){ true }
+    expect(@strategy).not_to receive(:destroy)
+    expect{ @base.destroy }.to raise_error("Unable to destroy #{@base.name}, it is depended on by other components")
+  end
+
+  it "should get output value" do
+    expect(@strategy).to receive(:output_value).with('key1'){ 'value1' }
+    @web.output_value('key1')
+  end
+
+  it "deployment should only deploy depends-on if the depends-on do not exists" do
+    expect(@base).to receive(:exists?){ false }
+    expect(@db).to receive(:exists?) { true }
+    expect(@base).to receive(:deploy)
+    expect(@db).to_not receive(:deploy)
+    expect(@strategy).to receive(:deploy)
+    expect(@base).to receive(:output_value).with('subnets') { 'abcd1234, edfas1234' }
+    @web.deploy
+
+    expect(@context[:inputs][:'vpc-subnets']).to eq('abcd1234, edfas1234')
+  end
+
+  it "should ask strategy if component exists" do
+     expect(@strategy).to receive(:exists?){ true }
+     @web.exists?.should eq(true)
+  end
+
+  it "should find direct dependencies" do
+    web = CfDeployer::Component.new('myApp', 'uat', 'web', {})
+    base = CfDeployer::Component.new('myApp', 'uat', 'base', {})
+    web.dependencies << base
+
+    web.depends_on?(base).should eq(true)
+  end
+
+  it "should find transitive dependencies" do
+    web = CfDeployer::Component.new('myApp', 'uat', 'web', {})
+    haproxy = CfDeployer::Component.new('myApp', 'uat', 'haproxy', {})
+    base = CfDeployer::Component.new('myApp', 'uat', 'base', {})
+
+    haproxy.dependencies << base
+    web.dependencies << haproxy
+
+    web.depends_on?(base).should eq(true)
+  end
+
+  it "should find cyclic dependency" do
+    web = CfDeployer::Component.new('myApp', 'uat', 'web', {})
+    haproxy = CfDeployer::Component.new('myApp', 'uat', 'haproxy', {})
+    base = CfDeployer::Component.new('myApp', 'uat', 'base', {})
+    foo = CfDeployer::Component.new('myApp', 'uat', 'foo', {})
+
+    haproxy.dependencies << base
+    web.dependencies << haproxy
+    base.dependencies << web
+
+    expect{haproxy.depends_on? foo}.to raise_error("Cyclic dependency")
+  end
+
+  describe '#status' do
+    it "should ask strategy for status" do
+       expect(@strategy).to receive(:status){ true }
+       @web.status false
+    end
+
+    it "should pass get_resource_statuses down to the strategy" do
+       expect(@strategy).to receive(:status).with(true)
+       @web.status(true)
+    end
+  end
+
+  describe '#kill_inactive' do
+    it 'should tell the strategy to kill the inactive piece' do
+      expect(@strategy).to receive(:kill_inactive)
+      @web.kill_inactive
+    end
+  end
+
+  describe '#switch' do
+    context 'if no stack exists' do
+      it 'should raise an error that there is no stack for the component' do
+        allow(@strategy).to receive(:exists?) { false }
+        expect(@strategy).not_to receive(:switch)
+        expect { @web.switch }.to raise_error 'No stack exists for component: web'
+      end
+    end
+
+    context 'a stack exists' do
+      it 'should use the deployment strategy to switch' do
+        allow(@strategy).to receive(:exists?) { true }
+        expect(@strategy).to receive(:switch)
+        @web.switch
+      end
+    end
+  end
+end