graphdb-workbench-tests 2.5.1 → 2.6.0-RC1

package/steps/guides/star-wars-guide-steps.js

@@ -0,0 +1,188 @@
+import {GuideSteps} from "./guide-steps";
+import {GuideDialogSteps} from "./guide-dialog-steps";
+import {MainMenuSteps} from "../main-menu-steps";
+import {VisualGraphSteps} from "../visual-graph-steps";
+import {YasqeSteps} from "../yasgui/yasqe-steps";
+import {YasrSteps} from "../yasgui/yasr-steps";
+
+export class StarWarsGuideSteps {
+
+    static assertVisualGraphExploreStep1() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph explore — 1/6');
+    }
+
+    static assertVisualGraphExploreStep2() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph explore — 2/6');
+        MainMenuSteps.getMenuExplore().should('be.visible');
+    }
+
+    static assertVisualGraphExploreStep3() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph explore — 3/6');
+        MainMenuSteps.getSubmenuVisualGraph().should('be.visible');
+    }
+
+    static assertVisualGraphExploreSte4() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph explore — 4/6');
+        VisualGraphSteps.getStartNodeSelectorField().should('be.visible');
+    }
+
+    static assertVisualGraphExploreSte5() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph explore — 5/6');
+        VisualGraphSteps.getResultItemField().should('be.visible');
+    }
+
+    static assertVisualGraphExploreSte6() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph explore — 6/6');
+    }
+
+    static assertSte30() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph nodes');
+        VisualGraphSteps.getCircleOfNodeByNodeId('https://swapi.co/resource/human/1').should('be.visible');
+    }
+
+    static assertSte31() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph links');
+        VisualGraphSteps.getLineBetweenNodesById('https://swapi.co/resource/human/1>https://swapi.co/vocabulary/Character').should('be.visible');
+    }
+
+    static assertSte32() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph nodes');
+        VisualGraphSteps.getCircleOfNodeByNodeId('https://swapi.co/vocabulary/Mammal').should('be.visible');
+    }
+
+    static assertSte33() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph links');
+        VisualGraphSteps.getLineBetweenNodesById('https://swapi.co/resource/human/1>https://swapi.co/resource/vehicle/14').should('be.visible');
+    }
+
+    static assertSte34() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph nodes');
+        VisualGraphSteps.getCircleOfNodeByNodeId('https://swapi.co/resource/vehicle/30').should('be.visible');
+    }
+
+    static assertVisualGraphPropertiesStep1() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph properties — 1/6');
+        VisualGraphSteps.getCircleOfNodeByNodeId('https://swapi.co/resource/film/1').should('be.visible');
+    }
+
+    static assertVisualGraphPropertiesStep2() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph properties — 2/6');
+        VisualGraphSteps.getSidePanelContent().should('be.visible');
+    }
+
+    static assertVisualGraphPropertiesStep3() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph properties — 3/6');
+        GuideSteps.getElementByGuideSelector('graph-visualization-node-info-types').should('be.visible');
+    }
+
+    static assertVisualGraphPropertiesStep4() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph properties — 4/6');
+        GuideSteps.getElementByGuideSelector('graph-visualization-node-info-voc:releaseDate').should('be.visible');
+    }
+
+    static assertVisualGraphPropertiesStep5() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph properties — 5/6');
+        GuideSteps.getElementByGuideSelector('graph-visualization-node-info-voc:episodeId').should('be.visible');
+    }
+
+    static assertVisualGraphPropertiesStep6() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph properties — 6/6');
+        GuideSteps.getElementByGuideSelector('close-info-panel').should('be.visible');
+    }
+
+    static assertStep41() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph: expand node');
+        VisualGraphSteps.getCircleOfNodeByNodeId('https://swapi.co/resource/film/1').should('be.visible');
+    }
+
+    static assertStep42() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph nodes');
+        VisualGraphSteps.getCircleOfNodeByNodeId('https://swapi.co/resource/planet/1').should('be.visible');
+    }
+
+    static assertStep43() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Visual graph nodes');
+        VisualGraphSteps.getCircleOfNodeByNodeId('https://swapi.co/resource/droid/2').should('be.visible');
+    }
+
+    static assertExecuteSparqlQueryStep1() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 1/11');
+    }
+
+    static assertExecuteSparqlQueryStep2() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 2/11');
+        MainMenuSteps.getMenuSparql().should('be.visible');
+    }
+
+    static assertExecuteSparqlQueryStep3() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 3/11');
+    }
+
+    static assertExecuteSparqlQueryStep4() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 4/11');
+        YasqeSteps.getExecuteQueryButton().should('be.visible');
+    }
+
+    static assertExecuteSparqlQueryStep5() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 5/11');
+        YasrSteps.getResults().should('be.visible');
+    }
+
+    static assertExecuteSparqlQueryStep6() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 6/11');
+    }
+
+    static assertExecuteSparqlQueryStep7() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 7/11');
+        YasrSteps.getResults().should('be.visible');
+    }
+
+    static assertExecuteSparqlQueryStep8() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 8/11');
+        YasrSteps.getResults().should('be.visible');
+    }
+
+    static assertExecuteSparqlQueryStep9() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 9/11');
+    }
+
+    static assertExecuteSparqlQueryStep10() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 10/11');
+        YasrSteps.getResults().should('be.visible');
+    }
+
+    static assertExecuteSparqlQueryStep11() {
+        GuideSteps.assertPageNotInteractive();
+        GuideDialogSteps.assertDialogWithTitleIsVisible('Execute SPARQL query — 11/11');
+    }
+}

package/steps/import-steps.js

@@ -9,6 +9,10 @@ class ImportSteps {
         ImportSteps.visitImport('user', repository);
     }
 
+    static verifyUserImportUrl() {
+        cy.url().should('include', '/import#user');
+    }
+
     static visitServerImport(repository) {
         ImportSteps.visitImport('server', repository);
     }
@@ -98,6 +102,18 @@ class ImportSteps {
         return ImportSteps;
     }
 
+    static getImportRdfFileElement() {
+        return cy.get('#import-user');
+    }
+
+    static getImportStatusMessage() {
+        return cy.get('.import-status-message');
+    }
+
+    static getImportFileRow(fileName) {
+        return cy.contains('tr', fileName);
+    }
+
     static getSnippetTextarea() {
         return cy.get('#wb-import-textarea');
     }

package/steps/language-selector-steps.js

@@ -0,0 +1,22 @@
+export class LanguageSelectorSteps {
+    static getLanguageSelectorDropdown() {
+        return cy.get('#languageGroupDrop').should('be.visible');
+    }
+
+    static openLanguageSelectorDropdown() {
+        LanguageSelectorSteps.getLanguageSelectorDropdown().should('be.visible').click();
+    }
+
+    static changeLanguage(language) {
+        LanguageSelectorSteps.openLanguageSelectorDropdown();
+        cy.get('#lang-select-' + language).click();
+    }
+
+    static switchToFr() {
+        LanguageSelectorSteps.changeLanguage('fr');
+    }
+
+    static switchToEn() {
+        LanguageSelectorSteps.changeLanguage('en');
+    }
+}

package/steps/loader-steps.js

@@ -0,0 +1,10 @@
+export class LoaderSteps {
+
+    static getLoader() {
+        return cy.get('.ot-loader-new-content');
+    }
+
+    static verifyMessage(message) {
+        LoaderSteps.getLoader().contains(message);
+    }
+}

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,67 @@
+export class MainMenuSteps {
+
+    static getMainMenu() {
+        return cy.get('.main-menu');
+    }
+
+    static getMenuButton(menuName) {
+        return MainMenuSteps.getMainMenu().find('.menu-element').contains(menuName);
+    }
+
+    static getMenuImport() {
+        return MainMenuSteps.getMenuButton('Import');
+    }
+
+    static getMenuExplore() {
+        return MainMenuSteps.getMenuButton('Explore');
+    }
+
+    static getMenuSetup() {
+        return MainMenuSteps.getMenuButton('Setup');
+    }
+
+    static getMenuSparql() {
+        return MainMenuSteps.getMenuButton('SPARQL');
+    }
+
+    static getSubmenuAutocomplete() {
+        return MainMenuSteps.getSubMenuButton("Autocomplete");
+    }
+
+    static getSubmenuClassHierarchy() {
+        return MainMenuSteps.getSubMenuButton("Class hierarchy");
+    }
+
+    static getSubmenuVisualGraph() {
+        return MainMenuSteps.getSubMenuButton("Visual graph");
+    }
+
+    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/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/repository-steps.js

@@ -97,6 +97,10 @@ export class RepositorySteps {
         RepositorySteps.getRepositoryTypeButton(type).click();
     }
 
+    static getGDBRepositoryTypeButton() {
+       return RepositorySteps.getRepositoryTypeButton('gdb');
+    }
+
     static getRepositoryCreateForm() {
         return cy.get('#newRepoForm').should('be.visible');
     }

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,149 @@
+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 getAllRoleTab() {
+        return ResourceSteps.getRoleTab('all');
+    }
+
+    static selectAllRole() {
+        ResourceSteps.getAllRoleTab().click();
+    }
+
+    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();
+    }
+}