graphdb-workbench-tests 2.8.0-Test → 2.8.1-RC1

package/steps/repository-steps.js

@@ -3,7 +3,7 @@ import {REPOSITORIES_URL} from "../support/repository-commands";
 export class RepositorySteps {
 
     static visit() {
-        cy.intercept('/rest/locations?filterClusterLocations=true').as('getLocations');
+        cy.intercept('/rest/locations').as('getLocations');
         cy.intercept(REPOSITORIES_URL + 'all').as('getRepositories');
         cy.visit('/repository');
         RepositorySteps.waitLoader();
@@ -85,6 +85,16 @@ export class RepositorySteps {
         RepositorySteps.clickRepositoryIcon(repositoryId, '.repository-actions .restart-repository-btn');
     }
 
+    static getEditViewRestartButton() {
+        return cy.get('#restartRepo');
+    }
+
+    static getRepositoryRestartButton(repositoryId) {
+        return RepositorySteps.getRepositoryFromList(repositoryId)
+            .should('be.visible')
+            .find('.repository-actions .restart-repository-btn');
+    }
+
     static createRepository() {
         RepositorySteps.getCreateRepositoryButton().click();
     }
@@ -227,26 +237,48 @@ export class RepositorySteps {
             .and('contain', 'Local');
     }
 
-    static getOntopicTable() {
-        return cy.get('#wb-repositories-ontopic-repositoryInGetRepositories');
+    static getSparqlOntopicTable() {
+        return cy.get('#wb-repositories-ontopic-sparql-repositoryInGetRepositories');
     }
 
     static getDeleteOntopicInstanceBtn(url) {
-        return RepositorySteps.getOntopicTable().find('tr').contains(url).parent().find('.delete-ontopic-location');
+        return RepositorySteps.getSparqlOntopicTable().find('tr').contains(url).parent().parent().find('.delete-ontopic-location');
     }
 
     static deleteOntopicInstance(url) {
         RepositorySteps.getDeleteOntopicInstanceBtn(url).click();
     }
 
+    static getDeleteSparqlInstanceBtn(url) {
+        return RepositorySteps.getSparqlOntopicTable().find('tr').contains(url).parent().parent().find('.delete-sparql-location');
+    }
+
+    static deleteSparqlLocation(url) {
+        RepositorySteps.getDeleteSparqlInstanceBtn(url).click();
+    }
+
     static getEditOntopicInstanceBtn(url) {
-        return RepositorySteps.getOntopicTable().find('tr').contains(url).parent().find('.edit-ontopic-location');
+        return RepositorySteps.getSparqlOntopicTable().find('tr').contains(url).parent().parent().find('.edit-ontopic-location');
     }
 
     static editOntopicInstance(url) {
         RepositorySteps.getEditOntopicInstanceBtn(url).click();
     }
 
+    static getEditSparqlInstanceBtn(row) {
+        return cy.get('#wb-repositories-ontopic-sparql-repositoryInGetRepositories tbody tr')
+            .eq(row)
+            .find('.edit-sparql-location');
+    }
+
+    static editSparqlInstance(row) {
+        RepositorySteps.getEditSparqlInstanceBtn(row).click();
+    }
+
+    static getRestartRemoteRepoButton(row) {
+        return this.getRemoteGraphDBTable().eq(row).find('.repository-actions .restart-repository-btn');
+    }
+
     static getRemoteGraphDBTable() {
         return cy.get('#wb-locations-locationInGetRemoteLocations');
     }
@@ -268,11 +300,8 @@ export class RepositorySteps {
     }
 
     static assertRepositoryStatus(repositoryId, status) {
-        cy.waitUntil(() =>
-            RepositorySteps.getRepositoryFromList(repositoryId)
-                .should('be.visible')
-                .find('.repository-status .text-secondary')
-                .then(($el) => $el)
-                .then(($el) => $el && $el.text() === status));
+        RepositorySteps.getRepositoryFromList(repositoryId).as('repo');
+        cy.get('@repo').should('be.visible');
+        cy.get('@repo').find('.repository-status .text-secondary').contains(status);
     }
 }

package/steps/setup/autocomplete-steps.js

@@ -0,0 +1,59 @@
+export class AutocompleteSteps {
+
+    static visit() {
+        cy.visit('/autocomplete');
+    }
+
+    static waitUntilAutocompletePageIsLoaded() {
+        // Workbench loading screen should not be visible
+        cy.get('.ot-splash').should('not.be.visible');
+
+        // No active loader
+        cy.get('.ot-loader').should('not.exist');
+
+        // No warnings should be present
+        this.getAutocompletePage().find('.alert-warning').should('not.be.visible');
+
+        this.getAutocompleteIndex().should('be.visible');
+    }
+
+    static getAutocompletePage() {
+        return cy.get('#autocomplete');
+    }
+
+    static getAutocompleteIndex() {
+        return this.getAutocompletePage().find('#toggleIndex');
+    }
+
+    static getAutocompleteHeader() {
+        return this.getAutocompleteIndex().find('.autocomplete-header');
+    }
+
+    static getAutocompleteSwitch() {
+        return this.getAutocompleteIndex().find('.autocomplete-switch');
+    }
+
+    static getAutocompleteStatus() {
+        return this.getAutocompleteIndex().find('.autocomplete-status');
+    }
+
+    static getBuildButton() {
+        return this.getAutocompleteIndex().find('.build-index-btn');
+    }
+
+    static getToggleIRIButton() {
+        return this.getAutocompletePage().find('#toggleIRIs');
+    }
+
+    static getAddLabelButton() {
+        return this.getAutocompletePage().find('#wb-autocomplete-addLabel');
+    }
+
+    static getAutocompleteLabels() {
+        return this.getAutocompletePage().find('#wb-autocomplete-labels');
+    }
+
+    static getSuccessStatusElement() {
+        return cy.get('.autocomplete-status').find('.tag.tag-success.ng-binding');
+    }
+}

package/steps/setup/namespace-steps.js

@@ -0,0 +1,211 @@
+export class NamespaceSteps {
+    static visit() {
+        cy.visit('/namespaces');
+    }
+
+    static getNamespacesView() {
+        return cy.get('#wb-namespaces');
+    }
+
+    // ------ Generic ------
+
+    static waitUntilPageIsLoaded() {
+        // Workbench loading screen should not be visible
+        cy.get('.ot-splash').should('not.be.visible');
+
+        // No active loader
+        cy.get('.ot-loader').should('not.be.visible');
+
+        this.getAddNamespaceForm().should('be.visible');
+    }
+
+    static getNoNamespacesAlert() {
+        return this.getNamespacesView().find('.no-namespaces-alert');
+    }
+
+    static getNoNamespacesMatchAlert() {
+        return this.getNamespacesView().find('.no-namespaces-match-alert');
+    }
+
+    // ------ Add namespaces ------
+
+    static getAddNamespaceForm() {
+        return this.getNamespacesView().find('.add-namespace-form');
+    }
+
+    static getNamespacePrefixField() {
+        return this.getAddNamespaceForm().find('#wb-namespaces-prefix');
+    }
+
+    static typeNamespacePrefix(prefix) {
+        this.getNamespacePrefixField().type(prefix);
+    }
+
+    static getNamespaceValueField() {
+        return this.getAddNamespaceForm().find('#wb-namespaces-namespace');
+    }
+
+    static typeNamespaceURI(uri) {
+        this.getNamespaceValueField().type(uri);
+    }
+
+    static getAddNamespaceButton() {
+        return this.getAddNamespaceForm().find('#wb-namespaces-addNamespace');
+    }
+
+    static addNamespace() {
+        this.getAddNamespaceButton().click();
+    }
+
+    // ------ Namespaces per page ------
+
+    static getNamespacesPerPageMenu() {
+        return cy.get('.namespaces-per-page-menu');
+    }
+
+    // ------ Namespaces results header ------
+
+    static getNamespacesResultHeader() {
+        return cy.get('.namespaces-result-header');
+    }
+
+    static getNamespacesFilterField() {
+        return this.getNamespacesResultHeader().find('.namespaces-filter');
+    }
+
+    static getNamespacesHeaderPagination() {
+        return this.getNamespacesResultHeader().find('.namespaces-header-pagination .pagination');
+    }
+
+    static getNamespacesHeaderPaginationInfo() {
+        return this.getNamespacesResultHeader().find('.showing-info-namespaces');
+    }
+
+    // ------ Namespaces results ------
+
+    static getNamespacesTable() {
+        return cy.get('#wb-namespaces-namespaceInNamespaces');
+    }
+
+    static getSelectAllNamespacesCheckbox() {
+        return this.getNamespacesTable().find('.select-all-namespaces');
+    }
+
+    static getDeleteNamespacesButton() {
+        return this.getNamespacesTable().get('[data-cy="delete-several-prefixes"]');
+    }
+
+    static getNamespaces() {
+        return this.getNamespacesTable().find('.namespace');
+    }
+
+    static getNamespacePrefix(index) {
+        return this.getNamespaces().eq(index).find('.namespace-prefix').invoke('text');
+    }
+
+    static getNamespaceValue(index) {
+        return this.getNamespaces().eq(index).find('.namespaceURI').invoke('text');
+    }
+
+    static getRefreshedTableNamespaces() {
+        cy.get('[data-cy="namespaces-per-page-menu"]').click()
+            .get('[data-cy="all-label"]').click();
+    }
+
+    static getNamespace(prefix) {
+        return this.getNamespacesTable().find('.namespace')
+            .should('be.visible')
+            .find('.namespace-prefix')
+            .should('be.visible')
+            .contains(prefix)
+            .should('be.visible')
+            .parentsUntil('tbody')
+            .last();
+    }
+
+    static getSelectNamespaceCheckbox(prefix) {
+        return this.getNamespace(prefix)
+            .should('be.visible')
+            .find('.select-namespace');
+    }
+
+    static selectNamespace(prefix) {
+        this.getSelectNamespaceCheckbox(prefix).click();
+    }
+
+    static getEditNamespaceButton(prefix) {
+        return this.getNamespace(prefix)
+            .should('be.visible')
+            .find('.edit-namespace-btn');
+    }
+
+    static editNamespaceByIndex(index) {
+        this.getNamespaces().eq(index).find('.edit-namespace-btn').click();
+    }
+
+    static getInlineNamespacePrefix(index) {
+        return this.getNamespaces().eq(index).find('.namespace-prefix').siblings('.editable-text').find('input');
+    }
+
+    static typeInlineNamespacePrefix(index, prefix) {
+        this.getInlineNamespacePrefix(index).clear().type(prefix);
+    }
+
+    static getInlineNamespaceValue(index) {
+        return this.getNamespaces().eq(index).find('.namespaceURI').siblings('.editable-url').find('input');
+    }
+
+    static typeInlineNamespaceValue(index, namespace) {
+        this.getInlineNamespaceValue(index).clear().type(namespace);
+    }
+
+    static getSaveInlineNamespaceButton(index) {
+        return this.getNamespaces().eq(index).find('button[type="submit"]');
+    }
+
+    static saveInlineNamespace(index) {
+        this.getSaveInlineNamespaceButton(index).click();
+    }
+
+    // TODO: Not used yet
+    static editNamespace(prefix) {
+        this.getEditNamespaceButton(prefix).click();
+    }
+
+    static getDeleteNamespaceButton(prefix) {
+        return this.getNamespace(prefix)
+            .should('be.visible')
+            .get(`[data-cy="delete-pref_${prefix}"]`)
+            .should('be.visible');
+    }
+
+    static deleteNamespace(prefix) {
+        this.getDeleteNamespaceButton(prefix).should('be.visible').click();
+    }
+
+    // ------ Namespaces pagination ------
+
+    static getNamespacesPagination() {
+        return this.getNamespacesView().find('.namespaces-pagination .pagination');
+    }
+
+    static getDefaultNamespacesLength(namespacesObject) {
+        return Object.keys(namespacesObject).length;
+    }
+
+    static getPagingCount(namespacesObject) {
+        const count = this.getDefaultNamespacesLength(namespacesObject);
+        if (count <= 10) {
+            return 1;
+        }
+        if (count <= 20) {
+            return 2;
+        }
+        if (count <= 50) {
+            return 3;
+        }
+        if (count <= 100) {
+            return 4;
+        } else return 5;
+    }
+}

package/steps/setup/plugins-steps.js

@@ -0,0 +1,37 @@
+export class PluginsSteps {
+    static visit() {
+        cy.visit('/plugins');
+    }
+
+    static getPluginsView() {
+        return cy.get('#plugins');
+    }
+
+    static waitUntilPluginsPageIsLoaded() {
+        // Workbench loading screen should not be visible
+        cy.get('.ot-splash').should('not.be.visible');
+
+        // No active loader
+        cy.get('.ot-loader').should('not.exist');
+    }
+
+    static getPluginByName(name) {
+        return this.getPluginsView().find('.plugin').contains(name).parent();
+    }
+
+    static getPluginStatus(name) {
+        return this.getPluginByName(name).find('.tag-primary');
+    }
+
+    static getPluginSwitch(name) {
+        return this.getPluginByName(name).find('.plugins-switch');
+    }
+
+    static getPluginSwitchField(name) {
+        return this.getPluginSwitch(name).find('input');
+    }
+
+    static togglePlugin(name) {
+        this.getPluginSwitch(name).click();
+    }
+}

package/steps/setup/rdf-rank-steps.js

@@ -0,0 +1,106 @@
+
+export class RdfRankSteps {
+    static visit() {
+        cy.visit('/rdfrank');
+    }
+
+    static getRdfRankView() {
+        return cy.get('#rdfRank');
+    }
+
+    static waitUntilRdfRankPageIsLoaded() {
+        // Workbench loading screen should not be visible
+        cy.get('.ot-splash').should('not.be.visible');
+
+        // No active loader
+        cy.get('.ot-loader').should('not.exist');
+
+        this.getRdfRankPage().find('.alert-warning').should('not.be.visible');
+
+        this.getFilteringSwitch().scrollIntoView().should('be.visible');
+    }
+
+    static getRdfRankPage() {
+        return cy.get('#rdfRank');
+    }
+
+    static getRdfStatusHeader() {
+        return this.getRdfRankPage().find('#toggleIndex');
+    }
+
+    static getRdfStatusTags() {
+        return this.getRdfStatusHeader().find('.tag');
+    }
+
+    static getComputeFullButton() {
+        return this.getRdfStatusHeader().find('.compute-rdf-rank-btn');
+    }
+
+    static computeRdfRank() {
+        this.getComputeFullButton().click();
+    }
+
+    static getFilteringMode() {
+        return this.getRdfRankPage().find('#toggleFilterMode');
+    }
+
+    static getFilteringSwitch() {
+        return this.getFilteringMode().find('.rdf-rank-filter-switch');
+    }
+
+    static getFilteringSwitchInput() {
+        return this.getFilteringSwitch().find('input');
+    }
+
+    static enableFiltering() {
+        this.getFilteringSwitch().click();
+    }
+
+    static getFilteringConfig() {
+        return this.getRdfRankPage().find('#filterConfig');
+    }
+
+    static getIncludeExplicitSwitch() {
+        return this.getFilteringConfig().find('#toggleIncludeExplicit');
+    }
+
+    static getIncludeImplicitSwitch() {
+        return this.getFilteringConfig().find('#toggleIncludeImplicit');
+    }
+
+    static getFilteringConfigTabs() {
+        return this.getFilteringConfig().find('.nav li');
+    }
+
+    static getGraphsConfigTab() {
+        return this.getFilteringConfigTabs().eq(0);
+    }
+
+    static getPredicatesConfigTab() {
+        return this.getFilteringConfigTabs().eq(1);
+    }
+
+    static openPredicatesConfigTab() {
+        this.getPredicatesConfigTab().find('.nav-item').click();
+    }
+
+    static getIncludedGraphsFilter() {
+        return this.getFilteringConfig().find('.included-graphs-filter');
+    }
+
+    static getExcludedGraphsFilter() {
+        return this.getFilteringConfig().find('.excluded-graphs-filter');
+    }
+
+    static getIncludedPredicatesFilter() {
+        return this.getFilteringConfig().find('.included-predicates-filter');
+    }
+
+    static getExcludedPredicatesFilter() {
+        return this.getFilteringConfig().find('.excluded-predicates-filter');
+    }
+
+    static getToast() {
+        return cy.get('#toast-container');
+    }
+}

package/steps/setup/settings-steps.js

@@ -0,0 +1,17 @@
+export class SettingsSteps {
+    static visit() {
+        cy.visit('/settings');
+    }
+
+    static getCookiePolicyButton() {
+        return cy.get('.show-cookie-policy-btn');
+    }
+
+    static clickCookiePolicyLink() {
+        return SettingsSteps.getCookiePolicyButton().click();
+    }
+
+    static getCookiePolicyModal() {
+        return cy.get('.cookie-policy-modal');
+    }
+}

package/steps/ttyg/chat-panel-steps.js

@@ -12,8 +12,8 @@ export class ChatPanelSteps {
         return ChatPanelSteps.getChatDetailsElements().eq(index).scrollIntoView();
     }
 
-    static getChatDetailActions(index = 0) {
-        return ChatPanelSteps.getChatDetailElement(index).find('.actions');
+    static getChatDetailActions(chatDetailIndex = 0, answerIndex = 0) {
+        return ChatPanelSteps.getChatDetailElement(chatDetailIndex).find('.actions').eq(answerIndex);
     }
 
     static getQuestionInputElement() {
@@ -28,10 +28,35 @@ export class ChatPanelSteps {
         return ChatPanelSteps.getChatDetailElement(index).find('.question');
     }
 
-    static regenerateQuestion(index) {
-        ChatPanelSteps.getChatDetailActions(index).find('.regenerate-question-btn').scrollIntoView().click();
+    static regenerateQuestion(index, answerIndex = 0) {
+        ChatPanelSteps.getChatDetailActions(index, answerIndex).find('.regenerate-question-btn').scrollIntoView().click();
     }
-    static copyAnswer(index) {
-        ChatPanelSteps.getChatDetailActions(index).find('.copy-answer-btn').click({force: true});
+
+    static copyAnswer(index, answerIndex = 0) {
+        ChatPanelSteps.getChatDetailActions(index, answerIndex).find('.copy-answer-btn').click({force: true});
+    }
+
+    static getAgentInfoMessages() {
+        return ChatPanelSteps.getChatPanel().find('.agent-changed-info');
+    }
+
+    static getAgentInfoMessage(index = 0) {
+        return ChatPanelSteps.getAgentInfoMessages().eq(index);
+    }
+
+    static getOpenInSparqlEditorElements() {
+        return ChatPanelSteps.getChatPanel().find('open-in-sparql-editor');
+    }
+
+    static getOpenInSparqlEditorElement(index = 0) {
+        return ChatPanelSteps.getOpenInSparqlEditorElements().eq(index);
+    }
+
+    static getCopyToClipboardElements() {
+        return ChatPanelSteps.getChatPanel().find('copy-to-clipboard');
+    }
+
+    static getCopyToClipboardElement(index = 0) {
+        return ChatPanelSteps.getCopyToClipboardElements().eq(index);
     }
 }