clean up tests

Author: StarbirdTech

test/unit/3p/test-ampcontext-integration.js

@@ -1,4 +1,4 @@
-import {masterSelection} from '#3p/ampcontext-integration';
+import {IntegrationAmpContext, masterSelection} from '#3p/ampcontext-integration';
 
 describes.fakeWin('#masterSelect', {}, (env) => {
   it('should allow sharing between configured networks', () =>
@@ -11,54 +11,48 @@ describes.sandboxed('IntegrationAmpContext aliases', {}, (env) => {
   let context;
 
   beforeEach(() => {
-    // Create a minimal context object that implements the needed methods
-    context = {
-      master_: env.sandbox.stub().returns('master-window'),
-      isMaster_: env.sandbox.stub().returns(true),
-      computeInMasterFrame: env.sandbox.stub(),
-    };
-
-    // Apply the getters from IntegrationAmpContext prototype
-    Object.defineProperty(context, 'coordinator', {
-      get() {
-        return this.master_();
-      },
-    });
-    Object.defineProperty(context, 'isCoordinator', {
-      get() {
-        return this.isMaster_();
-      },
-    });
-    context.computeInCoordinatingFrame = function (global, taskId, work, cb) {
-      return this.computeInMasterFrame(global, taskId, work, cb);
-    };
+    context = Object.create(IntegrationAmpContext.prototype);
+    context.master_ = env.sandbox.stub().returns('test-master-window');
+    context.isMaster_ = env.sandbox.stub().returns(true);
+    context.computeInMasterFrame = env.sandbox.stub();
   });
 
   it('should delegate coordinator to master', () => {
     const result = context.coordinator;
+    
     expect(context.master_).to.have.been.calledOnce;
-    expect(result).to.equal('master-window');
+    expect(result).to.equal('test-master-window');
   });
 
   it('should delegate isCoordinator to isMaster', () => {
     const result = context.isCoordinator;
+    
     expect(context.isMaster_).to.have.been.calledOnce;
     expect(result).to.equal(true);
   });
 
-  it('should delegate computeInCoordinatingFrame to computeInMasterFrame', () => {
-    const global = {test: 'global'};
+  it('should execute computeInCoordinatingFrame method', () => {
+    const masterWindow = {__ampMasterTasks: {}};
+    const global = {
+      context: {
+        master: masterWindow,
+        isMaster: true,
+      },
+    };
     const taskId = 'test-task';
-    const work = () => {};
-    const cb = () => {};
+    let workCalled = false;
+    const work = (done) => {
+      workCalled = true;
+      done('result');
+    };
+    let callbackResult;
+    const cb = (result) => {
+      callbackResult = result;
+    };
 
     context.computeInCoordinatingFrame(global, taskId, work, cb);
 
-    expect(context.computeInMasterFrame).to.have.been.calledOnceWith(
-      global,
-      taskId,
-      work,
-      cb
-    );
+    expect(workCalled).to.be.true;
+    expect(callbackResult).to.equal('result');
   });
 });