cf_deployer 1.2.8

data/spec/unit/driver/route53_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe CfDeployer::Driver::Route53 do
+  subject { CfDeployer::Driver::Route53.new }
+
+  describe ".find_alias_target" do
+    it "should raise an error when the target zone cannot be found" do
+      route53 = double('route53')
+      allow(AWS::Route53).to receive(:new) { route53 }
+
+      allow(route53).to receive(:hosted_zones) { [] }
+
+      expect { subject.find_alias_target('abc.com', 'foo') }.to raise_error('Target zone not found!')
+    end
+
+    it "should get empty alias target when the target host cannot be found" do
+      zone = double('zone')
+      allow(zone).to receive(:name) { 'target.com.' }
+      allow(zone).to receive(:resource_record_sets) { [] }
+
+      route53 = double('route53')
+      allow(AWS::Route53).to receive(:new) { route53 }
+      allow(route53).to receive(:hosted_zones) { [zone] }
+
+      subject.find_alias_target('target.com', 'foo').should be_nil
+    end
+
+    it "should get alias target" do
+      host = double('host', :name => 'foo.target.com.', :alias_target => { :dns_name => 'abc.com.'})
+      zone = double('zone', :name => 'target.com.', :resource_record_sets => [host])
+      route53 = double('route53', :hosted_zones => [zone])
+      allow(AWS::Route53).to receive(:new) { route53 }
+
+      subject.find_alias_target('Target.com', 'Foo.target.com').should eq('abc.com')
+    end
+
+    it "should get a nil alias target when the record exists but has no alias target" do
+      host = double('host', :name => 'foo.target.com.', :alias_target => nil)
+      zone = double('zone', :name => 'target.com.', :resource_record_sets => [host])
+      route53 = double('route53', :hosted_zones => [zone])
+      allow(AWS::Route53).to receive(:new) { route53 }
+
+      subject.find_alias_target('target.com', 'foo.target.com').should be_nil
+    end
+
+    it "should get alias target when zone and host name having trailing dot" do
+      host = double('host', :name => 'foo.target.com.', :alias_target => { :dns_name => 'abc.com.'})
+      zone = double('zone', :name => 'target.com.', :resource_record_sets => [host])
+      route53 = double('route53', :hosted_zones => [zone])
+      allow(AWS::Route53).to receive(:new) { route53 }
+
+      subject.find_alias_target('target.com.', 'foo.target.com.').should eq('abc.com')
+    end
+
+  end
+
+  describe ".set_alias_target" do
+    it "should raise an error when the target-zone cannot be found" do
+      route53 = double('route53')
+      allow(AWS::Route53).to receive(:new) { route53 }
+
+      allow(route53).to receive(:hosted_zones) { [] }
+
+      expect { subject.set_alias_target('abc.com', 'foo', 'abc', 'def') }.to raise_error('Target zone not found!')
+    end
+
+    it "should attempt multiple times" do
+      failing_route53 = Fakes::AWSRoute53.new(times_to_fail: 5, hosted_zones: [double(name: 'abc.com.', path: '')])
+      route53_driver = CfDeployer::Driver::Route53.new(failing_route53)
+
+      allow(route53_driver).to receive(:sleep)
+      route53_driver.set_alias_target('abc.com', 'foo', 'abc', 'def')
+
+      expect(failing_route53.client.fail_counter).to eq(6)
+    end
+
+    it "should raise an exception when failing more than 20 times" do
+      failing_route53 = Fakes::AWSRoute53.new(times_to_fail: 21, hosted_zones: [double(name: 'abc.com.', path: '')])
+      route53_driver = CfDeployer::Driver::Route53.new(failing_route53)
+
+      allow(route53_driver).to receive(:sleep)
+      expect { route53_driver.set_alias_target('abc.com', 'foo', 'abc', 'def') }.to raise_error('Failed to update Route53 alias target record!')
+    end
+  end
+end

data/spec/unit/driver/verisign_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe CfDeployer::Driver::Verisign do
+  subject { CfDeployer::Driver::Verisign.new }
+
+  describe ".find_alias_target" do
+    it "should raise an error because it's not implemented yet" do
+      expect { subject.find_alias_target('abc.com', 'foo') }.to raise_error('Not Implemented')
+    end
+  end
+
+  describe ".set_alias_target" do
+    it "should raise an error because it's not implemented yet" do
+      expect { subject.set_alias_target('abc.com', 'foo', 'abc', 'def') }.to raise_error('Not Implemented')
+    end
+
+  end
+end

data/spec/unit/hook_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe CfDeployer::Hook do
+  before :all do
+    @file = File.expand_path("../../../tmp/test_code.rb", __FILE__)
+  end
+  it 'should eval string as hook' do
+    $result = nil
+    context = { app: 'myApp'}
+    CfDeployer::Hook.new('MyHook', "$result = context[:app]").run(context)
+    expect($result).to eq('myApp')
+  end
+
+  it 'should log the hook name ' do
+    context = { app: 'myApp'}
+    expect(CfDeployer::Log).to receive(:info).with(/My Hook/)
+    CfDeployer::Hook.new('My Hook', "$result = context[:app]").run(context)
+  end
+
+  it 'should duplicate context in hook' do
+    $result = nil
+    context = { app: 'myApp'}
+    CfDeployer::Hook.new('MyHook', "context[:app] = 'app2'").run(context)
+    expect(context[:app]).to eq('myApp')
+  end
+
+  it 'should timeout when executing hook in a string takes too long time' do
+    $result = nil
+    stub_const("CfDeployer::Defaults::Timeout", 10/1000.0)
+    context = { app: 'myApp'}
+    expect{CfDeployer::Hook.new('MyHook', "sleep 40/1000.0").run(context)}.to raise_error(Timeout::Error)
+  end
+
+  it 'should timeout when executing hook in a string takes too longer time than given timeout' do
+    $result = nil
+    context = { app: 'myApp'}
+    expect{CfDeployer::Hook.new('MyHook', {code: "sleep 40/1000.0", timeout: 20/1000.0}).run(context)}.to raise_error(Timeout::Error)
+  end
+
+  it 'should excute code in a file' do
+    code = <<-eos
+      $result = context[:app]
+    eos
+    File.open(@file, 'w') {|f| f.write(code) }
+    $result = nil
+    config_dir = File.expand_path('../../samples', __FILE__)
+    context = { app: 'myApp', config_dir: config_dir}
+    CfDeployer::Hook.new('MyHook', {file: '../../tmp/test_code.rb'}).run(context)
+    expect($result).to eq('myApp')
+  end
+
+  it 'should timeout when excuting code in a file takes too long time' do
+    file = File.expand_path("../../tmp/test_code.rb", __FILE__)
+    code = <<-eos
+      sleep 40/1000.0
+      $result = context[:app]
+    eos
+    File.open(@file, 'w') {|f| f.write(code) }
+    $result = nil
+    config_dir = File.expand_path('../../samples', __FILE__)
+    context = { app: 'myApp', config_dir: config_dir}
+    expect{CfDeployer::Hook.new('MyHook', {file: '../../tmp/test_code.rb', timeout: 20/1000.0}).run(context)}.to raise_error(Timeout::Error)
+  end
+end

data/spec/unit/stack_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe CfDeployer::Stack do
+    before do
+      @cf_driver = double CfDeployer::Driver::CloudFormation
+      @stack = CfDeployer::Stack.new('test', 'web', {:cf_driver => @cf_driver})
+    end
+
+  context '#deploy' do
+    it 'should call CfDeployer::ConfigLoader.component_json to get the JSON for the stack' do
+      config = { :inputs => { :foo => 'foo' },
+                 :defined_parameters => { :bar => 'bar' },
+                 :cf_driver => @cf_driver }
+      CfDeployer::ConfigLoader.should_receive(:component_json).with('web', config)
+      allow(@cf_driver).to receive(:stack_exists?) { false }
+      allow(@cf_driver).to receive(:stack_status) { :create_complete }
+      stack = CfDeployer::Stack.new('test','web', config)
+      allow(stack).to receive(:create_stack)
+      stack.deploy
+    end
+  end
+
+  context '#parameters' do
+    it "should get parameters"  do
+      parameters = double('parameters')
+      allow(@cf_driver).to receive(:parameters){ parameters }
+      allow(@cf_driver).to receive(:stack_status) { :create_complete }
+      expect(@stack.parameters).to eq(parameters)
+    end
+
+    it "should get empty hash if stack is not ready"  do
+      allow(@cf_driver).to receive(:stack_status) { :create_inprogress }
+      expect(@stack.parameters).to eq({})
+    end
+  end
+
+  context '#outputs' do
+    it "should get outputs"  do
+      outputs = double('outputs')
+      allow(@cf_driver).to receive(:outputs){ outputs }
+      allow(@cf_driver).to receive(:stack_status) { :create_complete }
+      expect(@stack.outputs).to eq(outputs)
+    end
+
+    it "should get empty hash if stack is not ready"  do
+      outputs = double('outputs')
+      allow(@cf_driver).to receive(:stack_status) { :create_inprogress }
+      expect(@stack.outputs).to eq({})
+    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 }
+        expect(@stack).to be_ready
+      end
+    end
+
+    it "should not be ready when not in a ready status" 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
+    it 'should delete the stack' do
+      allow(@stack).to receive(:exists?).and_return(true, false)
+      expect(@cf_driver).to receive(:delete_stack)
+      @stack.delete
+    end
+
+    it 'should not delete the stack if it does not exist' do
+      allow(@stack).to receive(:exists?) { false }
+      expect(@cf_driver).not_to receive(:delete_stack)
+      @stack.delete
+    end
+
+    it 'should be fine to get not exist error after deletion' do
+      allow(@stack).to receive(:exists?).and_return(true, true)
+      allow(@stack).to receive(:stack_status).and_raise(AWS::CloudFormation::Errors::ValidationError.new('the stack does not exist'))
+      expect(@cf_driver).to receive(:delete_stack)
+      expect {@stack.delete}.not_to raise_error
+    end
+
+    it 'should raise an error if a validation error is thrown not about stack does not exist' do
+      allow(@stack).to receive(:exists?).and_return(true, true)
+      allow(@stack).to receive(:stack_status).and_raise(AWS::CloudFormation::Errors::ValidationError.new('I am an error'))
+      expect(@cf_driver).to receive(:delete_stack)
+      expect {@stack.delete}.to raise_error
+    end
+  end
+
+  describe '#status' do
+    it "should be :ready if the stack is ready" do
+      allow(@stack).to receive(:exists?) { true }
+      allow(@stack).to receive(:ready?)  { true }
+      expect(@stack.status).to eq(:ready)
+    end
+
+    it 'should be :exists if it exists but is not ready' do
+      allow(@stack).to receive(:exists?) { true }
+      allow(@stack).to receive(:ready?) { false }
+      expect(@stack.status).to eq(:exists)
+    end
+
+    it 'should be :does_not_exist if it does not exist' do
+      allow(@stack).to receive(:exists?) { false }
+      expect(@stack.status).to eq(:does_not_exist)
+    end
+  end
+
+  describe '#resource_statuses' do
+    it 'should get resource_statuses from the CF driver' do
+      rs =  { :something => :some_status }
+      expect(@cf_driver).to receive(:resource_statuses) { rs }
+      expect(@stack.resource_statuses[:something]).to eq(:some_status)
+    end
+
+    it 'should add instance status info for instances in ASGs' do
+      asg = double CfDeployer::Driver::AutoScalingGroup
+      rs = { 'AWS::AutoScaling::AutoScalingGroup' => { 'ASG123' => :some_status } }
+      expect(@cf_driver).to receive(:resource_statuses) { rs }
+      expect(asg).to receive(:instance_statuses) { { 'i-abcd1234' => { :status => :some_status } } }
+      expect(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('ASG123') { asg }
+      expect(@stack.resource_statuses[:asg_instances]['ASG123']['i-abcd1234'][:status]).to eq(:some_status)
+    end
+
+    it 'should add instance status info for instances NOT in ASGs' do
+      instance = double CfDeployer::Driver::Instance
+      rs = { 'AWS::EC2::Instance' => { 'i-abcd1234' => :some_status } }
+      expect(@cf_driver).to receive(:resource_statuses) { rs }
+      expect(CfDeployer::Driver::Instance).to receive(:new).with('i-abcd1234') { instance }
+      expect(instance).to receive(:status) { { :status => :some_status } }
+      expect(@stack.resource_statuses[:instances]['i-abcd1234'][:status]).to eq(:some_status)
+    end
+  end
+
+end

data/spec/unit/status_presenter_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe "status_presenter" do
+
+  before do
+    @presenter = CfDeployer::StatusPresenter.new({}, 'all')
+  end
+
+  context "#filter_for_verbosity" do
+    it "should filter out all resources if the verbosity is 'stacks'" do
+      info = { 
+        :web => {
+          :stack1 => {
+            :status => :ready,
+            :resources => { :some_resource_type => [ :resource_1, :resource_2 ] }            
+          }
+        }
+      }
+
+      stacks_presenter = CfDeployer::StatusPresenter.new({}, 'stacks')
+      filtered_info = stacks_presenter.send :filter_for_verbosity, info
+
+      expect(filtered_info[:resources]).to eq(nil)
+    end
+
+    it "should only keep :instances and :asg_instances when verbosity is 'instances'" do
+      info = { 
+        :web => {
+          :stack1 => {
+            :status => :ready,
+            :resources => { 
+              :instances => [ :instance_1 ],
+              :asg_instances => [ :asg_instance_1 ],
+              :some_other_resource => [ :other_resource ]
+            }
+          }
+        }
+      }
+
+      instances__presenter = CfDeployer::StatusPresenter.new({}, 'instances')
+      filtered_info = instances__presenter.send :filter_for_verbosity, info
+
+      expect(filtered_info[:web][:stack1][:resources][:instances]).to eq(info[:web][:stack1][:resources][:instances])
+      expect(filtered_info[:web][:stack1][:resources][:asg_instances]).to eq(info[:web][:stack1][:resources][:asg_instances])
+      expect(filtered_info[:web][:stack1][:resources][:some_other_resource]).to eq(nil)
+    end
+  end
+
+  context "#tableize" do
+    before do
+      @table_data = [
+        [ 'r1c1',
+          'r2c1',
+          'r3c1'
+        ],
+        [ 'r1c2',
+          'r2c2'
+        ]
+      ]
+
+      @table_output = @presenter.send :tableize, @table_data
+    end
+
+    it "should have one more row than the max of each column's number of rows" do
+      expect(@table_output.size).to eq(4)
+    end
+
+    it "should have a table seperator as the last row" do
+      expect(@table_output.last).to eq(@presenter.send :table_seperator)
+    end
+
+    it "should draw a column seperator and pad the left column" do
+      expected_pad = ' ' * (CfDeployer::StatusPresenter::UNPADDED_TABLE_CELL_WIDTH - CfDeployer::StatusPresenter::PAD.size)
+      expected_row = @table_data[0][0] + expected_pad + '|' + @table_data[1][0]
+      expect(@table_output.first).to eq(expected_row)
+    end
+  end
+
+  context "#middle_truncate_ljust" do
+    it "should replace the middle of a long string with an elipsis" do
+      long_str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      truncated_str = @presenter.send :middle_truncate_ljust, long_str, 40
+      expect(truncated_str).to eq('abcdefghijklmnopq...GHIJKLMNOPQRSTUVWXYZ')
+      expect(truncated_str.size).to eq(40)
+    end
+  end
+
+  context "#visible_length" do
+    it "should return the length of the string without ANSI color code characters" do
+      colored_string = "a \e[31mcolored\e[0m string"
+      expect(@presenter.send(:visible_length, colored_string)).to eq(16)
+    end
+  end
+
+  context "#invisible_length" do
+    it "should return the length of the ANSI color code characters" do
+      colored_string = "a \e[31mcolored\e[0m string"
+      expect(@presenter.send(:invisible_length, colored_string)).to eq(9)
+    end
+  end
+
+  context "#centered" do
+    it "should rjust a string to the center of the table" do
+      expect(@presenter.send(:centered, 'Some String')).to eq('                                                                                 Some String')
+    end
+  end
+
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: cf_deployer
+version: !ruby/object:Gem::Version
+  version: 1.2.8
+platform: ruby
+authors:
+- Jame Brechtel
+- Peter Zhao
+- Patrick McFadden
+- Rob Sweet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: For automatic blue green deployment flow on CloudFormation.
+email:
+- jbrechtel@gmail.com
+- peter.qs.zhao@gmail.com
+- pemcfadden@gmail.com
+- rob@ldg.net
+executables:
+- cf_deploy
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- ChangeLog.md
+- DETAILS.md
+- FAQ.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- QUICKSTART.md
+- README.md
+- Rakefile
+- bin/cf_deploy
+- cf_deployer.gemspec
+- lib/cf_deployer.rb
+- lib/cf_deployer/application.rb
+- lib/cf_deployer/application_error.rb
+- lib/cf_deployer/aws_constants.rb
+- lib/cf_deployer/cli.rb
+- lib/cf_deployer/component.rb
+- lib/cf_deployer/config_loader.rb
+- lib/cf_deployer/config_validation.rb
+- lib/cf_deployer/defaults.rb
+- lib/cf_deployer/deployment_strategy/auto_scaling_group_swap.rb
+- lib/cf_deployer/deployment_strategy/base.rb
+- lib/cf_deployer/deployment_strategy/blue_green.rb
+- lib/cf_deployer/deployment_strategy/cname_swap.rb
+- lib/cf_deployer/deployment_strategy/create_or_update.rb
+- lib/cf_deployer/driver/auto_scaling_group.rb
+- lib/cf_deployer/driver/cloud_formation_driver.rb
+- lib/cf_deployer/driver/dry_run.rb
+- lib/cf_deployer/driver/elb_driver.rb
+- lib/cf_deployer/driver/instance.rb
+- lib/cf_deployer/driver/route53_driver.rb
+- lib/cf_deployer/driver/verisign_driver.rb
+- lib/cf_deployer/hook.rb
+- lib/cf_deployer/logger.rb
+- lib/cf_deployer/stack.rb
+- lib/cf_deployer/status_presenter.rb
+- lib/cf_deployer/version.rb
+- spec/fakes/instance.rb
+- spec/fakes/route53_client.rb
+- spec/fakes/stack.rb
+- spec/functional/deploy_spec.rb
+- spec/functional/kill_inactive_spec.rb
+- spec/functional_spec_helper.rb
+- spec/spec_helper.rb
+- spec/unit/application_spec.rb
+- spec/unit/component_spec.rb
+- spec/unit/config_loader_spec.rb
+- spec/unit/config_validation_spec.rb
+- spec/unit/deployment_strategy/auto_scaling_group_swap_spec.rb
+- spec/unit/deployment_strategy/base_spec.rb
+- spec/unit/deployment_strategy/cname_swap_spec.rb
+- spec/unit/deployment_strategy/create_or_update_spec.rb
+- spec/unit/deployment_strategy/deployment_strategy_spec.rb
+- spec/unit/driver/auto_scaling_group_spec.rb
+- spec/unit/driver/cloud_formation_spec.rb
+- spec/unit/driver/elb_spec.rb
+- spec/unit/driver/instance_spec.rb
+- spec/unit/driver/route53_spec.rb
+- spec/unit/driver/verisign_spec.rb
+- spec/unit/hook_spec.rb
+- spec/unit/stack_spec.rb
+- spec/unit/status_presenter_spec.rb
+homepage: http://github.com/manheim/cf_deployer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Support multiple components deployment using CloudFormation templates with
+  multiple blue green strategies.
+test_files:
+- spec/fakes/instance.rb
+- spec/fakes/route53_client.rb
+- spec/fakes/stack.rb
+- spec/functional/deploy_spec.rb
+- spec/functional/kill_inactive_spec.rb
+- spec/functional_spec_helper.rb
+- spec/spec_helper.rb
+- spec/unit/application_spec.rb
+- spec/unit/component_spec.rb
+- spec/unit/config_loader_spec.rb
+- spec/unit/config_validation_spec.rb
+- spec/unit/deployment_strategy/auto_scaling_group_swap_spec.rb
+- spec/unit/deployment_strategy/base_spec.rb
+- spec/unit/deployment_strategy/cname_swap_spec.rb
+- spec/unit/deployment_strategy/create_or_update_spec.rb
+- spec/unit/deployment_strategy/deployment_strategy_spec.rb
+- spec/unit/driver/auto_scaling_group_spec.rb
+- spec/unit/driver/cloud_formation_spec.rb
+- spec/unit/driver/elb_spec.rb
+- spec/unit/driver/instance_spec.rb
+- spec/unit/driver/route53_spec.rb
+- spec/unit/driver/verisign_spec.rb
+- spec/unit/hook_spec.rb
+- spec/unit/stack_spec.rb
+- spec/unit/status_presenter_spec.rb
+has_rdoc: