fog-maestrodev 1.15.0.20130829165835 → 1.15.0.20130927082724

data/tests/aws/models/compute/subnets_tests.rb

@@ -1,6 +1,6 @@
 Shindo.tests("Fog::Compute[:aws] | subnets", ['aws']) do
   @vpc=Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/28')
-  collection_tests(Fog::Compute[:aws].subnets, { :vpc_id => @vpc.id, :cidr_block => '10.0.10.0/28'}, true)
+  collection_tests(Fog::Compute[:aws].subnets, { :vpc_id => @vpc.id, :cidr_block => '10.0.10.0/28', :availability_zone => 'us-east-1c'}, true)
   @vpc.destroy
 end
 

data/tests/aws/requests/data_pipeline/helper.rb

@@ -6,6 +6,14 @@ class AWS
         'pipelineId' => String,
       }
 
+      FIELDS = [
+        {
+          "key" => String,
+          "refValue" => Fog::Nullable::String,
+          "stringValue" => Fog::Nullable::String,
+        }
+      ]
+
       LIST_PIPELINES = {
         "hasMoreResults" => Fog::Nullable::Boolean,
         "marker" => Fog::Nullable::String,
@@ -17,19 +25,31 @@ class AWS
         ]
       }
 
+      QUERY_OBJECTS = {
+        "hasMoreResults" => Fog::Nullable::Boolean,
+        "marker" => Fog::Nullable::String,
+        "ids" => Fog::Nullable::Array,
+      }
+
+      DESCRIBE_OBJECTS = {
+        "hasMoreResults" => Fog::Nullable::Boolean,
+        "marker" => Fog::Nullable::String,
+        "pipelineObjects" => [
+          {
+            'id' => String,
+            'name' => String,
+            'fields' => FIELDS,
+          }
+        ]
+      }
+
       DESCRIBE_PIPELINES = {
         "pipelineDescriptionList" => [
           {
             "description" => Fog::Nullable::String,
             "name" => String,
             "pipelineId" => String,
-            "fields" => [
-              {
-                "key" => String,
-                "refValue" => Fog::Nullable::String,
-                "stringValue" => Fog::Nullable::String,
-              }
-            ]
+            "fields" => FIELDS,
           }
         ]
       }
@@ -38,7 +58,17 @@ class AWS
         "errored" => Fog::Boolean,
         "validationErrors" => Fog::Nullable::Array,
       }
-	
+
+      GET_PIPELINE_DEFINITION = {
+        "pipelineObjects" => [
+          {
+            "id" => String,
+            "name" => String,
+            "fields" => FIELDS,
+          }
+        ]
+      }
+
     end
   end
 end

data/tests/aws/requests/data_pipeline/pipeline_tests.rb

@@ -46,7 +46,31 @@ Shindo.tests('AWS::DataPipeline | pipeline_tests', ['aws', 'data_pipeline']) do
       Fog::AWS[:data_pipeline].activate_pipeline(@pipeline_id)
     end
 
-    tests("#delete_pipeline") do
+    tests("#get_pipeline_definition").formats(AWS::DataPipeline::Formats::GET_PIPELINE_DEFINITION) do
+      Fog::AWS[:data_pipeline].get_pipeline_definition(@pipeline_id)
+    end
+
+    tests("#query_objects") do
+      tests("for COMPONENTs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'COMPONENT')
+      end
+
+      tests("for INSTANCEs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'INSTANCE')
+      end
+
+      tests("for ATTEMPTs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'ATTEMPT')
+      end
+    end
+
+    tests('#describe_objects').formats(AWS::DataPipeline::Formats::DESCRIBE_OBJECTS) do
+      attempts = Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'ATTEMPT')
+      object_ids = attempts['ids'][0..5]
+      Fog::AWS[:data_pipeline].describe_objects(@pipeline_id, object_ids)
+    end
+
+    tests("#delete_pipeline").returns(true) do
       Fog::AWS[:data_pipeline].delete_pipeline(@pipeline_id)
     end
 

data/tests/aws/requests/elasticache/security_group_tests.rb

@@ -1,10 +1,9 @@
 Shindo.tests('AWS::Elasticache | security group requests', ['aws', 'elasticache']) do
 
   tests('success') do
-    pending if Fog.mocking?
 
     name = 'fog-test'
-    description = 'Fog Test Group'
+    description = 'Fog Test Security Group'
 
     tests(
     '#create_cache_security_group'
@@ -74,6 +73,8 @@ Shindo.tests('AWS::Elasticache | security group requests', ['aws', 'elasticache'
       tests(
       '#revoke_cache_security_group_ingress'
       ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+        pending if Fog.mocking?
+
         body = AWS[:elasticache].revoke_cache_security_group_ingress(
           name, ec2_group.name, ec2_group.owner_id
         ).body

data/tests/aws/requests/redshift/cluster_parameter_group_tests.rb

@@ -0,0 +1,77 @@
+Shindo.tests('Fog::Redshift[:aws] | cluster parameter group requests', ['aws']) do
+  pending if Fog.mocking?
+  suffix = rand(65536).to_s(16)
+  parameter_group = "test-cluster-parameter-group-#{suffix}"
+
+  @cluster_parameter_format = {
+    'Parameter' => {
+      "ParameterValue" => String,
+      "DataType"       => String,
+      "Source"         => String,
+      "IsModifiable"   => Fog::Boolean,
+      "Description"    => String,
+      "ParameterName"  => String
+    }
+  }
+
+  @cluster_parameters_format = {
+    "Parameters"=> [@cluster_parameter_format]
+  }
+
+  @cluster_parameter_group_format = {
+    'ClusterParameterGroup' => {
+      "ParameterGroupFamily" => String,
+      "Description"          => String,
+      "ParameterGroupName"   => String
+    }
+  }
+
+  @cluster_parameter_groups_format = {
+    "ParameterGroups"=> [@cluster_parameter_group_format]
+  }
+
+  @modify_cluster_parameter_group_format = {
+    "ParameterGroupStatus" => String,
+    "ParameterGroupName"   => String
+  }
+
+  tests('success') do
+    tests("create_cluster_parameter_group").formats(@cluster_parameter_group_format) do
+      body = Fog::AWS[:redshift].create_cluster_parameter_group(:parameter_group_name=> parameter_group, 
+                                                                :parameter_group_family=>"redshift-1.0", 
+                                                                :description=>'testing').body
+      body
+    end
+
+
+    tests("describe_cluster_parameter_groups").formats(@cluster_parameter_groups_format) do
+      body = Fog::AWS[:redshift].describe_cluster_parameter_groups.body
+      body
+    end
+
+    tests("describe_cluster_parameters").formats(@cluster_parameters_format) do
+      body = Fog::AWS[:redshift].describe_cluster_parameters(:parameter_group_name=>parameter_group).body
+      body
+    end
+
+    tests("modify_cluster_parameter_groups").formats(@modify_cluster_parameter_group_format) do
+      body = Fog::AWS[:redshift].modify_cluster_parameter_group(:parameter_group_name=>parameter_group, 
+                                                                :parameters=>{
+                                                                   :parameter_name=>'extra_float_digits',
+                                                                   :parameter_value=>2}).body
+      body
+    end
+
+    tests("delete_cluster_parameter_group") do 
+      present = !Fog::AWS[:redshift].describe_cluster_parameter_groups(:parameter_group_name=>parameter_group).body['ParameterGroups'].empty?
+      tests("verify presence before deletion").returns(true) { present }
+
+      Fog::AWS[:redshift].delete_cluster_parameter_group(:parameter_group_name=>parameter_group)
+
+      not_present = Fog::AWS[:redshift].describe_cluster_parameter_groups(:parameter_group_name=>parameter_group).body['ParameterGroups'].empty?
+      tests("verify deletion").returns(true) { not_present }
+     end
+
+  end
+
+end

data/tests/aws/requests/redshift/cluster_security_group_tests.rb

@@ -0,0 +1,44 @@
+Shindo.tests('Fog::Redshift[:aws] | cluster security group requests', ['aws']) do
+  pending if Fog.mocking?
+  suffix     = rand(65536).to_s(16) 
+  identifier = "test-cluster-security-group-#{suffix}"
+
+  @cluster_security_group_format = {
+    "ClusterSecurityGroup"  => {
+      "EC2SecurityGroups"        => Fog::Nullable::Array,             
+      "IPRanges"                 => Fog::Nullable::Array,             
+      "Description"              => String,
+      "ClusterSecurityGroupName" => String
+    }
+  }
+
+  @describe_cluster_security_groups_format = {
+    "ClusterSecurityGroups" => [@cluster_security_group_format]
+  }
+
+
+  tests('success') do
+    tests("create_cluster_security_group").formats(@cluster_security_group_format) do
+      body = Fog::AWS[:redshift].create_cluster_security_group(:cluster_security_group_name => identifier, :description => 'testing').body
+      body
+    end
+
+
+    tests("describe_cluster_security_groups").formats(@describe_cluster_security_groups_format) do
+      body = Fog::AWS[:redshift].describe_cluster_security_groups.body
+      body
+    end
+
+    tests("delete_cluster_security_group") do 
+      present = !Fog::AWS[:redshift].describe_cluster_security_groups(:cluster_security_group_name => identifier).body['ClusterSecurityGroups'].empty?
+      tests("verify presence before deletion").returns(true) { present }
+
+      Fog::AWS[:redshift].delete_cluster_security_group(:cluster_security_group_name => identifier)
+
+      not_present = Fog::AWS[:redshift].describe_cluster_security_groups(:cluster_security_group_name => identifier).body['ClusterSecurityGroups'].empty?
+      tests("verify deletion").returns(true) { not_present }
+    end
+
+  end
+
+end

data/tests/aws/requests/redshift/cluster_snapshot_tests.rb

@@ -0,0 +1,75 @@
+Shindo.tests('Fog::Redshift[:aws] | cluster snapshot requests', ['aws']) do
+  pending if Fog.mocking?
+  suffix = rand(65536).to_s(16)
+  identifier = "test-snapshot-#{suffix}"
+  cluster    = "test-cluster-#{suffix}"
+  start_time = Fog::Time.now.to_iso8601_basic
+  @cluster_snapshot_format = { 
+    'Snapshot' => {
+      "AccountsWithRestoreAccess"              => Fog::Nullable::Array,
+      "Port"                                   => Integer,
+      "SnapshotIdentifier"                     => String,
+      "OwnerAccount"                           => String,
+      "Status"                                 => String,
+      "SnapshotType"                           => String,
+      "ClusterVersion"                         => String,
+      "EstimatedSecondsToCompletion"           => Integer,
+      "SnapshotCreateTime"                     => Time,
+      "Encrypted"                              => Fog::Boolean,
+      "NumberOfNodes"                          => Integer,
+      "DBName"                                 => String,
+      "CurrentBackupRateInMegaBytesPerSecond"  => Float,
+      "ClusterCreateTime"                      => Time,
+      "AvailabilityZone"                       => String,
+      "ActualIncrementalBackupSizeInMegaBytes" => Float,
+      "TotalBackupSizeInMegaBytes"             => Float,
+      "ElapsedTimeInSeconds"                   => Integer,
+      "BackupProgressInMegaBytes"              => Float,
+      "NodeType"                               => String,
+      "ClusterIdentifier"                      => String,
+      "MasterUsername"                         => String
+    }
+  }
+
+  @describe_cluster_snapshots_format = {
+    "Snapshots" => [@cluster_snapshot_format]
+  }
+
+
+  tests('success') do
+    tests("create_cluster_snapshot").formats(@cluster_snapshot_format) do
+      Fog::AWS[:redshift].create_cluster(:cluster_identifier   => cluster, 
+                                         :master_user_password => 'Pass1234', 
+                                         :master_username      => 'testuser', 
+                                         :node_type            => 'dw.hs1.xlarge', 
+                                         :cluster_type         => 'single-node')
+      Fog.wait_for do
+        "available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>cluster).body['ClusterSet'].first['Cluster']['ClusterStatus']
+      end
+      body = Fog::AWS[:redshift].create_cluster_snapshot(:snapshot_identifier => identifier, 
+                                                         :cluster_identifier  => cluster).body
+      body
+    end
+
+
+    tests('describe_cluster_snaphots').formats(@describe_cluster_snapshots_format) do
+      sleep 30 unless Fog.mocking?
+      body = Fog::AWS[:redshift].describe_cluster_snapshots(:start_time=>start_time).body
+      body
+    end
+
+    tests('delete_cluster_snapshot').formats(@cluster_snapshot_format) do 
+      Fog.wait_for do
+        "available" == Fog::AWS[:redshift].describe_cluster_snapshots(:snapshot_identifier=>identifier).body['Snapshots'].first['Snapshot']['Status']        
+      end
+      sleep 30 unless Fog.mocking?
+      body = Fog::AWS[:redshift].delete_cluster_snapshot(:snapshot_identifier=>identifier).body      
+      body
+    end
+
+    Fog::AWS[:redshift].delete_cluster(:cluster_identifier          => cluster, 
+                                       :skip_final_cluster_snapshot => true)
+
+  end
+
+end

data/tests/aws/requests/redshift/cluster_tests.rb

@@ -0,0 +1,82 @@
+Shindo.tests('Fog::Redshift[:aws] | cluster requests', ['aws']) do
+  pending if Fog.mocking?
+  identifier = "test-cluster-#{rand(65536).to_s(16)}"
+
+  @cluster_format = {
+    'Cluster' => { 
+      "ClusterParameterGroups"  => [{
+        "ClusterParameterGroup" => {
+          "ParameterApplyStatus"  => String,
+          "ParameterGroupName"    => String
+        }
+      }],
+      "ClusterSecurityGroups"  => [{
+        'ClusterSecurityGroup' => {
+          "Status"                   => String,
+          "ClusterSecurityGroupName" => String
+        }
+      }],
+      "VpcSecurityGroups"     => Fog::Nullable::Array,
+      "EndPoint"              => Fog::Nullable::Hash, 
+      "PendingModifiedValues" => Fog::Nullable::Hash,
+      "RestoreStatus"         => Fog::Nullable::Hash,
+      "ClusterVersion"        => String,
+      "ClusterStatus"         => String,
+      "Encrypted"             => Fog::Boolean,
+      "NumberOfNodes"         => Integer,
+      "PubliclyAccessible"    => Fog::Boolean,
+      "AutomatedSnapshotRetentionPeriod" => Integer,
+      "DBName"                => String,
+      "PreferredMaintenanceWindow" => String,
+      "NodeType"              => String,
+      "ClusterIdentifier"     => String,
+      "AllowVersionUpgrade"   => Fog::Boolean,
+      "MasterUsername"        => String
+    }
+  }
+  @describe_clusters_format = {
+    "ClusterSet" => [{
+      'Cluster' => @cluster_format['Cluster'].merge({"ClusterCreateTime"=>Time, "AvailabilityZone"=>String, "EndPoint"=>{"Port"=>Integer, "Address"=>String}})
+    }]      
+  }
+
+  tests('success') do
+    tests('create_cluster').formats(@cluster_format) do
+      body = Fog::AWS[:redshift].create_cluster(:cluster_identifier   => identifier, 
+                                                :master_user_password => 'Password1234', 
+                                                :master_username      => 'testuser',
+                                                :node_type            => 'dw.hs1.xlarge', 
+                                                :cluster_type         => 'single-node').body
+      Fog.wait_for do
+        "available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body['ClusterSet'].first['Cluster']['ClusterStatus']
+      end
+      body
+    end
+
+    tests('describe_clusters').formats(@describe_clusters_format["ClusterSet"]) do
+      sleep 30 unless Fog.mocking?
+      body = Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body["ClusterSet"]
+      body
+    end
+
+
+    tests('reboot_cluster') do
+      sleep 30 unless Fog.mocking?
+      body = Fog::AWS[:redshift].reboot_cluster(:cluster_identifier=>identifier).body
+      tests("verify reboot").returns("rebooting") { body['Cluster']['ClusterStatus']}
+      body
+    end
+
+
+    tests('delete_cluster') do
+      Fog.wait_for do
+        "available" == Fog::AWS[:redshift].describe_clusters(:cluster_identifier=>identifier).body['ClusterSet'].first['Cluster']['ClusterStatus']
+      end
+      sleep 30 unless Fog.mocking?
+      body = Fog::AWS[:redshift].delete_cluster(:cluster_identifier=>identifier, :skip_final_cluster_snapshot=>true).body
+      tests("verify delete").returns("deleting") { body['Cluster']['ClusterStatus']}
+      body
+    end
+  end
+
+end

data/tests/aws/requests/sts/get_federation_token_tests.rb

@@ -14,7 +14,6 @@ Shindo.tests('AWS::STS | session tokens', ['aws']) do
 	}
 
 	tests("#get_federation_token('test@fog.io', #{@policy.inspect})").formats(@federation_format) do
-		pending if Fog.mocking?
 		Fog::AWS[:sts].get_federation_token("test@fog.io", @policy).body
 	end
 	

data/tests/aws/signed_params_tests.rb

@@ -2,4 +2,16 @@
 
 Shindo.tests('AWS | signed_params', ['aws']) do
   returns( Fog::AWS.escape( "'Stöp!' said Fred_-~." ) ) { "%27St%C3%B6p%21%27%20said%20Fred_-~." }
+
+  tests('Keys can contain a hierarchical prefix which should not be escaped') do
+    returns( Fog::AWS.escape( "key/with/prefix" ) ) { "key/with/prefix" }
+  end
+
+  tests('Keys should be canonicalised using Unicode NFC') do
+    returns( Fog::AWS.escape( ["00E9".to_i(16)].pack("U*") ) ) { "%C3%A9" }
+
+    tests('Characters with combining mark should be combined and then escaped') do
+      returns( Fog::AWS.escape( ["0065".to_i(16), "0301".to_i(16)].pack("U*") ) ) { "%C3%A9" }
+    end
+  end
 end