New API method for updating request state

1 files changed, 357 insertions, 277 deletions

diff --git a/spec/controllers/api_controller_spec.rb b/spec/controllers/api_controller_spec.rb
index 6b02bd5b4..28ed5c387 100644
--- a/spec/controllers/api_controller_spec.rb
+++ b/spec/controllers/api_controller_spec.rb
@@ -32,7 +32,23 @@ describe ApiController, "when using the API" do
       end
     end
 
-    it "should create a new request from a POST" do
+    def _create_request
+      post :create_request,
+          :k => public_bodies(:geraldine_public_body).api_key,
+          :request_json => {
+              "title" => "Tell me about your chickens",
+              "body" => "Dear Sir,\n\nI should like to know about your chickens.\n\nYours in faith,\nBob\n",
+
+              "external_url" => "http://www.example.gov.uk/foi/chickens_23",
+              "external_user_name" => "Bob Smith",
+          }.to_json
+      response.content_type.should == "application/json"
+      return ActiveSupport::JSON.decode(response.body)["id"]
+  end
+
+    # POST /api/v2/request.json
+    describe 'creating a request' do
+      it "should create a new request from a POST" do
         number_of_requests = InfoRequest.count(
             :conditions => [
                     "public_body_id = ?",
@@ -75,311 +91,375 @@ describe ApiController, "when using the API" do
         new_request.info_request_events[0].event_type.should == 'sent'
         new_request.info_request_events[0].calculated_state.should == 'waiting_response'
     end
-
-    def _create_request
-        post :create_request,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :request_json => {
-                "title" => "Tell me about your chickens",
-                "body" => "Dear Sir,\n\nI should like to know about your chickens.\n\nYours in faith,\nBob\n",
-
-                "external_url" => "http://www.example.gov.uk/foi/chickens_23",
-                "external_user_name" => "Bob Smith",
-            }.to_json
-        response.content_type.should == "application/json"
-        return ActiveSupport::JSON.decode(response.body)["id"]
     end
 
-    it "should add a response to a request" do
-        # First we need an external request
-        request_id = info_requests(:external_request).id
-
-        # Initially it has no incoming messages
-        IncomingMessage.count(:conditions => ["info_request_id = ?", request_id]).should == 0
-
-        # Now add one
-        sent_at = "2012-05-28T12:35:39+01:00"
-        response_body = "Thank you for your request for information, which we are handling in accordance with the Freedom of Information Act 2000. You will receive a response within 20 working days or before the next full moon, whichever is sooner.\n\nYours sincerely,\nJohn Gandermulch,\nExample Council FOI Officer\n"
-        post :add_correspondence,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => request_id,
-            :correspondence_json => {
-                "direction" => "response",
-                "sent_at" => sent_at,
-                "body" => response_body
-            }.to_json
-
-        # And make sure it worked
-        response.should be_success
-        incoming_messages = IncomingMessage.all(:conditions => ["info_request_id = ?", request_id])
-        incoming_messages.count.should == 1
-        incoming_message = incoming_messages[0]
-
-        incoming_message.sent_at.should == Time.iso8601(sent_at)
-        incoming_message.get_main_body_text_folded.should be_equal_modulo_whitespace_to(response_body)
-    end
+    # POST /api/v2/request/:id/add_correspondence.json
+    describe 'adding correspondence to a request' do
+      it "should add a response to a request" do
+          # First we need an external request
+          request_id = info_requests(:external_request).id
+
+          # Initially it has no incoming messages
+          IncomingMessage.count(:conditions => ["info_request_id = ?", request_id]).should == 0
+
+          # Now add one
+          sent_at = "2012-05-28T12:35:39+01:00"
+          response_body = "Thank you for your request for information, which we are handling in accordance with the Freedom of Information Act 2000. You will receive a response within 20 working days or before the next full moon, whichever is sooner.\n\nYours sincerely,\nJohn Gandermulch,\nExample Council FOI Officer\n"
+          post :add_correspondence,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :correspondence_json => {
+                  "direction" => "response",
+                  "sent_at" => sent_at,
+                  "body" => response_body
+              }.to_json
+
+          # And make sure it worked
+          response.should be_success
+          incoming_messages = IncomingMessage.all(:conditions => ["info_request_id = ?", request_id])
+          incoming_messages.count.should == 1
+          incoming_message = incoming_messages[0]
+
+          incoming_message.sent_at.should == Time.iso8601(sent_at)
+          incoming_message.get_main_body_text_folded.should be_equal_modulo_whitespace_to(response_body)
+      end
 
-    it "should add a followup to a request" do
-        # First we need an external request
-        request_id = info_requests(:external_request).id
-
-        # Initially it has one outgoing message
-        OutgoingMessage.count(:conditions => ["info_request_id = ?", request_id]).should == 1
-
-        # Add another, as a followup
-        sent_at = "2012-05-29T12:35:39+01:00"
-        followup_body = "Pls answer ASAP.\nkthxbye\n"
-        post :add_correspondence,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => request_id,
-            :correspondence_json => {
-                "direction" => "request",
-                "sent_at" => sent_at,
-                "body" => followup_body
-            }.to_json
-
-        # Make sure it worked
-        response.should be_success
-        followup_messages = OutgoingMessage.all(
-            :conditions => ["info_request_id = ? and message_type = 'followup'", request_id]
-        )
-        followup_messages.size.should == 1
-        followup_message = followup_messages[0]
+      it "should add a followup to a request" do
+          # First we need an external request
+          request_id = info_requests(:external_request).id
+
+          # Initially it has one outgoing message
+          OutgoingMessage.count(:conditions => ["info_request_id = ?", request_id]).should == 1
+
+          # Add another, as a followup
+          sent_at = "2012-05-29T12:35:39+01:00"
+          followup_body = "Pls answer ASAP.\nkthxbye\n"
+          post :add_correspondence,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :correspondence_json => {
+                  "direction" => "request",
+                  "sent_at" => sent_at,
+                  "body" => followup_body
+              }.to_json
+
+          # Make sure it worked
+          response.should be_success
+          followup_messages = OutgoingMessage.all(
+              :conditions => ["info_request_id = ? and message_type = 'followup'", request_id]
+          )
+          followup_messages.size.should == 1
+          followup_message = followup_messages[0]
+
+          followup_message.last_sent_at.should == Time.iso8601(sent_at)
+          followup_message.body.should == followup_body.strip
+      end
 
-        followup_message.last_sent_at.should == Time.iso8601(sent_at)
-        followup_message.body.should == followup_body.strip
-    end
+      it "should not allow internal requests to be updated" do
+          n_incoming_messages = IncomingMessage.count
+          n_outgoing_messages = OutgoingMessage.count
+
+          request_id = info_requests(:naughty_chicken_request).id
+          post :add_correspondence,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :correspondence_json => {
+                  "direction" => "request",
+                  "sent_at" => Time.now.iso8601,
+                  "body" => "xxx"
+              }.to_json
+
+          response.status.should == 500
+          ActiveSupport::JSON.decode(response.body)["errors"].should == [
+            "Request #{request_id} cannot be updated using the API"]
+
+          IncomingMessage.count.should == n_incoming_messages
+          OutgoingMessage.count.should == n_outgoing_messages
+      end
 
-    it "should not allow internal requests to be updated" do
-        n_incoming_messages = IncomingMessage.count
-        n_outgoing_messages = OutgoingMessage.count
-
-        request_id = info_requests(:naughty_chicken_request).id
-        post :add_correspondence,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => request_id,
-            :correspondence_json => {
-                "direction" => "request",
-                "sent_at" => Time.now.iso8601,
-                "body" => "xxx"
-            }.to_json
-
-        response.status.should == 500
-        ActiveSupport::JSON.decode(response.body)["errors"].should == [
-          "Request #{request_id} cannot be updated using the API"]
-
-        IncomingMessage.count.should == n_incoming_messages
-        OutgoingMessage.count.should == n_outgoing_messages
-    end
+      it "should not allow other people's requests to be updated" do
+          request_id = _create_request
+          n_incoming_messages = IncomingMessage.count
+          n_outgoing_messages = OutgoingMessage.count
+
+          post :add_correspondence,
+              :k => public_bodies(:humpadink_public_body).api_key,
+              :id => request_id,
+              :correspondence_json => {
+                  "direction" => "request",
+                  "sent_at" => Time.now.iso8601,
+                  "body" => "xxx"
+              }.to_json
+
+          response.status.should == 500
+          ActiveSupport::JSON.decode(response.body)["errors"].should == [
+            "You do not own request #{request_id}"]
+
+          IncomingMessage.count.should == n_incoming_messages
+          OutgoingMessage.count.should == n_outgoing_messages
+      end
 
-    it "should not allow other people's requests to be updated" do
-        request_id = _create_request
-        n_incoming_messages = IncomingMessage.count
-        n_outgoing_messages = OutgoingMessage.count
-
-        post :add_correspondence,
-            :k => public_bodies(:humpadink_public_body).api_key,
-            :id => request_id,
-            :correspondence_json => {
-                "direction" => "request",
-                "sent_at" => Time.now.iso8601,
-                "body" => "xxx"
-            }.to_json
-
-        response.status.should == 500
-        ActiveSupport::JSON.decode(response.body)["errors"].should == [
-          "You do not own request #{request_id}"]
-
-        IncomingMessage.count.should == n_incoming_messages
-        OutgoingMessage.count.should == n_outgoing_messages
-    end
+      it "should return a JSON 404 error for non-existent requests" do
+          request_id = 123459876 # Let's hope this doesn't exist!
+          sent_at = "2012-05-28T12:35:39+01:00"
+          response_body = "Thank you for your request for information, which we are handling in accordance with the Freedom of Information Act 2000. You will receive a response within 20 working days or before the next full moon, whichever is sooner.\n\nYours sincerely,\nJohn Gandermulch,\nExample Council FOI Officer\n"
+          post :add_correspondence,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :correspondence_json => {
+                  "direction" => "response",
+                  "sent_at" => sent_at,
+                  "body" => response_body
+              }.to_json
+          response.status.should == 404
+          ActiveSupport::JSON.decode(response.body)["errors"].should == ["Could not find request 123459876"]
+      end
 
-    it "should not allow files to be attached to a followup" do
-        post :add_correspondence,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => info_requests(:external_request).id,
-            :correspondence_json => {
-                    "direction" => "request",
-                    "sent_at" => Time.now.iso8601,
-                    "body" => "Are you joking, or are you serious?"
-                }.to_json,
-            :attachments => [
-                fixture_file_upload("/files/tfl.pdf")
-            ]
+      it "should return a JSON 500 error if we try to add correspondence to a request we don't own" do
+          request_id = info_requests(:naughty_chicken_request).id
+          sent_at = "2012-05-28T12:35:39+01:00"
+          response_body = "Thank you for your request for information, which we are handling in accordance with the Freedom of Information Act 2000. You will receive a response within 20 working days or before the next full moon, whichever is sooner.\n\nYours sincerely,\nJohn Gandermulch,\nExample Council FOI Officer\n"
+          post :add_correspondence,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :correspondence_json => {
+                  "direction" => "response",
+                  "sent_at" => sent_at,
+                  "body" => response_body
+              }.to_json
+          response.status.should == 500
+          ActiveSupport::JSON.decode(response.body)["errors"].should == ["Request #{request_id} cannot be updated using the API"]
+      end
 
+      it "should not allow files to be attached to a followup" do
+          post :add_correspondence,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => info_requests(:external_request).id,
+              :correspondence_json => {
+                      "direction" => "request",
+                      "sent_at" => Time.now.iso8601,
+                      "body" => "Are you joking, or are you serious?"
+                  }.to_json,
+              :attachments => [
+                  fixture_file_upload("/files/tfl.pdf")
+              ]
+
+          # Make sure it worked
+          response.status.should == 500
+          errors = ActiveSupport::JSON.decode(response.body)["errors"]
+          errors.should == ["You cannot attach files to messages in the 'request' direction"]
+      end
 
-        # Make sure it worked
-        response.status.should == 500
-        errors = ActiveSupport::JSON.decode(response.body)["errors"]
-        errors.should == ["You cannot attach files to messages in the 'request' direction"]
+      it "should allow files to be attached to a response" do
+          # First we need an external request
+          request_id = info_requests(:external_request).id
+
+          # Initially it has no incoming messages
+          IncomingMessage.count(:conditions => ["info_request_id = ?", request_id]).should == 0
+
+          # Now add one
+          sent_at = "2012-05-28T12:35:39+01:00"
+          response_body = "Thank you for your request for information, which we are handling in accordance with the Freedom of Information Act 2000. You will receive a response within 20 working days or before the next full moon, whichever is sooner.\n\nYours sincerely,\nJohn Gandermulch,\nExample Council FOI Officer\n"
+          post :add_correspondence,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :correspondence_json => {
+                      "direction" => "response",
+                      "sent_at" => sent_at,
+                      "body" => response_body
+                  }.to_json,
+              :attachments => [
+                  fixture_file_upload("/files/tfl.pdf")
+              ]
+
+          # And make sure it worked
+          response.should be_success
+          incoming_messages = IncomingMessage.all(:conditions => ["info_request_id = ?", request_id])
+          incoming_messages.count.should == 1
+          incoming_message = incoming_messages[0]
+
+          incoming_message.sent_at.should == Time.iso8601(sent_at)
+          incoming_message.get_main_body_text_folded.should be_equal_modulo_whitespace_to(response_body)
+
+          # Get the attachment
+          attachments = incoming_message.get_attachments_for_display
+          attachments.size.should == 1
+          attachment = attachments[0]
+          attachment.filename.should == "tfl.pdf"
+          attachment.body.should == load_file_fixture("tfl.pdf")
+      end
     end
 
-    it "should allow files to be attached to a response" do
-        # First we need an external request
-        request_id = info_requests(:external_request).id
-
-        # Initially it has no incoming messages
-        IncomingMessage.count(:conditions => ["info_request_id = ?", request_id]).should == 0
-
-        # Now add one
-        sent_at = "2012-05-28T12:35:39+01:00"
-        response_body = "Thank you for your request for information, which we are handling in accordance with the Freedom of Information Act 2000. You will receive a response within 20 working days or before the next full moon, whichever is sooner.\n\nYours sincerely,\nJohn Gandermulch,\nExample Council FOI Officer\n"
-        post :add_correspondence,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => request_id,
-            :correspondence_json => {
-                    "direction" => "response",
-                    "sent_at" => sent_at,
-                    "body" => response_body
-                }.to_json,
-            :attachments => [
-                fixture_file_upload("/files/tfl.pdf")
-            ]
+    # POST /api/v2/request/:id/update.json
+    describe "updating a request's status" do
+        it "should update the status" do
+            # First we need an external request
+            request_id = info_requests(:external_request).id
+            request = InfoRequest.find_by_id(request_id)
+
+            # Its status should be the default for a new request
+            request.described_state.should == 'waiting_response'
+
+            # Now accept an update
+            post :update_state,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :state => "not_held"
+
+            # It should have updated the status
+            request = InfoRequest.find_by_id(request_id)
+            request.described_state.should == "not_held"
+        end
 
-        # And make sure it worked
-        response.should be_success
-        incoming_messages = IncomingMessage.all(:conditions => ["info_request_id = ?", request_id])
-        incoming_messages.count.should == 1
-        incoming_message = incoming_messages[0]
-
-        incoming_message.sent_at.should == Time.iso8601(sent_at)
-        incoming_message.get_main_body_text_folded.should be_equal_modulo_whitespace_to(response_body)
-
-        # Get the attachment
-        attachments = incoming_message.get_attachments_for_display
-        attachments.size.should == 1
-        attachment = attachments[0]
-        attachment.filename.should == "tfl.pdf"
-        attachment.body.should == load_file_fixture("tfl.pdf")
-    end
+        it "should return a JSON 500 error if an invalid state is sent" do
+            # First we need an external request
+            request_id = info_requests(:external_request).id
+            request = InfoRequest.find_by_id(request_id)
 
-    it "should show information about a request" do
-        info_request = info_requests(:naughty_chicken_request)
-        get :show_request,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => info_request.id
+            # Its status should be the default for a new request
+            request.described_state.should == 'waiting_response'
 
-        response.should be_success
-        assigns[:request].id.should == info_request.id
-
-        r = ActiveSupport::JSON.decode(response.body)
-        r["title"].should == info_request.title
-        # Let’s not test all the fields here, because it would
-        # essentially just be a matter of copying the code that
-        # assigns them and changing assignment to an equality
-        # check, which does not really test anything at all.
-    end
+            # Now post an invalid update
+            post :update_state,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :state => "random_string"
 
-    it 'should show information about an external request' do
-        info_request = info_requests(:external_request)
-        get :show_request,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => info_request.id
+            # Check that the error has been raised...
+            response.status.should == 500
+            ActiveSupport::JSON.decode(response.body)["errors"].should == ["'random_string' is not a valid request state"]
 
-        response.should be_success
-        assigns[:request].id.should == info_request.id
-        r = ActiveSupport::JSON.decode(response.body)
-        r["title"].should == info_request.title
-    end
+            # ..and that the status hasn't been updated
+            request = InfoRequest.find_by_id(request_id)
+            request.described_state.should == "waiting_response"
+        end
 
-    it "should show an Atom feed of new request events" do
-        get :body_request_events,
-            :id => public_bodies(:geraldine_public_body).id,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :feed_type => "atom"
+        it "should return a JSON 404 error for non-existent requests" do
+            request_id = 123459876 # Let's hope this doesn't exist!
 
-        response.should be_success
-        response.should render_template("api/request_events")
-        assigns[:events].size.should > 0
-        assigns[:events].each do |event|
-            event.info_request.public_body.should == public_bodies(:geraldine_public_body)
-            event.outgoing_message.should_not be_nil
-            event.event_type.should satisfy {|x| ['sent', 'followup_sent', 'resent', 'followup_resent'].include?(x)}
+            post :update_state,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :state => "successful"
+
+            response.status.should == 404
+            ActiveSupport::JSON.decode(response.body)["errors"].should == ["Could not find request 123459876"]
         end
-    end
 
-    it "should show a JSON feed of new request events" do
-        get :body_request_events,
-            :id => public_bodies(:geraldine_public_body).id,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :feed_type => "json"
+        it "should return a JSON 500 error if we try to add correspondence to a request we don't own" do
+            request_id = info_requests(:naughty_chicken_request).id
 
-        response.should be_success
-        assigns[:events].size.should > 0
-        assigns[:events].each do |event|
-            event.info_request.public_body.should == public_bodies(:geraldine_public_body)
-            event.outgoing_message.should_not be_nil
-            event.event_type.should satisfy {|x| ['sent', 'followup_sent', 'resent', 'followup_resent'].include?(x)}
-        end
+            post :update_state,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => request_id,
+              :state => "successful"
 
-        assigns[:event_data].size.should == assigns[:events].size
-        assigns[:event_data].each do |event_record|
-            event_record[:event_type].should satisfy {|x| ['sent', 'followup_sent', 'resent', 'followup_resent'].include?(x)}
+            response.status.should == 500
+            ActiveSupport::JSON.decode(response.body)["errors"].should == ["Request #{request_id} cannot be updated using the API"]
         end
     end
 
-    it "should honour the since_event_id parameter" do
-        get :body_request_events,
-            :id => public_bodies(:geraldine_public_body).id,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :feed_type => "json"
-        response.should be_success
-        first_event = assigns[:event_data][0]
-        second_event_id = assigns[:event_data][1][:event_id]
-
-        get :body_request_events,
-            :id => public_bodies(:geraldine_public_body).id,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :feed_type => "json",
-            :since_event_id => second_event_id
-        response.should be_success
-        assigns[:event_data].should == [first_event]
-    end
+    # GET /api/v2/request/:id.json
+    describe "showing request info" do
+      it "should show information about a request" do
+          info_request = info_requests(:naughty_chicken_request)
+          get :show_request,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => info_request.id
+
+          response.should be_success
+          assigns[:request].id.should == info_request.id
+
+          r = ActiveSupport::JSON.decode(response.body)
+          r["title"].should == info_request.title
+          # Let’s not test all the fields here, because it would
+          # essentially just be a matter of copying the code that
+          # assigns them and changing assignment to an equality
+          # check, which does not really test anything at all.
+      end
 
-    it "should honour the since_date parameter for the Atom feed" do
-        get :body_request_events,
-            :id => public_bodies(:humpadink_public_body).id,
-            :k => public_bodies(:humpadink_public_body).api_key,
-            :since_date => "2010-01-01",
-            :feed_type => "atom"
+      it 'should show information about an external request' do
+          info_request = info_requests(:external_request)
+          get :show_request,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :id => info_request.id
 
-        response.should be_success
-        response.should render_template("api/request_events")
-        assigns[:events].size.should > 0
-        assigns[:events].each do |event|
-            event.created_at.should >= Date.new(2010, 1, 1)
-        end
+          response.should be_success
+          assigns[:request].id.should == info_request.id
+          r = ActiveSupport::JSON.decode(response.body)
+          r["title"].should == info_request.title
+      end
     end
 
-    it "should return a JSON 404 error for non-existent requests" do
-        request_id = 123459876 # Let's hope this doesn't exist!
-        sent_at = "2012-05-28T12:35:39+01:00"
-        response_body = "Thank you for your request for information, which we are handling in accordance with the Freedom of Information Act 2000. You will receive a response within 20 working days or before the next full moon, whichever is sooner.\n\nYours sincerely,\nJohn Gandermulch,\nExample Council FOI Officer\n"
-        post :add_correspondence,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => request_id,
-            :correspondence_json => {
-                "direction" => "response",
-                "sent_at" => sent_at,
-                "body" => response_body
-            }.to_json
-        response.status.should == 404
-        ActiveSupport::JSON.decode(response.body)["errors"].should == ["Could not find request 123459876"]
-    end
+    # GET /api/v2/body/:id/request_events.:feed_type
+    describe "showing public body info" do
+      it "should show an Atom feed of new request events" do
+          get :body_request_events,
+              :id => public_bodies(:geraldine_public_body).id,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :feed_type => "atom"
+
+          response.should be_success
+          response.should render_template("api/request_events")
+          assigns[:events].size.should > 0
+          assigns[:events].each do |event|
+              event.info_request.public_body.should == public_bodies(:geraldine_public_body)
+              event.outgoing_message.should_not be_nil
+              event.event_type.should satisfy {|x| ['sent', 'followup_sent', 'resent', 'followup_resent'].include?(x)}
+          end
+      end
+
+      it "should show a JSON feed of new request events" do
+          get :body_request_events,
+              :id => public_bodies(:geraldine_public_body).id,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :feed_type => "json"
+
+          response.should be_success
+          assigns[:events].size.should > 0
+          assigns[:events].each do |event|
+              event.info_request.public_body.should == public_bodies(:geraldine_public_body)
+              event.outgoing_message.should_not be_nil
+              event.event_type.should satisfy {|x| ['sent', 'followup_sent', 'resent', 'followup_resent'].include?(x)}
+          end
+
+          assigns[:event_data].size.should == assigns[:events].size
+          assigns[:event_data].each do |event_record|
+              event_record[:event_type].should satisfy {|x| ['sent', 'followup_sent', 'resent', 'followup_resent'].include?(x)}
+          end
+      end
 
-    it "should return a JSON 500 error if we try to add correspondence to a request we don't own" do
-        request_id = info_requests(:naughty_chicken_request).id
-        sent_at = "2012-05-28T12:35:39+01:00"
-        response_body = "Thank you for your request for information, which we are handling in accordance with the Freedom of Information Act 2000. You will receive a response within 20 working days or before the next full moon, whichever is sooner.\n\nYours sincerely,\nJohn Gandermulch,\nExample Council FOI Officer\n"
-        post :add_correspondence,
-            :k => public_bodies(:geraldine_public_body).api_key,
-            :id => request_id,
-            :correspondence_json => {
-                "direction" => "response",
-                "sent_at" => sent_at,
-                "body" => response_body
-            }.to_json
-        response.status.should == 500
-        ActiveSupport::JSON.decode(response.body)["errors"].should == ["Request #{request_id} cannot be updated using the API"]
+      it "should honour the since_event_id parameter" do
+          get :body_request_events,
+              :id => public_bodies(:geraldine_public_body).id,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :feed_type => "json"
+          response.should be_success
+          first_event = assigns[:event_data][0]
+          second_event_id = assigns[:event_data][1][:event_id]
+
+          get :body_request_events,
+              :id => public_bodies(:geraldine_public_body).id,
+              :k => public_bodies(:geraldine_public_body).api_key,
+              :feed_type => "json",
+              :since_event_id => second_event_id
+          response.should be_success
+          assigns[:event_data].should == [first_event]
+      end
+
+      it "should honour the since_date parameter for the Atom feed" do
+          get :body_request_events,
+              :id => public_bodies(:humpadink_public_body).id,
+              :k => public_bodies(:humpadink_public_body).api_key,
+              :since_date => "2010-01-01",
+              :feed_type => "atom"
+
+          response.should be_success
+          response.should render_template("api/request_events")
+          assigns[:events].size.should > 0
+          assigns[:events].each do |event|
+              event.created_at.should >= Date.new(2010, 1, 1)
+          end
+      end
     end
 end