kitchen-ec2 0.8.0 → 0.9.0

data/lib/kitchen/driver/ec2_version.rb

@@ -21,6 +21,6 @@ module Kitchen
   module Driver
 
     # Version string for EC2 Test Kitchen driver
-    EC2_VERSION = '0.8.0'
+    EC2_VERSION = "0.9.0"
   end
 end

data/spec/kitchen/driver/ec2/client_spec.rb

@@ -0,0 +1,119 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+#
+# Copyright (C) 2015, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "kitchen/driver/aws/client"
+require "climate_control"
+
+describe Kitchen::Driver::Aws::Client do
+  describe "::get_credentials" do
+    let(:shared) { instance_double(Aws::SharedCredentials) }
+    let(:iam) { instance_double(Aws::InstanceProfileCredentials) }
+
+    before do
+      expect(Aws::SharedCredentials).to \
+        receive(:new).with(:profile_name => "profile").and_return(shared)
+    end
+
+    # nothing else is set, so we default to this
+    it "loads IAM credentials last" do
+      expect(shared).to receive(:loadable?).and_return(false)
+      expect(Aws::InstanceProfileCredentials).to receive(:new).and_return(iam)
+      expect(Kitchen::Driver::Aws::Client.get_credentials("profile", nil, nil, nil)).to eq(iam)
+    end
+
+    it "loads shared credentials second to last" do
+      expect(shared).to receive(:loadable?).and_return(true)
+      expect(Kitchen::Driver::Aws::Client.get_credentials("profile", nil, nil, nil)).to eq(shared)
+    end
+
+    it "loads shared credentials third to last" do
+      expect(shared).to_not receive(:loadable?)
+      ClimateControl.modify(
+        "AWS_ACCESS_KEY_ID" => "key1",
+        "AWS_SECRET_ACCESS_KEY" => "value1",
+        "AWS_SESSION_TOKEN" => "token1"
+      ) do
+        expect(Kitchen::Driver::Aws::Client.get_credentials("profile", nil, nil, nil)).to \
+          be_a(Aws::Credentials).and have_attributes(
+            :access_key_id => "key1",
+            :secret_access_key => "value1",
+            :session_token => "token1"
+          )
+      end
+    end
+
+    it "loads deprecated credentials fourth to last" do
+      expect(shared).to_not receive(:loadable?)
+      ClimateControl.modify(
+        "AWS_ACCESS_KEY" => "key2",
+        "AWS_SECRET_KEY" => "value2",
+        "AWS_TOKEN" => "token2"
+      ) do
+        expect(Kitchen::Driver::Aws::Client.get_credentials("profile", nil, nil, nil)).to \
+          be_a(Aws::Credentials).and have_attributes(
+            :access_key_id => "key2",
+            :secret_access_key => "value2",
+            :session_token => "token2"
+          )
+      end
+    end
+
+    it "loads provided credentials first" do
+      expect(shared).to_not receive(:loadable?)
+      expect(Kitchen::Driver::Aws::Client.get_credentials("profile", "key3", "value3", nil)).to \
+        be_a(Aws::Credentials).and have_attributes(
+         :access_key_id => "key3",
+         :secret_access_key => "value3",
+         :session_token => nil
+       )
+    end
+
+    it "uses a session token if provided" do
+      expect(shared).to_not receive(:loadable?)
+      expect(Kitchen::Driver::Aws::Client.get_credentials("profile", "key3", "value3", "t")).to \
+        be_a(Aws::Credentials).and have_attributes(
+         :access_key_id => "key3",
+         :secret_access_key => "value3",
+         :session_token => "t"
+       )
+    end
+  end
+
+  let(:client) { Kitchen::Driver::Aws::Client.new("us-west-1") }
+
+  describe "#initialize" do
+
+    it "successfully creates a client" do
+      expect(client).to be_a(Kitchen::Driver::Aws::Client)
+    end
+
+    it "Sets the AWS config" do
+      client
+      expect(Aws.config[:region]).to eq("us-west-1")
+    end
+  end
+
+  it "returns a client" do
+    expect(client.client).to be_a(Aws::EC2::Client)
+  end
+
+  it "returns a resource" do
+    expect(client.resource).to be_a(Aws::EC2::Resource)
+  end
+
+end

data/spec/kitchen/driver/ec2/instance_generator_spec.rb

@@ -0,0 +1,303 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+#
+# Copyright (C) 2015, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "kitchen/driver/aws/instance_generator"
+require "kitchen/driver/aws/client"
+require "tempfile"
+
+describe Kitchen::Driver::Aws::InstanceGenerator do
+
+  let(:config) { Hash.new }
+
+  let(:resource) { instance_double(Aws::EC2::Resource) }
+
+  let(:ec2) { instance_double(Kitchen::Driver::Aws::Client, :resource => resource) }
+
+  let(:generator) { Kitchen::Driver::Aws::InstanceGenerator.new(config, ec2) }
+
+  describe "#debug_if_root_device" do
+    let(:image_id) { "ami-123456" }
+    let(:config) { { :image_id => image_id } }
+    let(:image) { double("image") }
+
+    before do
+      expect(resource).to receive(:image).with(image_id).and_return(image)
+    end
+
+    it "returns nil when the image cannot be found" do
+      expect(image).to receive(:root_device_name).and_raise(
+        ::Aws::EC2::Errors::InvalidAMIIDNotFound.new({}, "")
+      )
+      expect(generator).to_not receive(:info)
+      expect(generator.debug_if_root_device({})).to eq(nil)
+    end
+
+    it "logs an info message when the device mappings are overriding the root device" do
+      expect(image).to receive(:root_device_name).and_return("name")
+      expect(generator).to receive(:info)
+      expect(generator.debug_if_root_device([{ :device_name => "name" }])).to eq(nil)
+    end
+  end
+
+  describe "#prepared_user_data" do
+    context "when config[:user_data] is a file" do
+      let(:tmp_file) { Tempfile.new("prepared_user_data_test") }
+      let(:config) { { :user_data => tmp_file.path } }
+
+      before do
+        tmp_file.write("foo\nbar")
+        tmp_file.rewind
+      end
+
+      after do
+        tmp_file.close
+        tmp_file.unlink
+      end
+
+      it "reads the file contents" do
+        expect(generator.prepared_user_data).to eq("foo\nbar")
+      end
+
+      it "memoizes the file contents" do
+        expect(generator.prepared_user_data).to eq("foo\nbar")
+        tmp_file.write("other\nvalue")
+        tmp_file.rewind
+        expect(generator.prepared_user_data).to eq("foo\nbar")
+      end
+    end
+  end
+
+  describe "block_device_mappings" do
+    before do
+      expect(generator).to receive(:debug_if_root_device)
+    end
+
+    it "returns empty if nothing is provided" do
+      expect(generator.block_device_mappings).to eq([])
+    end
+
+    context "when populated with multiple mappings" do
+      let(:config) do
+        { :block_device_mappings => [
+          {
+            :ebs_volume_size => 13,
+            :ebs_delete_on_termination => true,
+            :ebs_device_name => "/dev/sda1"
+          },
+          {
+            :ebs_volume_size => 15,
+            :ebs_delete_on_termination => false,
+            :ebs_device_name => "/dev/sda2",
+            :ebs_volume_type => "gp2",
+            :ebs_snapshot_id => "id",
+            :ebs_virtual_name => "test"
+          }
+        ] }
+      end
+
+      it "returns the transformed mappings" do
+        expect(generator.block_device_mappings).to match(
+          [
+            {
+              :ebs => {
+                :volume_size => 13,
+                :delete_on_termination => true
+              },
+              :device_name => "/dev/sda1"
+            },
+            {
+              :ebs => {
+                :volume_size => 15,
+                :volume_type => "gp2",
+                :snapshot_id => "id",
+                :delete_on_termination => false
+              },
+              :device_name => "/dev/sda2",
+              :virtual_name => "test"
+            }
+          ]
+        )
+      end
+
+    end
+
+    context "when populatd with deprecated configs" do
+      let(:config) do
+        {
+          :ebs_volume_size => 13,
+          :ebs_delete_on_termination => true,
+          :ebs_device_name => "/dev/sda1",
+          :ebs_volume_type => "gp2"
+        }
+      end
+
+      it "returns the transformed mappings" do
+        expect(generator.block_device_mappings).to match(
+          [
+            {
+              :ebs => {
+                :volume_size => 13,
+                :delete_on_termination => true,
+                :volume_type => "gp2"
+              },
+              :device_name => "/dev/sda1"
+            }
+          ]
+        )
+      end
+    end
+
+    context "when populated with deprecated configs and new configs" do
+      let(:config) do
+        {
+          :ebs_volume_size => 13,
+          :ebs_delete_on_termination => true,
+          :ebs_device_name => "/dev/sda1",
+          :ebs_volume_type => "gp2",
+          :block_device_mappings => [
+            {
+              :ebs_volume_size => 15,
+              :ebs_delete_on_termination => false,
+              :ebs_device_name => "/dev/sda2",
+              :ebs_volume_type => "gp2",
+              :ebs_snapshot_id => "id",
+              :ebs_virtual_name => "test"
+            }
+          ]
+        }
+      end
+
+      it "ignores the old configs" do
+        expect(generator.block_device_mappings).to match(
+          [
+            {
+              :ebs => {
+                :volume_size => 15,
+                :volume_type => "gp2",
+                :snapshot_id => "id",
+                :delete_on_termination => false
+              },
+              :device_name => "/dev/sda2",
+              :virtual_name => "test"
+            }
+          ]
+        )
+      end
+    end
+  end
+
+  describe "#ec2_instance_data" do
+    before do
+      expect(generator).to receive(:debug_if_root_device)
+    end
+
+    it "returns empty on nil" do
+      expect(generator.ec2_instance_data).to eq(
+        :placement => { :availability_zone => nil },
+        :instance_type => nil,
+        :ebs_optimized => nil,
+        :image_id => nil,
+        :key_name => nil,
+        :subnet_id => nil,
+        :private_ip_address => nil
+      )
+    end
+
+    context "when populated with minimum requirements" do
+      let(:config) do
+        {
+          :availability_zone            => "eu-west-1a",
+          :instance_type                => "micro",
+          :ebs_optimized                => true,
+          :image_id                     => "ami-123",
+          :aws_ssh_key_id               => "key",
+          :subnet_id                    => "s-456",
+          :private_ip_address           => "0.0.0.0"
+        }
+      end
+
+      it "returns the minimum data" do
+        expect(generator.ec2_instance_data).to eq(
+          :placement => { :availability_zone => "eu-west-1a" },
+          :instance_type => "micro",
+          :ebs_optimized => true,
+          :image_id => "ami-123",
+          :key_name => "key",
+          :subnet_id => "s-456",
+          :private_ip_address => "0.0.0.0"
+        )
+      end
+    end
+
+    context "when provided the maximum config" do
+      let(:config) do
+        {
+          :availability_zone            => "eu-west-1a",
+          :instance_type                => "micro",
+          :ebs_optimized                => true,
+          :image_id                     => "ami-123",
+          :aws_ssh_key_id               => "key",
+          :subnet_id                    => "s-456",
+          :private_ip_address           => "0.0.0.0",
+          :block_device_mappings => [
+            {
+              :ebs_volume_size => 15,
+              :ebs_delete_on_termination => false,
+              :ebs_device_name => "/dev/sda2",
+              :ebs_volume_type => "gp2",
+              :ebs_snapshot_id => "id",
+              :ebs_virtual_name => "test"
+            }
+          ],
+          :security_group_ids => ["sg-789"],
+          :user_data => "foo",
+          :iam_instance_profile => "iam-123",
+          :associate_public_ip_address => true
+        }
+      end
+
+      it "returns the maximum data" do
+        expect(generator.ec2_instance_data).to eq(
+          :placement => { :availability_zone => "eu-west-1a" },
+          :instance_type => "micro",
+          :ebs_optimized => true,
+          :image_id => "ami-123",
+          :key_name => "key",
+          :subnet_id => "s-456",
+          :private_ip_address => "0.0.0.0",
+          :block_device_mappings => [
+            {
+              :ebs => {
+                :volume_size => 15,
+                :delete_on_termination => false,
+                :volume_type => "gp2",
+                :snapshot_id => "id"
+              },
+              :device_name => "/dev/sda2",
+              :virtual_name => "test"
+            }
+          ],
+          :iam_instance_profile => { :name => nil },
+          :network_interfaces => [{ :device_index => 0, :associate_public_ip_address => true }],
+          :security_group_ids => ["sg-789"],
+          :user_data => "foo"
+        )
+      end
+    end
+  end
+end

data/spec/kitchen/driver/ec2_spec.rb

@@ -0,0 +1,82 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+#
+# Copyright (C) 2015, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "kitchen/driver/ec2"
+require "kitchen/provisioner/dummy"
+require "kitchen/transport/dummy"
+require "kitchen/verifier/dummy"
+
+describe Kitchen::Driver::Ec2 do
+
+  let(:logged_output) { StringIO.new }
+  let(:logger)        { Logger.new(logged_output) }
+  let(:config)        { { :aws_ssh_key_id => "key", :image_id => "ami-1234567" } }
+  let(:platform)      { Kitchen::Platform.new(:name => "fooos-99") }
+  let(:suite)         { Kitchen::Suite.new(:name => "suitey") }
+  let(:verifier)      { Kitchen::Verifier::Dummy.new }
+  let(:provisioner)   { Kitchen::Provisioner::Dummy.new }
+  let(:transport)     { Kitchen::Transport::Dummy.new }
+  let(:state_file)    { double("state_file") }
+
+  let(:driver) { Kitchen::Driver::Ec2.new(config) }
+
+  let(:instance) do
+    Kitchen::Instance.new(
+      :verifier => verifier,
+      :driver => driver,
+      :logger => logger,
+      :suite => suite,
+      :platform => platform,
+      :provisioner => provisioner,
+      :transport => transport,
+      :state_file => state_file
+    )
+  end
+
+  it "driver api_version is 2" do
+    expect(driver.diagnose_plugin[:api_version]).to eq(2)
+  end
+
+  it "plugin_version is set to Kitchen::Vagrant::VERSION" do
+    expect(driver.diagnose_plugin[:version]).to eq(
+      Kitchen::Driver::EC2_VERSION)
+  end
+
+  describe "configuration" do
+    let(:config) { {} }
+    it "requires :aws_ssh_key_id to be provided" do
+      expect { driver.finalize_config!(instance) }.to \
+        raise_error(Kitchen::UserError, /:aws_ssh_key_id/)
+    end
+
+    it "requires :image_id to be provided" do
+      config[:aws_ssh_key_id] = "key"
+      expect { driver.finalize_config!(instance) }.to \
+        raise_error(Kitchen::UserError, /:image_id/)
+    end
+  end
+
+  describe "finalize_config!" do
+    it "defaults the availability zone if not provided" do
+      expect(config[:availability_zone]).to eq(nil)
+      driver.finalize_config!(instance)
+      expect(config[:availability_zone]).to eq("us-east-1b")
+    end
+  end
+
+end