v3: Audit events support multiple relational operators

Previously, we would ignore any operators except for the first one in
the list of parameters. Now, we support requests like:

`GET /v3/audit_events?created_ats[lt]=2020-01-02T00:00:00Z&created_ats[gt]=2019-12-31T23:59:59Z`

This request returns all audit events that occurred on New Year's Day.

[finishes #173575979]

Co-authored-by: Brian Cunnie <bcunnie@pivotal.io>
Co-authored-by: Reid Mitchell <rmitchell@pivotal.io>

Author: Brian Cunnie

app/fetchers/event_list_fetcher.rb

@@ -30,21 +30,20 @@ def filter(message, dataset)
 
         if message.requested?(:created_ats)
           if message.created_ats.is_a?(Hash)
-            operator = message.created_ats.keys[0]
-            given_timestamp = message.created_ats.values[0]
-
-            if operator == Event::LESS_THAN_COMPARATOR
-              normalized_timestamp = Time.parse(given_timestamp).utc
-              dataset = dataset.where(Sequel.lit('created_at < ?', normalized_timestamp))
-            elsif operator == Event::LESS_THAN_OR_EQUAL_COMPARATOR
-              normalized_timestamp = (Time.parse(given_timestamp).utc + 0.999999).utc
-              dataset = dataset.where(Sequel.lit('created_at <= ?', normalized_timestamp))
-            elsif operator == Event::GREATER_THAN_COMPARATOR
-              normalized_timestamp = (Time.parse(given_timestamp).utc + 0.999999).utc
-              dataset = dataset.where(Sequel.lit('created_at > ?', normalized_timestamp))
-            elsif operator == Event::GREATER_THAN_OR_EQUAL_COMPARATOR
-              normalized_timestamp = Time.parse(given_timestamp).utc
-              dataset = dataset.where(Sequel.lit('created_at >= ?', normalized_timestamp))
+            message.created_ats.map do |operator, given_timestamp|
+              if operator == Event::LESS_THAN_COMPARATOR
+                normalized_timestamp = Time.parse(given_timestamp).utc
+                dataset = dataset.where(Sequel.lit('created_at < ?', normalized_timestamp))
+              elsif operator == Event::LESS_THAN_OR_EQUAL_COMPARATOR
+                normalized_timestamp = (Time.parse(given_timestamp).utc + 0.999999).utc
+                dataset = dataset.where(Sequel.lit('created_at <= ?', normalized_timestamp))
+              elsif operator == Event::GREATER_THAN_COMPARATOR
+                normalized_timestamp = (Time.parse(given_timestamp).utc + 0.999999).utc
+                dataset = dataset.where(Sequel.lit('created_at > ?', normalized_timestamp))
+              elsif operator == Event::GREATER_THAN_OR_EQUAL_COMPARATOR
+                normalized_timestamp = Time.parse(given_timestamp).utc
+                dataset = dataset.where(Sequel.lit('created_at >= ?', normalized_timestamp))
+              end
             end
           else
             # Gotcha: unlike the other relational operators, which are hashes such as

docs/v3/source/includes/concepts/_filters.md.erb

@@ -53,6 +53,10 @@ the `created_at` field, using the `created_ats` filter.
 For example, a response to `/v3/audit_events?created_ats[lt]=2020-06-30T12:34:56Z` will contain
 audit events with a `created_at` timestamp strictly earlier than `2020-06-30T12:34:56Z`.
 
+Multiple relational operators can be combined to further refine the listed resources. For example, a
+response to `/v3/audit_events?created_ats[lt]=2020-01-02T00:00:00Z&created_ats[gt]=2019-12-31T23:59:59Z`
+will return all audit events occurring on New Year's Day.
+
 Timestamps must be in [standard timestamp format](#timestamps).
 
 ##### Valid inequality operators

spec/request/events_spec.rb

@@ -307,6 +307,94 @@
           )
         end
       end
+      context 'using greater than or equal to' do
+        let!(:extra_event) { VCAP::CloudController::Event.make(created_at: timestamp, organization_guid: org.guid, type: 'audit.organization.create') }
+
+        let(:extra_event_json) do
+          {
+            guid: extra_event.guid,
+            created_at: iso8601,
+            updated_at: iso8601,
+            type: 'audit.organization.create',
+            actor: {
+              guid: extra_event.actor,
+              type: extra_event.actor_type,
+              name: extra_event.actor_name
+            },
+            target: {
+              guid: extra_event.actee,
+              type: extra_event.actee_type,
+              name: extra_event.actee_name
+            },
+            data: {},
+            space: nil,
+            organization: {
+              guid: org.guid
+            },
+            links: {
+              self: {
+                href: "#{link_prefix}/v3/audit_events/#{extra_event.guid}"
+              }
+            }
+          }
+        end
+
+        it 'returns events at or after the given timestamp' do
+          get "/v3/audit_events?created_ats[gte]=#{timestamp}", nil, admin_header
+
+          expect(
+            resources: parsed_response['resources']
+          ).to match_json_response(
+            resources: [org_scoped_event_json, extra_event_json]
+          )
+        end
+      end
+
+      context 'using greater than and less than, together' do
+        let!(:event_1) { VCAP::CloudController::Event.make(guid: '1', created_at: '2020-05-26T18:47:01Z') }
+        let!(:event_2) { VCAP::CloudController::Event.make(guid: '2', created_at: '2020-05-26T18:47:02Z') }
+        let!(:event_3) { VCAP::CloudController::Event.make(guid: '3', created_at: '2020-05-26T18:47:03Z') }
+        let!(:event_4) { VCAP::CloudController::Event.make(guid: '4', created_at: '2020-05-26T18:47:04Z') }
+
+        let(:event_3_json) do
+          {
+            guid: event_3.guid,
+            created_at: iso8601,
+            updated_at: iso8601,
+            type: event_3.type,
+            actor: {
+              guid: event_3.actor,
+              type: event_3.actor_type,
+              name: event_3.actor_name
+            },
+            target: {
+              guid: event_3.actee,
+              type: event_3.actee_type,
+              name: event_3.actee_name
+            },
+            data: {},
+            space: nil,
+            organization: {
+              guid: event_3.organization_guid
+            },
+            links: {
+              self: {
+                href: "#{link_prefix}/v3/audit_events/#{event_3.guid}"
+              }
+            }
+          }
+        end
+
+        it 'returns events after the greater-than timestamp but before the less-than timestamp' do
+          get "/v3/audit_events?created_ats[gt]=#{event_2.created_at.iso8601}&created_ats[lt]=#{event_4.created_at.iso8601}", nil, admin_header
+
+          expect(
+            resources: parsed_response['resources']
+          ).to match_json_response(
+            resources: [event_3_json]
+          )
+        end
+      end
 
       context 'using equal' do
         let!(:same_time_event) { VCAP::CloudController::Event.make(created_at: timestamp, organization_guid: org.guid, type: 'audit.organization.create') }

spec/unit/fetchers/event_list_fetcher_spec.rb

@@ -146,6 +146,24 @@ module VCAP::CloudController
           end
         end
 
+        context 'requesting events greater than one timestamp and less than another timestamp' do
+          let(:filters) do
+            { created_ats: { gt: event_1.created_at.iso8601, lt: event_4.created_at.iso8601 } }
+          end
+
+          it 'returns events with a created_at timestamp at or after a given timestamp' do
+            expect(subject).to match_array([event_2, event_3])
+          end
+
+          context 'when there are events with subsecond timestamps' do
+            let!(:event_between_3_and_4) { Event.make(guid: '3.5', created_at: '2020-05-26T18:47:03.5Z') }
+
+            it 'returns events with a created_at timestamp before or at a given timestamp' do
+              expect(subject).to match_array([event_2, event_3, event_between_3_and_4])
+            end
+          end
+        end
+
         context 'requesting events equal to a timestamp' do
           let(:filters) do
             { created_ats: [event_3.created_at.iso8601] }