feat: add service methods to create users, groups and roles from the …

…provider

src/service/GroupService/index.spec.ts

@@ -1,14 +1,26 @@
+import fetchSpy, {
+  failureResponse,
+  successResponse
+} from '../../spec/fetchSpy';
 import Group, { KeycloakGroupRepresentation } from '../../model/Group';
 import GenericEntityService from '../GenericEntityService';
 import GroupService from '.';
 
 describe('GroupService', () => {
+  let fetchMock: jest.SpyInstance;
   let service: GroupService<Group<KeycloakGroupRepresentation>, KeycloakGroupRepresentation>;
 
   beforeEach(() => {
     service = new GroupService<Group<KeycloakGroupRepresentation>, KeycloakGroupRepresentation>();
   });
 
+  afterEach(() => {
+    if (fetchMock) {
+      fetchMock.mockReset();
+      fetchMock.mockRestore();
+    }
+  });
+
   it('is defined', () => {
     expect(GroupService).toBeDefined();
   });
@@ -21,4 +33,21 @@ describe('GroupService', () => {
     expect(service.getBasePath()).toEqual('/groups');
   });
 
+  it('sends all required parameters to create all groups from the provider (createAllFromProvider)', async () => {
+    fetchMock = fetchSpy(successResponse([]));
+
+    await service.createAllFromProvider();
+
+    expect(fetchMock).toHaveBeenCalledWith('/groups/createAllFromProvider', {
+      headers: {},
+      method: 'POST'
+    });
+  });
+
+  it('throws an error if the groups from the provider couldn\'t be created (createAllFromProvider)', async () => {
+    fetchMock = fetchSpy(failureResponse());
+
+    await expect(service.createAllFromProvider()).rejects.toThrow();
+  });
+
 });

src/service/GroupService/index.ts

@@ -1,4 +1,5 @@
 import Group, { KeycloakGroupRepresentation,ProviderGroupDetails } from '../../model/Group';
+import { getBearerTokenHeader } from '../../security/getBearerTokenHeader';
 import GenericEntityService, { GenericEntityServiceOpts } from '../GenericEntityService';
 
 export class GroupService<T extends Group<S>,
@@ -10,6 +11,23 @@ export class GroupService<T extends Group<S>,
     super(opts);
   }
 
+  async createAllFromProvider(fetchOpts?: RequestInit) {
+    try {
+      const response = await fetch(`${this.basePath}/createAllFromProvider`, {
+        method: 'POST',
+        headers: {
+          ...getBearerTokenHeader(this.keycloak)
+        },
+        ...fetchOpts
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP error status: ${response.status}`);
+      }
+    } catch (error) {
+      throw new Error(`Error while creating the groups from the group provider: ${error}`);
+    }
+  }
 }
 
 export default GroupService;

src/service/RoleService/index.spec.ts

@@ -1,14 +1,26 @@
+import fetchSpy, {
+  failureResponse,
+  successResponse
+} from '../../spec/fetchSpy';
 import Role from '../../model/Role';
 import GenericEntityService from '../GenericEntityService';
 import RoleService from '.';
 
 describe('RoleService', () => {
+  let fetchMock: jest.SpyInstance;
   let service: RoleService<Role>;
 
   beforeEach(() => {
     service = new RoleService();
   });
 
+  afterEach(() => {
+    if (fetchMock) {
+      fetchMock.mockReset();
+      fetchMock.mockRestore();
+    }
+  });
+
   it('is defined', () => {
     expect(RoleService).toBeDefined();
   });
@@ -21,4 +33,22 @@ describe('RoleService', () => {
     expect(service.getBasePath()).toEqual('/roles');
   });
 
+
+  it('sends all required parameters to create all roles from the provider (createAllFromProvider)', async () => {
+    fetchMock = fetchSpy(successResponse([]));
+
+    await service.createAllFromProvider();
+
+    expect(fetchMock).toHaveBeenCalledWith('/roles/createAllFromProvider', {
+      headers: {},
+      method: 'POST'
+    });
+  });
+
+  it('throws an error if the roles from the provider couldn\'t be created (createAllFromProvider)', async () => {
+    fetchMock = fetchSpy(failureResponse());
+
+    await expect(service.createAllFromProvider()).rejects.toThrow();
+  });
+
 });

src/service/RoleService/index.ts

@@ -1,4 +1,5 @@
 import Role, { KeycloakRoleRepresentation, ProviderRoleDetails } from '../../model/Role';
+import { getBearerTokenHeader } from '../../security/getBearerTokenHeader';
 import GenericEntityService, { GenericEntityServiceOpts } from '../GenericEntityService';
 
 export class RoleService<T extends Role<S>,
@@ -10,6 +11,23 @@ export class RoleService<T extends Role<S>,
     super(opts);
   }
 
+  async createAllFromProvider(fetchOpts?: RequestInit) {
+    try {
+      const response = await fetch(`${this.basePath}/createAllFromProvider`, {
+        method: 'POST',
+        headers: {
+          ...getBearerTokenHeader(this.keycloak)
+        },
+        ...fetchOpts
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP error status: ${response.status}`);
+      }
+    } catch (error) {
+      throw new Error(`Error while creating the roles from the role provider: ${error}`);
+    }
+  }
 }
 
 export default RoleService;

src/service/UserService/index.spec.ts

@@ -1,14 +1,26 @@
+import fetchSpy, {
+  failureResponse,
+  successResponse
+} from '../../spec/fetchSpy';
 import User from '../../model/User';
 import GenericEntityService from '../GenericEntityService';
 import UserService from '.';
 
 describe('UserService', () => {
+  let fetchMock: jest.SpyInstance;
   let service: UserService<User>;
 
   beforeEach(() => {
     service = new UserService();
   });
 
+  afterEach(() => {
+    if (fetchMock) {
+      fetchMock.mockReset();
+      fetchMock.mockRestore();
+    }
+  });
+
   it('is defined', () => {
     expect(UserService).toBeDefined();
   });
@@ -21,4 +33,21 @@ describe('UserService', () => {
     expect(service.getBasePath()).toEqual('/users');
   });
 
+  it('sends all required parameters to create all users from the provider (createAllFromProvider)', async () => {
+    fetchMock = fetchSpy(successResponse([]));
+
+    await service.createAllFromProvider();
+
+    expect(fetchMock).toHaveBeenCalledWith('/users/createAllFromProvider', {
+      headers: {},
+      method: 'POST'
+    });
+  });
+
+  it('throws an error if the users from the provider couldn\'t be created (createAllFromProvider)', async () => {
+    fetchMock = fetchSpy(failureResponse());
+
+    await expect(service.createAllFromProvider()).rejects.toThrow();
+  });
+
 });

src/service/UserService/index.ts

@@ -1,4 +1,5 @@
 import User, { KeycloakUserRepresentation, ProviderUserDetails } from '../../model/User';
+import { getBearerTokenHeader } from '../../security/getBearerTokenHeader';
 import GenericEntityService, { GenericEntityServiceOpts } from '../GenericEntityService';
 
 export class UserService<T extends User<S>,
@@ -10,6 +11,23 @@ export class UserService<T extends User<S>,
     super(opts);
   }
 
+  async createAllFromProvider(fetchOpts?: RequestInit) {
+    try {
+      const response = await fetch(`${this.basePath}/createAllFromProvider`, {
+        method: 'POST',
+        headers: {
+          ...getBearerTokenHeader(this.keycloak)
+        },
+        ...fetchOpts
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP error status: ${response.status}`);
+      }
+    } catch (error) {
+      throw new Error(`Error while creating the users from the user provider: ${error}`);
+    }
+  }
 }
 
 export default UserService;