shifted for limitations

Author: Elaina-Lee

apps/vs-code-react/src/app/designer/DesignerCommandBar/__test__/indexV2.test.tsx

@@ -294,5 +294,95 @@ describe('DesignerCommandBar (V2)', () => {
       fireEvent.click(screen.getByLabelText('More actions'));
       expect(screen.getByText('File a bug')).toBeDefined();
     });
+
+    it('should show "Create unit test from run" when isLocal', () => {
+      renderCommandBar({ isLocal: true });
+      fireEvent.click(screen.getByLabelText('More actions'));
+      expect(screen.getByText('Create unit test from run')).toBeDefined();
+    });
+
+    it('should show unit test items when isUnitTest', () => {
+      renderCommandBar({ isUnitTest: true });
+      fireEvent.click(screen.getByLabelText('More actions'));
+      expect(screen.getByText('Save unit test')).toBeDefined();
+      expect(screen.getByText('Create unit test')).toBeDefined();
+      expect(screen.getByText('Assertions')).toBeDefined();
+    });
+
+    it('should show panel items (Parameters, Connections, Errors)', () => {
+      renderCommandBar();
+      fireEvent.click(screen.getByLabelText('More actions'));
+      expect(screen.getByText('Parameters')).toBeDefined();
+      expect(screen.getByText('Connections')).toBeDefined();
+      expect(screen.getByText('Errors')).toBeDefined();
+    });
+  });
+
+  describe('Save button click handlers', () => {
+    it('should trigger save when Publish is clicked in designer view', () => {
+      mockDesignerIsDirty.current = true;
+      renderCommandBar({ isDraftMode: true, hasDraft: true, isDesignerView: true });
+      const publishBtn = screen.getByText('Publish').closest('button')!;
+      fireEvent.click(publishBtn);
+      // The mutation should have been called (useMutation mock calls the fn)
+    });
+
+    it('should trigger code save when Publish is clicked in code view', () => {
+      mockDesignerIsDirty.current = true;
+      renderCommandBar({ isDraftMode: true, hasDraft: true, isDesignerView: false, isCodeView: true });
+      const publishBtn = screen.getByText('Publish').closest('button')!;
+      fireEvent.click(publishBtn);
+      // The code save mutation should have been called
+    });
+  });
+
+  describe('Discard button in non-draft mode', () => {
+    it('should disable simple discard when not dirty', () => {
+      mockDesignerIsDirty.current = false;
+      renderCommandBar({ hasDraft: false });
+      const discardBtn = screen.getByLabelText('Discard');
+      expect(discardBtn.closest('button')?.disabled).toBe(true);
+    });
+
+    it('should disable simple discard in monitoring view', () => {
+      renderCommandBar({ hasDraft: false, isMonitoringView: true });
+      const discardBtn = screen.getByLabelText('Discard');
+      expect(discardBtn.closest('button')?.disabled).toBe(true);
+    });
+
+    it('should call discard when simple discard button is clicked', () => {
+      mockDesignerIsDirty.current = true;
+      const discard = vi.fn();
+      renderCommandBar({ hasDraft: false, discard });
+      fireEvent.click(screen.getByLabelText('Discard'));
+      expect(discard).toHaveBeenCalled();
+    });
+  });
+
+  describe('Draft save notification with saved time', () => {
+    it('should show autosaved time when lastDraftSaveTime is set', () => {
+      const recentTime = Date.now() - 5000; // 5 seconds ago
+      renderCommandBar({ isDraftMode: true, lastDraftSaveTime: recentTime, isDesignerView: true });
+      expect(screen.getByText('Autosaved seconds ago')).toBeDefined();
+    });
+
+    it('should show notification in code view too', () => {
+      renderCommandBar({ isDraftMode: true, isDraftSaving: true, isDesignerView: false, isCodeView: true });
+      expect(screen.getByText('Saving...')).toBeDefined();
+    });
+
+    it('should not show notification in monitoring view', () => {
+      renderCommandBar({ isDraftMode: true, lastDraftSaveTime: Date.now(), isMonitoringView: true, isDesignerView: false });
+      expect(screen.queryByText('Autosaved seconds ago')).toBeNull();
+    });
+  });
+
+  describe('View mode tab active states', () => {
+    it('should call switchToDesignerView when Workflow tab is clicked', () => {
+      const switchToDesignerView = vi.fn();
+      renderCommandBar({ switchToDesignerView, isDesignerView: false, isCodeView: true });
+      fireEvent.click(screen.getByText('Workflow'));
+      expect(switchToDesignerView).toHaveBeenCalled();
+    });
   });
 });

apps/vs-code-react/src/app/designer/__test__/appV2.test.tsx

@@ -332,4 +332,198 @@ describe('DesignerApp (V2)', () => {
 
     expect(mockPostMessage).toHaveBeenCalledWith({ command: 'discardDraft' });
   });
+
+  it('should dispatch setDraftSaving and update draft artifacts when saveDraftWorkflow is called', () => {
+    const store = createTestStore({ isDraftMode: true });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    const definition = { triggers: {}, actions: { a1: { type: 'Http' } } };
+    const params = { p: { type: 'String' } };
+    const conns = { c: { api: { id: '/test' } } };
+    capturedCommandBarProps.saveDraftWorkflow(definition, params, conns);
+
+    // Verify Redux state was updated
+    const state = store.getState().designer;
+    expect(state.isDraftSaving).toBe(true);
+    expect(state.draftWorkflow).toEqual(definition);
+    expect(state.draftConnections).toEqual(conns);
+    expect(state.draftParameters).toEqual(params);
+  });
+
+  it('should clear draft state after discardDraft', () => {
+    const store = createTestStore({
+      isDraftMode: true,
+      hasDraft: true,
+      draftWorkflow: mockWorkflowDefinition,
+    });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    capturedCommandBarProps.discardDraft();
+
+    const state = store.getState().designer;
+    expect(state.hasDraft).toBe(false);
+    expect(state.draftWorkflow).toBeNull();
+    expect(state.draftConnections).toBeNull();
+    expect(state.draftParameters).toBeNull();
+  });
+
+  it('should dispatch setDraftMode when switchWorkflowMode is called with false', () => {
+    const store = createTestStore({
+      isDraftMode: true,
+      hasDraft: true,
+      draftWorkflow: mockDraftDefinition,
+    });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    capturedCommandBarProps.switchWorkflowMode(false);
+
+    const state = store.getState().designer;
+    expect(state.isDraftMode).toBe(false);
+  });
+
+  it('should dispatch setDraftMode when switchWorkflowMode is called with true', () => {
+    const store = createTestStore({
+      isDraftMode: false,
+      hasDraft: true,
+      draftWorkflow: mockDraftDefinition,
+    });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    capturedCommandBarProps.switchWorkflowMode(true);
+
+    const state = store.getState().designer;
+    expect(state.isDraftMode).toBe(true);
+  });
+
+  it('should pass isMonitoringView to DesignerCommandBar', () => {
+    const store = createTestStore({ isMonitoringView: true });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    expect(capturedCommandBarProps.isMonitoringView).toBe(true);
+  });
+
+  it('should pass isUnitTest and isLocal to DesignerCommandBar', () => {
+    const store = createTestStore({ isUnitTest: true, isLocal: false });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    expect(capturedCommandBarProps.isUnitTest).toBe(true);
+    expect(capturedCommandBarProps.isLocal).toBe(false);
+  });
+
+  it('should render floating run button', () => {
+    const store = createTestStore();
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+    expect(screen.getByTestId('floating-run-button')).toBeDefined();
+  });
+
+  it('should use published connections when hasDraft but draftConnections is null', () => {
+    const store = createTestStore({
+      isDraftMode: true,
+      hasDraft: true,
+      draftConnections: null,
+    });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    // Falls through to published since draftConnections is null
+    expect(mockConvertConnectionsDataToReferences).toHaveBeenCalled();
+  });
+
+  it('should use published parameters when hasDraft but draftParameters is null', () => {
+    const store = createTestStore({
+      isDraftMode: true,
+      hasDraft: true,
+      draftParameters: null,
+    });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    const provider = screen.getByTestId('bjs-workflow-provider');
+    const workflowData = JSON.parse(provider.getAttribute('data-workflow') || '{}');
+    expect(workflowData.parameters).toEqual({ publishedParam: { type: 'String', value: 'pub' } });
+  });
+
+  it('should pass saveWorkflow and discard callbacks to command bar', () => {
+    const store = createTestStore();
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    expect(typeof capturedCommandBarProps.saveWorkflow).toBe('function');
+    expect(typeof capturedCommandBarProps.saveWorkflowFromCode).toBe('function');
+    expect(typeof capturedCommandBarProps.discard).toBe('function');
+    expect(typeof capturedCommandBarProps.switchToDesignerView).toBe('function');
+    expect(typeof capturedCommandBarProps.switchToCodeView).toBe('function');
+    expect(typeof capturedCommandBarProps.switchToMonitoringView).toBe('function');
+  });
+
+  it('should post save command and clear draft when saveWorkflow is called', async () => {
+    const store = createTestStore({
+      isDraftMode: true,
+      hasDraft: true,
+      draftWorkflow: mockWorkflowDefinition,
+    });
+    render(
+      <Provider store={store}>
+        <DesignerApp />
+      </Provider>
+    );
+
+    const workflow = {
+      definition: { triggers: {}, actions: {} },
+      parameters: { p: { type: 'String' } },
+      connectionReferences: { c: { api: { id: '/test' } } },
+    };
+    const clearDirtyState = vi.fn();
+    await capturedCommandBarProps.saveWorkflow(workflow, undefined, clearDirtyState);
+
+    expect(mockPostMessage).toHaveBeenCalledWith({
+      command: 'save',
+      definition: workflow.definition,
+      parameters: workflow.parameters,
+      connectionReferences: workflow.connectionReferences,
+      customCodeData: undefined,
+    });
+    expect(clearDirtyState).toHaveBeenCalled();
+    // Draft state should be cleared
+    const state = store.getState().designer;
+    expect(state.hasDraft).toBe(false);
+    expect(state.draftWorkflow).toBeNull();
+  });
 });

apps/vs-code-react/vitest.config.ts

@@ -11,7 +11,7 @@ export default defineProject({
     coverage: {
       enabled: true,
       provider: 'istanbul',
-      include: ['src/app/**/*', 'src/state/**/*'],
+      include: ['src/app/**/*', 'src/state/**/*', 'src/intl/**/*'],
       reporter: ['html', 'cobertura', 'lcov'],
     },
     restoreMocks: true,