graphdb-workbench-tests 3.1.0-WBM-9 → 3.1.0-plugins1

package/e2e-security/setup/users-and-access/create-user-permissions.spec.js

@@ -0,0 +1,184 @@
+import { MainMenuSteps } from "../../../steps/main-menu-steps";
+import {UserAndAccessSteps} from "../../../steps/setup/user-and-access-steps";
+import { LoginSteps } from "../../../steps/login-steps";
+import {ToasterSteps} from "../../../steps/toaster-steps";
+import {YasqeSteps} from "../../../steps/yasgui/yasqe-steps";
+import {YasrSteps} from "../../../steps/yasgui/yasr-steps";
+
+describe('User Management – Creation, Validation, Permissions & Deletion', () => {
+    let repositoryId;
+    const testPassword = 'P@ssw0rd123!';
+    const testUsername = `testuser-${Date.now()}`;
+
+    beforeEach(() => {
+        // Create and initialize a fresh repository for isolation
+        repositoryId = `repo-${Date.now()}`;
+        cy.createRepository({ id: repositoryId });
+        cy.presetRepository(repositoryId);
+        cy.initializeRepository(repositoryId);
+
+        // Navigate to Users & Access
+        UserAndAccessSteps.visit();
+    });
+
+    afterEach(() => {
+        // Clean up repository
+        cy.deleteRepository(repositoryId);
+    });
+
+    describe('Create a new user – validation', () => {
+        beforeEach(() => {
+            UserAndAccessSteps.clickCreateNewUserButton();
+        });
+
+        it('should show error when username is empty', () => {
+            UserAndAccessSteps.typePassword(testPassword);
+            UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+            UserAndAccessSteps.clickReadAccessRepo(repositoryId);
+            UserAndAccessSteps.clickWriteAccessRepo(repositoryId);
+            UserAndAccessSteps.confirmUserCreate();
+            UserAndAccessSteps.getUserFieldError('username').should('be.visible').and('contain.text', 'Enter username!');
+        });
+
+        it('should show error when passwords are empty', () => {
+            UserAndAccessSteps.typeUsername(testUsername);
+            UserAndAccessSteps.confirmUserCreate();
+            UserAndAccessSteps.getUserFieldError('password').should('be.visible').and('contain.text', 'Enter password!');
+            UserAndAccessSteps.getUserFieldError('confirmPassword').should('be.visible').and('contain.text', 'Confirm password!');
+        });
+
+        it('should show error when passwords do not match', () => {
+            UserAndAccessSteps.typeUsername(testUsername);
+            UserAndAccessSteps.typePassword(testPassword);
+            UserAndAccessSteps.typeConfirmPasswordField('Different123!');
+            UserAndAccessSteps.clickReadAccessRepo(repositoryId);
+            UserAndAccessSteps.clickWriteAccessRepo(repositoryId);
+            UserAndAccessSteps.confirmUserCreate();
+            UserAndAccessSteps.getUserFieldError('confirmPassword').should('be.visible').and('contain.text', 'Confirm password!');
+        });
+
+        it('should show error when username duplicates existing one', () => {
+            UserAndAccessSteps.typeUsername('user');
+            UserAndAccessSteps.typePassword(testPassword);
+            UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+            UserAndAccessSteps.clickReadAccessRepo(repositoryId);
+            UserAndAccessSteps.clickWriteAccessRepo(repositoryId);
+            UserAndAccessSteps.confirmUserCreate();
+
+            cy.url().should('include', '/users');
+            UserAndAccessSteps.clickCreateNewUserButton();
+            UserAndAccessSteps.typeUsername('user');
+            UserAndAccessSteps.typePassword(testPassword);
+            UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+            UserAndAccessSteps.clickWriteAccessRepo(repositoryId);
+            UserAndAccessSteps.confirmUserCreate();
+
+            ToasterSteps.verifyError('An account with the given username already exists.');
+            cy.deleteUser('user');
+        });
+
+        it('should show error when no repository read access is given', () => {
+            UserAndAccessSteps.typeUsername(testUsername);
+            UserAndAccessSteps.typePassword(testPassword);
+            UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+            UserAndAccessSteps.confirmUserCreate();
+            UserAndAccessSteps.getRepositoryRightsError().should('be.visible').and('contain.text', 'Users should have rights to at least one repository!');
+        });
+
+        it('should show error when custom role is too short', () => {
+            UserAndAccessSteps.typeUsername(testUsername);
+            UserAndAccessSteps.typePassword(testPassword);
+            UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+            UserAndAccessSteps.addTextToCustomRoleField('a');
+            UserAndAccessSteps.clickReadAccessRepo(repositoryId);
+            UserAndAccessSteps.clickWriteAccessRepo(repositoryId);
+            UserAndAccessSteps.getCustomRoleFieldError().should('be.visible').and('contain.text', 'Must be at least 2 symbols long');
+        });
+    });
+
+    describe('Create a new user – read/write access', () => {
+        const rwUsername = `rwuser-${Date.now()}`;
+
+        afterEach(() =>{
+            cy.loginAsAdmin();
+            cy.switchOffSecurity(true);
+            cy.deleteUser(rwUsername);
+        })
+
+        it('should create, login, and verify permissions', () => {
+            UserAndAccessSteps.clickCreateNewUserButton();
+            UserAndAccessSteps.typeUsername(rwUsername);
+            UserAndAccessSteps.typePassword(testPassword);
+            UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+            UserAndAccessSteps.clickReadAccessRepo(repositoryId);
+            UserAndAccessSteps.clickWriteAccessRepo(repositoryId);
+            UserAndAccessSteps.getWriteAccessForRepo(repositoryId).should('be.checked');
+            UserAndAccessSteps.confirmUserCreate();
+            UserAndAccessSteps.toggleSecurity();
+
+            LoginSteps.loginWithUser(rwUsername, testPassword);
+            // RepositorySteps.selectRepoFromDropdown(repositoryId);
+            MainMenuSteps.clickOnSparqlMenu();
+
+            YasqeSteps.clearEditor();
+            const prefix = 'PREFIX ex: <http://example.org/>\n';
+            const query = 'INSERT DATA {\n' +
+                'ex:greeting ex:text "Hello, world!" .\n' +
+                '}';
+            cy.pasteIntoCodeMirror('.CodeMirror', prefix + query);
+            YasqeSteps.executeQueryWithoutWaiteResult();
+            // Verify read access
+            YasrSteps.getResponseInfo()
+                .should('not.have.class', 'hidden')
+                .should('not.have.class', 'empty')
+                .should('be.visible')
+                .should('contain.text', 'Added 1 statements.');
+
+            LoginSteps.logout();
+        });
+    });
+
+    describe('Create a new user – read only access', () => {
+        const roUsername = `rouser-${Date.now()}`;
+
+        afterEach(() =>{
+            cy.loginAsAdmin();
+            cy.switchOffSecurity(true);
+            cy.deleteUser(roUsername);
+        })
+
+        it('should create, login, and verify read-only', () => {
+            UserAndAccessSteps.clickCreateNewUserButton();
+            UserAndAccessSteps.typeUsername(roUsername);
+            UserAndAccessSteps.typePassword(testPassword);
+            UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+            UserAndAccessSteps.clickReadAccessRepo(repositoryId);
+            UserAndAccessSteps.getReadAccessForRepo(repositoryId).should('be.checked');
+            UserAndAccessSteps.getWriteAccessForRepo(repositoryId).should('not.be.checked');
+            UserAndAccessSteps.confirmUserCreate();
+            UserAndAccessSteps.toggleSecurity();
+
+            LoginSteps.loginWithUser(roUsername, testPassword);
+            MainMenuSteps.clickOnSparqlMenu();
+
+            YasqeSteps.clearEditor();
+            const prefix = 'PREFIX ex: <http://example.org/>\n';
+            const query = 'INSERT DATA {\n' +
+                'ex:greeting ex:text "Hello, world!" .\n' +
+                '}';
+            cy.pasteIntoCodeMirror('.CodeMirror', prefix + query);
+            // Verify no write access
+            YasqeSteps.executeErrorQuery();
+
+            YasqeSteps.clearEditor();
+            const readQuery = 'select * where {\n' +
+                '?s ?p ?o .\n' +
+                '} limit 100';
+            cy.pasteIntoCodeMirror('.CodeMirror', readQuery);
+            // Verify read accessorQuery();
+            YasqeSteps.executeQuery();
+
+            LoginSteps.logout();
+        });
+    });
+});

package/e2e-security/setup/users-and-access/graphql-user.spec.js

@@ -0,0 +1,123 @@
+import {UserAndAccessSteps} from "../../../steps/setup/user-and-access-steps";
+import {LoginSteps} from "../../../steps/login-steps";
+import {GraphqlPlaygroundSteps} from "../../../steps/graphql/graphql-playground-steps";
+import {RepositorySteps} from "../../../steps/repository-steps";
+
+describe('GraphQL-only User – Playground Access & Mutation Restriction', () => {
+    let repositoryId;
+    const gqlUsername = `gqluser-${Date.now()}`;
+    const testPassword = 'P@ssw0rd123!';
+    const readQuery = `
+                query StarshipById {
+                  starship(ID: "https://swapi.co/resource/starship/9") {
+                    name
+                  }
+                }
+            `;
+    const mutation = `
+    mutation CreateHuman {
+      create_Human(
+        objects: [
+          {
+            id: "file:/test/onto/vocabulary/Human1",
+            rdfs_label: "New human with specific iri id"
+          }
+        ]
+      ) {
+        human { id }
+        affected_objects { ids }
+      }
+    }
+  `;
+
+    beforeEach(() => {
+        repositoryId = `repo-${Date.now()}`;
+        cy.createRepository({ id: repositoryId });
+        cy.presetRepository(repositoryId);
+        cy.importServerFile(repositoryId, 'swapi-dataset.ttl');
+        cy.uploadGraphqlSchema(repositoryId, 'graphql/soml/swapi-schema.yaml', 'swapi');
+    });
+
+    afterEach(() => {
+        cy.loginAsAdmin();
+        cy.switchOffSecurity(true);
+        cy.deleteUser(gqlUsername);
+        cy.deleteRepository(repositoryId);
+    });
+
+    it('should see only the assigned repo, block SPARQL, allow GraphQL read and forbid writes, and hide create-repo everywhere', () => {
+        UserAndAccessSteps.visit();
+        UserAndAccessSteps.clickCreateNewUserButton();
+        UserAndAccessSteps.typeUsername(gqlUsername);
+        UserAndAccessSteps.typePassword(testPassword);
+        UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+        UserAndAccessSteps.clickReadAccessRepo(repositoryId);
+        UserAndAccessSteps.clickGraphqlAccessRepo(repositoryId);
+        UserAndAccessSteps.confirmUserCreate();
+
+        UserAndAccessSteps.toggleSecurity();
+
+        // Log in as GraphQL-only user
+        LoginSteps.loginWithUser(gqlUsername, testPassword);
+        RepositorySteps.selectRepoFromDropdown(repositoryId);
+        // Verify only the assigned repository appears in endpoints
+        GraphqlPlaygroundSteps.visit();
+        GraphqlPlaygroundSteps.getView().should('be.visible');
+        GraphqlPlaygroundSteps.getQueryEditor().should('be.visible');
+        GraphqlPlaygroundSteps.getSelectedEndpoint().should('have.text', 'swapi');
+        // And I can execute a query on the countries endpoint
+        GraphqlPlaygroundSteps.setInEditor(readQuery);
+        // And I execute the query
+        GraphqlPlaygroundSteps.executeQuery();
+        // Then I get expected result
+        GraphqlPlaygroundSteps.getResponse().should('contain', '"name": "Death Star"');
+
+        // Execute the create_Human mutation → expect errors
+        GraphqlPlaygroundSteps.setInEditor(mutation);
+        GraphqlPlaygroundSteps.executeQuery();
+        GraphqlPlaygroundSteps.getResponse().should('contain.text', 'errors');
+        LoginSteps.logout();
+    });
+
+    it('should allow GraphQL mutation and hide SPARQL/Import/Create-repo menus', () => {
+        UserAndAccessSteps.visit();
+        UserAndAccessSteps.clickCreateNewUserButton();
+        UserAndAccessSteps.typeUsername(gqlUsername);
+        UserAndAccessSteps.typePassword(testPassword);
+        UserAndAccessSteps.typeConfirmPasswordField(testPassword);
+        UserAndAccessSteps.clickReadAccessRepo(repositoryId);
+        UserAndAccessSteps.clickWriteAccessRepo(repositoryId);
+        UserAndAccessSteps.clickGraphqlAccessRepo(repositoryId);
+        UserAndAccessSteps.confirmUserCreate();
+
+        UserAndAccessSteps.toggleSecurity();
+
+        // Log in as the new user
+        LoginSteps.loginWithUser(gqlUsername, testPassword);
+
+        // Select the repo in the navbar
+        RepositorySteps.selectRepoFromDropdown(repositoryId);
+
+        // Visit GraphQL Playground
+        GraphqlPlaygroundSteps.visit();
+        GraphqlPlaygroundSteps.getView().should('be.visible');
+        GraphqlPlaygroundSteps.getQueryEditor().should('be.visible');
+        GraphqlPlaygroundSteps.getSelectedEndpoint().should('have.text', 'swapi');
+
+        // Execute a read query to verify read access
+        GraphqlPlaygroundSteps.setInEditor(readQuery);
+        GraphqlPlaygroundSteps.executeQuery();
+        GraphqlPlaygroundSteps.getResponse()
+            .should('contain.text', '"name": "Death Star"');
+
+        // Execute the mutation and expect success
+        GraphqlPlaygroundSteps.setInEditor(mutation);
+        GraphqlPlaygroundSteps.executeQuery();
+        GraphqlPlaygroundSteps.getResponse()
+            .should('contain.text', 'data')
+            .and('contain.text', 'create_Human')
+            .and('contain.text', 'affected_objects');
+
+        LoginSteps.logout();
+    });
+});

package/e2e-security/setup/users-and-access/repo-admin-role.spec.js

@@ -0,0 +1,69 @@
+import {UserAndAccessSteps} from "../../../steps/setup/user-and-access-steps";
+import {LoginSteps} from "../../../steps/login-steps";
+import {YasqeSteps} from "../../../steps/yasgui/yasqe-steps";
+import {YasrSteps} from "../../../steps/yasgui/yasr-steps";
+import {MainMenuSteps} from "../../../steps/main-menu-steps";
+import HomeSteps from "../../../steps/home-steps";
+import {ActiveRepositoryWidgetSteps} from "../../../steps/widgets/active-repository-widget-steps";
+
+describe('Repository Admin – Permissions and Access Control', () => {
+    const repoAdminUsername = `repoadmin-${Date.now()}`;
+    const password = 'Admin123!';
+    let repositoryId;
+
+    beforeEach(() => {
+        repositoryId = `repo-${Date.now()}`;
+        cy.createRepository({ id: repositoryId });
+        cy.presetRepository(repositoryId);
+        cy.initializeRepository(repositoryId);
+
+        UserAndAccessSteps.visit();
+        UserAndAccessSteps.clickCreateNewUserButton();
+        UserAndAccessSteps.typeUsername(repoAdminUsername);
+        UserAndAccessSteps.typePassword(password);
+        UserAndAccessSteps.typeConfirmPasswordField(password);
+        UserAndAccessSteps.selectRoleRadioButton('#roleRepoAdmin');
+
+        UserAndAccessSteps.getReadAccessForRepo('*').should('be.checked').and('be.disabled');
+        UserAndAccessSteps.getWriteAccessForRepo('*').should('be.checked').and('be.disabled');
+
+        UserAndAccessSteps.confirmUserCreate();
+        UserAndAccessSteps.toggleSecurity();
+    });
+
+    afterEach(() => {
+        cy.loginAsAdmin();
+        cy.switchOffSecurity(true);
+        cy.deleteUser(repoAdminUsername);
+        cy.deleteRepository(repositoryId);
+    });
+
+    it('Repository admin has correct access and restrictions', () => {
+        LoginSteps.loginWithUser(repoAdminUsername, password);
+
+        // SPARQL – read access
+        MainMenuSteps.clickOnSparqlMenu();
+
+        YasqeSteps.getEditor().should('be.visible');
+        YasqeSteps.executeQuery();
+
+        // SPARQL – write access
+        YasqeSteps.clearEditor();
+        const prefix = 'PREFIX ex: <http://example.org/>\n';
+        const query = 'INSERT DATA {\n' +
+            'ex:greeting ex:text "Hello, world!" .\n' +
+            '}';
+        cy.pasteIntoCodeMirror('.CodeMirror', prefix + query);
+        YasqeSteps.executeQueryWithoutWaiteResult();
+        // Verify read access
+        YasrSteps.getResponseInfo()
+            .should('not.have.class', 'hidden')
+            .should('not.have.class', 'empty')
+            .should('be.visible')
+            .should('contain.text', 'Added 1 statements.');
+
+        // Create repo button on homepage should be visible
+        HomeSteps.visit();
+        ActiveRepositoryWidgetSteps.getImportLink().scrollIntoView().should('be.visible').and('not.be.disabled');
+    });
+});

package/e2e-security/setup/users-and-access/turn-on-security-and-password-change.spec.js

@@ -0,0 +1,87 @@
+import {MainMenuSteps} from "../../../steps/main-menu-steps";
+import {UserAndAccessSteps} from "../../../steps/setup/user-and-access-steps";
+import {LoginSteps} from "../../../steps/login-steps";
+import {ToasterSteps} from "../../../steps/toaster-steps";
+
+describe('Turn on Security', () => {
+
+    beforeEach(() => {
+        cy.loginAsAdmin();
+        cy.switchOnSecurity();
+    });
+
+    afterEach(() =>{
+        cy.loginAsAdmin();
+        cy.switchOffSecurity(true);
+    })
+
+  it('should enable security and show login screen with only Help accessible', () => {
+    // Navigate to Users & Access
+    UserAndAccessSteps.visit();
+    // Verify we are redirected to login page
+    cy.url().should('include', '/login');
+    MainMenuSteps.getMenuHelp().should('not.exist');
+    MainMenuSteps.getMenuExplore().should('not.exist');
+    MainMenuSteps.getMenuMonitoring().should('not.exist');
+    MainMenuSteps.getMenuSetup().should('not.exist');
+  });
+
+  it('should reject wrong credentials and accept admin/root', () => {
+    // Attempt login with invalid credentials
+    LoginSteps.visitLoginPage();
+    LoginSteps.loginWithUser('wrongUser', 'wrongPass');
+    // Expect error message
+    ToasterSteps.verifyError('Wrong credentials');
+
+    // Login with correct admin credentials
+    LoginSteps.visitLoginPage();
+    LoginSteps.loginWithUser('admin', 'root');
+    cy.url().should('include', '/');
+  });
+
+  it('should change admin password and enforce new credentials', () => {
+    // Navigate to Users & Access after login
+    UserAndAccessSteps.visit();
+    // Verify we are redirected to login page
+    cy.url().should('include', '/login');
+    LoginSteps.loginWithUser('admin', 'root');
+
+    // Open edit page for admin user
+    UserAndAccessSteps.openEditUserPage('admin');
+
+    // Change password to a new value
+    let newPassword = 'MyNewP@ssw0rd!';
+    UserAndAccessSteps.typePassword(newPassword);
+    UserAndAccessSteps.typeConfirmPasswordField(newPassword);
+    UserAndAccessSteps.confirmUserEdit();
+
+    // Log out
+    LoginSteps.logout();
+    cy.url().should('include', '/login');
+
+    // Attempt login with old password
+    LoginSteps.loginWithUser('admin', 'root');
+    ToasterSteps.verifyError('Wrong credentials');
+
+    // Attempt login with new password
+    LoginSteps.visitLoginPage();
+    LoginSteps.loginWithUser('admin', newPassword);
+    UserAndAccessSteps.visit();
+    // Open edit page for admin user
+    UserAndAccessSteps.openEditUserPage('admin');
+    newPassword = 'root';
+    UserAndAccessSteps.typePassword(newPassword);
+    UserAndAccessSteps.typeConfirmPasswordField(newPassword);
+    UserAndAccessSteps.confirmUserEdit();
+  });
+
+  it('should show toaster when after logging out', () => {
+      UserAndAccessSteps.visit();
+      LoginSteps.loginWithUser('admin', 'root');
+      // Log out
+      LoginSteps.logout();
+      cy.url().should('include', '/login');
+      // Verify toaster message
+      ToasterSteps.verifySuccess('Signed out');
+  })
+});

package/e2e-security/setup/users-and-access/user-and-access.spec.js

@@ -0,0 +1,87 @@
+import {RepositoriesStubs} from "../../../stubs/repositories/repositories-stubs";
+import {UserAndAccessSteps} from "../../../steps/setup/user-and-access-steps";
+import {LoginSteps} from "../../../steps/login-steps";
+import {ModalDialogSteps} from "../../../steps/modal-dialog-steps";
+import ImportSteps from "../../../steps/import/import-steps";
+import {MainMenuSteps} from "../../../steps/main-menu-steps";
+import {RepositorySelectorSteps} from "../../../steps/repository-selector-steps";
+import {ErrorSteps} from "../../../steps/error-steps";
+
+describe('User and Access', () => {
+
+    let repositoryId1;
+    let repositoryId2;
+    const graphqlUser = 'graphqlUser';
+
+    beforeEach(() => {
+        cy.viewport(1280, 1000);
+        RepositoriesStubs.spyGetRepositories();
+        repositoryId1 = 'user-access-repo1-' + Date.now();
+        repositoryId2 = 'user-access-repo2-' + Date.now();
+        cy.createRepository({id: repositoryId1});
+        cy.createRepository({id: repositoryId2});
+        cy.presetRepository(repositoryId1);
+        UserAndAccessSteps.visit();
+        // Users table should be visible
+        UserAndAccessSteps.getUsersTable().should('be.visible');
+    });
+
+    afterEach(() => {
+        cy.loginAsAdmin().then(() => {
+            cy.deleteRepository(repositoryId1, true);
+            cy.deleteRepository(repositoryId2, true);
+            cy.deleteUser(graphqlUser, true);
+            cy.switchOffFreeAccess(true);
+            cy.switchOffSecurity(true);
+        });
+
+    });
+
+    it('should restrict page when free access in on', () => {
+        // Given: There at least two repositories.
+        // When: I enable the security
+        UserAndAccessSteps.toggleSecurity();
+        LoginSteps.loginWithUser('admin', 'root');
+        // And: turn on Free Access
+        UserAndAccessSteps.getFreeAccessSwitchInput().should('not.be.checked');
+        UserAndAccessSteps.toggleFreeAccess();
+        // And: set graphql rights for the second repository when free access is ON
+        UserAndAccessSteps.clickFreeWriteAccessRepo(repositoryId2);
+        UserAndAccessSteps.clickFreeGraphqlAccessRepo(repositoryId2);
+        ModalDialogSteps.clickOKButton();
+
+        // When: I logout
+        LoginSteps.logout();
+        // And: repository with graphql rights is selected
+        RepositorySelectorSteps.selectRepository(repositoryId2);
+        // And: I click on the Import menu.
+        MainMenuSteps.clickOnMenuImport();
+
+        // Then: I should see the error message, because import view is available only for write access, repositoryId2 has only graphql rights.
+        ErrorSteps.verifyError('Some functionalities are not available because you do not have the required repository permissions.')
+    });
+
+    it('should restrict the repositories depending on whether free access is enabled and whether the user is logged in', () => {
+        // Given: There at least two repositories.
+        // When: I enable the security
+        UserAndAccessSteps.toggleSecurity();
+        LoginSteps.loginWithUser('admin', 'root');
+        // And: turn on Free Access
+        UserAndAccessSteps.toggleFreeAccess();
+        // And: set rights for the second repository when free access is ON
+        UserAndAccessSteps.clickFreeWriteAccessRepo(repositoryId2);
+        ModalDialogSteps.clickOKButton();
+
+        // When: I logout
+        LoginSteps.logout();
+        // Then: I should see only repositoryId2, as it is the only one configured for free access
+        RepositorySelectorSteps.getRepositorySelectorButton(repositoryId1).should('not.exist');
+        RepositorySelectorSteps.getRepositorySelectorButton(repositoryId2).should('exist');
+
+        // When: I log in again with a user who has access to all repositories
+        LoginSteps.loginWithUser('admin', 'root');
+        // Then: I should see both repositories in the repository selector, because the user has access to all repositories
+        RepositorySelectorSteps.getRepositorySelectorButton(repositoryId1).should('exist');
+        RepositorySelectorSteps.getRepositorySelectorButton(repositoryId2).should('exist');
+    });
+});

package/e2e-security/setup/users-and-access/users-and-access-initial-state.spec.js

@@ -0,0 +1,38 @@
+import {UserAndAccessSteps} from "../../../steps/setup/user-and-access-steps";
+import {MainMenuSteps} from "../../../steps/main-menu-steps";
+
+describe('Users and Access initial state', () => {
+    beforeEach(() => {
+        cy.intercept('GET', '**/rest/security/users').as('getUsers');
+    });
+
+    it('Should display the correct initial state when navigating via URL', () => {
+        // Given, I visit the Users and Access page via URL
+        UserAndAccessSteps.visit();
+        // Then,
+        validateInitialState();
+    });
+
+    it('Should display the correct initial state when navigating via the navigation menu', () => {
+        // Given, I visit the Users and Access page via the navigation menu
+        UserAndAccessSteps.visit();
+        MainMenuSteps.clickOnUsersAndAccess();
+        // Then,
+        validateInitialState();
+    });
+})
+
+function validateInitialState() {
+    cy.wait('@getUsers').then(({ response }) => {
+        const users = response.body;
+        expect(users).to.have.length(1);
+        expect(users[0].grantedAuthorities).to.have.length(1);
+    });
+
+    UserAndAccessSteps.getTableRow().should('have.length', 1);
+    UserAndAccessSteps.findUserInTable('admin')
+        .within(() => {
+            cy.get('.username').should('contain', 'admin');
+        });
+    UserAndAccessSteps.getToggleSecurityCheckbox().should('not.be.checked');
+}

package/fixtures/repositories/free-access.json

@@ -0,0 +1,13 @@
+{
+    "enabled": false,
+    "authorities": [
+        "READ_REPO_configurations@http://localhost:7202"
+    ],
+    "appSettings": {
+        "DEFAULT_INFERENCE": true,
+        "DEFAULT_VIS_GRAPH_SCHEMA": true,
+        "DEFAULT_SAMEAS": true,
+        "IGNORE_SHARED_QUERIES": false,
+        "EXECUTE_COUNT": true
+    }
+}

package/fixtures/ttyg/agent/get-agent-defaults-assistant-api.json

@@ -0,0 +1,44 @@
+{
+    "id": "id",
+    "name": "Quadro",
+    "model": "gpt-4o",
+    "api": "openai-assistants",
+    "contextSize": 128000,
+    "temperature": 0.7,
+    "topP": 1.0,
+    "seed": 0,
+    "repositoryId": "test-repository",
+    "instructions": {
+        "systemInstruction": "",
+        "userInstruction": "If you need to write a SPARQL query, use only the classes and properties provided in the schema and don't invent or guess any. Always try to return human-readable names or labels and not only the IRIs. If SPARQL fails to provide the necessary information you can try another tool too."
+    },
+    "assistantExtractionMethods": [
+        {
+            "method": "sparql_search",
+            "ontologyGraph": "http://example.com",
+            "sparqlQuery": "CONSTRUCT {?s ?p ?o} WHERE {GRAPH <http://example.org/ontology> {?s ?p ?o .}}",
+            "addMissingNamespaces": false
+        },
+        {
+            "method": "fts_search",
+            "maxNumberOfTriplesPerCall": 0
+        },
+        {
+            "method": "similarity_search",
+            "similarityIndex": "similarity-index",
+            "similarityIndexThreshold": 0.6,
+            "maxNumberOfTriplesPerCall": 0
+        },
+        {
+            "method": "retrieval_search",
+            "retrievalConnectorInstance": "retrieval-connector",
+            "queryTemplate": "{\"query\": \"string\"}",
+            "maxNumberOfTriplesPerCall": 0
+        }
+    ],
+    "additionalExtractionMethods": [
+        {
+            "method": "iri_discovery_search"
+        }
+    ]
+}

package/fixtures/ttyg/agent/get-agent-defaults.json

@@ -2,6 +2,8 @@
     "id": "id",
     "name": "Quadro",
     "model": "gpt-4o",
+    "api": "openai-completions",
+    "contextSize": 128000,
     "temperature": 0.7,
     "topP": 1.0,
     "seed": 0,