foreman-tasks 12.1.1 → 12.2.2

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Errors.test.js

@@ -1,36 +1,59 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
 import Errors from '../Errors';
 
-const fixtures = {
-  'render without Props': {},
-  'render with Props': {
-    executionPlan: {
-      state: 'paused',
-      cancellable: false,
-    },
-    failedSteps: [
-      {
-        error: {
-          exception_class: 'RuntimeError',
-          message:
-            'Action Actions::Katello::EventQueue::Monitor is already active',
-          backtrace: [
-            "/home/vagrant/.gem/ruby/gems/dynflow-1.2.3/lib/dynflow/action/singleton.rb:15:in `rescue in singleton_lock!'",
-            "/home/vagrant/.gem/ruby/gems/dynflow-1.2.3/lib/dynflow/action/singleton.rb:12:in `singleton_lock!'",
-          ],
-        },
-        action_class: 'Actions::Katello::EventQueue::Monitor',
-        state: 'error',
-        input:
-          '{"locale"=>"en",\n "current_request_id"=>nil,\n "current_user_id"=>4,\n "current_organization_id"=>nil,\n "current_location_id"=>nil}\n',
-        output: '{}\n',
-      },
+const failedStepFixture = {
+  error: {
+    exception_class: 'RuntimeError',
+    message: 'Action Actions::Katello::EventQueue::Monitor is already active',
+    backtrace: [
+      "/home/vagrant/.gem/ruby/gems/dynflow-1.2.3/lib/dynflow/action/singleton.rb:15:in `rescue in singleton_lock!'",
+      "/home/vagrant/.gem/ruby/gems/dynflow-1.2.3/lib/dynflow/action/singleton.rb:12:in `singleton_lock!'",
     ],
   },
+  action_class: 'Actions::Katello::EventQueue::Monitor',
+  state: 'error',
+  input:
+    '{"locale"=>"en",\n "current_request_id"=>nil,\n "current_user_id"=>4,\n "current_organization_id"=>nil,\n "current_location_id"=>nil}\n',
+  output: '{}\n',
 };
 
 describe('Errors', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(Errors, fixtures));
+  it('renders warning when execution plan is missing', () => {
+    render(<Errors failedSteps={[]} executionPlan={null} />);
+    expect(
+      screen.getByText(/execution plan data not available/i)
+    ).toBeInTheDocument();
+  });
+
+  it('renders success state when there are no failed steps', () => {
+    render(<Errors failedSteps={[]} executionPlan={{ state: 'paused' }} />);
+    const noErrors = screen.getAllByText(/^no errors$/i);
+    expect(noErrors.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('renders failed step details when failedSteps is non-empty', () => {
+    const { container } = render(
+      <Errors
+        executionPlan={{ state: 'paused', cancellable: false }}
+        failedSteps={[failedStepFixture]}
+      />
+    );
+    const stepAlert = container.querySelector(
+      '[data-ouia-component-id="task-error-0"]'
+    );
+    expect(stepAlert).toBeInTheDocument();
+    expect(stepAlert).toHaveClass('pf-m-inline');
+    expect(
+      screen.getByText('Actions::Katello::EventQueue::Monitor')
+    ).toBeInTheDocument();
+    expect(screen.getByText(/runtimeerror/i)).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        /action actions::katello::eventqueue::monitor is already active/i
+      )
+    ).toBeInTheDocument();
+  });
 });

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Locks.test.js

@@ -1,28 +1,261 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
 import Locks from '../Locks';
 
-const fixtures = {
-  'render without Props': {},
-  'render with Props': {
-    locks: [
-      {
-        name: 'task_owner',
-        exclusive: false,
-        resource_type: 'User',
-        resource_id: 4,
-      },
-      {
-        name: 'task_owner2',
-        exclusive: false,
-        resource_type: 'User',
-        resource_id: 2,
-      },
-    ],
-  },
-};
-
 describe('Locks', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(Locks, fixtures));
+  it('renders empty state when there are no locks', () => {
+    const { container } = render(<Locks locks={[]} />);
+    expect(
+      screen.getByRole('heading', { name: /no resources/i })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        /no resources currently associated with this task/i
+      )
+    ).toBeInTheDocument();
+  });
+
+  it('renders non-exclusive section with rows when there are only non-exclusive locks', () => {
+    render(
+      <Locks
+        locks={[
+          {
+            name: 'task_owner',
+            exclusive: false,
+            resource_type: 'User',
+            resource_id: 4,
+            link: null,
+          },
+          {
+            name: 'task_owner2',
+            exclusive: false,
+            resource_type: 'User',
+            resource_id: 2,
+            link: null,
+          },
+        ]}
+      />
+    );
+    expect(
+      screen.getByRole('heading', { name: 'Non-exclusive resources' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        /other tasks can access the resource simultaneously/i
+      )
+    ).toBeInTheDocument();
+    expect(screen.getAllByText('User')).toHaveLength(2);
+    expect(screen.getByText('id: 4')).toBeInTheDocument();
+    expect(screen.getByText('id: 2')).toBeInTheDocument();
+    expect(
+      screen.queryByRole('heading', { name: 'Exclusive resources' })
+    ).not.toBeInTheDocument();
+  });
+
+  it('renders exclusive section when there are only exclusive locks', () => {
+    render(
+      <Locks
+        locks={[
+          {
+            name: 'host_lock',
+            exclusive: true,
+            resource_type: 'Host',
+            resource_id: 1,
+            link: '/hosts/1',
+          },
+        ]}
+      />
+    );
+    expect(
+      screen.getByRole('heading', { name: 'Exclusive resources' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        /only this task can access the resource/i
+      )
+    ).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: 'Host' })).toHaveAttribute(
+      'href',
+      '/hosts/1'
+    );
+    expect(screen.getByText('id: 1')).toBeInTheDocument();
+    expect(
+      screen.queryByRole('heading', { name: 'Non-exclusive resources' })
+    ).not.toBeInTheDocument();
+  });
+
+  it('renders both sections when locks are mixed', () => {
+    render(
+      <Locks
+        locks={[
+          {
+            name: 'a',
+            exclusive: false,
+            resource_type: 'Smart proxy',
+            resource_id: 7,
+            link: null,
+          },
+          {
+            name: 'b',
+            exclusive: true,
+            resource_type: 'Host managed',
+            resource_id: 1,
+            link: null,
+          },
+        ]}
+      />
+    );
+    expect(
+      screen.getByRole('heading', { name: 'Non-exclusive resources' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('heading', { name: 'Exclusive resources' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        /other tasks can access the resource simultaneously/i
+      )
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(/only this task can access the resource/i)
+    ).toBeInTheDocument();
+    expect(screen.getByText('Smart proxy')).toBeInTheDocument();
+    expect(screen.getByText('Host managed')).toBeInTheDocument();
+    expect(screen.getByText('id: 7')).toBeInTheDocument();
+    expect(screen.getByText('id: 1')).toBeInTheDocument();
+  });
+
+  it('renders a link for non-exclusive locks when lock.link is set', () => {
+    render(
+      <Locks
+        locks={[
+          {
+            name: 'proxy',
+            exclusive: false,
+            resource_type: 'Smart proxy',
+            resource_id: 7,
+            link: '/smart_proxies/7',
+          },
+        ]}
+      />
+    );
+    const link = screen.getByRole('link', { name: 'Smart proxy' });
+    expect(link).toHaveAttribute('href', '/smart_proxies/7');
+  });
+
+  it('formats string resource_id values in the row label', () => {
+    render(
+      <Locks
+        locks={[
+          {
+            name: 'x',
+            exclusive: false,
+            resource_type: 'Custom',
+            resource_id: 'uuid-abc',
+            link: null,
+          },
+        ]}
+      />
+    );
+    expect(screen.getByText('id: uuid-abc')).toBeInTheDocument();
+  });
+
+  it('sets ouia ids on populated container, tables, rows, and resource links', () => {
+    const { container } = render(
+      <Locks
+        locks={[
+          {
+            name: 'ne',
+            exclusive: false,
+            resource_type: 'A',
+            resource_id: 1,
+            link: '/non-exclusive/1',
+          },
+          {
+            name: 'ex',
+            exclusive: true,
+            resource_type: 'B',
+            resource_id: 2,
+            link: '/exclusive/2',
+          },
+        ]}
+      />
+    );
+    expect(
+      container.querySelector('[data-ouia-component-id="task-locks-populated"]')
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector(
+        '[data-ouia-component-id="task-locks-non-exclusive-table"]'
+      )
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector(
+        '[data-ouia-component-id="task-locks-exclusive-table"]'
+      )
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector(
+        '[data-ouia-component-id="task-locks-non-exclusive-row-0"]'
+      )
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector(
+        '[data-ouia-component-id="task-locks-exclusive-row-0"]'
+      )
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector(
+        '[data-ouia-component-id="task-locks-non-exclusive-resource-type-link-0"]'
+      )
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector(
+        '[data-ouia-component-id="task-locks-exclusive-resource-type-link-0"]'
+      )
+    ).toBeInTheDocument();
+  });
+
+  it('does not render resource_type as a link when lock.link is absent', () => {
+    render(
+      <Locks
+        locks={[
+          {
+            name: 'ex',
+            exclusive: true,
+            resource_type: 'Host managed',
+            resource_id: 1,
+            link: null,
+          },
+        ]}
+      />
+    );
+    expect(
+      screen.queryByRole('link', { name: 'Host managed' })
+    ).not.toBeInTheDocument();
+    expect(screen.getByText('Host managed')).toBeInTheDocument();
+  });
+
+  it('does not set resource-type link ouia id when lock.link is absent', () => {
+    const { container } = render(
+      <Locks
+        locks={[
+          {
+            name: 'ne',
+            exclusive: false,
+            resource_type: 'Thing',
+            resource_id: 1,
+            link: null,
+          },
+        ]}
+      />
+    );
+    expect(
+      container.querySelector(
+        '[data-ouia-component-id="task-locks-non-exclusive-resource-type-link-0"]'
+      )
+    ).not.toBeInTheDocument();
+  });
 });

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Raw.test.js

@@ -1,27 +1,49 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
 import Raw from '../Raw';
 
-const fixtures = {
-  'render without Props': {},
-  'render with Props': {
-    startedAt: '2019-06-17 16:04:09 +0300',
-    endedAt: '2019-06-17 16:05:09 +0300',
-    id: '6b0d6db2-e9ab-40da-94e5-b6842ac50bd0',
-    label: 'Actions::Katello::EventQueue::Monitor',
-    input: {
-      locale: 'en',
-      current_request_id: 1,
-      current_user_id: 4,
-      current_organization_id: 2,
-      current_location_id: 3,
-    },
-    output: {},
-    externalId: 'test',
-  },
-};
-
 describe('Raw', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(Raw, fixtures));
+  it('renders id and label when minimal props are given', () => {
+    render(
+      <Raw
+        id="x"
+        label=""
+        startedAt=""
+        endedAt=""
+        input={[]}
+        output={{}}
+        externalId=""
+      />
+    );
+    expect(screen.getByText('x')).toBeInTheDocument();
+  });
+
+  it('renders raw task fields from props', () => {
+    render(
+      <Raw
+        startedAt="2019-06-17 16:04:09 +0300"
+        endedAt="2019-06-17 16:05:09 +0300"
+        id="6b0d6db2-e9ab-40da-94e5-b6842ac50bd0"
+        label="Actions::Katello::EventQueue::Monitor"
+        input={{
+          locale: 'en',
+          current_request_id: 1,
+          current_user_id: 4,
+          current_organization_id: 2,
+          current_location_id: 3,
+        }}
+        output={{}}
+        externalId="test"
+      />
+    );
+    expect(
+      screen.getByText('6b0d6db2-e9ab-40da-94e5-b6842ac50bd0')
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText('Actions::Katello::EventQueue::Monitor')
+    ).toBeInTheDocument();
+    expect(screen.getByText(/"locale":/)).toBeInTheDocument();
+  });
 });

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/RunningSteps.test.js

@@ -1,36 +1,68 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
 import RunningSteps from '../RunningSteps';
 
-const minProps = {
+const baseProps = {
   id: 'task-id1',
   taskReload: true,
   cancelStep: jest.fn(),
   taskReloadStart: jest.fn(),
 };
-const fixtures = {
-  'render with min Props': minProps,
-  'render with Props': {
-    ...minProps,
-    executionPlan: {
-      state: 'paused',
-      cancellable: false,
-    },
-    runningSteps: [
-      {
-        cancellable: false,
-        id: 1,
-        action_class: 'test',
-        state: 'paused',
-        input:
-          '{"locale"=>"en",\n "current_request_id"=>nil,\n "current_user_id"=>4,\n "current_organization_id"=>nil,\n "current_location_id"=>nil}\n',
-        output: '{}\n',
-      },
-    ],
-  },
+
+const sampleStep = {
+  cancellable: false,
+  id: 1,
+  action_class: 'test',
+  state: 'paused',
+  input:
+    '{"locale"=>"en",\n "current_request_id"=>nil,\n "current_user_id"=>4,\n "current_organization_id"=>nil,\n "current_location_id"=>nil}\n',
+  output: '{}\n',
 };
 
 describe('RunningSteps', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(RunningSteps, fixtures));
+  it('renders empty message when there are no running steps', () => {
+    render(<RunningSteps {...baseProps} runningSteps={[]} />);
+    expect(screen.getByText(/no running steps/i)).toBeInTheDocument();
+  });
+
+  it('renders running step fields and Cancel when step is cancellable', () => {
+    const cancelStep = jest.fn();
+    render(
+      <RunningSteps
+        {...baseProps}
+        cancelStep={cancelStep}
+        runningSteps={[
+          {
+            ...sampleStep,
+            cancellable: true,
+            id: 99,
+          },
+        ]}
+      />
+    );
+    expect(
+      screen.getByRole('heading', { name: 'Warning alert: Running step 1' })
+    ).toBeInTheDocument();
+    expect(screen.getByText('test')).toBeInTheDocument();
+    expect(screen.getByText('paused')).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: /cancel/i }));
+    expect(cancelStep).toHaveBeenCalledWith('task-id1', 99);
+  });
+
+  it('uses sprintf so each running step title shows a 1-based step index', () => {
+    render(
+      <RunningSteps
+        {...baseProps}
+        runningSteps={[sampleStep, { ...sampleStep, id: 2, state: 'running' }]}
+      />
+    );
+    expect(
+      screen.getByRole('heading', { name: 'Warning alert: Running step 1' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('heading', { name: 'Warning alert: Running step 2' })
+    ).toBeInTheDocument();
+  });
 });

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Task.test.js

@@ -1,26 +1,46 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 import { STATUS } from 'foremanReact/constants';
+
 import Task from '../Task';
 
-const fixtures = {
-  'render with minimal Props': {
-    id: 'test',
-    taskReloadStart: jest.fn(),
-    taskProgressToggle: jest.fn(),
-  },
-  'render with some Props': {
-    id: 'test',
-    state: 'paused',
-    hasSubTasks: true,
-    dynflowEnableConsole: true,
-    parentTask: 'parent-id',
-    taskReload: true,
-    canEdit: true,
-    status: STATUS.RESOLVED,
-    taskProgressToggle: jest.fn(),
-    taskReloadStart: jest.fn(),
-  },
-};
+describe('Task', () => {
+  it('renders task controls from TaskButtons with minimal props', () => {
+    render(
+      <Task
+        id="test"
+        taskReloadStart={jest.fn()}
+        taskProgressToggle={jest.fn()}
+      />
+    );
+    expect(
+      screen.getByRole('button', { name: /start auto-reloading/i })
+    ).toBeInTheDocument();
+  });
 
-describe('Task rendering', () =>
-  testComponentSnapshotsWithFixtures(Task, fixtures));
+  it('renders parent task and sub tasks links when provided', () => {
+    render(
+      <Task
+        id="test"
+        state="paused"
+        hasSubTasks
+        dynflowEnableConsole
+        parentTask="parent-id"
+        taskReload
+        canEdit
+        status={STATUS.RESOLVED}
+        taskProgressToggle={jest.fn()}
+        taskReloadStart={jest.fn()}
+      />
+    );
+    expect(screen.getByRole('link', { name: /parent task/i })).toHaveAttribute(
+      'href',
+      '/foreman_tasks/tasks/parent-id'
+    );
+    expect(screen.getByRole('link', { name: /sub tasks/i })).toHaveAttribute(
+      'href',
+      '/foreman_tasks/tasks/test/sub_tasks'
+    );
+  });
+});