rews 0.2.12 → 0.5.0

data/lib/rews/util.rb

@@ -63,6 +63,16 @@ module Rews
       Hash[h.map{|k,v| [camelize(k.to_s), v]}]
     end
 
+    # convert rsxml to xml, transforming tags to CamelCase and prefixing with
+    # the t: namespace prefix
+    def rsxml_to_xml(sexp)
+      Rsxml.to_xml(sexp) do |tag, attrs|
+        ttag = "t:#{camelize(tag.to_s)}"
+        tattrs = Hash[attrs.map{|k,v| [camelize(k.to_s), v]}]
+        [ttag, tattrs]
+      end
+    end
+
     # check the response codes of an Exchange Web Services request.
     # the supplied block makes a SOAP request, and the response is parsed
     # out and checked
@@ -82,7 +92,7 @@ module Rews
         
         errors = all_statuses.map{|s| single_error_check(client, s)}.compact
       rescue Exception=>e
-        client.log{|logger| logger.warn(e)}
+        Rews.log{|logger| logger.warn(e)}
         tag_exception(e, :savon_response=>response)
         raise e
       end
@@ -102,7 +112,7 @@ module Rews
       if status[:response_class] == "Error"
         return "#{status[:response_code]} - #{status[:message_text]}"
       elsif status[:response_class] == "Warning"
-        client.log{|logger| logger.warn("#{status[:response_code]} - #{status[:message_text]}")}
+        Rews.log{|logger| logger.warn("#{status[:response_code]} - #{status[:message_text]}")}
       end
     end
   end

data/spec/request_proxy.rb

@@ -4,7 +4,8 @@ class RequestProxy
   attr_accessor :soap
   attr_accessor :http
   def initialize
-    @soap=Object.new
+    soap_struct = Struct.new(:body)
+    @soap = soap_struct.new
     @http=Object.new
   end
 
@@ -16,5 +17,28 @@ class RequestProxy
   def method_missing(method, *args, &block)
     @self_before_instance_eval.send method, *args, &block
   end
+
+  class << self
+    # mocks a request to the savon client, and validates that the body xml generated
+    # is correct
+    def mock_request(example, client, action, attrs, response, &validate_block)
+      # deal with different call arity
+      example.mock(client).savon_client.mock!.request(*[:wsdl, action, attrs].compact) do |*args|
+        block = args.last # block is the last arg
+
+        ctx = RequestProxy.new()
+        example.mock(ctx.http).headers.mock!["SOAPAction"]="\"#{Rews::SCHEMA_MESSAGES}/#{action}\""
+        ns = Object.new
+        example.mock(ctx.soap).namespaces{ns}
+        example.mock(ns)["xmlns:t"]=Rews::SCHEMA_TYPES
+        #          mock(ctx.soap).body=(anything)
+
+        ctx.eval_with_delegation(&block)
+
+        validate_block.call(ctx.soap.body) if validate_block
+        response
+      end
+    end
+  end
 end
 

data/spec/rews/client_spec.rb

@@ -17,5 +17,309 @@ module Rews
 
       client.distinguished_folder_id('inbox')
     end
+
+    describe "create_item" do
+      def test_create_item(client, items, &validate_block)
+        response = Object.new
+        mock(response).to_hash{{:create_item_response=>{:response_messages=>{:create_item_response_message=>{:response_class=>"Success"}}}}}
+
+        RequestProxy.mock_request(self, 
+                                  client, 
+                                  "CreateItem",
+                                  {},
+                                  response,
+                                  &validate_block)
+        client.create_item(:items=>items)
+      end
+
+      it "should create a CreateItem request and render the Items to the body" do
+        client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+        test_create_item(client, [[:suppress_read_receipt, [:reference_item_id, {:id=>"abc", :change_key=>"def"}]]]) do |body|
+          rsxml = Rsxml.to_rsxml(body, :ns=>{"wsdl"=>"ews_wsdl", "t"=>"ews_types"})
+          rsxml.should == ["wsdl:Items",{"xmlns:wsdl"=>"ews_wsdl", "xmlns:t"=>"ews_types"},
+                           ["t:SuppressReadReceipt",
+                            ["t:ReferenceItemId", {"Id"=>"abc", "ChangeKey"=>"def"}]]]
+        end
+      end
+    end
+
+    describe "suppress_read_receipt" do
+      def test_suppress_read_receipt(client, item_or_item_ids, &validate_block)
+        response = Object.new
+        mock(response).to_hash{{:create_item_response=>{:response_messages=>{:create_item_response_message=>{:response_class=>"Success"}}}}}
+
+        RequestProxy.mock_request(self, 
+                                  client, 
+                                  "CreateItem",
+                                  {},
+                                  response,
+                                  &validate_block)
+        client.suppress_read_receipt(item_or_item_ids)
+      end
+
+      it "should send a CreateItemRequest with SuppressReadReceipt items for each ItemId" do
+        client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+        test_suppress_read_receipt(client, [Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"}),
+                                             Item::ItemId.new(client, {:id=>"ghi", :change_key=>"jkl"})]) do |body|
+          rsxml = Rsxml.to_rsxml(body, :ns=>{"wsdl"=>"ews_wsdl", "t"=>"ews_types"})
+          rsxml.should ==  ["wsdl:Items", {"xmlns:wsdl"=>"ews_wsdl", "xmlns:t"=>"ews_types"},
+                            ["t:SuppressReadReceipt",
+                             ["t:ReferenceItemId", {"Id"=>"abc", "ChangeKey"=>"def"}]],
+                            ["t:SuppressReadReceipt",
+                             ["t:ReferenceItemId", {"Id"=>"ghi", "ChangeKey"=>"jkl"}]]]
+        end
+      end
+
+      it "should send a CreateItemRequest with SuppressReadReceipt items for each Item" do
+        client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+        test_suppress_read_receipt(client, [Item::Item.new(client, 'Message', {:item_id=>{:id=>'abc', :change_key=>'def'}}),
+                                             Item::Item.new(client, 'Message', {:item_id=>{:id=>'ghi', :change_key=>'jkl'}})]) do |body|
+          rsxml = Rsxml.to_rsxml(body, :ns=>{"wsdl"=>"ews_wsdl", "t"=>"ews_types"})
+          rsxml.should ==  ["wsdl:Items", {"xmlns:wsdl"=>"ews_wsdl", "xmlns:t"=>"ews_types"},
+                            ["t:SuppressReadReceipt",
+                             ["t:ReferenceItemId", {"Id"=>"abc", "ChangeKey"=>"def"}]],
+                            ["t:SuppressReadReceipt",
+                             ["t:ReferenceItemId", {"Id"=>"ghi", "ChangeKey"=>"jkl"}]]]
+        end
+      end
+
+      it "should filter Items with IsRead=true or IsReadReceiptRequested=false before making request" do
+        client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+        test_suppress_read_receipt(client, [Item::Item.new(client, 
+                                                            'Message', 
+                                                            {:item_id=>{:id=>'abc', :change_key=>'def'},
+                                                              :is_read=>true}),
+                                             Item::Item.new(client, 'Message', {:item_id=>{:id=>'ghi', :change_key=>'jkl'}}),
+                                             Item::Item.new(client, 
+                                                            'Message',
+                                                            {:item_id=>{:id=>'mno', :change_key=>'pqr'},
+                                                              :is_read_receipt_requested=>false})]) do |body|
+          rsxml = Rsxml.to_rsxml(body, :ns=>{"wsdl"=>"ews_wsdl", "t"=>"ews_types"})
+          rsxml.should == ["wsdl:Items", {"xmlns:wsdl"=>"ews_wsdl", "xmlns:t"=>"ews_types"},
+                           ["t:SuppressReadReceipt",
+                            ["t:ReferenceItemId", {"Id"=>"ghi", "ChangeKey"=>"jkl"}]]]
+        end
+      end
+    end
+
+      describe "get_item" do
+        def test_get_item(client, item_shape, ignore_change_keys, message_ids, result)
+          shape = Object.new
+          mock(Shape::ItemShape).new(item_shape||{}){shape}
+          mock(shape).to_xml{""}
+          
+          message_ids = message_ids.result if message_ids.is_a?(Folder::FindResult)
+          message_ids.each do |mid|
+            if mid.is_a?(Item::Item)
+              mock(mid.item_id).to_xml(ignore_change_keys){""}
+            else
+              mock(mid).to_xml(ignore_change_keys){""}
+            end
+          end
+          
+          response = Object.new
+          mock(response).to_hash{{:get_item_response=>{:response_messages=>{:get_item_response_message=>{:response_class=>"Success", :items=>result}}}}}
+          
+          RequestProxy.mock_request(self, client, "GetItem", nil, response)
+          
+          opts = {}
+          opts[:item_shape]=item_shape if item_shape
+          opts[:ignore_change_keys]=ignore_change_keys if ignore_change_keys
+          client.get_item(message_ids, opts)
+        end
+
+        it "should generate xml including all provided ItemIds and parse response" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          items = test_get_item(client,
+                                {:base_shape=>:IdOnly},
+                                nil,
+                                [Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"})],
+                                {:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}})
+          items.size.should == 1
+          msg=items.first
+          msg.item_id.should == Item::ItemId.new(client, :id=>"abc", :change_key=>"def")
+        end
+
+        it "should generate xml ignoring change keys if requested and parsing a response with multiple items" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          items = test_get_item(client,
+                                {:base_shape=>:Default},
+                                true,
+                                [Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"}),
+                                 Item::ItemId.new(client, {:id=>"ghi", :change_key=>"jkl"})],
+                                {:message=>[{:item_id=>{:id=>"abc", :change_key=>"def"}},
+                                            {:item_id=>{:id=>"ghi", :change_key=>"jkl"}}]})
+          items.size.should == 2
+          items.first.item_id.should == Item::ItemId.new(client, :id=>"abc", :change_key=>"def")
+          items[1].item_id.should == Item::ItemId.new(client, :id=>"ghi", :change_key=>"jkl")
+        end
+
+        it "should extract ItemIds from Items if items are provided as identifiers" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          items = test_get_item(client,
+                                {:base_shape=>:Default},
+                                true,
+                                [Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}}),
+                                 Item::Item.new(client, :message, {:item_id=>{:id=>"ghi", :change_key=>"jkl"}})],
+                                {:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}})
+        end
+
+        it "should extract results from a FindResult if a FindResult is provided for identifiers" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          items = test_get_item(client,
+                                {:base_shape=>:Default},
+                                true,
+                                Folder::FindResult.new({}) {
+                                  [Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}}),
+                                   Item::Item.new(client, :message, {:item_id=>{:id=>"ghi", :change_key=>"jkl"}})]},
+                                {:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}})
+        end
+      end
+
+
+
+      describe "update_item" do
+        def test_update_item(client,
+                             conflict_resolution, 
+                             message_disposition,
+                             ignore_change_keys,
+                             updates,
+                             message_ids,
+                             &validate_block)
+          
+          message_ids = message_ids.result if message_ids.is_a?(Folder::FindResult)
+          message_ids.each do |mid|
+            if mid.is_a?(Item::Item)
+              proy(mid.item_id).to_xml(ignore_change_keys)
+            else
+              proxy(mid).to_xml(ignore_change_keys)
+            end
+          end
+          
+          response = Object.new
+          mock(response).to_hash{{:update_item_response=>{:response_messages=>{:update_item_response_message=>{:response_class=>"Success"}}}}}
+          
+          RequestProxy.mock_request(self, client, "UpdateItem",  
+                                    { :ConflictResolution=>conflict_resolution || "AutoResolve",
+                                      :MessageDisposition=>message_disposition || "SaveOnly"}, 
+                                    response,
+                                    &validate_block)
+          
+          opts = {}
+          opts[:conflict_resolution]=conflict_resolution if conflict_resolution
+          opts[:message_disposition]=message_disposition if message_disposition
+          opts[:ignore_change_keys]=ignore_change_keys if !ignore_change_keys.nil?
+          opts[:updates]=updates
+          client.update_item(message_ids, opts)
+        end
+
+        it "should generate body xml and parse response for a single update" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          test_update_item(client, nil, nil, nil,
+                           SetItemField.new("message:IsRead", [:message, [:is_read, "true"]]),
+                           [Item::ItemId.new(client, :id=>"abc", :change_key=>"def")]) do |body|
+            
+            rsxml = Rsxml.to_rsxml(body, :ns=>{:wsdl=>"ews_wsdl", :t=>"ews_types", ""=>"ews_wsdl"})
+            Rsxml.compare(rsxml, ["wsdl:ItemChanges", {"xmlns:wsdl"=>"ews_wsdl", "xmlns:t"=>"ews_types", "xmlns"=>"ews_wsdl"},
+                                  ["t:ItemChange",
+                                   ["t:ItemId", {"Id"=>"abc", "ChangeKey"=>"def"}],
+                                   ["t:Updates",
+                                    ["t:SetItemField",
+                                     ["t:FieldURI", {"FieldURI"=>"message:IsRead"}],
+                                     ["t:Message", ["t:IsRead", "true"]]]]]]).should == true  
+          end
+        end
+        
+        it "should generate body xml and parse response for a multiple updates of multiple items" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          test_update_item(client, nil, nil, nil,
+                           [SetItemField.new("message:IsRead", [:message, [:is_read, "true"]]),
+                            SetItemField.new("item:Blah", [:item, [:blah, "blah"]])],
+                           [Item::ItemId.new(client, :id=>"abc", :change_key=>"def"),
+                            Item::ItemId.new(client, :id=>"ghi", :change_key=>"jkl")]) do |body|
+            
+            rsxml = Rsxml.to_rsxml(body, :ns=>{:wsdl=>"ews_wsdl", :t=>"ews_types", ""=>"ews_wsdl"})
+            Rsxml.compare(rsxml, ["wsdl:ItemChanges", {"xmlns:wsdl"=>"ews_wsdl", "xmlns:t"=>"ews_types", "xmlns"=>"ews_wsdl"},
+                                  ["t:ItemChange",
+                                   ["t:ItemId", {"Id"=>"abc", "ChangeKey"=>"def"}],
+                                   ["t:Updates",
+                                    ["t:SetItemField",
+                                     ["t:FieldURI", {"FieldURI"=>"message:IsRead"}],
+                                     ["t:Message", ["t:IsRead", "true"]]],
+                                    ["t:SetItemField",
+                                     ["t:FieldURI", {"FieldURI"=>"item:Blah"}],
+                                     ["t:Item", ["t:Blah", "blah"]]]]],
+                                  ["t:ItemChange",
+                                   ["t:ItemId", {"Id"=>"ghi", "ChangeKey"=>"jkl"}],
+                                   ["t:Updates",
+                                    ["t:SetItemField",
+                                     ["t:FieldURI", {"FieldURI"=>"message:IsRead"}],
+                                     ["t:Message", ["t:IsRead", "true"]]],
+                                    ["t:SetItemField",
+                                     ["t:FieldURI", {"FieldURI"=>"item:Blah"}],
+                                     ["t:Item", ["t:Blah", "blah"]]]]]]).should == true  
+          end
+        end
+        
+      end
+
+
+
+      describe "delete_item" do
+        def test_delete_item(client, delete_type, ignore_change_keys, message_ids)
+          message_ids = message_ids.result if message_ids.is_a?(Folder::FindResult)
+          message_ids.each do |mid|
+            if mid.is_a?(Item::Item)
+              mock(mid.item_id).to_xml(ignore_change_keys){""}
+            else
+              mock(mid).to_xml(ignore_change_keys){""}
+            end
+          end
+          
+          response = Object.new
+          mock(response).to_hash{{:delete_item_response=>{:response_messages=>{:delete_item_response_message=>{:response_class=>"Success"}}}}}
+          
+          RequestProxy.mock_request(self, client, "DeleteItem", {:DeleteType=>delete_type}, response)
+          
+          opts = {}
+          opts[:delete_type]=delete_type if delete_type
+          opts[:ignore_change_keys]=ignore_change_keys if ignore_change_keys
+          client.delete_item(message_ids, opts)
+        end
+
+        it "should generate xml including a single ItemId" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          test_delete_item(client, :HardDelete, nil, [Item::ItemId.new(client, :id=>"abc", :change_key=>"def")])
+        end
+        
+        it "should generate xml ignoring change keys and including multiple ItemIds" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          test_delete_item(client, 
+                           :HardDelete, 
+                           true, 
+                           [Item::ItemId.new(client, :id=>"abc", :change_key=>"def"),
+                           Item::ItemId.new(client, :id=>"ghi", :change_key=>"jkl")])
+        end
+
+        it "should extract ItemIds from Items if Items are provided as identifiers" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          test_delete_item(client, 
+                           :HardDelete, 
+                           true, 
+                           [Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}}),
+                            Item::Item.new(client, :message, {:item_id=>{:id=>"ghi", :change_key=>"jkl"}})])
+        end
+
+        it "should extract ItemIds from a FindResult if a FindResult is provided as identifiers" do
+          client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+          test_delete_item(client, 
+                           :HardDelete, 
+                           true, 
+                           Folder::FindResult.new({}) {[Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}}),
+                                                        Item::Item.new(client, :message, {:item_id=>{:id=>"ghi", :change_key=>"jkl"}})]})
+        end
+      end
+
+
   end
 end

data/spec/rews/folder_spec.rb

@@ -88,23 +88,6 @@ module Rews
     end
 
     describe Folder::BaseFolderId do
-      def mock_request(client, action, attrs, response)
-        # deal with different call arity
-        mock(client).savon_client.mock!.request(*[:wsdl, action, attrs].compact) do |*args|
-          block = args.last # block is the last arg
-
-          ctx = RequestProxy.new()
-          mock(ctx.http).headers.mock!["SOAPAction"]="\"#{SCHEMA_MESSAGES}/#{action}\""
-          ns = Object.new
-          mock(ctx.soap).namespaces{ns}
-          mock(ns)["xmlns:t"]=Rews::SCHEMA_TYPES
-          mock(ctx.soap).body=(anything)
-          
-          ctx.eval_with_delegation(&block)
-          response
-        end
-      end
-
       describe "find_folder" do
         def test_find_folder(client, folder_shape, indexed_page_folder_view, restriction, result)
           shape = Object.new
@@ -129,7 +112,7 @@ module Rews
           response = Object.new
           mock(response).to_hash{{:find_folder_response=>{:response_messages=>{:find_folder_response_message=>{:response_class=>"Success", :root_folder=>result}}}}}
 
-          mock_request(client, "FindFolder", {"Traversal"=>"Shallow"}, response)
+          RequestProxy.mock_request(self, client, "FindFolder", {"Traversal"=>"Shallow"}, response)
 
           opts = {}
           opts[:folder_shape] = folder_shape if folder_shape
@@ -227,7 +210,7 @@ module Rews
         response = Object.new
         mock(response).to_hash{{:find_item_response=>{:response_messages=>{:find_item_response_message=>{:response_class=>"Success", :root_folder=>result}}}}}
 
-        mock_request(client, "FindItem", {"Traversal"=>"Shallow"}, response)
+        RequestProxy.mock_request(self, client, "FindItem", {"Traversal"=>"Shallow"}, response)
 
         opts = {}
         opts[:item_shape] = item_shape if item_shape
@@ -314,139 +297,8 @@ module Rews
         end
       end
 
-      describe "get_item" do
-        def test_get_item(client, item_shape, ignore_change_keys, message_ids, result)
-          shape = Object.new
-          mock(Shape::ItemShape).new(item_shape||{}){shape}
-          mock(shape).to_xml{""}
-          
-          fid = Folder::DistinguishedFolderId.new(client, 'blah')
-
-          message_ids = message_ids.result if message_ids.is_a?(Folder::FindResult)
-          message_ids.each do |mid|
-            if mid.is_a?(Item::Item)
-              mock(mid.item_id).to_xml(ignore_change_keys){""}
-            else
-              mock(mid).to_xml(ignore_change_keys){""}
-            end
-          end
-          
-          response = Object.new
-          mock(response).to_hash{{:get_item_response=>{:response_messages=>{:get_item_response_message=>{:response_class=>"Success", :items=>result}}}}}
-          
-          mock_request(client, "GetItem", nil, response)
-          
-          opts = {}
-          opts[:item_shape]=item_shape if item_shape
-          opts[:ignore_change_keys]=ignore_change_keys if ignore_change_keys
-          fid.get_item(message_ids, opts)
-        end
-
-        it "should generate xml including all provided ItemIds and parse response" do
-          client = Object.new
-          items = test_get_item(client,
-                                {:base_shape=>:IdOnly},
-                                nil,
-                                [Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"})],
-                                {:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}})
-          items.size.should == 1
-          msg=items.first
-          msg.item_id.should == Item::ItemId.new(client, :id=>"abc", :change_key=>"def")
-        end
-
-        it "should generate xml ignoring change keys if requested and parsing a response with multiple items" do
-          client = Object.new
-          items = test_get_item(client,
-                                {:base_shape=>:Default},
-                                true,
-                                [Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"}),
-                                 Item::ItemId.new(client, {:id=>"ghi", :change_key=>"jkl"})],
-                                {:message=>[{:item_id=>{:id=>"abc", :change_key=>"def"}},
-                                            {:item_id=>{:id=>"ghi", :change_key=>"jkl"}}]})
-          items.size.should == 2
-          items.first.item_id.should == Item::ItemId.new(client, :id=>"abc", :change_key=>"def")
-          items[1].item_id.should == Item::ItemId.new(client, :id=>"ghi", :change_key=>"jkl")
-        end
-
-        it "should extract ItemIds from Items if items are provided as identifiers" do
-          client = Object.new
-          items = test_get_item(client,
-                                {:base_shape=>:Default},
-                                true,
-                                [Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}}),
-                                 Item::Item.new(client, :message, {:item_id=>{:id=>"ghi", :change_key=>"jkl"}})],
-                                {:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}})
-        end
-
-        it "should extract results from a FindResult if a FindResult is provided for identifiers" do
-          client = Object.new
-          items = test_get_item(client,
-                                {:base_shape=>:Default},
-                                true,
-                                Folder::FindResult.new({}) {
-                                  [Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}}),
-                                   Item::Item.new(client, :message, {:item_id=>{:id=>"ghi", :change_key=>"jkl"}})]},
-                                {:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}})
-        end
-      end
-
-      describe "delete_item" do
-        def test_delete_item(client, delete_type, ignore_change_keys, message_ids)
-          
-          fid = Folder::DistinguishedFolderId.new(client, 'blah')
-
-          message_ids = message_ids.result if message_ids.is_a?(Folder::FindResult)
-          message_ids.each do |mid|
-            if mid.is_a?(Item::Item)
-              mock(mid.item_id).to_xml(ignore_change_keys){""}
-            else
-              mock(mid).to_xml(ignore_change_keys){""}
-            end
-          end
-          
-          response = Object.new
-          mock(response).to_hash{{:delete_item_response=>{:response_messages=>{:delete_item_response_message=>{:response_class=>"Success"}}}}}
-          
-          mock_request(client, "DeleteItem", {:DeleteType=>delete_type}, response)
-          
-          opts = {}
-          opts[:delete_type]=delete_type if delete_type
-          opts[:ignore_change_keys]=ignore_change_keys if ignore_change_keys
-          fid.delete_item(message_ids, opts)
-        end
-
-        it "should generate xml including a single ItemId" do
-          client = Object.new
-          test_delete_item(client, :HardDelete, nil, [Item::ItemId.new(client, :id=>"abc", :change_key=>"def")])
-        end
-        
-        it "should generate xml ignoring change keys and including multiple ItemIds" do
-          client = Object.new
-          test_delete_item(client, 
-                           :HardDelete, 
-                           true, 
-                           [Item::ItemId.new(client, :id=>"abc", :change_key=>"def"),
-                           Item::ItemId.new(client, :id=>"ghi", :change_key=>"jkl")])
-        end
 
-        it "should extract ItemIds from Items if Items are provided as identifiers" do
-          client = Object.new
-          test_delete_item(client, 
-                           :HardDelete, 
-                           true, 
-                           [Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}}),
-                            Item::Item.new(client, :message, {:item_id=>{:id=>"ghi", :change_key=>"jkl"}})])
-        end
 
-        it "should extract ItemIds from a FindResult if a FindResult is provided as identifiers" do
-          client = Object.new
-          test_delete_item(client, 
-                           :HardDelete, 
-                           true, 
-                           Folder::FindResult.new({}) {[Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}}),
-                                                        Item::Item.new(client, :message, {:item_id=>{:id=>"ghi", :change_key=>"jkl"}})]})
-        end
-      end
     end
   end
 end