feat: apiml Spring-Modulith based module with ZAAS service

.github/workflows/integration-tests.yml

@@ -45,6 +45,8 @@ jobs:
                     APIML_SECURITY_AUTH_JWT_CUSTOMAUTHHEADER: customJwtHeader
                     APIML_SECURITY_AUTH_PASSTICKET_CUSTOMUSERHEADER: customUserHeader
                     APIML_SECURITY_AUTH_PASSTICKET_CUSTOMAUTHHEADER: customPassticketHeader
+                    APIML_SECURITY_X509_ENABLED: true
+                    APIML_SECURITY_X509_CERTIFICATESURL: https://apiml:10010/gateway/certificates
                     SERVER_MAX_HTTP_REQUEST_HEADER_SIZE: 16348
                     SERVER_WEBSOCKET_REQUESTBUFFERSIZE: 16348
                     APIML_GATEWAY_SERVICESTOLIMITREQUESTRATE: discoverableclient
@@ -65,13 +67,6 @@ jobs:
                 image: ghcr.io/balhar-jakub/discoverable-client:${{ github.run_id }}-${{ github.run_number }}
                 env:
                     APIML_SERVICE_DISCOVERYSERVICEURLS: https://apiml:10011/eureka
-            zaas-service:
-                image: ghcr.io/balhar-jakub/zaas-service:${{ github.run_id }}-${{ github.run_number }}
-                env:
-                    APIML_SECURITY_X509_ENABLED: true
-                    APIML_SECURITY_X509_ACCEPTFORWARDEDCERT: true
-                    APIML_SECURITY_X509_CERTIFICATESURL: https://apiml:10010/gateway/certificates
-                    APIML_SERVICE_DISCOVERYSERVICEURLS: https://apiml:10011/eureka
             mock-services:
                 image: ghcr.io/balhar-jakub/mock-services:${{ github.run_id }}-${{ github.run_number }}
                 env:
@@ -86,7 +81,7 @@ jobs:
             -   name: Run CI Tests
                 run: >
                     ENV_CONFIG=docker-modulith ./gradlew runStartUpCheck :integration-tests:runContainerModulithTests --info
-                    -Ddiscoverableclient.instances=1 -Denvironment.config=-docker-modulith
+                    -Ddiscoverableclient.instances=1 -Denvironment.config=-docker-modulith -Denvironment.modulith=true
                     -Partifactory_user=${{ secrets.ARTIFACTORY_USERNAME }} -Partifactory_password=${{ secrets.ARTIFACTORY_PASSWORD }}
             -   uses: ./.github/actions/dump-jacoco
                 if: always()

.gitignore

@@ -46,7 +46,7 @@ bin
 !api-catalog-package/src/main/resources/bin
 !discovery-package/src/main/resources/bin
 !caching-service-package/src/main/resources/bin
-!zaas-service-package/src/main/resources/bin
+!zaas-package/src/main/resources/bin
 !apiml-package/src/main/resources/bin
 var
 sdist

api-catalog-ui/frontend/src/actions/user-actions.jsx

@@ -56,6 +56,12 @@ function login(credentials) {
     };
 }
 
+export function forceLogout() {
+    return (dispatch) => {
+        dispatch({ type: userConstants.USERS_LOGOUT_SUCCESS });
+    };
+}
+
 export function query(user) {
     const success = { showUpdatePassSuccess: true };
     return { type: userConstants.USERS_LOGIN_SUCCESS, user, success };
@@ -77,6 +83,9 @@ function logout() {
         userService.logout().then(
             () => {
                 dispatch(success());
+                const channel = new BroadcastChannel('auth_channel');
+                channel.postMessage('logout');
+                channel.close();
             },
             (error) => {
                 dispatch(failure(error));
@@ -123,4 +132,5 @@ export const userActions = {
     validateInput,
     closeAlert,
     query,
+    forceLogout,
 };

api-catalog-ui/frontend/src/actions/user-actions.test.jsx

@@ -14,6 +14,15 @@ import { userService } from '../services';
 
 describe('>>> User actions tests', () => {
     const credentials = { username: 'user', password: 'password' };
+    const mockPostMessage = jest.fn();
+    const mockClose = jest.fn();
+
+    global.BroadcastChannel = class {
+        constructor() {
+            this.postMessage = mockPostMessage;
+            this.close = mockClose;
+        }
+    };
 
     it('should close alert', () => {
         const expectedAction = {
@@ -89,4 +98,41 @@ describe('>>> User actions tests', () => {
         expect(action.type).toBe('USERS_LOGIN_SUCCESS');
         expect(action.user).toBe('user');
     });
+
+    it('should dispatch USERS_LOGOUT_SUCCESS in forceLogout', () => {
+        const dispatch = jest.fn();
+
+        userActions.forceLogout()(dispatch);
+
+        expect(dispatch).toHaveBeenCalledWith({
+            type: userConstants.USERS_LOGOUT_SUCCESS
+        });
+    });
+
+    it('should dispatch logout success and broadcast logout on success', async () => {
+        const dispatch = jest.fn();
+
+        userService.logout = jest.fn().mockResolvedValue();
+
+        await userActions.logout()(dispatch);
+
+        expect(dispatch).toHaveBeenCalledWith({ type: userConstants.USERS_LOGOUT_REQUEST });
+        expect(dispatch).toHaveBeenCalledWith({ type: userConstants.USERS_LOGOUT_SUCCESS });
+
+        const channelCall = new BroadcastChannel('auth_channel');
+        expect(channelCall.postMessage).toHaveBeenCalledWith('logout');
+        expect(channelCall.close).toHaveBeenCalled();
+    });
+
+    it('should dispatch logout failure on error', async () => {
+        const dispatch = jest.fn();
+        const error = new Error('Logout failed');
+
+        userService.logout = jest.fn().mockRejectedValue(error);
+
+        await userActions.logout()(dispatch);
+
+        expect(dispatch).toHaveBeenCalledWith({ type: userConstants.USERS_LOGOUT_REQUEST });
+        expect(dispatch).toHaveBeenCalledWith({ type: userConstants.USERS_LOGOUT_FAILURE, error });
+    });
 });

api-catalog-ui/frontend/src/components/App/App.jsx

@@ -26,7 +26,7 @@ function App(props) {
     useEffect(() => {
         window.process = { ...window.process };
     }, []);
-    const { authentication, success } = props;
+    const { authentication, success, logout } = props;
     useEffect(() => {
         const checkAuth = () => {
             if (!authentication.user) {
@@ -48,8 +48,25 @@ function App(props) {
         // Run again whenever the tab gains focus
         window.addEventListener('focus', checkAuth);
 
+        const authChannel = new BroadcastChannel('auth_channel');
+        authChannel.onmessage = (event) => {
+            if (event.data === 'logout') {
+                logout();
+                navigate('/login');
+            }
+
+            if (event.data === 'login') {
+                userService.query().then((result) => {
+                    if (result.status === 200) {
+                        success(result.userId, false);
+                    }
+                });
+            }
+        };
+
         return () => { // Remove immediately to avoid loop
             window.removeEventListener('focus', checkAuth);
+            authChannel.close();
         };
     }, [authentication.user, success, navigate]);
 

api-catalog-ui/frontend/src/components/App/App.test.jsx

@@ -17,6 +17,8 @@ import { userService } from "../../services";
 
 const mockNavigate = jest.fn();
 const mockLocation = jest.fn();
+let broadcastInstance;
+
 jest.mock('react-router', () => {
     return {
         __esModule: true,
@@ -45,6 +47,22 @@ async function assertMethod(mockSuccess) {
 }
 
 describe('>>> App component tests', () => {
+
+    beforeAll(() => {
+        global.BroadcastChannel = class {
+            constructor() {
+                this.onmessage = null;
+                broadcastInstance = this;
+            }
+            postMessage(msg) {
+                if (this.onmessage) {
+                    this.onmessage({ data: msg });
+                }
+            }
+            close() {}
+        };
+    });
+
     it('should call render', () => {
         const history = { push: jest.fn() };
         const success = { push: jest.fn() };
@@ -108,4 +126,67 @@ describe('>>> App component tests', () => {
         userService.query.mockRejectedValue(new Error('Network error'));
         await assertMethod(mockSuccess);
     });
+
+    it('handles BroadcastChannel logout message', async () => {
+        const mockLogout = jest.fn();
+        const mockSuccess = jest.fn();
+
+        await act(async () => {
+            render(
+                <MemoryRouter initialEntries={['/dashboard']}>
+                    <App authentication={{ user: 'user' }} success={mockSuccess} logout={mockLogout} />
+                </MemoryRouter>
+            );
+        });
+
+        broadcastInstance.onmessage({ data: 'logout' });
+
+        expect(mockLogout).toHaveBeenCalled();
+        expect(mockNavigate).toHaveBeenCalledWith('/login');
+    });
+
+    it('handles BroadcastChannel login message and calls success if 200', async () => {
+        const mockLogout = jest.fn();
+        const mockSuccess = jest.fn();
+        userService.query.mockResolvedValue({ status: 200, userId: 'mockedUser' });
+
+        await act(async () => {
+            render(
+                <MemoryRouter initialEntries={['/dashboard']}>
+                    <App authentication={{ user: 'user' }} success={mockSuccess} logout={mockLogout} />
+                </MemoryRouter>
+            );
+        });
+
+        broadcastInstance.onmessage({ data: 'login' });
+
+        await waitFor(() => {
+            expect(userService.query).toHaveBeenCalled();
+            expect(mockSuccess).toHaveBeenCalledWith('mockedUser', false);
+        });
+    });
+
+    it('handles BroadcastChannel login message but does NOT call success if status !== 200', async () => {
+        const mockLogout = jest.fn();
+        const mockSuccess = jest.fn();
+        userService.query.mockResolvedValue({ status: 403 });
+
+        await act(async () => {
+            render(
+                <MemoryRouter initialEntries={['/dashboard']}>
+                    <App authentication={{ user: 'user' }} success={mockSuccess} logout={mockLogout} />
+                </MemoryRouter>
+            );
+        });
+
+        await act(async () => {
+            broadcastInstance.onmessage({ data: 'login' });
+        });
+
+        await waitFor(() => {
+            expect(userService.query).toHaveBeenCalled();
+            expect(mockSuccess).not.toHaveBeenCalled();
+        });
+    });
+
 });

api-catalog-ui/frontend/src/components/App/AppContainer.jsx

@@ -11,20 +11,14 @@ import App from './App';
 import { connect } from "react-redux";
 import { userActions } from '../../actions/user-actions';
 
-const withRouter = (App) =>{
-    return (props) =>{
-        return <App {...props}/>
-    }
-}
-
 const mapDispatchToProps = (dispatch) => ({
     success: (user) => dispatch(userActions.query(user)),
+    logout: () => dispatch(userActions.forceLogout()),
 });
 
-
 const mapStateToProps = (state) => ({
     authentication: state.authenticationReducer,
 });
 
 
-export default connect(mapStateToProps, mapDispatchToProps)(withRouter(App))
+export default connect(mapStateToProps, mapDispatchToProps)(App);

api-catalog-ui/frontend/src/components/App/AppContainer.test.jsx

@@ -33,6 +33,12 @@ describe('App Container', () => {
         );
     });
 
+    beforeAll(() => {
+        global.BroadcastChannel = class {
+            close() {}
+        };
+    });
+
     it('should render the container', () => {
         expect(container).not.toBeNull();
     });

api-catalog-ui/frontend/src/components/Dashboard/Dashboard.jsx

@@ -47,16 +47,20 @@ function Dashboard({
                    }) {
     const navigate = useNavigate();
     useEffect(() => {
-        clearService();
-        fetchTilesStart();
         if (!authentication.user) {
             navigate('/login');
+            return;
         }
+        clearService();
+        fetchTilesStart();
         return function cleanup () {
             clear();
         }
-    }, []);
+    }, [authentication.user, navigate]);
 
+        if (!authentication.user) {
+            return null;
+        }
         const hasSearchCriteria =
             typeof searchCriteria !== 'undefined' &&
             searchCriteria !== undefined &&
@@ -76,7 +80,6 @@ function Dashboard({
         if (hasTiles) {
             allServices = sortServices(tiles);
         }
-
         return (
             <div className="main-content dashboard-content">
                 <div id="dash-buttons">