@rancher/shell 3.0.6 → 3.0.7

package/pages/c/_cluster/uiplugins/index.vue

@@ -1,9 +1,10 @@
 <script>
 import { mapGetters } from 'vuex';
+import day from 'dayjs';
 import { mapPref, PLUGIN_DEVELOPER } from '@shell/store/prefs';
 import { sortBy } from '@shell/utils/sort';
 import { allHash } from '@shell/utils/promise';
-import { CATALOG, UI_PLUGIN, MANAGEMENT } from '@shell/config/types';
+import { CATALOG, UI_PLUGIN, MANAGEMENT, ZERO_TIME } from '@shell/config/types';
 import { SETTING } from '@shell/config/settings';
 import { fetchOrCreateSetting } from '@shell/utils/settings';
 import { getVersionData, isRancherPrime } from '@shell/config/version';
@@ -40,10 +41,8 @@ const MAX_DESCRIPTION_LENGTH = 200;
 
 const TABS_VALUES = {
   INSTALLED: 'installed',
-  UPDATES:   'updates',
   AVAILABLE: 'available',
   BUILTIN:   'builtin',
-  ALL:       'all',
 };
 
 export default {
@@ -67,7 +66,7 @@ export default {
     return {
       TABS_VALUES,
       kubeVersion:                    null,
-      view:                           '',
+      activeTab:                      '',
       installing:                     {},
       errors:                         {},
       plugins:                        [], // The installed plugins
@@ -122,11 +121,6 @@ export default {
 
     this.addExtensionReposBannerSetting = await fetchOrCreateSetting(this.$store, SETTING.ADD_EXTENSION_REPOS_BANNER_DISPLAY, 'true', true) || {};
 
-    // If there are no plugins installed, default to the catalog view
-    if (this.plugins.length === 0) {
-      this.$refs.tabs?.select(TABS_VALUES.AVAILABLE);
-    }
-
     this.loading = false;
   },
 
@@ -207,12 +201,10 @@ export default {
       // If not an extension developer, then don't include built-in extensions
       const all = this.pluginDeveloper ? this.available : this.available.filter((p) => !p.builtin);
 
-      switch (this.view) {
+      switch (this.activeTab) {
       case TABS_VALUES.INSTALLED:
         // We never show built-in extensions as installed - installed are just the ones the user has installed
-        return all.filter((p) => !p.builtin && (!!p.installed || !!p.installing));
-      case TABS_VALUES.UPDATES:
-        return this.updates;
+        return all.filter((p) => !p.builtin && (!!p.installed || !!p.installing) && p.installableVersions?.length > 0);
       case TABS_VALUES.AVAILABLE:
         return all.filter((p) => !p.installed);
       case TABS_VALUES.BUILTIN:
@@ -226,14 +218,14 @@ export default {
       return this.menuActions?.length > 0;
     },
 
-    // Message to display when the tab view is empty (depends on the tab)
+    // Message to display when the active tab is empty (depends on the tab)
     emptyMessage() {
       // i18n-uses plugins.empty.*
-      return this.t(`plugins.empty.${ this.view }`);
+      return this.t(`plugins.empty.${ this.activeTab }`);
     },
 
-    updates() {
-      return this.available.filter((plugin) => !!plugin.upgrade);
+    installed() {
+      return this.available.filter((p) => !p.builtin && (!!p.installed || !!p.installing));
     },
 
     pluginCards() {
@@ -298,6 +290,7 @@ export default {
           item.displayVersion = latestCompatible.version;
           item.displayVersionLabel = getPluginChartVersionLabel(latestCompatible);
           item.icon = latestCompatible.icon;
+          item.created = latestCompatible.created;
         } else {
           item.experimental = uiPluginHasAnnotation(chart, CATALOG_ANNOTATIONS.EXPERIMENTAL, 'true');
           item.certified = uiPluginHasAnnotation(chart, CATALOG_ANNOTATIONS.CERTIFIED, CATALOG_ANNOTATIONS._RANCHER);
@@ -305,6 +298,7 @@ export default {
           item.displayVersion = item.versions?.[0]?.version;
           item.displayVersionLabel = getPluginChartVersionLabel(item.versions?.[0]);
           item.icon = chart.icon || latestCompatible?.annotations?.['catalog.cattle.io/ui-icon'];
+          item.created = item.versions?.[0]?.created;
         }
 
         // add message of extension card if there's a newer version of the extension, but it's not available to be installed
@@ -353,6 +347,7 @@ export default {
             displayVersion:      p.metadata?.version,
             displayVersionLabel: p.metadata?.version || '-',
             installed:           true,
+            installedVersion:    p.metadata?.version,
             builtin:             !!p.builtin,
             experimental:        rancher?.annotations?.[CATALOG_ANNOTATIONS.EXPERIMENTAL] === 'true',
             certified:           rancher?.annotations?.[CATALOG_ANNOTATIONS.CERTIFIED] === CATALOG_ANNOTATIONS._RANCHER
@@ -373,8 +368,7 @@ export default {
         if (chart) {
           chart.installed = true;
           chart.uiplugin = p;
-          chart.displayVersion = p.version;
-          let displayVersionLabel = p.version;
+          chart.installedVersion = p.version;
 
           // Can't do this here
           chart.installing = this.installing[chart.name];
@@ -389,13 +383,10 @@ export default {
             if (installedVersion) {
               chart.experimental = installedVersion?.annotations?.[CATALOG_ANNOTATIONS.EXPERIMENTAL] === 'true';
               chart.certified = installedVersion?.annotations?.[CATALOG_ANNOTATIONS.CERTIFIED] === CATALOG_ANNOTATIONS._RANCHER;
-              displayVersionLabel = getPluginChartVersionLabel(installedVersion);
             }
 
             chart.upgrade = getPluginChartVersionLabel(latestInstallableVersion);
           }
-
-          chart.displayVersionLabel = displayVersionLabel;
         } else {
           // No chart, so add a card for the plugin based on its Custom resource being present
           const item = {
@@ -474,10 +465,10 @@ export default {
 
             if (active) {
             // Can use the status directly, apart from upgrade, which maps to update
-              const status = op.status.action === 'upgrade' ? 'update' : op.status.action;
+              const status = op.status.action;
 
-              if (status === 'update' && this.installing[plugin.name] === 'rollback') {
-                // Helm op is an upgrade, but we initiated a rollback, so keep the 'rollback' status
+              if (status === 'upgrade' && this.installing[plugin.name] === 'downgrade') {
+                // Helm op is an upgrade, but we initiated a downgrade, so keep the 'downgrade' status
               } else {
                 this.updatePluginInstallStatus(plugin.name, status);
               }
@@ -535,6 +526,16 @@ export default {
   },
 
   methods: {
+    handlePanelAction(button) {
+      const { action, plugin, version } = button;
+
+      if (action === 'uninstall') {
+        this.showUninstallDialog(plugin, {});
+      } else {
+        this.showInstallDialog(plugin, action, {}, version);
+      }
+    },
+
     async refreshCharts(forceChartsUpdate = false) {
       // we might need to force the request, so that we know at all times if what's the status of the offical and partners repos (installed or not)
       // tied to the SetupUIPlugins, AddExtensionRepos checkboxes
@@ -560,8 +561,8 @@ export default {
       return hasFeatureFlag;
     },
 
-    filterChanged(f) {
-      this.view = f.selectedName;
+    tabChanged(f) {
+      this.activeTab = f.selectedName;
     },
 
     // Developer Load is in the action menu
@@ -623,10 +624,10 @@ export default {
       });
     },
 
-    showInstallDialog(plugin, action, ev) {
-      ev.target?.blur();
-      ev.preventDefault();
-      ev.stopPropagation();
+    showInstallDialog(plugin, action, ev, initialVersion = null) {
+      ev?.target?.blur();
+      ev?.preventDefault?.();
+      ev?.stopPropagation?.();
 
       this.$store.dispatch('management/promptModal', {
         component:                            'InstallExtensionDialog',
@@ -636,6 +637,7 @@ export default {
         componentProps:                       {
           plugin,
           action,
+          initialVersion,
           updateStatus: (pluginName, type) => {
             this.updatePluginInstallStatus(pluginName, type);
           },
@@ -647,9 +649,9 @@ export default {
     },
 
     showUninstallDialog(plugin, ev) {
-      ev.target?.blur();
-      ev.preventDefault();
-      ev.stopPropagation();
+      ev?.target?.blur();
+      ev?.preventDefault?.();
+      ev?.stopPropagation?.();
 
       this.$store.dispatch('management/promptModal', {
         component:                            'UninstallExtensionDialog',
@@ -683,7 +685,7 @@ export default {
 
     didInstall(plugin) {
       if (plugin) {
-        // Change the view to installed if we started installing a plugin
+        // Change the activeTab to installed if we started installing a plugin
         this.$refs.tabs?.select(TABS_VALUES.INSTALLED);
 
         // Clear the load error, if there was one previously
@@ -692,7 +694,9 @@ export default {
     },
 
     showPluginDetail(plugin) {
-      this.$refs.infoPanel.show(plugin);
+      const tags = this.getFooterItems(plugin);
+
+      this.$refs.infoPanel.show({ ...plugin, tags });
     },
 
     updatePluginInstallStatus(name, status) {
@@ -741,42 +745,46 @@ export default {
     getPluginActions(plugin) {
       const actions = [];
 
-      const canInstall = !plugin.installed && plugin.installableVersions?.length;
-      const canUninstall = plugin.installed && !plugin.builtin;
-      const canUpdate = plugin.installed && plugin.upgrade;
-      const canRollback = plugin.installed && !plugin.upgrade && plugin.installableVersions?.length > 1;
-
-      if (canUninstall) {
-        actions.push({
-          label:  this.t('plugins.uninstall.label'),
-          action: 'uninstall',
-          icon:   'icon-delete',
-        });
-      }
-
-      if (canUpdate) {
-        actions.push({
-          label:  this.t('plugins.update.label'),
-          action: 'update',
-          icon:   'icon-edit',
-        });
-      }
+      if (plugin.installed) {
+        const canUpdate = !!plugin.upgrade;
+        const canDowngrade = plugin.installableVersions?.some((v) => isChartVersionHigher(plugin.installedVersion, v.version));
+        const canUninstall = !plugin.builtin;
+
+        if (canUpdate) {
+          actions.push({
+            label:  this.t('plugins.upgrade.label'),
+            action: 'upgrade',
+            icon:   'icon-upgrade-alt',
+          });
+        }
 
-      if (canRollback) {
-        actions.push({
-          label:  this.t('plugins.rollback.label'),
-          action: 'rollback',
-          icon:   'icon-history',
-        });
-      }
+        if (canDowngrade) {
+          actions.push({
+            label:  this.t('plugins.downgrade.label'),
+            action: 'downgrade',
+            icon:   'icon-downgrade-alt',
+          });
+        }
 
-      if (canInstall) {
-        actions.push({
-          label:   this.t('plugins.install.label'),
-          action:  'install',
-          icon:    'icon-plus',
-          enabled: true,
-        });
+        if (canUninstall) {
+          if (actions.length > 0) {
+            actions.push({ divider: true });
+          }
+          actions.push({
+            label:  this.t('plugins.uninstall.label'),
+            action: 'uninstall',
+            icon:   'icon-delete',
+          });
+        }
+      } else {
+        if (plugin.installableVersions?.length) {
+          actions.push({
+            label:   this.t('plugins.install.label'),
+            action:  'install',
+            icon:    'icon-plus',
+            enabled: true,
+          });
+        }
       }
 
       return actions;
@@ -784,12 +792,25 @@ export default {
 
     getSubHeaderItems(plugin) {
       const items = [{
-        icon:         'icon-version-alt',
-        iconTooltip:  { key: 'tableHeaders.version' },
-        label:        plugin.displayVersionLabel,
-        labelTooltip: plugin.upgrade ? this.t('plugins.upgradeAvailableTooltip', { version: plugin.upgrade }) : ''
+        icon:        'icon-version-alt',
+        iconTooltip: { key: 'tableHeaders.version' },
+        label:       plugin.displayVersionLabel,
       }];
 
+      if (plugin.created) {
+        const hasZeroTime = plugin.created === ZERO_TIME;
+        const lastUpdatedItem = {
+          icon:        'icon-refresh-alt',
+          iconTooltip: { key: 'tableHeaders.lastUpdated' },
+          label:       hasZeroTime ? this.t('generic.na') : day(plugin.created).format('MMM D, YYYY')
+        };
+
+        if (hasZeroTime) {
+          lastUpdatedItem.labelTooltip = this.t('catalog.charts.appChartCard.subHeaderItem.missingVersionDate');
+        }
+        items.push(lastUpdatedItem);
+      }
+
       if (plugin.installing) {
         let label;
 
@@ -800,11 +821,11 @@ export default {
         case 'uninstall':
           label = this.t('plugins.labels.uninstalling');
           break;
-        case 'update':
-          label = this.t('plugins.labels.updating');
+        case 'upgrade':
+          label = this.t('plugins.labels.upgrading');
           break;
-        case 'rollback':
-          label = this.t('plugins.labels.rollingBack');
+        case 'downgrade':
+          label = this.t('plugins.labels.downgrading');
           break;
         default:
           label = this.t('plugins.labels.installing');
@@ -874,7 +895,7 @@ export default {
 
       if (plugin.installed && !plugin.builtin && !plugin.installing) {
         statuses.push({
-          icon: 'icon-confirmation-alt', color: 'success', tooltip: { key: 'generic.installed' }
+          icon: 'icon-confirmation-alt', color: 'success', tooltip: { text: `${ this.t('generic.installed') } (${ plugin.installedVersion })` }
         });
       }
 
@@ -958,7 +979,10 @@ export default {
     </div>
 
     <!-- extensions slide-in panel -->
-    <PluginInfoPanel ref="infoPanel" />
+    <PluginInfoPanel
+      ref="infoPanel"
+      @action="handlePanelAction"
+    />
 
     <!-- extensions not enabled by feature flag -->
     <div v-if="!hasFeatureFlag">
@@ -1008,15 +1032,18 @@ export default {
         </Banner>
 
         <Tabbed
+          v-if="!loading"
           ref="tabs"
           :tabs-only="true"
           data-testid="extension-tabs"
-          @changed="filterChanged"
+          @changed="tabChanged"
         >
           <Tab
+            v-if="installed.length"
             :name="TABS_VALUES.INSTALLED"
             data-testid="extension-tab-installed"
             label-key="plugins.tabs.installed"
+            :badge="installed.length"
             :weight="20"
           />
           <Tab
@@ -1025,23 +1052,12 @@ export default {
             label-key="plugins.tabs.available"
             :weight="19"
           />
-          <Tab
-            :name="TABS_VALUES.UPDATES"
-            label-key="plugins.tabs.updates"
-            :weight="18"
-            :badge="updates.length"
-          />
           <Tab
             v-if="pluginDeveloper"
             :name="TABS_VALUES.BUILTIN"
             label-key="plugins.tabs.builtin"
             :weight="17"
           />
-          <Tab
-            :name="TABS_VALUES.ALL"
-            label-key="plugins.tabs.all"
-            :weight="16"
-          />
         </Tabbed>
         <div
           v-if="loading"
@@ -1079,8 +1095,8 @@ export default {
               :clickable="true"
               @card-click="showPluginDetail(card.plugin)"
               @uninstall="({event}) => showUninstallDialog(card.plugin, event)"
-              @update="({event}) => showInstallDialog(card.plugin, 'update', event)"
-              @rollback="({event}) => showInstallDialog(card.plugin, 'rollback', event)"
+              @upgrade="({event}) => showInstallDialog(card.plugin, 'upgrade', event)"
+              @downgrade="({event}) => showInstallDialog(card.plugin, 'downgrade', event)"
               @install="({event}) => showInstallDialog(card.plugin, 'install', event)"
             >
               <template #item-card-sub-header>

package/plugins/__tests__/subscribe.events.test.ts

@@ -0,0 +1,194 @@
+import { SteveWatchEventListenerManager } from '@shell/plugins/subscribe-events';
+import { STEVE_WATCH_EVENT_TYPES } from '@shell/types/store/subscribe.types';
+
+// Mock function to create a consistent key for testing
+const mockKeyForSubscribe = jest.fn(({
+  params: {
+    type, name, id, selector, mode
+  }
+}) => {
+  return `${ type }-${ name }-${ id }-${ selector }-${ mode }`;
+});
+
+// Mock parameters and callbacks
+const mockParams1 = {
+  type: 'pods', name: 'my-pod', id: 'abc-123', selector: 'app=test'
+};
+const mockCallback1 = jest.fn();
+const mockCallback2 = jest.fn();
+
+// The class under test
+let manager: SteveWatchEventListenerManager;
+
+describe('steveWatchEventListenerManager', () => {
+  beforeEach(() => {
+    // Reset the manager and mocks before each test
+    manager = new SteveWatchEventListenerManager();
+    jest.clearAllMocks();
+    // Replace the internal keyForSubscribe with our mock
+    (manager as any).keyForSubscribe = mockKeyForSubscribe;
+  });
+
+  describe('initialization and Properties', () => {
+    it('should be created successfully', () => {
+      expect(manager).toBeInstanceOf(SteveWatchEventListenerManager);
+    });
+
+    it('should have a supportedEventTypes array with STEVE_WATCH_EVENT_TYPES.CHANGES', () => {
+      expect(manager.supportedEventTypes).toStrictEqual([STEVE_WATCH_EVENT_TYPES.CHANGES]);
+    });
+
+    it('should correctly identify a supported event type', () => {
+      const isSupported = manager.isSupportedEventType(STEVE_WATCH_EVENT_TYPES.CHANGES);
+
+      expect(isSupported).toBe(true);
+    });
+
+    it('should correctly identify an unsupported event type', () => {
+      const isSupported = manager.isSupportedEventType('some.other.event' as STEVE_WATCH_EVENT_TYPES);
+
+      expect(isSupported).toBe(false);
+    });
+  });
+
+  describe('watch Management', () => {
+    it('should return undefined when getting a non-existent watch', () => {
+      const watch = manager.getWatch({ params: mockParams1 });
+
+      expect(watch).toBeUndefined();
+    });
+
+    it('should create a watch when setStandardWatch is called with standardWatch true and no watch exists', () => {
+      manager.setStandardWatch({ standardWatch: true, args: { params: mockParams1 } });
+      const watch = (manager as any).watches[mockKeyForSubscribe({ params: mockParams1 })];
+
+      expect(watch).toBeDefined();
+      expect(watch.hasStandardWatch).toBe(true);
+      expect(watch.listeners).toStrictEqual([]);
+    });
+
+    it('should not create a watch when setStandardWatch is called with standardWatch false and no watch exists', () => {
+      manager.setStandardWatch({ standardWatch: false, args: { params: mockParams1 } });
+      const watch = (manager as any).watches[mockKeyForSubscribe({ params: mockParams1 })];
+
+      expect(watch).toBeUndefined();
+    });
+
+    it('should delete a watch when hasStandardWatch becomes false and there are no listeners', () => {
+      manager.setStandardWatch({ standardWatch: true, args: { params: mockParams1 } });
+      manager.setStandardWatch({ standardWatch: false, args: { params: mockParams1 } });
+      const watch = (manager as any).watches[mockKeyForSubscribe({ params: mockParams1 })];
+
+      expect(watch).toBeUndefined();
+    });
+  });
+
+  describe('listener and Callback Management', () => {
+    it('should add a new listener and a callback', () => {
+      const listener = manager.addEventListenerCallback({
+        callback: mockCallback1,
+        args:     {
+          event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
+          params: mockParams1,
+          id:     'cb-1'
+        }
+      });
+
+      expect(listener).toBeDefined();
+      expect(listener.event).toBe(STEVE_WATCH_EVENT_TYPES.CHANGES);
+      expect(listener.callbacks['cb-1']).toBe(mockCallback1);
+      const watch = manager.getWatch({ params: mockParams1 });
+
+      expect(watch?.listeners.length).toBe(1);
+    });
+
+    it('should add a second callback to an existing listener', () => {
+      manager.addEventListenerCallback({
+        callback: mockCallback1,
+        args:     {
+          event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
+          params: mockParams1,
+          id:     'cb-1'
+        }
+      });
+      manager.addEventListenerCallback({
+        callback: mockCallback2,
+        args:     {
+          event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
+          params: mockParams1,
+          id:     'cb-2'
+        }
+      });
+
+      const listener = manager.getEventListener({ args: { event: STEVE_WATCH_EVENT_TYPES.CHANGES, params: mockParams1 } });
+
+      expect(Object.keys(listener?.callbacks || {})).toHaveLength(2);
+      expect(listener?.callbacks['cb-2']).toBe(mockCallback2);
+    });
+
+    it('should trigger a specific event listener and its callbacks', () => {
+      manager.addEventListenerCallback({
+        callback: mockCallback1,
+        args:     {
+          event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
+          params: mockParams1,
+          id:     'cb-1'
+        }
+      });
+      manager.addEventListenerCallback({
+        callback: mockCallback2,
+        args:     {
+          event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
+          params: mockParams1,
+          id:     'cb-2'
+        }
+      });
+
+      manager.triggerEventListener({ event: STEVE_WATCH_EVENT_TYPES.CHANGES, params: mockParams1 });
+      expect(mockCallback1).toHaveBeenCalledTimes(1);
+      expect(mockCallback2).toHaveBeenCalledTimes(1);
+    });
+
+    it('should remove a specific callback from a listener', () => {
+      manager.addEventListenerCallback({
+        callback: mockCallback1,
+        args:     {
+          event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
+          params: mockParams1,
+          id:     'cb-1'
+        }
+      });
+      manager.removeEventListenerCallback({
+        event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
+        params: mockParams1,
+        id:     'cb-1'
+      });
+      const listener = manager.getEventListener({ args: { event: STEVE_WATCH_EVENT_TYPES.CHANGES, params: mockParams1 } });
+
+      expect(listener?.callbacks['cb-1']).toBeUndefined();
+    });
+
+    it('should trigger all callbacks for a given watch', () => {
+      manager.addEventListenerCallback({
+        callback: mockCallback1,
+        args:     {
+          event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
+          params: mockParams1,
+          id:     'cb-1'
+        }
+      });
+      manager.addEventListenerCallback({
+        callback: mockCallback2,
+        args:     {
+          event:  'another.event' as STEVE_WATCH_EVENT_TYPES,
+          params: mockParams1,
+          id:     'cb-2'
+        }
+      });
+
+      manager.triggerAllEventListeners({ params: mockParams1 });
+      expect(mockCallback1).toHaveBeenCalledTimes(1);
+      expect(mockCallback2).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/plugins/dashboard-store/actions.js

@@ -220,6 +220,9 @@ export default {
       )
     ) {
       if (opt.watch !== false ) {
+        // Note - Empty revision here seems broken
+        // - list page (watch all) --> detail page (stop watch all, watch one) --> list page (watch all - no revision)
+        // - the missing revision means watch start from now... instead of the point the clusters were last monitored (cache contains stale data)
         const args = {
           type,
           revision:  '',

package/plugins/dashboard-store/getters.js

@@ -526,7 +526,7 @@ export default {
     const store = state.config.namespace;
     const resource = id || context ? { id, context } : null;
 
-    return paginationUtils.isEnabled({ rootGetters }, { store, resource });
+    return paginationUtils.isEnabled({ rootGetters, $plugin: rootState.$plugin }, { store, resource });
   },
 
   /**

package/plugins/dashboard-store/resource-class.js

@@ -62,7 +62,7 @@ const DEFAULT_COLOR = 'warning';
 const DEFAULT_ICON = 'x';
 
 const DEFAULT_WAIT_INTERVAL = 1000;
-const DEFAULT_WAIT_TMIMEOUT = 30000;
+const DEFAULT_WAIT_TIMEOUT = 30000;
 
 export const STATES_ENUM = {
   IN_USE:           'in-use',
@@ -806,7 +806,7 @@ export default class Resource {
   // ------------------------------------------------------------------
 
   waitForTestFn(fn, msg, timeoutMs, intervalMs) {
-    return waitFor(() => fn.apply(this), msg, timeoutMs || DEFAULT_WAIT_TMIMEOUT, intervalMs || DEFAULT_WAIT_INTERVAL, true);
+    return waitFor(() => fn.apply(this), msg, timeoutMs || DEFAULT_WAIT_TIMEOUT, intervalMs || DEFAULT_WAIT_INTERVAL, true);
   }
 
   waitForState(state, timeout, interval) {
@@ -855,7 +855,7 @@ export default class Resource {
     return (entry.status || '').toLowerCase() === `${ withStatus }`.toLowerCase();
   }
 
-  waitForCondition(name, withStatus = 'True', timeoutMs = DEFAULT_WAIT_TMIMEOUT, intervalMs = DEFAULT_WAIT_INTERVAL) {
+  waitForCondition(name, withStatus = 'True', timeoutMs = DEFAULT_WAIT_TIMEOUT, intervalMs = DEFAULT_WAIT_INTERVAL) {
     return this.waitForTestFn(() => {
       return this.isCondition(name, withStatus);
     }, `condition ${ name }=${ withStatus }`, timeoutMs, intervalMs);