From e3bce4c2372801956a27f0215b37168f6b2358e8 Mon Sep 17 00:00:00 2001
From: vanessa <vanessascherma@gmail.com>
Date: Tue, 10 Sep 2024 15:42:52 +0200
Subject: [PATCH] Add unit tests

---
 .../src/components/asset/StartStopButton.tsx  |   2 +-
 .../unit/components/asset/AssetBoard.test.tsx |  58 +++++
 .../unit/components/asset/AssetCard.test.tsx  |  53 ++++
 .../unit/components/asset/LogButton.test.tsx  |  39 +++
 .../components/asset/StartStopButton.test.tsx | 172 +++++++++++++
 .../digitaltwins/DigitalTwinsPreview.test.tsx | 104 ++++++++
 .../digitaltwins/ExecutionFunctions.test.ts   | 170 +++++++++++++
 .../routes/digitaltwins/LogDialog.test.tsx    |  80 ++++++
 .../routes/digitaltwins/Snackbar.test.tsx     |  74 ++++++
 client/test/unit/unit.testUtil.tsx            |  45 +++-
 client/test/unitTests/Util/gitlab.test.ts     | 151 ++++++++---
 .../unitTests/Util/gitlabDigitalTwin.test.ts  | 234 ++++++++++--------
 12 files changed, 1035 insertions(+), 147 deletions(-)
 create mode 100644 client/test/unit/components/asset/AssetBoard.test.tsx
 create mode 100644 client/test/unit/components/asset/AssetCard.test.tsx
 create mode 100644 client/test/unit/components/asset/LogButton.test.tsx
 create mode 100644 client/test/unit/components/asset/StartStopButton.test.tsx
 create mode 100644 client/test/unit/routes/digitaltwins/DigitalTwinsPreview.test.tsx
 create mode 100644 client/test/unit/routes/digitaltwins/ExecutionFunctions.test.ts
 create mode 100644 client/test/unit/routes/digitaltwins/LogDialog.test.tsx
 create mode 100644 client/test/unit/routes/digitaltwins/Snackbar.test.tsx

diff --git a/client/src/components/asset/StartStopButton.tsx b/client/src/components/asset/StartStopButton.tsx
index b8abbbe12..8055886c1 100644
--- a/client/src/components/asset/StartStopButton.tsx
+++ b/client/src/components/asset/StartStopButton.tsx
@@ -33,7 +33,7 @@ function StartStopButton({
   return (
     <>
       {digitalTwin?.pipelineLoading ? (
-        <CircularProgress size={22} style={{ marginRight: '8px' }} />
+        <CircularProgress size={22} style={{ marginRight: '8px' }} data-testid="circular-progress"/>
       ) : null}{' '}
       <Button
         variant="contained"
diff --git a/client/test/unit/components/asset/AssetBoard.test.tsx b/client/test/unit/components/asset/AssetBoard.test.tsx
new file mode 100644
index 000000000..1c1e055ee
--- /dev/null
+++ b/client/test/unit/components/asset/AssetBoard.test.tsx
@@ -0,0 +1,58 @@
+import * as React from 'react';
+import { render, screen } from '@testing-library/react';
+import AssetBoard from 'components/asset/AssetBoard';
+import { Asset } from 'components/asset/Asset';
+import { GitlabInstance } from 'util/gitlab';
+import '@testing-library/jest-dom';
+import store from 'store/store';
+import { Provider } from 'react-redux';
+
+jest.unmock('components/asset/AssetBoard');
+
+jest.mock('react-redux', () => ({
+  ...jest.requireActual('react-redux'),
+}));
+
+jest.mock('util/envUtil', () => ({
+  ...jest.requireActual('util/envUtil'),
+  getAuthority: jest.fn(() => 'https://example.com'),
+}));
+
+jest.mock('')
+
+const assetsMock: Asset[] = [
+  { name: 'Asset1', path: 'path1', description: 'Description1' },
+  { name: 'Asset2', path: 'path2', description: 'Description2' },
+];
+
+jest.mock('util/gitlab', () => ({
+  GitlabInstance: jest.fn().mockImplementation(() => ({
+    init: jest.fn(),
+  })),
+}));
+
+const mockGitlabInstance = new GitlabInstance('username', 'authority', 'access_token');
+
+describe('AssetBoard', () => {
+  it('renders AssetCard components for each asset', () => {
+    render(
+    <Provider store={store}>
+    <AssetBoard subfolders={assetsMock} gitlabInstance={mockGitlabInstance} error={null} />);
+    </Provider>
+    );
+    const cards = screen.getAllByText(/Description/);
+    expect(cards).toHaveLength(assetsMock.length);
+  });
+
+  it('displays an error message when error prop is provided', () => {
+    const errorMessage = 'Something went wrong!';
+    render(<AssetBoard subfolders={[]} gitlabInstance={mockGitlabInstance} error={errorMessage} />);
+    expect(screen.getByText(errorMessage)).toBeInTheDocument();
+  });
+
+  it('renders correctly with no assets', () => {
+    render(<AssetBoard subfolders={[]} gitlabInstance={mockGitlabInstance} error={null} />);
+    const cards = screen.queryAllByText(/Description/);
+    expect(cards).toHaveLength(0);
+  });
+});
\ No newline at end of file
diff --git a/client/test/unit/components/asset/AssetCard.test.tsx b/client/test/unit/components/asset/AssetCard.test.tsx
new file mode 100644
index 000000000..e302175c1
--- /dev/null
+++ b/client/test/unit/components/asset/AssetCard.test.tsx
@@ -0,0 +1,53 @@
+import * as React from 'react';
+import { render, screen } from '@testing-library/react';
+import AssetCardExecute from 'components/asset/AssetCard';
+import { Provider } from 'react-redux';
+import store from 'store/store';
+import '@testing-library/jest-dom';
+
+if (!AbortSignal.timeout) {
+  AbortSignal.timeout = (ms) => {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(new DOMException('TimeoutError')), ms);
+    return controller.signal;
+  };
+}
+
+jest.deepUnmock('components/asset/AssetCard');
+
+jest.mock('react-redux', () => ({
+  ...jest.requireActual('react-redux'),
+}));
+
+jest.mock('react-oidc-context', () => ({
+  ...jest.requireActual('react-oidc-context'),
+  useAuth: jest.fn(),
+}));
+
+jest.mock('util/envUtil', () => ({
+  ...jest.requireActual('util/envUtil'),
+  getAuthority: jest.fn(() => 'https://example.com'),
+}));
+
+jest.mock('')
+
+
+describe('AssetCard', () => {
+  const assetMock = {
+    name: 'TestName',
+    path: 'testPath',
+    description: 'testDescription',
+  };
+
+  beforeEach(() => {
+    render(
+      <Provider store={store}>
+        <AssetCardExecute asset={assetMock} />);
+      </Provider>  
+    );
+  });
+
+  it('renders asset name correctly', () => {
+    expect(screen.getByText(assetMock.name)).toBeInTheDocument();
+  });
+});
\ No newline at end of file
diff --git a/client/test/unit/components/asset/LogButton.test.tsx b/client/test/unit/components/asset/LogButton.test.tsx
new file mode 100644
index 000000000..0db156be5
--- /dev/null
+++ b/client/test/unit/components/asset/LogButton.test.tsx
@@ -0,0 +1,39 @@
+import * as React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import LogButton from 'components/asset/LogButton';
+
+const mockSetShowLog = jest.fn();
+
+describe('LogButton', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('calls setShowLog with the correct value when clicked', () => {
+    render(
+      <LogButton setShowLog={mockSetShowLog} logButtonDisabled={false} />
+    );
+
+    fireEvent.click(screen.getByText('Log'));
+
+    expect(mockSetShowLog).toHaveBeenCalledTimes(1);
+    expect(mockSetShowLog).toHaveBeenCalledWith(expect.any(Function));
+    
+    const toggleFunction = mockSetShowLog.mock.calls[0][0];
+    expect(toggleFunction(true)).toBe(false);
+  });
+
+  it('disables button when logButtonDisabled is true', () => {
+    render(<LogButton setShowLog={mockSetShowLog} logButtonDisabled={true} />);
+
+    const button = screen.getByText('Log') as HTMLButtonElement;
+    expect(button.disabled).toBe(true);
+  });
+
+  it('enables button when logButtonDisabled is false', () => {
+    render(<LogButton setShowLog={mockSetShowLog} logButtonDisabled={false} />);
+
+    const button = screen.getByText('Log') as HTMLButtonElement;
+    expect(button.disabled).toBe(false);
+  });
+});
\ No newline at end of file
diff --git a/client/test/unit/components/asset/StartStopButton.test.tsx b/client/test/unit/components/asset/StartStopButton.test.tsx
new file mode 100644
index 000000000..a1561fbe7
--- /dev/null
+++ b/client/test/unit/components/asset/StartStopButton.test.tsx
@@ -0,0 +1,172 @@
+import * as React from 'react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import StartStopButton from 'components/asset/StartStopButton';
+import { handleButtonClick } from 'route/digitaltwins/ExecutionFunctions';
+import { useSelector, useDispatch } from 'react-redux';
+import { RootState } from 'store/store';
+import '@testing-library/jest-dom';
+
+jest.mock('route/digitaltwins/ExecutionFunctions', () => ({
+  handleButtonClick: jest.fn(),
+}));
+
+jest.mock('react-redux', () => ({
+  useSelector: jest.fn(),
+  useDispatch: jest.fn(),
+}));
+
+const mockSetSnackbarOpen = jest.fn();
+const mockSetSnackbarMessage = jest.fn();
+const mockSetSnackbarSeverity = jest.fn();
+const mockSetLogButtonDisabled = jest.fn();
+const mockDispatch = jest.fn();
+const mockHandleButtonClick = handleButtonClick as jest.MockedFunction<typeof handleButtonClick>;
+
+describe('StartStopButton', () => {
+  beforeEach(() => {
+    (useSelector as jest.Mock).mockImplementation((selector) =>
+      selector({
+        digitalTwin: {
+          'testAsset': { DTName: 'Test Digital Twin', pipelineLoading: false },
+        },
+      } as unknown as RootState)
+    );
+    (useDispatch as jest.Mock).mockReturnValue(mockDispatch);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('renders with start button text initially', () => {
+    render(
+      <StartStopButton
+        assetName="testAsset"
+        setSnackbarOpen={mockSetSnackbarOpen}
+        setSnackbarMessage={mockSetSnackbarMessage}
+        setSnackbarSeverity={mockSetSnackbarSeverity}
+        setLogButtonDisabled={mockSetLogButtonDisabled}
+      />
+    );
+
+    expect(screen.getByText('Start')).toBeInTheDocument();
+  });
+
+  test('renders circular progress when pipelineLoading is true', async () => {
+    (useSelector as jest.Mock).mockImplementationOnce((selector) =>
+      selector({
+        digitalTwin: {
+          'testAsset': { DTName: 'Test Digital Twin', pipelineLoading: true },
+        },
+      } as unknown as RootState)
+    );
+
+    render(
+      <StartStopButton
+        assetName="testAsset"
+        setSnackbarOpen={mockSetSnackbarOpen}
+        setSnackbarMessage={mockSetSnackbarMessage}
+        setSnackbarSeverity={mockSetSnackbarSeverity}
+        setLogButtonDisabled={mockSetLogButtonDisabled}
+      />
+    );
+
+    expect(screen.getByTestId('circular-progress')).toBeInTheDocument();
+
+    expect(screen.getByText('Start')).toBeInTheDocument();
+  });
+
+  test('does not render circular progress when pipelineLoading is false', () => {
+    render(
+      <StartStopButton
+        assetName="testAsset"
+        setSnackbarOpen={mockSetSnackbarOpen}
+        setSnackbarMessage={mockSetSnackbarMessage}
+        setSnackbarSeverity={mockSetSnackbarSeverity}
+        setLogButtonDisabled={mockSetLogButtonDisabled}
+      />
+    );
+
+    expect(screen.queryByTestId('circular-progress')).not.toBeInTheDocument();
+
+    expect(screen.getByText('Start')).toBeInTheDocument();
+  });
+
+  test('calls handleButtonClick with correct arguments when button is clicked', () => {
+    render(
+      <StartStopButton
+        assetName="testAsset"
+        setSnackbarOpen={mockSetSnackbarOpen}
+        setSnackbarMessage={mockSetSnackbarMessage}
+        setSnackbarSeverity={mockSetSnackbarSeverity}
+        setLogButtonDisabled={mockSetLogButtonDisabled}
+      />
+    );
+
+    fireEvent.click(screen.getByText('Start'));
+
+    expect(mockHandleButtonClick).toHaveBeenCalledTimes(1);
+    expect(mockHandleButtonClick).toHaveBeenCalledWith(
+      'Start',
+      expect.any(Function),
+      { DTName: 'Test Digital Twin', pipelineLoading: false },
+      mockSetSnackbarMessage,
+      mockSetSnackbarSeverity,
+      mockSetSnackbarOpen,
+      mockSetLogButtonDisabled,
+      mockDispatch,
+    );
+  });
+
+  test('updates snackbar message and severity on execution status change', async () => {
+    mockHandleButtonClick.mockImplementationOnce((buttonText, setButtonText, digitalTwin, setSnackbarMessage, setSnackbarSeverity, setSnackbarOpen, setLogButtonDisabled, dispatch) => {
+      setSnackbarMessage('Execution started successfully');
+      setSnackbarSeverity('success');
+      setSnackbarOpen(true);
+    });
+
+    render(
+      <StartStopButton
+        assetName="testAsset"
+        setSnackbarOpen={mockSetSnackbarOpen}
+        setSnackbarMessage={mockSetSnackbarMessage}
+        setSnackbarSeverity={mockSetSnackbarSeverity}
+        setLogButtonDisabled={mockSetLogButtonDisabled}
+      />
+    );
+
+    fireEvent.click(screen.getByText('Start'));
+
+    await waitFor(() => {
+      expect(mockSetSnackbarMessage).toHaveBeenCalledWith('Execution started successfully');
+      expect(mockSetSnackbarSeverity).toHaveBeenCalledWith('success');
+      expect(mockSetSnackbarOpen).toHaveBeenCalledWith(true);
+    });
+  });
+
+  test('updates snackbar message and severity on execution status change to error', async () => {
+    mockHandleButtonClick.mockImplementationOnce((buttonText, setButtonText, digitalTwin, setSnackbarMessage, setSnackbarSeverity, setSnackbarOpen, setLogButtonDisabled, dispatch) => {
+      setSnackbarMessage('Execution failed');
+      setSnackbarSeverity('error');
+      setSnackbarOpen(true);
+    });
+
+    render(
+      <StartStopButton
+        assetName="testAsset"
+        setSnackbarOpen={mockSetSnackbarOpen}
+        setSnackbarMessage={mockSetSnackbarMessage}
+        setSnackbarSeverity={mockSetSnackbarSeverity}
+        setLogButtonDisabled={mockSetLogButtonDisabled}
+      />
+    );
+
+    fireEvent.click(screen.getByText('Start'));
+
+    await waitFor(() => {
+      expect(mockSetSnackbarMessage).toHaveBeenCalledWith('Execution failed');
+      expect(mockSetSnackbarSeverity).toHaveBeenCalledWith('error');
+      expect(mockSetSnackbarOpen).toHaveBeenCalledWith(true);
+    });
+  });
+});
diff --git a/client/test/unit/routes/digitaltwins/DigitalTwinsPreview.test.tsx b/client/test/unit/routes/digitaltwins/DigitalTwinsPreview.test.tsx
new file mode 100644
index 000000000..95cb8a052
--- /dev/null
+++ b/client/test/unit/routes/digitaltwins/DigitalTwinsPreview.test.tsx
@@ -0,0 +1,104 @@
+import * as React from 'react';
+import DigitalTwinsPreview, { fetchSubfolders } from 'route/digitaltwins/DigitalTwinsPreview';
+import tabs from 'route/digitaltwins/DigitalTwinTabData';
+import {
+  InitRouteTests,
+  itDisplaysContentOfExecuteTab,
+  itHasCorrectExecuteTabNameInDTIframe,
+} from 'test/unit/unit.testUtil';
+import store from 'store/store';
+import { Provider } from 'react-redux';
+import { MemoryRouter } from 'react-router-dom';
+import '@testing-library/jest-dom';
+import { GitlabInstance } from 'util/gitlab';
+import { renderHook, act } from '@testing-library/react';
+import { Asset } from 'components/asset/Asset';
+
+jest.mock('react-oidc-context', () => ({
+  ...jest.requireActual('react-oidc-context'),
+  useAuth: jest.fn(),
+}));
+
+jest.mock('util/gitlab', () => ({
+  GitlabInstance: jest.fn().mockImplementation(() => ({
+    init: jest.fn(),
+    getDTSubfolders: jest.fn().mockResolvedValue([]),
+    projectId: 'mockedProjectId',
+  })),
+}));
+
+jest.mock('util/envUtil', () => ({
+  getAuthority: jest.fn(() => 'https://example.com'),
+}));
+
+describe('Digital Twins Preview', () => {
+  const tabLabels: string[] = [];
+  tabs.forEach((tab) => tabLabels.push(tab.label));
+
+  InitRouteTests(
+    <Provider store={store}>
+      <MemoryRouter>
+        <DigitalTwinsPreview />
+      </MemoryRouter>
+    </Provider>
+  );
+
+  itDisplaysContentOfExecuteTab(tabs);
+
+  itHasCorrectExecuteTabNameInDTIframe(tabLabels);
+
+  it('should call getDTSubfolders and update subfolders state', async () => {
+    const mockGitlabInstance = new GitlabInstance('username', 'https://example.com', 'access_token');
+    const { result } = renderHook(() => React.useState<Asset[]>([]));
+    
+    const setSubfolders: React.Dispatch<React.SetStateAction<Asset[]>> = result.current[1];
+    
+    await act(async () => {
+      await fetchSubfolders(mockGitlabInstance, setSubfolders, jest.fn());
+    });
+
+    expect(mockGitlabInstance.init).toHaveBeenCalled();
+    expect(mockGitlabInstance.getDTSubfolders).toHaveBeenCalledWith('mockedProjectId');
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it('should handle empty projectId correctly', async () => {
+    const mockGitlabInstance = new GitlabInstance('username', 'https://example.com', 'access_token');
+    jest.spyOn(mockGitlabInstance, 'init').mockResolvedValue(undefined);
+    jest.spyOn(mockGitlabInstance, 'getDTSubfolders').mockResolvedValue([]);
+
+    mockGitlabInstance.projectId = null;
+
+    const { result } = renderHook(() => React.useState<Asset[]>([]));
+    
+    const setSubfolders: React.Dispatch<React.SetStateAction<Asset[]>> = result.current[1];
+    
+    await act(async () => {
+      await fetchSubfolders(mockGitlabInstance, setSubfolders, jest.fn());
+    });
+
+    expect(mockGitlabInstance.init).toHaveBeenCalled();
+    expect(mockGitlabInstance.getDTSubfolders).not.toHaveBeenCalled();
+    expect(result.current[0]).toEqual([]);
+  });
+
+  it('should handle errors correctly', async () => {
+    const mockGitlabInstance = new GitlabInstance('username', 'https://example.com', 'access_token');
+    jest.spyOn(mockGitlabInstance, 'init').mockRejectedValue(new Error('Initialization failed'));
+    
+    const { result: subfoldersResult } = renderHook(() => React.useState<Asset[]>([]));
+    const { result: errorResult } = renderHook(() => React.useState<string | null>(null));
+    
+    const setSubfolders: React.Dispatch<React.SetStateAction<Asset[]>> = subfoldersResult.current[1];
+    const setError: React.Dispatch<React.SetStateAction<string | null>> = errorResult.current[1];
+
+    await act(async () => {
+      await fetchSubfolders(mockGitlabInstance, setSubfolders, setError);
+    });
+
+    expect(mockGitlabInstance.init).toHaveBeenCalled();
+    expect(mockGitlabInstance.getDTSubfolders).not.toHaveBeenCalled();
+    expect(subfoldersResult.current[0]).toEqual([]);
+    expect(errorResult.current[0]).toBe('An error occurred');
+  });
+});
diff --git a/client/test/unit/routes/digitaltwins/ExecutionFunctions.test.ts b/client/test/unit/routes/digitaltwins/ExecutionFunctions.test.ts
new file mode 100644
index 000000000..db489b262
--- /dev/null
+++ b/client/test/unit/routes/digitaltwins/ExecutionFunctions.test.ts
@@ -0,0 +1,170 @@
+import {
+    handleButtonClick,
+    handleStop,
+    checkFirstPipelineStatus,
+    fetchJobLogs,
+    handlePipelineCompletion,
+    retryPipelineCheck,
+  } from 'route/digitaltwins/ExecutionFunctions';
+  import DigitalTwin from 'util/gitlabDigitalTwin';
+  import { GitlabInstance } from 'util/gitlab';
+  
+  jest.mock('util/gitlabDigitalTwin');
+  jest.mock('util/gitlab', () => ({
+    GitlabInstance: jest.fn().mockImplementation(() => ({
+      getPipelineStatus: jest.fn(),
+      getPipelineJobs: jest.fn(),
+      getJobTrace: jest.fn(),
+      stop: jest.fn(),
+    })),
+  }));
+  
+  jest.mock('strip-ansi');
+  
+  describe('ExecutionFunctions', () => {
+    let mockSetButtonText: jest.Mock;
+    let mockSetJobLogs: jest.Mock;
+    let mockSetPipelineCompleted: jest.Mock;
+    let mockSetPipelineLoading: jest.Mock;
+    let mockSetExecutionStatus: jest.Mock;
+    let mockSetExecutionCount: jest.Mock;
+    let mockSetSnackbarMessage: jest.Mock;
+    let mockSetSnackbarSeverity: jest.Mock;
+    let mockSetSnackbarOpen: jest.Mock;
+    let digitalTwin: DigitalTwin;
+    let gitlabInstance: GitlabInstance;
+  
+    beforeEach(() => {
+      mockSetButtonText = jest.fn();
+      mockSetJobLogs = jest.fn();
+      mockSetPipelineCompleted = jest.fn();
+      mockSetPipelineLoading = jest.fn();
+      mockSetExecutionStatus = jest.fn();
+      mockSetExecutionCount = jest.fn();
+      mockSetSnackbarMessage = jest.fn();
+      mockSetSnackbarSeverity = jest.fn();
+      mockSetSnackbarOpen = jest.fn();
+      gitlabInstance = new GitlabInstance('user1', 'authority', 'token1');
+      digitalTwin = new DigitalTwin('DTName', gitlabInstance);
+    });
+  
+    it('should handle button click with Start text', async () => {
+      await handleButtonClick(
+        'Start',
+        mockSetButtonText,
+        mockSetJobLogs,
+        mockSetPipelineCompleted,
+        mockSetPipelineLoading,
+        mockSetExecutionStatus,
+        mockSetExecutionCount,
+        digitalTwin,
+        mockSetSnackbarMessage,
+        mockSetSnackbarSeverity,
+        mockSetSnackbarOpen,
+        0,
+      );
+  
+      expect(mockSetButtonText).toHaveBeenCalledWith('Stop');
+      expect(mockSetJobLogs).toHaveBeenCalledWith([]);
+    });
+  
+    it('should call handleStop when buttonText is not "Start"', async () => {
+      digitalTwin.stop = jest.fn();
+  
+      await handleButtonClick(
+        'Stop',
+        mockSetButtonText,
+        mockSetJobLogs,
+        mockSetPipelineCompleted,
+        mockSetPipelineLoading,
+        mockSetExecutionStatus,
+        mockSetExecutionCount,
+        digitalTwin,
+        mockSetSnackbarMessage,
+        mockSetSnackbarSeverity,
+        mockSetSnackbarOpen,
+        1,
+      );
+  
+      expect(mockSetButtonText).toHaveBeenCalledWith('Start');
+     });
+  
+    it('should check first pipeline status', async () => {
+      gitlabInstance.projectId = 1;
+      gitlabInstance.getPipelineStatus = jest.fn().mockResolvedValue('success');
+      await checkFirstPipelineStatus(
+        gitlabInstance,
+        1,
+        mockSetJobLogs,
+        mockSetPipelineCompleted,
+        mockSetPipelineLoading,
+        mockSetButtonText,
+      );
+  
+      expect(gitlabInstance.getPipelineStatus).toHaveBeenCalledWith('user1', 1);
+      expect(mockSetPipelineCompleted).toHaveBeenCalledWith(true);
+    });
+  
+    it('should fetch job logs', async () => {
+      gitlabInstance.getPipelineJobs = jest
+        .fn()
+        .mockResolvedValue([{ id: 1, name: 'Job1' }]);
+      gitlabInstance.getJobTrace = jest.fn().mockResolvedValue('log content');
+  
+      const logs = await fetchJobLogs(gitlabInstance, 1);
+  
+      expect(gitlabInstance.getPipelineJobs).toHaveBeenCalledWith('user1', 1);
+      expect(gitlabInstance.getJobTrace).toHaveBeenCalledWith('user1', 1);
+      expect(logs).toEqual([{ jobName: 'Job1', log: 'log content' }]);
+    });
+  
+    it('should handle pipeline completion', async () => {
+      gitlabInstance.getPipelineStatus = jest.fn().mockResolvedValue('success');
+      await handlePipelineCompletion(
+        gitlabInstance,
+        2,
+        mockSetJobLogs,
+        mockSetPipelineCompleted,
+        mockSetPipelineLoading,
+        mockSetButtonText,
+      );
+  
+      expect(gitlabInstance.getPipelineStatus).toHaveBeenCalled();
+    });
+  
+    it('should retry pipeline check', () => {
+      jest.useFakeTimers();
+      retryPipelineCheck(
+        gitlabInstance,
+        1,
+        mockSetJobLogs,
+        mockSetPipelineCompleted,
+        mockSetPipelineLoading,
+        mockSetButtonText,
+      );
+      jest.advanceTimersByTime(5000);
+  
+      expect(gitlabInstance.getPipelineStatus).toHaveBeenCalled();
+    });
+  
+    it('should handle stop execution with success', async () => {
+      digitalTwin.stop = jest.fn().mockResolvedValue(true);
+  
+      await handleStop(
+        digitalTwin,
+        mockSetSnackbarMessage,
+        mockSetSnackbarSeverity,
+        mockSetSnackbarOpen,
+        0,
+        mockSetButtonText,
+        mockSetPipelineCompleted,
+        mockSetPipelineLoading,
+      );
+  
+      expect(mockSetSnackbarMessage).toHaveBeenCalledWith(
+        'DTName (Run #0) execution stopped successfully',
+      );
+      expect(mockSetSnackbarSeverity).toHaveBeenCalledWith('success');
+      expect(mockSetButtonText).toHaveBeenCalledWith('Start');
+    });
+  });
\ No newline at end of file
diff --git a/client/test/unit/routes/digitaltwins/LogDialog.test.tsx b/client/test/unit/routes/digitaltwins/LogDialog.test.tsx
new file mode 100644
index 000000000..b215d8ada
--- /dev/null
+++ b/client/test/unit/routes/digitaltwins/LogDialog.test.tsx
@@ -0,0 +1,80 @@
+import * as React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import LogDialog from 'route/digitaltwins/LogDialog';
+
+describe('LogDialog', () => {
+  it('renders the dialog with job logs', () => {
+    render(
+      <LogDialog
+        showLog={true}
+        setShowLog={jest.fn()}
+        name="Test Name"
+      />
+    );
+
+    expect(screen.getByText('Test Name - log (run #1)')).toBeInTheDocument();
+    expect(screen.getByText('Job 1')).toBeInTheDocument();
+    expect(screen.getByText('Log for Job 1')).toBeInTheDocument();
+    expect(screen.getByText('Job 2')).toBeInTheDocument();
+    expect(screen.getByText('Log for Job 2')).toBeInTheDocument();
+  });
+
+  it('renders "No logs available" when no job logs are provided', () => {
+    render(
+      <LogDialog
+        showLog={true}
+        setShowLog={jest.fn()}
+        name="Test Name"
+      />
+    );
+
+    expect(screen.getByText('No logs available')).toBeInTheDocument();
+  });
+
+  it('closes the dialog when the close button is clicked', () => {
+    const setShowLog = jest.fn();
+    render(
+      <LogDialog
+        showLog={true}
+        setShowLog={setShowLog}
+        name="Test Name"
+      />
+    );
+
+    fireEvent.click(screen.getByText('Close'));
+    expect(setShowLog).toHaveBeenCalledTimes(1);
+    expect(setShowLog).toHaveBeenCalledWith(false);
+  });
+
+  it('does not render the dialog when showLog is false', () => {
+    const { container } = render(
+      <LogDialog
+        showLog={false}
+        setShowLog={jest.fn()}
+        name="Test Name"
+      />
+    );
+
+    expect(container.querySelector('div')).toBeNull(); // No dialog should be present
+  });
+
+  it('calls handleCloseLog when dialog is closed', () => {
+    const setShowLog = jest.fn();
+    render(
+      <LogDialog
+        showLog={true}
+        setShowLog={setShowLog}
+        name="Test Name"
+      />
+    );
+
+    // Simulate dialog close event by clicking the close button
+    fireEvent.click(screen.getByText('Close'));
+    expect(setShowLog).toHaveBeenCalledWith(false);
+
+    // Simulate dialog backdrop close event (if applicable)
+    fireEvent.click(document.querySelector('[role="dialog"]')!); // Assuming clicking outside also closes
+    expect(setShowLog).toHaveBeenCalledWith(false);
+  });
+});
diff --git a/client/test/unit/routes/digitaltwins/Snackbar.test.tsx b/client/test/unit/routes/digitaltwins/Snackbar.test.tsx
new file mode 100644
index 000000000..39e31a44a
--- /dev/null
+++ b/client/test/unit/routes/digitaltwins/Snackbar.test.tsx
@@ -0,0 +1,74 @@
+import * as React from 'react';
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import CustomSnackbar from 'route/digitaltwins/Snackbar'; // Adjust the import path accordingly
+
+describe('CustomSnackbar', () => {
+  it('renders the snackbar with the correct message and severity', () => {
+    act(() => {
+      render(
+        <CustomSnackbar
+          snackbarOpen={true}
+          snackbarMessage="Test Message"
+          snackbarSeverity="success"
+          setSnackbarOpen={jest.fn()}
+        />
+      );
+    });
+
+    expect(screen.getByText('Test Message')).toBeInTheDocument();
+    expect(screen.getByRole('alert')).toHaveClass('MuiAlert-standardSuccess');
+  });
+
+  it('does not render the snackbar when snackbarOpen is false', () => {
+    const { container } = render(
+      <CustomSnackbar
+        snackbarOpen={false}
+        snackbarMessage="Test Message"
+        snackbarSeverity="success"
+        setSnackbarOpen={jest.fn()}
+      />
+    );
+
+    expect(container.querySelector('div')).toBeNull(); 
+  });
+
+  it('calls handleCloseSnackbar when the snackbar is closed through the alert button', () => {
+    const setSnackbarOpen = jest.fn();
+    act(() => {
+      render(
+        <CustomSnackbar
+          snackbarOpen={true}
+          snackbarMessage="Test Message"
+          snackbarSeverity="error"
+          setSnackbarOpen={setSnackbarOpen}
+        />
+      );
+    });
+
+    fireEvent.click(screen.getByRole('button'));
+    expect(setSnackbarOpen).toHaveBeenCalledWith(false);
+  });
+
+  it('calls handleCloseSnackbar when the snackbar is closed via auto-hide duration', () => {
+    jest.useFakeTimers(); // Mock timers
+    const setSnackbarOpen = jest.fn();
+    act(() => {
+      render(
+        <CustomSnackbar
+          snackbarOpen={true}
+          snackbarMessage="Test Message"
+          snackbarSeverity="warning"
+          setSnackbarOpen={setSnackbarOpen}
+        />
+      );
+    });
+
+    act(() => {
+      jest.runAllTimers();
+    });
+
+    expect(setSnackbarOpen).toHaveBeenCalledWith(false);
+    jest.useRealTimers();
+  });
+});
diff --git a/client/test/unit/unit.testUtil.tsx b/client/test/unit/unit.testUtil.tsx
index c2fde11ce..6620fd066 100644
--- a/client/test/unit/unit.testUtil.tsx
+++ b/client/test/unit/unit.testUtil.tsx
@@ -106,6 +106,35 @@ export function itDisplaysContentOfTabs(
   });
 }
 
+export function itDisplaysContentOfExecuteTab(tabs: { label: string; body: string }[]) {
+  const executeTab = tabs.find((tab) => tab.label === 'Execute');
+
+  if (!executeTab) return;
+
+  it('should render the label of the Execute tab', () => {
+    expect(screen.getByRole('tab', { name: executeTab.label })).toBeInTheDocument();
+  });
+
+  it('should render the content of the clicked Execute tab', () => {
+    const tabElement = screen.getByRole('tab', { name: executeTab.label });
+
+    act(() => {
+      tabElement.click();
+    });
+
+    const executeTabContent = screen.getAllByText(executeTab.body, {
+      normalizer: getDefaultNormalizer({ collapseWhitespace: false }),
+    });
+    expect(executeTabContent.length).toBeGreaterThan(0);
+
+    tabs
+      .filter((tab) => tab.label !== 'Execute')
+      .forEach((otherTab) => {
+        expect(screen.queryByText(otherTab.body)).not.toBeInTheDocument();
+      });
+  });
+}
+
 export function itPreventsDefaultActionWhenLinkIsClicked(linkText: string) {
   it(`should prevent default action when ${linkText} is clicked`, () => {
     const linkElement = screen.getByRole('link', { name: linkText });
@@ -169,6 +198,21 @@ export function itHasCorrectTabNameinDTIframe(tablabels: string[]) {
   });
 }
 
+export function itHasCorrectExecuteTabNameInDTIframe(tablabels: string[]) {
+  it("should render the Iframe component on DT page for the 'Execute' tab with the correct title", () => {
+    const executeTabLabel = tablabels.find((label) => label === 'Execute');
+
+    if (!executeTabLabel) return;
+
+    const tabElement = screen.getByRole('tab', {
+      name: executeTabLabel,
+    });
+
+    expect(tabElement).toBeTruthy();
+  });
+}
+
+
 export function testStaticAccountProfile(mockUser: mockUserType) {
   const profilePicture = screen.getByTestId('profile-picture');
   expect(profilePicture).toBeInTheDocument();
@@ -194,7 +238,6 @@ export async function testAccountSettings(mockUser: mockUserType) {
       screen.getByRole('heading', { level: 2, name: 'Settings' }),
     ).toBeInTheDocument();
 
-    // Testing that the text is present, the link is correct and in bold
     const settingsParagraph = screen.getByText(/Edit the profile on/);
     expect(settingsParagraph).toHaveProperty(
       'innerHTML',
diff --git a/client/test/unitTests/Util/gitlab.test.ts b/client/test/unitTests/Util/gitlab.test.ts
index 6e82034f5..d10e7a1f2 100644
--- a/client/test/unitTests/Util/gitlab.test.ts
+++ b/client/test/unitTests/Util/gitlab.test.ts
@@ -1,5 +1,5 @@
 import { Gitlab } from '@gitbeaker/rest';
-import GitlabInstance from 'util/gitlab';
+import { GitlabInstance } from 'util/gitlab';
 
 jest.mock('@gitbeaker/rest');
 
@@ -12,15 +12,23 @@ describe('GitlabInstance', () => {
     },
     PipelineTriggerTokens: {
       all: jest.fn(),
-      trigger: jest.fn(),
+    },
+    RepositoryFiles: {
+      show: jest.fn(),
     },
     Repositories: {
       allRepositoryTrees: jest.fn(),
     },
+    Jobs: {
+      all: jest.fn(),
+      showLog: jest.fn(),
+    },
+    Pipelines: {
+      show: jest.fn(),
+    },
   };
 
   beforeEach(() => {
-    window.sessionStorage.clear();
     jest.clearAllMocks();
 
     gitlab = new GitlabInstance(
@@ -31,76 +39,82 @@ describe('GitlabInstance', () => {
     gitlab.api = mockApi as unknown as InstanceType<typeof Gitlab>;
   });
 
-  it('should initialize the Gitlab API with the correct parameters', () => {
-    expect(Gitlab).toHaveBeenCalledWith({
-      host: 'https://gitlab.example.com',
-      oauthToken: 'test_token',
-    });
-  });
-
-  it('should fetch project ID successfully', async () => {
+  it('should initialize with a project ID and trigger token', async () => {
     mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
     mockApi.Groups.allProjects.mockResolvedValue([{ id: 1, name: 'user1' }]);
+    mockApi.PipelineTriggerTokens.all.mockResolvedValue([{ token: 'test-token' }]);
 
-    const projectId = await gitlab.getProjectId();
+    await gitlab.init();
 
-    expect(projectId).toBe(1);
+    expect(gitlab.projectId).toBe(1);
+    expect(gitlab.triggerToken).toBe('test-token');
     expect(mockApi.Groups.show).toHaveBeenCalledWith('DTaaS');
     expect(mockApi.Groups.allProjects).toHaveBeenCalledWith(1);
+    expect(mockApi.PipelineTriggerTokens.all).toHaveBeenCalledWith(1);
   });
 
-  it('should handle project ID not found', async () => {
+  it('should handle no project ID found', async () => {
     mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
     mockApi.Groups.allProjects.mockResolvedValue([]);
 
-    const projectId = await gitlab.getProjectId();
-
-    expect(projectId).toBeNull();
-  });
-
-  it('should fetch trigger token successfully', async () => {
-    mockApi.PipelineTriggerTokens.all.mockResolvedValue([
-      { token: 'test-token' },
-    ]);
-
-    const token = await gitlab.getTriggerToken(1);
+    await gitlab.init();
 
-    expect(token).toBe('test-token');
-    expect(mockApi.PipelineTriggerTokens.all).toHaveBeenCalledWith(1);
+    expect(gitlab.projectId).toBeNull();
+    expect(gitlab.triggerToken).toBeNull();
+    expect(mockApi.Groups.show).toHaveBeenCalledWith('DTaaS');
+    expect(mockApi.Groups.allProjects).toHaveBeenCalledWith(1);
+    expect(mockApi.PipelineTriggerTokens.all).not.toHaveBeenCalled();
   });
 
-  it('should handle no trigger tokens found', async () => {
+  it('should handle no trigger token found', async () => {
+    mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
+    mockApi.Groups.allProjects.mockResolvedValue([{ id: 1, name: 'user1' }]);
     mockApi.PipelineTriggerTokens.all.mockResolvedValue([]);
 
-    const token = await gitlab.getTriggerToken(1);
+    await gitlab.init();
 
-    expect(token).toBeNull();
+    expect(gitlab.projectId).toBe(1);
+    expect(gitlab.triggerToken).toBeNull();
+    expect(mockApi.Groups.show).toHaveBeenCalledWith('DTaaS');
+    expect(mockApi.Groups.allProjects).toHaveBeenCalledWith(1);
     expect(mockApi.PipelineTriggerTokens.all).toHaveBeenCalledWith(1);
   });
 
-  it('should handle undefined trigger tokens', async () => {
-    mockApi.PipelineTriggerTokens.all.mockResolvedValue(undefined);
+  it('should handle error fetching DT description', async () => {
+    const dtName = 'test-dt';
+    const readmePath = `digital_twins/${dtName}/description.md`;
 
-    const token = await gitlab.getTriggerToken(1);
+    mockApi.RepositoryFiles.show.mockRejectedValue(new Error('Failed to fetch'));
 
-    expect(token).toBeNull();
+    await expect(gitlab.getDTDescription(dtName)).rejects.toThrow('Failed to fetch');
+    expect(mockApi.RepositoryFiles.show).toHaveBeenCalledWith(
+      gitlab.projectId!,
+      readmePath,
+      'main',
+    );
   });
 
   it('should fetch DT subfolders successfully', async () => {
-    mockApi.Repositories.allRepositoryTrees.mockResolvedValue([
+    const projectId = 1;
+    const files = [
       { name: 'subfolder1', path: 'digital_twins/subfolder1', type: 'tree' },
       { name: 'subfolder2', path: 'digital_twins/subfolder2', type: 'tree' },
       { name: 'file1', path: 'digital_twins/file1', type: 'blob' },
-    ]);
+    ];
 
-    const subfolders = await gitlab.getDTSubfolders(1);
+    gitlab.getDTDescription = jest.fn()
+      .mockImplementation((name: string) => Promise.resolve(`Description for ${name}`));
+
+    mockApi.Repositories.allRepositoryTrees.mockResolvedValue(files);
+
+    const subfolders = await gitlab.getDTSubfolders(projectId);
 
     expect(subfolders).toHaveLength(2);
     expect(subfolders).toEqual([
-      { name: 'subfolder1', path: 'digital_twins/subfolder1' },
-      { name: 'subfolder2', path: 'digital_twins/subfolder2' },
+      { name: 'subfolder1', path: 'digital_twins/subfolder1', description: 'Description for subfolder1' },
+      { name: 'subfolder2', path: 'digital_twins/subfolder2', description: 'Description for subfolder2' },
     ]);
-    expect(mockApi.Repositories.allRepositoryTrees).toHaveBeenCalledWith(1, {
+    expect(mockApi.Repositories.allRepositoryTrees).toHaveBeenCalledWith(projectId, {
       path: 'digital_twins',
       recursive: false,
     });
@@ -123,4 +137,61 @@ describe('GitlabInstance', () => {
     expect(logs[0].DTName).toBe('test-DTName');
     expect(logs[0].runnerTag).toBe('test-runnerTag');
   });
+
+  it('should fetch pipeline jobs successfully', async () => {
+    const projectId = 1;
+    const pipelineId = 2;
+    const jobs = [{ id: 1, name: 'job1' }, { id: 2, name: 'job2' }];
+
+    mockApi.Jobs.all.mockResolvedValue(jobs);
+
+    const result = await gitlab.getPipelineJobs(projectId, pipelineId);
+
+    expect(result).toEqual(jobs);
+    expect(mockApi.Jobs.all).toHaveBeenCalledWith(projectId, { pipelineId });
+  });
+
+  it('should fetch job trace successfully', async () => {
+    const projectId = 1;
+    const jobId = 2;
+    const log = 'Job log content';
+
+    mockApi.Jobs.showLog.mockResolvedValue(log);
+
+    const result = await gitlab.getJobTrace(projectId, jobId);
+
+    expect(result).toBe(log);
+    expect(mockApi.Jobs.showLog).toHaveBeenCalledWith(projectId, jobId);
+  });
+
+  it('should fetch pipeline status successfully', async () => {
+    const projectId = 1;
+    const pipelineId = 2;
+    const status = 'success';
+
+    mockApi.Pipelines.show.mockResolvedValue({ status });
+
+    const result = await gitlab.getPipelineStatus(projectId, pipelineId);
+
+    expect(result).toBe(status);
+    expect(mockApi.Pipelines.show).toHaveBeenCalledWith(projectId, pipelineId);
+  });
+
+  it('should fetch DT description successfully and decode content', async () => {
+    const dtName = 'test-dt';
+    const readmePath = `digital_twins/${dtName}/description.md`;
+    const encodedContent = btoa('Description content');
+    const mockFileData = { content: encodedContent };
+
+    mockApi.RepositoryFiles.show.mockResolvedValue(mockFileData);
+
+    const description = await gitlab.getDTDescription(dtName);
+
+    expect(description).toBe('Description content');
+    expect(mockApi.RepositoryFiles.show).toHaveBeenCalledWith(
+      gitlab.projectId!,
+      readmePath,
+      'main',
+    );
+  });
 });
diff --git a/client/test/unitTests/Util/gitlabDigitalTwin.test.ts b/client/test/unitTests/Util/gitlabDigitalTwin.test.ts
index 351c928b2..0e9060ac0 100644
--- a/client/test/unitTests/Util/gitlabDigitalTwin.test.ts
+++ b/client/test/unitTests/Util/gitlabDigitalTwin.test.ts
@@ -1,162 +1,186 @@
-import { ProjectSchema, PipelineTriggerTokenSchema } from '@gitbeaker/rest';
-import DigitalTwin from 'util/gitlabDigitalTwin';
 import { GitlabInstance } from 'util/gitlab';
-
-type LogEntry = { status: string; DTName: string; runnerTag: string };
+import DigitalTwin, { formatName } from 'util/gitlabDigitalTwin';
 
 const mockApi = {
-  Groups: {
+  RepositoryFiles: {
     show: jest.fn(),
-    allProjects: jest.fn(),
+    remove: jest.fn(),
   },
   PipelineTriggerTokens: {
-    all: jest.fn(),
     trigger: jest.fn(),
   },
-  Repositories: {
-    allRepositoryTrees: jest.fn(),
+  Pipelines: {
+    cancel: jest.fn(),
   },
 };
 
 const mockGitlabInstance = {
   api: mockApi as unknown as GitlabInstance['api'],
-  executionLogs: jest.fn() as jest.Mock<LogEntry[]>,
+  projectId: 1,
+  triggerToken: 'test-token',
+  logs: [] as any[],
   getProjectId: jest.fn(),
   getTriggerToken: jest.fn(),
-  getDTSubfolders: jest.fn(),
-  logs: [],
 } as unknown as GitlabInstance;
 
 describe('DigitalTwin', () => {
   let dt: DigitalTwin;
 
   beforeEach(() => {
+    mockGitlabInstance.projectId = 1;
     dt = new DigitalTwin('test-DTName', mockGitlabInstance);
   });
 
-  it('should handle null project ID during pipeline execution', async () => {
-    mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
-    mockApi.Groups.allProjects.mockResolvedValue([]);
-    (mockGitlabInstance.getProjectId as jest.Mock).mockResolvedValue(null);
+  it('should return full description if projectId exists', async () => {
+    const mockContent = btoa('Test README content');
+    (mockApi.RepositoryFiles.show as jest.Mock).mockResolvedValue({
+      content: mockContent,
+    });
 
-    const success = await dt.execute();
+    const description = await dt.getFullDescription();
 
-    expect(success).toBe(false);
-    expect(dt.executionStatus()).toBe('error');
-    expect(mockApi.PipelineTriggerTokens.trigger).not.toHaveBeenCalled();
+    expect(description).toBe('Test README content');
+    expect(mockApi.RepositoryFiles.show).toHaveBeenCalledWith(
+      1,
+      'digital_twins/test-DTName/README.md',
+      'main'
+    );
   });
 
-  it('should handle null trigger token during pipeline execution', async () => {
-    mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
-    mockApi.Groups.allProjects.mockResolvedValue([
-      { id: 1, name: 'user1' } as ProjectSchema,
-    ]);
-    mockApi.PipelineTriggerTokens.all.mockResolvedValue([]);
-    (mockGitlabInstance.getTriggerToken as jest.Mock).mockResolvedValue(null);
+  it('should return error message if no README.md file exists', async () => {
+    (mockApi.RepositoryFiles.show as jest.Mock).mockRejectedValue(new Error('File not found'));
 
-    const success = await dt.execute();
+    const description = await dt.getFullDescription();
 
-    expect(success).toBe(false);
-    expect(dt.executionStatus()).toBe('error');
-    expect(mockApi.PipelineTriggerTokens.trigger).not.toHaveBeenCalled();
+    expect(description).toBe('There is no README.md file in the test-DTName GitLab folder');
   });
 
-  it('should execute pipeline successfully', async () => {
-    mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
-    mockApi.Groups.allProjects.mockResolvedValue([
-      { id: 1, name: 'user1' } as ProjectSchema,
-    ]);
-    mockApi.PipelineTriggerTokens.all.mockResolvedValue([
-      { token: 'test-token' } as PipelineTriggerTokenSchema,
-    ]);
+  it('should return error message when projectId is missing', async () => {
+    dt.gitlabInstance.projectId = null;
+    const description = await dt.getFullDescription();
+    expect(description).toBe('Error fetching description.');
+  });
+
+  it('should execute pipeline and return the pipeline ID', async () => {
+    const mockResponse = { id: 123 };
+    (mockApi.PipelineTriggerTokens.trigger as jest.Mock).mockResolvedValue(mockResponse);
     (mockGitlabInstance.getProjectId as jest.Mock).mockResolvedValue(1);
-    (mockGitlabInstance.getTriggerToken as jest.Mock).mockResolvedValue(
-      'test-token',
-    );
-    (mockApi.PipelineTriggerTokens.trigger as jest.Mock).mockResolvedValue(
-      undefined,
-    );
+    (mockGitlabInstance.getTriggerToken as jest.Mock).mockResolvedValue('test-token');
 
-    const success = await dt.execute();
+    const pipelineId = await dt.execute();
 
-    expect(success).toBe(true);
-    expect(dt.executionStatus()).toBe('success');
+    expect(pipelineId).toBe(123);
+    expect(dt.lastExecutionStatus).toBe('success');
     expect(mockApi.PipelineTriggerTokens.trigger).toHaveBeenCalledWith(
       1,
       'main',
       'test-token',
-      { variables: { DTName: 'test-DTName', RunnerTag: 'test-runnerTag' } },
+      { variables: { DTName: 'test-DTName', RunnerTag: 'linux' } }
     );
   });
 
+  it('should log error and return null when projectId or triggerToken is missing', async () => {
+    dt.gitlabInstance.projectId = null;
+    dt.gitlabInstance.triggerToken = null;
+  
+    jest.spyOn(dt as any, 'isValidInstance').mockReturnValue(false);
+  
+    (mockApi.PipelineTriggerTokens.trigger as jest.Mock).mockReset();
+  
+    const pipelineId = await dt.execute();
+  
+    expect(pipelineId).toBeNull();
+    expect(dt.lastExecutionStatus).toBe('error');
+    expect(mockApi.PipelineTriggerTokens.trigger).not.toHaveBeenCalled();
+  });
+  
+
+  it('should log success and update status', () => {
+    dt['logSuccess']();
+
+    expect(dt.gitlabInstance.logs).toContainEqual({
+      status: 'success',
+      DTName: 'test-DTName',
+      runnerTag: 'linux',
+    });
+    expect(dt.lastExecutionStatus).toBe('success');
+  });
+
+  it('should log error when triggering pipeline fails', async () => {
+    jest.spyOn(dt as any, 'isValidInstance').mockReturnValue(true);
+    const errorMessage = 'Trigger failed';
+    (mockApi.PipelineTriggerTokens.trigger as jest.Mock).mockRejectedValue(errorMessage);
+
+    const pipelineId = await dt.execute();
+
+    expect(pipelineId).toBeNull();
+    expect(dt.lastExecutionStatus).toBe('error');
+  });
+
   it('should handle non-Error thrown during pipeline execution', async () => {
-    mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
-    mockApi.Groups.allProjects.mockResolvedValue([
-      { id: 1, name: 'user1' } as ProjectSchema,
-    ]);
-    mockApi.PipelineTriggerTokens.all.mockResolvedValue([
-      { token: 'test-token' } as PipelineTriggerTokenSchema,
-    ]);
-    (mockGitlabInstance.getProjectId as jest.Mock).mockResolvedValue(1);
-    (mockGitlabInstance.getTriggerToken as jest.Mock).mockResolvedValue(
-      'test-token',
-    );
-    (mockApi.PipelineTriggerTokens.trigger as jest.Mock).mockRejectedValue(
-      'String error message',
-    );
+    (mockApi.PipelineTriggerTokens.trigger as jest.Mock).mockRejectedValue('String error message');
 
-    const success = await dt.execute();
+    const pipelineId = await dt.execute();
 
-    expect(success).toBe(false);
-    expect(dt.executionStatus()).toBe('error');
-    expect(mockApi.PipelineTriggerTokens.trigger).toHaveBeenCalledWith(
+    expect(pipelineId).toBeNull();
+    expect(dt.lastExecutionStatus).toBe('error');
+  });
+
+  it('should stop the pipeline and update status', async () => {
+    const pipelineId = 456;
+    (mockApi.Pipelines.cancel as jest.Mock).mockResolvedValue({});
+
+    await dt.stop(1, pipelineId);
+
+    expect(mockApi.Pipelines.cancel).toHaveBeenCalledWith(1, pipelineId);
+    expect(dt.lastExecutionStatus).toBe('canceled');
+  });
+
+  it('should handle stop error', async () => {
+    (mockApi.Pipelines.cancel as jest.Mock).mockRejectedValue(new Error('Stop failed'));
+
+    await dt.stop(1, 456);
+
+    expect(dt.lastExecutionStatus).toBe('error');
+  });
+
+  it('should delete the digital twin and return success message', async () => {
+    (mockApi.RepositoryFiles.remove as jest.Mock).mockResolvedValue({});
+
+    const result = await dt.delete();
+
+    expect(result).toBe('test-DTName deleted successfully');
+    expect(mockApi.RepositoryFiles.remove).toHaveBeenCalledWith(
       1,
+      'digital_twins/test-DTName',
       'main',
-      'test-token',
-      { variables: { DTName: 'test-DTName', RunnerTag: 'test-runnerTag' } },
+      'Removing test-DTName digital twin'
     );
   });
 
-  it('should handle Error thrown during pipeline execution', async () => {
-    mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
-    mockApi.Groups.allProjects.mockResolvedValue([
-      { id: 1, name: 'user1' } as ProjectSchema,
-    ]);
-    mockApi.PipelineTriggerTokens.all.mockResolvedValue([
-      { token: 'test-token' } as PipelineTriggerTokenSchema,
-    ]);
-
-    mockApi.PipelineTriggerTokens.trigger.mockRejectedValue(
-      new Error('Error instance message'),
-    );
+  it('should return error message when deletion fails', async () => {
+    (mockApi.RepositoryFiles.remove as jest.Mock).mockRejectedValue(new Error('Delete failed'));
+
+    const result = await dt.delete();
 
-    const success = await dt.execute();
+    expect(result).toBe('Error deleting test-DTName digital twin');
+  });
 
-    expect(success).toBe(false);
+  it('should return error message when projectId is missing during deletion', async () => {
+    dt.gitlabInstance.projectId = null;
 
-    expect(dt.executionStatus()).toBe('error');
+    const result = await dt.delete();
+
+    expect(result).toBe('Error deleting test-DTName digital twin: no project id');
   });
 
-  it('should return execution logs', async () => {
-    mockApi.Groups.show.mockResolvedValue({ id: 1, name: 'DTaaS' });
-    mockApi.Groups.allProjects.mockResolvedValue([
-      { id: 1, name: 'user1' } as ProjectSchema,
-    ]);
-    mockApi.PipelineTriggerTokens.all.mockResolvedValue([
-      { token: 'test-token' } as PipelineTriggerTokenSchema,
-    ]);
-    mockApi.PipelineTriggerTokens.trigger.mockResolvedValue(undefined);
-
-    await dt.execute();
-
-    (mockGitlabInstance.executionLogs as jest.Mock).mockReturnValue([
-      { status: 'success', DTName: 'test-DTName', runnerTag: 'test-runnerTag' },
-    ]);
-
-    const logs = dt.gitlabInstance.executionLogs();
-    expect(logs).toHaveLength(1);
-    expect(logs[0].status).toBe('success');
-    expect(logs[0].DTName).toBe('test-DTName');
-    expect(logs[0].runnerTag).toBe('test-runnerTag');
+  it('should format the name correctly', () => {
+    const testCases = [
+      { input: 'digital-twin', expected: 'Digital twin' },
+    ];
+
+    testCases.forEach(({ input, expected }) => {
+      expect(formatName(input)).toBe(expected);
+    });
   });
 });