chef-provisioning-aws 1.3.1 → 1.4.0

data/spec/integration/aws_vpc_peering_connection_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Chef::Resource::AwsVpcPeeringConnection do
+  extend AWSSupport
+
+  when_the_chef_12_server "exists", organization: 'foo', server_scope: :context do
+    with_aws "with 2 VPCs" do
+
+      aws_vpc "test_vpc" do
+        cidr_block '10.0.0.0/24'
+        internet_gateway false
+      end
+
+      aws_vpc "test_vpc_2" do
+        cidr_block '11.0.0.0/24'
+        internet_gateway false
+      end
+
+      it "aws_peering_connection 'test_vpc' with no attributes fails to create a VPC peering connection (must specify vpc and peer_vpc)" do
+        expect_converge {
+          aws_vpc_peering_connection 'test_peering_connection' do
+          end
+        }.to raise_error(RuntimeError, /VCP peering connection create action for 'test_peering_connection' requires the 'vpc' attribute./)
+
+        expect_converge {
+          aws_vpc_peering_connection 'test_peering_connection' do
+            vpc 'test_vpc'
+          end
+        }.to raise_error(RuntimeError, /VCP peering connection create action for 'test_peering_connection' requires the 'peer_vpc' attribute./)
+      end
+
+      it "aws_peering_connection 'test_peering_connection' with minimal parameters creates a active connection" do
+        expect_recipe {
+          aws_vpc_peering_connection 'test_peering_connection' do
+            vpc 'test_vpc'
+            peer_vpc 'test_vpc_2'
+          end
+        }.to create_an_aws_vpc_peering_connection('test_peering_connection',
+          :'requester_vpc_info.vpc_id' => test_vpc.aws_object.id,
+          :'accepter_vpc_info.vpc_id' => test_vpc_2.aws_object.id,
+          :'status.code' => 'active'
+        ).and be_idempotent
+      end
+
+      it "aws_peering_connection 'test_peering_connection' with peer_owner_id set to be the actual account id, creates an active peering" do
+        expect_recipe {
+          aws_vpc_peering_connection 'test_peering_connection' do
+            vpc 'test_vpc'
+            peer_vpc 'test_vpc_2'
+            peer_owner_id driver.account_id
+          end
+        }.to create_an_aws_vpc_peering_connection('test_peering_connection',
+            :'requester_vpc_info.vpc_id' => test_vpc.aws_object.id,
+            :'accepter_vpc_info.vpc_id' => test_vpc_2.aws_object.id,
+            :'status.code' => 'active'
+         ).and be_idempotent
+      end
+
+      it "aws_peering_connection 'test_peering_connection' with a false peer_owner_id, creates a failed peering connection" do
+        expect_recipe {
+          aws_vpc_peering_connection 'test_peering_connection' do
+            vpc 'test_vpc'
+            peer_vpc 'test_vpc_2'
+            peer_owner_id '000000000000'
+          end
+        }.to create_an_aws_vpc_peering_connection('test_peering_connection',
+            :'requester_vpc_info.vpc_id' => test_vpc.aws_object.id,
+            :'accepter_vpc_info.vpc_id' => test_vpc_2.aws_object.id,
+            :'status.code' => 'failed'
+        ).and be_idempotent
+      end
+
+      it "aws_peering_connection 'test_peering_connection' with accept action, accepts a pending peering connection" do
+        pcx = nil
+        ec2_resource = driver.ec2_resource
+        expect_recipe {
+          ruby_block "fetch VPC objects" do
+            block do
+              test_vpc = Chef::Resource::AwsVpc.get_aws_object("test_vpc", run_context: run_context)
+              test_vpc_2 = Chef::Resource::AwsVpc.get_aws_object("test_vpc_2", run_context: run_context)
+              pcx = ec2_resource.vpc(test_vpc.id).request_vpc_peering_connection({ :peer_vpc_id => test_vpc_2.id })
+            end
+          end
+        }.to match_an_aws_vpc_peering_connection(pcx.id,
+           :'status.code' => 'pending-acceptance'
+        )
+
+        expect_recipe {
+          aws_vpc_peering_connection pcx.id do
+            action :accept
+          end
+        }.to match_an_aws_vpc_peering_connection(pcx.id,
+          :'status.code' => 'active'
+        )
+      end
+    end
+  end
+end
+

data/spec/integration/aws_vpc_spec.rb

@@ -114,12 +114,85 @@ describe Chef::Resource::AwsVpc do
         end
       end
 
+      it "creates aws_vpc tags" do
+        expect_recipe {
+          aws_vpc 'test_vpc' do
+            cidr_block '10.0.0.0/24'
+            aws_tags key1: "value"
+          end
+        }.to create_an_aws_vpc('test_vpc')
+        .and have_aws_vpc_tags('test_vpc',
+          {
+            'Name' => 'test_vpc',
+            'key1' => 'value'
+          }
+        ).and be_idempotent
+      end
+
+      context "with existing tags" do
+        aws_vpc 'test_vpc' do
+          cidr_block '10.0.0.0/24'
+          aws_tags key1: "value"
+        end
+
+        it "updates aws_vpc tags" do
+          expect_recipe {
+            aws_vpc 'test_vpc' do
+              aws_tags key1: "value2", key2: nil
+            end
+          }.to have_aws_vpc_tags('test_vpc',
+            {
+              'Name' => 'test_vpc',
+              'key1' => 'value2',
+              'key2' => ''
+            }
+          ).and be_idempotent
+        end
+
+        it "removes all aws_vpc tags except Name" do
+          expect_recipe {
+            aws_vpc 'test_vpc' do
+              aws_tags {}
+            end
+          }.to have_aws_vpc_tags('test_vpc',
+            {
+              'Name' => 'test_vpc'
+            }
+          ).and be_idempotent
+        end
+      end
+
       it "aws_vpc 'vpc' with no attributes fails to create a VPC (must specify cidr_block)" do
         expect_converge {
           aws_vpc 'test_vpc' do
           end
         }.to raise_error(AWS::Core::OptionGrammar::FormatError, /expected string value for option cidr_block/)
       end
+
+      context "When having two VPC's and a peering connection between them" do
+        aws_vpc "test_vpc_1" do
+          cidr_block '20.0.0.0/24'
+        end
+
+        aws_vpc "test_vpc_2" do
+          cidr_block '21.0.0.0/24'
+        end
+
+        aws_vpc_peering_connection "test_peering_connection" do
+          vpc "test_vpc_1"
+          peer_vpc "test_vpc_2"
+        end
+
+        it "deletes the peer connection when one of the vpc's is deleted." do
+          expect_recipe {
+            aws_vpc "test_vpc_1" do
+              action :purge
+            end
+          }.to match_an_aws_vpc_peering_connection('test_peering_connection',
+              :'status.code' => 'deleted'
+          )
+        end
+      end
     end
   end
 end

data/spec/integration/load_balancer_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Chef::Resource::LoadBalancer do
+  extend AWSSupport
+
+  when_the_chef_12_server "exists", organization: 'foo', server_scope: :context do
+    with_aws "with a VPC and a public subnet" do
+
+      purge_all
+      setup_public_vpc
+
+      it "creates a load_balancer with the maximum attributes" do
+        expect_recipe {
+          load_balancer 'test-load-balancer' do
+            load_balancer_options({
+              listeners: [{
+                  :port => 80,
+                  :protocol => :http,
+                  :instance_port => 80,
+                  :instance_protocol => :http,
+              }],
+              subnets: ["test_public_subnet"],
+              security_groups: ["test_security_group"],
+              health_check: {
+                target: "HTTP:80/",
+                interval: 10,
+                timeout: 5,
+                unhealthy_threshold: 2,
+                healthy_threshold: 2
+              }
+              # 'only 1 of subnets or availability_zones may be specified'
+              # availability_zones: [test_public_subnet.aws_object.availability_zone_name]
+           })
+          end
+        }.to create_an_aws_load_balancer('test-load-balancer', {
+          listeners: [{
+              :port => 80,
+              :protocol => :http,
+              :instance_port => 80,
+              :instance_protocol => :http,
+          }],
+          subnets: [test_public_subnet.aws_object],
+          security_groups: [test_security_group.aws_object],
+          health_check: {
+            target: "HTTP:80/",
+            interval: 10,
+            timeout: 5,
+            unhealthy_threshold: 2,
+            healthy_threshold: 2
+          }
+        }
+        ).and be_idempotent
+      end
+
+      it "creates load_balancer tags" do
+        expect_recipe {
+          load_balancer 'test-load-balancer' do
+            aws_tags key1: "value"
+            load_balancer_options :availability_zones => ['us-east-1d']
+          end
+        }.to create_an_aws_load_balancer('test-load-balancer')
+        .and have_aws_load_balancer_tags('test-load-balancer',
+          {
+            'key1' => 'value'
+          }
+        ).and be_idempotent
+      end
+
+      context "with existing tags" do
+        load_balancer 'test-load-balancer' do
+          aws_tags key1: "value"
+          load_balancer_options :availability_zones => ['us-east-1d']
+        end
+
+        it "updates aws_load_balancer tags" do
+          expect_recipe {
+            load_balancer 'test-load-balancer' do
+              aws_tags key1: "value2", key2: nil
+            end
+          }.to have_aws_load_balancer_tags('test-load-balancer',
+            {
+              'key1' => 'value2',
+              'key2' => ''
+            }
+          ).and be_idempotent
+        end
+
+        it "removes all aws_load_balancer tags" do
+          expect_recipe {
+            load_balancer 'test-load-balancer' do
+              aws_tags Hash.new
+            end
+          }.to have_aws_load_balancer_tags('test-load-balancer',
+            Hash.new
+          ).and be_idempotent
+        end
+      end
+
+    end
+  end
+end

data/spec/integration/machine_image_spec.rb

@@ -17,7 +17,8 @@ describe Chef::Resource::MachineImage do
           machine_image 'test_machine_image' do
             machine_options bootstrap_options: {
               subnet_id: 'test_public_subnet',
-              key_name: 'test_key_pair'
+              key_name: 'test_key_pair',
+              instance_type: 'm3.medium'
             }
           end
         }.to create_an_aws_image('test_machine_image',
@@ -31,19 +32,73 @@ describe Chef::Resource::MachineImage do
         chef_config[:log_level] = :warn
       end
 
+      aws_key_pair 'test_key_pair' do
+        allow_overwrite true
+      end
+
       it "machine_image with no options can create an image in the VPC", :super_slow do
         expect_recipe {
-          aws_key_pair 'test_key_pair' do
-            allow_overwrite true
-          end
           machine_image 'test_machine_image' do
-            machine_options bootstrap_options: { key_name: 'test_key_pair' }
+            machine_options bootstrap_options: {
+              key_name: 'test_key_pair',
+              instance_type: 'm3.medium'
+            }
           end
         }.to create_an_aws_image('test_machine_image',
           name: 'test_machine_image'
-        ).and create_an_aws_key_pair('test_key_pair'
         ).and be_idempotent
       end
+
+      it "creates aws_image tags", :super_slow do
+        expect_recipe {
+          machine_image 'test_machine_image' do
+            machine_options bootstrap_options: {
+              key_name: 'test_key_pair',
+              instance_type: 'm3.medium'
+            }
+            aws_tags key1: "value"
+          end
+        }.to create_an_aws_image('test_machine_image')
+        .and have_aws_image_tags('test_machine_image',
+          {
+            'key1' => 'value'
+          }
+        ).and be_idempotent
+      end
+
+      context "with existing tags" do
+        machine_image 'test_machine_image' do
+          machine_options bootstrap_options: {
+            key_name: 'test_key_pair',
+            instance_type: 'm3.medium'
+          }
+          aws_tags key1: "value"
+        end
+
+        it "updates aws_image tags", :super_slow do
+          expect_recipe {
+            machine_image 'test_machine_image' do
+              aws_tags key1: "value2", key2: nil
+            end
+          }.to have_aws_image_tags('test_machine_image',
+            {
+              'key1' => 'value2',
+              'key2' => ''
+            }
+          ).and be_idempotent
+        end
+
+        it "removes all aws_image tags", :super_slow do
+          expect_recipe {
+            machine_image 'test_machine_image' do
+              aws_tags {}
+            end
+          }.to have_aws_image_tags('test_machine_image',
+            {}
+          ).and be_idempotent
+        end
+      end
+
     end
   end
 end

data/spec/integration/machine_spec.rb

@@ -52,6 +52,32 @@ describe Chef::Resource::Machine do
           source_dest_check: false
         ).and be_idempotent
       end
+
+      it "machine with from_image option is created from correct image", :super_slow do
+        expect_recipe {
+
+          machine_image 'test_machine_ami' do
+            machine_options bootstrap_options: {
+              subnet_id: 'test_public_subnet',
+              key_name: 'test_key_pair'
+            }
+          end
+
+          machine 'test_machine' do
+            from_image 'test_machine_ami'
+            machine_options bootstrap_options: {
+              subnet_id: 'test_public_subnet',
+              key_name: 'test_key_pair'
+            }
+            action :allocate
+          end
+        }.to create_an_aws_instance('test_machine',
+          image_id: driver.ec2.images.filter('name', 'test_machine_ami').first.image_id
+        ).and create_an_aws_image('test_machine_ami',
+          name: 'test_machine_ami'
+        ).and be_idempotent
+      end
+
     end
 
     with_aws "Without a VPC" do

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
+require 'simplecov'
+SimpleCov.start
+
 # Bring in the RSpec monkeypatch before we do *anything*, so that builtin matchers
 # will get the module.  Not strictly necessary, but cleaner that way.
 require 'aws_support/deep_matcher/rspec_monkeypatches'

data/spec/unit/chef/provisioning/aws_driver/driver_spec.rb

@@ -0,0 +1,88 @@
+require 'chef/provisioning/aws_driver/driver'
+require 'chef/provisioning/aws_driver/credentials2'
+
+describe Chef::Provisioning::AWSDriver::Driver do
+
+  let(:driver) { Chef::Provisioning::AWSDriver::Driver.new("aws::us-east-1", {}) }
+  let(:aws_credentials) { double("credentials", :default => {
+    aws_access_key_id: "id",
+    aws_secret_access_key: "secret"
+  })}
+  let(:credentials2) { double("credentials2", :get_credentials => {})}
+
+  before do
+    expect_any_instance_of(Chef::Provisioning::AWSDriver::Driver).to receive(:aws_credentials).and_return(aws_credentials)
+    expect(AWS).to receive(:config) do |h|
+      expect(h).to include({
+        access_key_id:     "id",
+        secret_access_key: "secret",
+        region:            "us-east-1"
+      })
+    end
+    expect(Chef::Provisioning::AWSDriver::Credentials2).to receive(:new).and_return(credentials2)
+    expect(::Aws).to receive(:config).and_return({})
+  end
+
+  describe "#determine_remote_host" do
+    let(:machine_spec) { double("machine_spec", :reference => reference, :name => 'name') }
+    let(:instance) { double("instance", :private_ip_address => 'private', :dns_name => 'dns', :public_ip_address => 'public') }
+
+    context "when 'use_private_ip_for_ssh' is specified in the machine_spec.reference" do
+      let(:reference) { { 'use_private_ip_for_ssh' => true } }
+      it "returns the private ip" do
+        expect(driver.determine_remote_host(machine_spec, instance)).to eq('private')
+        expect(reference).to eq( {'transport_address_location' => :private_ip} )
+      end
+    end
+
+    context "when 'transport_address_location' is set to :private_ip" do
+      let(:reference) { { 'transport_address_location' => :private_ip } }
+      it "returns the private ip" do
+        expect(driver.determine_remote_host(machine_spec, instance)).to eq('private')
+      end
+    end
+
+    context "when 'transport_address_location' is set to :dns" do
+      let(:reference) { { 'transport_address_location' => :dns } }
+      it "returns the dns name" do
+        expect(driver.determine_remote_host(machine_spec, instance)).to eq('dns')
+      end
+    end
+
+    context "when 'transport_address_location' is set to :public_ip" do
+      let(:reference) { { 'transport_address_location' => :public_ip } }
+      it "returns the public ip" do
+        expect(driver.determine_remote_host(machine_spec, instance)).to eq('public')
+      end
+    end
+
+    context "when machine_spec.reference does not specify the transport type" do
+      let(:reference) { Hash.new }
+
+      context "when the machine does not have a public_ip_address" do
+        let(:instance) { double("instance", :private_ip_address => 'private', :public_ip_address => nil) }
+
+        it "returns the private ip" do
+          expect(driver.determine_remote_host(machine_spec, instance)).to eq('private')
+        end
+      end
+
+      context "when the machine has a public_ip_address" do
+        let(:instance) { double("instance", :private_ip_address => 'private', :public_ip_address => 'public') }
+
+        it "returns the public ip" do
+          expect(driver.determine_remote_host(machine_spec, instance)).to eq('public')
+        end
+      end
+
+      context "when the machine does not have a public_ip_address or private_ip_address" do
+        let(:instance) { double("instance", :private_ip_address => nil, :public_ip_address => nil, :id => 'id') }
+
+        it "raises an error" do
+          expect {driver.determine_remote_host(machine_spec, instance)}.to raise_error("Server #{instance.id} has no private or public IP address!")
+        end
+      end
+    end
+  end
+
+end