graphdb-workbench-tests 2.5.1 → 2.6.0-RC2

package/steps/yasgui/yasgui-steps.js

@@ -0,0 +1,191 @@
+export class YasguiSteps {
+
+    static getYasgui() {
+        return cy.get('.yasgui');
+    }
+
+    static getYasguiTag() {
+        return cy.get('ontotext-yasgui');
+    }
+
+    static openANewTab() {
+        cy.get('button.addTab').click();
+    }
+
+    static closeTab(index) {
+        this.getTabs().eq(index).find('.closeTab').click();
+    }
+
+    static getTabs() {
+        return cy.get('.tab');
+    }
+
+    static getCurrentTab() {
+        return cy.get('.tab.active');
+    }
+
+    static getCurrentTabTitle() {
+        return this.getCurrentTab().find('[role=tab] > div');
+    }
+
+    static openTab(index) {
+        this.getTabs().eq(index).click();
+    }
+
+    static openTabContextMenu(index) {
+        this.getTabs().eq(index).rightclick();
+        return TabContextMenu.getContextMenu();
+    }
+
+    static getTabQuery(tabIndex) {
+        return cy.get('.yasqe .CodeMirror').then((el) => {
+            return el[tabIndex].CodeMirror.getValue();
+        });
+    }
+
+    static getCreateSavedQueryButton() {
+        return cy.get('.yasqe_createSavedQueryButton');
+    }
+
+    static createSavedQuery() {
+        this.getCreateSavedQueryButton().click();
+    }
+
+    static getShowSavedQueriesButton() {
+        return cy.get('.yasqe_showSavedQueriesButton');
+    }
+
+    static showSavedQueries() {
+        this.getShowSavedQueriesButton().click();
+    }
+
+    static getYasguiModeButton() {
+        return cy.get('.btn-mode-yasgui');
+    }
+
+    static isYasguiModeSelected() {
+        return this.getYasguiModeButton().should('have.class', 'btn-selected');
+    }
+
+    static isYasguiModeDeselected() {
+        return this.getYasguiModeButton().should('not.have.class', 'btn-selected');
+    }
+
+    static getYasqeModeButton() {
+        return cy.get('.btn-mode-yasqe');
+    }
+
+    static isYasqeModeSelected() {
+        return this.getYasqeModeButton().should('have.class', 'btn-selected');
+    }
+
+    static isYasqeModeDeselected() {
+        return this.getYasqeModeButton().should('not.have.class', 'btn-selected');
+    }
+
+    static isVerticalOrientation() {
+        this.getYasguiTag().should('have.class', 'orientation-vertical');
+    }
+
+    static getYasrModeButton() {
+        return cy.get('.btn-mode-yasr');
+    }
+
+    static isYasrModeSelected() {
+        return this.getYasrModeButton().should('have.class', 'btn-selected');
+    }
+
+    static getOrientationButton() {
+        return cy.get('.btn-orientation');
+    }
+
+    static isBtnOrientationVerticalOrientation() {
+        this.getOrientationButton().should('not.have.class', 'icon-rotate-90');
+    }
+
+    static isBtnOrientationHorizontalOrientation() {
+        this.getOrientationButton().should('have.class', 'icon-rotate-90');
+    }
+
+    static switchToModeYasgui() {
+        this.getYasguiModeButton().click();
+    }
+
+    static switchToModeYasqe() {
+        this.getYasqeModeButton().click();
+    }
+
+    static switchToModeYasr() {
+        this.getYasrModeButton().click();
+    }
+
+    static toggleOrientation() {
+        this.getOrientationButton().click();
+    }
+
+    static getHideToolbarButton() {
+        return cy.get('#hideToolbar');
+    }
+
+    static hideToolbar() {
+        this.getHideToolbarButton().click();
+    }
+
+    static getShowToolbarButton() {
+        return cy.get('#showToolbar');
+    }
+
+    static showToolbar() {
+        this.getShowToolbarButton().click();
+    }
+
+    static getToolbar() {
+        return cy.get('.yasgui-toolbar');
+    }
+
+    static showLayoutOrientationButtonTooltip() {
+        YasguiSteps.getOrientationButton().trigger('mouseover');
+    }
+
+    static hideLayoutOrientationButtonTooltip() {
+        YasguiSteps.getOrientationButton().trigger('mouseleave');
+    }
+
+    static isYasrModeDeselected() {
+        return this.getYasrModeButton().should('not.have.class', 'btn-selected');
+    }
+
+    static isHorizontalOrientation() {
+        this.getYasguiTag().should('have.class', 'orientation-horizontal');
+    }
+
+    static getDeleteQueryConfirmation() {
+        return cy.get('.confirmation-dialog');
+    }
+
+    static rejectDeleteOperation() {
+        this.getDeleteQueryConfirmation().find('.cancel-button').click();
+    }
+
+    static confirmDeleteOperation() {
+        this.getDeleteQueryConfirmation().find('.confirm-button').click();
+    }
+
+    static getTooltipRoot() {
+        return cy.get('div[data-tippy-root]');
+    }
+}
+
+export class TabContextMenu {
+    static getContextMenu() {
+        return cy.get('.yasgui .context-menu');
+    }
+
+    static closeTab() {
+        this.getContextMenu().contains('Close Tab').click();
+    }
+
+    static closeOtherTabs() {
+        this.getContextMenu().contains('Close other tabs').click();
+    }
+}

package/steps/yasgui/yasqe-steps.js

@@ -0,0 +1,187 @@
+import {YasrSteps} from "./yasr-steps";
+
+export class YasqeSteps {
+    static getYasqe() {
+        return cy.get('.tabPanel.active .yasqe');
+    }
+
+    static getQueryTabs() {
+        return cy.get('.tabsList');
+    }
+
+    static getEditor() {
+        return YasqeSteps.getYasqe();
+    }
+
+    static getCodeMirror() {
+        return this.getEditor().find('.CodeMirror').then(($el) => {
+            // @ts-ignore
+            return $el[0].CodeMirror;
+        });
+    }
+
+    static getActiveTabCodeMirror() {
+        return this.getYasqe().find('.CodeMirror').then(($el) => {
+            // @ts-ignore
+            return $el[0].CodeMirror;
+        });
+    }
+
+    static getExecuteQueryButton() {
+        return YasqeSteps.getYasqe().find('.yasqe_queryButton');
+    }
+
+    static executeQuery() {
+        this.getExecuteQueryButton().click();
+        YasrSteps.getResponseInfo()
+            .should('not.have.class', 'hidden')
+            .should('not.have.class', 'empty')
+            .should('be.visible');
+    }
+
+    static executeQueryWithoutWaiteResult() {
+        this.getExecuteQueryButton().click();
+    }
+
+    static executeErrorQuery() {
+        this.getExecuteQueryButton().click();
+        // Wait a wile for the response information to be present.
+        cy.get('.error-response-plugin').should('be.visible');
+    }
+
+    static clearEditor() {
+        this.getCodeMirror().then((cm) => {
+            cm.getDoc().setValue('');
+        });
+    }
+
+    /**
+     * Adds <code>text</code> to the end of current query.
+     * @param {string} text - text to be added.
+     */
+    static writeInEditor(text, parseSpecialCharSequences = false) {
+        YasqeSteps.getEditor().find('textarea').type(text, {force: true, parseSpecialCharSequences});
+        YasqeSteps.verifyQueryContains(text);
+    }
+
+    /**
+     * Paste query in Yasqe editor.
+     * This method is faster than {@link YasqeSteps.writeInEditor}, but the editor stay pristine, if you want editor to be touched use {@link YasqeSteps.writeInEditor}.
+     * @param {string} query - the new value of Yasqe.
+     */
+    static pasteQuery(query) {
+        this.clearEditor();
+        this.getCodeMirror().then((cm) => {
+            cm.getDoc().setValue(query);
+        });
+        YasqeSteps.verifyQueryTyped(query);
+    }
+
+    static waitUntilQueryIsVisible() {
+        return cy.waitUntil(() =>
+            this.getEditor().find('.CodeMirror')
+                .then((codeMirrorEl) =>
+                    codeMirrorEl && codeMirrorEl[0].CodeMirror.getValue().trim().length > 0));
+    }
+
+    static verifyQueryTyped(query) {
+        return cy.waitUntil(() =>
+            this.getEditor().find('.CodeMirror')
+                .then((codeMirrorEl) => {
+                    return codeMirrorEl && codeMirrorEl[0].CodeMirror.getValue().indexOf(query) !== -1;
+                }));
+    }
+
+    static verifyQueryContains(queryPart) {
+        this.getCodeMirror().then((cm) => {
+            expect(cm.getValue().replace(/\s/g, '')).contain(queryPart.replace(/\s/g, ''));
+        });
+    }
+
+    /**
+     * In certain scenarios we need to wait a bit before trying to get the query from the editor. For example, when the
+     * query is dynamically switched using the yasgui api, it may take some time before the old query gets replaced or
+     * removed from the editor.
+     * @param {number} delay The time in milliseconds to wait before trying to get the editor and its query.
+     * @return {Cypress.Chainable<unknown>}
+     */
+    static getQuery(delay = 0) {
+        return cy.wait(delay).then(() => this.getCodeMirror()).then((cm) => {
+            return cm.getValue();
+        });
+    }
+
+    static getActiveTabQuery(delay = 0) {
+        return cy.wait(delay).then(() => this.getActiveTabCodeMirror()).then((cm) => {
+            return cm.getValue();
+        });
+    }
+
+    static getControlBar() {
+        return cy.get('.controlbar');
+    }
+
+    static getIncludeInferredStatementsButton() {
+        return cy.get('.yasqe_inferStatementsButton');
+    }
+
+    static getIncludeInferredStatementsButtonTooltip() {
+        return this.getIncludeInferredStatementsButton().parent();
+    }
+
+    static includeInferredStatements() {
+        this.getIncludeInferredStatementsButton().click();
+    }
+
+    static getExpandResultsOverSameAsButton() {
+        return cy.get('.yasqe_expandResultsButton');
+    }
+
+    static getExpandResultsOverSameAsButtonTooltip() {
+        return this.getExpandResultsOverSameAsButton().parent();
+    }
+
+    static expandResultsOverSameAs() {
+        this.getExpandResultsOverSameAsButton().click();
+    }
+
+    static getShareQueryButton() {
+        return cy.get('.yasqe_shareQueryButton');
+    }
+
+    static shareQuery() {
+        this.getShareQueryButton().click();
+    }
+
+    static getAbortQueryButton() {
+        return cy.get('.abort-button');
+    }
+
+    static hoverOverAbortQueryButton() {
+        YasqeSteps.getAbortQueryButton().realHover();
+    }
+
+    static getAbortQueryTooltip() {
+        return YasqeSteps.getAbortQueryButton().parent();
+    }
+
+    static getActionsToolbar() {
+        return YasqeSteps.getEditor().find('.yasqe_buttons');
+    }
+
+    static getActionButtonsTooltips() {
+        return YasqeSteps.getActionsToolbar().find('yasgui-tooltip');
+    }
+
+    static getActionButtonTooltip(index) {
+        return YasqeSteps.getActionButtonsTooltips().eq(index);
+    }
+
+    static getActionButtons() {
+        return YasqeSteps.getActionsToolbar().find('.custom-button');
+    }
+
+    static getActionButton(index) {
+        return YasqeSteps.getActionButtons().eq(index);
+    }
+}

package/steps/yasgui/yasr-steps.js

@@ -0,0 +1,108 @@
+export class YasrSteps {
+    static getYasr() {
+        return cy.get('.tabPanel.active .yasr');
+    }
+
+    static getResultHeader() {
+        return cy.get('.yasr_header');
+    }
+
+    static getResponseInfo() {
+        return YasrSteps.getYasr().find('.yasr_response_chip');
+    }
+
+    static getErrorHeader() {
+        return YasrSteps.getResultHeader().get('.errorHeader');
+    }
+
+    static getErrorBody() {
+        return YasrSteps.getResultHeader().get('.error-response-plugin-body');
+    }
+
+    static getYasrResultsContainer() {
+        return YasrSteps.getYasr().find('.yasr_results');
+    }
+
+    static getResults() {
+        return YasrSteps.getYasr().find('.yasr_results tbody').find('tr');
+    }
+
+    static getResultTableHeader() {
+        return cy.get('.yasr_results thead');
+    }
+
+    static getResultTableHeaderColumns() {
+        return YasrSteps.getResultTableHeader().find('th');
+    }
+
+    static getResultFilter() {
+        return cy.get('.tableFilter');
+    }
+
+    static getResultRow(rowNumber) {
+        return this.getResults().eq(rowNumber);
+    }
+
+    static getResultRowCells(rowNumber) {
+        return YasrSteps.getResultRow(rowNumber).find('td');
+    }
+
+    static getResultCell(rowNumber, cellNumber) {
+        return YasrSteps.getResultRowCells(rowNumber).eq(cellNumber);
+    }
+
+    static getResultLink(rowNumber, cellNumber) {
+        return YasrSteps.getResultCell(rowNumber, cellNumber).find('a');
+    }
+
+    static hoverCell(rowNumber, cellNumber) {
+        this.getResultCell(rowNumber, cellNumber).realHover();
+    }
+
+    static getCopyResourceLink(rowNumber, cellNumber) {
+        return this.getResultCell(rowNumber, cellNumber)
+            .realHover()
+            .find('.copy-resource-link-button a');
+    }
+
+    static showSharedResourceLink(rowNumber, cellNumber) {
+        return this.getResultCell(rowNumber, cellNumber)
+            .find('.copy-resource-link-button a');
+    }
+
+    static copyResourceLink(rowNumber, cellNumber) {
+        this.showSharedResourceLink(rowNumber, cellNumber).realClick();
+    }
+
+    static getDownloadAsDropdown() {
+        return this.getYasr().find('ontotext-download-as');
+    }
+
+    static openDownloadAsDropdown() {
+        this.getDownloadAsDropdown().click();
+    }
+
+    static getDownloadAsOption(number) {
+        return this.getDownloadAsDropdown().find('.ontotext-dropdown-menu-item').eq(number);
+    }
+
+    static getPagination() {
+        return YasrSteps.getYasr().find('.ontotext-pagination');
+    }
+
+    static getYasrToolbar() {
+        return YasrSteps.getYasr().find('.yasr-toolbar');
+    }
+
+    static getVisualButton() {
+        return YasrSteps.getYasrToolbar().find('.explore-visual-graph-button');
+    }
+
+    static getNoDataElement() {
+        return cy.get('.dataTables_empty');
+    }
+
+    static getNoResultsMessage() {
+        return YasrSteps.getYasr().find('.alert-success');
+    }
+}

package/stubs/namespace-stubs.js

@@ -0,0 +1,10 @@
+export class NamespaceStubs {
+
+    static stubGeneratedOntotextNamespacesResponse(repositoryId, withDelay = 0) {
+        NamespaceStubs.stubNameSpaceResponse(repositoryId, '/namespaces/ontotext-generated-namespace.json', withDelay);
+    }
+
+    static stubNameSpaceResponse(repositoryId, fixture, withDelay = 0) {
+        cy.intercept(`/repositories/${repositoryId}/namespaces`, {fixture, delay: withDelay}).as(`${repositoryId}-stub-namespaces`);
+    }
+}

package/stubs/repositories-stub.js

@@ -0,0 +1,58 @@
+export class RepositoriesStub {
+
+    static stubOntopRepository(repositoryId) {
+        const alRepositoryResponse = `{
+        "":[{
+                    "id": "${repositoryId}",
+                    "title": "",
+                    "uri": "http://b:9000/repositories/${repositoryId}",
+                    "externalUrl": "http://b:9000/repositories/${repositoryId}",
+                    "local": true,
+                    "type": "ontop",
+                    "sesameType": "graphdb:OntopRepository",
+                    "location": "",
+                    "readable": true,
+                    "writable": true,
+                    "unsupported": false,
+                    "state": "RUNNING"
+        }]}`;
+
+
+        cy.intercept('GET', '/rest/repositories/all', {
+            statusCode: 200,
+            body: alRepositoryResponse
+        });
+    }
+
+    /**
+     * @param {string} repositoryId
+     * @param {[]}namespaces - An instance of array object have to be:
+     *         {
+     *             "prefix" : {
+     *                 "type" : "literal",
+     *                 "value" : "agg"
+     *             },
+     *             "namespace" : {
+     *                 "type" : "literal",
+     *                 "value" : "http://jena.apache.org/ARQ/function/aggregate#"
+     *             }
+     *         }
+     */
+    static stubNameSpaces(repositoryId, namespaces = []) {
+        const namespacesResponse = `{
+                                      "head" : {
+                                        "vars" : [
+                                          "prefix",
+                                          "namespace"
+                                        ]
+                                      },
+                                      "results" : {
+                                        "bindings" : ${JSON.stringify(namespaces)}
+                                      }
+                                    }`;
+        cy.intercept('GET', `/repositories/${repositoryId}/namespaces`, {
+            statusCode: 200,
+            body: namespacesResponse
+        });
+    }
+}

package/stubs/security-stubs.js

@@ -0,0 +1,69 @@
+export class SecurityStubs {
+
+    static stubUserSecurity(infer = true, sameAs = true, userName = 'admin') {
+        cy.intercept(`rest/security/users/${userName}`, (req) => {
+            req.reply(SecurityStubs.getAdminResponse(infer, sameAs));
+        }).as('security-get-admin');
+    }
+
+    static stubInferAndSameAsDefaults() {
+        cy.intercept('rest/security/all', (req) => {
+            req.reply(SecurityStubs.getResponseSecurityEnabled());
+        }).as('security-all');
+    }
+
+    static getAdminResponse(infer, sameAs) {
+        return {
+            "username": "admin",
+            "password": "",
+            "grantedAuthorities": [
+                "ROLE_ADMIN"
+            ],
+            "appSettings": {
+                "DEFAULT_INFERENCE": infer,
+                "DEFAULT_VIS_GRAPH_SCHEMA": true,
+                "DEFAULT_SAMEAS": sameAs,
+                "IGNORE_SHARED_QUERIES": false,
+                "EXECUTE_COUNT": true
+            },
+            "dateCreated": 1663139335552
+        };
+    }
+
+    static getResponseSecurityEnabled() {
+        return {
+            "freeAccess": {
+                "enabled": false,
+                "authorities": [],
+                "appSettings": {
+                    "DEFAULT_INFERENCE": true,
+                    "DEFAULT_VIS_GRAPH_SCHEMA": true,
+                    "DEFAULT_SAMEAS": true,
+                    "IGNORE_SHARED_QUERIES": false,
+                    "EXECUTE_COUNT": true
+                }
+            },
+            "overrideAuth": {
+                "enabled": false,
+                "authorities": [
+                    "ROLE_REPO_MANAGER",
+                    "ROLE_MONITORING",
+                    "ROLE_USER"
+                ],
+                "appSettings": {
+                    "DEFAULT_INFERENCE": true,
+                    "DEFAULT_VIS_GRAPH_SCHEMA": true,
+                    "DEFAULT_SAMEAS": true,
+                    "IGNORE_SHARED_QUERIES": false,
+                    "EXECUTE_COUNT": true
+                }
+            },
+            "methodSettings": {},
+            "enabled": false,
+            "passwordLoginEnabled": true,
+            "hasExternalAuth": false,
+            "authImplementation": "Local",
+            "openIdEnabled": false
+        };
+    }
+}

package/stubs/yasgui/connectors-stubs.js

@@ -0,0 +1,12 @@
+export class ConnectorsStubs {
+
+    static stubLuceneHasNotSupport() {
+        ConnectorsStubs.stubCheckConnector('create', 'lucene-connector', 'Lucene', false);
+    }
+
+    static stubCheckConnector(command, connectorName, pluginName, hasSupport) {
+        cy.intercept(`rest/connectors/check`, (req) => {
+            req.reply({command, connectorName, pluginName, hasSupport});
+        }).as(`query-connector-has-not-support`);
+    }
+}