@rancher/shell 3.0.8 → 3.0.9-rc.2

package/components/nav/__tests__/TopLevelMenu.helper.test.ts

@@ -0,0 +1,277 @@
+import TopLevelMenuHelperService, { TopLevelMenuHelperLegacy, TopLevelMenuHelperPagination } from '../TopLevelMenu.helper';
+import { CAPI, MANAGEMENT } from '@shell/config/types';
+import PaginationWrapper from '@shell/utils/pagination-wrapper';
+
+// Mock dependencies
+jest.mock('@shell/utils/pagination-wrapper');
+jest.mock('@shell/utils/cluster', () => ({
+  filterHiddenLocalCluster:     jest.fn((clusters) => clusters),
+  filterOnlyKubernetesClusters: jest.fn((clusters) => clusters),
+  paginationFilterClusters:     jest.fn(() => []),
+}));
+
+describe('topLevelMenu.helper', () => {
+  let mockStore: any;
+
+  beforeEach(() => {
+    mockStore = {
+      getters: {
+        'management/schemaFor':         jest.fn(),
+        'management/all':               jest.fn(),
+        'management/paginationEnabled': jest.fn(),
+      },
+      dispatch: jest.fn(),
+    };
+
+    jest.clearAllMocks();
+    (PaginationWrapper as unknown as jest.Mock).mockImplementation(() => ({
+      request:   jest.fn().mockResolvedValue({ data: [] }),
+      onDestroy: jest.fn(),
+    }));
+  });
+
+  describe('class: TopLevelMenuHelperLegacy', () => {
+    it('should dispatch findAll for CAPI.RANCHER_CLUSTER on init if schema exists', () => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      new TopLevelMenuHelperLegacy({ $store: mockStore });
+      expect(mockStore.dispatch).toHaveBeenCalledWith('management/findAll', { type: CAPI.RANCHER_CLUSTER });
+    });
+
+    it('should not dispatch findAll if schema does not exist', () => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(false);
+      new TopLevelMenuHelperLegacy({ $store: mockStore });
+      expect(mockStore.dispatch).not.toHaveBeenCalled();
+    });
+
+    it('should filter and sort clusters correctly in update', async() => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      const mgmtClusters = [
+        {
+          id: 'c1', nameDisplay: 'Cluster 1', isReady: true, pinned: false, pin: jest.fn(), unpin: jest.fn()
+        },
+        {
+          id: 'c2', nameDisplay: 'Cluster 2', isReady: true, pinned: true, pin: jest.fn(), unpin: jest.fn()
+        },
+        {
+          id: 'local', nameDisplay: 'Local', isReady: true, pinned: true, isLocal: true, pin: jest.fn(), unpin: jest.fn()
+        },
+      ];
+      const provClusters = [
+        { mgmt: { id: 'c1' } },
+        { mgmt: { id: 'c2' } },
+        { mgmt: { id: 'local' } },
+      ];
+
+      mockStore.getters['management/all'].mockImplementation((type: string) => {
+        if (type === MANAGEMENT.CLUSTER) {
+          return mgmtClusters;
+        }
+        if (type === CAPI.RANCHER_CLUSTER) {
+          return provClusters;
+        }
+
+        return [];
+      });
+
+      const helper = new TopLevelMenuHelperLegacy({ $store: mockStore });
+
+      // Test with no search, expecting pinned clusters (local + c2)
+      await helper.update({
+        searchTerm: '',
+        pinnedIds:  [],
+      });
+
+      expect(helper.clustersPinned).toHaveLength(2);
+      expect(helper.clustersPinned[0].id).toBe('local');
+      expect(helper.clustersPinned[1].id).toBe('c2');
+      expect(helper.clustersOthers).toHaveLength(1);
+      expect(helper.clustersOthers[0].id).toBe('c1');
+
+      // Test with search
+      await helper.update({
+        searchTerm: 'Cluster 1',
+        pinnedIds:  [],
+      });
+
+      expect(helper.clustersOthers).toHaveLength(1);
+      expect(helper.clustersOthers[0].id).toBe('c1');
+    });
+  });
+
+  describe('class: TopLevelMenuHelperPagination', () => {
+    it('should initialize PaginationWrappers', () => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      new TopLevelMenuHelperPagination({ $store: mockStore });
+      expect(PaginationWrapper).toHaveBeenCalledTimes(3);
+    });
+
+    it('should update clusters correctly', async() => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      const mgmtPinned = [{
+        id: 'c1', nameDisplay: 'Pinned', isReady: true, pinned: true, pin: jest.fn(), unpin: jest.fn()
+      }];
+      const mgmtOthers = [{
+        id: 'c2', nameDisplay: 'Other', isReady: true, pinned: false, pin: jest.fn(), unpin: jest.fn()
+      }];
+      const provClusters = [
+        { mgmtClusterId: 'c1' },
+        { mgmtClusterId: 'c2' }
+      ];
+
+      const mockRequestPinned = jest.fn().mockResolvedValue({ data: mgmtPinned });
+      const mockRequestOthers = jest.fn().mockResolvedValue({ data: mgmtOthers });
+      const mockRequestProv = jest.fn().mockResolvedValue({ data: provClusters });
+
+      (PaginationWrapper as unknown as jest.Mock)
+        .mockImplementationOnce(() => ({ request: mockRequestPinned, onDestroy: jest.fn() }))
+        .mockImplementationOnce(() => ({ request: mockRequestOthers, onDestroy: jest.fn() }))
+        .mockImplementationOnce(() => ({ request: mockRequestProv, onDestroy: jest.fn() }));
+
+      const helper = new TopLevelMenuHelperPagination({ $store: mockStore });
+
+      const input = {
+        searchTerm: '',
+        pinnedIds:  ['c1'],
+      };
+
+      await helper.update(input);
+
+      expect(mockRequestPinned).toHaveBeenCalledWith({
+        forceWatch: undefined,
+        pagination: {
+          filters: [{
+            equals: true,
+            fields: [{
+              equals: true, exact: true, field: 'id', value: input.pinnedIds[0]
+            }],
+            param: 'filter'
+          }],
+          page:                 1,
+          projectsOrNamespaces: [],
+          sort:                 [{ asc: false, field: 'spec.internal' }, { asc: false, field: 'status.connected' }, { asc: true, field: 'spec.displayName' }]
+        },
+        revision: undefined
+      });
+      expect(mockRequestOthers).toHaveBeenCalledWith({
+        forceWatch: undefined,
+        pagination: {
+          filters: [{
+            equals: true,
+            fields: [{
+              equality: '!=', equals: false, exact: true, exists: false, field: 'id', value: input.pinnedIds[0]
+            }],
+            param: 'filter'
+          }],
+          page:                 1,
+          pageSize:             undefined,
+          projectsOrNamespaces: [],
+          sort:                 [{ asc: false, field: 'spec.internal' }, { asc: false, field: 'status.connected' }, { asc: true, field: 'spec.displayName' }]
+        },
+        revision: undefined
+      });
+      expect(mockRequestProv).toHaveBeenCalledWith({
+        forceWatch: undefined,
+        pagination: {
+          filters: [{
+            equals: true,
+            fields: [{
+              equals: true, exact: true, field: 'status.clusterName', value: mgmtOthers[0].id
+            }, {
+              equals: true, exact: true, field: 'status.clusterName', value: mgmtPinned[0].id
+            }],
+            param: 'filter'
+          }],
+          page:                 1,
+          projectsOrNamespaces: [],
+          sort:                 []
+        },
+        revision: undefined
+      });
+
+      expect(helper.clustersPinned).toHaveLength(1);
+      expect(helper.clustersPinned[0].id).toBe('c1');
+      expect(helper.clustersOthers).toHaveLength(1);
+      expect(helper.clustersOthers[0].id).toBe('c2');
+    });
+
+    it('should filter out mgmt clusters without matching prov clusters', async() => {
+      mockStore.getters['management/schemaFor'].mockReturnValue(true);
+      const mgmtOthers = [{
+        id: 'c2', nameDisplay: 'Other', isReady: true, pinned: false, pin: jest.fn(), unpin: jest.fn()
+      }];
+      // No prov cluster for c2
+      const provClusters: any[] = [];
+
+      const mockRequestPinned = jest.fn().mockResolvedValue({ data: [] });
+      const mockRequestOthers = jest.fn().mockResolvedValue({ data: mgmtOthers });
+      const mockRequestProv = jest.fn().mockResolvedValue({ data: provClusters });
+
+      (PaginationWrapper as unknown as jest.Mock)
+        .mockImplementationOnce(() => ({ request: mockRequestPinned, onDestroy: jest.fn() }))
+        .mockImplementationOnce(() => ({ request: mockRequestOthers, onDestroy: jest.fn() }))
+        .mockImplementationOnce(() => ({ request: mockRequestProv, onDestroy: jest.fn() }));
+
+      const helper = new TopLevelMenuHelperPagination({ $store: mockStore });
+
+      await helper.update({
+        searchTerm: '',
+        pinnedIds:  [],
+      });
+
+      expect(helper.clustersOthers).toHaveLength(0);
+    });
+  });
+
+  describe('class: TopLevelMenuHelperService', () => {
+    beforeEach(async() => {
+      await TopLevelMenuHelperService.reset();
+    });
+
+    it('should throw error if helper is accessed before init', () => {
+      expect(() => TopLevelMenuHelperService.helper).toThrow('Unable to use the side nav cluster helper (not initialised)');
+    });
+
+    it('should initialize with Legacy helper when pagination is disabled', () => {
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(false);
+
+      TopLevelMenuHelperService.init(mockStore);
+
+      expect(TopLevelMenuHelperService.helper).toBeInstanceOf(TopLevelMenuHelperLegacy);
+    });
+
+    it('should initialize with Pagination helper when pagination is enabled', () => {
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(true);
+
+      TopLevelMenuHelperService.init(mockStore);
+
+      expect(TopLevelMenuHelperService.helper).toBeInstanceOf(TopLevelMenuHelperPagination);
+    });
+
+    it('should not re-initialize if already initialized', () => {
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(false);
+      TopLevelMenuHelperService.init(mockStore);
+      const helper1 = TopLevelMenuHelperService.helper;
+
+      // Change condition
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(true);
+      TopLevelMenuHelperService.init(mockStore);
+      const helper2 = TopLevelMenuHelperService.helper;
+
+      expect(helper1).toBe(helper2);
+      expect(helper2).toBeInstanceOf(TopLevelMenuHelperLegacy);
+    });
+
+    it('should reset correctly', async() => {
+      mockStore.getters['management/paginationEnabled'].mockReturnValue(false);
+      TopLevelMenuHelperService.init(mockStore);
+
+      const helper = TopLevelMenuHelperService.helper;
+      const destroySpy = jest.spyOn(helper, 'destroy');
+
+      await TopLevelMenuHelperService.reset();
+
+      expect(destroySpy).toHaveBeenCalledWith();
+      expect(() => TopLevelMenuHelperService.helper).toThrow('Unable to use the side nav cluster helper (not initialised)');
+    });
+  });
+});

package/components/nav/__tests__/TopLevelMenu.test.ts

@@ -5,6 +5,15 @@ import { PINNED_CLUSTERS } from '@shell/store/prefs';
 import { nextTick } from 'vue';
 import sideNavService from '@shell/components/nav/TopLevelMenu.helper';
 
+jest.mock('@shell/utils/pagination-wrapper', () => {
+  return jest.fn().mockImplementation(() => {
+    return {
+      request:   jest.fn().mockResolvedValue({ data: [] }),
+      onDestroy: jest.fn(),
+    };
+  });
+});
+
 /**
  * `clusters` doubles up as both mgmt and prov clusters (don't shoot the messenger)
  */
@@ -55,11 +64,14 @@ describe('topLevelMenu', () => {
   beforeEach(() => {
     jest.useFakeTimers();
     sideNavService.reset();
+    sideNavService.initialized = false;
+    jest.restoreAllMocks();
   });
 
   afterEach(() => {
     jest.runOnlyPendingTimers();
     jest.useRealTimers();
+    jest.restoreAllMocks();
   });
 
   it('should display clusters', async() => {
@@ -434,8 +446,6 @@ describe('topLevelMenu', () => {
     describe('should displays a no results message if have clusters but', () => {
       it('given no matching clusters', async() => {
         const wrapper: Wrapper<InstanceType<typeof TopLevelMenu>> = mount(TopLevelMenu, {
-          data: () => ({ clusterFilter: 'whatever' }),
-
           global: {
             mocks: {
               $route: {},
@@ -454,6 +464,8 @@ describe('topLevelMenu', () => {
           },
         });
 
+        await wrapper.setData({ clusterFilter: 'whatever' });
+
         await waitForIt();
 
         const noResults = wrapper.find('[data-testid="top-level-menu-no-results"]');
@@ -527,8 +539,6 @@ describe('topLevelMenu', () => {
       it('given clusters with status pinned', async() => {
         const search = 'you found me';
         const wrapper: Wrapper<InstanceType<typeof TopLevelMenu>> = mount(TopLevelMenu, {
-          data: () => ({ clusterFilter: search }),
-
           global: {
             mocks: {
               $route: {},
@@ -548,6 +558,8 @@ describe('topLevelMenu', () => {
           },
         });
 
+        await wrapper.setData({ clusterFilter: search });
+
         await waitForIt();
 
         const noResults = wrapper.find('[data-testid="top-level-menu-no-results"]');
@@ -557,4 +569,148 @@ describe('topLevelMenu', () => {
       });
     });
   });
+
+  describe('initialization', () => {
+    it('should initialize sideNavService', () => {
+      const spyInit = jest.spyOn(sideNavService, 'init');
+
+      mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: { ...generateStore([]) },
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(spyInit).toHaveBeenCalled(); // eslint-disable-line jest/prefer-called-with
+    });
+
+    it('should call helper.update if pagination is disabled', () => {
+      const store = generateStore([]);
+
+      store.getters['management/paginationEnabled'] = () => false;
+
+      jest.spyOn(sideNavService, 'init').mockImplementation(() => {});
+      const updateSpy = jest.fn();
+      const mockHelper = {
+        update: updateSpy, clustersPinned: [], clustersOthers: []
+      };
+
+      jest.spyOn(sideNavService, 'helper', 'get').mockReturnValue(mockHelper as any);
+
+      mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(updateSpy).toHaveBeenCalledWith({
+        pinnedIds: [], searchTerm: '', unPinnedMax: 10
+      });
+    });
+
+    it('should call helper.update if pagination is enabled but service not initialized', () => {
+      const store = generateStore([]);
+
+      store.getters['management/paginationEnabled'] = () => true;
+      sideNavService.initialized = false;
+
+      jest.spyOn(sideNavService, 'init').mockImplementation(() => {});
+      const updateSpy = jest.fn();
+      const mockHelper = {
+        update: updateSpy, clustersPinned: [], clustersOthers: []
+      };
+
+      jest.spyOn(sideNavService, 'helper', 'get').mockReturnValue(mockHelper as any);
+
+      mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(updateSpy).toHaveBeenCalledWith({
+        pinnedIds: [], searchTerm: '', unPinnedMax: 10
+      });
+    });
+
+    it('should NOT call helper.update if pagination is enabled and service initialized', () => {
+      const store = generateStore([]);
+
+      store.getters['management/paginationEnabled'] = () => true;
+      sideNavService.initialized = true;
+
+      jest.spyOn(sideNavService, 'init').mockImplementation(() => {});
+      const updateSpy = jest.fn();
+      const mockHelper = {
+        update: updateSpy, clustersPinned: [], clustersOthers: []
+      };
+
+      jest.spyOn(sideNavService, 'helper', 'get').mockReturnValue(mockHelper as any);
+
+      mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(updateSpy).not.toHaveBeenCalled();
+    });
+
+    it('should populate clusters from store if pagination is disabled', () => {
+      const clusters = [{ id: 'c1' }];
+      const store = generateStore(clusters);
+
+      store.getters['management/paginationEnabled'] = () => false;
+      store.getters['management/schemaFor'] = () => true;
+
+      const wrapper = mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(wrapper.vm.provClusters).toStrictEqual(clusters);
+      expect(wrapper.vm.mgmtClusters).toStrictEqual(clusters);
+    });
+
+    it('should NOT populate clusters from store if pagination is enabled', () => {
+      const clusters = [{ id: 'c1' }];
+      const store = generateStore(clusters);
+
+      store.getters['management/paginationEnabled'] = () => true;
+      store.getters['management/schemaFor'] = () => true;
+
+      const wrapper = mount(TopLevelMenu, {
+        global: {
+          mocks: {
+            $route: {},
+            $store: store,
+          },
+          stubs: ['BrandImage', 'router-link'],
+        },
+      });
+
+      expect(wrapper.vm.provClusters).toStrictEqual([]);
+      expect(wrapper.vm.mgmtClusters).toStrictEqual([]);
+    });
+  });
 });

package/components/templates/default.vue

@@ -18,7 +18,6 @@ import Inactivity from '@shell/components/Inactivity';
 import Brand from '@shell/mixins/brand';
 import FixedBanner from '@shell/components/FixedBanner';
 import AwsComplianceBanner from '@shell/components/AwsComplianceBanner';
-import AzureWarning from '@shell/components/auth/AzureWarning';
 import { MANAGEMENT } from '@shell/config/types';
 import { markSeenReleaseNotes } from '@shell/utils/version';
 import PageHeaderActions from '@shell/mixins/page-actions';
@@ -43,7 +42,6 @@ export default {
     WindowManager,
     FixedBanner,
     AwsComplianceBanner,
-    AzureWarning,
     Inactivity,
     SideNav,
   },
@@ -163,7 +161,6 @@ export default {
   <div class="dashboard-root">
     <FixedBanner :header="true" />
     <AwsComplianceBanner v-if="managementReady" />
-    <AzureWarning v-if="managementReady" />
     <div
       v-if="managementReady"
       class="dashboard-content"

package/components/templates/home.vue

@@ -7,7 +7,6 @@ import ModalManager from '@shell/components/ModalManager';
 import SlideInPanelManager from '@shell/components/SlideInPanelManager';
 import { mapPref, THEME_SHORTCUT } from '@shell/store/prefs';
 import AwsComplianceBanner from '@shell/components/AwsComplianceBanner';
-import AzureWarning from '@shell/components/auth/AzureWarning';
 import BrowserTabVisibility from '@shell/mixins/browser-tab-visibility';
 import Inactivity from '@shell/components/Inactivity';
 import { mapState, mapGetters } from 'vuex';
@@ -23,7 +22,6 @@ export default {
     GrowlManager,
     ModalManager,
     SlideInPanelManager,
-    AzureWarning,
     AwsComplianceBanner,
     Inactivity,
     PromptModal,
@@ -64,7 +62,6 @@ export default {
     <FixedBanner :header="true" />
     <Inactivity />
     <AwsComplianceBanner />
-    <AzureWarning />
     <PromptModal />
     <ModalManager />
     <div

package/components/templates/plain.vue

@@ -10,7 +10,6 @@ import GrowlManager from '@shell/components/GrowlManager';
 import ModalManager from '@shell/components/ModalManager';
 import SlideInPanelManager from '@shell/components/SlideInPanelManager';
 import AwsComplianceBanner from '@shell/components/AwsComplianceBanner';
-import AzureWarning from '@shell/components/auth/AzureWarning';
 import BrowserTabVisibility from '@shell/mixins/browser-tab-visibility';
 import Inactivity from '@shell/components/Inactivity';
 import { mapGetters } from 'vuex';
@@ -31,7 +30,6 @@ export default {
     ModalManager,
     SlideInPanelManager,
     AwsComplianceBanner,
-    AzureWarning,
     Inactivity,
     WindowManager
   },
@@ -67,7 +65,6 @@ export default {
   <div class="dashboard-root">
     <FixedBanner :header="true" />
     <AwsComplianceBanner />
-    <AzureWarning />
 
     <div
       class="dashboard-content"

package/composables/useClickOutside.ts

@@ -76,6 +76,6 @@ export const useClickOutside = <T extends OnClickOutsideOptions>(
 
   onBeforeUnmount(() => {
     window.removeEventListener('click', listener as any);
-    window.removeEventListener('pointerDown', setShouldListen);
+    window.removeEventListener('pointerdown', setShouldListen);
   });
 };

package/config/product/explorer.js

@@ -196,7 +196,7 @@ export function init(store) {
   configureType(SECRET, { showListMasthead: false });
   weightType(SECRET, 1, false);
 
-  configureType(VIRTUAL_TYPES.PROJECT_SECRETS, { showListMasthead: false });
+  configureType(VIRTUAL_TYPES.PROJECT_SECRETS, { showListMasthead: false, resource: SECRET });
   weightType(VIRTUAL_TYPES.PROJECT_SECRETS, 2, false);
 
   configureType(EVENT, { limit: 500 });
@@ -647,7 +647,6 @@ export function init(store) {
       name:   'c-cluster-product-resource',
       params: { resource: VIRTUAL_TYPES.PROJECT_SECRETS }
     },
-    exact:      true,
     ifHaveType: [{
       store: 'management',
       type:  SECRET

package/config/types.js

@@ -81,7 +81,11 @@ export const RBAC = {
 
 export const WORKLOAD = 'workload';
 
-// The types that are aggregated into a "workload"
+/**
+ * Rancher Workload types
+ *
+ * The types that are aggregated into a "workload"
+ */
 export const WORKLOAD_TYPES = {
   DEPLOYMENT:             'apps.deployment',
   CRON_JOB:               'batch.cronjob',
@@ -92,15 +96,44 @@ export const WORKLOAD_TYPES = {
   REPLICATION_CONTROLLER: 'replicationcontroller',
 };
 
+/**
+ * Kube Workload Kinds
+ */
+export const WORKLOAD_KINDS = {
+  DEPLOYMENT:             'Deployment',
+  CRON_JOB:               'CronJob',
+  DAEMON_SET:             'DaemonSet',
+  JOB:                    'Job',
+  STATEFUL_SET:           'StatefulSet',
+  REPLICA_SET:            'ReplicaSet',
+  REPLICATION_CONTROLLER: 'ReplicationController',
+};
+
+/**
+ * Map Rancher Workload types to Kube Workload Kinds
+ */
 export const WORKLOAD_TYPE_TO_KIND_MAPPING = {
   // Each deployment creates a replicaset and the metrics are published for a replicaset.
-  [WORKLOAD_TYPES.DEPLOYMENT]:             'ReplicaSet',
-  [WORKLOAD_TYPES.CRON_JOB]:               'CronJob',
-  [WORKLOAD_TYPES.DAEMON_SET]:             'DaemonSet',
-  [WORKLOAD_TYPES.JOB]:                    'Job',
-  [WORKLOAD_TYPES.STATEFUL_SET]:           'StatefulSet',
-  [WORKLOAD_TYPES.REPLICA_SET]:            'ReplicaSet',
-  [WORKLOAD_TYPES.REPLICATION_CONTROLLER]: 'ReplicationController',
+  [WORKLOAD_TYPES.DEPLOYMENT]:             WORKLOAD_KINDS.DEPLOYMENT,
+  [WORKLOAD_TYPES.CRON_JOB]:               WORKLOAD_KINDS.CRON_JOB,
+  [WORKLOAD_TYPES.DAEMON_SET]:             WORKLOAD_KINDS.DAEMON_SET,
+  [WORKLOAD_TYPES.JOB]:                    WORKLOAD_KINDS.JOB,
+  [WORKLOAD_TYPES.STATEFUL_SET]:           WORKLOAD_KINDS.STATEFUL_SET,
+  [WORKLOAD_TYPES.REPLICA_SET]:            WORKLOAD_KINDS.REPLICA_SET,
+  [WORKLOAD_TYPES.REPLICATION_CONTROLLER]: WORKLOAD_KINDS.REPLICATION_CONTROLLER,
+};
+
+/**
+ * Map Kube Workload Kinds types to Rancher Workload
+ */
+export const WORKLOAD_KIND_TO_TYPE_MAPPING = {
+  [WORKLOAD_KINDS.DEPLOYMENT]:             WORKLOAD_TYPES.DEPLOYMENT,
+  [WORKLOAD_KINDS.CRON_JOB]:               WORKLOAD_TYPES.CRON_JOB,
+  [WORKLOAD_KINDS.DAEMON_SET]:             WORKLOAD_TYPES.DAEMON_SET,
+  [WORKLOAD_KINDS.JOB]:                    WORKLOAD_TYPES.JOB,
+  [WORKLOAD_KINDS.STATEFUL_SET]:           WORKLOAD_TYPES.STATEFUL_SET,
+  [WORKLOAD_KINDS.REPLICA_SET]:            WORKLOAD_TYPES.REPLICA_SET,
+  [WORKLOAD_KINDS.REPLICATION_CONTROLLER]: WORKLOAD_TYPES.REPLICATION_CONTROLLER,
 };
 
 export const METRICS_SUPPORTED_KINDS = [