Avoid renaming params within report

I changed the used parameter names within the report so that we don't
have to rename the given parameter names when the report runs. This
avoids modifying the `params` object and therefore other problems.

lib/reporting/reports/enterprise_fee_summary/base.rb

@@ -8,13 +8,7 @@ module Reporting
 
         def initialize(user, params = {}, render: false)
           super(user, params, render: render)
-          # Clone hash before modifying it:
-          p = params[:q].clone
-          if p.present?
-            p['start_at'] = p.delete('completed_at_gt')
-            p['end_at'] = p.delete('completed_at_lt')
-          end
-          @parameters = Parameters.new(p || {})
+          @parameters = Parameters.new(params.fetch(:q, {}))
           @parameters.validate!
           @permissions = Permissions.new(user)
           @parameters.authorize!(@permissions)

lib/reporting/reports/enterprise_fee_summary/parameters.rb

@@ -6,12 +6,12 @@ module Reporting
       class Parameters < Reporting::Reports::EnterpriseFeeSummary::Reports::Parameters::Base
         include ActiveModel::Validations
 
-        attr_accessor :start_at, :end_at, :distributor_ids, :producer_ids, :order_cycle_ids,
+        attr_accessor :completed_at_gt, :completed_at_lt, :distributor_ids, :producer_ids, :order_cycle_ids,
                       :enterprise_fee_ids, :shipping_method_ids, :payment_method_ids
 
         before_validation :cleanup_arrays
 
-        validates :start_at, :end_at, date_time_string: true
+        validates :completed_at_gt, :completed_at_lt, date_time_string: true
         validates :distributor_ids, :producer_ids, integer_array: true
         validates :order_cycle_ids, integer_array: true
         validates :enterprise_fee_ids, integer_array: true

lib/reporting/reports/enterprise_fee_summary/reports/parameters/base.rb

@@ -28,10 +28,10 @@ module Reporting
             protected
 
             def require_valid_datetime_range
-              return if start_at.blank? || end_at.blank?
+              return if completed_at_gt.blank? || completed_at_lt.blank?
 
               error_message = self.class.date_end_before_start_error_message
-              errors.add(:end_at, error_message) unless start_at < end_at
+              errors.add(:completed_at_lt, error_message) unless completed_at_gt < completed_at_lt
             end
           end
         end

lib/reporting/reports/enterprise_fee_summary/scope.rb

@@ -315,9 +315,9 @@ module Reporting
         end
 
         def filter_by_date(params)
-          filter_scope("spree_orders.completed_at >= ?", params.start_at) \
-            if params.start_at.present?
-          filter_scope("spree_orders.completed_at <= ?", params.end_at) if params.end_at.present?
+          filter_scope("spree_orders.completed_at >= ?", params.completed_at_gt) \
+            if params.completed_at_gt.present?
+          filter_scope("spree_orders.completed_at <= ?", params.completed_at_lt) if params.completed_at_lt.present?
         end
 
         def filter_by_distribution(params)

spec/lib/reports/enterprise_fee_summary/enterprise_fee_summary_report_spec.rb

@@ -468,8 +468,8 @@ describe Reporting::Reports::EnterpriseFeeSummary::Base do
         end
       end
 
-      context "on or after start_at" do
-        let(:parameters_attributes) { { start_at: timestamp } }
+      context "on or after completed_at_gt" do
+        let(:parameters_attributes) { { completed_at_gt: timestamp } }
 
         it "filters entries" do
           totals = subject.query_result
@@ -480,8 +480,8 @@ describe Reporting::Reports::EnterpriseFeeSummary::Base do
         end
       end
 
-      context "on or before end_at" do
-        let(:parameters_attributes) { { end_at: timestamp } }
+      context "on or before completed_at_lt" do
+        let(:parameters_attributes) { { completed_at_lt: timestamp } }
 
         it "filters entries" do
           totals = subject.query_result

spec/lib/reports/enterprise_fee_summary/parameters_spec.rb

@@ -16,8 +16,8 @@ module Reporting
           end
 
           context "for type of parameters" do
-            it { is_expected.to validate_date_time_format_of(:start_at) }
-            it { is_expected.to validate_date_time_format_of(:end_at) }
+            it { is_expected.to validate_date_time_format_of(:completed_at_gt) }
+            it { is_expected.to validate_date_time_format_of(:completed_at_lt) }
             it { is_expected.to validate_integer_array(:distributor_ids) }
             it { is_expected.to validate_integer_array(:producer_ids) }
             it { is_expected.to validate_integer_array(:order_cycle_ids) }
@@ -43,21 +43,21 @@ module Reporting
               expect(subject.payment_method_ids).to eq(["1"])
             end
 
-            describe "requiring start_at to be before end_at" do
+            describe "requiring completed_at_gt to be before completed_at_lt" do
               let(:now) { Time.zone.now.utc }
 
-              it "adds error when start_at is after end_at" do
-                allow(subject).to receive(:start_at) { now.to_s }
-                allow(subject).to receive(:end_at) { (now - 1.hour).to_s }
+              it "adds error when completed_at_gt is after completed_at_lt" do
+                allow(subject).to receive(:completed_at_gt) { now.to_s }
+                allow(subject).to receive(:completed_at_lt) { (now - 1.hour).to_s }
 
                 expect(subject).not_to be_valid
                 error_message = described_class.date_end_before_start_error_message
-                expect(subject.errors[:end_at]).to eq([error_message])
+                expect(subject.errors[:completed_at_lt]).to eq([error_message])
               end
 
-              it "does not add error when start_at is before end_at" do
-                allow(subject).to receive(:start_at) { now.to_s }
-                allow(subject).to receive(:end_at) { (now + 1.hour).to_s }
+              it "does not add error when completed_at_gt is before completed_at_lt" do
+                allow(subject).to receive(:completed_at_gt) { now.to_s }
+                allow(subject).to receive(:completed_at_lt) { (now + 1.hour).to_s }
 
                 expect(subject).to be_valid
               end