rews 0.1.0 → 0.2.0

data/lib/rews.rb

@@ -19,37 +19,5 @@ require 'rews/sort_order'
 require 'rews/view'
 require 'rews/folder'
 require 'rews/item'
+require 'rews/client'
 
-module Rews
-  class Client
-    attr_reader :client
-    attr_accessor :logdev
-
-    # Rews::Client.new('https://exchange.foo.com/EWS/Exchange.asmx', :ntlm, 'DOMAIN\\user', 'password')
-    # Rews::Client.new('https://exchange.foo.com/EWS/Exchange.asmx', :basic, 'DOMAIN\\user', 'password')
-    def initialize(endpoint, auth_type, user, password)
-      @client = Savon::Client.new do
-        wsdl.endpoint = endpoint
-        wsdl.namespace = SCHEMA_MESSAGES
-        
-        http.auth.ssl.verify_mode = :none
-        http.auth.send(auth_type, user, password)
-      end
-    end
-
-    # client.distinguished_folder_id('inbox')
-    # client.distinguished_folder_id('inbox', 'foo@bar.com') # to get a folder from another mailbox
-    def distinguished_folder_id(id, mailbox_email=nil)
-      Folder::DistinguishedFolderId.new(client, id, mailbox_email)
-    end
-
-    def log
-      yield logger if @logdev
-    end
-
-    def logger
-      return @logger if @logger
-      @logger = Logger.new(@logdev) if @logdev
-    end
-  end
-end

data/spec/request_proxy.rb

@@ -0,0 +1,18 @@
+# a stand-in for a Savon Client, which does instance_eval with delegation
+# like the Savon Client
+class RequestProxy
+  attr_accessor :soap
+  def initialize
+    @soap=Object.new
+  end
+
+  def eval_with_delegation(&block)
+    @self_before_instance_eval = eval "self", block.binding
+    instance_eval &block
+  end
+
+  def method_missing(method, *args, &block)
+    @self_before_instance_eval.send method, *args, &block
+  end
+end
+

data/spec/rews/client_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rews
+  describe Client do
+    it "should create new DistinguishedFolderIds for arbitrary mailboxes" do
+      client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+
+      mock(Folder::DistinguishedFolderId).new(client.client, 'inbox', 'foo@bar.com')
+
+      client.distinguished_folder_id('inbox', 'foo@bar.com')
+    end
+
+    it "should create new DistinguishedFolderIds for the default mailbox" do
+      client = Client.new("https://foo/EWS/Exchange.asmx", :ntlm, "EXCHDOM\\foo", "password")
+
+      mock(Folder::DistinguishedFolderId).new(client.client, 'inbox', nil)
+
+      client.distinguished_folder_id('inbox')
+    end
+  end
+end

data/spec/rews/folder_spec.rb

@@ -0,0 +1,402 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rews
+  describe Folder do
+    describe Folder::Folder do
+      it "should parse the folder_id and attributes from the XML hash" do
+        client = Object.new
+
+        i = Folder::Folder.new(client, {:folder_id=>{:id=>"abc", :change_key=>'def'}, :foo=>100})
+        i.client.should == client
+        i.folder_id.should == Folder::VanillaFolderId.new(client, {:id=>'abc', :change_key=>"def"})
+        i[:foo].should == 100
+      end
+    end
+
+    describe Folder::DistinguishedFolderId do
+      it "should generate DistinguishedFolderId xml for the default mailbox" do
+        client = Object.new
+        xml = Folder::DistinguishedFolderId.new(client, 'inbox').to_xml
+        doc = Nokogiri::XML(xml)
+        dfid=doc.children.first
+        dfid.name.should == "DistinguishedFolderId"
+        dfid[:Id].should == 'inbox'
+        dfid.children.size.should == 0
+      end
+
+      it "should generate DistinguishedFolderId xml for a specified mailbox" do
+        client = Object.new
+        xml = Folder::DistinguishedFolderId.new(client, 'inbox', 'foo@bar.com').to_xml
+        doc = Nokogiri::XML(xml)
+        dfid=doc.children.first
+        dfid.name.should == "DistinguishedFolderId"
+        dfid[:Id].should == 'inbox'
+        dfid.children.size.should == 1
+
+        mb = dfid.children.first
+        mb.name.should == "Mailbox"
+        mb.children.size.should == 1
+
+        ea = mb.children.first
+        ea.name.should == "EmailAddress"
+        ea.content.should == 'foo@bar.com'
+        ea.children.size.should == 1 # the content
+      end
+    end
+
+    describe Folder::VanillaFolderId do
+      it "should generate FolderId xml with a change_key" do
+        client = Object.new
+        xml = Folder::VanillaFolderId.new(client, {:id=>"abc", :change_key=>"def"}).to_xml
+        doc = Nokogiri::XML(xml)
+        fid=doc.children.first
+        fid.name.should=="FolderId"
+        fid[:Id].should == "abc"
+        fid[:ChangeKey].should == "def"
+      end
+
+      it "should generate FolderId without a change_key" do
+        client = Object.new
+        xml = Folder::VanillaFolderId.new(client, {:id=>"abc"}).to_xml
+        doc = Nokogiri::XML(xml)
+        fid=doc.children.first
+        fid.name.should=="FolderId"
+        fid[:Id].should == "abc"
+        fid[:ChangeKey].should == nil
+      end
+    end
+
+    describe Folder::BaseFolderId do
+      def mock_request(client, action, attrs, response)
+        # deal with different call arity
+        mock(client).request(*[:wsdl, action, attrs].compact) do |*args|
+          block = args.last # block is the last arg
+
+          ctx = RequestProxy.new()
+          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
+          mock(Shape::FolderShape).new(folder_shape||{}){shape}
+          mock(shape).to_xml{""}
+
+          if indexed_page_folder_view
+            view = Object.new
+            mock(View::IndexedPageFolderView).new(indexed_page_folder_view){view}
+            mock(view).to_xml{""}
+          end
+
+          if restriction
+            r = Object.new
+            mock(Restriction).new(restriction){r}
+            mock(r).to_xml{""}
+          end
+
+          fid = Folder::DistinguishedFolderId.new(client, 'blah')
+          mock.proxy(fid).to_xml
+
+          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)
+
+          opts = {}
+          opts[:folder_shape] = folder_shape if folder_shape
+          opts[:indexed_page_folder_view] = indexed_page_folder_view if indexed_page_folder_view
+          opts[:restriction] = restriction if restriction
+          fid.find_folder(opts)
+        end
+
+        it "should generate minimal xml and parse a response with one folder" do
+          client = Object.new
+          folders = test_find_folder(client,
+                                     {:base_shape=>:IdOnly},
+                                     nil,
+                                     nil,
+                                     {:includes_last_item_in_range=>false,
+                                       :indexed_paging_offset=>0,
+                                       :total_items_in_view=>1,
+                                       :folders=>{:folder=>{:folder_id=>{:id=>"abc", :change_key=>"def"}}}})
+          folders.includes_last_item_in_range.should == false
+          folders.indexed_paging_offset.should == 0
+          folders.total_items_in_view.should == 1
+          folders.result.first.should == Folder::Folder.new(client, :folder_id=>{:id=>"abc", :change_key=>"def"})
+          
+        end
+
+        it "should generate xml with indexed_page_folder_view and parse a response with multiple folders" do
+          client = Object.new
+          folders = test_find_folder(client,
+                                     {:base_shape=>:Default},
+                                     {:max_entries_returned=>10, :offset=>10, :base_point=>:Beginning},
+                                     [[:== , "item:DateTimeReceived", DateTime.now]],
+                                     {:includes_last_item_in_range=>true,
+                                       :indexed_paging_offset=>10,
+                                       :total_items_in_view=>5,
+                                       :folders=>{:folder=>[{:folder_id=>{:id=>"abc", :change_key=>"def"}},
+                                                            {:folder_id=>{:id=>"ghi", :change_key=>"jkl"}}]}})
+          folders.includes_last_item_in_range.should == true
+          folders.indexed_paging_offset.should == 10
+          folders.total_items_in_view.should == 5
+          folders.result.first.should == Folder::Folder.new(client, :folder_id=>{:id=>"abc", :change_key=>"def"})
+          folders.result[1].should == Folder::Folder.new(client, :folder_id=>{:id=>"ghi", :change_key=>"jkl"})
+        end
+      end
+
+      describe "find_folder_id" do
+        it "should call find_folder with a default BaseShape of IdOnly" do
+          client=Object.new
+
+          fid = Folder::DistinguishedFolderId.new(client, 'blah')
+          
+          opts = {:indexed_page_folder_view=>{:max_entries_returned=>10, :offset=>10, :base_point=>:Beginning},
+            :restriction=>[[:==, "item:DateTimeReceived", DateTime.now]]}
+          mock(fid).find_folder(opts){Folder::FindResult.new(:includes_last_item_in_range=>true, :indexed_paging_offset=>10, :total_items_in_view=>3){[Folder::Folder.new(client, {:folder_id=>{:id=>"abc", :change_key=>"def"}})]}}
+          
+          fres = fid.find_folder_id(opts)
+          fres.includes_last_item_in_range.should == true
+          fres.indexed_paging_offset.should == 10
+          fres.total_items_in_view.should == 3
+        end
+      end
+
+      def test_find_item(client, item_shape, indexed_page_item_view, restriction, result)
+        shape = Object.new
+        mock(Shape::ItemShape).new(item_shape||{}){shape}
+        mock(shape).to_xml{""}
+
+        if indexed_page_item_view
+          view = Object.new
+          mock(View::IndexedPageItemView).new(indexed_page_item_view){view}
+          mock(view).to_xml{""}
+        end
+
+        if restriction
+          r = Object.new
+          mock(Restriction).new(restriction){r}
+          mock(r).to_xml{""}
+        end
+
+        fid = Folder::DistinguishedFolderId.new(client, 'blah')
+        mock.proxy(fid).to_xml
+
+        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)
+
+        opts = {}
+        opts[:item_shape] = item_shape if item_shape
+        opts[:indexed_page_item_view] = indexed_page_item_view if indexed_page_item_view
+        opts[:restriction] = restriction if restriction
+        fid.find_item(opts)
+      end
+      
+      describe "find_item" do
+        it "should generate minimal xml and parse a response with one item" do
+          client = Object.new
+          items = test_find_item(client,
+                                 {:base_shape=>:IdOnly},
+                                 nil,
+                                 nil,
+                                 {:includes_last_item_in_range=>false,
+                                   :indexed_paging_offset=>0,
+                                   :total_items_in_view=>1,
+                                   :items=>{:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}}})
+          items.includes_last_item_in_range.should == false
+          items.indexed_paging_offset.should == 0
+          items.total_items_in_view.should == 1
+          items.result.size.should == 1
+          items.result.first.should == Item::Item.new(client, :message, :item_id=>{:id=>"abc", :change_key=>"def"})
+        end
+
+        it "should generate xml with indexed_page_folder_view and parse a response with multiple folders" do
+          client = Object.new
+          items = test_find_item(client,
+                                 {:base_shape=>:IdOnly},
+                                 {:max_entries_returned=>10, :offset=>10, :base_point=>:Beginning},
+                                 [[:== , "item:DateTimeReceived", DateTime.now]],
+                                 {:includes_last_item_in_range=>false,
+                                   :indexed_paging_offset=>0,
+                                   :total_items_in_view=>1,
+                                   :items=>{:message=>[{:item_id=>{:id=>"abc", :change_key=>"def"}},
+                                                       {:item_id=>{:id=>"ghi", :change_key=>"jkl"}}]}})
+          items.includes_last_item_in_range.should == false
+          items.indexed_paging_offset.should == 0
+          items.total_items_in_view.should == 1
+          items.result.size.should == 2
+          items.result.first.should == Item::Item.new(client, :message, :item_id=>{:id=>"abc", :change_key=>"def"})
+          items.result[1].should == Item::Item.new(client, :message, :item_id=>{:id=>"ghi", :change_key=>"jkl"})
+        end
+      end
+
+      describe "find_item_id" do
+        it "should call find_folder with a default BaseShape of IdOnly" do
+          client=Object.new
+
+          fid = Folder::DistinguishedFolderId.new(client, 'blah')
+          
+          opts = {
+            :indexed_page_item_view=>{:max_entries_returned=>10, :offset=>10, :base_point=>:Beginning}
+          }
+
+          mock(fid).find_item(opts.merge(:item_shape=>{:base_shape=>:IdOnly})) do
+            Folder::FindResult.new(:includes_last_item_in_range=>false, 
+                                   :indexed_paging_offset=>10, 
+                                   :total_items_in_view=>10) do
+              [Item::Item.new(client, :message, {:item_id=>{:id=>"abc", :change_key=>"def"}})]
+            end
+          end
+          
+          res = fid.find_item_id(opts)
+          res.includes_last_item_in_range.should == false
+          res.indexed_paging_offset.should == 10
+          res.total_items_in_view.should == 10
+        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

data/spec/rews/item_spec.rb

@@ -0,0 +1,124 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rews
+  describe Item do
+    describe Item::Item do
+      it "should parse the item_id and attributes from the XML hash" do
+        client = Object.new
+
+        i = Item::Item.new(client, 'Message', {:item_id=>{:id=>'1234', :change_key=>'abcd'}, :foo=>100})
+
+        i.client.should == client
+        i.item_class.should == 'Message'
+        i.item_id.should == Item::ItemId.new(client, {:id=>'1234', :change_key=>'abcd'})
+
+        i[:foo].should == 100
+      end
+    end
+
+    describe Item::ItemId do
+
+      describe "to_xml" do
+        it "should generate an ItemId with change_key by default" do
+          client = Object.new
+          xml = Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"}).to_xml
+          doc = Nokogiri::XML(xml)
+          id=doc.children.first
+          id.name.should == "ItemId"
+          id[:Id].should == "abc"
+          id[:ChangeKey].should == "def"
+        end
+
+        it "should generate an ItemId without change_key if requested" do
+          client = Object.new
+          xml = Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"}).to_xml(true)
+          doc = Nokogiri::XML(xml)
+          id=doc.children.first
+          id.name.should == "ItemId"
+          id[:Id].should == "abc"
+          id[:ChangeKey].should == nil
+        end
+      end
+
+      def mock_request(client, action, attrs, response)
+        # deal with different call arity
+        mock(client).request(*[:wsdl, action, attrs].compact) do |*args|
+          block = args.last # block is the last arg
+
+          ctx = RequestProxy.new()
+          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 "get_item" do
+        def test_get_item(client, item_shape, ignore_change_keys, result)
+          shape = Object.new
+          mock(Shape::ItemShape).new(item_shape||{}){shape}
+          mock(shape).to_xml{""}
+
+          iid = Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"})
+          mock.proxy(iid).to_xml(ignore_change_keys){""}
+
+          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
+          iid.get_item(opts)
+        end
+
+        it "should generate the BaseShape and ItemId xml and parse the response" do
+          client = Object.new
+          msg = test_get_item(client,
+                              {:base_shape=>:IdOnly}, 
+                              nil, 
+                              {:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}})
+          msg.item_class.should == :message
+          msg.item_id.should == Item::ItemId.new(client, :id=>"abc", :change_key=>"def")
+        end
+
+        it "should generate a request with no change_key if specified" do
+          client = Object.new
+          msg = test_get_item(client,
+                              {:base_shape=>:Default}, 
+                              true, 
+                              {:message=>{:item_id=>{:id=>"abc", :change_key=>"def"}}})
+          msg.item_class.should == :message
+          msg.item_id.should == Item::ItemId.new(client, :id=>"abc", :change_key=>"def")
+        end
+
+      end
+
+      describe "delete_item" do
+        def test_delete_item(client, ignore_change_keys, delete_type)
+          iid = Item::ItemId.new(client, {:id=>"abc", :change_key=>"def"})
+          mock.proxy(iid).to_xml(ignore_change_keys){""}
+
+          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[:ignore_change_keys]=ignore_change_keys if ignore_change_keys
+          opts[:delete_type] = delete_type
+          iid.delete_item(opts)
+        end
+
+        it "should generate the ItemId xml and parse the response" do
+          client = Object.new
+          msg = test_delete_item(client, true, :HardDelete)
+        end
+      end
+    end
+  end
+end

data/spec/rews/restriction_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Rews
+  describe Restriction do
+    it "should write Restriction xml" do
+      xml = Restriction.new([:and,
+                             [:<= , "item:DateTimeReceived", DateTime.parse("2011-03-14T17:02:17+00:00")],
+                             [:> , "item:DateTimeReceived", DateTime.parse("2010-03-14T17:02:17+00:00")]]).to_xml
+
+      doc = Nokogiri::XML(xml)
+      r = doc.children.first
+      r.name.should == "Restriction"
+      r.children.size.should == 1
+      
+      join = r.children.first
+      join.name.should == "And"
+      join.children.size.should == 2
+
+      le = join.children.first
+      le.name.should == "IsLessThanOrEqualTo"
+      le.children.size.should == 2
+      
+      furi = le.children.first
+      furi.name.should == "FieldURI"
+      furi[:FieldURI].should == "item:DateTimeReceived"
+
+      foc = le.children[1]
+      foc.name.should == "FieldURIOrConstant"
+      foc.children.size.should == 1
+
+      furi2 = foc.children.first
+      furi2.name.should == "Constant"
+      furi2[:Value].should == DateTime.parse("2011-03-14T17:02:17+00:00").to_s
+      
+
+      gt = join.children[1]
+      gt.name.should == "IsGreaterThan"
+      gt.children.size.should == 2
+
+      furi3 = gt.children.first
+      furi3.name.should == "FieldURI"
+      furi3[:FieldURI].should == "item:DateTimeReceived"
+
+      foc2 = gt.children[1]
+      foc2.name.should == "FieldURIOrConstant"
+      foc2.children.size.should == 1
+
+      furi4 = foc2.children.first
+      furi4.name.should == "Constant"
+      furi4[:Value].should == DateTime.parse("2010-03-14T17:02:17+00:00").to_s
+    end
+  end
+end