chef-provisioning-aws 3.0.4 → 3.0.6

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

@@ -1,87 +1,87 @@
-require 'chef/provisioning/aws_driver/driver'
-require 'chef/provisioning/aws_driver/credentials2'
+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 => {})}
+  let(:aws_credentials) do
+    double("credentials", default: {
+             aws_access_key_id: "id",
+             aws_secret_access_key: "secret"
+           })
+  end
+  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.config).to receive(:update) do |h|
-      expect(h).to include({
+      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)
   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') }
+    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 } }
+      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} )
+        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 } }
+      let(:reference) { { "transport_address_location" => :private_ip } }
       it "returns the private ip" do
-        expect(driver.determine_remote_host(machine_spec, instance)).to eq('private')
+        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 } }
+      let(:reference) { { "transport_address_location" => :dns } }
       it "returns the dns name" do
-        expect(driver.determine_remote_host(machine_spec, instance)).to eq('dns')
+        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 } }
+      let(:reference) { { "transport_address_location" => :public_ip } }
       it "returns the public ip" do
-        expect(driver.determine_remote_host(machine_spec, instance)).to eq('public')
+        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 }
+      let(:reference) { {} }
 
       context "when the machine does not have a public_ip_address" do
-        let(:instance) { double("instance", :private_ip_address => 'private', :public_ip_address => nil) }
+        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')
+          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') }
+        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')
+          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') }
+        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!")
+          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

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

@@ -1,19 +1,18 @@
-require 'chef/provisioning/aws_driver/driver'
+require "chef/provisioning/aws_driver/driver"
 
 describe ::Aws::Route53::Types::ResourceRecordSet do
-  it "returns the correct RecordSet unique key" 
+  it "returns the correct RecordSet unique key"
   it "returns the correct AWS change struct"
 end
 
 describe Chef::Resource::AwsRoute53RecordSet do
-
   let(:resource_name) { "test_resource" }
   let(:zone_name) { "blerf.net" }
-  let(:resource) {
+  let(:resource) do
     r = Chef::Resource::AwsRoute53RecordSet.new(resource_name)
     r.aws_route53_zone_name(zone_name)
     r
-  }
+  end
 
   it "returns the correct RecordSet unique key" do
     expect(resource.aws_key).to eq("#{resource_name}.#{zone_name}")
@@ -27,16 +26,15 @@ describe Chef::Resource::AwsRoute53RecordSet do
     resource.type("A")
     resource.resource_records(["141.222.1.1", "8.8.8.8"])
 
-    expect(resource.to_aws_struct).to eq({ :name=>"foo.blerf.net",
-                                           :type=>"A",
-                                           :ttl=>900, 
-                                           :resource_records=>[{:value=>"141.222.1.1"}, {:value=>"8.8.8.8"}]
-                                           })
+    expect(resource.to_aws_struct).to eq(name: "foo.blerf.net",
+                                         type: "A",
+                                         ttl: 900,
+                                         resource_records: [{ value: "141.222.1.1" }, { value: "8.8.8.8" }])
   end
 
   context "#validate_rr_type" do
     it "validates MX values" do
-      correct = 2.times.map { [rand(10000), rand(36**40).to_s(36)].join(" ") }
+      correct = 2.times.map { [rand(10_000), rand(36**40).to_s(36)].join(" ") }
       expect(resource.validate_rr_type!("MX", correct)).to be_truthy
 
       incorrect = ["string content doesn't matter without a number"]
@@ -45,7 +43,7 @@ describe Chef::Resource::AwsRoute53RecordSet do
     end
 
     it "validates SRV values" do
-      correct = 2.times.map { [rand(10000), rand(10000), rand(10000), rand(36**40).to_s(36)].join(" ") }
+      correct = 2.times.map { [rand(10_000), rand(10_000), rand(10_000), rand(36**40).to_s(36)].join(" ") }
       expect(resource.validate_rr_type!("MX", correct)).to be_truthy
 
       incorrect = ["string content doesn't matter without a number"]
@@ -57,7 +55,7 @@ describe Chef::Resource::AwsRoute53RecordSet do
       correct = ["foo"]
       expect(resource.validate_rr_type!("CNAME", correct)).to be_truthy
 
-      incorrect = ["foo1", "foo2"]
+      incorrect = %w{foo1 foo2}
       expect { resource.validate_rr_type!("CNAME", incorrect) }.to raise_error(Chef::Exceptions::ValidationFailed,
                                                                                /CNAME records may only have a single value/)
     end
@@ -72,7 +70,7 @@ describe Chef::Resource::AwsRoute53RecordSet do
     end
 
     it "quietly accepts the remaining RR types" do
-      %w(TXT PTR AAAA SPF).each do |type|
+      %w{TXT PTR AAAA SPF}.each do |type|
         expect(resource.validate_rr_type!(type, "We're not validating anything on type '#{type}'.")).to be_truthy
       end
 
@@ -102,4 +100,4 @@ describe Chef::Resource::AwsRoute53RecordSet do
 end
 
 describe Chef::Provider::AwsRoute53HostedZone do
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-aws
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 3.0.6
 platform: ruby
 authors:
 - Tyler Ball
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-20 00:00:00.000000000 Z
+date: 2018-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-provisioning
@@ -238,6 +238,7 @@ files:
 - spec/integration/machine_batch_spec.rb
 - spec/integration/machine_image_spec.rb
 - spec/integration/machine_spec.rb
+- spec/persistence_file.txt
 - spec/spec_helper.rb
 - spec/unit/chef/provisioning/aws_driver/credentials_spec.rb
 - spec/unit/chef/provisioning/aws_driver/driver_spec.rb
@@ -262,7 +263,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Provisioner for creating aws containers in Chef Provisioning.