eionet2-dashboard 3.2.1 → 3.2.2

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

@@ -0,0 +1,228 @@
+jest.mock('@microsoft/teams-js', () => ({
+  app: {
+    initialize: jest.fn().mockResolvedValue(undefined),
+  },
+  authentication: {
+    getAuthToken: jest.fn().mockResolvedValue('token-123'),
+  },
+}));
+
+const mockRequest = jest.fn();
+jest.mock('axios', () => ({
+  __esModule: true,
+  request: mockRequest,
+  default: {
+    request: mockRequest,
+  },
+}));
+
+describe('apiProvider', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+    process.env.REACT_APP_FUNC_ENDPOINT = 'https://func.example.org';
+    process.env.REACT_APP_SHAREPOINT_SITE_ID = 'site-id';
+    process.env.REACT_APP_CONFIGURATION_LIST_ID = 'cfg-list-id';
+  });
+
+  test('apiGet calls function endpoint with auth token and query params', async () => {
+    const axios = require('axios');
+    const { apiGet } = require('./apiProvider');
+
+    axios.default.request.mockResolvedValue({
+      data: { graphClientMessage: { value: [] } },
+    });
+
+    const response = await apiGet('/users', 'user', true);
+
+    expect(response).toEqual({ graphClientMessage: { value: [] } });
+    expect(axios.default.request).toHaveBeenCalledWith({
+      method: 'get',
+      url: 'https://func.example.org/api/graphData',
+      headers: {
+        authorization: 'Bearer token-123',
+      },
+      data: undefined,
+      params: {
+        path: '/users',
+        credentialType: 'user',
+      },
+    });
+  });
+
+  test('apiPatch includes eTag when provided', async () => {
+    const axios = require('axios');
+    const { apiPatch } = require('./apiProvider');
+
+    axios.default.request.mockResolvedValue({
+      data: { ok: true },
+    });
+
+    await apiPatch('/sites/abc', { key: 'value' }, 'etag-value');
+
+    expect(axios.default.request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: 'patch',
+        data: {
+          credentialType: 'app',
+          data: { key: 'value' },
+          path: '/sites/abc',
+          eTag: 'etag-value',
+        },
+      }),
+    );
+  });
+
+  test('getUserMail caches user email after first request', async () => {
+    const axios = require('axios');
+    const { getUserMail } = require('./apiProvider');
+
+    axios.default.request.mockResolvedValue({
+      data: {
+        graphClientMessage: {
+          mail: 'cached@example.org',
+        },
+      },
+    });
+
+    const first = await getUserMail();
+    const second = await getUserMail();
+
+    expect(first).toBe('cached@example.org');
+    expect(second).toBe('cached@example.org');
+    expect(axios.default.request).toHaveBeenCalledTimes(1);
+  });
+
+  test('getConfiguration caches mapped SharePoint config', async () => {
+    const axios = require('axios');
+    const { getConfiguration } = require('./apiProvider');
+
+    axios.default.request.mockResolvedValue({
+      data: {
+        graphClientMessage: {
+          value: [
+            { fields: { Title: 'LoggingListId', Value: 'log-list-id' } },
+            { fields: { Title: 'FromEmailAddress', Value: 'from@example.org' } },
+          ],
+        },
+      },
+    });
+
+    const first = await getConfiguration();
+    const second = await getConfiguration();
+
+    expect(first).toEqual({
+      LoggingListId: 'log-list-id',
+      FromEmailAddress: 'from@example.org',
+      SharepointSiteId: 'site-id',
+    });
+    expect(second).toEqual(first);
+    expect(axios.default.request).toHaveBeenCalledTimes(1);
+  });
+
+  test('apiGet rethrows and skips logging when requiresLogin is true', async () => {
+    const axios = require('axios');
+    const { apiGet } = require('./apiProvider');
+    const err = { requiresLogin: true };
+
+    axios.default.request.mockRejectedValue(err);
+
+    await expect(apiGet('/users')).rejects.toBe(err);
+    expect(axios.default.request).toHaveBeenCalledTimes(1);
+  });
+
+  test('apiPost rethrows and skips logging when skipLog is true', async () => {
+    const axios = require('axios');
+    const { apiPost } = require('./apiProvider');
+    const err = new Error('post failed');
+
+    axios.default.request.mockRejectedValue(err);
+
+    await expect(apiPost('/users', { a: 1 }, 'app', true)).rejects.toBe(err);
+    expect(axios.default.request).toHaveBeenCalledTimes(1);
+  });
+
+  test('logError uses missing-index message and writes to logging list when config exists', async () => {
+    const axios = require('axios');
+    const { getConfiguration, logError } = require('./apiProvider');
+
+    axios.default.request
+      .mockResolvedValueOnce({
+        data: {
+          graphClientMessage: {
+            value: [{ fields: { Title: 'LoggingListId', Value: 'log-list-id' } }],
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          graphClientMessage: {
+            mail: 'user@example.org',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: { ok: true },
+      });
+
+    await getConfiguration();
+
+    await logError(
+      {
+        message: 'fallback',
+        response: {
+          data: {
+            message: 'HonorNonIndexedQueriesWarningMayFailRandomly details',
+            error: { body: 'ignored body' },
+          },
+        },
+      },
+      '/path',
+      { key: 'value' },
+    );
+
+    const lastCall = axios.default.request.mock.calls.at(-1)[0];
+    expect(lastCall.method).toBe('post');
+    expect(lastCall.data.path).toBe('/sites/site-id/lists/log-list-id/items');
+    expect(lastCall.data.data.fields.Title).toBe(
+      'HonorNonIndexedQueriesWarningMayFailRandomly details',
+    );
+  });
+
+  test('logInfo can omit user email when skipEmail is true', async () => {
+    const axios = require('axios');
+    const { logInfo } = require('./apiProvider');
+
+    axios.default.request
+      .mockResolvedValueOnce({
+        data: {
+          graphClientMessage: {
+            value: [{ fields: { Title: 'LoggingListId', Value: 'log-list-id' } }],
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          graphClientMessage: {
+            mail: 'user@example.org',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: { ok: true },
+      });
+
+    await logInfo('Info title', '/path', { key: 1 }, 'ACT', 'affected@example.org', true);
+
+    const lastCall = axios.default.request.mock.calls.at(-1)[0];
+    expect(lastCall.data.path).toBe('/sites/site-id/lists/log-list-id/items');
+    expect(lastCall.data.data.fields).toMatchObject({
+      Title: 'Info title',
+      ApiPath: '/path',
+      Action: 'ACT',
+      AffectedUser: 'affected@example.org',
+      UserMail: '',
+      Logtype: 'Info',
+    });
+  });
+});

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

@@ -0,0 +1,76 @@
+jest.mock('ics', () => ({
+  createEvent: jest.fn(),
+}));
+
+const { createEvent } = require('ics');
+const { createIcs } = require('./icsHelper');
+
+describe('createIcs', () => {
+  let originalBlob;
+
+  beforeAll(() => {
+    originalBlob = global.Blob;
+    if (typeof global.Blob === 'undefined') {
+      global.Blob = function Blob(parts, options) {
+        this.parts = parts;
+        this.type = options?.type || '';
+      };
+    }
+  });
+
+  afterAll(() => {
+    global.Blob = originalBlob;
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    createEvent.mockImplementation((event, callback) => {
+      callback(null, 'BEGIN:VCALENDAR');
+    });
+  });
+
+  test('creates an event with hour/minute duration and meeting link', () => {
+    const meeting = {
+      MeetingStart: '2025-01-01T10:00:00.000Z',
+      MeetingEnd: '2025-01-01T11:30:00.000Z',
+      Title: 'Coordination meeting',
+      MeetingLink: 'https://example.org/meeting',
+    };
+    const participant = {
+      ParticipantName: 'Jane Doe',
+      Email: 'jane@example.org',
+    };
+
+    const blob = createIcs(meeting, 'organizer@example.org', 'Line 1\nLine 2', participant);
+
+    expect(createEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: 'REQUEST',
+        title: 'Coordination meeting',
+        duration: { hours: 1, minutes: 30 },
+        htmlContent: 'Line 1Line 2',
+        url: 'https://example.org/meeting',
+      }),
+      expect.any(Function),
+    );
+    expect(blob).toBeInstanceOf(Blob);
+  });
+
+  test('creates an event with minutes-only duration and no url when link is missing', () => {
+    const meeting = {
+      MeetingStart: '2025-01-01T10:00:00.000Z',
+      MeetingEnd: '2025-01-01T10:45:00.000Z',
+      Title: 'Short meeting',
+    };
+    const participant = {
+      ParticipantName: 'John Doe',
+      Email: 'john@example.org',
+    };
+
+    createIcs(meeting, 'organizer@example.org', 'Description', participant);
+
+    const eventArg = createEvent.mock.calls[0][0];
+    expect(eventArg.duration).toEqual({ minutes: 45 });
+    expect(eventArg.url).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,351 @@
+jest.mock('./apiProvider', () => ({
+  apiGet: jest.fn(),
+  apiPost: jest.fn(),
+  getConfiguration: jest.fn(),
+  logInfo: jest.fn(),
+  logError: jest.fn(),
+}));
+
+jest.mock('./sharepointProvider', () => ({
+  getSPUserByMail: jest.fn(),
+  getMeetingManager: jest.fn(),
+  getOrganisationList: jest.fn(),
+}));
+
+const { apiGet, apiPost, getConfiguration, logInfo, logError } = require('./apiProvider');
+const { getSPUserByMail, getMeetingManager, getOrganisationList } = require('./sharepointProvider');
+const { getUserByMail, sendEmail, getMeetingJoinInfo, getUser } = require('./provider');
+
+describe('provider', () => {
+  const loadProvider = () => {
+    let loaded;
+    jest.isolateModules(() => {
+      loaded = require('./provider');
+    });
+    return loaded;
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('getUserByMail returns AD and SharePoint data and escapes apostrophe in email', async () => {
+    apiGet.mockResolvedValue({
+      graphClientMessage: {
+        value: [{ id: 'ad-user' }],
+      },
+    });
+    getSPUserByMail.mockResolvedValue({ id: 'sp-user' });
+
+    const result = await getUserByMail("o'hara@example.org");
+
+    expect(apiGet).toHaveBeenCalledWith("/users/?$filter=mail eq 'o''hara%40example.org'");
+    expect(getSPUserByMail).toHaveBeenCalledWith("o'hara@example.org");
+    expect(result).toEqual({
+      ADUser: { id: 'ad-user' },
+      SharepointUser: { id: 'sp-user' },
+      IsValid: true,
+    });
+  });
+
+  test('getUserByMail returns invalid when AD user list is empty', async () => {
+    apiGet.mockResolvedValue({
+      graphClientMessage: {
+        value: [],
+      },
+    });
+    getSPUserByMail.mockResolvedValue(undefined);
+
+    const result = await getUserByMail('missing@example.org');
+
+    expect(result).toEqual({
+      ADUser: undefined,
+      SharepointUser: undefined,
+      IsValid: false,
+    });
+  });
+
+  test('getMeetingJoinInfo returns first meeting match when join id exists', async () => {
+    getMeetingManager.mockResolvedValue('manager-id');
+    apiGet.mockResolvedValue({
+      graphClientMessage: {
+        value: [{ id: 'online-meeting-id' }],
+      },
+    });
+
+    const result = await getMeetingJoinInfo({
+      fields: {
+        JoinMeetingId: ' 123 45 ',
+        MeetingmanagerLookupId: 99,
+      },
+    });
+
+    expect(getMeetingManager).toHaveBeenCalledWith(99);
+    expect(apiGet).toHaveBeenCalledWith(
+      "/users/manager-id/onlineMeetings?$filter=joinMeetingIdSettings/JoinMeetingId eq '12345'",
+    );
+    expect(result).toEqual({ id: 'online-meeting-id' });
+  });
+
+  test('getMeetingJoinInfo returns undefined when join id is missing', async () => {
+    const result = await getMeetingJoinInfo({
+      fields: {
+        JoinMeetingId: '',
+        MeetingmanagerLookupId: 99,
+      },
+    });
+
+    expect(result).toBeUndefined();
+    expect(getMeetingManager).not.toHaveBeenCalled();
+    expect(apiGet).not.toHaveBeenCalled();
+  });
+
+  test('getMeetingJoinInfo returns undefined when manager is missing', async () => {
+    getMeetingManager.mockResolvedValue(undefined);
+
+    const result = await getMeetingJoinInfo({
+      fields: {
+        JoinMeetingId: ' 123 45 ',
+        MeetingmanagerLookupId: 99,
+      },
+    });
+
+    expect(result).toBeUndefined();
+    expect(apiGet).not.toHaveBeenCalled();
+  });
+
+  test('getUser returns graph client message', async () => {
+    apiGet.mockResolvedValue({
+      graphClientMessage: { id: 'user-id', displayName: 'User' },
+    });
+
+    const result = await getUser('user-id');
+
+    expect(apiGet).toHaveBeenCalledWith('/users/user-id');
+    expect(result).toEqual({ id: 'user-id', displayName: 'User' });
+  });
+
+  test('getUser returns undefined on api failure', async () => {
+    apiGet.mockRejectedValue(new Error('boom'));
+
+    const result = await getUser('user-id');
+
+    expect(result).toBeUndefined();
+  });
+
+  test('sendEmail logs error when required fields are missing', async () => {
+    getConfiguration.mockResolvedValue({
+      FromEmailAddress: 'from@example.org',
+      DashboardEmailLoggingEnabled: 'false',
+    });
+
+    await sendEmail('', '<p>Body</p>', ['to@example.org']);
+
+    expect(logError).toHaveBeenCalledWith('Missing subject, body or recipients!', '', {
+      subject: '',
+      body: '<p>Body</p>',
+      recipients: ['to@example.org'],
+    });
+    expect(apiPost).not.toHaveBeenCalled();
+  });
+
+  test('sendEmail sends mail and writes info log when email logging is enabled', async () => {
+    getConfiguration.mockResolvedValue({
+      FromEmailAddress: 'from@example.org',
+      DashboardEmailLoggingEnabled: 'true',
+    });
+    apiPost.mockResolvedValue(undefined);
+    logInfo.mockResolvedValue(undefined);
+
+    await sendEmail('Subject', '<p>Body</p>', ['to@example.org']);
+
+    expect(apiPost).toHaveBeenCalledWith('users/from@example.org/sendMail', {
+      message: {
+        subject: 'Subject',
+        body: {
+          contentType: 'HTML',
+          content: '<p>Body</p>',
+        },
+        toRecipients: [
+          {
+            emailAddress: {
+              address: 'to@example.org',
+            },
+          },
+        ],
+      },
+      saveToSentItems: true,
+    });
+    expect(logInfo).toHaveBeenCalledWith(
+      'Mail sent during registration process',
+      'users/from@example.org/sendMail',
+      expect.objectContaining({
+        subject: 'Subject',
+      }),
+      '',
+      'to@example.org',
+    );
+  });
+
+  test('sendEmail sends mail without info log when email logging is disabled', async () => {
+    getConfiguration.mockResolvedValue({
+      FromEmailAddress: 'from@example.org',
+      DashboardEmailLoggingEnabled: 'false',
+    });
+    apiPost.mockResolvedValue(undefined);
+
+    await sendEmail('Subject', '<p>Body</p>', ['first@example.org', 'second@example.org']);
+
+    expect(apiPost).toHaveBeenCalledWith('users/from@example.org/sendMail', {
+      message: expect.objectContaining({
+        toRecipients: [
+          { emailAddress: { address: 'first@example.org' } },
+          { emailAddress: { address: 'second@example.org' } },
+        ],
+      }),
+      saveToSentItems: true,
+    });
+    expect(logInfo).not.toHaveBeenCalled();
+  });
+
+  test('sendEmail attaches ICS payload when attachment is provided', async () => {
+    getConfiguration.mockResolvedValue({
+      FromEmailAddress: 'from@example.org',
+      DashboardEmailLoggingEnabled: 'false',
+    });
+    apiPost.mockResolvedValue(undefined);
+
+    global.FileReader = class {
+      readAsDataURL() {
+        this.result = 'data:text/calendar;base64,ZmFrZS1pY3M=';
+        this.onloadend();
+      }
+    };
+
+    await sendEmail('Subject', '<p>Body</p>', ['to@example.org'], { name: 'event.ics' });
+
+    expect(apiPost).toHaveBeenCalledWith('users/from@example.org/sendMail', {
+      message: expect.objectContaining({
+        attachments: [
+          {
+            '@odata.type': '#microsoft.graph.fileAttachment',
+            name: 'event.ics',
+            contentType: 'text/calendar; charset=utf-8; method=REQUEST; name=event.ics',
+            contentBytes: 'ZmFrZS1pY3M=',
+          },
+        ],
+      }),
+      saveToSentItems: true,
+    });
+  });
+
+  test('getMe builds and caches profile for valid sharepoint user', async () => {
+    const { getMe } = loadProvider();
+    getConfiguration.mockResolvedValue({
+      AdminGroupId: 'admin-group',
+      NFPGroupId: 'nfp-group',
+      SelfSeviceHelpdeskPreferencesText: 'Pref text',
+      SelfSeviceHelpdeskPersonalDetailsText: 'Details text',
+    });
+    apiGet
+      .mockResolvedValueOnce({
+        graphClientMessage: {
+          displayName: 'John Doe',
+          mail: 'john@example.org',
+          country: 'RO',
+        },
+      })
+      .mockResolvedValueOnce({
+        graphClientMessage: {
+          value: [{ id: 'admin-group' }],
+        },
+      })
+      .mockResolvedValueOnce({
+        graphClientMessage: {
+          value: [{ givenName: 'John', surname: 'Doe' }],
+        },
+      });
+    getSPUserByMail.mockResolvedValue({
+      fields: {
+        Title: 'Mr',
+        Phone: '123',
+        Email: 'john@example.org',
+        Country: 'RO',
+        Membership: ['B', 'A'],
+        OtherMemberships: ['Y', 'X'],
+        Gender: 'M',
+        OrganisationLookupId: 11,
+        NFP: 'NFP',
+        SuggestedOrganisation: 'Org S',
+        Department: 'Dept',
+        JobTitle: 'Job',
+        PCP: 'PCP',
+        id: 1,
+        ADUserId: 77,
+      },
+    });
+    getOrganisationList.mockResolvedValue([{ content: 11, header: 'Org Header' }]);
+
+    const profile = await getMe();
+    const cached = await getMe();
+
+    expect(profile).toEqual(
+      expect.objectContaining({
+        displayName: 'John Doe',
+        mail: 'john@example.org',
+        country: 'RO',
+        isAdmin: true,
+        isNFP: false,
+        isGuest: false,
+        isEionetUser: true,
+        Organisation: 'Org Header',
+        Memberships: ['A', 'B'],
+        OtherMemberships: ['X', 'Y'],
+      }),
+    );
+    expect(cached).toBe(profile);
+    expect(getOrganisationList).toHaveBeenCalledWith('RO');
+    expect(apiGet).toHaveBeenCalledTimes(3);
+  });
+
+  test('getMe returns non-eionet profile when sharepoint user is missing', async () => {
+    const { getMe } = loadProvider();
+    getConfiguration.mockResolvedValue({
+      AdminGroupId: 'admin-group',
+      NFPGroupId: 'nfp-group',
+    });
+    apiGet
+      .mockResolvedValueOnce({
+        graphClientMessage: {
+          displayName: 'Guest User',
+          mail: 'guest@example.org',
+          country: 'DE',
+        },
+      })
+      .mockResolvedValueOnce({
+        graphClientMessage: {
+          value: [{ id: 'nfp-group' }],
+        },
+      })
+      .mockResolvedValueOnce({
+        graphClientMessage: {
+          value: [{ givenName: 'Guest', surname: 'User' }],
+        },
+      });
+    getSPUserByMail.mockResolvedValue(undefined);
+
+    const profile = await getMe();
+
+    expect(profile).toEqual(
+      expect.objectContaining({
+        displayName: 'Guest User',
+        mail: 'guest@example.org',
+        country: 'DE',
+        isEionetUser: false,
+        isAdmin: false,
+        isNFP: true,
+        isGuest: false,
+      }),
+    );
+  });
+});