fog 0.8.2 → 0.9.0

data/spec/ecloud/models/networks_spec.rb

@@ -1,21 +1,21 @@
 require 'ecloud/spec_helper'
 
 if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Networks", :type => :mock_tmrk_ecloud_model do
+  describe "Fog::Compute::Ecloud::Networks", :type => :mock_tmrk_ecloud_model do
     subject { @vcloud }
 
     it { should respond_to(:networks) }
 
     describe :class do
       subject { @vcloud.networks.class }
-      its(:model)       { should == Fog::Ecloud::Compute::Network }
+      its(:model)       { should == Fog::Compute::Ecloud::Network }
     end
 
     describe :networks do
       subject { @vcloud.vdcs[0].networks }
       it { should_not respond_to(:create) }
 
-      it { should be_an_instance_of(Fog::Ecloud::Compute::Networks) }
+      it { should be_an_instance_of(Fog::Compute::Ecloud::Networks) }
 
       its(:length) { should == 2 }
 

data/spec/ecloud/models/node_spec.rb

@@ -1,12 +1,12 @@
 require 'ecloud/spec_helper'
 
 if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Node", :type => :mock_tmrk_ecloud_model do
+  describe "Fog::Compute::Ecloud::Node", :type => :mock_tmrk_ecloud_model do
 
     subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.first }
 
     describe :class do
-      subject { Fog::Ecloud::Compute::Node }
+      subject { Fog::Compute::Ecloud::Node }
 
       it { should have_identity(:href) }
       it { should have_only_these_attributes([:href, :ip_address, :description, :name, :port, :enabled, :id]) }
@@ -14,7 +14,7 @@ if Fog.mocking?
 
     context "with no uri" do
 
-      subject { Fog::Ecloud::Compute::Node.new() }
+      subject { Fog::Compute::Ecloud::Node.new() }
       it { should have_all_attributes_be_nil }
 
     end
@@ -22,7 +22,7 @@ if Fog.mocking?
     context "as a collection member" do
       subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.first.reload }
 
-      it { should be_an_instance_of(Fog::Ecloud::Compute::Node) }
+      it { should be_an_instance_of(Fog::Compute::Ecloud::Node) }
 
       its(:href)                  { should == @mock_node.href }
       its(:identity)              { should == @mock_node.href }

data/spec/ecloud/models/nodes_spec.rb

@@ -1,7 +1,7 @@
 require 'ecloud/spec_helper'
 
 if Fog.mocking?
-  describe "Fog::Ecloud::Compute::InternetServices", :type => :mock_tmrk_ecloud_model do
+  describe "Fog::Compute::Ecloud::InternetServices", :type => :mock_tmrk_ecloud_model do
     context "as an attribute of an internet_service" do
       subject { @vcloud.vdcs.first.public_ips.first.internet_services.first }
 
@@ -9,7 +9,7 @@ if Fog.mocking?
 
       describe :class do
         subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.class }
-        its(:model)       { should == Fog::Ecloud::Compute::Node }
+        its(:model)       { should == Fog::Compute::Ecloud::Node }
       end
 
       describe :nodes do
@@ -17,7 +17,7 @@ if Fog.mocking?
 
         it { should respond_to(:create) }
 
-        it { should be_an_instance_of(Fog::Ecloud::Compute::Nodes) }
+        it { should be_an_instance_of(Fog::Compute::Ecloud::Nodes) }
 
         its(:length) { should == 3 }
 

data/spec/ecloud/models/public_ip_spec.rb

@@ -1,11 +1,11 @@
 require 'ecloud/spec_helper'
 
 if Fog.mocking?
-  describe "Fog::Ecloud::Compute::PublicIp", :type => :mock_tmrk_ecloud_model do
+  describe "Fog::Compute::Ecloud::PublicIp", :type => :mock_tmrk_ecloud_model do
     subject { @vcloud }
 
     describe :class do
-      subject { Fog::Ecloud::Compute::PublicIp }
+      subject { Fog::Compute::Ecloud::PublicIp }
 
       it { should have_identity(:href) }
       it { should have_only_these_attributes([:name, :id, :href]) }
@@ -13,7 +13,7 @@ if Fog.mocking?
 
     context "with no uri" do
 
-      subject { Fog::Ecloud::Compute::PublicIp.new() }
+      subject { Fog::Compute::Ecloud::PublicIp.new() }
 
       it { should have_all_attributes_be_nil }
     end
@@ -21,7 +21,7 @@ if Fog.mocking?
     context "as a collection member" do
       subject { @vcloud.vdcs[0].public_ips[0].reload; @vcloud.vdcs[0].public_ips[0] }
 
-      it { should be_an_instance_of(Fog::Ecloud::Compute::PublicIp) }
+      it { should be_an_instance_of(Fog::Compute::Ecloud::PublicIp) }
 
       its(:href)                  { should == @mock_public_ip.href }
       its(:identity)              { should == @mock_public_ip.href }

data/spec/ecloud/models/public_ips_spec.rb

@@ -1,21 +1,21 @@
 require 'ecloud/spec_helper'
 
 if Fog.mocking?
-  describe "Fog::Ecloud::Compute::PublicIps", :type => :mock_tmrk_ecloud_model do
+  describe "Fog::Compute::Ecloud::PublicIps", :type => :mock_tmrk_ecloud_model do
     subject { @vcloud }
 
     it { should respond_to(:public_ips) }
 
     describe :class do
       subject { @vcloud.public_ips.class }
-      its(:model)       { should == Fog::Ecloud::Compute::PublicIp }
+      its(:model)       { should == Fog::Compute::Ecloud::PublicIp }
     end
 
     describe :public_ips do
       subject { @vcloud.vdcs[0].public_ips }
       it { should_not respond_to(:create) }
 
-      it { should be_an_instance_of(Fog::Ecloud::Compute::PublicIps) }
+      it { should be_an_instance_of(Fog::Compute::Ecloud::PublicIps) }
 
       its(:length) { should == 3 }
 

data/spec/ecloud/models/server_spec.rb

@@ -1,18 +1,18 @@
 require 'ecloud/spec_helper'
 
 if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Vdc", :type => :mock_tmrk_ecloud_model do
+  describe "Fog::Compute::Ecloud::Vdc", :type => :mock_tmrk_ecloud_model do
     subject { @vcloud }
 
     describe :class do
-      subject { Fog::Ecloud::Compute::Server }
+      subject { Fog::Compute::Ecloud::Server }
 
       it { should have_identity(:href) }
       it { should have_only_these_attributes([:href, :type, :name, :status, :network_connections, :os, :virtual_hardware, :storage_size, :links]) }
     end
 
     context "with no uri" do
-      subject { Fog::Ecloud::Compute::Server.new() }
+      subject { Fog::Compute::Ecloud::Server.new() }
 
       it { should have_all_attributes_be_nil }
     end

data/spec/ecloud/models/vdc_spec.rb

@@ -1,13 +1,13 @@
 require 'ecloud/spec_helper'
 
 if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Vdc", :type => :mock_tmrk_ecloud_model do
+  describe "Fog::Compute::Ecloud::Vdc", :type => :mock_tmrk_ecloud_model do
     subject { @vcloud }
 
     it { should respond_to(:get_vdc) }
 
     describe :class do
-      subject { Fog::Ecloud::Compute::Vdc }
+      subject { Fog::Compute::Ecloud::Vdc }
 
       it { should have_identity(:href) }
       it { should have_only_these_attributes([:href, :name, :type, :description, :other_links, :compute_capacity, :storage_capacity, :available_networks,
@@ -16,7 +16,7 @@ if Fog.mocking?
 
     context "with no uri" do
 
-      subject { Fog::Ecloud::Compute::Vdc.new() }
+      subject { Fog::Compute::Ecloud::Vdc.new() }
 
       it { should have_all_attributes_be_nil }
     end
@@ -27,7 +27,7 @@ if Fog.mocking?
       its(:href)                  { should == @mock_vdc.href }
       its(:identity)              { should == @mock_vdc.href }
       its(:name)                  { should == @mock_vdc.name }
-      its(:public_ips)            { should be_an_instance_of(Fog::Ecloud::Compute::PublicIps) }
+      its(:public_ips)            { should be_an_instance_of(Fog::Compute::Ecloud::PublicIps) }
       its(:other_links)           { should have(4).items }
       its(:resource_entities)     { should have(3).items }
       its(:available_networks)    { should have(2).items }

data/spec/ecloud/models/vdcs_spec.rb

@@ -1,21 +1,21 @@
 require 'ecloud/spec_helper'
 
 if Fog.mocking?
-  describe "Fog::Ecloud::Compute::Vdcs", :type => :mock_tmrk_ecloud_model do
+  describe "Fog::Compute::Ecloud::Vdcs", :type => :mock_tmrk_ecloud_model do
     subject { @vcloud }
 
     it { should respond_to(:vdcs) }
 
     describe :class do
       subject { @vcloud.vdcs.class }
-      its(:model)       { should == Fog::Ecloud::Compute::Vdc }
+      its(:model)       { should == Fog::Compute::Ecloud::Vdc }
     end
 
     describe :vdcs do
       subject { @vcloud.vdcs }
       it { should_not respond_to(:create) }
 
-      it { should be_an_instance_of(Fog::Ecloud::Compute::Vdcs) }
+      it { should be_an_instance_of(Fog::Compute::Ecloud::Vdcs) }
 
       its(:length) { should == 2 }
 

data/spec/ecloud/spec_helper.rb

@@ -227,8 +227,8 @@ def setup_generic_mock_data
 end
 
 def setup_ecloud_mock_data
-  @base_url = Fog::Ecloud::Compute::Mock.base_url
-  @mock_data = Fog::Ecloud::Compute::Mock.data
+  @base_url = Fog::Compute::Ecloud::Mock.base_url
+  @mock_data = Fog::Compute::Ecloud::Mock.data
   setup_generic_mock_data
   @mock_vdc_service_collection = @mock_vdc.internet_service_collection
   @mock_public_ip_collection = @mock_vdc.public_ip_collection
@@ -246,29 +246,29 @@ def setup_ecloud_mock_data
 end
 
 def setup_vcloud_mock_data
-  @base_url = Fog::Ecloud::Compute::Mock.base_url
-  @mock_data = Fog::Ecloud::Compute::Mock.data
+  @base_url = Fog::Compute::Ecloud::Mock.base_url
+  @mock_data = Fog::Compute::Ecloud::Mock.data
   setup_generic_mock_data
 end
 
 Spec::Runner.configure do |config|
   config.after(:all) do
-    Fog::Ecloud::Compute::Mock.reset
+    Fog::Compute::Ecloud::Mock.reset
   end
 
   config.before(:each, :type => :vcloud_request) do
-    @vcloud = Fog::Ecloud::Compute.new(Fog.credentials[:vcloud][:ecloud])
+    @vcloud = Fog::Compute::Ecloud.new(Fog.credentials[:vcloud][:ecloud])
   end
 
   config.before(:each, :type => :mock_tmrk_ecloud_request) do
-    Fog::Ecloud::Compute::Mock.reset
+    Fog::Compute::Ecloud::Mock.reset
     setup_ecloud_mock_data
-    @vcloud = Fog::Ecloud::Compute.new(:ecloud_username => "foo", :ecloud_password => "bar", :ecloud_versions_uri => "http://fakey.com/api/versions")
+    @vcloud = Fog::Compute::Ecloud.new(:ecloud_username => "foo", :ecloud_password => "bar", :ecloud_versions_uri => "http://fakey.com/api/versions")
   end
   config.before(:each, :type => :mock_tmrk_ecloud_model) do
-    Fog::Ecloud::Compute::Mock.reset
+    Fog::Compute::Ecloud::Mock.reset
     setup_ecloud_mock_data
-    @vcloud = Fog::Ecloud::Compute.new(:ecloud_username => "foo", :ecloud_password => "bar", :ecloud_versions_uri => "http://fakey.com/api/versions")
+    @vcloud = Fog::Compute::Ecloud.new(:ecloud_username => "foo", :ecloud_password => "bar", :ecloud_versions_uri => "http://fakey.com/api/versions")
   end
 end
 

data/spec/ecloud/vcloud_spec.rb

@@ -4,7 +4,7 @@ if Fog.mocking?
   describe Fog::Ecloud, :type => :mock_tmrk_ecloud_request do
     subject { @vcloud }
 
-    it { should be_an_instance_of(Fog::Ecloud::Compute::Mock) }
+    it { should be_an_instance_of(Fog::Compute::Ecloud::Mock) }
 
     it { should respond_to(:default_organization_uri) }
 

data/tests/aws/models/rds/helper.rb

@@ -0,0 +1,5 @@
+def rds_default_server_params
+  { :id => uniq_id, :allocated_storage => 5, :engine => 'mysql',
+    :master_username => 'foguser', :password => 'fogpassword',
+    :backup_retention_period => 0 }
+end

data/tests/aws/models/rds/parameter_group_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests("AWS::RDS | parameter_group", ['aws', 'rds']) do
+
+  group_name = 'fog-test'
+  params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
+
+  pending if Fog.mocking?
+  model_tests(AWS[:rds].parameter_groups, params, false) do
+    tests('#parameters') do
+      #search for a sample parameter
+      tests 'contains parameters' do
+        returns(true){ @instance.parameters.any? {|p| p.name == 'query_cache_size'}}
+      end
+    end
+
+    tests('#modify') do
+      @instance.modify([{:name => 'query_cache_size', :value => '6553600', :apply_method => 'immediate'}])
+
+      tests 'parameter has changed' do
+        returns('6553600'){@instance.parameters.detect {|p| p.name == 'query_cache_size'}.value}
+      end
+    end
+
+  end
+end

data/tests/aws/models/rds/parameter_groups_tests.rb

@@ -0,0 +1,8 @@
+Shindo.tests("AWS::RDS | parameter_groups", ['aws', 'rds']) do
+
+  group_name = 'fog-test'
+  params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
+
+  pending if Fog.mocking?
+  collection_tests(AWS[:rds].parameter_groups, params, false)
+end

data/tests/aws/models/rds/security_group_tests.rb

@@ -0,0 +1,50 @@
+Shindo.tests("AWS::RDS | security_group", ['aws', 'rds']) do
+  group_name = 'fog-test'
+  params = {:id => group_name, :description => 'fog test'}
+
+  pending if Fog.mocking?
+  model_tests(AWS[:rds].security_groups, params, false) do
+
+    tests("#description").returns('fog test') { @instance.description }
+
+    tests("#authorize_ec2_security_group").succeeds do
+      @ec2_sec_group = Compute[:aws].security_groups.create(:name => 'fog-test', :description => 'fog test')
+
+      @instance.authorize_ec2_security_group(@ec2_sec_group.name)
+      returns('authorizing') do
+        @instance.ec2_security_groups.detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
+      end
+    end
+
+    @instance.wait_for { ready? }
+
+    tests("#revoke_ec2_security_group").succeeds do
+      @instance.revoke_ec2_security_group(@ec2_sec_group.name)
+
+      returns('revoking') do
+        @instance.ec2_security_groups.detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
+      end
+
+      @instance.wait_for { ready? }
+
+      returns(false) { @instance.ec2_security_groups.any?{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name} }
+      @ec2_sec_group.destroy
+    end
+
+    tests("#authorize_cidrip").succeeds do
+      @cidr = '127.0.0.1/32'
+      @instance.authorize_cidrip(@cidr)
+      returns('authorizing') { @instance.ip_ranges.detect{|h| h['CIDRIP'] == @cidr}['Status'] }
+    end
+
+    @instance.wait_for { ready? }
+    tests("#revoke_cidrip").succeeds do
+      @instance.revoke_cidrip(@cidr)
+      returns('revoking') { @instance.ip_ranges.detect{|h| h['CIDRIP'] == @cidr}['Status'] }
+      @instance.wait_for { ready? }
+      returns(false) { @instance.ip_ranges.any?{|h| h['CIDRIP'] == @cidr} }
+
+    end
+
+  end
+end

data/tests/aws/models/rds/security_groups_tests.rb

@@ -0,0 +1,6 @@
+Shindo.tests("AWS::RDS | security groups", ['aws', 'rds']) do
+  params = {:id => 'fog-test', :description => 'fog test'}
+
+  pending if Fog.mocking?
+  collection_tests(AWS[:rds].security_groups, params, false)
+end

data/tests/aws/models/rds/server_tests.rb

@@ -0,0 +1,104 @@
+Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  model_tests(AWS[:rds].servers, rds_default_server_params, false) do
+    # We'll need this later; create it early to avoid waiting
+    @instance_with_final_snapshot = AWS[:rds].servers.create(rds_default_server_params.merge(:id => uniq_id("fog-snapshot-test"), :backup_retention_period => 1))
+
+    @instance.wait_for { ready? }
+
+    tests('#snapshots') do
+      snapshot = nil
+
+      tests('#create').succeeds do
+        snapshot = @instance.snapshots.create(:id => 'fog-test-snapshot')
+      end
+
+      snapshot.wait_for {ready?}
+
+      @instance.reload
+      @instance.wait_for { ready? }
+
+      returns(true) { @instance.snapshots.map{|s| s.id}.include?(snapshot.id) }
+      snapshot.destroy
+    end
+
+    tests("#modify").succeeds do
+      orig_parameter_group = @instance.db_parameter_groups.first['DBParameterGroupName']
+      parameter_group = AWS[:rds].parameter_groups.create(:id => uniq_id, :family => 'mysql5.1', :description => 'fog-test')
+
+      orig_security_groups = @instance.db_security_groups.map{|h| h['DBSecurityGroupName']}
+      security_group = AWS[:rds].security_groups.create(:id => uniq_id, :description => 'fog-test')
+
+      modify_options = {
+        'DBParameterGroupName' => parameter_group.id,
+        'DBSecurityGroups' => orig_security_groups + [security_group.id]
+      }
+
+      @instance.modify(true, modify_options)
+      @instance.reload
+
+      returns(parameter_group.id, 'new parameter group') do
+        @instance.db_parameter_groups.first['DBParameterGroupName']
+      end
+
+      returns(true, "new security group") do
+        @instance.db_security_groups.any?{|hash| hash['DBSecurityGroupName'] == security_group.id}
+      end
+
+      @instance.reboot
+      @instance.reload.wait_for { state == 'rebooting' }
+      @instance.reload.wait_for { ready? }
+
+      # Restore back to original state
+      restore_options = {
+       'DBParameterGroupName' => orig_parameter_group,
+       'DBSecurityGroups' => orig_security_groups
+      }
+      @instance.modify(true, restore_options)
+
+      @instance.reboot
+      @instance.reload.wait_for { state == 'rebooting' }
+      @instance.reload.wait_for do
+        ready? &&
+          db_security_groups.all? {|hash| hash['Status'] == 'active'} &&
+          db_parameter_groups.all? {|hash| hash['ParameterApplyStatus'] == 'in-sync' }
+      end
+
+      parameter_group.destroy
+      security_group.destroy
+    end
+
+    tests("#reboot").succeeds do
+      @instance.reboot
+    end
+    @instance.reload.wait_for {state == 'rebooting'}
+    @instance.reload.wait_for { ready? }
+
+    tests('#create_read_replica').succeeds do
+      replica = @instance_with_final_snapshot.create_read_replica(uniq_id('fog-replica'))
+      @instance_with_final_snapshot.reload
+      returns([replica.id]) { @instance_with_final_snapshot.read_replica_identifiers }
+      returns(@instance_with_final_snapshot.id) { replica.read_replica_source }
+
+      replica.wait_for { ready? }
+      replica.destroy
+    end
+
+    test("Destroying with a final snapshot") do
+      final_snapshot_id = 'fog-test-snapshot'
+
+      @instance_with_final_snapshot.wait_for { ready? }
+      @instance_with_final_snapshot.destroy(final_snapshot_id)
+      returns(true, "Final snapshot created") do
+        @final_snapshot = AWS[:rds].snapshots.get(final_snapshot_id)
+        !@final_snapshot.nil?
+      end
+
+      @final_snapshot.wait_for { ready? }
+      @final_snapshot.destroy
+    end
+
+  end
+end