Only disable audits which were enabled when scheduled run is false

Author: tkotthakota-adobe

src/tasks/disable-import-audit-processor/handler.js

@@ -60,20 +60,26 @@ export async function runDisableImportAuditProcessor(message, context) {
     site.setConfig(Config.toDynamoItem(siteConfig));
 
     const configuration = await Configuration.findLatest();
+    const auditsDisabled = [];
     for (const auditType of auditTypes) {
-      configuration.disableHandlerForSite(auditType, site);
+      if (configuration.isHandlerEnabledForSite(auditType, site)) {
+        configuration.disableHandlerForSite(auditType, site);
+        auditsDisabled.push(auditType);
+      }
     }
 
     await site.save();
-    await configuration.save();
+    if (auditsDisabled.length > 0) {
+      await configuration.save();
+    }
     log.info(`For site: ${siteUrl}: Disabled imports and audits`);
 
     const importsText = importTypes.length > 0 ? importTypes.join(', ') : 'None';
-    const auditsText = auditTypes.length > 0 ? auditTypes.join(', ') : 'None';
+    const auditsText = auditsDisabled.length > 0 ? auditsDisabled.join(', ') : 'None';
 
     let slackMessage = `:broom: *For site: ${siteUrl}: Disabled imports*: ${importsText} *and audits*: ${auditsText}`;
     await say(env, log, slackContext, slackMessage);
-    slackMessage = ':information_source: The list of enabled imports and audits may differ from the disabled ones because items that are already enabled are not automatically disabled. When schedule run flag is true then no imports and audits are disabled.';
+    slackMessage = ':information_source: Only audits currently enabled for the site are disabled. Scheduled sites skip disable entirely.';
     await say(env, log, slackContext, slackMessage);
   } catch (error) {
     log.error('Error in disable import and audit processor:', error);

test/tasks/disable-import-audit-processor/disable-import-audit-processor.test.js

@@ -71,6 +71,7 @@ describe('Disable Import Audit Processor', () => {
     };
 
     mockConfiguration = {
+      isHandlerEnabledForSite: sandbox.stub().returns(true),
       disableHandlerForSite: sandbox.stub(),
       save: sandbox.stub().resolves(),
     };
@@ -153,7 +154,7 @@ describe('Disable Import Audit Processor', () => {
           context.env,
           context.log,
           'test-slack-context',
-          ':information_source: The list of enabled imports and audits may differ from the disabled ones because items that are already enabled are not automatically disabled. When schedule run flag is true then no imports and audits are disabled.',
+          ':information_source: Only audits currently enabled for the site are disabled. Scheduled sites skip disable entirely.',
         );
 
         // Verify successful completion
@@ -172,7 +173,7 @@ describe('Disable Import Audit Processor', () => {
 
         // Verify saves were still called
         expect(mockSite.save).to.have.been.calledOnce;
-        expect(mockConfiguration.save).to.have.been.calledOnce;
+        expect(mockConfiguration.save).not.to.have.been.called;
 
         expect(toDynamoItemStub).to.have.been.calledOnceWith(mockSiteConfig);
         expect(mockSite.setConfig).to.have.been.calledOnceWith(serializedConfigFixture);

test/tasks/disable-import-audit-processor/handler.test.js

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { expect, use } from 'chai';
+import sinon from 'sinon';
+import sinonChai from 'sinon-chai';
+import esmock from 'esmock';
+
+use(sinonChai);
+
+describe('disable-import-audit-processor handler', () => {
+  let sandbox;
+  let context;
+  let message;
+  let mockSite;
+  let mockSiteConfig;
+  let mockConfiguration;
+  let mockSay;
+  let runDisableImportAuditProcessor;
+
+  beforeEach(async () => {
+    sandbox = sinon.createSandbox();
+
+    mockSay = sandbox.stub().resolves();
+
+    const handlerModule = await esmock('../../../src/tasks/disable-import-audit-processor/handler.js', {
+      '../../../src/utils/slack-utils.js': { say: mockSay },
+      '@adobe/spacecat-shared-data-access': {
+        Config: { toDynamoItem: sandbox.stub().returns({}) },
+      },
+    });
+    runDisableImportAuditProcessor = handlerModule.runDisableImportAuditProcessor;
+
+    mockSiteConfig = {
+      disableImport: sandbox.stub(),
+    };
+
+    mockSite = {
+      getConfig: sandbox.stub().returns(mockSiteConfig),
+      setConfig: sandbox.stub(),
+      save: sandbox.stub().resolves(),
+    };
+
+    mockConfiguration = {
+      isHandlerEnabledForSite: sandbox.stub(),
+      disableHandlerForSite: sandbox.stub(),
+      save: sandbox.stub().resolves(),
+    };
+
+    context = {
+      log: {
+        info: sandbox.stub(),
+        error: sandbox.stub(),
+        warn: sandbox.stub(),
+      },
+      env: {},
+      dataAccess: {
+        Site: { findByBaseURL: sandbox.stub().resolves(mockSite) },
+        Configuration: { findLatest: sandbox.stub().resolves(mockConfiguration) },
+      },
+    };
+
+    message = {
+      siteId: 'site-123',
+      siteUrl: 'https://example.com',
+      organizationId: 'org-123',
+      taskContext: {
+        importTypes: ['traffic-analysis'],
+        auditTypes: ['cwv', 'apex'],
+        scheduledRun: false,
+        slackContext: null,
+      },
+    };
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('skips all disabling when scheduledRun is true', async () => {
+    message.taskContext.scheduledRun = true;
+
+    const result = await runDisableImportAuditProcessor(message, context);
+
+    expect(result.status).to.equal(200);
+    expect(context.dataAccess.Site.findByBaseURL).not.to.have.been.called;
+    expect(context.dataAccess.Configuration.findLatest).not.to.have.been.called;
+    expect(context.log.info.calledWith(sinon.match(/Scheduled run detected/))).to.be.true;
+  });
+
+  it('disables imports and enabled audits for non-scheduled site', async () => {
+    mockConfiguration.isHandlerEnabledForSite.withArgs('cwv', mockSite).returns(true);
+    mockConfiguration.isHandlerEnabledForSite.withArgs('apex', mockSite).returns(true);
+
+    await runDisableImportAuditProcessor(message, context);
+
+    expect(mockSiteConfig.disableImport).to.have.been.calledWith('traffic-analysis');
+    expect(mockConfiguration.disableHandlerForSite).to.have.been.calledWith('cwv', mockSite);
+    expect(mockConfiguration.disableHandlerForSite).to.have.been.calledWith('apex', mockSite);
+    expect(mockConfiguration.save).to.have.been.calledOnce;
+    expect(mockSite.save).to.have.been.calledOnce;
+  });
+
+  it('is a no-op for audits that are already disabled', async () => {
+    mockConfiguration.isHandlerEnabledForSite.returns(false);
+
+    await runDisableImportAuditProcessor(message, context);
+
+    expect(mockConfiguration.disableHandlerForSite).not.to.have.been.called;
+    expect(mockConfiguration.save).not.to.have.been.called;
+  });
+
+  it('only disables audits that are currently enabled', async () => {
+    mockConfiguration.isHandlerEnabledForSite.withArgs('cwv', mockSite).returns(true);
+    mockConfiguration.isHandlerEnabledForSite.withArgs('apex', mockSite).returns(false);
+
+    await runDisableImportAuditProcessor(message, context);
+
+    expect(mockConfiguration.disableHandlerForSite).to.have.been.calledOnceWith('cwv', mockSite);
+    expect(mockConfiguration.save).to.have.been.calledOnce;
+  });
+
+  it('skips audit disable when auditTypes is empty', async () => {
+    message.taskContext.auditTypes = [];
+
+    await runDisableImportAuditProcessor(message, context);
+
+    expect(mockConfiguration.isHandlerEnabledForSite).not.to.have.been.called;
+    expect(mockConfiguration.disableHandlerForSite).not.to.have.been.called;
+    expect(mockConfiguration.save).not.to.have.been.called;
+    expect(mockSite.save).to.have.been.calledOnce;
+  });
+
+  it('handles missing site gracefully', async () => {
+    context.dataAccess.Site.findByBaseURL.resolves(null);
+
+    const result = await runDisableImportAuditProcessor(message, context);
+
+    expect(result.status).to.equal(200);
+    expect(context.log.error.calledWith(
+      'Error in disable import and audit processor:',
+      sinon.match.instanceOf(Error),
+    )).to.be.true;
+  });
+
+  it('returns 200 on success', async () => {
+    mockConfiguration.isHandlerEnabledForSite.returns(false);
+
+    const result = await runDisableImportAuditProcessor(message, context);
+
+    expect(result.status).to.equal(200);
+  });
+});