@webex/internal-plugin-metrics 3.12.0-task-refactor.1 → 3.12.0-webex-services-ready.2

package/src/call-diagnostic/config.ts

@@ -26,6 +26,7 @@ export const WEBEX_SUB_SERVICE_TYPES: Record<string, ClientSubServiceType> = {
   SCHEDULED_MEETING: 'ScheduledMeeting',
   WEBINAR: 'Webinar',
   WEBCAST: 'Webcast',
+  LARGE_SCALE_WEBINAR: 'LargeScaleWebinar',
 };
 
 // Found in https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia
@@ -133,8 +134,10 @@ export const ERROR_DESCRIPTIONS = {
   MULTISTREAM_NOT_AVAILABLE: 'MultistreamNotAvailable',
   SDP_OFFER_CREATION_ERROR: 'SdpOfferCreationError',
   SDP_OFFER_CREATION_ERROR_MISSING_CODEC: 'SdpOfferCreationErrorMissingCodec',
+  WEBRTC_API_NOT_AVAILABLE: 'WebrtcApiNotAvailableError',
   WDM_RESTRICTED_REGION: 'WdmRestrictedRegion',
   USER_NOT_ALLOWED_JOIN_WEBINAR: 'UserNotAllowedJoinWebinar',
+  INVALID_MEETING_INFO: 'InvalidMeetingInfo',
 };
 
 export const SERVICE_ERROR_CODES_TO_CLIENT_ERROR_CODES_MAP = {
@@ -145,6 +148,8 @@ export const SERVICE_ERROR_CODES_TO_CLIENT_ERROR_CODES_MAP = {
   99002: 4100,
   // Cannot find the data. Unkown meeting.
   99009: 4100,
+  // The input parameters contain invalid item
+  99019: 4105,
   // Meeting is not allow to cross env
   58500: 4100,
   // Input parameters contain invalit item
@@ -200,6 +205,8 @@ export const SERVICE_ERROR_CODES_TO_CLIENT_ERROR_CODES_MAP = {
   423005: 4005,
   // Wrong password or host key with too many requests
   423006: 4005,
+  // PanelistPasswordError too many time,please input captcha code
+  423008: 4005,
   // PasswordError with right captcha, please input captcha code
   423010: 4005,
   // PasswordOrHostKeyError with right captcha, please input captcha code
@@ -226,6 +233,8 @@ export const SERVICE_ERROR_CODES_TO_CLIENT_ERROR_CODES_MAP = {
   403003: 4101,
   // Attendee email is required
   403030: 4101,
+  // webinar need login when un-invited attendee join
+  403106: 4104,
 
   // ---- Locus ------
   // FREE_USER_MAX_PARTICIPANTS_EXCEEDED
@@ -695,6 +704,12 @@ export const CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD: Record<number, Partial<ClientEv
     category: 'expected',
     fatal: true,
   },
+  4105: {
+    errorDescription: ERROR_DESCRIPTIONS.INVALID_MEETING_INFO,
+    category: 'expected',
+    fatal: false,
+    shownToUser: true,
+  },
   2729: {
     errorDescription: ERROR_DESCRIPTIONS.NO_MEDIA_FOUND,
     category: 'expected',

package/src/config.js

@@ -19,6 +19,7 @@ export default {
     batcherMaxCalls: 50,
     batcherMaxWait: 1500,
     batcherRetryPlateau: 32000,
+    batcherRetryOnNetworkError: true,
     waitForServiceTimeout: 30,
   },
 };

package/src/generic-metrics.ts

@@ -79,7 +79,7 @@ export default abstract class GenericMetrics extends StatelessWebexPlugin {
       device: {
         id: this.getDeviceId(),
       },
-      locale: window.navigator.language,
+      locale: window?.navigator.language,
       os: {
         name: getOSNameInternal(),
         version: getOSVersion(),
@@ -94,12 +94,12 @@ export default abstract class GenericMetrics extends StatelessWebexPlugin {
   protected getBrowserDetails(): object {
     return {
       browser: getBrowserName(),
-      browserHeight: window.innerHeight,
+      browserHeight: window?.innerHeight,
       browserVersion: getBrowserVersion(),
-      browserWidth: window.innerWidth,
-      domain: window.location.hostname,
-      inIframe: window.self !== window.top,
-      locale: window.navigator.language,
+      browserWidth: window?.innerWidth,
+      domain: window?.location.hostname,
+      inIframe: window?.self !== window?.top,
+      locale: window?.navigator.language,
       os: getOSNameInternal(),
     };
   }

package/src/index.ts

@@ -28,6 +28,7 @@ import BehavioralMetrics from './behavioral-metrics';
 import OperationalMetrics from './operational-metrics';
 import BusinessMetrics from './business-metrics';
 import RtcMetrics from './rtcMetrics';
+import PreLoginMetrics from './prelogin-metrics';
 
 registerInternalPlugin('metrics', Metrics, {
   config,
@@ -51,6 +52,7 @@ export {
   OperationalMetrics,
   BusinessMetrics,
   RtcMetrics,
+  PreLoginMetrics,
 };
 export type {
   ClientEvent,

package/src/metrics.types.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   ClientEvent as RawClientEvent,
   Event as RawEvent,
   MediaQualityEvent as RawMediaQualityEvent,
@@ -156,7 +156,6 @@ export type InternalEvent = {
     | 'internal.register.device.request'
     | 'internal.register.device.response'
     | 'internal.reset.join.latencies'
-    | 'internal.client.meeting.click.joinbutton'
     | 'internal.host.meeting.participant.admitted'
     | 'internal.client.meeting.interstitial-window.showed'
     | 'internal.client.interstitial-window.click.joinbutton'
@@ -197,7 +196,7 @@ export interface BusinessEventPayload {
   metricName: string;
   timestamp: number;
   context: DeviceContext;
-  browserDetails: EventPayload;
+  browserDetails: object;
   value: EventPayload;
 }
 
@@ -319,6 +318,7 @@ export type PreComputedLatencies =
   | 'internal.get.cluster.time'
   | 'internal.click.to.interstitial'
   | 'internal.click.to.interstitial.with.user.delay'
+  | 'internal.click.to.interstitial.for.client.jmt'
   | 'internal.refresh.captcha.time'
   | 'internal.exchange.ci.token.time'
   | 'internal.get.u2c.time'

package/src/new-metrics.ts

@@ -9,6 +9,8 @@ import CallDiagnosticMetrics from './call-diagnostic/call-diagnostic-metrics';
 import BehavioralMetrics from './behavioral-metrics';
 import OperationalMetrics from './operational-metrics';
 import BusinessMetrics from './business-metrics';
+import PreLoginMetrics from './prelogin-metrics';
+import PreLoginMetricsBatcher from './prelogin-metrics-batcher';
 import {
   RecursivePartial,
   MetricEventProduct,
@@ -45,6 +47,7 @@ class Metrics extends WebexPlugin {
   behavioralMetrics: BehavioralMetrics;
   operationalMetrics: OperationalMetrics;
   businessMetrics: BusinessMetrics;
+  preLoginMetrics: PreLoginMetrics;
   isReady = false;
 
   /**
@@ -87,6 +90,13 @@ class Metrics extends WebexPlugin {
     this.webex.once('ready', () => {
       // @ts-ignore
       this.callDiagnosticMetrics = new CallDiagnosticMetrics({}, {parent: this.webex});
+      this.preLoginMetrics = new PreLoginMetrics(
+        // @ts-ignore
+        new PreLoginMetricsBatcher({}, {parent: this.webex}),
+        {},
+        // @ts-ignore
+        {parent: this.webex}
+      );
       this.isReady = true;
       this.setDelaySubmitClientEvents({
         shouldDelay: this.delaySubmitClientEvents,
@@ -251,6 +261,38 @@ class Metrics extends WebexPlugin {
     return this.businessMetrics.submitBusinessEvent({name, payload, table, metadata});
   }
 
+  /**
+   * Call Analyzer: Pre-Login Event
+   * @param args
+   */
+  submitPreLoginEvent({
+    name,
+    preLoginId,
+    payload,
+    metadata,
+  }: {
+    name: string;
+    preLoginId: string;
+    payload: EventPayload;
+    metadata?: EventPayload;
+  }): Promise<void> {
+    if (!this.isReady) {
+      // @ts-ignore
+      this.webex.logger.log(
+        `NewMetrics: @submitPreLoginEvent. Attempted to submit before webex.ready: ${name}`
+      );
+
+      return Promise.resolve();
+    }
+
+    return this.preLoginMetrics.submitPreLoginEvent({
+      name,
+      preLoginId,
+      payload,
+      metadata,
+    });
+  }
+
   /**
    * Call Analyzer: Media Quality Event
    * @param args

package/src/prelogin-metrics-batcher.ts

@@ -78,6 +78,8 @@ const PreLoginMetricsBatcher = Batcher.extend({
           `PreLoginMetricsBatcher: @submitHttpRequest#${batchId}. Request successful.`
         );
 
+        this.handleHttpResponseStatus(res?.statusCode, payload);
+
         return res;
       })
       .catch((err) => {
@@ -87,9 +89,33 @@ const PreLoginMetricsBatcher = Batcher.extend({
           `error: ${generateCommonErrorMetadata(err)}`
         );
 
+        this.handleHttpResponseStatus(err?.statusCode, payload);
+
         return Promise.reject(err);
       });
   },
+
+  /**
+   * React to the HTTP status code returned by the prelogin metrics endpoint.
+   * Only items submitted with `markTelemetryOptOutOnResponse: true` opt into
+   * this behavior.
+   * @param {number | undefined} statusCode
+   * @param {any[]} payload Items flushed in this HTTP batch.
+   * @returns {void}
+   */
+  handleHttpResponseStatus(statusCode: number | undefined, payload: any[]) {
+    const shouldMark =
+      Array.isArray(payload) &&
+      payload.some((item) => item?.markTelemetryOptOutOnResponse === true);
+
+    if (!shouldMark) {
+      return;
+    }
+
+    if (statusCode === 200) {
+      this.webex.internal.newMetrics?.callDiagnosticMetrics?.setIsTelemetryOptOutAutomatic(true);
+    }
+  },
 });
 
 export default PreLoginMetricsBatcher;

package/src/prelogin-metrics.ts

@@ -0,0 +1,94 @@
+import GenericMetrics from './generic-metrics';
+import {BusinessEvent, EventPayload} from './metrics.types';
+import PreLoginMetricsBatcher from './prelogin-metrics-batcher';
+
+/**
+ * @description Util class to handle PreLogin Metrics
+ * @export
+ * @class PreLoginMetrics
+ */
+export default class PreLoginMetrics extends GenericMetrics {
+  private preLoginMetricsBatcher: typeof PreLoginMetricsBatcher;
+
+  /**
+   * Constructor
+   * @param {PreLoginMetricsBatcher} preLoginMetricsBatcher - Pre-login metrics batcher
+   * @param {any} attrs - Attributes
+   * @param {any} options - Options
+   * @constructor
+   */
+  constructor(
+    preLoginMetricsBatcher: typeof PreLoginMetricsBatcher,
+    attrs: any = {},
+    options: {parent?: any} = {}
+  ) {
+    super(attrs, options);
+    this.preLoginMetricsBatcher = preLoginMetricsBatcher;
+  }
+
+  /**
+   * Submit a business metric to our metrics endpoint.
+   * Routes to the correct table with the correct schema payload by table.
+   * @see https://confluence-eng-gpk2.cisco.com/conf/display/WAP/Business+metrics++-%3E+ROMA
+   * @param {Object} options - The options object
+   * @param {string} options.name - Name of the metric
+   * @param {string} options.preLoginId - ID to identify pre-login user
+   * @param {EventPayload} options.payload - User payload of the metric
+   * @param {EventPayload} [options.metadata] - Optional metadata to include outside of eventPayload.value
+   * @returns {Promise<void>} Promise that resolves when the metric is submitted
+   */
+  public submitPreLoginEvent({
+    name,
+    preLoginId,
+    payload,
+    metadata,
+  }: {
+    name: string;
+    preLoginId: string;
+    payload: EventPayload;
+    metadata?: EventPayload;
+  }): Promise<void> {
+    if (!metadata) {
+      metadata = {};
+    }
+    if (!metadata.appType) {
+      metadata.appType = 'Web Client';
+    }
+
+    const finalEvent = this.buildEvent(name, preLoginId, payload, metadata);
+
+    this.preLoginMetricsBatcher.savePreLoginId(preLoginId);
+
+    return this.preLoginMetricsBatcher.request(finalEvent);
+  }
+
+  /**
+   * Builds a formatted event object for metrics submission.
+   * @param {string} metricName - Metric name
+   * @param {string} preLoginId - Pre-login user identifier
+   * @param {EventPayload} payload - Metric payload data
+   * @param {EventPayload} metadata - Additional metadata to include in the event
+   * @returns {object} Formatted metrics event object with type, eventPayload, and timestamp
+   */
+  private buildEvent(
+    metricName: string,
+    preLoginId: string,
+    payload: EventPayload,
+    metadata: EventPayload
+  ): BusinessEvent {
+    return {
+      type: ['business'],
+      eventPayload: {
+        metricName,
+        browserDetails: this.getBrowserDetails(),
+        context: this.getContext(),
+        timestamp: new Date().getTime(),
+        value: {
+          preLoginId,
+          ...metadata,
+          ...payload,
+        },
+      },
+    };
+  }
+}

package/test/unit/spec/batcher.js

@@ -177,6 +177,49 @@ describe('plugin-metrics', () => {
               assert.lengthOf(webex.internal.metrics.batcher.queue, 0);
             });
         });
+
+        it('rejects the deferred without reenqueuing when batcherRetryOnNetworkError is false', () => {
+          webex.config.metrics = {...config.metrics, batcherRetryOnNetworkError: false};
+
+          webex.request = function () {
+            // noop
+          };
+
+          sinon.stub(webex, 'request').callsFake((options) => {
+            options.headers = {
+              trackingid: 'test-no-retry',
+            };
+
+            return Promise.reject(
+              new WebexHttpError.NetworkOrCORSError({
+                statusCode: 0,
+                options,
+              })
+            );
+          });
+
+          const promise = webex.internal.metrics.batcher.request({
+            key: 'testMetric',
+          });
+
+          return promiseTick(50)
+            .then(() => assert.lengthOf(webex.internal.metrics.batcher.queue, 1))
+            .then(() => clock.tick(config.metrics.batcherWait))
+            .then(() => assert.calledOnce(webex.request))
+            .then(() => promiseTick(50))
+            .then(() =>
+              promise.then(
+                () => {
+                  assert.fail('promise should have been rejected');
+                },
+                (reason) => {
+                  assert.instanceOf(reason, WebexHttpError.NetworkOrCORSError);
+                  assert.lengthOf(webex.internal.metrics.batcher.queue, 0);
+                  assert.calledOnce(webex.request);
+                }
+              )
+            );
+        });
       });
     });
   });

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics-batcher.ts

@@ -142,9 +142,7 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
             .stub()
             .returns(10);
-          webex.internal.newMetrics.callDiagnosticLatencies.getU2CTime = sinon
-            .stub()
-            .returns(20);
+          webex.internal.newMetrics.callDiagnosticLatencies.getU2CTime = sinon.stub().returns(20);
           webex.internal.newMetrics.callDiagnosticLatencies.getReachabilityClustersReqResp = sinon
             .stub()
             .returns(10);
@@ -165,7 +163,7 @@ describe('plugin-metrics', () => {
               registerWDMDeviceJMT: 10,
               showInterstitialTime: 10,
               getU2CTime: 20,
-              getReachabilityClustersReqResp: 10
+              getReachabilityClustersReqResp: 10,
             },
           });
           assert.lengthOf(
@@ -189,12 +187,17 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getDownloadTimeJMT = sinon
             .stub()
             .returns(100);
-          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitialWithUserDelay = sinon
-            .stub()
-            .returns(43);
+          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitialWithUserDelay =
+            sinon.stub().returns(43);
           webex.internal.newMetrics.callDiagnosticLatencies.getTotalJMTWithUserDelay = sinon
             .stub()
             .returns(64);
+          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToJoinOK = sinon
+            .stub()
+            .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getTotalJMT = sinon
+            .stub()
+            .returns(20);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
             {event: {name: 'client.locus.join.response'}}
@@ -346,9 +349,15 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToJoinOK = sinon
             .stub()
             .returns(7);
-            webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
+          webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
+            .stub()
+            .returns(1);
+          webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTimeCappedBy = sinon
             .stub()
             .returns(1);
+          webex.internal.newMetrics.callDiagnosticLatencies.getTotalMediaJMT = sinon
+            .stub()
+            .returns(44);
           webex.internal.newMetrics.callDiagnosticLatencies.getTotalMediaJMTWithUserDelay = sinon
             .stub()
             .returns(43);
@@ -369,10 +378,9 @@ describe('plugin-metrics', () => {
           assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
             name: 'client.media-engine.ready',
             joinTimes: {
-              totalMediaJMT: 61,
+              totalMediaJMT: 44,
               interstitialToMediaOKJMT: 22,
-              callInitMediaEngineReady: 10,
-              stayLobbyTime: 1,
+              callInitMediaEngineReady: 22,
               totalMediaJMTWithUserDelay: 43,
               totalJMTWithUserDelay: 64,
             },
@@ -382,6 +390,34 @@ describe('plugin-metrics', () => {
             0
           );
         });
+
+        it('appends the correct join times to the request for client.lobby.exited', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
+            .stub()
+            .returns(10);
+
+          const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.lobby.exited'}}
+          );
+          await flushPromises();
+          clock.tick(config.metrics.batcherWait);
+
+          await promise;
+
+          //@ts-ignore
+          assert.calledOnce(webex.request);
+          assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
+            name: 'client.lobby.exited',
+            joinTimes: {
+              stayLobbyTime: 10,
+            },
+          });
+          assert.lengthOf(
+            webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue,
+            0
+          );
+        });
       });
 
       describe('when the request fails', () => {
@@ -480,5 +516,141 @@ describe('plugin-metrics', () => {
         assert.deepEqual(prepareDiagnosticMetricItemCalls[0].args[1].type, ['diagnostic-event']);
       });
     });
+
+    describe('#submitHttpRequest', () => {
+      it('calls handleHttpResponseStatus with response status on success', async () => {
+        const payload = [
+          {
+            eventPayload: {event: 'my.event'},
+            type: ['diagnostic-event'],
+          },
+        ];
+
+        webex.request = sinon.stub().resolves({statusCode: 200});
+
+        const handleHttpResponseStatusSpy = sinon.spy(
+          webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher,
+          'handleHttpResponseStatus'
+        );
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.submitHttpRequest(
+            payload
+          );
+
+        assert.deepEqual(handleHttpResponseStatusSpy.getCalls().length, 0);
+
+        await flushPromises();
+        clock.tick(config.metrics.batcherWait);
+
+        await promise;
+
+        assert.calledOnce(webex.request);
+        assert.deepEqual(handleHttpResponseStatusSpy.getCalls().length, 1);
+        assert.deepEqual(handleHttpResponseStatusSpy.args[0][0], 200);
+        assert.deepEqual(handleHttpResponseStatusSpy.args[0][1], payload);
+      });
+
+      it('calls handleHttpResponseStatus with error status on failure', async () => {
+        const payload = [
+          {
+            eventPayload: {event: 'my.event'},
+            type: ['diagnostic-event'],
+          },
+        ];
+
+        webex.request = sinon.stub().rejects({statusCode: 503});
+
+        const handleHttpResponseStatusSpy = sinon.spy(
+          webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher,
+          'handleHttpResponseStatus'
+        );
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.submitHttpRequest(
+            payload
+          );
+
+        assert.deepEqual(handleHttpResponseStatusSpy.getCalls().length, 0);
+
+        await flushPromises();
+        clock.tick(config.metrics.batcherWait);
+
+        let error: any;
+
+        try {
+          await promise;
+        } catch (err) {
+          error = err;
+        }
+
+        assert.deepEqual(error.statusCode, 503);
+        assert.calledOnce(webex.request);
+        assert.deepEqual(handleHttpResponseStatusSpy.getCalls().length, 1);
+        assert.deepEqual(handleHttpResponseStatusSpy.args[0][0], 503);
+        assert.deepEqual(handleHttpResponseStatusSpy.args[0][1], payload);
+      });
+    });
+
+    describe('#handleHttpResponseStatus', () => {
+      let setIsTelemetryOptOutAutomaticStub;
+
+      beforeEach(() => {
+        setIsTelemetryOptOutAutomaticStub = sinon.stub(
+          webex.internal.newMetrics.callDiagnosticMetrics,
+          'setIsTelemetryOptOutAutomatic'
+        );
+      });
+
+      [201, 400, 503, undefined].forEach((statusCode) => {
+        it(`does not call setIsTelemetryOptOutAutomatic() when statusCode is ${statusCode} and markTelemetryOptOutOnResponse is true`, () => {
+          webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.handleHttpResponseStatus(
+            statusCode,
+            [{markTelemetryOptOutOnResponse: true}]
+          );
+
+          assert.notCalled(setIsTelemetryOptOutAutomaticStub);
+        });
+      });
+
+      it('calls setIsTelemetryOptOutAutomatic(true) when statusCode is 200 and markTelemetryOptOutOnResponse is true', () => {
+        webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.handleHttpResponseStatus(
+          200,
+          [{markTelemetryOptOutOnResponse: true}]
+        );
+
+        assert.calledOnce(setIsTelemetryOptOutAutomaticStub);
+        assert.calledWithExactly(setIsTelemetryOptOutAutomaticStub, true);
+      });
+
+      [200, 201, 400, 503, undefined].forEach((statusCode) => {
+        it(`does not call setIsTelemetryOptOutAutomatic when shouldMark is false (statusCode: ${statusCode})`, () => {
+          webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.handleHttpResponseStatus(
+            statusCode,
+            [{markTelemetryOptOutOnResponse: false}]
+          );
+
+          assert.notCalled(setIsTelemetryOptOutAutomaticStub);
+        });
+      });
+
+      it('does not call setIsTelemetryOptOutAutomatic when payload is empty', () => {
+        webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.handleHttpResponseStatus(
+          200,
+          []
+        );
+
+        assert.notCalled(setIsTelemetryOptOutAutomaticStub);
+      });
+
+      it('does not call setIsTelemetryOptOutAutomatic when payload is not an array', () => {
+        webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.handleHttpResponseStatus(
+          200,
+          null
+        );
+
+        assert.notCalled(setIsTelemetryOptOutAutomaticStub);
+      });
+    });
   });
 });