graphdb-workbench-tests 2.7.4 → 2.8.0-TR2

package/steps/repository-steps.js

@@ -55,6 +55,10 @@ export class RepositorySteps {
         return RepositorySteps.getRepositoryFromList(id).find('.icon-connection-off');
     }
 
+    static clickRepositoryConnectionOffBtn(id) {
+        RepositorySteps.getRepositoryConnectionOffBtn(id).click();
+    }
+
     static getRepositoryConnectionOnBtn(id) {
         return RepositorySteps.getRepositoryFromList(id).find('.icon-connection-on');
     }
@@ -121,6 +125,22 @@ export class RepositorySteps {
         return cy.get('.ot-edit-input');
     }
 
+    static getUsernameFieldEditRepo() {
+        return cy.get('.form-group #username');
+    }
+
+    static typeUsernameInEditRepo(username) {
+        this.getUsernameFieldEditRepo().type(username);
+    }
+
+    static clickSaveEditedRepo() {
+        cy.get('#addEditOntopRepository').click();
+    }
+
+    static typeURL(url) {
+        cy.get('#url').type(url);
+    }
+
     static editRepositoryId() {
         this.getRepositoryIdEditElement().click();
     }
@@ -242,4 +262,17 @@ export class RepositorySteps {
     static uploadRulesetFile(file) {
         cy.get('input[type=file]').eq(1).selectFile(file, {force: true});
     }
+
+    static getRepoIcon(type) {
+        return this.getLocalGraphDBTable().get(`.lead .icon-repo-${type}`);
+    }
+
+    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));
+    }
 }

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

@@ -0,0 +1,37 @@
+export class ChatPanelSteps {
+
+    static getChatPanel() {
+        return cy.get('.chat-panel');
+    }
+
+    static getChatDetailsElements() {
+        return ChatPanelSteps.getChatPanel().find('.chat-detail');
+    }
+
+    static getChatDetailElement(index = 0) {
+        return ChatPanelSteps.getChatDetailsElements().eq(index).scrollIntoView();
+    }
+
+    static getChatDetailActions(index = 0) {
+        return ChatPanelSteps.getChatDetailElement(index).find('.actions');
+    }
+
+    static getQuestionInputElement() {
+        return ChatPanelSteps.getChatPanel().find('.question-input');
+    }
+
+    static getAskButtonElement() {
+        return ChatPanelSteps.getChatPanel().find('.ask-button');
+    }
+
+    static getChatDetailQuestionElement(index = 0) {
+        return ChatPanelSteps.getChatDetailElement(index).find('.question');
+    }
+
+    static regenerateQuestion(index) {
+        ChatPanelSteps.getChatDetailActions(index).find('.regenerate-question-btn').scrollIntoView().click();
+    }
+    static copyAnswer(index) {
+        ChatPanelSteps.getChatDetailActions(index).find('.copy-answer-btn').click({force: true});
+    }
+}

package/steps/ttyg/ttyg-agent-settings-modal.steps.js

@@ -0,0 +1,363 @@
+import {ModalDialogSteps} from "../modal-dialog-steps";
+
+export class TtygAgentSettingsModalSteps extends ModalDialogSteps {
+
+    static getSaveAgentButton() {
+        return this.getDialog().find('.save-agent-settings-btn');
+    }
+
+    static saveAgent() {
+        this.getSaveAgentButton().click();
+    }
+
+    // =========================
+    // Form fields
+    // =========================
+
+    // Agent name
+
+    static getAgentNameFormGroup() {
+        return this.getDialog().find('.agent-name');
+    }
+
+    static getAgentNameField() {
+        return this.getAgentNameFormGroup().find('input');
+    }
+
+    static typeAgentName(name) {
+        this.getAgentNameField().type(name);
+    }
+
+    static clearAgentName() {
+        this.getAgentNameField().clear();
+        cy.realPress('Tab');
+    }
+
+    static getAgentNameError() {
+        return this.getAgentNameFormGroup().find('.alert-danger');
+    }
+
+    // Repository ID
+
+    static getRepositoryIdFromGroup() {
+        return this.getDialog().find('.repository-id');
+    }
+
+    static getRepositorySelect() {
+        return this.getRepositoryIdFromGroup().find('select');
+    }
+
+    static selectRepository(repositoryId) {
+        this.getRepositorySelect().select(repositoryId);
+    }
+
+    static getRepositoryIdError() {
+        return this.getRepositoryIdFromGroup().find('.alert-danger');
+    }
+
+    // Extraction methods
+
+    static getExtractionMethodError() {
+        return this.getDialog().find('.extraction-methods-group .extraction-method-required-error');
+    }
+
+    static getExtractionMethod(method) {
+        return this.getDialog().find(`#${method}_method_heading`);
+    }
+
+    static getExtractionMethodPanel(method) {
+        return this.getDialog().find(`#${method}_method_content`).find('.extraction-method-options');
+    }
+
+    // SPARQL extraction method
+
+    static enableSparqlExtractionMethod() {
+        this.getExtractionMethod('sparql_search').find('.extraction-method-toggle label').click();
+    }
+
+    static disableSparqlExtractionMethod() {
+        this.getExtractionMethod('sparql_search').find('.extraction-method-toggle label').click();
+    }
+
+    static toggleSparqlExtractionMethodPanel() {
+        this.getExtractionMethod('sparql_search').find('.panel-toggle-link').click();
+    }
+
+    static getSparqlExtractionMethodPanel() {
+        return this.getExtractionMethodPanel('sparql_search');
+    }
+
+    static getSparqlExtractionMethodError() {
+        return this.getSparqlExtractionMethodPanel().find('.sparql-method-option-required-error.alert-danger');
+    }
+
+    static selectSparqlMethodOntologyGraph() {
+        this.getSparqlExtractionMethodPanel().find('.ontology-graph-option input[type=radio]').click();
+    }
+
+    static getSparqlMethodOntologyGraphField() {
+        return this.getSparqlExtractionMethodPanel().find('#ontologyGraph');
+    }
+
+    static clearSparqlMethodOntologyGraphField() {
+        return this.getSparqlMethodOntologyGraphField().clear();
+    }
+
+    static typeSparqlMethodOntologyGraphField(value) {
+        return this.getSparqlMethodOntologyGraphField().type(value);
+    }
+
+    static selectSparqlMethodSparqlQuery() {
+        this.getSparqlExtractionMethodPanel().find('.sparql-query-option input[type=radio]').click();
+    }
+
+    static getSparqlMethodSparqlQueryField() {
+        return this.getSparqlExtractionMethodPanel().find('#sparqlQuery');
+    }
+
+    static clearSparqlMethodSparqlQueryField() {
+        return this.getSparqlMethodSparqlQueryField().clear();
+    }
+
+    static typeSparqlMethodSparqlQueryField(value) {
+        // disabled the parsing of special character sequences because the value is a SPARQL query and may contain special characters
+        return this.getSparqlMethodSparqlQueryField().type(value, {parseSpecialCharSequences: false});
+    }
+
+    // FTS extraction method
+
+    static enableFtsExtractionMethod() {
+        this.getExtractionMethod('fts_search').find('.extraction-method-toggle label').click();
+    }
+
+    static disableFtsExtractionMethod() {
+        this.getExtractionMethod('fts_search').find('.extraction-method-toggle label').click();
+    }
+
+    static toggleFTSExtractionMethodPanel() {
+        this.getExtractionMethod('fts_search').find('.panel-toggle-link').click();
+    }
+
+    static getMissingRepositoryIdErrorInFtsSearchPanel() {
+        return this.getExtractionMethodPanel('fts_search').find('.missing-repositoryid-error');
+    }
+
+    static getFtsDisabledHelp() {
+        return this.getExtractionMethodPanel('fts_search').find('.fts-disabled-message');
+    }
+
+    static getFtsSearchMaxTriplesFormGroup() {
+        return this.getExtractionMethodPanel('fts_search').find('.max-triples');
+    }
+
+    // Similarity search method
+
+    static enableSimilaritySearchMethodPanel() {
+        this.getExtractionMethod('similarity_search').find('.extraction-method-toggle label').click();
+    }
+
+    static toggleSimilaritySearchMethodPanel() {
+        this.getExtractionMethod('similarity_search').find('.panel-toggle-link').click();
+    }
+
+    static getSimilaritySearchIndexMissingHelp() {
+        return this.getExtractionMethodPanel('similarity_search').find('.no-similarity-index-message');
+    }
+
+    static getSimilarityIndexFormGroup() {
+        return this.getExtractionMethodPanel('similarity_search').find('.similarity-index');
+    }
+
+    static getSimilarityIndexField() {
+        return this.getSimilarityIndexFormGroup().find('select');
+    }
+
+    static selectSimilarityIndex(index) {
+        this.getSimilarityIndexField().select(index);
+    }
+
+    static getSimilarityIndexThresholdFormGroup() {
+        return this.getExtractionMethodPanel('similarity_search').find('.similarity-index-threshold');
+    }
+
+    static getSimilarityIndexThresholdField() {
+        return this.getSimilarityIndexThresholdFormGroup().find('#similarityIndexThreshold');
+    }
+
+    static setSimilarityIndexThreshold(value) {
+        this.getSimilarityIndexThresholdField().invoke('val', value).trigger('input');
+    }
+
+    static getSimilarityIndexMaxTriplesFormGroup() {
+        return this.getExtractionMethodPanel('similarity_search').find('.similarity-max-triples');
+    }
+
+    static getSimilarityIndexMaxTriplesField() {
+        return this.getSimilarityIndexMaxTriplesFormGroup().find('input');
+    }
+
+    static setSimilarityIndexMaxTriples(value) {
+        this.getSimilarityIndexMaxTriplesField().invoke('val', value).trigger('input');
+    }
+
+    // Retrieval method
+
+    static enableRetrievalMethodPanel() {
+        this.getExtractionMethod('retrieval_search').find('.extraction-method-toggle label').click();
+    }
+
+    static toggleRetrievalMethodPanel() {
+        this.getExtractionMethod('retrieval_search').find('.panel-toggle-link').click();
+    }
+
+    static getMissingRetrievalConnectorHelp() {
+        return this.getExtractionMethodPanel('retrieval_search').find('.no-retrieval-connector-message');
+    }
+
+    static getRetrievalConnectorFormGroup() {
+        return this.getExtractionMethodPanel('retrieval_search').find('.retrieval-connector');
+    }
+
+    static getRetrievalConnectorField() {
+        return this.getRetrievalConnectorFormGroup().find('select');
+    }
+
+    static selectRetrievalConnector(connector) {
+        this.getRetrievalConnectorField().select(connector);
+    }
+
+    static getQueryTemplateFormGroup() {
+        return this.getExtractionMethodPanel('retrieval_search').find('.query-template');
+    }
+
+    static getQueryTemplateField() {
+        return this.getQueryTemplateFormGroup().find('textarea');
+    }
+
+    static clearQueryTemplate() {
+        this.getQueryTemplateField().clear();
+    }
+
+    static typeQueryTemplate(value) {
+        // disabled the parsing of special character sequences because the value is a SPARQL query and may contain special characters
+        return this.getQueryTemplateField().type(value, {parseSpecialCharSequences: false});
+    }
+
+    static getRetrievalMaxTriplesFormGroup() {
+        return this.getExtractionMethodPanel('retrieval_search').find('.retrieval-connector-max-triples');
+    }
+
+    static getRetrievalMaxTriplesField() {
+        return this.getRetrievalMaxTriplesFormGroup().find('input');
+    }
+
+    static setRetrievalMaxTriples(value) {
+        this.getRetrievalMaxTriplesField().invoke('val', value).trigger('input');
+    }
+
+    // GPT model
+
+    static getGptModelFormGroup() {
+        return this.getDialog().find('.gpt-model');
+    }
+
+    static getGptModelField() {
+        return this.getGptModelFormGroup().find('input');
+    }
+
+    static clearGptModel() {
+        this.getGptModelField().clear();
+        cy.realPress('Tab');
+    }
+
+    static getGptModelError() {
+        return this.getGptModelFormGroup().find('.alert-danger');
+    }
+
+    static typeGptModel(value) {
+        return this.getGptModelField().type(value);
+    }
+
+    // temperature
+
+    static getTemperatureFormGroup() {
+        return this.getDialog().find('.temperature');
+    }
+
+    static getTemperatureField() {
+        return this.getTemperatureFormGroup().find('#temperature');
+    }
+
+    static setTemperature(value) {
+        this.getTemperatureField().invoke('val', value).trigger('input');
+    }
+
+    // Top P
+
+    static getTopPFormGroup() {
+        return this.getDialog().find('.top-p');
+    }
+
+    static getTopPField() {
+        return this.getTopPFormGroup().find('#topP');
+    }
+
+    static setTopP(value) {
+        this.getTopPField().invoke('val', value).trigger('input');
+    }
+
+    // Seed
+
+    static getSeedFormGroup() {
+        return this.getDialog().find('.seed');
+    }
+
+    static getSeedField() {
+        return this.getSeedFormGroup().find('#seed');
+    }
+
+    static clearSeed() {
+        this.getSeedField().clear();
+        cy.realPress('Tab');
+    }
+
+    static typeSeed(value) {
+        return this.getSeedField().type(value);
+    }
+
+    // System instructions
+
+    static getSystemInstructionsFormGroup() {
+        return this.getDialog().find('.system-instructions');
+    }
+
+    static getSystemInstructionsField() {
+        return this.getSystemInstructionsFormGroup().find('#systemInstruction');
+    }
+
+    static clearSystemInstructions() {
+        this.getSystemInstructionsField().clear();
+    }
+
+    static typeSystemInstructions(value) {
+        return this.getSystemInstructionsField().type(value);
+    }
+
+    // User instructions
+
+    static getUserInstructionsFormGroup() {
+        return this.getDialog().find('.user-instructions');
+    }
+
+    static getUserInstructionsField() {
+        return this.getUserInstructionsFormGroup().find('#userInstruction');
+    }
+
+    static clearUserInstructions() {
+        this.getUserInstructionsField().clear();
+    }
+
+    static typeUserInstructions(value) {
+        return this.getUserInstructionsField().type(value);
+    }
+}

package/steps/ttyg/ttyg-view-steps.js

@@ -0,0 +1,253 @@
+export class TTYGViewSteps {
+    static visit() {
+        cy.visit('/chatgpt');
+    }
+
+    static getTtygView() {
+        return cy.get('.ttyg-view');
+    }
+
+    static getTtygViewTitle() {
+        return cy.get('#ttyg-view-title');
+    }
+
+    static getNoAgentsView() {
+        return this.getTtygView().find('.no-agents-view-component');
+    }
+
+    static getTtygViewContent() {
+        return cy.get('.ttyg-view-content');
+    }
+
+    static getChatsSidebar() {
+        return cy.get('.left-sidebar');
+    }
+
+    static getChatListLoadingIndicator() {
+        return this.getChatsSidebar().find('[onto-loader-fancy]');
+    }
+
+    static getChatsPanel() {
+        return this.getChatsSidebar().find('.chat-list-panel');
+    }
+
+    static getChatListComponent() {
+        return this.getChatsPanel().find('.chat-list-component');
+    }
+
+    static getChatByDayGroups() {
+        return this.getChatListComponent().find('.chat-group');
+    }
+
+    static getChatGroup(index) {
+        return this.getChatByDayGroups().eq(index);
+    }
+
+    static getChatsFromGroup(index) {
+        return this.getChatGroup(index).find('.chat-item');
+    }
+
+    static getChatFromGroup(groupIndex, chatIndex) {
+        return this.getChatGroup(groupIndex).find('.chat-item').eq(chatIndex);
+    }
+
+    static selectChat(groupIndex, chatIndex) {
+        this.getChatFromGroup(groupIndex, chatIndex).click();
+    }
+
+    static editChatName(groupIndex, chatIndex) {
+        this.getChatFromGroup(groupIndex, chatIndex).dblclick();
+    }
+
+    static getChatNameInput(groupIndex, chatIndex) {
+        return this.getChatFromGroup(groupIndex, chatIndex).find('.inline-editable-text input');
+    }
+
+    static writeChatName(groupIndex, chatIndex, name) {
+        this.getChatNameInput(groupIndex, chatIndex).clear().type(name);
+    }
+
+    static saveChatName(groupIndex, chatIndex) {
+        this.getChatNameInput(groupIndex, chatIndex).type('{enter}');
+    }
+
+    static cancelChatNameSaving(groupIndex, chatIndex) {
+        this.getChatNameInput(groupIndex, chatIndex).type('{esc}');
+    }
+
+    static openChatActionMenu(groupIndex, chatIndex) {
+        this.getChatFromGroup(groupIndex, chatIndex).realHover().find('.open-chat-actions-btn').click();
+    }
+
+    static triggerEditChatActionMenu(groupIndex, chatIndex) {
+        this.openChatActionMenu(groupIndex, chatIndex);
+        this.getChatFromGroup(groupIndex, chatIndex).find('.chat-actions-menu .rename-chat-btn').click();
+    }
+
+    static triggerDeleteChatActionMenu(groupIndex, chatIndex) {
+        this.openChatActionMenu(groupIndex, chatIndex);
+        this.getChatFromGroup(groupIndex, chatIndex).find('.chat-actions-menu .delete-chat-btn').click();
+    }
+
+    static getToggleChatsSidebarButton() {
+        return this.getChatsSidebar().find('.toggle-chats-sidebar-btn');
+    }
+
+    static collapseChatsSidebar() {
+        return this.getToggleChatsSidebarButton().click();
+    }
+
+    static expandChatsSidebar() {
+        return this.getToggleChatsSidebarButton().click();
+    }
+
+    static getCreateChatButton() {
+        return this.getChatsSidebar().find('.create-chat-btn');
+    }
+
+    static getAgentsSidebar() {
+        return cy.get('.right-sidebar');
+    }
+
+    static getAgentsPanel() {
+        return this.getAgentsSidebar().find('.agent-list-panel');
+    }
+
+    static getAgentFilter() {
+        return this.getAgentsPanel().find('.agents-filter-dropdown');
+    }
+
+    static getSelectedAgentFilter() {
+        return this.getAgentFilter().find('.selected-filter');
+    }
+
+    static filterAgentsByRepository(repository) {
+        this.getAgentFilter().click();
+        this.getAgentFilter().find('.dropdown-menu').find(`[data-value="${repository}"]`).click();
+    }
+
+    static getAgents() {
+        return this.getAgentsPanel().find('.agent-item');
+    }
+
+    static getAgent(index) {
+        return this.getAgents().eq(index);
+    }
+
+    static getHelpButton() {
+        return this.getAgentsSidebar().find('.help-btn');
+    }
+
+    static getCreateFirstAgentButton() {
+        return this.getNoAgentsView().find('.create-agent-btn');
+    }
+
+    static getCreateAgentButton() {
+        return this.getAgentsSidebar().find('.create-agent-btn');
+    }
+
+    static createFirstAgent() {
+        this.getCreateFirstAgentButton().click();
+    }
+
+    static getToggleAgentsSidebarButton() {
+        return this.getAgentsSidebar().find('.toggle-agents-sidebar-btn');
+    }
+
+    static collapseAgentsSidebar() {
+        return this.getToggleAgentsSidebarButton().click();
+    }
+
+    static expandAgentsSidebar() {
+        return this.getToggleAgentsSidebarButton().click();
+    }
+
+    static getChatPanel() {
+        return this.getTtygView().find('.chat-content');
+    }
+
+    static getChatPanelToolbar() {
+        return this.getChatPanel().find('.toolbar');
+    }
+
+    static getEditCurrentAgentButton() {
+        return this.getChatPanelToolbar().find('.edit-current-agent-btn');
+    }
+
+    static editCurrentAgent() {
+        return this.getEditCurrentAgentButton().click();
+    }
+
+    static getExportCurrentChatButton() {
+        return this.getChatPanelToolbar().find('.export-current-chat-btn');
+    }
+
+    static exportCurrentChat() {
+        return this.getExportCurrentChatButton().click();
+    }
+
+    static getChat() {
+        return this.getChatPanel().find('.chat');
+    }
+
+    static openAgentActionMenu(index) {
+        this.getAgent(index).realHover().find('.open-agent-actions-btn').click();
+    }
+
+    static triggerDeleteAgentActionMenu(index) {
+        this.openAgentActionMenu(index);
+        this.getAgent(index).find('.agent-actions-menu .delete-agent-btn').click();
+    }
+
+    static getAgentDeletingLoader() {
+        return this.getAgentsPanel().find('.agent-list .deleting-agent-loader');
+    }
+
+    /**
+     * @param {*[]} data
+     */
+    static verifyAgentList(data) {
+        this.getAgents().should('have.length', data.length);
+        data.forEach((agent, index) => {
+            this.getAgent(index).within(() => {
+                cy.get('.agent-name').should('contain', agent.name);
+                cy.get('.related-repository').should('contain', agent.repositoryId);
+            });
+        });
+    }
+
+    static getAgentsMenu() {
+        return this.getTtygView().find('.agent-select-menu');
+    }
+
+    static getAgentsMenuToggleButton() {
+        return this.getAgentsMenu().find('.dropdown-toggle-btn');
+    }
+
+    static openAgentsMenu() {
+        this.getAgentsMenuToggleButton().click();
+    }
+
+    static getAgentsFromMenu() {
+        return this.getAgentsMenu().find('.agent-menu-item');
+    }
+
+    static getAgentFromMenu(index) {
+        return this.getAgentsFromMenu().eq(index);
+    }
+
+    static selectAgent(index) {
+        this.getAgentFromMenu(index).click();
+    }
+
+    static verifySelectAgentMenuItems(data) {
+        this.openAgentsMenu();
+        this.getAgentsFromMenu().should('have.length', data.length);
+        data.forEach((agent, index) => {
+            this.getAgentFromMenu(index).within(() => {
+                cy.get('.agent-name').should('contain', agent.name);
+                cy.get('.repository-id').should('contain', agent.repositoryId);
+            });
+        });
+    }
+}

package/steps/window-steps.js

@@ -0,0 +1,5 @@
+export class WindowSteps {
+    static getClipboardTextContent() {
+        return cy.window().its('navigator.clipboard').invoke('readText').then((text) => text);
+    }
+}