eionet2-dashboard 3.2.0 → 3.2.2

package/tabs/src/data/reportingProvider.test.js

@@ -0,0 +1,103 @@
+jest.mock('./apiProvider', () => ({
+  apiGet: jest.fn(),
+  getConfiguration: jest.fn(),
+}));
+
+const { apiGet, getConfiguration } = require('./apiProvider');
+const { getFlows } = require('./reportingProvider');
+
+describe('getFlows', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('returns empty array when country is missing', async () => {
+    const result = await getFlows();
+
+    expect(result).toEqual([]);
+    expect(getConfiguration).not.toHaveBeenCalled();
+    expect(apiGet).not.toHaveBeenCalled();
+  });
+
+  test('maps paginated graph response and capitalizes status', async () => {
+    getConfiguration.mockResolvedValue({
+      SharepointSiteId: 'site-id',
+      ReportnetFlowsListId: 'flows-id',
+    });
+
+    apiGet
+      .mockResolvedValueOnce({
+        graphClientMessage: {
+          value: [
+            {
+              id: '1',
+              fields: {
+                Country: 'RO',
+                DataflowId: 'DF-1',
+                DataflowName: 'Flow one',
+                DataflowURL: 'https://flow-1',
+                ObligationName: 'Obl',
+                ObligationURL: 'https://obl',
+                LegalInstrumentName: 'Law',
+                LegalInstrumentURL: 'https://law',
+                DeadlineDate: '2025-10-01',
+                Status: 'IN_PROGRESS',
+                ReporterEmails: 'a@example.org,b@example.org',
+                FirstReleaseDate: '2025-01-01',
+                LastReleaseDate: '2025-01-02',
+                DeliveryStatus: 'ok',
+                IsEEACore: true,
+              },
+            },
+          ],
+          '@odata.nextLink': 'next-page',
+        },
+      })
+      .mockResolvedValueOnce({
+        graphClientMessage: {
+          value: [
+            {
+              id: '2',
+              fields: {
+                Country: 'RO',
+                DataflowId: 'DF-2',
+                DataflowName: 'Flow two',
+                Status: 'DONE',
+              },
+            },
+          ],
+        },
+      });
+
+    const result = await getFlows('RO');
+
+    expect(apiGet).toHaveBeenCalledTimes(2);
+    expect(apiGet.mock.calls[0][0]).toContain("$filter=fields/Country eq 'RO'");
+    expect(apiGet.mock.calls[1][0]).toBe('next-page');
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual(
+      expect.objectContaining({
+        id: '1',
+        country: 'RO',
+        status: 'In progress',
+        reporterEmails: ['a@example.org', 'b@example.org'],
+      }),
+    );
+    expect(result[0].deadlineDate).toBeInstanceOf(Date);
+    expect(result[0].firstReleaseDate).toBeInstanceOf(Date);
+    expect(result[0].lastReleaseDate).toBeInstanceOf(Date);
+    expect(result[1].status).toBe('Done');
+  });
+
+  test('returns empty array when api call fails', async () => {
+    getConfiguration.mockResolvedValue({
+      SharepointSiteId: 'site-id',
+      ReportnetFlowsListId: 'flows-id',
+    });
+    apiGet.mockRejectedValue(new Error('boom'));
+
+    const result = await getFlows('RO');
+
+    expect(result).toEqual([]);
+  });
+});

package/tabs/src/data/selfServiceProvider.test.js

@@ -0,0 +1,108 @@
+jest.mock('./apiProvider', () => ({
+  apiPatch: jest.fn(),
+  getConfiguration: jest.fn(),
+  logInfo: jest.fn(),
+}));
+
+const { apiPatch, getConfiguration, logInfo } = require('./apiProvider');
+const { saveData } = require('./selfServiceProvider');
+
+const baseUser = {
+  id: '77',
+  ADUserId: 'ad-1',
+  FirstName: 'Jane',
+  LastName: 'Doe',
+  Country: 'RO',
+  NFP: false,
+  Phone: '123',
+  Gender: 'Female',
+  JobTitle: 'Expert',
+  Department: 'Air',
+  Email: 'jane@example.org',
+};
+
+describe('saveData', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getConfiguration.mockResolvedValue({
+      SharepointSiteId: 'site-id',
+      UserListId: 'user-list-id',
+    });
+  });
+
+  test('saves AD user and SharePoint user for a normal user', async () => {
+    apiPatch.mockResolvedValue(undefined);
+    logInfo.mockResolvedValue(undefined);
+
+    const result = await saveData(baseUser);
+
+    expect(apiPatch).toHaveBeenNthCalledWith(1, '/users/ad-1', {
+      givenName: 'Jane',
+      surname: 'Doe',
+      displayName: 'Jane Doe (RO)',
+      department: 'Eionet',
+    });
+    expect(apiPatch).toHaveBeenNthCalledWith(
+      2,
+      '/sites/site-id/lists/user-list-id/items/77',
+      expect.objectContaining({
+        fields: expect.objectContaining({
+          Title: 'Jane Doe',
+          Phone: '123',
+          Gender: 'Female',
+        }),
+      }),
+    );
+    expect(logInfo).toHaveBeenCalledWith(
+      'User edited information',
+      '',
+      baseUser,
+      'Edit user',
+      'jane@example.org',
+    );
+    expect(result).toEqual({ Success: true });
+  });
+
+  test('uses NFP display name format', async () => {
+    apiPatch.mockResolvedValue(undefined);
+    logInfo.mockResolvedValue(undefined);
+
+    await saveData({ ...baseUser, NFP: true });
+
+    expect(apiPatch).toHaveBeenNthCalledWith(
+      1,
+      '/users/ad-1',
+      expect.objectContaining({
+        displayName: 'Jane Doe (NFP-RO)',
+      }),
+    );
+  });
+
+  test('returns wrapped error when AD update fails', async () => {
+    const error = new Error('ad failed');
+    apiPatch.mockRejectedValueOnce(error);
+
+    const result = await saveData(baseUser);
+
+    expect(result).toEqual({
+      Message: 'saveADUser',
+      Error: error,
+      Success: false,
+    });
+    expect(logInfo).not.toHaveBeenCalled();
+  });
+
+  test('returns wrapped error when SharePoint update fails', async () => {
+    const error = new Error('sp failed');
+    apiPatch.mockResolvedValueOnce(undefined).mockRejectedValueOnce(error);
+
+    const result = await saveData(baseUser);
+
+    expect(result).toEqual({
+      Message: 'saveSPUser',
+      Error: error,
+      Success: false,
+    });
+    expect(logInfo).not.toHaveBeenCalled();
+  });
+});

package/tabs/src/data/selfServiceSharepointProvider.test.js

@@ -0,0 +1,100 @@
+jest.mock('./apiProvider', () => ({
+  apiGet: jest.fn(),
+  getConfiguration: jest.fn(),
+}));
+
+const { apiGet, getConfiguration } = require('./apiProvider');
+const {
+  getOrganisationList,
+  getSPUserByMail,
+  getGenderList,
+} = require('./selfServiceSharepointProvider');
+
+describe('selfServiceSharepointProvider', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getConfiguration.mockResolvedValue({
+      SharepointSiteId: 'site-id',
+      OrganisationListId: 'org-list-id',
+      UserListId: 'user-list-id',
+    });
+  });
+
+  test('getOrganisationList maps organisations and applies country filter', async () => {
+    apiGet.mockResolvedValue({
+      graphClientMessage: {
+        value: [
+          {
+            id: 10,
+            fields: {
+              Title: 'Org 1',
+              Unspecified: false,
+            },
+          },
+        ],
+      },
+    });
+
+    const result = await getOrganisationList('RO');
+
+    expect(apiGet).toHaveBeenCalledWith(
+      expect.stringContaining("$filter=fields/Country eq 'RO' or fields/Unspecified eq 1"),
+    );
+    expect(result).toEqual([
+      {
+        header: 'Org 1',
+        content: 10,
+        unspecified: false,
+      },
+    ]);
+  });
+
+  test('getSPUserByMail returns first user and escapes apostrophe', async () => {
+    apiGet.mockResolvedValue({
+      graphClientMessage: {
+        value: [{ id: 1, fields: { Email: 'o@example.org' } }],
+      },
+    });
+
+    const result = await getSPUserByMail("o'hara@example.org");
+
+    expect(apiGet).toHaveBeenCalledWith(expect.stringContaining("o''hara%40example.org"));
+    expect(result).toEqual({ id: 1, fields: { Email: 'o@example.org' } });
+  });
+
+  test('getSPUserByMail returns undefined when no result exists', async () => {
+    apiGet.mockResolvedValue({
+      graphClientMessage: {
+        value: [],
+      },
+    });
+
+    const result = await getSPUserByMail('none@example.org');
+
+    expect(result).toBeUndefined();
+  });
+
+  test('getGenderList returns choices from Gender column', async () => {
+    apiGet.mockResolvedValue({
+      graphClientMessage: {
+        value: [{ name: 'Title' }, { name: 'Gender', choice: { choices: ['Female', 'Male'] } }],
+      },
+    });
+
+    const result = await getGenderList();
+
+    expect(result).toEqual(['Female', 'Male']);
+  });
+
+  test('getGenderList returns empty array when Gender column is missing', async () => {
+    apiGet.mockResolvedValue({
+      graphClientMessage: {
+        value: [{ name: 'Title' }],
+      },
+    });
+
+    const result = await getGenderList();
+
+    expect(result).toEqual([]);
+  });
+});