graphdb-workbench-tests 2.3.1 → 2.4.0-TR1

package/steps/lucene-connector-steps.js

@@ -0,0 +1,43 @@
+export class LuceneConnectorSteps {
+    static getCreateConnectorQuery(connectorName) {
+        return `PREFIX luc: <http://www.ontotext.com/connectors/lucene#> ` +
+                `PREFIX luc-index: <http://www.ontotext.com/connectors/lucene/instance#> ` +
+                    `INSERT DATA { ` +
+                        `luc-index:${connectorName} luc:createConnector ''' { ` +
+                            `"types": [` +
+                                `"http://www.ontotext.com/example/wine#Wine"` +
+                            `],` +
+                            `"fields": [` +
+                                `{` +
+                                    `"fieldName": "grape", ` +
+                                    `"propertyChain": [` +
+                                        `"http://www.ontotext.com/example/wine#madeFromGrape", ` +
+                                        `"http://www.w3.org/2000/01/rdf-schema#label"` +
+                                     `]` +
+                                `}, {` +
+                                    `"fieldName": "sugar", ` +
+                                    `"analyzed": false,` +
+                                    `"multivalued": false,` +
+                                    `"propertyChain": [` +
+                                        `"http://www.ontotext.com/example/wine#hasSugar"` +
+                                        `]` +
+                                `}, { ` +
+                                    `"fieldName": "year", ` +
+                                    `"analyzed": false, ` +
+                                    `"propertyChain": [` +
+                                        `"http://www.ontotext.com/example/wine#hasYear"` +
+                                    `]` +
+                                `}` +
+                            `]` +
+                        `}''' ` +
+                `.}`;
+    }
+
+    static getDeleteConnectorSteps(connectorName) {
+        return `PREFIX luc: <http://www.ontotext.com/connectors/lucene#>` +
+                `PREFIX luc-index: <http://www.ontotext.com/connectors/lucene/instance#>` +
+                `INSERT DATA {` +
+                `  luc-index:${connectorName} luc:dropConnector [] .` +
+                `}`;
+    }
+}

package/steps/main-menu-steps.js

@@ -0,0 +1,39 @@
+export class MainMenuSteps {
+
+    static getMainMenu() {
+        return cy.get('.main-menu');
+    }
+
+    static getMenuButton(menuName) {
+        return MainMenuSteps.getMainMenu().find('.menu-element').contains(menuName);
+    }
+
+    static clickOnMenu(menuName) {
+        // Forced it because some element as "Explore" for example has CSS pointer-events: none
+        MainMenuSteps.getMenuButton(menuName).click({force: true});
+    }
+
+    static clickOnMenuImport() {
+        MainMenuSteps.clickOnMenu('Import');
+    }
+
+    static clickOnExplore() {
+        MainMenuSteps.clickOnMenu('Explore');
+    }
+
+    static getSubMenus() {
+        return cy.get('.sub-menu-item');
+    }
+
+    static getSubMenuButton(submenuName) {
+        return MainMenuSteps.getSubMenus().contains(submenuName);
+    }
+
+    static clickOnSubMenu(submenuName) {
+        MainMenuSteps.getMenuButton(submenuName).click();
+    }
+
+    static clickOnGraphsOverview() {
+        MainMenuSteps.clickOnSubMenu('Graphs overview');
+    }
+}

package/steps/modal-dialog-steps.js

@@ -0,0 +1,113 @@
+export class ModalDialogSteps {
+    static getDialog() {
+        return cy.get('.modal-dialog');
+    }
+
+    static getDialogHeader() {
+        return ModalDialogSteps.getDialog().find('.modal-header');
+    }
+
+    static getCloseButton() {
+        return ModalDialogSteps.getDialogHeader().find('.close');
+    }
+
+    static clickOnCloseButton() {
+        ModalDialogSteps.getCloseButton().click();
+    }
+
+    static getDialogBody() {
+        return ModalDialogSteps.getDialog().find('.modal-body');
+    }
+
+    static verifyDialogBody(message) {
+        ModalDialogSteps.getDialogBody().contains(message);
+    }
+
+    static getDialogFooter() {
+        return ModalDialogSteps.getDialog().find('.modal-footer');
+    }
+
+    static getConfirmButton() {
+        return ModalDialogSteps.getDialogFooter().find('.confirm-btn');
+    }
+
+    static clickOnConfirmButton() {
+        ModalDialogSteps.getConfirmButton().click();
+    }
+
+    static getCancelButton() {
+        return ModalDialogSteps.getDialogFooter().find('.cancel-btn');
+    }
+
+    static clickOnCancelButton() {
+        ModalDialogSteps.getCancelButton().click();
+    }
+
+    static verifyUrlChangedConfirmation(verifyConfirmationDialogOptions = new VerifyConfirmationDialogOptions()) {
+        // and try to change the page
+        verifyConfirmationDialogOptions.changePageFunction();
+
+        // Then I expect to be asked to confirm the leaving tha page.
+        ModalDialogSteps.verifyDialogBody(verifyConfirmationDialogOptions.confirmationMessage);
+
+        // When I click on close dialog button.
+        ModalDialogSteps.clickOnCloseButton();
+
+        // Then I expect to stay on same page.
+        verifyConfirmationDialogOptions.verifyCurrentUrl();
+
+
+        // When I try to change the page again.
+        verifyConfirmationDialogOptions.changePageFunction();
+
+        // Then I expect to be asked to confirm the leaving tha page.
+        ModalDialogSteps.verifyDialogBody(verifyConfirmationDialogOptions.confirmationMessage);
+
+        // When I click on cancel dialog button.
+        ModalDialogSteps.clickOnCancelButton();
+
+        // Then I expect to stay on same page.
+        verifyConfirmationDialogOptions.verifyCurrentUrl();
+
+        // When I try to change the page again.
+        verifyConfirmationDialogOptions.changePageFunction();
+
+        // Then I expect to be asked to confirm the leaving tha page.
+        ModalDialogSteps.verifyDialogBody(verifyConfirmationDialogOptions.confirmationMessage);
+
+        // When I click on confirm dialog button.
+        ModalDialogSteps.clickOnConfirmButton();
+
+        // Then I expect to be redirected.
+        verifyConfirmationDialogOptions.verifyRedirectedUrl();
+    }
+}
+
+export class VerifyConfirmationDialogOptions {
+    constructor() {
+        this.changePageFunction = () => {};
+        this.confirmationMessage = "";
+        this.verifyCurrentUrl = () => {};
+        this.verifyRedirectedUrl = () => {};
+    }
+
+    setChangePageFunction(changePageFunction) {
+        this.changePageFunction = changePageFunction;
+        return this;
+    }
+
+    setConfirmationMessage(confirmationMessage) {
+        this.confirmationMessage = confirmationMessage;
+        return this;
+    }
+
+    setVerifyCurrentUrl(verifyCurrentUrl) {
+        this.verifyCurrentUrl = verifyCurrentUrl;
+        return this;
+    }
+
+    setVerifyRedirectedUrl(verifyRedirectedUrl) {
+        this.verifyRedirectedUrl = verifyRedirectedUrl;
+        return this;
+    }
+}

package/steps/repository-selector-steps.js

@@ -0,0 +1,26 @@
+export class RepositorySelectorSteps {
+
+    static getRepositorySelectorDropdown() {
+        return cy.get('#repositorySelectDropdown');
+    }
+
+    static getRepositorySelectorsButton() {
+        return RepositorySelectorSteps.getRepositorySelectorDropdown().find('#btnReposGroup');
+    }
+    static openRepositorySelectors() {
+        RepositorySelectorSteps.getRepositorySelectorsButton().click();
+    }
+
+    static getRepositorySelectorButton(repositoryId) {
+        return RepositorySelectorSteps.getRepositorySelectorDropdown().find('.dropdown-menu .multiline-text').contains(repositoryId);
+    }
+
+    static selectRepository(repositoryId) {
+        RepositorySelectorSteps.openRepositorySelectors();
+        RepositorySelectorSteps.getRepositorySelectorButton(repositoryId).click();
+    }
+
+    static getSelectedRepository() {
+        return RepositorySelectorSteps.getRepositorySelectorDropdown().find('.active-repository');
+    }
+}

package/steps/resource/resource-edit-steps.js

@@ -0,0 +1,111 @@
+const VIEW_URL = 'esource/edit';
+
+export class ResourceEditSteps {
+    static visit() {
+        cy.visit(VIEW_URL);
+    }
+
+    static verifyUrl() {
+        cy.url().should('eq', `${Cypress.config('baseUrl')}${VIEW_URL}`);
+    }
+
+    static getResourceTableElement() {
+        return cy.get('.table-striped');
+    }
+
+    static getNewPredicateInput() {
+        return ResourceEditSteps.getResourceTableElement().find('.predicate-input');
+    }
+
+    static getNewSuggestionsElement() {
+        return cy.get('.predicate-suggestions');
+    }
+
+    static selectPredicateSuggestion(suggestion = 'agg') {
+        ResourceEditSteps.getNewSuggestionsElement().contains(suggestion).find('.predicate-suggestion').click();
+    }
+
+    static getObjectTypeSelectorElement() {
+        return cy.get('.object-type-selector');
+    }
+
+    static openObjectTypeSelector() {
+        ResourceEditSteps.getObjectTypeSelectorElement().click();
+    }
+
+    static getObjectTypeOptionElement(objectType = 'IRI') {
+        return ResourceEditSteps.getObjectTypeSelectorElement().find('option').contains(objectType);
+    }
+
+    static selectObjectType(objectType) {
+        ResourceEditSteps.getObjectTypeOptionElement().contains(objectType).click();
+    }
+
+    static getObjectUriTextInput() {
+        return cy.get('#objectUriText');
+    }
+
+    static getObjectIriTypeSuggestionsElement() {
+        return cy.get('.object-iri-type-suggestions');
+    }
+
+    static getObjectIriTypeSuggestions(iri = 'agg') {
+        return ResourceEditSteps.getObjectIriTypeSuggestionsElement().find('.object-iri-type-suggestion').contains(iri);
+    }
+
+    static selectObjectIriType(iri) {
+        ResourceEditSteps.getObjectIriTypeSuggestions(iri).click();
+    }
+
+    static getObjectLiteralTypeSelectorElement() {
+        return cy.get('.literalType');
+    }
+
+    static openObjectLiteralTypeSelector() {
+        ResourceEditSteps.getObjectLiteralTypeSelectorElement().click();
+    }
+
+    static getObjectLiteralTypeOption(literalType = 'string') {
+        return ResourceEditSteps.getObjectLiteralTypeSelectorElement().find('option');
+    }
+
+    static selectObjectLiteralType(literalType) {
+        ResourceEditSteps.getObjectLiteralTypeOption(literalType).click();
+    }
+
+    static getObjectLiteralManualInput() {
+        return cy.get('#languageText');
+    }
+
+    static getContextInput() {
+        return cy.get('.context-input');
+    }
+
+    static getContextSuggestionsElement() {
+        return cy.get('.context-suggestions');
+    }
+
+    static getContextSuggestion() {
+        return ResourceEditSteps.getContextSuggestionsElement().find('.context-suggestion');
+    }
+
+    static selectContextSuggestion(contextSuggestion = 'agg') {
+        ResourceEditSteps.getContextSuggestion().click();
+    }
+
+    static getViewTrigButton() {
+        return cy.get('.view-trig-btn');
+    }
+
+    static clickOnViewTrigButton() {
+        ResourceEditSteps.getViewTrigButton().click();
+    }
+
+    static getSaveButton() {
+        return cy.get('.save-btn');
+    }
+
+    static clickOnSaveButton() {
+        ResourceEditSteps.getSaveButton().click();
+    }
+}

package/steps/resource/resource-steps.js

@@ -0,0 +1,145 @@
+const VIEW_URL = '/resource';
+
+export class ResourceSteps {
+
+    static visit(parameters) {
+        cy.visit(`${VIEW_URL}${parameters ? ('?' + parameters) : ''}`);
+        // Wait for yasr to be initialized to ensure that the page is loaded.
+        cy.get('.yasr');
+    }
+
+    static verifyUrl() {
+        cy.url().should('include+', `${Cypress.config('baseUrl')}${VIEW_URL}`);
+    }
+
+    static getInferenceSelectElement() {
+        return cy.get('#inference-select');
+    }
+
+    static selectInference(inference = 'Explicit only') {
+        ResourceSteps.getInferenceSelectElement().select(inference);
+    }
+
+    static selectExplicitOnlyInference() {
+        ResourceSteps.selectInference();
+    }
+
+    static selectImplicitOnlyInference() {
+        ResourceSteps.selectInference('Implicit only');
+    }
+
+    static selectExplicitAndImplicitInference() {
+        ResourceSteps.selectInference('Explicit and Implicit');
+    }
+
+    static getSameAsButton() {
+        return cy.get('.same-as-btn');
+    }
+
+    static verifySameAsEnable() {
+        ResourceSteps.getSameAsButton().find('.icon-sameas-on').should('have.length', 1);
+    }
+
+    static verifySameAsDisable() {
+        ResourceSteps.getSameAsButton().find('.icon-sameas-off').should('have.length', 1);
+    }
+
+    static getShowBlankNodesButton() {
+        return cy.get('.show-blank-nodes-btn');
+    }
+
+    static clickOnShowBlankNodesButton() {
+        ResourceSteps.getShowBlankNodesButton().click();
+    }
+
+    static getDownloadAsDropdown() {
+        return cy.get('.dropdown-toggle');
+    }
+
+    static getVisualGraphButton() {
+        return cy.get('.visual-graph-btn');
+    }
+
+    static clickOnVisualGraphButton() {
+        ResourceSteps.getVisualGraphButton().click();
+    }
+
+    static getEditResourceLink() {
+        return cy.get('.edit-resource-link');
+    }
+
+    static clickOnEditResourceLink() {
+        ResourceSteps.getEditResourceLink().click();
+    }
+
+    static getSourceLink() {
+        return cy.get('.source-link');
+    }
+
+    static clickOnSourceLink() {
+        ResourceSteps.getSourceLink().click();
+    }
+
+    static getContextLink() {
+        return cy.get('.context-link');
+    }
+
+    static clickOnContextLink() {
+        ResourceSteps.getContextLink().click();
+    }
+
+    static getRoleSelectionElement() {
+        return cy.get('#selection');
+    }
+
+    static getRoleTab(role = 'subject') {
+        return ResourceSteps.getRoleSelectionElement().find('.nav-link').contains(role);
+    }
+
+    static selectRole(role) {
+        ResourceSteps.getRoleTab(role).click();
+    }
+
+    static selectSubjectRole() {
+        ResourceSteps.selectRole('subject');
+    }
+
+    static selectPredicateRole() {
+        ResourceSteps.selectRole('predicate');
+    }
+
+    static selectObjectRole() {
+        ResourceSteps.selectRole('object');
+    }
+
+    static selectContextRole() {
+        ResourceSteps.selectRole('context');
+    }
+
+    static selectAlRole() {
+        ResourceSteps.selectRole('all');
+    }
+
+    static verifyActiveRoleTab(activeRole = 'subject') {
+        ResourceSteps.getAllRoles().forEach((role) => {
+            const chainer = activeRole === role ? 'have.class' : 'not.have.class';
+            ResourceSteps.getRoleTab(role).should(chainer, 'active');
+        });
+    }
+
+    static getAllRoles() {
+        return ['subject', 'predicate', 'object', 'context', 'all'];
+    }
+
+    static getTargetLink() {
+        return cy.get('.target-link');
+    }
+
+    static getTripleResourceLink() {
+        return cy.get('.triple-resource-link');
+    }
+
+    static clickOnTripleResourceLink() {
+        ResourceSteps.getTripleResourceLink().click();
+    }
+}

package/steps/setup/jdbc-create-steps.js

@@ -0,0 +1,97 @@
+export class JdbcCreateSteps {
+
+    static visit(jdbcConfigurationName) {
+        cy.visit(`/jdbc/configuration/create${jdbcConfigurationName ? '?name=' + jdbcConfigurationName : ''}`);
+        cy.get('.ontotext-yasgui').should('be.visible');
+    }
+
+    static verifyUrl() {
+        cy.url().should('include', '/jdbc/configuration/create');
+    }
+
+    static getJDBCConfigNameField() {
+        return cy.get('.jdbc-configuration-name');
+    }
+
+    static typeTableName(tableName) {
+        // force is needed because ontotext-yasgui is created with focus on editor
+        // and if it appears in the middle of templateId typing the last part of template is written in ontotext-yasgui instead input element.
+        JdbcCreateSteps.getJDBCConfigNameField().type(tableName, {force: true});
+    }
+
+    static getTab(index = 0) {
+        return cy.get('.nav-item').eq(index);
+    }
+
+    static getActiveTab() {
+        return cy.get('.nav-item.active');
+    }
+
+    static openDataQueryTab() {
+        JdbcCreateSteps.getTab(0).click();
+    }
+
+    static openColumnTypesTab() {
+        JdbcCreateSteps.getTab(1).click();
+    }
+
+    static getSaveButton() {
+        return cy.get('.save-query-btn');
+    }
+
+    static clickOnSave() {
+        JdbcCreateSteps.getSaveButton().click();
+    }
+
+    static getCancelButton() {
+        return cy.get('.cancel-button');
+    }
+
+    static clickOnCancel() {
+        JdbcCreateSteps.getCancelButton().click();
+    }
+
+    static getPreviewButton() {
+        return cy.get('.preview-btn');
+    }
+
+    static clickOnPreviewButton() {
+        JdbcCreateSteps.getPreviewButton().click();
+    }
+
+    static getSuggestButton() {
+        return cy.get('.suggest-btn');
+    }
+
+    static clickOnSuggestButton() {
+        JdbcCreateSteps.getSuggestButton().click();
+    }
+
+    static getColumnSuggestionRows() {
+        return cy.get('.column-suggestion-row');
+    }
+
+    static getColumnSuggestion(columnSuggestionRowIndex = 0) {
+        return JdbcCreateSteps.getColumnSuggestionRows().eq(columnSuggestionRowIndex);
+    }
+
+    static getColumnDeleteButton(columnSuggestionRowIndex = 0) {
+        return JdbcCreateSteps.getColumnSuggestion(columnSuggestionRowIndex).find('.delete-column-btn');
+    }
+
+    static clickOnDeleteColumnButton(columnSuggestionRowIndex = 0) {
+        JdbcCreateSteps.getColumnDeleteButton(columnSuggestionRowIndex).click();
+    }
+
+    static getJdbcConfigurationNameIsRequired() {
+        return cy.get('.jdbc-configuration-name-required');
+    }
+
+    static getInvalidQueryMode() {
+        return cy.get('.invalid-query-mode');
+    }
+
+    static getInvalidQuery() {
+        return cy.get('.invalid-query');
+    }
+}

package/steps/setup/jdbc-steps.js

@@ -0,0 +1,42 @@
+export class JdbcSteps {
+
+    static visit() {
+        cy.visit('/jdbc');
+    }
+
+    static verifyUrl() {
+        cy.url().should('include', '/jdbc');
+    }
+
+    static getCreateNewJDBCConfigurationButton() {
+        return cy.get('.create-sql-table-configuration');
+    }
+
+    static clickOnCreateJdbcConfigurationButton() {
+        JdbcSteps.getCreateNewJDBCConfigurationButton().click();
+    }
+
+    static getJDBCConfigurations() {
+        return cy.get('#configurations-table');
+    }
+
+    static getJDBCConfigurationResults(configurationIndex = 0) {
+        return JdbcSteps.getJDBCConfigurations(configurationIndex).find('tr');
+    }
+
+    static getEditButton(configurationIndex = 0) {
+        return JdbcSteps.getJDBCConfigurationResults(configurationIndex).find('.edit-query-btn');
+    }
+
+    static clickOnEditButton(configurationIndex = 0) {
+        JdbcSteps.getEditButton(configurationIndex).click();
+    }
+
+    static getDeleteButton(configurationIndex = 0) {
+        return JdbcSteps.getJDBCConfigurationResults(configurationIndex).find('.delete-configuration-btn');
+    }
+
+    static clickOnDeleteButton(configurationIndex = 0) {
+        JdbcSteps.getDeleteButton(configurationIndex).click();
+    }
+}

package/steps/setup/sparql-create-update-steps.js

@@ -0,0 +1,55 @@
+export class SparqlCreateUpdateSteps {
+    static visit(templateId) {
+        cy.visit(`/sparql-template/create${templateId ? '?templateID=' + templateId : ''}`);
+        cy.get('.ontotext-yasgui').should('be.visible');
+    }
+
+    static verifyUrl() {
+        cy.url().should('include', '/sparql-template/create');
+    }
+
+    static getSaveButton() {
+        return cy.get('.save-query-btn');
+    }
+
+    static clickOnSaveButton() {
+        SparqlCreateUpdateSteps.getSaveButton().click();
+    }
+
+    static getCancelButton() {
+        return cy.get('.cancel-query-btn');
+    }
+
+    static clickOnCancelButton() {
+        SparqlCreateUpdateSteps.getCancelButton().click();
+    }
+
+    static typeTemplateId(templateId) {
+        SparqlCreateUpdateSteps.getTemplateIdField()
+            .should('exist')
+            .click()
+            // force is needed because ontotext-yasgui is created with focus on editor
+            // and if it appears in the middle of templateId typing the last part of template is written in ontotext-yasgui instead input element.
+            .type(templateId, {force: true});
+    }
+
+    static getTemplateIdField() {
+        return cy.get('.sparql-template-id');
+    }
+
+    static getRequiredErrorElement() {
+        return cy.get('.template-id-required');
+    }
+
+    static getInvalidErrorElement() {
+        return cy.get('.template-id-invalid');
+    }
+
+    static getInvalidQueryModeElement() {
+        return cy.get('.invalid-query-mode');
+    }
+
+    static getInvalidQueryElement() {
+        return cy.get('.invalid-query');
+    }
+}