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}"]]`);
  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}"]]`);
  42     });
  43
  44     it("should serialize output collections and projects", () => {
  45         const filters = pipe(
  46             () => getInitialResourceTypeFilters(),
  47             deselectNode(ObjectTypeFilter.PROCESS),
  48             deselectNode(CollectionTypeFilter.GENERAL_COLLECTION),
  49             deselectNode(CollectionTypeFilter.LOG_COLLECTION),
  50             deselectNode(CollectionTypeFilter.INTERMEDIATE_COLLECTION),
  51         )();
  52
  53         const serializedFilters = serializeResourceTypeFilters(filters);
  54         expect(serializedFilters)
  55             .toEqual(`["uuid","is_a",["${ResourceKind.PROJECT}","${ResourceKind.COLLECTION}"]],["collections.properties.type","in",["output"]]`);
  56     });
  57
  58     it("should serialize intermediate collections and projects", () => {
  59         const filters = pipe(
  60             () => getInitialResourceTypeFilters(),
  61             deselectNode(ObjectTypeFilter.PROCESS),
  62             deselectNode(CollectionTypeFilter.GENERAL_COLLECTION),
  63             deselectNode(CollectionTypeFilter.LOG_COLLECTION),
  64             deselectNode(CollectionTypeFilter.OUTPUT_COLLECTION),
  65         )();
  66
  67         const serializedFilters = serializeResourceTypeFilters(filters);
  68         expect(serializedFilters)
  69             .toEqual(`["uuid","is_a",["${ResourceKind.PROJECT}","${ResourceKind.COLLECTION}"]],["collections.properties.type","in",["intermediate"]]`);
  70     });
  71
  72     it("should serialize general and log collections", () => {
  73         const filters = pipe(
  74             () => getInitialResourceTypeFilters(),
  75             deselectNode(ObjectTypeFilter.PROJECT),
  76             deselectNode(ObjectTypeFilter.PROCESS),
  77             deselectNode(CollectionTypeFilter.OUTPUT_COLLECTION)
  78         )();
  79
  80         const serializedFilters = serializeResourceTypeFilters(filters);
  81         expect(serializedFilters)
  82             .toEqual(`["uuid","is_a",["${ResourceKind.COLLECTION}"]],["collections.properties.type","not in",["output"]]`);
  83     });
  84
  85     it("should serialize only main processes", () => {
  86         const filters = pipe(
  87             () => getInitialResourceTypeFilters(),
  88             deselectNode(ObjectTypeFilter.PROJECT),
  89             deselectNode(ProcessTypeFilter.CHILD_PROCESS),
  90             deselectNode(ObjectTypeFilter.COLLECTION)
  91         )();
  92
  93         const serializedFilters = serializeResourceTypeFilters(filters);
  94         expect(serializedFilters)
  95             .toEqual(`["uuid","is_a",["${ResourceKind.PROCESS}"]],["container_requests.requesting_container_uuid","=",null]`);
  96     });
  97
  98     it("should serialize only child processes", () => {
  99         const filters = pipe(
 100             () => getInitialResourceTypeFilters(),
 101             deselectNode(ObjectTypeFilter.PROJECT),
 102             deselectNode(ProcessTypeFilter.MAIN_PROCESS),
 103             deselectNode(ObjectTypeFilter.COLLECTION)
 104         )();
 105
 106         const serializedFilters = serializeResourceTypeFilters(filters);
 107         expect(serializedFilters)
 108             .toEqual(`["uuid","is_a",["${ResourceKind.PROCESS}"]],["container_requests.requesting_container_uuid","!=",null]`);
 109     });
 110
 111     it("should serialize all project types", () => {
 112         const filters = pipe(
 113             () => getInitialResourceTypeFilters(),
 114             deselectNode(ObjectTypeFilter.PROCESS),
 115             deselectNode(ObjectTypeFilter.COLLECTION),
 116         )();
 117
 118         const serializedFilters = serializeResourceTypeFilters(filters);
 119         expect(serializedFilters)
 120             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]]`);
 121     });
 122
 123     it("should serialize filter groups", () => {
 124         const filters = pipe(
 125             () => getInitialResourceTypeFilters(),
 126             deselectNode(GroupTypeFilter.PROJECT),
 127             deselectNode(ObjectTypeFilter.PROCESS),
 128             deselectNode(ObjectTypeFilter.COLLECTION),
 129         )();
 130
 131         const serializedFilters = serializeResourceTypeFilters(filters);
 132         expect(serializedFilters)
 133             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]],["groups.group_class","=","filter"]`);
 134     });
 135
 136     it("should serialize projects (normal)", () => {
 137         const filters = pipe(
 138             () => getInitialResourceTypeFilters(),
 139             deselectNode(GroupTypeFilter.FILTER_GROUP),
 140             deselectNode(ObjectTypeFilter.PROCESS),
 141             deselectNode(ObjectTypeFilter.COLLECTION),
 142         )();
 143
 144         const serializedFilters = serializeResourceTypeFilters(filters);
 145         expect(serializedFilters)
 146             .toEqual(`["uuid","is_a",["${ResourceKind.GROUP}"]],["groups.group_class","=","project"]`);
 147     });
 148
 149 });