v3: Client can filter **audit events** by **updated_ats**

[finishes #173691526]

Co-authored-by: Mona Mohebbi <mmohebbi@pivotal.io>
Co-authored-by: Reid Mitchell <rmitchell@pivotal.io>

Author: monamohebbi

app/fetchers/event_list_fetcher.rb

@@ -28,21 +28,25 @@ def filter(message, dataset)
           dataset = dataset.where(organization_guid: message.organization_guids)
         end
 
-        if message.requested?(:created_ats)
-          if message.created_ats.is_a?(Hash)
-            message.created_ats.map do |operator, given_timestamp|
+        advanced_filters = {}
+        advanced_filters['created_at'] = message.created_ats if message.requested?(:created_ats)
+        advanced_filters['updated_at'] = message.updated_ats if message.requested?(:updated_ats)
+
+        advanced_filters.each do |filter, values|
+          if values.is_a?(Hash)
+            values.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))
+                dataset = dataset.where(Sequel.lit("#{filter} < ?", 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))
+                dataset = dataset.where(Sequel.lit("#{filter} <= ?", 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))
+                dataset = dataset.where(Sequel.lit("#{filter} > ?", 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))
+                dataset = dataset.where(Sequel.lit("#{filter} >= ?", normalized_timestamp))
               end
             end
           else
@@ -53,10 +57,10 @@ def filter(message, dataset)
             # the span of the second (e.g. "12:34:56.00-12:34:56.9999999"), for databases store
             # timestamps in sub-second accuracy (PostgreSQL stores in microseconds, for example)
             sequel_query =
-              (['created_at BETWEEN ? AND ?'] * message.created_ats.size).join(' OR ')
+              (["#{filter} BETWEEN ? AND ?"] * values.size).join(' OR ')
 
-            times = message.created_ats.map do |created_at|
-              lower_bound = Time.parse(created_at).utc
+            times = values.map do |timestamp|
+              lower_bound = Time.parse(timestamp).utc
               upper_bound = Time.at(lower_bound + 0.999999).utc
               [lower_bound, upper_bound]
             end.flatten

app/messages/events_list_message.rb

@@ -4,45 +4,51 @@ module VCAP::CloudController
   class EventsListMessage < ListMessage
     class CreatedAtValidator < ActiveModel::Validator
       def validate(record)
-        if record.requested?(:created_ats)
-          if record.created_ats.is_a?(Array)
-            record.created_ats.each do |timestamp|
-              opinionated_iso_8601(timestamp, record)
-            end
-          else
-            unless record.created_ats.is_a?(Hash)
-              record.errors[:created_ats] << 'relational operator and timestamp must be specified'
-              return
-            end
+        filters = {}
+        filters[:created_ats] = record.created_ats if record.requested?(:created_ats)
+        filters[:updated_ats] = record.updated_ats if record.requested?(:updated_ats)
 
-            valid_relational_operators = [
-              Event::LESS_THAN_COMPARATOR,
-              Event::GREATER_THAN_COMPARATOR,
-              Event::LESS_THAN_OR_EQUAL_COMPARATOR,
-              Event::GREATER_THAN_OR_EQUAL_COMPARATOR,
-            ]
-
-            record.created_ats.each do |relational_operator, timestamp|
-              unless valid_relational_operators.include?(relational_operator)
-                record.errors[:created_ats] << "Invalid relational operator: '#{relational_operator}'"
+        filters.each do |filter, values|
+          if record.requested?(filter)
+            if values.is_a?(Array)
+              values.each do |timestamp|
+                opinionated_iso_8601(timestamp, record, filter)
               end
-
-              if timestamp.to_s.include?(',')
-                record.errors[:created_ats] << 'only accepts one value when using a relational operator'
+            else
+              unless values.is_a?(Hash)
+                record.errors[filter] << 'relational operator and timestamp must be specified'
                 next
               end
 
-              opinionated_iso_8601(timestamp, record)
+              valid_relational_operators = [
+                Event::LESS_THAN_COMPARATOR,
+                Event::GREATER_THAN_COMPARATOR,
+                Event::LESS_THAN_OR_EQUAL_COMPARATOR,
+                Event::GREATER_THAN_OR_EQUAL_COMPARATOR,
+              ]
+
+              values.each do |relational_operator, timestamp|
+                unless valid_relational_operators.include?(relational_operator)
+                  record.errors[filter] << "Invalid relational operator: '#{relational_operator}'"
+                end
+
+                if timestamp.to_s.include?(',')
+                  record.errors[filter] << 'only accepts one value when using a relational operator'
+                  next
+                end
+
+                opinionated_iso_8601(timestamp, record, filter)
+              end
             end
           end
         end
       end
 
       private
 
-      def opinionated_iso_8601(timestamp, record)
+      def opinionated_iso_8601(timestamp, record, filter)
         if timestamp !~ /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\Z/
-          record.errors[:created_ats] << "has an invalid timestamp format. Timestamps should be formatted as 'YYYY-MM-DDThh:mm:ssZ'"
+          record.errors[filter] << "has an invalid timestamp format. Timestamps should be formatted as 'YYYY-MM-DDThh:mm:ssZ'"
         end
       end
     end
@@ -52,7 +58,8 @@ def opinionated_iso_8601(timestamp, record)
       :target_guids,
       :space_guids,
       :organization_guids,
-      :created_ats
+      :created_ats,
+      :updated_ats
     ]
 
     validates_with NoAdditionalParamsValidator
@@ -64,7 +71,7 @@ def opinionated_iso_8601(timestamp, record)
     validates :organization_guids, array: true, allow_nil: true
 
     def self.from_params(params)
-      super(params, %w(types target_guids space_guids organization_guids created_ats))
+      super(params, %w(types target_guids space_guids organization_guids created_ats updated_ats))
     end
   end
 end

spec/request/events_spec.rb

@@ -161,9 +161,17 @@
     end
 
     context 'filtering by timestamp' do
+      before do
+        VCAP::CloudController::Event.plugin :timestamps, update_on_create: false
+      end
+
       let(:timestamp) { (Time.now + 1).utc.iso8601 }
       let(:timestamp_half_second_later) { (Time.parse(timestamp) + 0.5).utc.iso8601 }
 
+      after do
+        VCAP::CloudController::Event.plugin :timestamps, update_on_create: true
+      end
+
       context 'using less than' do
         let!(:extra_event) { VCAP::CloudController::Event.make(created_at: Time.now + 100, organization_guid: org.guid) }
         let!(:half_second_event) { VCAP::CloudController::Event.make(created_at: timestamp_half_second_later, organization_guid: org.guid, type: 'audit.organization.create') }
@@ -179,225 +187,8 @@
         end
       end
 
-      context 'using less 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
-
-        let!(:half_second_event) { VCAP::CloudController::Event.make(created_at: timestamp_half_second_later, organization_guid: org.guid, type: 'audit.organization.create') }
-
-        let(:half_second_event_json) do
-          {
-            guid: half_second_event.guid,
-            created_at: iso8601,
-            updated_at: iso8601,
-            type: 'audit.organization.create',
-            actor: {
-              guid: half_second_event.actor,
-              type: half_second_event.actor_type,
-              name: half_second_event.actor_name
-            },
-            target: {
-              guid: half_second_event.actee,
-              type: half_second_event.actee_type,
-              name: half_second_event.actee_name
-            },
-            data: {},
-            space: nil,
-            organization: {
-              guid: org.guid
-            },
-            links: {
-              self: {
-                href: "#{link_prefix}/v3/audit_events/#{half_second_event.guid}"
-              }
-            }
-          }
-        end
-
-        it 'returns events earlier than the given timestamp' do
-          get "/v3/audit_events?created_ats[lte]=#{timestamp}", nil, admin_header
-
-          expect(
-            resources: parsed_response['resources']
-          ).to match_json_response(
-            resources: [unscoped_event_json, space_scoped_event_json, extra_event_json, half_second_event_json]
-          )
-        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' do
-        it 'returns events after the given timestamp' do
-          get "/v3/audit_events?created_ats[gt]=#{timestamp}", nil, admin_header
-
-          expect(
-            resources: parsed_response['resources']
-          ).to match_json_response(
-            resources: [org_scoped_event_json]
-          )
-        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') }
+        let!(:same_time_event) { VCAP::CloudController::Event.make(updated_at: timestamp, organization_guid: org.guid, type: 'audit.organization.create') }
 
         let(:same_time_event_json) do
           {
@@ -429,7 +220,7 @@
         end
 
         it 'returns events at the given timestamp' do
-          get "/v3/audit_events?created_ats=#{timestamp}", nil, admin_header
+          get "/v3/audit_events?updated_ats=#{timestamp}", nil, admin_header
 
           expect(last_response).to have_status_code(200)
           expect(