dashboard-shell-shell 1.0.111

package/plugins/steve/__tests__/getters.test.ts

@@ -0,0 +1,214 @@
+import _getters from '@shell/plugins/steve/getters';
+
+const { urlFor, urlOptions, pathExistsInSchema } = _getters;
+
+describe('steve: getters:', () => {
+  describe('urlFor', () => {
+    // we're not testing function output based off of state or getter inputs here since they are dependencies
+    const baseUrl = '/v1';
+    const collectionUrl = 'https://abc.com/v1/urlFoo';
+    const namespace = 'myNamespace';
+    const state = { config: { baseUrl } };
+    const getters = {
+      normalizeType: (type: string) => type,
+      schemaFor:     (type: string) => {
+        if (type === 'rType') {
+          return { links: { collection: collectionUrl } };
+        }
+        if (type === 'trailingforwardslash') {
+          return { links: { collection: `${ collectionUrl }/` } };
+        }
+      },
+      // this has its own tests so it just returns the input string
+      urlOptions: (url: string, opt: any, type: string) => {
+        if (opt.addParam) {
+          url += '?param=true';
+        }
+
+        return url;
+      }
+    };
+
+    const urlForGetter = urlFor(state, getters);
+
+    // most tests for this getter will go through the dashboard-store getters test spec, this only tests logic specific to the steve variant
+
+    it.each([
+      ['rType', undefined, undefined, collectionUrl],
+
+      // No namespace
+      ['rType', undefined, { }, `${ collectionUrl }`],
+      ['rType', undefined, { addParam: true }, `${ collectionUrl }?param=true`],
+      ['rType', 'abc', { }, `${ collectionUrl }/abc`],
+      ['rType', 'abc', { addParam: true }, `${ collectionUrl }/abc?param=true`],
+
+      // With namespace
+      ['rType', undefined, { namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }`],
+      ['rType', undefined, { addParam: true, namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }?param=true`],
+      ['rType', 'abc', { namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }/abc`],
+      ['rType', 'abc', { addParam: true, namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }/abc?param=true`],
+
+      // With url (mostly no op)
+      ['rType', undefined, { url: `${ baseUrl }/urlFoo`, namespaced: `${ namespace }` }, `${ baseUrl }/urlFoo`],
+      ['rType', undefined, { url: `${ baseUrl }/urlFoo/abc`, namespaced: `${ namespace }` }, `${ baseUrl }/urlFoo/abc`],
+      ['rType', undefined, { url: `/urlFoo`, namespaced: `${ namespace }` }, `/urlFoo`],
+      ['rType', undefined, { url: `/urlFoo/abc`, namespaced: `${ namespace }` }, `/urlFoo/abc`],
+
+      // multiple namespaces (no op)
+      ['rType', undefined, { namespaced: [`${ namespace }`, 'nsBaz'] }, `${ collectionUrl }`],
+
+      // handle trailing space
+      ['trailingforwardslash', undefined, { namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }`],
+
+    ])("given type '%p', id '%p' and opt '%p', should get url '%p'", (type, id, opt, url) => {
+      expect(urlForGetter(type, id, opt)).toBe(url);
+    });
+  });
+
+  describe('urlOptions', () => {
+    // we're not testing function output based off of state or getter inputs here since they are dependencies
+    const state = { config: { baseUrl: 'protocol' } };
+    const getters = {
+      normalizeType: (type) => type,
+      // this has its own tests so it just returns the input string
+      urlOptions:    (string) => string
+    };
+
+    const urlOptionsGetter = urlOptions();
+
+    it('expects urlOptions to return a function', () => {
+      expect(typeof urlOptions(state, getters)).toBe('function');
+    });
+    it('returns undefined when called without params', () => {
+      expect(urlOptionsGetter()).toBeUndefined();
+    });
+    it('returns an unmodified string when called without options', () => {
+      expect(urlOptionsGetter('foo')).toBe('foo');
+    });
+    it('returns an unmodified string when called with options that are not accounted for', () => {
+      expect(urlOptionsGetter('foo', { bar: 'baz' })).toBe('foo');
+    });
+    it('returns a string with a single filter statement applied if a single filter statement is applied', () => {
+      expect(urlOptionsGetter('foo', { filter: { bar: 'baz' } })).toBe('foo?bar=baz');
+    });
+    it('returns a string with a single filter statement applied and formatted for steve if a single filter statement is applied and the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { filter: { bar: 'baz' } })).toBe('/v1/foo?filter=bar=baz&exclude=metadata.managedFields');
+    });
+    it('returns a string with a single filter statement applied and formatted for steve if a single filter statement is applied and the url starts with "/k8s/clusters/c-m-n4x45x4b/v1/"', () => {
+      expect(urlOptionsGetter('/k8s/clusters/c-m-n4x45x4b/v1/foo', { filter: { bar: 'baz' } })).toBe('/k8s/clusters/c-m-n4x45x4b/v1/foo?filter=bar=baz&exclude=metadata.managedFields');
+    });
+    it('returns a string with a multiple filter statements applied if a single filter statement is applied', () => {
+      expect(urlOptionsGetter('foo', { filter: { bar: 'baz', far: 'faz' } })).toBe('foo?bar=baz&far=faz');
+    });
+    it('returns a string with a multiple filter statements applied and formatted for steve if a single filter statement is applied and the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { filter: { bar: 'baz', far: 'faz' } })).toBe('/v1/foo?filter=bar=baz&far=faz&exclude=metadata.managedFields');
+    });
+    it('returns a string with a labelSelector and formatted for steve if the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { labelSelector: 'a=b' })).toBe('/v1/foo?labelSelector=a=b&exclude=metadata.managedFields');
+    });
+    it('returns a string with a labelSelector and filter, and formatted for steve if the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { labelSelector: 'a=b', filter: { bar: 'baz', far: 'faz' } })).toBe('/v1/foo?labelSelector=a=b&filter=bar=baz&far=faz&exclude=metadata.managedFields');
+    });
+    it('returns a string with an exclude statement for "bar" if excludeFields is a single element array with the string "bar" and the url starts with "/v1/"', () => {
+      expect(urlOptionsGetter('/v1/foo', { excludeFields: ['bar'] })).toBe('/v1/foo?exclude=bar');
+    });
+    it('returns a string without an exclude statement for "managedFields" if omitExcludeFields includes it and the url starts with "/v1/"', () => {
+      expect(urlOptionsGetter('/v1/foo', { omitExcludeFields: ['metadata.managedFields'] })).toBe('/v1/foo?');
+    });
+    it('returns a string without an exclude statement if excludeFields is set but the url does not start with "/v1/"', () => {
+      expect(urlOptionsGetter('foo', { excludeFields: ['bar'] })).toBe('foo');
+    });
+    it('returns a string without an exclude statement if excludeFields is an array but the URL doesn\'t include the "/v1/ string"', () => {
+      expect(urlOptionsGetter('foo', { excludeFields: ['bar'] })).toBe('foo');
+    });
+    it('returns a string with a limit applied if a limit is provided', () => {
+      expect(urlOptionsGetter('foo', { limit: 10 })).toBe('foo?limit=10');
+    });
+    it('returns a string with a sorting criteria if the sort option is provided', () => {
+      expect(urlOptionsGetter('foo', { sortBy: 'bar' })).toBe('foo?sort=bar');
+    });
+    it('returns a string with a sorting criteria formatted for steve if the sort option is provided and the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar' })).toBe('/v1/foo?sort=bar&exclude=metadata.managedFields');
+    });
+    it('returns a string with a sorting criteria if the sort option is provided and an order if sortOrder is provided', () => {
+      expect(urlOptionsGetter('foo', { sortBy: 'bar', sortOrder: 'baz' })).toBe('foo?sort=bar&order=baz');
+    });
+    it('returns a string with a sorting criteria formatted for steve if the sort option is provided and an order if sortOrder is provided and the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar', sortOrder: 'baz' })).toBe('/v1/foo?sort=bar&exclude=metadata.managedFields');
+    });
+    it('returns a string with a sorting criteria formatted for steve if the sort option is provided and an order if sortOrder is "desc" and the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar', sortOrder: 'desc' })).toBe('/v1/foo?sort=-bar&exclude=metadata.managedFields');
+    });
+  });
+
+  describe('pathExistsInSchema', () => {
+    const state = {};
+
+    const getters = { schemaFor: (type: string) => ({}) };
+
+    it('expects pathExistsInSchema to return a function', () => {
+      expect(typeof pathExistsInSchema(state, getters)).toBe('function');
+    });
+
+    describe('resourceFields', () => {
+      it('requires resourceFields but no resourceFields', () => {
+        expect(pathExistsInSchema(state, {
+          ...getters,
+          schemaFor: () => ({
+            requiresResourceFields: true,
+            hasResourceFields:      false,
+          })
+        })()).toBe(false);
+      });
+
+      it('requires resourceFields but empty resourceFields', () => {
+        expect(pathExistsInSchema(state, {
+          ...getters,
+          schemaFor: () => ({
+            requiresResourceFields: true,
+            hasResourceFields:      true,
+            schemaDefinitions:      {}
+          })
+        })('', 'name')).toBe(false);
+      });
+
+      it('requires resourceFields and has resourceFields', () => {
+        expect(pathExistsInSchema(state, {
+          ...getters,
+          schemaFor: () => ({
+            requiresResourceFields: true,
+            hasResourceFields:      true,
+            resourceFields:         { name: { type: 'string' } },
+            schemaDefinitions:      { name: { } },
+          })
+        })('n/a', 'name')).toBe(true);
+      });
+
+      it('requires nested resourceFields and has resourceFields', () => {
+        expect(pathExistsInSchema(state, {
+          ...getters,
+          schemaFor: (type) => {
+            const metadata = { resourceFields: { name: { type: 'string' } } };
+
+            switch (type) {
+            case 'root':
+              return {
+                requiresResourceFields: true,
+                hasResourceFields:      true,
+                resourceFields:         { metadata: { type: 'metadata' } },
+                schemaDefinitions:      { metadata: { ...metadata } },
+              };
+            case 'metadata':
+              return {
+                requiresResourceFields: true,
+                hasResourceFields:      true,
+                ...metadata,
+              };
+            }
+            expect(type).toBe('Something known');
+          }
+        })('root', 'metadata.name')).toBe(true);
+      });
+    });
+  });
+});

package/plugins/steve/__tests__/header-warnings.test.ts

@@ -0,0 +1,238 @@
+import { handleKubeApiHeaderWarnings } from '@shell/plugins/steve/header-warnings';
+import { DEFAULT_PERF_SETTING } from '@shell/config/settings';
+
+describe('steve: header-warnings', () => {
+  // eslint-disable-next-line jest/no-hooks
+
+  function setupMocks(settings = {
+    separator:             '299 - ',
+    notificationBlockList: ['299 - unknown field']
+  }) {
+    return {
+      dispatch:     jest.fn(),
+      consoleWarn:  jest.spyOn(console, 'warn').mockImplementation(),
+      consoleDebug: jest.spyOn(console, 'debug').mockImplementation(),
+      rootGetter:   {
+        'management/byId': (resource: string, id: string): { value: string} => {
+          return {
+            value: JSON.stringify({
+              ...DEFAULT_PERF_SETTING,
+              kubeAPI: { warningHeader: settings }
+            })
+          };
+        },
+        'i18n/t': (key: string, { resourceType }: any) => {
+          return `${ key }_${ resourceType }`;
+        }
+      }
+    };
+  }
+
+  function createMockRes( headers = {}, data = { type: inputResourceType }) {
+    return {
+      headers, config: { url: 'unit/test' }, data
+    };
+  }
+
+  function createGrowlResponse(message: string, action = updateKey) {
+    return [
+      'growl/warning',
+      {
+        message, timeout: 0, title: `${ action }_${ inputResourceType }`
+      },
+      { root: true }
+    ];
+  }
+
+  function createConsoleResponse(warnings: string) {
+    return `Validation Warnings for unit/test\n\n${ warnings }`;
+  }
+
+  const inputResourceType = 'abc';
+  const updateKey = 'growl.kubeApiHeaderWarning.titleUpdate';
+  const createKey = 'growl.kubeApiHeaderWarning.titleCreate';
+  const podSecurity = '299 - would violate PodSecurity "restricted:latest": unrestricted capabilities (container "container-0" must set securityContext.capabilities.drop=["ALL"]), runAsNonRoot != true (container "container-0" must not set securityContext.runAsNonRoot=false), seccompProfile (pod or container "container-0" must set securityContext.seccompProfile.type to "RuntimeDefault" or "Localhost")';
+  const deprecated = "299 - i'm deprecated";
+  const validation = '299 - unknown field "spec.containers[0].__active"';
+
+  describe('no warnings', () => {
+    it('put, no header warning', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(createMockRes(),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'put',
+        true,
+      );
+
+      expect(mocks.dispatch).not.toHaveBeenCalled();
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).not.toHaveBeenCalled();
+    });
+
+    it('post, no header warning', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(createMockRes(),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'post',
+        true,
+      );
+
+      expect(mocks.dispatch).not.toHaveBeenCalled();
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).not.toHaveBeenCalled();
+    });
+
+    it('patch, no header warning', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(createMockRes(),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'patch',
+        true,
+      );
+
+      expect(mocks.dispatch).not.toHaveBeenCalled();
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).not.toHaveBeenCalled();
+    });
+
+    it('get, no header warning', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(createMockRes(),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'get',
+        true,
+      );
+
+      expect(mocks.dispatch).not.toHaveBeenCalled();
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).not.toHaveBeenCalled();
+    });
+
+    it('get, warnings', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(createMockRes( { warnings: ['erg'] }),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'get',
+        true,
+      );
+
+      expect(mocks.dispatch).not.toHaveBeenCalled();
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).not.toHaveBeenCalled();
+    });
+
+    it('blocked (via default config)', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(
+        createMockRes({ warning: validation }),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'put',
+        true
+      );
+
+      expect(mocks.dispatch).not.toHaveBeenCalled();
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).toHaveBeenCalledWith(createConsoleResponse(validation));
+    });
+
+    it('blocked (via custom config)', () => {
+      const mocks = setupMocks({
+        separator:             '299 - ',
+        notificationBlockList: [deprecated]
+      });
+
+      handleKubeApiHeaderWarnings(
+        createMockRes({ warning: deprecated }),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'put',
+        true
+      );
+
+      expect(mocks.dispatch).not.toHaveBeenCalled();
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).toHaveBeenCalledWith(createConsoleResponse(deprecated));
+    });
+
+    it('multi blocked (via custom config)', () => {
+      const mocks = setupMocks({
+        separator:             '299 - ',
+        notificationBlockList: [deprecated, podSecurity]
+      });
+
+      handleKubeApiHeaderWarnings(
+        createMockRes({ warning: `${ deprecated },${ podSecurity }` }),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'put',
+        true
+      );
+
+      expect(mocks.dispatch).not.toHaveBeenCalled();
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).toHaveBeenCalledWith(createConsoleResponse(`${ deprecated }\n${ podSecurity }`));
+    });
+  });
+
+  describe('warnings', () => {
+    it('deprecated', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(
+        createMockRes({ warning: deprecated }),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'put',
+        true,
+      );
+
+      expect(mocks.dispatch).toHaveBeenCalledWith(...createGrowlResponse(deprecated));
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).toHaveBeenCalledWith(createConsoleResponse(deprecated));
+    });
+
+    it('pod security', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(
+        createMockRes({ warning: podSecurity }),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'post',
+        true,
+      );
+
+      expect(mocks.dispatch).toHaveBeenCalledWith(...createGrowlResponse(podSecurity, createKey));
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).toHaveBeenCalledWith(createConsoleResponse(podSecurity));
+    });
+
+    it('deprecated & pod security', () => {
+      const mocks = setupMocks();
+
+      handleKubeApiHeaderWarnings(
+        createMockRes({ warning: `${ deprecated },${ podSecurity }` }),
+        mocks.dispatch,
+        mocks.rootGetter,
+        'put',
+        true,
+      );
+
+      expect(mocks.dispatch).toHaveBeenCalledWith(...createGrowlResponse(`${ deprecated }, ${ podSecurity }` ));
+      expect(mocks.consoleWarn).not.toHaveBeenCalled();
+      expect(mocks.consoleDebug).toHaveBeenCalledWith(createConsoleResponse(`${ deprecated }\n${ podSecurity }`));
+    });
+  });
+});

package/plugins/steve/__tests__/mutations.test.ts

@@ -0,0 +1,50 @@
+import mutations from '@shell/plugins/steve/mutations.js';
+import { POD } from '@shell/config/types';
+import Resource from '@shell/plugins/dashboard-store/resource-class';
+import mutationHelpers from '@shell/plugins/steve/__tests__/utils/mutation.test.helpers';
+
+describe('steve-store: mutations', () => {
+  describe('loadAdd', () => {
+    const createNewEntry = () => {
+      const res = mutationHelpers.loadAll.createNewEntry();
+      const pod = res.params[1].data[0];
+
+      res.params[0].podsByNamespace = {};
+      res.expected.podsByNamespace = {
+        [pod.namespace]: {
+          list: [new Resource(pod)],
+          map:  new Map([
+            [pod.id, new Resource(pod)]
+          ]),
+        }
+      };
+      res.expected.types[POD].havePage = false;
+
+      return res;
+    };
+
+    it.each([['No change', mutationHelpers.loadAll.createNoOp()]])('%s', (_, run) => {
+      mutations.loadAdd(...run.params);
+
+      expect(run.params[0]).toStrictEqual(run.expected.state);
+    });
+
+    it.each([
+      ['Add a new pod', createNewEntry()],
+    ])('%s', (_, run) => { // eslint-disable-line jest/no-identical-title
+      mutations.loadAdd(...run.params);
+      const { map: cacheMap, ...cacheState } = run.params[0].types?.[POD] ;
+      const cachePodsByNamespace = run.params[0].podsByNamespace ;
+      const { map: expectedMap, ...expected } = run.expected.types?.[POD];
+      const expectedPodsByNamespace = run.expected.podsByNamespace ;
+
+      expect(cacheMap).toBeDefined();
+      expect(expectedMap).toBeDefined();
+
+      expect(cacheState).toStrictEqual(expected);
+      expect(cacheMap).toStrictEqual(expectedMap);
+
+      expect(cachePodsByNamespace).toStrictEqual(expectedPodsByNamespace);
+    });
+  });
+});

package/plugins/steve/__tests__/resource-utils.test.ts

@@ -0,0 +1,159 @@
+import { steveCleanForDownload } from '@shell/plugins/steve/resource-utils';
+
+describe('steve: ressource-utils', () => {
+  it('should do nothing if the yaml is not passed', () => {
+    const r = steveCleanForDownload();
+
+    expect(r).toBeUndefined();
+  });
+  it('should remove all default rootKeys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+`;
+    const yamlStr = `
+id: test_id
+links: 
+  view: https://example.com2
+type: test_type
+actions:
+  remove: https://example.com
+${ expectedYamlStr }
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+  it('should remove all the specified root keys', () => {
+    const part = `apiVersion: v1
+kind: Secret
+metadata:
+  name: my-secret`;
+
+    const rootKeyToYamlStringMap = {
+      id:    'id: test_id',
+      links: `links:
+  view: https://example.com`,
+      actions: `actions:
+  remove: https://example.com`,
+      type: 'type: Opaque'
+    };
+
+    const entries = Object.entries(rootKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.filter(([k]) => k !== key).map(([_, str]) => str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { rootKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+  it('should remove all default metadata keys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+`;
+    const yamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+  fields: 
+    - kube-root-ca.crt
+    - 1
+    - 7d23h
+  relationships:
+    - rel: 'owner'
+  state: 'active'
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+
+  it('should remove all the specified metadata keys', () => {
+    const part = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap`;
+
+    const metadataKeyToYamlStringMap = {
+      fields:
+`  fields:
+    - kube-root-ca.crt
+    - 1
+    - 7d23h`,
+      relationships:
+`  relationships:
+    - rel: owner`,
+      state: `  state: active`
+    };
+
+    const entries = Object.entries(metadataKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.filter(([k]) => k !== key).map(([_, str]) => str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { metadataKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+  it('should remove all defalut condition keys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - {}
+    - {}
+    - message: message
+`;
+    const yamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - error: 'error'
+    - transitioning: false
+    - message: message
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+  it('should remove all the specified condition keys', () => {
+    const part = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - message: message`;
+
+    const conditionKeyToYamlStringMap = {
+      error:         '    - error: error',
+      transitioning: '    - transitioning: false'
+    };
+
+    const entries = Object.entries(conditionKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.map(([k, str]) => k === key ? '    - {}' : str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { conditionKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+});