RH Cloud Host Details

Author: parthaa

webpack/InsightsHostDetailsTab/__tests__/InsightsTab.test.js

@@ -1,13 +1,15 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
 import InsightsTab from '../InsightsTab';
 import { props } from './InsightsTab.fixtures';
 
-const fixtures = {
-  'render with props': props,
-};
-
 describe('InsightsTab', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(InsightsTab, fixtures));
+  describe('rendering', () => {
+    it('should render with props', () => {
+      render(<InsightsTab {...props} />);
+      expect(screen.getByText('Recommendations')).toBeInTheDocument();
+    });
+  });
 });

webpack/InsightsHostDetailsTab/__tests__/InsightsTabActions.test.js

@@ -1,19 +1,52 @@
-import { testActionSnapshotWithFixtures } from '@theforeman/test';
 import { API } from 'foremanReact/redux/API';
 import { fetchHits } from '../InsightsTabActions';
 import { hostID, hits } from './InsightsTab.fixtures';
+import {
+  INSIGHTS_HITS_REQUEST,
+  INSIGHTS_HITS_SUCCESS,
+  INSIGHTS_HITS_FAILURE,
+} from '../InsightsTabConstants';
 
 jest.mock('foremanReact/redux/API');
-API.get.mockImplementation(async () => ({ data: { hits } }));
 
-const fixtures = {
-  'should fetchHits': () => fetchHits(hostID),
-  'should fetchHits with error': () => {
+describe('InsightsTab actions', () => {
+  it('should fetchHits', async () => {
+    API.get.mockImplementation(async () => ({ data: { hits } }));
+    const dispatch = jest.fn();
+
+    await fetchHits(hostID)(dispatch);
+
+    expect(dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: INSIGHTS_HITS_REQUEST,
+      })
+    );
+    expect(dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: INSIGHTS_HITS_SUCCESS,
+        payload: { hits },
+      })
+    );
+  });
+
+  it('should fetchHits with error', async () => {
     API.get.mockImplementationOnce(() =>
       Promise.reject(new Error('Network error!'))
     );
-    return fetchHits(hostID);
-  },
-};
+    const dispatch = jest.fn();
+
+    await fetchHits(hostID)(dispatch);
 
-describe('InsightsTab actions', () => testActionSnapshotWithFixtures(fixtures));
+    expect(dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: INSIGHTS_HITS_REQUEST,
+      })
+    );
+    // Error handling dispatches a toast notification, not INSIGHTS_HITS_FAILURE
+    expect(dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'TOASTS_ADD',
+      })
+    );
+  });
+});

webpack/InsightsHostDetailsTab/__tests__/InsightsTabReducer.test.js

@@ -1,26 +1,35 @@
-import { testReducerSnapshotWithFixtures } from '@theforeman/test';
+import Immutable from 'seamless-immutable';
 import reducer from '../InsightsTabReducer';
 import { hits } from './InsightsTab.fixtures';
 import {
   INSIGHTS_HITS_REQUEST,
   INSIGHTS_HITS_SUCCESS,
 } from '../InsightsTabConstants';
 
-const fixtures = {
-  'should return the initial state': {},
-  'should handle INSIGHTS_HITS_REQUEST': {
-    action: {
+describe('AccountList reducer', () => {
+  it('should return the initial state', () => {
+    const initialState = Immutable({ hits: [] });
+    expect(reducer(undefined, {})).toEqual(initialState);
+  });
+
+  it('should handle INSIGHTS_HITS_REQUEST', () => {
+    const initialState = Immutable({ hits: [] });
+    const action = {
       type: INSIGHTS_HITS_REQUEST,
       payload: {},
-    },
-  },
-  'should handle INSIGHTS_HITS_SUCCESS': {
-    action: {
+    };
+    const newState = reducer(initialState, action);
+    expect(newState).toHaveProperty('hits');
+    expect(newState.hits).toEqual([]);
+  });
+
+  it('should handle INSIGHTS_HITS_SUCCESS', () => {
+    const initialState = Immutable({ hits: [] });
+    const action = {
       type: INSIGHTS_HITS_SUCCESS,
       payload: { hits },
-    },
-  },
-};
-
-describe('AccountList reducer', () =>
-  testReducerSnapshotWithFixtures(reducer, fixtures));
+    };
+    const newState = reducer(initialState, action);
+    expect(newState.hits).toEqual(hits);
+  });
+});

webpack/InsightsHostDetailsTab/__tests__/InsightsTabSelectors.test.js

@@ -1,13 +1,11 @@
-import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
 import { hostInsightsStateWrapper } from '../../ForemanRhCloudTestHelpers';
 import { hits } from './InsightsTab.fixtures';
 import { selectHits } from '../InsightsTabSelectors';
 
 const state = hostInsightsStateWrapper({ hits });
 
-const fixtures = {
-  'should return hits': () => selectHits(state),
-};
-
-describe('InsightsTab selectors', () =>
-  testSelectorsSnapshotWithFixtures(fixtures));
+describe('InsightsTab selectors', () => {
+  it('should return hits', () => {
+    expect(selectHits(state)).toEqual(hits);
+  });
+});

webpack/InsightsHostDetailsTab/__tests__/__snapshots__/InsightsTab.test.js.snap

@@ -1,55 +1,69 @@
-import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
 import { foremanUrl, vulnerabilityDisabled, hasNoInsightsFacet } from '../ForemanRhCloudHelpers';
 
 global.URL_PREFIX = 'MY_TEST_URL_PREFIX.example.com';
 
-const fixtures = {
-  'should return foreman Url': () => foremanUrl('/test_path'),
-  'vulnerabilityDisabled returns false for RHEL host with vulnerability enabled': () =>
-    vulnerabilityDisabled({
+describe('ForemanRhCloud helpers', () => {
+  it('should return foreman Url', () => {
+    expect(foremanUrl('/test_path')).toBe('MY_TEST_URL_PREFIX.example.com/test_path');
+  });
+
+  it('vulnerabilityDisabled returns false for RHEL host with vulnerability enabled', () => {
+    expect(vulnerabilityDisabled({
       hostDetails: {
         operatingsystem_name: 'Red Hat Enterprise Linux',
         vulnerability: { enabled: true },
       },
-    }),
-  'vulnerabilityDisabled returns true for non-RHEL host': () =>
-    vulnerabilityDisabled({
+    })).toBe(false);
+  });
+
+  it('vulnerabilityDisabled returns true for non-RHEL host', () => {
+    expect(vulnerabilityDisabled({
       hostDetails: {
         operatingsystem_name: 'Ubuntu',
         vulnerability: { enabled: true },
       },
-    }),
-  'vulnerabilityDisabled returns true for RHEL host with vulnerability disabled': () =>
-    vulnerabilityDisabled({
+    })).toBe(true);
+  });
+
+  it('vulnerabilityDisabled returns true for RHEL host with vulnerability disabled', () => {
+    expect(vulnerabilityDisabled({
       hostDetails: {
         operatingsystem_name: 'Red Hat Enterprise Linux',
         vulnerability: { enabled: false },
       },
-    }),
-  'vulnerabilityDisabled returns true for missing vulnerability object': () =>
-    vulnerabilityDisabled({
+    })).toBe(true);
+  });
+
+  it('vulnerabilityDisabled returns true for missing vulnerability object', () => {
+    expect(vulnerabilityDisabled({
       hostDetails: {
         operatingsystem_name: 'Red Hat Enterprise Linux',
       },
-    }),
-  'vulnerabilityDisabled returns true for missing hostDetails': () =>
-    vulnerabilityDisabled({}),
-  'hasNoInsightsFacet returns false when insights_attributes is present': () =>
-    hasNoInsightsFacet({
+    })).toBe(true);
+  });
+
+  it('vulnerabilityDisabled returns true for missing hostDetails', () => {
+    expect(vulnerabilityDisabled({})).toBe(true);
+  });
+
+  it('hasNoInsightsFacet returns false when insights_attributes is present', () => {
+    expect(hasNoInsightsFacet({
       response: {
         insights_attributes: {
           uuid: 'test-uuid',
           insights_hits_count: 5,
         },
       },
-    }),
-  'hasNoInsightsFacet returns true when insights_attributes is missing': () =>
-    hasNoInsightsFacet({
+    })).toBe(false);
+  });
+
+  it('hasNoInsightsFacet returns true when insights_attributes is missing', () => {
+    expect(hasNoInsightsFacet({
       response: {},
-    }),
-  'hasNoInsightsFacet returns true when response is missing': () =>
-    hasNoInsightsFacet({}),
-};
+    })).toBe(true);
+  });
 
-describe('ForemanRhCloud helpers', () =>
-  testSelectorsSnapshotWithFixtures(fixtures));
+  it('hasNoInsightsFacet returns true when response is missing', () => {
+    expect(hasNoInsightsFacet({})).toBe(true);
+  });
+});