minor cleanup and add first pass at schedule_key_deletion method and mock

Author: geemus

lib/fog/aws/kms.rb

@@ -20,6 +20,7 @@ class KMS < Fog::Service
       request :list_keys
       request :create_key
       request :describe_key
+      request :schedule_key_deletion
 
       model_path 'fog/aws/models/kms'
       model      :key

lib/fog/aws/parsers/kms/describe_key.rb

@@ -17,9 +17,9 @@ def start_element(name, attrs = [])
 
           def end_element(name)
             case name
-            when 'KeyUsage', 'AWSAccountId', 'Description', 'KeyId', 'Arn'
+            when 'Arn', 'AWSAccountId', 'Description', 'KeyId', 'KeyState', 'KeyUsage'
               @key[name] = value
-            when 'CreationDate'
+            when 'CreationDate', 'DeletionDate'
               @key[name] = Time.parse(value)
             when 'Enabled'
               @key[name] = (value == 'true')

lib/fog/aws/parsers/kms/schedule_key_deletion.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Parsers
+    module AWS
+      module KMS
+        class ScheduleKeyDeletion < Fog::Parsers::Base
+          def reset
+            @response = {}
+          end
+
+          def start_element(name, attrs = [])
+            super
+          end
+
+          def end_element(name)
+            case name
+            when 'DeletionDate'
+              @response[name] = Time.parse(value)
+            when 'KeyId', 'KeyState'
+              @response[name] = value
+            when 'PendingWindowInDays'
+              @response[name] = value.to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/fog/aws/requests/kms/create_key.rb

@@ -4,38 +4,40 @@ class KMS
       class Real
         require 'fog/aws/parsers/kms/describe_key'
 
-        def create_key(policy = nil, description = nil, usage = "ENCRYPT_DECRYPT")
+        def create_key(policy = nil, description = nil, usage = 'ENCRYPT_DECRYPT')
           request(
-            'Action'      => 'CreateKey',
+            'Action' => 'CreateKey',
             'Description' => description,
-            'KeyUsage'    => usage,
-            'Policy'      => policy,
-            :parser       => Fog::Parsers::AWS::KMS::DescribeKey.new
+            'KeyUsage' => usage,
+            'Policy' => policy,
+            :parser => Fog::Parsers::AWS::KMS::DescribeKey.new
           )
         end
       end
 
       class Mock
-        def create_key(policy = nil, description = nil, usage = "ENCRYPT_DECRYPT")
+        def create_key(_policy = nil, description = nil, usage = 'ENCRYPT_DECRYPT')
           response = Excon::Response.new
           key_id   = UUID.uuid
           key_arn  = Fog::AWS::Mock.arn("kms", self.account_id, "key/#{key_id}", @region)
 
           key = {
-            "KeyUsage"     => usage,
-            "AWSAccountId" => self.account_id,
-            "KeyId"        => key_id,
-            "Description"  => description,
-            "CreationDate" => Time.now,
-            "Arn"          => key_arn,
-            "Enabled"      => true,
+            'Arn' => key_arn,
+            'AWSAccountId' => self.account_id,
+            'CreationDate' => Time.now.utc,
+            'DeletionDate' => nil,
+            'Description' => description,
+            'Enabled' => true,
+            'KeyId' => key_id,
+            'KeyState' => 'Enabled',
+            'KeyUsage' => usage
           }
 
           # @todo use default policy
 
           self.data[:keys][key_id] = key
 
-          response.body = { "KeyMetadata" => key }
+          response.body = { 'KeyMetadata' => key }
           response
         end
       end

lib/fog/aws/requests/kms/list_keys.rb

@@ -43,9 +43,9 @@ def list_keys(options={})
           key_set = if marker
                       self.data[:markers][marker] || []
                     else
-                      self.data[:keys].inject([]) { |r,(k,v)|
-                        r << { "KeyId" => k, "KeyArn" => v["Arn"] }
-                      }
+                      self.data[:keys].inject([]) do |r, (k, v)|
+                        r << { 'KeyArn' => v['Arn'], 'KeyId' => k }
+                      end
                     end
 
           keys = if limit

lib/fog/aws/requests/kms/schedule_key_deletion.rb

@@ -0,0 +1,37 @@
+module Fog
+  module AWS
+    class KMS
+      class Real
+        require 'fog/aws/parsers/kms/schedule_key_deletion'
+
+        def schedule_key_deletion(identifier, pending_window_in_days)
+          request(
+            'Action' => 'ScheduleKeyDeletion',
+            'KeyId' => identifier,
+            'PendingWindowInDays' => pending_window_in_days,
+            :parser => Fog::Parsers::AWS::KMS::ScheduleKeyDeletion.new
+          )
+        end
+      end
+
+      class Mock
+        def schedule_key_deletion(identifier, pending_window_in_days)
+          response = Excon::Response.new
+          key = self.data[:keys][identifier]
+
+          key['DeletionDate'] = Time.now + (60 * 60 * 24 * pending_window_in_days)
+          key['Enabled'] = false
+          key['KeyState'] = 'PendingDeletion'
+
+          response.body = {
+            'DeletionDate' => key['DeletionDate'],
+            'KeyId' => key['KeyId'],
+            'KeyState' => key['KeyState'],
+            'PendingWindowInDays' => pending_window_in_days
+          }
+          response
+        end
+      end
+    end
+  end
+end

tests/requests/kms/helper.rb

@@ -7,20 +7,29 @@ module Formats
 
       DESCRIBE_KEY = {
         'KeyMetadata' => {
-          'KeyUsage' => String,
+          'Arn' => String,
           'AWSAccountId' => String,
-          'KeyId' => String,
-          'Description' => Fog::Nullable::String,
           'CreationDate' => Time,
-          'Arn' => String,
-          'Enabled' => Fog::Boolean
+          'DeletionDate' => Fog::Nullable::Time,
+          'Description' => Fog::Nullable::String,
+          'Enabled' => Fog::Boolean,
+          'KeyId' => String,
+          'KeyState' => String,
+          'KeyUsage' => String
         }
       }.freeze
 
       LIST_KEYS = {
-        'Keys' => [{ 'KeyId' => String, 'KeyArn' => String }],
-        'Truncated' => Fog::Boolean,
-        'Marker' => Fog::Nullable::String
+        'Keys' => [{ 'KeyArn' => String, 'KeyId' => String }],
+        'Marker' => Fog::Nullable::String,
+        'Truncated' => Fog::Boolean
+      }.freeze
+
+      SCHEDULE_KEY_DELETION = {
+        'DeletionDate' => Time,
+        'KeyId' => String,
+        'KeyState' => String,
+        'PendingWindowInDays' => Integer
       }.freeze
     end
   end

tests/requests/kms/key_tests.rb

@@ -19,4 +19,8 @@
   tests('#list_keys').data_matches_schema(AWS::KMS::Formats::LIST_KEYS) do
     Fog::AWS[:kms].list_keys.body
   end
+
+  tests('#schedule_key_deletion').data_matches_schema(AWS::KMS::Formats::SCHEDULE_KEY_DELETION) do
+    Fog::AWS[:kms].schedule_key_deletion(key_id, 7)
+  end
 end