foreman-tasks 12.2.1 → 12.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3ab9dfe5221351a1c392ddc1ba3c9c8693ba9c7dd6ceea8659aabc30de78d56
-  data.tar.gz: d666650ff5f3073c9c66e3c37ec6d9c2d28ac08e3abd18f13157261cf0e511b6
+  metadata.gz: 79e3003ee203359edba19b75adac7c38435b94081969faba3ad211601c559345
+  data.tar.gz: b3da633082735d6adf5a5d569744d3d5a6fa1d18d05568e7bc048b922205c674
 SHA512:
-  metadata.gz: 99b91eb15001bc4d8d93605b1e7ffff2d39aab63ae044259d474f84827cf9888233d3e7b7b107e32ab63a7145ed419f5ac163a5c8d8a13857bfa6a2dc2fc935e
-  data.tar.gz: f95f6d9169b3b442fe9a4c8a20a3426984d997365fb9c7bf2708828e4f7e8ca634f78f70b8f07d02f9e22e92ed597b6f59d4140f36bb3661532f459adfd4baa3
+  metadata.gz: 6614edd5d7578167024f5df26bc5f950862dd9a2411a75cfd3f591b19755acbc40a1ca4321eff752800023923bb574d0095aa8c81ab4fa953e030999cf3d4547
+  data.tar.gz: fcdd9f699f2a55d3e27bf014f8dbee0dd0e92e3d4f6b6b6921f0a4ba9841cf2cd8aa2392d0376667fa34a85ec41b53ad6e6ff25dae9443fcee9bd625350e82f2

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '12.2.1'.freeze
+  VERSION = '12.2.2'.freeze
 end

data/webpack/ForemanTasks/Components/TaskDetails/Components/Dependencies.js

@@ -1,55 +1,75 @@
 import React from 'react';
 import PropTypes from 'prop-types';
+import { capitalize } from 'lodash';
 import {
-  Alert,
-  AlertVariant,
   Grid,
   GridItem,
+  Text,
+  TextVariants,
   Title,
 } from '@patternfly/react-core';
 import { Table, Thead, Tbody, Tr, Th, Td } from '@patternfly/react-table';
 import { translate as __ } from 'foremanReact/common/I18n';
 
-const DependencyTable = ({ title, tasks }) => {
-  const tableId = title.toLowerCase().replace(/\s+/g, '-');
-  return (
-    <div>
-      <Title headingLevel="h4" size="md" ouiaId={`${tableId}-title`}>
-        {title}
-      </Title>
-      {tasks.length === 0 ? (
-        <p className="text-muted">{__('None')}</p>
-      ) : (
-        <Table aria-label={title} variant="compact" ouiaId={`${tableId}-table`}>
-          <Thead>
-            <Tr ouiaId={`${tableId}-table-header`}>
-              <Th width={50}>{__('Action')}</Th>
-              <Th width={25}>{__('State')}</Th>
-              <Th width={25}>{__('Result')}</Th>
-            </Tr>
-          </Thead>
-          <Tbody>
-            {tasks.map(task => (
-              <Tr key={task.id} ouiaId={`${tableId}-table-row-${task.id}`}>
-                <Td>
-                  <a href={`/foreman_tasks/tasks/${task.id}`}>
-                    {task.humanized || task.action}
-                  </a>
-                </Td>
-                <Td>{task.state}</Td>
-                <Td>{task.result}</Td>
+const DependencyTable = ({ title, tasks, ouiaSectionId }) => (
+  <React.Fragment>
+    <Title headingLevel="h3" size="lg" ouiaId={`${ouiaSectionId}-title`}>
+      {title}
+    </Title>
+    <Grid hasGutter>
+      <GridItem span={12} xl={8}>
+        {tasks.length === 0 ? (
+          <Text component={TextVariants.small} ouiaId={`${ouiaSectionId}-none`}>
+            {__('None')}
+          </Text>
+        ) : (
+          <Table
+            aria-label={title}
+            variant="compact"
+            ouiaId={`${ouiaSectionId}-table`}
+          >
+            <Thead>
+              <Tr ouiaId={`${ouiaSectionId}-table-header`}>
+                <Th>{__('Name')}</Th>
+                <Th>{__('State')}</Th>
+                <Th>{__('Result')}</Th>
               </Tr>
-            ))}
-          </Tbody>
-        </Table>
-      )}
-    </div>
-  );
-};
+            </Thead>
+            <Tbody>
+              {tasks.map(task => (
+                <Tr
+                  key={task.id}
+                  ouiaId={`${ouiaSectionId}-table-row-${task.id}`}
+                >
+                  <Td dataLabel={__('Name')}>
+                    <Text
+                      component={TextVariants.a}
+                      href={`/foreman_tasks/tasks/${task.id}`}
+                      ouiaId={`${ouiaSectionId}-task-link-${task.id}`}
+                    >
+                      {task.humanized || task.action}
+                    </Text>
+                  </Td>
+                  <Td dataLabel={__('State')}>
+                    {capitalize(String(task.state || ''))}
+                  </Td>
+                  <Td dataLabel={__('Result')}>
+                    {capitalize(String(task.result || ''))}
+                  </Td>
+                </Tr>
+              ))}
+            </Tbody>
+          </Table>
+        )}
+      </GridItem>
+    </Grid>
+  </React.Fragment>
+);
 
 DependencyTable.propTypes = {
   title: PropTypes.string.isRequired,
   tasks: PropTypes.array,
+  ouiaSectionId: PropTypes.string.isRequired,
 };
 
 DependencyTable.defaultProps = {
@@ -57,27 +77,18 @@ DependencyTable.defaultProps = {
 };
 
 const Dependencies = ({ dependsOn, blocks }) => (
-  <div>
-    <Alert
-      variant={AlertVariant.info}
-      isInline
-      title={__('Task dependencies')}
-      ouiaId="task-dependencies-info-alert"
-    >
-      {__(
-        'This task may have dependencies on other tasks or may be blocking other tasks from executing. Dependencies are established through task chaining relationships.'
-      )}
-    </Alert>
-    <br />
-    <Grid hasGutter>
-      <GridItem span={6}>
-        <DependencyTable title={__('Depends on')} tasks={dependsOn} />
-      </GridItem>
-      <GridItem span={6}>
-        <DependencyTable title={__('Blocks')} tasks={blocks} />
-      </GridItem>
-    </Grid>
-  </div>
+  <React.Fragment>
+    <DependencyTable
+      title={__('Task depends on')}
+      tasks={dependsOn}
+      ouiaSectionId="task-dependencies-depends-on"
+    />
+    <DependencyTable
+      title={__('Task blocks')}
+      tasks={blocks}
+      ouiaSectionId="task-dependencies-blocks"
+    />
+  </React.Fragment>
 );
 
 Dependencies.propTypes = {

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

@@ -1,56 +1,183 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { Alert, Card, Row, Col } from 'patternfly-react';
-import { translate as __ } from 'foremanReact/common/I18n';
+import {
+  EmptyState,
+  EmptyStateBody,
+  EmptyStateHeader,
+  EmptyStateIcon,
+  EmptyStateVariant,
+  Flex,
+  FlexItem,
+  Grid,
+  GridItem,
+  Icon,
+  Text,
+  TextContent,
+  TextVariants,
+  Title,
+} from '@patternfly/react-core';
+import { Table, Tbody, Tr, Td } from '@patternfly/react-table';
+import { LockIcon, LockOpenIcon } from '@patternfly/react-icons';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
 
-const ConditionalLink = ({ children, link }) =>
-  link ? <a href={link}>{children}</a> : children;
+const LocksSection = ({
+  title,
+  description,
+  items,
+  RowIcon,
+  ouiaSectionId,
+}) => (
+  <Flex direction={{ default: 'column' }}>
+    <FlexItem spacer={{ default: 'spacerSm' }}>
+      <Flex
+        alignItems={{ default: 'alignItemsCenter' }}
+        spaceItems={{ default: 'spaceItemsSm' }}
+      >
+        <FlexItem>
+          <Title
+            headingLevel="h3"
+            size="lg"
+            style={{ margin: '0' }}
+            ouiaId={`${ouiaSectionId}-title`}
+          >
+            {title}
+          </Title>
+        </FlexItem>
+        <FlexItem>
+          <RowIcon aria-hidden />
+        </FlexItem>
+      </Flex>
+    </FlexItem>
+    <FlexItem>
+      <TextContent>
+        <Text
+          component={TextVariants.p}
+          ouiaId={`${ouiaSectionId}-description`}
+        >
+          {description}
+        </Text>
+      </TextContent>
+    </FlexItem>
+    <FlexItem>
+      <Grid>
+        <GridItem span={5}>
+          <Table
+            aria-label={title}
+            variant="compact"
+            ouiaId={`${ouiaSectionId}-table`}
+          >
+            <Tbody>
+              {items.map((lock, index) => (
+                <Tr
+                  key={`${lock.resource_type}-${lock.resource_id}-${index}`}
+                  ouiaId={`${ouiaSectionId}-row-${index}`}
+                >
+                  <Td>
+                    <Flex
+                      alignItems={{ default: 'alignItemsCenter' }}
+                      spaceItems={{ default: 'spaceItemsSm' }}
+                      flexWrap={{ default: 'nowrap' }}
+                    >
+                      <FlexItem>
+                        <Icon size="sm">
+                          <RowIcon />
+                        </Icon>
+                      </FlexItem>
+                      <FlexItem>
+                        {lock.link ? (
+                          <a
+                            href={lock.link}
+                            data-ouia-component-id={`${ouiaSectionId}-resource-type-link-${index}`}
+                          >
+                            {lock.resource_type}
+                          </a>
+                        ) : (
+                          lock.resource_type
+                        )}
+                      </FlexItem>
+                    </Flex>
+                  </Td>
+                  <Td>{sprintf(__('id: %s'), String(lock.resource_id))}</Td>
+                </Tr>
+              ))}
+            </Tbody>
+          </Table>
+        </GridItem>
+      </Grid>
+    </FlexItem>
+  </Flex>
+);
 
-ConditionalLink.propTypes = {
-  children: PropTypes.node.isRequired,
-  link: PropTypes.string,
+LocksSection.propTypes = {
+  title: PropTypes.string.isRequired,
+  description: PropTypes.string.isRequired,
+  items: PropTypes.array.isRequired,
+  RowIcon: PropTypes.elementType.isRequired,
+  ouiaSectionId: PropTypes.string.isRequired,
 };
 
-ConditionalLink.defaultProps = {
-  link: null,
-};
+const Locks = ({ locks }) => {
+  const nonExclusive = locks.filter(l => !l.exclusive);
+  const exclusive = locks.filter(l => l.exclusive);
 
-const Locks = ({ locks }) => (
-  <div>
-    <Alert type="info">
-      {__(
-        'You can find resource locks on this page. Exclusive lock marked with locked icon means that no other task can use locked resource while this task is running. Non-exclusive lock marked with unlocked icon means other tasks can access the resource freely, it is only used to indicate the relation of this task with the resource'
+  if (locks.length === 0) {
+    return (
+      <EmptyState variant={EmptyStateVariant.lg}>
+        <EmptyStateHeader
+          headingLevel="h3"
+          titleText={__('No resources')}
+          icon={<EmptyStateIcon icon={LockOpenIcon} />}
+        />
+        <EmptyStateBody>
+          {__(
+            'No resources currently associated with this task. Locking resources prevents conflicting tasks from running simultaneously. Other tasks must wait until this process completes.'
+          )}
+        </EmptyStateBody>
+      </EmptyState>
+    );
+  }
+
+  return (
+    <Flex
+      direction={{ default: 'column' }}
+      gap={{ default: 'gap2xl' }}
+      data-ouia-component-id="task-locks-populated"
+    >
+      {nonExclusive.length > 0 && (
+        <LocksSection
+          title={__('Non-exclusive resources')}
+          description={__(
+            "Other tasks can access the resource simultaneously. This lock tracks the task's relationship to the resource without blocking others."
+          )}
+          items={nonExclusive}
+          RowIcon={LockOpenIcon}
+          ouiaSectionId="task-locks-non-exclusive"
+        />
       )}
-    </Alert>
-    <Card.Grid>
-      <Row>
-        {locks.map((lock, key) => (
-          <Col xs={6} sm={4} md={4} key={key}>
-            <ConditionalLink link={lock.link}>
-              <Card className="card-pf-aggregate-status" accented>
-                <Card.Title>
-                  <span
-                    className={`fa ${
-                      lock.exclusive ? 'fa-lock' : 'fa-unlock-alt'
-                    }`}
-                  />
-                  {lock.resource_type}
-                </Card.Title>
-                <Card.Body>
-                  {`id:${lock.resource_id}`}
-                  <br />
-                </Card.Body>
-              </Card>
-            </ConditionalLink>
-          </Col>
-        ))}
-      </Row>
-    </Card.Grid>
-  </div>
-);
+      {exclusive.length > 0 && (
+        <LocksSection
+          title={__('Exclusive resources')}
+          description={__(
+            'Only this task can access the resource. Other tasks must wait until this process completes.'
+          )}
+          items={exclusive}
+          RowIcon={LockIcon}
+          ouiaSectionId="task-locks-exclusive"
+        />
+      )}
+    </Flex>
+  );
+};
+
+const lockShape = PropTypes.shape({
+  exclusive: PropTypes.bool,
+  resource_type: PropTypes.string,
+  resource_id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  link: PropTypes.string,
+});
 
 Locks.propTypes = {
-  locks: PropTypes.array,
+  locks: PropTypes.arrayOf(lockShape),
 };
 
 Locks.defaultProps = {

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

@@ -5,16 +5,21 @@ import '@testing-library/jest-dom';
 import Dependencies from '../Dependencies';
 
 describe('Dependencies', () => {
-  it('renders info alert and None for both tables when there are no tasks', () => {
+  it('renders both sections with empty placeholders when there are no tasks', () => {
     render(<Dependencies dependsOn={[]} blocks={[]} />);
+
+    expect(
+      screen.getByRole('heading', { name: /task depends on/i })
+    ).toBeInTheDocument();
     expect(
-      screen.getByRole('heading', { name: /task dependencies/i })
+      screen.getByRole('heading', { name: /task blocks/i })
     ).toBeInTheDocument();
-    const noneLabels = screen.getAllByText(/^none$/i);
-    expect(noneLabels.length).toBeGreaterThanOrEqual(2);
+
+    expect(screen.getAllByText(/^none$/i)).toHaveLength(2);
+    expect(screen.queryByRole('grid')).not.toBeInTheDocument();
   });
 
-  it('renders depends_on tasks in the first table', () => {
+  it('renders depends-on tasks in the first grid', () => {
     const dependsOn = [
       {
         id: '123',
@@ -31,15 +36,39 @@ describe('Dependencies', () => {
         result: 'pending',
       },
     ];
+
     render(<Dependencies dependsOn={dependsOn} blocks={[]} />);
-    const table = screen.getByRole('grid', { name: /depends on/i });
-    expect(within(table).getByText('Foo Bar Action')).toBeInTheDocument();
-    expect(within(table).getByText('Baz Qux Action')).toBeInTheDocument();
-    expect(within(table).getByText('stopped')).toBeInTheDocument();
-    expect(within(table).getByText('success')).toBeInTheDocument();
+
+    const dependsGrid = screen.getByRole('grid', {
+      name: /task depends on/i,
+    });
+    expect(screen.queryAllByRole('grid')).toHaveLength(1);
+
+    expect(
+      within(dependsGrid).getByRole('columnheader', { name: /^name$/i })
+    ).toBeInTheDocument();
+
+    const bodyRows = within(dependsGrid)
+      .getAllByRole('row')
+      .slice(1);
+    expect(bodyRows).toHaveLength(2);
+
+    expect(
+      screen.getByRole('link', { name: 'Foo Bar Action' })
+    ).toHaveAttribute('href', '/foreman_tasks/tasks/123');
+    expect(
+      screen.getByRole('link', { name: 'Baz Qux Action' })
+    ).toHaveAttribute('href', '/foreman_tasks/tasks/456');
+
+    expect(within(dependsGrid).getByText('Stopped')).toBeInTheDocument();
+    expect(within(dependsGrid).getByText('Success')).toBeInTheDocument();
+    expect(within(dependsGrid).getByText('Running')).toBeInTheDocument();
+    expect(within(dependsGrid).getByText('Pending')).toBeInTheDocument();
+
+    expect(screen.getAllByText(/^none$/i)).toHaveLength(1);
   });
 
-  it('renders blocks in the second table', () => {
+  it('renders blocks in the second grid', () => {
     const blocks = [
       {
         id: '789',
@@ -49,14 +78,28 @@ describe('Dependencies', () => {
         result: 'warning',
       },
     ];
+
     render(<Dependencies dependsOn={[]} blocks={blocks} />);
-    const table = screen.getByRole('grid', { name: /^blocks$/i });
-    expect(within(table).getByText('Test Action')).toBeInTheDocument();
-    expect(within(table).getByText('paused')).toBeInTheDocument();
-    expect(within(table).getByText('warning')).toBeInTheDocument();
+
+    const blocksGrid = screen.getByRole('grid', { name: /task blocks/i });
+    expect(screen.queryAllByRole('grid')).toHaveLength(1);
+
+    const bodyRows = within(blocksGrid)
+      .getAllByRole('row')
+      .slice(1);
+    expect(bodyRows).toHaveLength(1);
+
+    expect(screen.getByRole('link', { name: 'Test Action' })).toHaveAttribute(
+      'href',
+      '/foreman_tasks/tasks/789'
+    );
+    expect(within(blocksGrid).getByText('Paused')).toBeInTheDocument();
+    expect(within(blocksGrid).getByText('Warning')).toBeInTheDocument();
+
+    expect(screen.getAllByText(/^none$/i)).toHaveLength(1);
   });
 
-  it('renders both tables when dependsOn and blocks are present', () => {
+  it('renders both grids when dependsOn and blocks are present', () => {
     const dependsOn = [
       {
         id: '123',
@@ -82,11 +125,29 @@ describe('Dependencies', () => {
         result: 'error',
       },
     ];
+
     render(<Dependencies dependsOn={dependsOn} blocks={blocks} />);
-    expect(screen.getByRole('grid', { name: /depends on/i })).toBeInTheDocument();
-    expect(screen.getByText('Foo Action')).toBeInTheDocument();
-    expect(screen.getByRole('grid', { name: /^blocks$/i })).toBeInTheDocument();
-    expect(screen.getByText('Bar Action')).toBeInTheDocument();
-    expect(screen.getByText('Baz Action')).toBeInTheDocument();
+
+    expect(
+      screen.getByRole('grid', { name: /task depends on/i })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('grid', { name: /task blocks/i })
+    ).toBeInTheDocument();
+
+    expect(screen.getByRole('link', { name: 'Foo Action' })).toHaveAttribute(
+      'href',
+      '/foreman_tasks/tasks/123'
+    );
+    expect(screen.getByRole('link', { name: 'Bar Action' })).toHaveAttribute(
+      'href',
+      '/foreman_tasks/tasks/456'
+    );
+    expect(screen.getByRole('link', { name: 'Baz Action' })).toHaveAttribute(
+      'href',
+      '/foreman_tasks/tasks/789'
+    );
+
+    expect(screen.queryByText(/^none$/i)).not.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();
+  });
 });

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 12.2.1
+  version: 12.2.2
 platform: ruby
 authors:
 - Ivan Nečas
@@ -389,7 +389,6 @@ files:
 - webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/TaskButtons.test.js
 - webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/TaskHelper.test.js
 - webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/TaskInfo.test.js
-- webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/__snapshots__/Locks.test.js.snap
 - webpack/ForemanTasks/Components/TaskDetails/TaskDetails.js
 - webpack/ForemanTasks/Components/TaskDetails/TaskDetails.scss
 - webpack/ForemanTasks/Components/TaskDetails/TaskDetailsActions.js

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

@@ -1,116 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Locks rendering render with Props 1`] = `
-<div>
-  <Alert
-    className=""
-    onDismiss={null}
-    type="info"
-  >
-    You can find resource locks on this page. Exclusive lock marked with locked icon means that no other task can use locked resource while this task is running. Non-exclusive lock marked with unlocked icon means other tasks can access the resource freely, it is only used to indicate the relation of this task with the resource
-  </Alert>
-  <CardGrid
-    className=""
-    matchHeight={false}
-  >
-    <Row
-      bsClass="row"
-      componentClass="div"
-    >
-      <Col
-        bsClass="col"
-        componentClass="div"
-        key="0"
-        md={4}
-        sm={4}
-        xs={6}
-      >
-        <ConditionalLink
-          link={null}
-        >
-          <Card
-            accented={true}
-            aggregated={false}
-            aggregatedMini={false}
-            cardRef={null}
-            className="card-pf-aggregate-status"
-            matchHeight={false}
-          >
-            <CardTitle
-              className=""
-            >
-              <span
-                className="fa fa-unlock-alt"
-              />
-              User
-            </CardTitle>
-            <CardBody
-              className=""
-            >
-              id:4
-              <br />
-            </CardBody>
-          </Card>
-        </ConditionalLink>
-      </Col>
-      <Col
-        bsClass="col"
-        componentClass="div"
-        key="1"
-        md={4}
-        sm={4}
-        xs={6}
-      >
-        <ConditionalLink
-          link={null}
-        >
-          <Card
-            accented={true}
-            aggregated={false}
-            aggregatedMini={false}
-            cardRef={null}
-            className="card-pf-aggregate-status"
-            matchHeight={false}
-          >
-            <CardTitle
-              className=""
-            >
-              <span
-                className="fa fa-unlock-alt"
-              />
-              User
-            </CardTitle>
-            <CardBody
-              className=""
-            >
-              id:2
-              <br />
-            </CardBody>
-          </Card>
-        </ConditionalLink>
-      </Col>
-    </Row>
-  </CardGrid>
-</div>
-`;
-
-exports[`Locks rendering render without Props 1`] = `
-<div>
-  <Alert
-    className=""
-    onDismiss={null}
-    type="info"
-  >
-    You can find resource locks on this page. Exclusive lock marked with locked icon means that no other task can use locked resource while this task is running. Non-exclusive lock marked with unlocked icon means other tasks can access the resource freely, it is only used to indicate the relation of this task with the resource
-  </Alert>
-  <CardGrid
-    className=""
-    matchHeight={false}
-  >
-    <Row
-      bsClass="row"
-      componentClass="div"
-    />
-  </CardGrid>
-</div>
-`;