chef-provisioning-aws 0.2.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 336d0793083b6da83f022552b5388784cf8733ab
-  data.tar.gz: e441903ab07300b474e22d6d1eae7f2e42327f37
+  metadata.gz: 5ec492afa3798bae513c3b61ea626958a6b7e954
+  data.tar.gz: 1b8ecf59b63a169aaa7d744efe491f3f1627065c
 SHA512:
-  metadata.gz: b230e7c97d4508ee54fb026bcda2c8945ae1e3f52dce1b46d67a7981757e8c097ddfe8e10dd50688f65d1b6e41c1f7a912915ae965edb5a112ed2bca91d15ca3
-  data.tar.gz: b3a7a575bba6c5a23ebbef6838f39b1055b55d8f83f0f723eb9137fda4e412d8fb3523ca86d491f3f464fdf0a5224884907d8358ead099681a87b4ec730769c2
+  metadata.gz: bcbdddb1f0cc451ecd9b345e62fc95d6049e5e1d9c715dff1b000f859a80728d1670fb42064e65b4ca1b2e93d26e9c036177b36d40a3a5802ad67a1e14a344d4
+  data.tar.gz: 8e17c7774db57b2e9774d366ffbe04f301c8bb5d09761a7a9f6fb1892567cd2163a6197a31591ca7a249f8f4216c1f65790a3c91f6e074c45b1a7ad197ab448f

data/README.md

@@ -1,18 +1,6 @@
 # chef-provisioning-aws
 
-A mostly-functional implementation of an AWS driver that doesn't use fog
-(for a variety of reasons). It also implements AWS-specific resources to
-manage such as SQS queues and SNS topics (currently) along with load
-balancers (needs a non-production branch of chef_provisioning at the moment) 
-
-This is not quite ready for public consumption and is under active
-development.
-
-This requires the latest from chef-provisioning's load_balancer branch for some 
-features like region support (until it gets merged into master, which should be soon)
-
-
-List of resources (these may not have 100% of SDK functionality mapped but can be provisioned): 
+An implementation of the AWS driver using the AWS Ruby SDK (v1).  It also implements a large number of AWS-specific resources such as:
 
 * SQS Queues
 * SNS Topics

data/Rakefile

@@ -1,6 +1,10 @@
 require 'bundler'
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-task :spec do
-  require File.expand_path('spec/run')
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
 end

data/lib/chef/provider/aws_auto_scaling_group.rb

@@ -3,13 +3,20 @@ require 'chef/provider/aws_provider'
 class Chef::Provider::AwsAutoScalingGroup < Chef::Provider::AwsProvider
   action :create do
     if existing_group.nil?
-      converge_by "Creating new Auto Scaling group #{id} in #{new_resource.region_name}" do
+      auto_scaling_opts = {
+        :launch_configuration => new_resource.launch_config,
+        :min_size => new_resource.min_size,
+        :max_size => new_resource.max_size,
+        :availability_zones => availability_zones
+      }
+      
+      auto_scaling_opts[:desired_capacity] = new_resource.desired_capacity if new_resource.desired_capacity
+      auto_scaling_opts[:load_balancers] = new_resource.load_balancers if new_resource.load_balancers
+       
+      converge_by "Creating new Auto Scaling group #{new_resource.name} in #{new_resource.region_name}" do
         @existing_group = auto_scaling.groups.create(
           new_resource.name,
-          :launch_configuration => new_resource.launch_config,
-          :min_size => new_resource.min_size,
-          :max_size => new_resource.max_size,
-          :availability_zones => availability_zones
+          auto_scaling_opts
         )
 
         new_resource.save
@@ -19,7 +26,7 @@ class Chef::Provider::AwsAutoScalingGroup < Chef::Provider::AwsProvider
 
   action :delete do
     if existing_group
-      converge_by "Deleting Auto Scaling group #{id} in #{new_resource.region_name}" do
+      converge_by "Deleting Auto Scaling group #{new_resource.name} in #{new_resource.region_name}" do
         existing_group.delete!
       end
     end

data/lib/chef/provider/aws_security_group.rb

@@ -32,7 +32,7 @@ class Chef::Provider::AwsSecurityGroup < Chef::Provider::AwsProvider
   end
 
   action :delete do
-    if existing_vpc
+    if existing_sg
       converge_by "Deleting SG #{new_resource.name} in #{new_resource.region_name}" do
         existing_sg.delete
       end

data/lib/chef/provider/aws_subnet.rb

@@ -9,7 +9,7 @@ class Chef::Provider::AwsSubnet < Chef::Provider::AwsProvider
     if existing_subnet == nil
       converge_by "Creating new Subnet #{fqn} in VPC #{new_resource.vpc} in #{new_resource.region_name}" do
         opts = { :vpc => vpc_id }
-	opts[:availability_zone] = new_resource.availability_zone if new_resource.availability_zone
+        opts[:availability_zone] = new_resource.availability_zone if new_resource.availability_zone
         subnet = ec2.subnets.create(new_resource.cidr_block, opts)
         subnet.tags['Name'] = new_resource.name
         subnet.tags['VPC'] = new_resource.vpc

data/lib/chef/provisioning/aws_driver/driver.rb

@@ -2,8 +2,10 @@ require 'chef/mixin/shell_out'
 require 'chef/provisioning/driver'
 require 'chef/provisioning/convergence_strategy/install_cached'
 require 'chef/provisioning/convergence_strategy/install_sh'
+require 'chef/provisioning/convergence_strategy/install_msi'
 require 'chef/provisioning/convergence_strategy/no_converge'
 require 'chef/provisioning/transport/ssh'
+require 'chef/provisioning/transport/winrm'
 require 'chef/provisioning/machine/windows_machine'
 require 'chef/provisioning/machine/unix_machine'
 require 'chef/provisioning/machine_spec'
@@ -59,6 +61,7 @@ module AWSDriver
 
     # Load balancer methods
     def allocate_load_balancer(action_handler, lb_spec, lb_options, machine_specs)
+      lb_options ||= {}
       if lb_options[:security_group_id]
         security_group = ec2.security_groups[:security_group_id]
       elsif lb_options[:security_group_name]
@@ -68,6 +71,8 @@ module AWSDriver
       availability_zones = lb_options[:availability_zones]
       listeners = lb_options[:listeners]
 
+      validate_listeners(listeners)
+
       lb_optionals = {}
       lb_optionals[:security_groups] = [security_group] if security_group
       lb_optionals[:availability_zones] = availability_zones if availability_zones
@@ -117,43 +122,44 @@ module AWSDriver
           end
         end
 
-        # Update listeners
-        perform_listener_action = proc do |desc, &block|
-          perform_listener_action = proc { |desc, &block| perform_action(desc, &block) }
-          perform_action([ "  update listener #{listener.port}", desc ], &block)
-        end
+        # Update listeners - THIS IS NOT ATOMIC
         add_listeners = {}
         listeners.each { |l| add_listeners[l[:port]] = l } if listeners
         actual_elb.listeners.each do |listener|
           desired_listener = add_listeners.delete(listener.port)
           if desired_listener
-            if listener.protocol != desired_listener[:protocol]
-              perform_listener_action.call("    update protocol from #{listener.protocol.inspect} to #{desired_listener[:protocol].inspect}'") do
-                listener.protocol = desired_listener[:protocol]
-              end
+
+            # listener.(port|protocol|instance_port|instance_protocol) are immutable for the life
+            # of the listener - must create a new one and delete old one
+            immutable_updates = []
+            if listener.protocol != desired_listener[:protocol].to_sym.downcase
+              immutable_updates << "    update protocol from #{listener.protocol.inspect} to #{desired_listener[:protocol].inspect}"
             end
             if listener.instance_port != desired_listener[:instance_port]
-              perform_listener_action.call("    update instance port from #{listener.instance_port.inspect} to #{desired_listener[:instance_port].inspect}'") do
-                listener.instance_port = desired_listener[:instance_port]
-              end
+              immutable_updates << "    update instance port from #{listener.instance_port.inspect} to #{desired_listener[:instance_port].inspect}"
             end
-            if listener.instance_protocol != desired_listener[:instance_protocol]
-              perform_listener_action.call("    update instance protocol from #{listener.instance_protocol.inspect} to #{desired_listener[:instance_protocol].inspect}'") do
-                listener.instance_protocol = desired_listener[:instance_protocol]
-              end
+            if listener.instance_protocol != desired_listener[:instance_protocol].to_sym.downcase
+              immutable_updates << "    update instance protocol from #{listener.instance_protocol.inspect} to #{desired_listener[:instance_protocol].inspect}"
             end
-            if listener.server_certificate != desired_listener[:server_certificate]
-              perform_listener_action.call("    update server certificate from #{listener.server_certificate} to #{desired_listener[:server_certificate]}'") do
+            if !immutable_updates.empty?
+              perform_action.call(immutable_updates) do
+                listener.delete
+                actual_elb.listeners.create(desired_listener)
+              end
+            elsif listener.server_certificate != desired_listener[:server_certificate]
+              # Server certificate is mutable - if no immutable changes required a full recreate, update cert
+              perform_action.call("    update server certificate from #{listener.server_certificate} to #{desired_listener[:server_certificate]}") do
                 listener.server_certificate = desired_listener[:server_certificate]
               end
             end
+
           else
             perform_action.call("  remove listener #{listener.port}") do
               listener.delete
             end
           end
         end
-        add_listeners.each do |listener|
+        add_listeners.values.each do |listener|
           updates = [ "  add listener #{listener[:port]}" ]
           updates << "    set protocol to #{listener[:protocol].inspect}"
           updates << "    set instance port to #{listener[:instance_port].inspect}"
@@ -213,7 +219,7 @@ module AWSDriver
           image_options[:instance_id] ||= machine_spec.location['instance_id']
           image_options[:description] ||= "Image #{image_spec.name} created from machine #{machine_spec.name}"
           Chef::Log.debug "AWS Image options: #{image_options.inspect}"
-          image = ec2.images.create(image_options)
+          image = ec2.images.create(image_options.to_hash)
           image_spec.location = {
             'driver_url' => driver_url,
             'driver_version' => Chef::Provisioning::AWSDriver::VERSION,
@@ -253,7 +259,7 @@ module AWSDriver
         action_handler.perform_action "De-registering image #{image_spec.name}" do
           actual_image.deregister
         end
-        unless snapshots.any?
+        if snapshots.any?
           action_handler.perform_action "Deleting image #{image_spec.name} snapshots" do
             snapshots.each do |snap|
               snap.delete
@@ -263,22 +269,37 @@ module AWSDriver
       end
     end
 
+    def user_data
+      # TODO: Make this use HTTPS at some point.
+      <<EOD
+<powershell>
+winrm quickconfig -q
+winrm set winrm/config/winrs '@{MaxMemoryPerShellMB="300"}'
+winrm set winrm/config '@{MaxTimeoutms="1800000"}'
+winrm set winrm/config/service '@{AllowUnencrypted="true"}'
+winrm set winrm/config/service/auth '@{Basic="true"}'
+
+netsh advfirewall firewall add rule name="WinRM 5985" protocol=TCP dir=in localport=5985 action=allow
+netsh advfirewall firewall add rule name="WinRM 5986" protocol=TCP dir=in localport=5986 action=allow
+
+net stop winrm
+sc config winrm start=auto
+net start winrm
+</powershell>
+EOD
+    end
+
     # Machine methods
     def allocate_machine(action_handler, machine_spec, machine_options)
       actual_instance = instance_for(machine_spec)
       if actual_instance == nil || !actual_instance.exists? || actual_instance.status == :terminated
-        image_id = machine_options[:image_id] || default_ami_for_region(@region)
-        bootstrap_options = (machine_options[:bootstrap_options] || {}).to_h.dup
-        bootstrap_options[:image_id] = image_id
-        if !bootstrap_options[:key_name]
-          Chef::Log.debug('No key specified, generating a default one...')
-          bootstrap_options[:key_name] = default_aws_keypair(action_handler, machine_spec)
-        end
-        Chef::Log.debug "AWS Bootstrap options: #{bootstrap_options.inspect}"
+        bootstrap_options = bootstrap_options_for(action_handler, machine_spec, machine_options)
 
-        action_handler.perform_action "Create #{machine_spec.name} with AMI #{image_id} in #{@region}" do
+        action_handler.perform_action "Create #{machine_spec.name} with AMI #{bootstrap_options[:image_id]} in #{@region}" do
           Chef::Log.debug "Creating instance with bootstrap options #{bootstrap_options}"
-          instance = ec2.instances.create(bootstrap_options)
+
+          instance = ec2.instances.create(bootstrap_options.to_hash)
+
           # Make sure the instance is ready to be tagged
           sleep 5 while instance.status == :pending
           # TODO add other tags identifying user / node url (same as fog)
@@ -288,7 +309,7 @@ module AWSDriver
               'driver_version' => Chef::Provisioning::AWSDriver::VERSION,
               'allocated_at' => Time.now.utc.to_s,
               'host_node' => action_handler.host_node,
-              'image_id' => machine_options[:image_id],
+              'image_id' => bootstrap_options[:image_id],
               'instance_id' => instance.id
           }
           machine_spec.location['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
@@ -374,7 +395,24 @@ module AWSDriver
       end
     end
 
-    def start_machine(action_handler, machine_spec, machine_options, base_image_name)
+    def bootstrap_options_for(action_handler, machine_spec, machine_options)
+      bootstrap_options = (machine_options[:bootstrap_options] || {}).to_h.dup
+      image_id = bootstrap_options[:image_id] || machine_options[:image_id] || default_ami_for_region(@region)
+      bootstrap_options[:image_id] = image_id
+      if !bootstrap_options[:key_name]
+        Chef::Log.debug('No key specified, generating a default one...')
+        bootstrap_options[:key_name] = default_aws_keypair(action_handler, machine_spec)
+      end
+
+      if machine_options[:is_windows]
+        Chef::Log.debug "Setting WinRM userdata..."
+        bootstrap_options[:user_data] = user_data
+      else
+        Chef::Log.debug "Non-windows, not setting userdata"
+      end
+
+      Chef::Log.debug "AWS Bootstrap options: #{bootstrap_options.inspect}"
+      bootstrap_options
     end
 
     def ec2
@@ -446,8 +484,11 @@ module AWSDriver
     end
 
     def transport_for(machine_spec, machine_options, instance)
-      # TODO winrm
-      create_ssh_transport(machine_spec, machine_options, instance)
+      if machine_spec.location['is_windows']
+        create_winrm_transport(machine_spec, machine_options, instance)
+      else
+        create_ssh_transport(machine_spec, machine_options, instance)
+      end
     end
 
     def compute_options
@@ -461,9 +502,9 @@ module AWSDriver
                            else
                              credentials = Credentials.new
                              if driver_options[:aws_config_file]
-                               credentials.load_ini(driver_options.delete(:aws_config_file))
+                               credentials.load_ini(driver_options[:aws_config_file])
                              elsif driver_options[:aws_csv_file]
-                               credentials.load_csv(driver_options.delete(:aws_csv_file))
+                               credentials.load_csv(driver_options[:aws_csv_file])
                              else
                                credentials.load_default
                              end
@@ -498,6 +539,53 @@ module AWSDriver
       end
     end
 
+    def create_winrm_transport(machine_spec, machine_options, instance)
+      remote_host = determine_remote_host(machine_spec, instance)
+
+      port = machine_spec.location['winrm_port'] || 5985
+      endpoint = "http://#{remote_host}:#{port}/wsman"
+      type = :plaintext
+      pem_bytes = get_private_key(instance.key_name)
+      encrypted_admin_password = wait_for_admin_password(machine_spec)
+
+      decoded = Base64.decode64(encrypted_admin_password)
+      private_key = OpenSSL::PKey::RSA.new(pem_bytes)
+      decrypted_password = private_key.private_decrypt decoded
+
+      winrm_options = {
+        :user => machine_spec.location['winrm_username'] || 'Administrator',
+        :pass => decrypted_password,
+        :disable_sspi => true,
+        :basic_auth_only => true
+      }
+
+      Chef::Provisioning::Transport::WinRM.new("#{endpoint}", type, winrm_options, {})
+    end
+
+    def wait_for_admin_password(machine_spec)
+      time_elapsed = 0
+      sleep_time = 10
+      max_wait_time = 900 # 15 minutes
+      encrypted_admin_password = nil
+      instance_id = machine_spec.location['instance_id']
+
+      Chef::Log.info "waiting for #{machine_spec.name}'s admin password to be available..."
+      while time_elapsed < max_wait_time && encrypted_admin_password.nil?
+        response = ec2.client.get_password_data({ :instance_id => instance_id })
+        encrypted_admin_password = response['password_data'.to_sym]
+
+        if encrypted_admin_password.nil?
+          Chef::Log.info "#{time_elapsed}/#{max_wait_time}s elapsed -- sleeping #{sleep_time} for #{machine_spec.name}'s admin password."
+          sleep(sleep_time)
+          time_elapsed += sleep_time
+        end
+      end
+
+      Chef::Log.info "#{machine_spec.name}'s admin password is available!"
+
+      encrypted_admin_password
+    end
+
     def create_ssh_transport(machine_spec, machine_options, instance)
       ssh_options = ssh_options_for(machine_spec, machine_options, instance)
       username = machine_spec.location['ssh_username'] || machine_options[:ssh_username] || default_ssh_username
@@ -509,24 +597,26 @@ module AWSDriver
         options[:prefix] = 'sudo '
       end
 
-      remote_host = nil
+      remote_host = determine_remote_host(machine_spec, instance)
+
+      #Enable pty by default
+      options[:ssh_pty_enable] = true
+      options[:ssh_gateway] = machine_spec.location['ssh_gateway'] if machine_spec.location.has_key?('ssh_gateway')
+
+      Chef::Provisioning::Transport::SSH.new(remote_host, username, ssh_options, options, config)
+    end
 
+    def determine_remote_host(machine_spec, instance)
       if machine_spec.location['use_private_ip_for_ssh']
-        remote_host = instance.private_ip_address
+        instance.private_ip_address
       elsif !instance.public_ip_address
         Chef::Log.warn("Server #{machine_spec.name} has no public ip address.  Using private ip '#{instance.private_ip_address}'.  Set driver option 'use_private_ip_for_ssh' => true if this will always be the case ...")
-        remote_host = instance.private_ip_address
+        instance.private_ip_address
       elsif instance.public_ip_address
-        remote_host = instance.public_ip_address
+        instance.public_ip_address
       else
         raise "Server #{instance.id} has no private or public IP address!"
       end
-
-      #Enable pty by default
-      options[:ssh_pty_enable] = true
-      options[:ssh_gateway] = machine_spec.location['ssh_gateway'] if machine_spec.location.has_key?('ssh_gateway')
-
-      Chef::Provisioning::Transport::SSH.new(remote_host, username, ssh_options, options, config)
     end
 
     def ssh_options_for(machine_spec, machine_options, instance)
@@ -692,7 +782,7 @@ module AWSDriver
           Chef::Log.warn "Machine #{machine_spec.name} (#{machine_spec.location['instance_id']} on #{driver_url}) no longer exists.  Recreating ..."
         end
 
-        bootstrap_options = machine_options[:bootstrap_options] || {}
+        bootstrap_options = bootstrap_options_for(action_handler, machine_spec, machine_options)
         by_bootstrap_options[bootstrap_options] ||= []
         by_bootstrap_options[bootstrap_options] << machine_spec
       end
@@ -742,13 +832,26 @@ module AWSDriver
     def create_many_instances(num_servers, bootstrap_options, parallelizer)
       parallelizer.parallelize(1.upto(num_servers)) do |i|
         clean_bootstrap_options = Marshal.load(Marshal.dump(bootstrap_options))
-        instance = ec2.instances.create(clean_bootstrap_options)
+        instance = ec2.instances.create(clean_bootstrap_options.to_hash)
 
         yield instance if block_given?
         instance
       end.to_a
     end
 
+    # The listeners API is different between the SDK v1 and v2
+    # http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/ELB/Listener.html
+    VALID_LISTENER_KEYS = [:port, :protocol, :instance_port, :instance_protocol]
+    def validate_listeners(listeners)
+      listeners.each do |listener|
+        listener.keys.each do |k|
+          unless VALID_LISTENER_KEYS.include?(k)
+            raise "#{k} is an invalid listener key, can be one of #{VALID_LISTENER_KEYS.inspect}"
+          end
+        end
+      end
+    end
+
   end
 end
 end

data/lib/chef/provisioning/aws_driver/version.rb

@@ -1,7 +1,7 @@
 class Chef
 module Provisioning
 module AWSDriver
-  VERSION = '0.2.2'
+  VERSION = '0.3'
 end
 end
 end

data/lib/chef/resource/aws_auto_scaling_group.rb

@@ -13,4 +13,5 @@ class Chef::Resource::AwsAutoScalingGroup < Chef::Resource::AwsResource
   attribute :launch_config, :kind_of => String
   attribute :min_size, :kind_of => Integer, :default => 1
   attribute :max_size, :kind_of => Integer, :default => 4
+  attribute :load_balancers, :kind_of => Array
 end

data/spec/acceptance/aws_ebs_volume/nodes/ettores-mbp.lan.json

@@ -0,0 +1,3 @@
+{
+  "name": "ettores-mbp.lan"
+}

data/spec/chef_zero_rspec_helper.rb

@@ -0,0 +1,8 @@
+# Cargo culted from John Keiser's
+# support/shared/integration/integration_helper
+
+require 'chef_zero/rspec'
+
+module ChefZeroRspecHelper
+  include ChefZero::RSpec
+end

data/spec/spec_helper.rb

@@ -1,6 +1,10 @@
+require 'chef/mixin/shell_out'
 require 'chef/dsl/recipe'
 require 'chef/provisioning'
 require 'chef/provisioning/aws_driver'
+require 'chef/platform'
+require 'chef/run_context'
+require 'chef/event_dispatch/dispatcher'
 
 RSpec.configure do |rspec|
   rspec.run_all_when_everything_filtered = true

data/spec/unit/provider/aws_subnet_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'chef_zero_rspec_helper'
+AWS.stub!
+
+describe Chef::Provider::AwsSubnet do
+  extend ChefZeroRspecHelper
+  let(:new_resource) {
+    Chef::Resource::AwsSubnet.new('my_subnet', run_context)
+  }
+  let(:my_node) {
+    node = Chef::Node.new
+    node.automatic['platform'] = 'ubuntu'
+    node.automatic['platform_version'] = '12.04'
+    node
+  }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) {
+    cookbook_collection = {}
+    Chef::RunContext.new(my_node, cookbook_collection ,events)
+  }
+
+  subject(:provider) {
+    described_class.new(new_resource, run_context)
+  }
+
+  when_the_chef_server "is empty" do
+    describe '#action_create' do
+      it 'requires cidr_block' do
+        expect{ provider.action_create }
+          .to raise_error(
+             RuntimeError, "Can't create a Subnet without a CIDR block"
+          )
+      end
+
+      it 'requires VPC to exist' do
+        new_resource.cidr_block('1.2.3.4/24')
+        new_resource.vpc('my_vpc')
+        allow_any_instance_of(AWS::EC2::VPCCollection)
+          .to receive(:with_tag)
+          .and_return(nil)
+        expect{ provider.action_create }
+          .to raise_error(AWS::Core::OptionGrammar::FormatError)
+      end
+
+      it 'should work with a VPC object' do
+        new_resource.cidr_block('1.2.3.4/24')
+        allow_any_instance_of(AWS::EC2::VPCCollection)
+          .to receive(:with_tag)
+          .and_return( [ AWS::EC2::VPC.new('vpc-abcd1234') ] )
+        allow_any_instance_of(AWS::EC2::SubnetCollection)
+          .to receive(:create)
+          .and_return(AWS::EC2::Subnet.new('subnet-feeddeed'))
+        expect(new_resource).to receive(:save)
+        provider.action_create
+      end
+
+      it 'should not converge if subnet already exists' do
+        new_resource.cidr_block('1.2.3.4/24')
+        allow_any_instance_of(AWS::EC2::SubnetCollection)
+          .to receive(:with_tag)
+          .and_return([AWS::EC2::Subnet.new('subnet-feeddeed')])
+        expect(provider).to_not receive(:converge_by)
+        provider.action_create
+      end
+    end
+  end
+end

data/spec/unit/resource/aws_subnet_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'chef_zero_rspec_helper'
+
+describe Chef::Resource::AwsSubnet do
+  extend ChefZeroRspecHelper
+  let(:my_node) { Chef::Node.new() }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(my_node,{},events) }
+
+  subject(:resource) {
+    described_class.new('my_subnet', run_context)
+  }
+
+  when_the_chef_server "is empty" do
+    it 'should match resource name' do
+      expect(resource.resource_name).to eq(:aws_subnet)
+    end
+
+    it 'should match name' do
+      expect(resource.name).to eq('my_subnet')
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-aws
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: '0.3'
 platform: ruby
 authors:
 - John Ewart
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-10 00:00:00.000000000 Z
+date: 2015-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -136,8 +136,12 @@ files:
 - lib/chef/resource/aws_sqs_queue.rb
 - lib/chef/resource/aws_subnet.rb
 - lib/chef/resource/aws_vpc.rb
+- spec/acceptance/aws_ebs_volume/nodes/ettores-mbp.lan.json
+- spec/chef_zero_rspec_helper.rb
 - spec/spec_helper.rb
 - spec/unit/aws_driver/credentials_spec.rb
+- spec/unit/provider/aws_subnet_spec.rb
+- spec/unit/resource/aws_subnet_spec.rb
 homepage: https://github.com/opscode/chef-provisioning-aws
 licenses: []
 metadata: {}
@@ -157,8 +161,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Provisioner for creating aws containers in Chef Provisioning.
 test_files: []
+has_rdoc: