SCAL-236431 corrected related tests

Author: shivam-kumar-ts

src/embed/events.spec.ts

@@ -272,15 +272,18 @@ describe('test communication between host app and ThoughtSpot', () => {
         });
 
         await executeAfterWait(() => {
-            expect(spy).toHaveBeenCalledTimes(3);
+            expect(spy).toHaveBeenCalledTimes(4);
             expect(spy.mock.calls[0][0]).toMatchObject({
-                type: EmbedEvent.Init,
+                type: EmbedEvent.InitStateChange,
             });
             expect(spy.mock.calls[1][0]).toMatchObject({
+                type: EmbedEvent.Init,
+            });
+            expect(spy.mock.calls[2][0]).toMatchObject({
                 type: EmbedEvent.CustomAction,
                 data: PAYLOAD,
             });
-            expect(spy.mock.calls[2][0]).toMatchObject({
+            expect(spy.mock.calls[3][0]).toMatchObject({
                 type: EmbedEvent.DialogOpen,
             });
         }, EVENT_WAIT_TIME);

src/embed/ts-embed.spec.ts

@@ -1926,7 +1926,8 @@ describe('Unit test case for ts embed', () => {
         let mockReject: (error: any) => void;
 
         beforeEach(() => {
-            mockInitPromise = new Promise<void>((resolve) => {
+            mockInitPromise = new Promise<void>((resolve , reject) => {
+                mockReject = (error: any) => reject(error);
                 mockResolve = () => resolve();
             });
 
@@ -1963,6 +1964,7 @@ describe('Unit test case for ts embed', () => {
             // Extract just the first argument (the data)
             const [callData] = initStateChangeCallback.mock.calls[0];
             expect(callData).toEqual({
+                type: EmbedEvent.InitStateChange,
                 state: InitState.Ready,
                 previousState: InitState.Initializing,
                 timestamp: expect.any(Number),
@@ -1971,6 +1973,35 @@ describe('Unit test case for ts embed', () => {
             // waitForInit should resolve
             await expect(tsEmbed.waitForInit()).resolves.toBeUndefined();
         });
+
+        test('Should wait for initialization in renderIFrame when not ready', async () => {
+            tsEmbed = new SearchEmbed(getRootEl(), {});
+            const renderPromise = tsEmbed['renderIFrame']('http://test-url');
+            let renderCompleted = false;
+            renderPromise.then(() => { renderCompleted = true; });
+            expect(renderCompleted).toBe(false);
+            await new Promise(resolve => setTimeout(resolve, 0));
+            mockResolve();
+            await mockInitPromise;
+            await renderPromise;
+            expect(renderCompleted).toBe(true);
+        });
+
+        test('Should wait for initialization in ensureInitialized when not ready', async () => {
+            tsEmbed = new SearchEmbed(getRootEl(), {});
+            const ensurePromise = tsEmbed['ensureInitialized']();
+            let ensureCompleted = false;
+            ensurePromise.then(() => { ensureCompleted = true; });
+            expect(ensureCompleted).toBe(false);
+        });
+
+        test('Should wait for initialization in waitForInit when not ready', async () => {
+            tsEmbed = new SearchEmbed(getRootEl(), {});
+            const waitForInitPromise = tsEmbed.waitForInit();
+            let waitForInitCompleted = false;
+            waitForInitPromise.then(() => { waitForInitCompleted = true; });
+            expect(waitForInitCompleted).toBe(false);
+        });
     });
 
     describe('V1Embed ', () => {

src/embed/ts-embed.ts

@@ -202,6 +202,11 @@ export class TsEmbed {
     */
     private initPromiseResolve: () => void;
 
+    /**
+    * Reject function for the init promise
+    */
+    private initPromiseReject: (error: any) => void;
+
     /**
      * Sets the initialization state and emits events
      */
@@ -210,6 +215,7 @@ export class TsEmbed {
         this.initState = newState;
 
         this.executeCallbacks(EmbedEvent.InitStateChange, {
+            type: EmbedEvent.InitStateChange,
             state: newState,
             previousState,
             timestamp: Date.now(),
@@ -262,8 +268,9 @@ export class TsEmbed {
 
         this.hostEventClient = new HostEventClient(this.iFrame);
 
-        this.initPromise = new Promise((resolve) => {
+        this.initPromise = new Promise((resolve , reject) => {
             this.initPromiseResolve = resolve;
+            this.initPromiseReject = reject;
         });
         this.setInitState(InitState.Initializing);
 
@@ -275,6 +282,8 @@ export class TsEmbed {
             this.thoughtSpotV2Base = getV2BasePath(embedConfig);
             this.shouldEncodeUrlQueryParams = embedConfig.shouldEncodeUrlQueryParams;
             this.setInitState(InitState.Ready);
+        }).catch((error) => {
+            this.initPromiseReject(error);
         });
     }
 
@@ -876,7 +885,7 @@ export class TsEmbed {
         try {
             await this.ensureInitialized();
         } catch (error) {
-            this.handleError('Cannot render: initialization failed');
+            this.handleError(ERROR_MESSAGE.EMBED_INITIALIZATION_FAILED);
             return null;
         }
         if (url.length > URL_MAX_LENGTH) {

src/types.ts

@@ -5895,6 +5895,7 @@ export enum LogLevel {
  * NotStarted = 'not-started'
  * Initializing = 'initializing'
  * Ready = 'ready'
+ * Error = 'error'
  * ```
  */
 export enum InitState {
@@ -5910,6 +5911,10 @@ export enum InitState {
      * SDK initialization completed successfully
      */
     Ready = 'ready',
+    /**
+     * SDK initialization failed
+     */
+    Error = 'error',
 }
 
 export interface DefaultAppInitData {