keycloak-api-manager 3.2.0 → 3.2.1

package/test/clientScopes.test.js

@@ -0,0 +1,256 @@
+const { expect } = require('chai');
+const { getAdminClient } = require('./config');
+
+describe('Client Scopes Handler', function () {
+  this.timeout(15000);
+  let client;
+  let testScopeId;
+  let testScopeName;
+
+  before(function () {
+    client = getAdminClient();
+    testScopeName = `test-scope-${Date.now()}`;
+  });
+
+  // ==================== CLIENT SCOPE CRUD ====================
+  describe('CRUD Operations', function () {
+    describe('create', function () {
+      it('should create a client scope with valid representation', async function () {
+        const scopeRep = {
+          name: testScopeName,
+          displayName: 'Test Scope Display',
+          protocol: 'openid-connect',
+          description: 'Test scope for integration',
+        };
+
+        const result = await client.clientScopes.create(
+          { realm: 'test-realm' },
+          scopeRep
+        );
+
+        expect(result).to.have.property('id');
+        testScopeId = result.id;
+      });
+    });
+
+    describe('find', function () {
+      it('should list all client scopes', async function () {
+        const scopes = await client.clientScopes.find({ realm: 'test-realm' });
+
+        expect(scopes).to.be.an('array');
+        expect(scopes.length).to.be.greaterThan(0);
+        expect(scopes.some((s) => s.name === testScopeName)).to.be.true;
+      });
+    });
+
+    describe('findOne', function () {
+      it('should find a specific scope by id', async function () {
+        const scope = await client.clientScopes.findOne({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        expect(scope).to.exist;
+        expect(scope.name).to.equal(testScopeName);
+      });
+    });
+
+    describe('findOneByName', function () {
+      it('should find a specific scope by name', async function () {
+        const scope = await client.clientScopes.findOneByName({
+          realm: 'test-realm',
+          name: testScopeName,
+        });
+
+        expect(scope).to.exist;
+        expect(scope.name).to.equal(testScopeName);
+      });
+    });
+
+    describe('update', function () {
+      it('should update scope attributes', async function () {
+        const updateRep = {
+          displayName: 'Updated Scope Display',
+          description: 'Updated description',
+        };
+
+        await client.clientScopes.update(
+          { realm: 'test-realm', id: testScopeId },
+          updateRep
+        );
+
+        const updated = await client.clientScopes.findOne({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        expect(updated.displayName).to.equal('Updated Scope Display');
+      });
+    });
+
+    describe('delByName', function () {
+      it('should delete scope by name', async function () {
+        // Create temp scope for deletion test
+        const tempScope = await client.clientScopes.create(
+          { realm: 'test-realm' },
+          { name: `temp-scope-${Date.now()}` }
+        );
+
+        await client.clientScopes.delByName({
+          realm: 'test-realm',
+          name: tempScope.name,
+        });
+
+        // Verify deleted
+      });
+    });
+  });
+
+  // ==================== DEFAULT CLIENT SCOPES ====================
+  describe('Default Client Scopes', function () {
+    describe('listDefaultClientScopes', function () {
+      it('should list default client scopes', async function () {
+        const scopes = await client.clientScopes.listDefaultClientScopes({
+          realm: 'test-realm',
+        });
+
+        expect(scopes).to.be.an('array');
+      });
+    });
+
+    describe('addDefaultClientScope', function () {
+      it('should add a client scope to defaults', async function () {
+        await client.clientScopes.addDefaultClientScope({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        const defaults = await client.clientScopes.listDefaultClientScopes({
+          realm: 'test-realm',
+        });
+
+        expect(defaults.some((s) => s.id === testScopeId)).to.be.true;
+      });
+    });
+
+    describe('delDefaultClientScope', function () {
+      it('should remove client scope from defaults', async function () {
+        await client.clientScopes.delDefaultClientScope({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        const defaults = await client.clientScopes.listDefaultClientScopes({
+          realm: 'test-realm',
+        });
+
+        expect(defaults.some((s) => s.id === testScopeId)).to.be.false;
+      });
+    });
+  });
+
+  // ==================== DEFAULT OPTIONAL CLIENT SCOPES ====================
+  describe('Default Optional Client Scopes', function () {
+    describe('listDefaultOptionalClientScopes', function () {
+      it('should list default optional client scopes', async function () {
+        const scopes = await client.clientScopes.listDefaultOptionalClientScopes({
+          realm: 'test-realm',
+        });
+
+        expect(scopes).to.be.an('array');
+      });
+    });
+
+    describe('addDefaultOptionalClientScope', function () {
+      it('should add scope to default optional', async function () {
+        await client.clientScopes.addDefaultOptionalClientScope({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        const optionals = await client.clientScopes.listDefaultOptionalClientScopes({
+          realm: 'test-realm',
+        });
+
+        expect(optionals.some((s) => s.id === testScopeId)).to.be.true;
+      });
+    });
+
+    describe('delDefaultOptionalClientScope', function () {
+      it('should remove scope from default optional', async function () {
+        await client.clientScopes.delDefaultOptionalClientScope({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        const optionals = await client.clientScopes.listDefaultOptionalClientScopes({
+          realm: 'test-realm',
+        });
+
+        expect(optionals.some((s) => s.id === testScopeId)).to.be.false;
+      });
+    });
+  });
+
+  // ==================== PROTOCOL MAPPERS ====================
+  describe('Protocol Mappers', function () {
+    describe('listProtocolMappers', function () {
+      it('should list protocol mappers for scope', async function () {
+        const mappers = await client.clientScopes.listProtocolMappers({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        expect(mappers).to.be.an('array');
+      });
+    });
+
+    describe('findProtocolMappersByProtocol', function () {
+      it('should find protocol mappers by protocol', async function () {
+        const mappers = await client.clientScopes.findProtocolMappersByProtocol({
+          realm: 'test-realm',
+          id: testScopeId,
+          protocol: 'openid-connect',
+        });
+
+        expect(mappers).to.be.an('array');
+      });
+    });
+  });
+
+  // ==================== SCOPE MAPPINGS ====================
+  describe('Scope Mappings', function () {
+    describe('listScopeMappings', function () {
+      it('should list all scope mappings', async function () {
+        const mappings = await client.clientScopes.listScopeMappings({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        expect(mappings).to.be.an('object');
+      });
+    });
+
+    describe('listRealmScopeMappings', function () {
+      it('should list realm scope mappings', async function () {
+        const mappings = await client.clientScopes.listRealmScopeMappings({
+          realm: 'test-realm',
+          id: testScopeId,
+        });
+
+        expect(mappings).to.be.an('array');
+      });
+    });
+  });
+
+  // ==================== CLEANUP ====================
+  after(async function () {
+    try {
+      if (testScopeId) {
+        await client.clientScopes.del({ realm: 'test-realm', id: testScopeId });
+      }
+    } catch (err) {
+      console.error('Cleanup error:', err.message);
+    }
+  });
+});

package/test/clients.test.js

@@ -0,0 +1,284 @@
+const { expect } = require('chai');
+const { getAdminClient } = require('./config');
+
+describe('Clients Handler', function () {
+  this.timeout(15000);
+  let client;
+  let testClientId;
+  let testRoleId;
+
+  before(async function () {
+    client = getAdminClient();
+
+    // Create a test role for client role mappings
+    const role = await client.roles.create(
+      { realm: 'test-realm' },
+      { name: 'clients-test-role' }
+    );
+    testRoleId = role.id;
+  });
+
+  // ==================== CLIENT CRUD ====================
+  describe('CRUD Operations', function () {
+    describe('create', function () {
+      it('should create a client with valid representation', async function () {
+        const clientRep = {
+          clientId: `test-client-${Date.now()}`,
+          name: 'Integration Test Client',
+          enabled: true,
+          publicClient: false,
+          standardFlowEnabled: true,
+          directAccessGrantsEnabled: true,
+        };
+
+        const result = await client.clients.create(
+          { realm: 'test-realm' },
+          clientRep
+        );
+
+        expect(result).to.have.property('id');
+        testClientId = result.id;
+      });
+
+      it('should fail creating duplicate clientId', async function () {
+        const clientId = `unique-client-${Date.now()}`;
+
+        await client.clients.create({ realm: 'test-realm' }, {
+          clientId,
+          enabled: true,
+        });
+
+        try {
+          await client.clients.create({ realm: 'test-realm' }, {
+            clientId,
+            enabled: true,
+          });
+          expect.fail('Should have thrown error for duplicate clientId');
+        } catch (err) {
+          expect(err).to.exist;
+        }
+      });
+    });
+
+    describe('find', function () {
+      it('should list all clients in realm', async function () {
+        const clients = await client.clients.find({ realm: 'test-realm' });
+
+        expect(clients).to.be.an('array');
+        expect(clients.length).to.be.greaterThan(0);
+      });
+
+      it('should search clients by clientId', async function () {
+        const foundClients = await client.clients.find({
+          realm: 'test-realm',
+          clientId: `test-client-${Date.now()}`,
+        });
+
+        expect(foundClients).to.be.an('array');
+      });
+    });
+
+    describe('findOne', function () {
+      it('should find a specific client by id', async function () {
+        const foundClient = await client.clients.findOne({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(foundClient).to.exist;
+        expect(foundClient.id).to.equal(testClientId);
+      });
+    });
+
+    describe('update', function () {
+      it('should update client attributes', async function () {
+        const updateRep = {
+          name: 'Updated Client Name',
+          description: 'Updated description',
+          publicClient: true,
+          attributes: {
+            'custom-attr': 'value',
+          },
+        };
+
+        await client.clients.update(
+          { realm: 'test-realm', id: testClientId },
+          updateRep
+        );
+
+        const updated = await client.clients.findOne({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(updated.name).to.equal('Updated Client Name');
+        expect(updated.description).to.equal('Updated description');
+      });
+    });
+  });
+
+  // ==================== CLIENT SECRETS ====================
+  describe('Secret Management', function () {
+    describe('generateNewClientSecret', function () {
+      it('should generate a new client secret', async function () {
+        const secret = await client.clients.generateNewClientSecret({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(secret).to.have.property('value');
+        expect(secret.value).to.be.a('string');
+        expect(secret.value.length).to.be.greaterThan(0);
+      });
+    });
+
+    describe('getClientSecret', function () {
+      it('should retrieve the current client secret', async function () {
+        const secret = await client.clients.getClientSecret({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(secret).to.have.property('value');
+        expect(secret.value).to.be.a('string');
+      });
+    });
+  });
+
+  // ==================== CLIENT CREDENTIALS ====================
+  describe('Credential Management', function () {
+    describe('listClientCredentials', function () {
+      it('should list all client credentials', async function () {
+        const creds = await client.clients.getCredentials({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(creds).to.be.an('array');
+      });
+    });
+  });
+
+  // ==================== CLIENT SESSIONS ====================
+  describe('Session Management', function () {
+    describe('getUserConsents', function () {
+      it('should retrieve user consents for client', async function () {
+        // This might be empty but should not error
+        try {
+          const consents = await client.clients.getUserConsents({
+            realm: 'test-realm',
+            id: testClientId,
+          });
+
+          expect(consents).to.be.an('array');
+        } catch (err) {
+          // Some versions might not support this
+        }
+      });
+    });
+
+    describe('getActiveSessions', function () {
+      it('should retrieve active sessions for client', async function () {
+        const sessions = await client.clients.getActiveSessions({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(sessions).to.be.an('array');
+      });
+    });
+
+    describe('getOfflineSessions', function () {
+      it('should retrieve offline sessions for client', async function () {
+        const sessions = await client.clients.getOfflineSessions({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(sessions).to.be.an('array');
+      });
+    });
+  });
+
+  // ==================== CLIENT ROLE MAPPINGS ====================
+  describe('Role Mappings', function () {
+    describe('listServiceAccountRoleMappings', function () {
+      it('should list service account role mappings', async function () {
+        try {
+          const mappings = await client.clients.listServiceAccountRoleMappings({
+            realm: 'test-realm',
+            id: testClientId,
+          });
+
+          expect(mappings).to.be.an('object');
+        } catch (err) {
+          // Service account might not be enabled
+        }
+      });
+    });
+  });
+
+  // ==================== PROTOCOL MAPPERS ====================
+  describe('Protocol Mappers', function () {
+    describe('listProtocolMappers', function () {
+      it('should list protocol mappers', async function () {
+        const mappers = await client.clients.listProtocolMappers({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(mappers).to.be.an('array');
+      });
+    });
+
+    describe('addProtocolMapper', function () {
+      it('should add a protocol mapper', async function () {
+        const mapper = {
+          name: 'test-mapper',
+          protocol: 'openid-connect',
+          protocolMapper: 'oidc-usermodel-attribute-mapper',
+          config: {
+            'user.attribute': 'email',
+            'claim.name': 'email',
+            'jsonType.label': 'String',
+          },
+        };
+
+        const result = await client.clients.addProtocolMapper(
+          { realm: 'test-realm', id: testClientId },
+          mapper
+        );
+
+        expect(result).to.exist;
+      });
+    });
+  });
+
+  // ==================== SCOPE MAPPINGS ====================
+  describe('Scope Mappings', function () {
+    describe('listScopeMappings', function () {
+      it('should list all scope mappings', async function () {
+        const mappings = await client.clients.listScopeMappings({
+          realm: 'test-realm',
+          id: testClientId,
+        });
+
+        expect(mappings).to.be.an('object');
+      });
+    });
+  });
+
+  // ==================== CLEANUP ====================
+  after(async function () {
+    try {
+      if (testClientId) {
+        await client.clients.del({ realm: 'test-realm', id: testClientId });
+      }
+      if (testRoleId) {
+        await client.roles.del({ realm: 'test-realm', id: testRoleId });
+      }
+    } catch (err) {
+      console.error('Cleanup error:', err.message);
+    }
+  });
+});

package/test/components.test.js

@@ -0,0 +1,122 @@
+const { expect } = require('chai');
+const { getAdminClient } = require('./config');
+
+describe('Components Handler', function () {
+  this.timeout(15000);
+  let client;
+  let testComponentId;
+
+  before(function () {
+    client = getAdminClient();
+  });
+
+  // ==================== COMPONENT CRUD ====================
+  describe('CRUD Operations', function () {
+    describe('create', function () {
+      it('should create a component with valid representation', async function () {
+        const componentRep = {
+          name: `test-component-${Date.now()}`,
+          providerId: 'org.keycloak.storage.UserStorageProvider',
+          providerType: 'org.keycloak.storage.UserStorageProvider',
+          config: {
+            priority: ['0'],
+          },
+        };
+
+        const result = await client.components.create(
+          { realm: 'test-realm' },
+          componentRep
+        );
+
+        expect(result).to.have.property('id');
+        testComponentId = result.id;
+      });
+    });
+
+    describe('find', function () {
+      it('should list all components', async function () {
+        const components = await client.components.find({ realm: 'test-realm' });
+
+        expect(components).to.be.an('array');
+      });
+
+      it('should filter components by type', async function () {
+        const components = await client.components.find({
+          realm: 'test-realm',
+          type: 'org.keycloak.storage.UserStorageProvider',
+        });
+
+        expect(components).to.be.an('array');
+      });
+
+      it('should filter components by provider id', async function () {
+        const components = await client.components.find({
+          realm: 'test-realm',
+          filter: 'org.keycloak.storage.UserStorageProvider',
+        });
+
+        expect(components).to.be.an('array');
+      });
+    });
+
+    describe('findOne', function () {
+      it('should find a specific component by id', async function () {
+        const component = await client.components.findOne({
+          realm: 'test-realm',
+          id: testComponentId,
+        });
+
+        expect(component).to.exist;
+        expect(component.id).to.equal(testComponentId);
+      });
+    });
+
+    describe('update', function () {
+      it('should update component attributes', async function () {
+        const updateRep = {
+          name: `updated-component-${Date.now()}`,
+          config: {
+            priority: ['1'],
+          },
+        };
+
+        await client.components.update(
+          { realm: 'test-realm', id: testComponentId },
+          updateRep
+        );
+
+        const updated = await client.components.findOne({
+          realm: 'test-realm',
+          id: testComponentId,
+        });
+
+        expect(updated.name).to.include('updated-component');
+      });
+    });
+  });
+
+  // ==================== SUBCOMPONENTS ====================
+  describe('Subcomponents', function () {
+    describe('listSubComponents', function () {
+      it('should list subcomponents', async function () {
+        const subcomponents = await client.components.listSubComponents({
+          realm: 'test-realm',
+          id: testComponentId,
+        });
+
+        expect(subcomponents).to.be.an('array');
+      });
+    });
+  });
+
+  // ==================== CLEANUP ====================
+  after(async function () {
+    try {
+      if (testComponentId) {
+        await client.components.del({ realm: 'test-realm', id: testComponentId });
+      }
+    } catch (err) {
+      console.error('Cleanup error:', err.message);
+    }
+  });
+});