src/store/resource-type-filters/resource-type-filters.test.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { getInitialResourceTypeFilters, serializeResourceTypeFilters, ObjectTypeFilter, CollectionTypeFilter, ProcessTypeFilter, GroupTypeFilter, buildProcessStatusFilters, ProcessStatusFilter } from './resource-type-filters';
   6 import { ResourceKind } from 'models/resource';
   7 import { selectNode, deselectNode } from 'models/tree';
   8 import { pipe } from 'lodash/fp';
   9 import { FilterBuilder } from 'services/api/filter-builder';
  10
  11 describe("buildProcessStatusFilters", () => {
  12     [
  13         [ProcessStatusFilter.ALL, ""],
  14         [ProcessStatusFilter.ONHOLD, `["state","!=","Final"],["priority","=","0"],["container.state","in",["Queued","Locked"]]`],
  15         [ProcessStatusFilter.COMPLETED, `["container.state","=","Complete"],["container.exit_code","=","0"]`],
  16         [ProcessStatusFilter.FAILED, `["container.state","=","Complete"],["container.exit_code","!=","0"]`],
  17         [ProcessStatusFilter.QUEUED, `["container.state","=","Queued"],["priority","!=","0"]`],
  18         [ProcessStatusFilter.CANCELLED, `["container.state","=","Cancelled"]`],
  19         [ProcessStatusFilter.RUNNING, `["container.state","=","Running"]`],
  20     ].forEach(([status, expected]) => {
  21         it(`can filter "${status}" processes`, () => {
  22             const filters = buildProcessStatusFilters(new FilterBuilder(), status);
  23             expect(filters.getFilters())
  24                 .toEqual(expected);
  25         })
  26     });
  27 });
  28
  29 describe("serializeResourceTypeFilters", () => {
  30     it("should serialize all filters", () => {
  31         const filters = getInitialResourceTypeFilters();
  32         const serializedFilters = serializeResourceTypeFilters(filters);
  33         expect(serializedFilters)
  34             .toEqual(`["uuid","is_a",["${ResourceKind.PROJECT}","${ResourceKind.COLLECTION}","${ResourceKind.WORKFLOW}","${ResourceKind.PROCESS}"]],["collections.properties.type","not in",["log","intermediate"]],["container_requests.requesting_container_uuid","=",null]`);
  35     });
  36
  37     it("should serialize all but collection filters", () => {
  38         const filters = deselectNode(ObjectTypeFilter.COLLECTION)(getInitialResourceTypeFilters());
  39         const serializedFilters = serializeResourceTypeFilters(filters);
  40         expect(serializedFilters)
  41             .toEqual(`["uuid","is_a",["${ResourceKind.PROJECT}","${ResourceKind.WORKFLOW}","${ResourceKind.PROCESS}"]],["container_requests.requesting_container_uuid","=",null]`);
  42     });
  43
  44     it("should serialize output collections and projects", () => {
  45         const filters = pipe(
  46             () => getInitialResourceTypeFilters(),
  47             deselectNode(ObjectTypeFilter.DEFINITION),
  48             deselectNode(ProcessTypeFilter.MAIN_PROCESS),
  49             deselectNode(CollectionTypeFilter.GENERAL_COLLECTION),
  50             deselectNode(CollectionTypeFilter.LOG_COLLECTION),
  51             deselectNode(CollectionTypeFilter.INTERMEDIATE_COLLECTION),
  52         )();
  53
  54         const serializedFilters = serializeResourceTypeFilters(filters);
  55         expect(serializedFilters)
  56             .toEqual(`["uuid","is_a",["${ResourceKind.PROJECT}","${ResourceKind.COLLECTION}"]],["collections.properties.type","in",["output"]]`);
  57     });
  58
  59     it("should serialize output collections and projects", () => {
  60         const filters = pipe(
  61             () => getInitialResourceTypeFilters(),
  62             deselectNode(ObjectTypeFilter.DEFINITION),
  63             deselectNode(ProcessTypeFilter.MAIN_PROCESS),
  64             deselectNode(CollectionTypeFilter.GENERAL_COLLECTION),
  65             deselectNode(CollectionTypeFilter.LOG_COLLECTION),
  66             deselectNode(CollectionTypeFilter.INTERMEDIATE_COLLECTION),
  67         )();
  68
  69         const serializedFilters = serializeResourceTypeFilters(filters);
  70         expect(serializedFilters)
  71             .toEqual(`["uuid","is_a",["${ResourceKind.PROJECT}","${ResourceKind.COLLECTION}"]],["collections.properties.type","in",["output"]]`);
  72     });
  73
  74     it("should serialize general collections", () => {
  75         const filters = pipe(
  76             () => getInitialResourceTypeFilters(),
  77             deselectNode(ObjectTypeFilter.PROJECT),
  78             deselectNode(ObjectTypeFilter.DEFINITION),
  79             deselectNode(ProcessTypeFilter.MAIN_PROCESS),
  80             deselectNode(CollectionTypeFilter.OUTPUT_COLLECTION)
  81         )();
  82
  83         const serializedFilters = serializeResourceTypeFilters(filters);
  84         expect(serializedFilters)
  85             .toEqual(`["uuid","is_a",["${ResourceKind.COLLECTION}"]],["collections.properties.type","not in",["output","log","intermediate"]]`);
  86     });
  87
  88     it("should serialize only main processes", () => {
  89         const filters = pipe(
  90             () => getInitialResourceTypeFilters(),
  91             deselectNode(ObjectTypeFilter.PROJECT),
  92             deselectNode(ProcessTypeFilter.CHILD_PROCESS),
  93             deselectNode(ObjectTypeFilter.COLLECTION),
  94             deselectNode(ObjectTypeFilter.DEFINITION),
  95         )();
  96
  97         const serializedFilters = serializeResourceTypeFilters(filters);
  98         expect(serializedFilters)
  99             .toEqual(`["uuid","is_a",["${ResourceKind.PROCESS}"]],["container_requests.requesting_container_uuid","=",null]`);
 100     });
 101
 102     it("should serialize only child processes", () => {
 103         const filters = pipe(
 104             () => getInitialResourceTypeFilters(),
 105             deselectNode(ObjectTypeFilter.PROJECT),
 106             deselectNode(ProcessTypeFilter.MAIN_PROCESS),
 107             deselectNode(ObjectTypeFilter.DEFINITION),
 108             deselectNode(ObjectTypeFilter.COLLECTION),
 109
 110             selectNode(ProcessTypeFilter.CHILD_PROCESS),
 111         )();
 112
 113         const serializedFilters = serializeResourceTypeFilters(filters);
 114         expect(serializedFilters)
 115             .toEqual(`["uuid","is_a",["${ResourceKind.PROCESS}"]],["container_requests.requesting_container_uuid","!=",null]`);
 116     });
 117
 118     it("should serialize all project types", () => {
 119         const filters = pipe(
 120             () => getInitialResourceTypeFilters(),
 121             deselectNode(ObjectTypeFilter.COLLECTION),
 122             deselectNode(ObjectTypeFilter.DEFINITION),
 123             deselectNode(ProcessTypeFilter.MAIN_PROCESS),
 124         )();
 125
 126         const serializedFilters = serializeResourceTypeFilters(filters);
 127         expect(serializedFilters)
 128             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]]`);
 129     });
 130
 131     it("should serialize filter groups", () => {
 132         const filters = pipe(
 133             () => getInitialResourceTypeFilters(),
 134             deselectNode(GroupTypeFilter.PROJECT),
 135             deselectNode(ObjectTypeFilter.DEFINITION),
 136             deselectNode(ProcessTypeFilter.MAIN_PROCESS),
 137             deselectNode(ObjectTypeFilter.COLLECTION),
 138         )();
 139
 140         const serializedFilters = serializeResourceTypeFilters(filters);
 141         expect(serializedFilters)
 142             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]],["groups.group_class","=","filter"]`);
 143     });
 144
 145     it("should serialize projects (normal)", () => {
 146         const filters = pipe(
 147             () => getInitialResourceTypeFilters(),
 148             deselectNode(GroupTypeFilter.FILTER_GROUP),
 149             deselectNode(ObjectTypeFilter.DEFINITION),
 150             deselectNode(ProcessTypeFilter.MAIN_PROCESS),
 151             deselectNode(ObjectTypeFilter.COLLECTION),
 152         )();
 153
 154         const serializedFilters = serializeResourceTypeFilters(filters);
 155         expect(serializedFilters)
 156             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]],["groups.group_class","=","project"]`);
 157     });
 158
 159 });