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 { 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.PROCESS}","${ResourceKind.COLLECTION}","${ResourceKind.WORKFLOW}"]]`);
  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.PROCESS}","${ResourceKind.WORKFLOW}"]]`);
  42     });
  43
  44     it("should serialize output collections and projects", () => {
  45         const filters = pipe(
  46             () => getInitialResourceTypeFilters(),
  47             deselectNode(ObjectTypeFilter.PROCESS),
  48             deselectNode(ObjectTypeFilter.WORKFLOW),
  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 intermediate collections and projects", () => {
  60         const filters = pipe(
  61             () => getInitialResourceTypeFilters(),
  62             deselectNode(ObjectTypeFilter.PROCESS),
  63             deselectNode(ObjectTypeFilter.WORKFLOW),
  64             deselectNode(CollectionTypeFilter.GENERAL_COLLECTION),
  65             deselectNode(CollectionTypeFilter.LOG_COLLECTION),
  66             deselectNode(CollectionTypeFilter.OUTPUT_COLLECTION),
  67         )();
  68
  69         const serializedFilters = serializeResourceTypeFilters(filters);
  70         expect(serializedFilters)
  71             .toEqual(`["uuid","is_a",["${ResourceKind.PROJECT}","${ResourceKind.COLLECTION}"]],["collections.properties.type","in",["intermediate"]]`);
  72     });
  73
  74     it("should serialize general and log collections", () => {
  75         const filters = pipe(
  76             () => getInitialResourceTypeFilters(),
  77             deselectNode(ObjectTypeFilter.PROJECT),
  78             deselectNode(ObjectTypeFilter.PROCESS),
  79             deselectNode(ObjectTypeFilter.WORKFLOW),
  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"]]`);
  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.WORKFLOW),
  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.COLLECTION),
 108             deselectNode(ObjectTypeFilter.WORKFLOW),
 109         )();
 110
 111         const serializedFilters = serializeResourceTypeFilters(filters);
 112         expect(serializedFilters)
 113             .toEqual(`["uuid","is_a",["${ResourceKind.PROCESS}"]],["container_requests.requesting_container_uuid","!=",null]`);
 114     });
 115
 116     it("should serialize all project types", () => {
 117         const filters = pipe(
 118             () => getInitialResourceTypeFilters(),
 119             deselectNode(ObjectTypeFilter.PROCESS),
 120             deselectNode(ObjectTypeFilter.COLLECTION),
 121             deselectNode(ObjectTypeFilter.WORKFLOW),
 122         )();
 123
 124         const serializedFilters = serializeResourceTypeFilters(filters);
 125         expect(serializedFilters)
 126             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]]`);
 127     });
 128
 129     it("should serialize filter groups", () => {
 130         const filters = pipe(
 131             () => getInitialResourceTypeFilters(),
 132             deselectNode(GroupTypeFilter.PROJECT),
 133             deselectNode(ObjectTypeFilter.PROCESS),
 134             deselectNode(ObjectTypeFilter.COLLECTION),
 135             deselectNode(ObjectTypeFilter.WORKFLOW),
 136         )();
 137
 138         const serializedFilters = serializeResourceTypeFilters(filters);
 139         expect(serializedFilters)
 140             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]],["groups.group_class","=","filter"]`);
 141     });
 142
 143     it("should serialize projects (normal)", () => {
 144         const filters = pipe(
 145             () => getInitialResourceTypeFilters(),
 146             deselectNode(GroupTypeFilter.FILTER_GROUP),
 147             deselectNode(ObjectTypeFilter.PROCESS),
 148             deselectNode(ObjectTypeFilter.COLLECTION),
 149             deselectNode(ObjectTypeFilter.WORKFLOW),
 150         )();
 151
 152         const serializedFilters = serializeResourceTypeFilters(filters);
 153         expect(serializedFilters)
 154             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]],["groups.group_class","=","project"]`);
 155     });
 156
 157 });