test(observability): add BuildUpdate one-shot regression test [SDK-6574]

Drives multiple test events through a single reporter instance (deps stubbed via
proxyquire) and asserts BuildUpdate is uploaded at most once. Fails on the buggy
code (one BuildUpdate per event) and passes on the fix. Also asserts BuildUpdate
is deferred until the framework version is known.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: xxshubhamxx

test/unit/bin/testObservability/reporter/index.js

@@ -0,0 +1,118 @@
+'use strict';
+
+/*
+ * Regression test for SDK-6574.
+ *
+ * The Observability reporter is meant to emit `BuildUpdate` once. A typo made
+ * the one-shot guard set a dead sibling field (`shouldSendBuildUpdate`) instead
+ * of `haveSentBuildUpdate`, so the flag never flipped and `BuildUpdate` re-fired
+ * on every test/hook event. This test drives several events through a single
+ * reporter instance and asserts `BuildUpdate` is uploaded at most once.
+ *
+ * Pre-fix this test FAILS (one BuildUpdate per event); post-fix it PASSES.
+ */
+
+const chai = require('chai');
+const chaiAsPromised = require('chai-as-promised');
+const sinon = require('sinon');
+const proxyquire = require('proxyquire').noCallThru();
+const { EventEmitter } = require('events');
+
+const { expect } = chai;
+chai.use(chaiAsPromised);
+
+const REPORTER_PATH = '../../../../../bin/testObservability/reporter/index.js';
+
+// Minimal Cypress/Mocha "test" object — just enough to drive sendTestRunEvent('TestRunStarted').
+function makeTest(id) {
+  return {
+    body: 'function () {}',
+    title: 'spec ' + id,
+    testAnalyticsId: 'test-' + id,
+    retryOf: null,
+    duration: 10,
+    file: 'cypress/e2e/spec.cy.js',
+    test_started_at: new Date().toISOString(),
+    started_at: new Date().toISOString(),
+    fullTitle: () => 'suite spec ' + id,
+    titlePath: () => ['suite', 'spec ' + id],
+  };
+}
+
+describe('testObservability reporter — BuildUpdate one-shot guard [SDK-6574]', () => {
+  let uploadEventData;
+  let MyReporter;
+  let savedEnv;
+
+  const buildUpdateCount = () =>
+    uploadEventData.getCalls().filter(c => c.args[0] && c.args[0].event_type === 'BuildUpdate').length;
+
+  beforeEach(() => {
+    savedEnv = { ...process.env };
+    delete process.env.observability_framework_version;
+    delete process.env.observability_integration;
+    delete process.env.observability_product;
+    process.env.REPORTER_API_PORT_NO = '0';
+
+    uploadEventData = sinon.spy(async () => ({ status: 'ok' }));
+
+    const helperStub = {
+      requireModule: (m) => require(m), // load the REAL mocha (Base/utils/Mocha) as the source expects
+      uploadEventData,
+      failureData: () => [],
+      PathHelper: class { prefixTestPath(p) { return p; } },
+      getTestEnv: () => ({ location_prefix: '' }),
+      getHookDetails: () => ['before all', 'hook'],
+      getHooksForTest: () => [],
+      mapTestHooks: () => {},
+      debug: () => {},
+      isBrowserstackInfra: () => true,
+      getHookSkippedTests: () => [],
+      getOSDetailsFromSystem: async () => ({ os: 'OSX', os_version: '13' }),
+      findGitConfig: () => null,
+      getFileSeparatorData: () => '/',
+      setCrashReportingConfigFromReporter: () => {},
+      debugOnConsole: () => {},
+    };
+
+    const fakeHttpServer = { on() { return this; }, listen() { return this; }, close() {} };
+
+    MyReporter = proxyquire(REPORTER_PATH, {
+      '../helper/helper': helperStub,
+      '../helper/constants': { IPC_EVENTS: {}, TEST_REPORTING_ANALYTICS: 'TRA', consoleHolder: console },
+      '../plugin/ipcServer': { startIPCServer: () => {} },
+      '../../testhub/utils': { shouldProcessEventForTesthub: () => true },
+      'http': { createServer: () => fakeHttpServer },
+    });
+  });
+
+  afterEach(() => {
+    sinon.restore();
+    process.env = savedEnv;
+  });
+
+  function newReporter() {
+    const runner = new EventEmitter();
+    const reporter = new MyReporter(runner, { reporterOptions: {} });
+    if (reporter.httpServer && reporter.httpServer.close) reporter.httpServer.close();
+    reporter.currentCypressVersion = '13.6.0'; // framework version known (arrives via IPC in prod)
+    return reporter;
+  }
+
+  it('sends BuildUpdate exactly once across many test events (regression: was once-per-event)', async () => {
+    const reporter = newReporter();
+    for (let i = 0; i < 5; i++) {
+      await reporter.sendTestRunEvent(makeTest(i), undefined, false, 'TestRunStarted');
+    }
+    expect(buildUpdateCount()).to.equal(1);
+    expect(reporter.haveSentBuildUpdate).to.equal(true);
+  });
+
+  it('does not send BuildUpdate until the framework version is known', async () => {
+    const reporter = newReporter();
+    reporter.currentCypressVersion = undefined; // no version yet, no env override
+    await reporter.sendTestRunEvent(makeTest('x'), undefined, false, 'TestRunStarted');
+    expect(buildUpdateCount()).to.equal(0);
+    expect(reporter.haveSentBuildUpdate).to.equal(false);
+  });
+});