src/store/project/project-reducer.test.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import projectsReducer, { getTreePath } from "./project-reducer";
   6 import actions from "./project-action";
   7 import { TreeItem, TreeItemStatus } from "../../components/tree/tree";
   8 import { ResourceKind } from "../../models/resource";
   9
  10 describe('project-reducer', () => {
  11     it('should add new project to the list', () => {
  12         const initialState = undefined;
  13         const project = {
  14             name: 'test',
  15             href: 'href',
  16             createdAt: '2018-01-01',
  17             modifiedAt: '2018-01-01',
  18             ownerUuid: 'owner-test123',
  19             uuid: 'test123',
  20             kind: ResourceKind.PROJECT
  21         };
  22
  23         const state = projectsReducer(initialState, actions.CREATE_PROJECT(project));
  24         expect(state.items[0].data).toEqual(project);
  25     });
  26
  27     it('should load projects', () => {
  28         const initialState = undefined;
  29         const project = {
  30             name: 'test',
  31             href: 'href',
  32             createdAt: '2018-01-01',
  33             modifiedAt: '2018-01-01',
  34             ownerUuid: 'owner-test123',
  35             uuid: 'test123',
  36             kind: ResourceKind.PROJECT
  37         };
  38
  39         const projects = [project, project];
  40         const state = projectsReducer(initialState, actions.PROJECTS_SUCCESS({ projects, parentItemId: undefined }));
  41         expect(state).toEqual({
  42             items: [{
  43                 active: false,
  44                 open: false,
  45                 id: "test123",
  46                 items: [],
  47                 data: project,
  48                 status: 0
  49             }, {
  50                 active: false,
  51                 open: false,
  52                 id: "test123",
  53                 items: [],
  54                 data: project,
  55                 status: 0
  56             }
  57             ],
  58             currentItemId: ""
  59         });
  60     });
  61
  62     it('should remove activity on projects list', () => {
  63         const initialState = {
  64             items: [{
  65                 data: {
  66                     name: 'test',
  67                     href: 'href',
  68                     createdAt: '2018-01-01',
  69                     modifiedAt: '2018-01-01',
  70                     ownerUuid: 'owner-test123',
  71                     uuid: 'test123',
  72                     kind: ResourceKind.PROJECT
  73                 },
  74                 id: "1",
  75                 open: true,
  76                 active: true,
  77                 status: 1
  78             }],
  79             currentItemId: "1",
  80             creator: { opened: false, pending: false, ownerUuid: "" },
  81         };
  82         const project = {
  83             items: [{
  84                 data: {
  85                     name: 'test',
  86                     href: 'href',
  87                     createdAt: '2018-01-01',
  88                     modifiedAt: '2018-01-01',
  89                     ownerUuid: 'owner-test123',
  90                     uuid: 'test123',
  91                     kind: ResourceKind.PROJECT
  92                 },
  93                 id: "1",
  94                 open: true,
  95                 active: false,
  96                 status: 1
  97             }],
  98             currentItemId: ""
  99         };
 100
 101         const state = projectsReducer(initialState, actions.RESET_PROJECT_TREE_ACTIVITY(initialState.items[0].id));
 102         expect(state).toEqual(project);
 103     });
 104
 105     it('should toggle project tree item activity', () => {
 106         const initialState = {
 107             items: [{
 108                 data: {
 109                     name: 'test',
 110                     href: 'href',
 111                     createdAt: '2018-01-01',
 112                     modifiedAt: '2018-01-01',
 113                     ownerUuid: 'owner-test123',
 114                     uuid: 'test123',
 115                     kind: ResourceKind.PROJECT
 116                 },
 117                 id: "1",
 118                 open: true,
 119                 active: false,
 120                 status: 1
 121             }],
 122             currentItemId: "1",
 123             creator: { opened: false, pending: false, ownerUuid: "" }
 124         };
 125         const project = {
 126             items: [{
 127                 data: {
 128                     name: 'test',
 129                     href: 'href',
 130                     createdAt: '2018-01-01',
 131                     modifiedAt: '2018-01-01',
 132                     ownerUuid: 'owner-test123',
 133                     uuid: 'test123',
 134                     kind: ResourceKind.PROJECT,
 135                 },
 136                 id: "1",
 137                 open: true,
 138                 active: true,
 139                 status: 1,
 140                 toggled: true
 141             }],
 142             currentItemId: "1",
 143             creator: { opened: false, pending: false, ownerUuid: "" },
 144         };
 145
 146         const state = projectsReducer(initialState, actions.TOGGLE_PROJECT_TREE_ITEM_ACTIVE(initialState.items[0].id));
 147         expect(state).toEqual(project);
 148     });
 149
 150
 151     it('should close project tree item ', () => {
 152         const initialState = {
 153             items: [{
 154                 data: {
 155                     name: 'test',
 156                     href: 'href',
 157                     createdAt: '2018-01-01',
 158                     modifiedAt: '2018-01-01',
 159                     ownerUuid: 'owner-test123',
 160                     uuid: 'test123',
 161                     kind: ResourceKind.PROJECT
 162                 },
 163                 id: "1",
 164                 open: true,
 165                 active: false,
 166                 status: 1,
 167                 toggled: false,
 168             }],
 169             currentItemId: "1",
 170             creator: { opened: false, pending: false, ownerUuid: "" }
 171         };
 172         const project = {
 173             items: [{
 174                 data: {
 175                     name: 'test',
 176                     href: 'href',
 177                     createdAt: '2018-01-01',
 178                     modifiedAt: '2018-01-01',
 179                     ownerUuid: 'owner-test123',
 180                     uuid: 'test123',
 181                     kind: ResourceKind.PROJECT
 182                 },
 183                 id: "1",
 184                 open: false,
 185                 active: false,
 186                 status: 1,
 187                 toggled: true
 188             }],
 189             currentItemId: "1",
 190             creator: { opened: false, pending: false, ownerUuid: "" },
 191         };
 192
 193         const state = projectsReducer(initialState, actions.TOGGLE_PROJECT_TREE_ITEM_OPEN(initialState.items[0].id));
 194         expect(state).toEqual(project);
 195     });
 196 });
 197
 198 describe("findTreeBranch", () => {
 199     const createTreeItem = (id: string, items?: Array<TreeItem<string>>): TreeItem<string> => ({
 200         id,
 201         items,
 202         active: false,
 203         data: "",
 204         open: false,
 205         status: TreeItemStatus.Initial
 206     });
 207
 208     it("should return an array that matches path to the given item", () => {
 209         const tree: Array<TreeItem<string>> = [
 210             createTreeItem("1", [
 211                 createTreeItem("1.1", [
 212                     createTreeItem("1.1.1"),
 213                     createTreeItem("1.1.2")
 214                 ])
 215             ]),
 216             createTreeItem("2", [
 217                 createTreeItem("2.1", [
 218                     createTreeItem("2.1.1"),
 219                     createTreeItem("2.1.2")
 220                 ])
 221             ])
 222         ];
 223         const branch = getTreePath(tree, "2.1.1");
 224         expect(branch.map(item => item.id)).toEqual(["2", "2.1", "2.1.1"]);
 225     });
 226
 227     it("should return empty array if item is not found", () => {
 228         const tree: Array<TreeItem<string>> = [
 229             createTreeItem("1", [
 230                 createTreeItem("1.1", [
 231                     createTreeItem("1.1.1"),
 232                     createTreeItem("1.1.2")
 233                 ])
 234             ]),
 235             createTreeItem("2", [
 236                 createTreeItem("2.1", [
 237                     createTreeItem("2.1.1"),
 238                     createTreeItem("2.1.2")
 239                 ])
 240             ])
 241         ];
 242         expect(getTreePath(tree, "3")).toHaveLength(0);
 243     });
 244
 245 });