services/workbench2/cypress/support/commands.js

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 // ***********************************************
   6 // This example commands.js shows you how to
   7 // create various custom commands and overwrite
   8 // existing commands.
   9 //
  10 // For more comprehensive examples of custom
  11 // commands please read more here:
  12 // https://on.cypress.io/custom-commands
  13 // ***********************************************
  14 //
  15 //
  16 // -- This is a parent command --
  17 // Cypress.Commands.add("login", (email, password) => { ... })
  18 //
  19 //
  20 // -- This is a child command --
  21 // Cypress.Commands.add("drag", { prevSubject: 'element'}, (subject, options) => { ... })
  22 //
  23 //
  24 // -- This is a dual command --
  25 // Cypress.Commands.add("dismiss", { prevSubject: 'optional'}, (subject, options) => { ... })
  26 //
  27 //
  28 // -- This will overwrite an existing command --
  29 // Cypress.Commands.overwrite("visit", (originalFn, url, options) => { ... })
  30
  31 import 'cypress-wait-until';
  32 import { extractFilesData } from "services/collection-service/collection-service-files-response";
  33
  34 const controllerURL = Cypress.env("controller_url");
  35 const systemToken = Cypress.env("system_token");
  36 let createdResources = [];
  37
  38 const containerLogFolderPrefix = "log for container ";
  39
  40 // Clean up anything that was created.  You can temporarily add
  41 // 'return' to the top if you need the resources to hang around to
  42 // debug a specific test.
  43 afterEach(function () {
  44     if (createdResources.length === 0) {
  45         return;
  46     }
  47     cy.log(`Cleaning ${createdResources.length} previously created resource(s).`);
  48     createdResources.forEach(function ({ suffix, uuid }) {
  49         // Don't fail when a resource isn't already there, some objects may have
  50         // been removed, directly or indirectly, from the test that created them.
  51         cy.deleteResource(systemToken, suffix, uuid, false);
  52     });
  53     createdResources = [];
  54 });
  55
  56 Cypress.Commands.add(
  57     "doRequest",
  58     (method = "GET", path = "", data = null, qs = null, token = systemToken, auth = false, followRedirect = true, failOnStatusCode = true) => {
  59         return cy.request({
  60             method: method,
  61             url: `${controllerURL.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`,
  62             body: data,
  63             qs: auth ? qs : Object.assign({ api_token: token }, qs),
  64             auth: auth ? { bearer: `${token}` } : undefined,
  65             followRedirect: followRedirect,
  66             failOnStatusCode: failOnStatusCode,
  67         });
  68     }
  69 );
  70
  71 Cypress.Commands.add(
  72     "doWebDAVRequest",
  73     (method = "GET", path = "", data = null, qs = null, token = systemToken, auth = false, followRedirect = true, failOnStatusCode = true) => {
  74         return cy.doRequest("GET", "/arvados/v1/config", null, null).then(({ body: config }) => {
  75             return cy.request({
  76                 method: method,
  77                 url: `${config.Services.WebDAVDownload.ExternalURL.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`,
  78                 body: data,
  79                 qs: auth ? qs : Object.assign({ api_token: token }, qs),
  80                 auth: auth ? { bearer: `${token}` } : undefined,
  81                 followRedirect: followRedirect,
  82                 failOnStatusCode: failOnStatusCode,
  83             });
  84         });
  85     }
  86 );
  87
  88 Cypress.Commands.add("getUser", (username, first_name = "", last_name = "", is_admin = false, is_active = true) => {
  89     // Create user if not already created
  90     return (
  91         cy
  92             .doRequest(
  93                 "POST",
  94                 "/auth/controller/callback",
  95                 {
  96                     auth_info: JSON.stringify({
  97                         email: `${username}@example.local`,
  98                         username: username,
  99                         first_name: first_name,
 100                         last_name: last_name,
 101                         alternate_emails: [],
 102                     }),
 103                     return_to: ",https://controller.api.client.invalid",
 104                 },
 105                 null,
 106                 systemToken,
 107                 true,
 108                 false
 109             ) // Don't follow redirects so we can catch the token
 110             .its("headers.location")
 111             .as("location")
 112             // Get its token and set the account up as admin and/or active
 113             .then(function () {
 114                 this.userToken = this.location.split("=")[1];
 115                 assert.isString(this.userToken);
 116                 return cy
 117                     .doRequest("GET", "/arvados/v1/users", null, {
 118                         filters: `[["username", "=", "${username}"]]`,
 119                     })
 120                     .its("body.items.0")
 121                     .as("aUser")
 122                     .then(function () {
 123                         cy.doRequest("PUT", `/arvados/v1/users/${this.aUser.uuid}`, {
 124                             user: {
 125                                 is_admin: is_admin,
 126                                 is_active: is_active,
 127                             },
 128                         })
 129                             .its("body")
 130                             .as("theUser")
 131                             .then(function () {
 132                                 cy.doRequest("GET", "/arvados/v1/api_clients", null, {
 133                                     filters: `[["is_trusted", "=", false]]`,
 134                                     order: `["created_at desc"]`,
 135                                 })
 136                                     .its("body.items")
 137                                     .as("apiClients")
 138                                     .then(function () {
 139                                         if (this.apiClients.length > 0) {
 140                                             cy.doRequest("PUT", `/arvados/v1/api_clients/${this.apiClients[0].uuid}`, {
 141                                                 api_client: {
 142                                                     is_trusted: true,
 143                                                 },
 144                                             })
 145                                                 .its("body")
 146                                                 .as("updatedApiClient")
 147                                                 .then(function () {
 148                                                     assert(this.updatedApiClient.is_trusted);
 149                                                 });
 150                                         }
 151                                     })
 152                                     .then(function () {
 153                                         return { user: this.theUser, token: this.userToken };
 154                                     });
 155                             });
 156                     });
 157             })
 158     );
 159 });
 160
 161 Cypress.Commands.add("createLink", (token, data) => {
 162     return cy.createResource(token, "links", {
 163         link: JSON.stringify(data),
 164     });
 165 });
 166
 167 Cypress.Commands.add("createGroup", (token, data) => {
 168     return cy.createResource(token, "groups", {
 169         group: JSON.stringify(data),
 170         ensure_unique_name: true,
 171     });
 172 });
 173
 174 Cypress.Commands.add("trashGroup", (token, uuid) => {
 175     return cy.deleteResource(token, "groups", uuid);
 176 });
 177
 178 Cypress.Commands.add("createWorkflow", (token, data) => {
 179     return cy.createResource(token, "workflows", {
 180         workflow: JSON.stringify(data),
 181         ensure_unique_name: true,
 182     });
 183 });
 184
 185 Cypress.Commands.add("createCollection", (token, data) => {
 186     return cy.createResource(token, "collections", {
 187         collection: JSON.stringify(data),
 188         ensure_unique_name: true,
 189     });
 190 });
 191
 192 Cypress.Commands.add("getCollection", (token, uuid) => {
 193     return cy.getResource(token, "collections", uuid);
 194 });
 195
 196 Cypress.Commands.add("updateCollection", (token, uuid, data) => {
 197     return cy.updateResource(token, "collections", uuid, {
 198         collection: JSON.stringify(data),
 199     });
 200 });
 201
 202 Cypress.Commands.add("collectionReplaceFiles", (token, uuid, data) => {
 203     return cy.updateResource(token, "collections", uuid, {
 204         collection: {
 205             preserve_version: true,
 206         },
 207         replace_files: JSON.stringify(data),
 208     });
 209 });
 210
 211 Cypress.Commands.add("getContainer", (token, uuid) => {
 212     return cy.getResource(token, "containers", uuid);
 213 });
 214
 215 Cypress.Commands.add("updateContainer", (token, uuid, data) => {
 216     return cy.updateResource(token, "containers", uuid, {
 217         container: JSON.stringify(data),
 218     });
 219 });
 220
 221 Cypress.Commands.add("getContainerRequest", (token, uuid) => {
 222     return cy.getResource(token, "container_requests", uuid);
 223 });
 224
 225 Cypress.Commands.add("createContainerRequest", (token, data) => {
 226     return cy.createResource(token, "container_requests", {
 227         container_request: JSON.stringify(data),
 228         ensure_unique_name: true,
 229     });
 230 });
 231
 232 Cypress.Commands.add("updateContainerRequest", (token, uuid, data) => {
 233     return cy.updateResource(token, "container_requests", uuid, {
 234         container_request: JSON.stringify(data),
 235     });
 236 });
 237
 238 /**
 239  * Requires an admin token for log_uuid modification to succeed
 240  */
 241 Cypress.Commands.add("appendLog", (token, crUuid, fileName, lines = []) =>
 242     cy.getContainerRequest(token, crUuid).then(containerRequest => {
 243         if (containerRequest.log_uuid) {
 244             cy.listContainerRequestLogs(token, crUuid).then(logFiles => {
 245                 const filePath = `${containerRequest.log_uuid}/${containerLogFolderPrefix}${containerRequest.container_uuid}/${fileName}`;
 246                 if (logFiles.find(file => file.name === fileName)) {
 247                     // File exists, fetch and append
 248                     return cy
 249                         .doWebDAVRequest("GET", `c=${filePath}`, null, null, token)
 250                         .then(({ body: contents }) =>
 251                             cy.doWebDAVRequest("PUT", `c=${filePath}`, contents.split("\n").concat(lines).join("\n"), null, token)
 252                         );
 253                 } else {
 254                     // File not exists, put new file
 255                     cy.doWebDAVRequest("PUT", `c=${filePath}`, lines.join("\n"), null, token);
 256                 }
 257             });
 258         } else {
 259             // Create log collection
 260             return cy
 261                 .createCollection(token, {
 262                     name: `Test log collection ${Math.floor(Math.random() * 999999)}`,
 263                     owner_uuid: containerRequest.owner_uuid,
 264                     manifest_text: "",
 265                 })
 266                 .then(collection => {
 267                     // Update CR log_uuid to fake log collection
 268                     cy.updateContainerRequest(token, containerRequest.uuid, {
 269                         log_uuid: collection.uuid,
 270                     }).then(() =>
 271                         // Create empty directory for container uuid
 272                         cy
 273                             .collectionReplaceFiles(token, collection.uuid, {
 274                                 [`/${containerLogFolderPrefix}${containerRequest.container_uuid}`]: "d41d8cd98f00b204e9800998ecf8427e+0",
 275                             })
 276                             .then(() =>
 277                                 // Put new log file with contents into fake log collection
 278                                 cy.doWebDAVRequest(
 279                                     "PUT",
 280                                     `c=${collection.uuid}/${containerLogFolderPrefix}${containerRequest.container_uuid}/${fileName}`,
 281                                     lines.join("\n"),
 282                                     null,
 283                                     token
 284                                 )
 285                             )
 286                     );
 287                 });
 288         }
 289     })
 290 );
 291
 292 Cypress.Commands.add("listContainerRequestLogs", (token, crUuid) =>
 293     cy.getContainerRequest(token, crUuid).then(containerRequest =>
 294         cy
 295             .doWebDAVRequest(
 296                 "PROPFIND",
 297                 `c=${containerRequest.log_uuid}/${containerLogFolderPrefix}${containerRequest.container_uuid}`,
 298                 null,
 299                 null,
 300                 token
 301             )
 302             .then(({ body: data }) => {
 303                 return extractFilesData(new DOMParser().parseFromString(data, "text/xml"));
 304             })
 305     )
 306 );
 307
 308 Cypress.Commands.add("createVirtualMachine", (token, data) => {
 309     return cy.createResource(token, "virtual_machines", {
 310         virtual_machine: JSON.stringify(data),
 311         ensure_unique_name: true,
 312     });
 313 });
 314
 315 Cypress.Commands.add("getResource", (token, suffix, uuid) => {
 316     return cy
 317         .doRequest("GET", `/arvados/v1/${suffix}/${uuid}`, null, {}, token)
 318         .its("body")
 319         .then(function (resource) {
 320             return resource;
 321         });
 322 });
 323
 324 Cypress.Commands.add("createResource", (token, suffix, data) => {
 325     return cy
 326         .doRequest("POST", "/arvados/v1/" + suffix, data, null, token, true)
 327         .its("body")
 328         .then(function (resource) {
 329             createdResources.push({ suffix, uuid: resource.uuid });
 330             return resource;
 331         });
 332 });
 333
 334 Cypress.Commands.add("deleteResource", (token, suffix, uuid, failOnStatusCode = true) => {
 335     return cy
 336         .doRequest("DELETE", "/arvados/v1/" + suffix + "/" + uuid, null, null, token, false, true, failOnStatusCode)
 337         .its("body")
 338         .then(function (resource) {
 339             return resource;
 340         });
 341 });
 342
 343 Cypress.Commands.add("updateResource", (token, suffix, uuid, data) => {
 344     return cy
 345         .doRequest("PATCH", "/arvados/v1/" + suffix + "/" + uuid, data, null, token, true)
 346         .its("body")
 347         .then(function (resource) {
 348             return resource;
 349         });
 350 });
 351
 352 Cypress.Commands.add("loginAs", user => {
 353     // This shouldn't be necessary unless we need to call loginAs multiple times
 354     // in the same test.
 355     cy.clearCookies();
 356     cy.clearAllLocalStorage();
 357     cy.clearAllSessionStorage();
 358     cy.visit(`/token/?api_token=${user.token}`);
 359     // Use waitUntil to avoid permafail race conditions with window.location being undefined
 360     cy.waitUntil(() => cy.window().then(win =>
 361         win?.location?.href &&
 362         win.location.href.includes("/projects/")
 363     ), { timeout: 15000 });
 364     // Wait for page to settle before getting elements
 365     cy.waitForDom();
 366     cy.get("div#root").should("contain", "Arvados Workbench (zzzzz)");
 367     cy.get("div#root").should("not.contain", "Your account is inactive");
 368 });
 369
 370 Cypress.Commands.add("testEditProjectOrCollection", (container, oldName, newName, newDescription, isProject = true) => {
 371     cy.get(container).contains(oldName).rightclick();
 372     cy.get("[data-cy=context-menu]")
 373         .contains(isProject ? "Edit project" : "Edit collection")
 374         .click();
 375     cy.get("[data-cy=form-dialog]").within(() => {
 376         cy.get("input[name=name]").clear().type(newName);
 377         cy.get(isProject ? "div[contenteditable=true]" : "input[name=description]")
 378             .clear()
 379             .type(newDescription);
 380         cy.get("[data-cy=form-submit-btn]").click();
 381     });
 382
 383     cy.get(container).contains(newName).rightclick();
 384     cy.get("[data-cy=context-menu]")
 385         .contains(isProject ? "Edit project" : "Edit collection")
 386         .click();
 387     cy.get("[data-cy=form-dialog]").within(() => {
 388         cy.get("input[name=name]").should("have.value", newName);
 389
 390         if (isProject) {
 391             cy.get("span[data-text=true]").contains(newDescription);
 392         } else {
 393             cy.get("input[name=description]").should("have.value", newDescription);
 394         }
 395
 396         cy.get("[data-cy=form-cancel-btn]").click();
 397     });
 398 });
 399
 400 Cypress.Commands.add("doSearch", searchTerm => {
 401     cy.get("[data-cy=searchbar-input-field]").type(`{selectall}${searchTerm}{enter}`);
 402 });
 403
 404 Cypress.Commands.add("goToPath", path => {
 405     return cy.window().its("appHistory").invoke("push", path);
 406 });
 407
 408 Cypress.Commands.add("getAll", (...elements) => {
 409     const promise = cy.wrap([], { log: false });
 410
 411     for (let element of elements) {
 412         promise.then(arr => cy.get(element).then(got => cy.wrap([...arr, got])));
 413     }
 414
 415     return promise;
 416 });
 417
 418 Cypress.Commands.add("shareWith", (srcUserToken, targetUserUUID, itemUUID, permission = "can_write") => {
 419     cy.createLink(srcUserToken, {
 420         name: permission,
 421         link_class: "permission",
 422         head_uuid: itemUUID,
 423         tail_uuid: targetUserUUID,
 424     });
 425 });
 426
 427 Cypress.Commands.add("addToFavorites", (userToken, userUUID, itemUUID) => {
 428     cy.createLink(userToken, {
 429         head_uuid: itemUUID,
 430         link_class: "star",
 431         name: "",
 432         owner_uuid: userUUID,
 433         tail_uuid: userUUID,
 434     });
 435 });
 436
 437 Cypress.Commands.add("createProject", ({ owningUser, targetUser, projectName, canWrite, addToFavorites }) => {
 438     const writePermission = canWrite ? "can_write" : "can_read";
 439
 440     cy.createGroup(owningUser.token, {
 441         name: `${projectName} ${Math.floor(Math.random() * 999999)}`,
 442         group_class: "project",
 443     })
 444         .as(`${projectName}`)
 445         .then(project => {
 446             if (targetUser && targetUser !== owningUser) {
 447                 cy.shareWith(owningUser.token, targetUser.user.uuid, project.uuid, writePermission);
 448             }
 449             if (addToFavorites) {
 450                 const user = targetUser ? targetUser : owningUser;
 451                 cy.addToFavorites(user.token, user.user.uuid, project.uuid);
 452             }
 453         });
 454 });
 455
 456 Cypress.Commands.add(
 457     "upload",
 458     {
 459         prevSubject: "element",
 460     },
 461     (subject, file, fileName, binaryMode = true) => {
 462         cy.window().then(window => {
 463             const blob = binaryMode ? b64toBlob(file, "", 512) : new Blob([file], { type: "text/plain" });
 464             const testFile = new window.File([blob], fileName);
 465
 466             cy.wrap(subject).trigger("drop", {
 467                 dataTransfer: { files: [testFile] },
 468             });
 469         });
 470     }
 471 );
 472
 473 function b64toBlob(b64Data, contentType = "", sliceSize = 512) {
 474     const byteCharacters = atob(b64Data);
 475     const byteArrays = [];
 476
 477     for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
 478         const slice = byteCharacters.slice(offset, offset + sliceSize);
 479
 480         const byteNumbers = new Array(slice.length);
 481         for (let i = 0; i < slice.length; i++) {
 482             byteNumbers[i] = slice.charCodeAt(i);
 483         }
 484
 485         const byteArray = new Uint8Array(byteNumbers);
 486
 487         byteArrays.push(byteArray);
 488     }
 489
 490     const blob = new Blob(byteArrays, { type: contentType });
 491     return blob;
 492 }
 493
 494 // From https://github.com/cypress-io/cypress/issues/7306#issuecomment-1076451070=
 495 // This command requires the async package (https://www.npmjs.com/package/async)
 496 Cypress.Commands.add("waitForDom", () => {
 497     cy.window().then(
 498         {
 499             // Don't timeout before waitForDom finishes
 500             timeout: 10000,
 501         },
 502         win => {
 503             let timeElapsed = 0;
 504
 505             cy.log("Waiting for DOM mutations to complete");
 506
 507             return new Cypress.Promise(resolve => {
 508                 // set the required variables
 509                 let async = require("async");
 510                 let observerConfig = { attributes: true, childList: true, subtree: true };
 511                 let items = Array.apply(null, { length: 50 }).map(Number.call, Number);
 512                 win.mutationCount = 0;
 513                 win.previousMutationCount = null;
 514
 515                 // create an observer instance
 516                 let observer = new win.MutationObserver(mutations => {
 517                     mutations.forEach(mutation => {
 518                         // Only record "attributes" type mutations that are not a "class" mutation.
 519                         // If the mutation is not an "attributes" type, then we always record it.
 520                         if (mutation.type === "attributes" && mutation.attributeName !== "class") {
 521                             win.mutationCount += 1;
 522                         } else if (mutation.type !== "attributes") {
 523                             win.mutationCount += 1;
 524                         }
 525                     });
 526
 527                     // initialize the previousMutationCount
 528                     if (win.previousMutationCount == null) win.previousMutationCount = 0;
 529                 });
 530
 531                 // watch the document body for the specified mutations
 532                 observer.observe(win.document.body, observerConfig);
 533
 534                 // check the DOM for mutations up to 50 times for a maximum time of 5 seconds
 535                 async.eachSeries(
 536                     items,
 537                     function iteratee(item, callback) {
 538                         // keep track of the elapsed time so we can log it at the end of the command
 539                         timeElapsed = timeElapsed + 100;
 540
 541                         // make each iteration of the loop 100ms apart
 542                         setTimeout(() => {
 543                             if (win.mutationCount === win.previousMutationCount) {
 544                                 // pass an argument to the async callback to exit the loop
 545                                 return callback("Resolved - DOM changes complete.");
 546                             } else if (win.previousMutationCount != null) {
 547                                 // only set the previous count if the observer has checked the DOM at least once
 548                                 win.previousMutationCount = win.mutationCount;
 549                                 return callback();
 550                             } else if (win.mutationCount === 0 && win.previousMutationCount == null && item === 4) {
 551                                 // this is an early exit in case nothing is changing in the DOM. That way we only
 552                                 // wait 500ms instead of the full 5 seconds when no DOM changes are occurring.
 553                                 return callback("Resolved - Exiting early since no DOM changes were detected.");
 554                             } else {
 555                                 // proceed to the next iteration
 556                                 return callback();
 557                             }
 558                         }, 100);
 559                     },
 560                     function done() {
 561                         // Log the total wait time so users can see it
 562                         cy.log(`DOM mutations ${timeElapsed >= 5000 ? "did not complete" : "completed"} in ${timeElapsed} ms`);
 563
 564                         // disconnect the observer and resolve the promise
 565                         observer.disconnect();
 566                         resolve();
 567                     }
 568                 );
 569             });
 570         }
 571     );
 572 });