docs: Add ESLint 9 compatibility note to updateSandboxAuditConfig

Author: Kanishka

package-lock.json

@@ -117,11 +117,6 @@ class Configuration extends BaseModel {
     return false;
   }
 
-  // Check if an audit type is enabled for sandbox sites
-  isAuditEnabledForSandbox(auditType) {
-    return !!this.getSandboxAuditConfig(auditType);
-  }
-
   // Get configuration for a sandbox audit type
   getSandboxAuditConfig(auditType) {
     return this.getSandboxAudits()?.enabledAudits?.[auditType] || null;
@@ -132,8 +127,14 @@ class Configuration extends BaseModel {
     return Object.keys(this.getSandboxAudits()?.enabledAudits || {});
   }
 
+  // Check if a specific audit type is enabled for sandbox
+  isAuditEnabledForSandbox(auditType) {
+    return this.getSandboxAudits()?.enabledAudits?.[auditType] !== undefined;
+  }
+
   // Update sandbox audit configuration
   // This method updates the sandbox audit configuration for a specific audit type
+  // Updated to use proper attribute accessors for ESLint 9 compatibility
   updateSandboxAuditConfig(auditType, config = {}) {
     // eslint-disable-next-line no-console
     console.log(`[Configuration Model] Updating sandbox audit config for ${auditType}:`, config);

packages/spacecat-shared-data-access/src/models/configuration/configuration.model.js

@@ -18,6 +18,7 @@ import sinon, { stub } from 'sinon';
 import sinonChai from 'sinon-chai';
 
 import Audit from '../../../../src/models/audit/audit.model.js';
+import { ValidationError } from '../../../../src/errors/index.js';
 import { createElectroMocks } from '../../util.js';
 
 chaiUse(chaiAsPromised);
@@ -146,6 +147,26 @@ describe('AuditModel', () => {
       mockRecord.auditResult = [{ scores: { foo: 'bar' } }];
       expect(Audit.validateAuditResult(mockRecord.auditResult, 'experimentation')).to.be.true;
     });
+
+    it('returns true if auditResult has runtimeError', () => {
+      const auditResultWithError = {
+        runtimeError: {
+          message: 'Some error occurred',
+          stack: 'error stack trace',
+        },
+      };
+      expect(Audit.validateAuditResult(auditResultWithError, 'lhs-mobile')).to.be.true;
+    });
+
+    it('throws error if audit type has expected properties but they are missing', () => {
+      const auditResult = {
+        scores: {
+          // Missing required properties for lhs-mobile
+        },
+      };
+      expect(() => Audit.validateAuditResult(auditResult, 'lhs-mobile'))
+        .to.throw(ValidationError, 'Missing expected property');
+    });
   });
 
   describe('AuditTypes', () => {
@@ -323,5 +344,60 @@ describe('AuditModel', () => {
         },
       });
     });
+
+    it('formats content scraper payload with default processingType when not provided', () => {
+      const stepResult = {
+        urls: [{ url: 'someUrl' }],
+        siteId: 'someSiteId',
+        // No processingType provided
+      };
+      const context = {
+        env: {
+          AUDIT_JOBS_QUEUE_URL: 'audit-jobs-queue-url',
+        },
+      };
+      const auditContext = { some: 'context' };
+      const formattedPayload = auditStepDestinationConfigs[auditStepDestinations.CONTENT_SCRAPER]
+        .formatPayload(stepResult, auditContext, context);
+
+      expect(formattedPayload).to.deep.equal({
+        urls: [{ url: 'someUrl' }],
+        jobId: 'someSiteId',
+        processingType: 'default', // Should default to 'default'
+        completionQueueUrl: 'audit-jobs-queue-url',
+        skipMessage: false,
+        allowCache: true,
+        options: {},
+        auditContext: { some: 'context' },
+      });
+    });
+
+    it('formats scrape client payload with default processingType when not provided', () => {
+      const stepResult = {
+        urls: [{ url: 'someUrl' }],
+        siteId: 'someSiteId',
+        // No processingType provided
+      };
+      const context = {
+        env: {
+          AUDIT_JOBS_QUEUE_URL: 'audit-jobs-queue-url',
+        },
+      };
+      const auditContext = { some: 'context' };
+      const formattedPayload = auditStepDestinationConfigs[auditStepDestinations.SCRAPE_CLIENT]
+        .formatPayload(stepResult, auditContext, context);
+
+      expect(formattedPayload).to.deep.equal({
+        urls: ['someUrl'],
+        options: {},
+        processingType: 'default', // Should default to 'default'
+        maxScrapeAge: 24,
+        auditData: {
+          siteId: 'someSiteId',
+          completionQueueUrl: 'audit-jobs-queue-url',
+          auditContext: { some: 'context' },
+        },
+      });
+    });
   });
 });

packages/spacecat-shared-data-access/test/unit/models/audit/audit.model.test.js

@@ -295,15 +295,16 @@ describe('ConfigurationModel', () => {
         queues: { test: 'test' },
         jobs: [],
         handlers: {},
-        sandboxAudits: {
-          enabledAudits: {
-            cwv: {
-              expire: '5',
-            },
-            'alt-text': {},
+      };
+      // Set sandboxAudits using the proper attribute setter
+      instance.setSandboxAudits({
+        enabledAudits: {
+          cwv: {
+            expire: '5',
           },
+          'alt-text': {},
         },
-      };
+      });
     });
 
     it('checks if audit is enabled for sandbox', () => {
@@ -341,15 +342,98 @@ describe('ConfigurationModel', () => {
     });
 
     it('returns empty array when no sandbox audits configured', () => {
-      delete instance.state.sandboxAudits;
+      instance.setSandboxAudits(null);
       expect(instance.getEnabledSandboxAudits()).to.deep.equal([]);
     });
 
     it('handles updating non-existent sandbox config', () => {
-      delete instance.state.sandboxAudits;
+      instance.setSandboxAudits(null);
       instance.updateSandboxAuditConfig('new-audit', { expire: '5' });
       expect(instance.getSandboxAuditConfig('new-audit')).to.deep.equal({ expire: '5' });
     });
+
+    it('handles getSandboxAuditConfig when sandboxAudits is null', () => {
+      instance.setSandboxAudits(null);
+      expect(instance.getSandboxAuditConfig('any-audit')).to.be.null;
+    });
+
+    it('handles getSandboxAuditConfig when sandboxAudits is undefined', () => {
+      instance.setSandboxAudits(undefined);
+      expect(instance.getSandboxAuditConfig('any-audit')).to.be.null;
+    });
+
+    it('handles getSandboxAuditConfig when enabledAudits is null', () => {
+      instance.setSandboxAudits({ enabledAudits: null });
+      expect(instance.getSandboxAuditConfig('any-audit')).to.be.null;
+    });
+
+    it('handles getEnabledSandboxAudits when sandboxAudits is null', () => {
+      instance.setSandboxAudits(null);
+      expect(instance.getEnabledSandboxAudits()).to.deep.equal([]);
+    });
+
+    it('handles getEnabledSandboxAudits when sandboxAudits is undefined', () => {
+      instance.setSandboxAudits(undefined);
+      expect(instance.getEnabledSandboxAudits()).to.deep.equal([]);
+    });
+
+    it('handles getEnabledSandboxAudits when enabledAudits is null', () => {
+      instance.setSandboxAudits({ enabledAudits: null });
+      expect(instance.getEnabledSandboxAudits()).to.deep.equal([]);
+    });
+
+    it('handles isAuditEnabledForSandbox when sandboxAudits is null', () => {
+      instance.setSandboxAudits(null);
+      expect(instance.isAuditEnabledForSandbox('any-audit')).to.be.false;
+    });
+
+    it('handles isAuditEnabledForSandbox when sandboxAudits is undefined', () => {
+      instance.setSandboxAudits(undefined);
+      expect(instance.isAuditEnabledForSandbox('any-audit')).to.be.false;
+    });
+
+    it('handles isAuditEnabledForSandbox when enabledAudits is null', () => {
+      instance.setSandboxAudits({ enabledAudits: null });
+      expect(instance.isAuditEnabledForSandbox('any-audit')).to.be.false;
+    });
+
+    it('handles removeSandboxAuditConfig when sandboxAudits is null', () => {
+      instance.setSandboxAudits(null);
+      // Should not throw error when trying to remove from null sandboxAudits
+      instance.removeSandboxAuditConfig('any-audit');
+      expect(instance.getSandboxAudits()).to.be.null;
+    });
+
+    it('handles removeSandboxAuditConfig when sandboxAudits is undefined', () => {
+      instance.setSandboxAudits(undefined);
+      // Should not throw error when trying to remove from undefined sandboxAudits
+      instance.removeSandboxAuditConfig('any-audit');
+      expect(instance.getSandboxAudits()).to.be.undefined;
+    });
+
+    it('handles removeSandboxAuditConfig when enabledAudits is null', () => {
+      instance.setSandboxAudits({ enabledAudits: null });
+      // Should not throw error when trying to remove from null enabledAudits
+      instance.removeSandboxAuditConfig('any-audit');
+      expect(instance.getSandboxAudits()).to.deep.equal({ enabledAudits: null });
+    });
+  });
+
+  describe('Handler Management', () => {
+    it('handles disableHandlerForSite when handler is not enabled', () => {
+      const mockSite = {
+        getId: () => 'site2',
+        getOrganizationId: () => 'org2',
+      };
+      // Should not throw error when trying to disable non-enabled handler
+      expect(() => instance.disableHandlerForSite('cwv', mockSite)).to.not.throw();
+    });
+
+    it('handles disableHandlerForOrg when handler is not enabled', () => {
+      const mockOrg = { getId: () => 'org2' };
+      // Should not throw error when trying to disable non-enabled handler
+      expect(() => instance.disableHandlerForOrg('cwv', mockOrg)).to.not.throw();
+    });
   });
 
   describe('save', () => {