BRD-20938 fix Rubocop exceptions

Author: jamesh-gomo

lib/scorm_engine/faraday/request.rb

@@ -52,7 +52,7 @@ def request(method, path, options, body = nil)
             # Retry the original request and return the result
             retry_response = make_request(method, path, options, body, api_version)
             ScormEngine::Response.new(raw_response: retry_response)
-          rescue StandardError => e
+          rescue StandardError
             # If tenant creation or retry fails, return the original response
             wrapped_response
           end

lib/scorm_engine/models/course.rb

@@ -58,7 +58,7 @@ def self.new_from_api(options = {})
         this.version = options["version"]
         this.title = get_title_from_api(options)
         this.registration_count = options["registrationCount"]
-        this.updated = Time.parse(options["updated"]) if options.key?("updated")
+        this.updated = Time.zone.parse(options["updated"]) if options.key?("updated")
         this.description = options.fetch("metadata", {})["description"]
         this.scaled_passing_score = get_scaled_passing_score_from_api(options)
         this.course_learning_standard = options["courseLearningStandard"]&.upcase

lib/scorm_engine/models/dispatch.rb

@@ -92,7 +92,7 @@ def self.new_from_api(options = {})
       def self.get_expiration_date(options = {})
         expiration_date = options["expirationDate"]
         return if expiration_date.nil? || expiration_date == "none"
-        Time.parse(expiration_date)
+        Time.zone.parse(expiration_date)
       end
     end
   end

lib/scorm_engine/models/dispatch_registration_count.rb

@@ -42,7 +42,7 @@ def self.get_last_reset_time(options = {})
         time = options["lastResetTime"]
         return if time.nil? || time == "none"
 
-        Time.parse(time)
+        Time.zone.parse(time)
       end
     end
   end

lib/scorm_engine/models/registration.rb

@@ -89,14 +89,14 @@ def self.new_from_api(options = {})
         this.options = options.dup
         this.id = options["id"]
         this.instance = options["instance"]
-        this.updated = Time.parse(options["updated"]) if options.key?("updated")
+        this.updated = Time.zone.parse(options["updated"]) if options.key?("updated")
         this.registration_completion = options["registrationCompletion"]&.upcase
         this.registration_success = options["registrationSuccess"]&.upcase
         this.total_seconds_tracked = options["totalSecondsTracked"]&.to_i
-        this.first_access_date = Time.parse(options["firstAccessDate"]) if options.key?("firstAccessDate")
-        this.last_access_date = Time.parse(options["lastAccessDate"]) if options.key?("lastAccessDate")
-        this.created_date = Time.parse(options["createdDate"]) if options.key?("createdDate")
-        this.updated = Time.parse(options["updated"]) if options.key?("updated")
+        this.first_access_date = Time.zone.parse(options["firstAccessDate"]) if options.key?("firstAccessDate")
+        this.last_access_date = Time.zone.parse(options["lastAccessDate"]) if options.key?("lastAccessDate")
+        this.created_date = Time.zone.parse(options["createdDate"]) if options.key?("createdDate")
+        this.updated = Time.zone.parse(options["updated"]) if options.key?("updated")
         this.registration_completion_amount = options["registrationCompletionAmount"].to_f # Sometimes it returns "NaN"
 
         this.score = get_score_from_api(options)
@@ -181,7 +181,7 @@ def self.get_completed_at_from_api(options = {})
         completed_date = options["completedDate"]
         completed_date ||= options.fetch("score", {})["completedDate"]
         return if completed_date.nil?
-        Time.parse(completed_date)
+        Time.zone.parse(completed_date)
       end
     end
     # rubocop:enable Metrics/AbcSize

lib/scorm_engine/models/registration_launch_history.rb

@@ -76,10 +76,10 @@ def self.new_from_api(options = {})
       # @return [Time]
       #
       def self.parse_time(string)
-        return nil if string.nil? || string.empty?
+        return nil if string.blank?
         Time.strptime("#{string} UTC", "%m/%d/%Y %H:%M:%S %p %Z")
       rescue StandardError
-        Time.parse(string)
+        Time.zone.parse(string)
       end
 
       #

lib/scorm_engine/models/registration_runtime_interaction.rb

@@ -88,8 +88,8 @@ def self.get_learner_response_from_api(options)
 
       def self.get_timestamp_from_api(options)
         timestamp = options["timestampUtc"]
-        return if timestamp.nil? || timestamp.empty?
-        Time.parse(timestamp)
+        return if string.blank?
+        Time.zone.parse(timestamp)
       end
     end
   end

lib/scorm_engine/response.rb

@@ -2,17 +2,13 @@ module ScormEngine
   class Response
     attr_reader :raw_response, :result
 
-    delegate :success?, :status, to: :raw_response
+    delegate :success?, :status, :body, to: :raw_response
 
     def initialize(raw_response:, result: nil)
       @raw_response = raw_response
       @result = result
     end
 
-    def body
-      raw_response.body
-    end
-
     def results
       result.is_a?(Enumerator) ? result : Array(result)
     end

spec/scorm_engine/api/endpoints/about_spec.rb

@@ -1,58 +1,60 @@
 RSpec.describe ScormEngine::Api::Endpoints::About do
   describe "#get_about" do
-    let(:subject) { scorm_engine_client.get_about }
+    client(:client) { scorm_engine_client.get_about }
 
     it "is successful" do
-      expect(subject.success?).to eq true
+      expect(client.success?).to eq true
     end
 
     it "knows the version" do
-      expect(subject.result.version).to eq "20.1.12.336"
+      expect(client.result.version).to eq "20.1.12.336"
     end
 
     it "knows the platform" do
-      expect(subject.result.platform).to eq "Java"
+      expect(client.result.platform).to eq "Java"
     end
   end
 
   describe "#get_about_user_count" do
-    let(:subject) { scorm_engine_client.get_about_user_count }
+    let(:client) { scorm_engine_client.get_about_user_count }
 
     it "is successful" do
-      expect(subject.success?).to eq true
+      expect(client.success?).to eq true
     end
 
     it "tracks combined counts" do
       aggregate_failures do
-        expect(subject.result.total).to be >= 1
-        expect(subject.result.dispatched).to be >= 0
-        expect(subject.result.non_dispatched).to be >= 0
+        expect(client.result.total).to be >= 1
+        expect(client.result.dispatched).to be >= 0
+        expect(client.result.non_dispatched).to be >= 0
       end
     end
 
+    # rubocop:disable RSpec/ExampleLength
     it "tracks per tenantcounts" do
       aggregate_failures do
-        expect(subject.result.by_tenant).to be_a Hash
-        tenant = subject.result.by_tenant[scorm_engine_client.tenant.downcase]
+        expect(client.result.by_tenant).to be_a Hash
+        tenant = client.result.by_tenant[scorm_engine_client.tenant.downcase]
         expect(tenant.total).to be >= 0
         expect(tenant.dispatched).to be >= 0
         expect(tenant.non_dispatched).to be >= 0
       end
     end
+    # rubocop:enable RSpec/ExampleLength
 
     it "accepts :before option" do
-      subject = scorm_engine_client.get_about_user_count(before: Time.parse("1901-01-1 00:00:00 UTC"))
+      client = scorm_engine_client.get_about_user_count(before: Time.parse("1901-01-1 00:00:00 UTC"))
       aggregate_failures do
-        expect(subject.success?).to eq true
-        expect(subject.result.total).to eq 0
+        expect(client.success?).to eq true
+        expect(client.result.total).to eq 0
       end
     end
 
     it "accepts :since option" do
-      subject = scorm_engine_client.get_about_user_count(since: Time.parse("2031-01-1 00:00:00 UTC"))
+      client = scorm_engine_client.get_about_user_count(since: Time.parse("2031-01-1 00:00:00 UTC"))
       aggregate_failures do
-        expect(subject.success?).to eq true
-        expect(subject.result.total).to eq 0
+        expect(client.success?).to eq true
+        expect(client.result.total).to eq 0
       end
     end
   end

spec/scorm_engine/api/endpoints/configuration_spec.rb

@@ -1,33 +1,36 @@
+# rubocop:disable RSpec/ExampleLength
 RSpec.describe ScormEngine::Api::Endpoints::Configuration do
   describe "#get_app_configuration" do
-    let(:subject) { scorm_engine_client.get_app_configuration }
+    client(:client) { scorm_engine_client.get_app_configuration }
 
     it "is successful" do
-      expect(subject.success?).to eq true
+      expect(client.success?).to eq true
     end
 
     it "returns settings and values" do
-      expect(subject.result.UserCountReportLookBackDays).to be_truthy
-      expect(subject.result["UserCountReportDaysBetweenReports"]).to be_truthy
+      aggregate_failures do
+        expect(client.result.UserCountReportLookBackDays).to be_truthy
+        expect(client.result["UserCountReportDaysBetweenReports"]).to be_truthy
+      end
     end
 
     describe "includeMetadata" do
-      let(:subject) { scorm_engine_client.get_app_configuration(includeMetadata: true) }
+      let(:client) { scorm_engine_client.get_app_configuration(includeMetadata: true) }
 
       it "is successful" do
-        expect(subject.success?).to eq true
+        expect(client.success?).to eq true
       end
 
       it "returns metadata in raw_response when included in options" do
-        expect(subject.raw_response.body["settingItems"].first["metadata"]).to_not be_nil
+        expect(client.raw_response.body["settingItems"].first["metadata"]).not_to be_nil
       end
     end
   end
 
   describe "#post_app_configuration" do
-    let(:subject) { scorm_engine_client }
+    let(:client) { scorm_engine_client }
     let(:response) {
-      subject.post_app_configuration(
+      client.post_app_configuration(
         settings: { "UserCountReportLookBackDays" => "90",
                     "UserCountReportDaysBetweenReports" => 20 }
       )
@@ -37,46 +40,60 @@
       expect(response.success?).to eq true
     end
 
-    it "persists the settings" do
+    it "persists the settings, default params" do
+      response # trigger the api
+      configuration = client.get_app_configuration.result
+      aggregate_failures do
+        expect(configuration["UserCountReportLookBackDays"]).to eq "90"
+        expect(configuration["UserCountReportDaysBetweenReports"]).to eq "20"
+      end
+    end
+
+    it "persists the settings, modified params" do
       response # trigger the api
-      configuration = subject.get_app_configuration.result
-      expect(configuration["UserCountReportLookBackDays"]).to eq "90"
-      expect(configuration["UserCountReportDaysBetweenReports"]).to eq "20"
 
-      subject.post_app_configuration(
+      client.post_app_configuration(
         settings: { "UserCountReportLookBackDays" => "365",
                     "UserCountReportDaysBetweenReports" => 30 }
       )
 
       sleep 3 # there seems to be a delay between posting new values and when they're updated frd
 
-      configuration = subject.get_app_configuration.result
-      expect(configuration["UserCountReportLookBackDays"]).to eq "365"
-      expect(configuration["UserCountReportDaysBetweenReports"]).to eq "30"
+      configuration = client.get_app_configuration.result
+      aggregate_failures do
+        expect(configuration["UserCountReportLookBackDays"]).to eq "365"
+        expect(configuration["UserCountReportDaysBetweenReports"]).to eq "30"
+      end
     end
 
     it "fails when settings are invalid" do
-      response = subject.post_app_configuration(settings: { "NonExistentSettingTotesBogus" => "YES" })
-      expect(response.success?).to eq false
-      expect(response.status).to eq 400
-      expect(response.message).to match(/NonExistentSettingTotesBogus is not a valid setting ID/)
+      response = client.post_app_configuration(settings: { "NonExistentSettingTotesBogus" => "YES" })
+      aggregate_failures do
+        expect(response.success?).to eq false
+        expect(response.status).to eq 400
+        expect(response.message).to match(/NonExistentSettingTotesBogus is not a valid setting ID/)
+      end
     end
   end
 
   describe "#delete_app_configuration" do
-    let(:subject) { scorm_engine_client }
+    let(:client) { scorm_engine_client }
     let(:response) {
-      subject.delete_app_configuration(setting_id: "UserCountReportLookBackDays")
+      client.delete_app_configuration(setting_id: "UserCountReportLookBackDays")
     }
 
     it "is successful" do
       expect(response.success?).to eq true
     end
+
     it "fails when settings are invalid" do
-      response = subject.delete_app_configuration(setting_id: "NonExistentSettingTotesBogus")
-      expect(response.success?).to eq false
-      expect(response.status).to eq 400
-      expect(response.message).to match(/NonExistentSettingTotesBogus/)
+      response = client.delete_app_configuration(setting_id: "NonExistentSettingTotesBogus")
+      aggregate_failures do
+        expect(response.success?).to eq false
+        expect(response.status).to eq 400
+        expect(response.message).to match(/NonExistentSettingTotesBogus/)
+      end
     end
   end
 end
+# rubocop:enable RSpec/ExampleLength