Added tests

ui/src/app/admin/hoc/RoleProvider.js

@@ -3,7 +3,7 @@ import { useRole } from '../hooks';
 
 export function RoleProvider({ id, children }) {
 
-    const [role, setRole] = React.useState();
+    const [role, setRole] = React.useState({id: 'foo'});
     const { get, response } = useRole(id);
 
     async function loadRole() {

ui/src/app/admin/hoc/RoleProvider.test.js

@@ -0,0 +1,35 @@
+import { render, screen } from "@testing-library/react";
+import { act } from 'react-dom/test-utils';
+import React from 'react';
+import {RoleProvider} from './RoleProvider';
+
+import {useRole} from '../hooks';
+
+jest.mock('../hooks');
+
+describe('RoleProvider component', () => {
+
+    beforeEach(() => {
+        useRole.mockImplementation(() => {
+            return {
+                get: jest.fn().mockResolvedValue({ id: 'foo' }),
+                response: {
+                    ok: false,
+                    status: 200
+                }
+            };
+        });
+    })
+
+    test('should provide the role context', async () => {
+        act(() => {
+            render(<RoleProvider id={'foo'}>
+            {(role) => <div>{role?.id}</div>}
+            </RoleProvider>);
+        });
+
+        expect(useRole).toHaveBeenCalled();
+        expect(screen.getByText('foo')).toBeInTheDocument();
+    });
+
+})

ui/src/app/admin/hoc/RolesProvider.test.js

@@ -0,0 +1,43 @@
+import { render, screen } from "@testing-library/react";
+import { act } from 'react-dom/test-utils';
+import React from 'react';
+import { RolesProvider } from './RolesProvider';
+
+import { useRoles } from '../hooks';
+import { useNotificationDispatcher } from "../../notifications/hoc/Notifications";
+
+jest.mock('../hooks');
+
+jest.mock('../../notifications/hoc/Notifications');
+
+describe('RolesProvider component', () => {
+
+    beforeEach(() => {
+
+        useNotificationDispatcher.mockImplementation(() => {
+            return {};
+        });
+
+        useRoles.mockImplementation(() => {
+            return {
+                get: jest.fn().mockResolvedValue([]),
+                response: {
+                    ok: false,
+                    status: 200
+                }
+            };
+        });
+    })
+
+    test('should provide the roles context', async () => {
+        act(() => {
+            render(<RolesProvider>
+                {(roles) => <div>{roles.length}</div>}
+            </RolesProvider>);
+        });
+
+        expect(useRoles).toHaveBeenCalled();
+        expect(screen.getByText('0')).toBeInTheDocument();
+    });
+
+})

ui/src/app/admin/hooks.js

@@ -12,9 +12,5 @@ export function useRole(id) {
 }
 
 export function useRoleUiSchema() {
-    return {
-        description: {
-            'ui:widget': 'textarea'
-        }
-    };
+    return {};
 }

ui/src/app/admin/hooks.test.js

@@ -0,0 +1,55 @@
+import {
+    useRoles,
+    useRole,
+} from './hooks';
+
+import useFetch from 'use-http';
+import API_BASE_PATH from '../App.constant';
+
+jest.mock('use-http');
+
+describe('api hooks', () => {
+
+    let mockPut;
+    let mockGet;
+
+    beforeEach(() => {
+
+        mockPut = jest.fn().mockResolvedValue({ response: { ok: true } });
+        mockGet = jest.fn().mockResolvedValue({ response: { ok: true } });
+
+        useFetch.mockImplementation(() => {
+            return {
+                request: {
+                    ok: true
+                },
+                put: mockPut,
+                get: mockGet,
+                error: null,
+                response: {
+                    status: 409
+                }
+            };
+        });
+    })
+
+    describe('useRoles', () => {
+        it('should call useFetch', () => {
+            const opts = {};
+            const roles = useRoles(opts);
+
+            expect(useFetch).toHaveBeenCalledWith(`${API_BASE_PATH}/admin/roles`, opts)
+        });
+    });
+
+    describe('useRole', () => {
+        it('should call useFetch', () => {
+            const opts = {
+                cachePolicy: 'no-cache'
+            };
+            const role = useRole('foo');
+
+            expect(useFetch).toHaveBeenCalledWith(`${API_BASE_PATH}/admin/roles/foo`, opts)
+        });
+    });
+});

ui/src/app/metadata/hooks/schema.js

@@ -1,5 +1,4 @@
 import React from 'react';
-import { useIsAdmin } from '../../core/user/UserContext';
 
 export const fillInRootProperties = (keys, ui) => keys.reduce((sch, key, idx) => {
     if (!sch.hasOwnProperty(key)) {
@@ -31,21 +30,7 @@ export function useUiSchema(definition, schema, current, locked = true) {
         }
     ), [mapped, step.locked, locked]);
 
-    const isAdmin = useIsAdmin();
-
-    const hideEnableFromNonAdmins = React.useMemo(() => {
-        if (!isAdmin) {
-            return {
-                ...isLocked,
-                serviceEnabled: {
-                    'ui:widget': 'hidden'
-                }
-            };
-        }
-        return isLocked;
-    }, [isAdmin, isLocked]);
-
-    return { uiSchema: hideEnableFromNonAdmins, step};
+    return { uiSchema: isLocked, step};
 }
 
 

ui/src/testing/uiSchema.js

@@ -11,7 +11,6 @@ const schema = {
                 "fields": [
                     "serviceProviderName",
                     "entityId",
-                    "serviceEnabled",
                     "organization"
                 ]
             },
@@ -208,7 +207,6 @@ const schema = {
     },
     "serviceProviderName": {},
     "entityId": {},
-    "serviceEnabled": {},
     "organization": {},
     "ui:disabled": false
 };