eionet2-dashboard 3.2.1 → 3.2.3

package/tabs/src/components/event_rating/EventRatingDialog.test.jsx

@@ -0,0 +1,28 @@
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { EventRatingDialog } from './EventRatingDialog';
+
+jest.mock('../../data/hooks/useConfiguration', () => ({
+  useConfiguration: () => ({ DateFormatDashboard: 'dd-MMM-yyyy' }),
+}));
+jest.mock('../event_rating/EventRating', () => ({
+  EventRating: () => <div>event-rating-content</div>,
+}));
+jest.mock('../EventDialogTitle', () => ({
+  EventDialogTitle: () => <div>event-dialog-title</div>,
+}));
+
+describe('EventRatingDialog', () => {
+  test('renders title and rating component', () => {
+    const html = renderToStaticMarkup(
+      <EventRatingDialog
+        open={true}
+        handleClose={jest.fn()}
+        event={{ Title: 'Event 1', MeetingStart: new Date(), MeetingEnd: new Date() }}
+        participant={{}}
+      />,
+    );
+
+    expect(html).toContain('MuiDialog-root');
+  });
+});

package/tabs/src/components/event_registration/Approval.test.jsx

@@ -0,0 +1,25 @@
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { Approval } from './Approval';
+
+describe('Approval', () => {
+  test('renders participant details and invited by NFP state', () => {
+    const html = renderToStaticMarkup(
+      <Approval
+        participant={{
+          id: 1,
+          ParticipantName: 'User 1',
+          Email: 'user1@example.org',
+          NFPApproved: 'No value',
+          PhysicalParticipation: false,
+          EEAReimbursementRequested: false,
+          IsInvitedByNFP: true,
+        }}
+      />,
+    );
+
+    expect(html).toContain('User 1');
+    expect(html).toContain('user1@example.org');
+    expect(html).toContain('Invited by NFP');
+  });
+});

package/tabs/src/components/event_registration/ApprovalDialog.test.jsx

@@ -0,0 +1,25 @@
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { ApprovalDialog } from './ApprovalDialog';
+
+jest.mock('./ApprovalList', () => ({
+  ApprovalList: () => <div>approval-list-content</div>,
+}));
+jest.mock('../EventDialogTitle', () => ({
+  EventDialogTitle: () => <div>event-dialog-title</div>,
+}));
+
+describe('ApprovalDialog', () => {
+  test('renders approval list and event title section', () => {
+    const html = renderToStaticMarkup(
+      <ApprovalDialog
+        open={true}
+        handleClose={jest.fn()}
+        event={{ Title: 'Event 1' }}
+        userInfo={{}}
+      />,
+    );
+
+    expect(html).toContain('MuiDialog-root');
+  });
+});

package/tabs/src/components/event_registration/ApprovalList.test.jsx

@@ -0,0 +1,36 @@
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { ApprovalList } from './ApprovalList';
+
+jest.mock('../../data/hooks/useConfiguration', () => ({
+  useConfiguration: () => ({ EventApprovalInfo: 'Approval info' }),
+}));
+jest.mock('../../data/sharepointProvider', () => ({
+  patchParticipants: jest.fn(),
+}));
+jest.mock('./Approval', () => ({
+  Approval: ({ participant }) => <div>approval-{participant.id}</div>,
+}));
+jest.mock('../HtmlBox', () => ({
+  HtmlBox: ({ html }) => <div>{html}</div>,
+}));
+
+describe('ApprovalList', () => {
+  test('renders participants list and update button', () => {
+    const html = renderToStaticMarkup(
+      <ApprovalList
+        event={{
+          Participants: [
+            { id: 1, ParticipantName: 'A', Email: 'a@example.org' },
+            { id: 2, ParticipantName: 'B', Email: 'b@example.org' },
+          ],
+        }}
+      />,
+    );
+
+    expect(html).toContain('approval-1');
+    expect(html).toContain('approval-2');
+    expect(html).toContain('Approval info');
+    expect(html).toContain('Update');
+  });
+});

package/tabs/src/components/event_registration/EventExternalRegistration.test.jsx

@@ -0,0 +1,219 @@
+jest.mock('react', () => {
+  const actual = jest.requireActual('react');
+  return {
+    ...actual,
+    React: actual,
+    useState: jest.fn(actual.useState),
+  };
+});
+
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { EventExternalRegistration } from './EventExternalRegistration';
+import { postParticipant } from '../../data/sharepointProvider';
+import { getUserByMail } from '../../data/provider';
+
+const buttonHandlers = [];
+
+jest.mock('@mui/material', () => {
+  const ReactLocal = require('react');
+  const passthrough =
+    (Tag = 'div') =>
+    ({ children }) =>
+      ReactLocal.createElement(Tag, {}, children);
+
+  const labelToText = (children) => {
+    if (typeof children === 'string') {
+      return children;
+    }
+    if (Array.isArray(children)) {
+      return children
+        .filter((v) => typeof v === 'string')
+        .join(' ')
+        .trim();
+    }
+    return '';
+  };
+
+  return {
+    Alert: passthrough(),
+    Box: passthrough(),
+    Checkbox: passthrough('input'),
+    TextField: ({ label }) => <div>{label || ''}</div>,
+    Button: ({ onClick, children }) => {
+      const label = labelToText(children);
+      if (onClick) {
+        buttonHandlers.push({ label, onClick });
+      }
+      return <button>{children}</button>;
+    },
+    FormControlLabel: ({ label, control }) => (
+      <div>
+        {label}
+        {control}
+      </div>
+    ),
+    CircularProgress: passthrough('span'),
+    Backdrop: passthrough(),
+  };
+});
+
+jest.mock('@mui/icons-material/Check', () => () => <span>check-icon</span>);
+jest.mock('@mui/icons-material/Save', () => () => <span>save-icon</span>);
+
+jest.mock('../../data/hooks/useConfiguration', () => ({
+  useConfiguration: () => ({
+    NFPInvitationInfoMessage: 'Invitation info',
+    NFPInvitationSuccessMessage: 'Invitation success',
+    EventInvitationByNFPError: 'Already invited',
+  }),
+}));
+
+jest.mock('../../data/sharepointProvider', () => ({
+  postParticipant: jest.fn(),
+}));
+
+jest.mock('../../data/provider', () => ({
+  getUserByMail: jest.fn(),
+}));
+
+jest.mock('../HtmlBox', () => ({
+  HtmlBox: ({ html }) => <div>{html}</div>,
+}));
+
+function mockStateSequence(values) {
+  let index = 0;
+  React.useState.mockImplementation((initialValue) => {
+    if (index < values.length) {
+      const current = values[index];
+      index += 1;
+      return [current, jest.fn()];
+    }
+    return [initialValue, jest.fn()];
+  });
+}
+
+function buildState(participantOverride = {}) {
+  const participant = {
+    MeetingId: 1,
+    ParticipantName: 'John Doe',
+    Email: 'john@example.org',
+    PhysicalParticipation: false,
+    EEAReimbursementRequested: false,
+    Registered: true,
+    RegistrationDate: new Date('2025-01-01'),
+    Country: 'RO',
+    NFPApproved: 'Approved',
+    CustomMeetingRequest: 'Registered by NFP',
+    IsInvitedByNFP: true,
+    ...participantOverride,
+  };
+
+  return [participant, false, '', {}, false, false, false];
+}
+
+describe('EventExternalRegistration', () => {
+  const baseEvent = {
+    id: 1,
+    IsOffline: true,
+    Participants: [],
+    NoOfRegistered: 0,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    buttonHandlers.length = 0;
+    React.useState.mockImplementation((initialValue) => [initialValue, jest.fn()]);
+    getUserByMail.mockResolvedValue(null);
+    postParticipant.mockResolvedValue({ id: 77 });
+  });
+
+  test('renders external registration form', () => {
+    mockStateSequence(buildState());
+
+    const html = renderToStaticMarkup(
+      <EventExternalRegistration event={{ ...baseEvent }} userInfo={{ country: 'RO' }} />,
+    );
+
+    expect(html).toContain('Invitation info');
+    expect(html).toContain('Register');
+    expect(html).toContain('Physical participation');
+    expect(html).toContain('Reimbursement requested');
+  });
+
+  test('successfully registers external participant', async () => {
+    const event = {
+      ...baseEvent,
+      Participants: [
+        { Email: 'a@x.org', Registered: true },
+        { Email: 'b@x.org', Registered: false },
+      ],
+    };
+
+    const state = buildState({ Email: 'new.user@domain.org', ParticipantName: 'New User' });
+    const participant = state[0];
+    mockStateSequence(state);
+
+    renderToStaticMarkup(<EventExternalRegistration event={event} userInfo={{ country: 'RO' }} />);
+
+    const register = buttonHandlers.find((b) => b.label === 'Register');
+    expect(register).toBeDefined();
+
+    await register.onClick();
+
+    expect(getUserByMail).toHaveBeenCalledWith('new.user@domain.org');
+    expect(postParticipant).toHaveBeenCalledWith(participant, event);
+    expect(participant.id).toBe(77);
+    expect(event.Participants.length).toBe(3);
+    expect(event.NoOfRegistered).toBe(2);
+  });
+
+  test('does not post when email is invalid', async () => {
+    const state = buildState({ Email: 'invalid-email', ParticipantName: 'Valid Name' });
+    mockStateSequence(state);
+
+    renderToStaticMarkup(
+      <EventExternalRegistration event={{ ...baseEvent }} userInfo={{ country: 'RO' }} />,
+    );
+
+    const register = buttonHandlers.find((b) => b.label === 'Register');
+    await register.onClick();
+
+    expect(getUserByMail).not.toHaveBeenCalled();
+    expect(postParticipant).not.toHaveBeenCalled();
+  });
+
+  test('does not post EEA addresses', async () => {
+    const state = buildState({ Email: 'user@eea.europa.eu', ParticipantName: 'Valid Name' });
+    mockStateSequence(state);
+
+    renderToStaticMarkup(
+      <EventExternalRegistration event={{ ...baseEvent }} userInfo={{ country: 'RO' }} />,
+    );
+
+    const register = buttonHandlers.find((b) => b.label === 'Register');
+    await register.onClick();
+
+    expect(getUserByMail).not.toHaveBeenCalled();
+    expect(postParticipant).not.toHaveBeenCalled();
+  });
+
+  test('does not post when user exists or already invited', async () => {
+    const event = {
+      ...baseEvent,
+      Participants: [{ Email: 'existing@domain.org', Registered: true }],
+    };
+
+    const state = buildState({ Email: 'existing@domain.org', ParticipantName: 'Valid Name' });
+    mockStateSequence(state);
+    getUserByMail.mockResolvedValue({ SharepointUser: true });
+
+    renderToStaticMarkup(<EventExternalRegistration event={event} userInfo={{ country: 'RO' }} />);
+
+    const register = buttonHandlers.find((b) => b.label === 'Register');
+    await register.onClick();
+
+    expect(getUserByMail).toHaveBeenCalledWith('existing@domain.org');
+    expect(postParticipant).not.toHaveBeenCalled();
+  });
+});

package/tabs/src/components/event_registration/EventRegistration.test.jsx

@@ -0,0 +1,208 @@
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { EventRegistration } from './EventRegistration';
+import {
+  postParticipant,
+  patchParticipant,
+  deleteParticipant,
+} from '../../data/sharepointProvider';
+
+const buttonHandlers = [];
+
+jest.mock('@mui/material', () => {
+  const ReactLocal = require('react');
+  const passthrough =
+    (Tag = 'div') =>
+    ({ children }) =>
+      ReactLocal.createElement(Tag, {}, children);
+
+  const labelToText = (children) => {
+    if (typeof children === 'string') {
+      return children;
+    }
+    if (Array.isArray(children)) {
+      return children
+        .filter((v) => typeof v === 'string')
+        .join(' ')
+        .trim();
+    }
+    return '';
+  };
+
+  return {
+    Box: passthrough(),
+    Checkbox: passthrough('input'),
+    TextField: ({ label }) => <div>{label || ''}</div>,
+    Button: ({ onClick, children }) => {
+      const label = labelToText(children);
+      if (onClick) {
+        buttonHandlers.push({ label, onClick });
+      }
+      return <button>{children}</button>;
+    },
+    FormControlLabel: ({ label, control }) => (
+      <div>
+        {label}
+        {control}
+      </div>
+    ),
+    CircularProgress: passthrough('span'),
+    Backdrop: passthrough(),
+    Alert: passthrough(),
+  };
+});
+
+jest.mock('@mui/icons-material/Check', () => () => <span>check-icon</span>);
+jest.mock('@mui/icons-material/Save', () => () => <span>save-icon</span>);
+
+jest.mock('../../data/hooks/useConfiguration', () => ({
+  useConfiguration: () => ({ EventRegistrationInfo: 'Registration info' }),
+}));
+
+jest.mock('../../data/sharepointProvider', () => ({
+  postParticipant: jest.fn(),
+  patchParticipant: jest.fn(),
+  deleteParticipant: jest.fn(),
+}));
+
+jest.mock('../HtmlBox', () => ({
+  HtmlBox: ({ html }) => <div>{html}</div>,
+}));
+
+describe('EventRegistration', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    buttonHandlers.length = 0;
+  });
+
+  test('renders registration form and action buttons for registered offline event', () => {
+    const html = renderToStaticMarkup(
+      <EventRegistration
+        participant={{
+          id: 1,
+          ParticipantName: 'User 1',
+          Email: 'user1@example.org',
+          Country: 'RO',
+          Registered: true,
+          PhysicalParticipation: true,
+          EEAReimbursementRequested: false,
+          CustomMeetingRequest: '',
+        }}
+        event={{
+          IsOffline: true,
+          Participants: [],
+          CustomMeetingRequest: 'Bring badge',
+        }}
+      />,
+    );
+
+    expect(html).toContain('Registration info');
+    expect(html).toContain('Update registration');
+    expect(html).toContain('Unregister');
+    expect(html).toContain('Physical participation');
+    expect(html).toContain('Reimbursement requested');
+  });
+
+  test('register flow posts participant and updates event counters', async () => {
+    const participant = {
+      ParticipantName: 'User 2',
+      Email: 'user2@example.org',
+      Country: 'RO',
+      Registered: false,
+      PhysicalParticipation: false,
+      EEAReimbursementRequested: false,
+      CustomMeetingRequest: '',
+    };
+    const event = {
+      IsOffline: true,
+      HasRegistered: false,
+      NoOfRegistered: 0,
+      Participants: [{ Registered: true }, { Registered: false }],
+      CustomMeetingRequest: '',
+    };
+
+    postParticipant.mockResolvedValue({ id: 55 });
+
+    renderToStaticMarkup(<EventRegistration participant={participant} event={event} />);
+
+    const register = buttonHandlers.find((b) => b.label === 'Register');
+    expect(register).toBeDefined();
+
+    await register.onClick();
+
+    expect(postParticipant).toHaveBeenCalledWith(participant, event);
+    expect(participant.Registered).toBe(true);
+    expect(participant.id).toBe(55);
+    expect(event.HasRegistered).toBe(true);
+    expect(event.NoOfRegistered).toBe(2);
+    expect(event.Participants.length).toBe(3);
+  });
+
+  test('update and unregister flows call patch and delete', async () => {
+    const participant = {
+      id: 10,
+      ParticipantName: 'User 3',
+      Email: 'user3@example.org',
+      Country: 'RO',
+      Registered: true,
+      NFPApproved: 'Yes',
+      PhysicalParticipation: true,
+      EEAReimbursementRequested: true,
+      CustomMeetingRequest: '',
+    };
+    const event = {
+      IsOffline: true,
+      HasRegistered: true,
+      NoOfRegistered: 1,
+      Participants: [participant],
+      CustomMeetingRequest: '',
+    };
+
+    patchParticipant.mockResolvedValue({});
+    deleteParticipant.mockResolvedValue({});
+
+    renderToStaticMarkup(<EventRegistration participant={participant} event={event} />);
+
+    const update = buttonHandlers.find((b) => b.label === 'Update registration');
+    const unregister = buttonHandlers.find((b) => b.label === 'Unregister');
+
+    expect(update).toBeDefined();
+    expect(unregister).toBeDefined();
+
+    await update.onClick();
+    expect(patchParticipant).toHaveBeenCalledWith(participant, event);
+    expect(participant.NFPApproved).toBe('No value');
+    expect(event.HasRegistered).toBe(true);
+
+    await unregister.onClick();
+    expect(deleteParticipant).toHaveBeenCalledWith(participant, event);
+    expect(participant.Registered).toBe(false);
+    expect(event.HasRegistered).toBe(false);
+    expect(event.NoOfRegistered).toBe(0);
+  });
+
+  test('online event hides offline-only controls', () => {
+    const html = renderToStaticMarkup(
+      <EventRegistration
+        participant={{
+          ParticipantName: 'User 4',
+          Email: 'user4@example.org',
+          Country: 'RO',
+          Registered: false,
+          PhysicalParticipation: false,
+          EEAReimbursementRequested: false,
+          CustomMeetingRequest: '',
+        }}
+        event={{
+          IsOffline: false,
+          Participants: [],
+          CustomMeetingRequest: 'ignored',
+        }}
+      />,
+    );
+
+    expect(html).not.toContain('Physical participation');
+    expect(html).not.toContain('Reimbursement requested');
+    expect(html).toContain('Register');
+  });
+});

package/tabs/src/components/my_country/AtAGlance.test.jsx

@@ -0,0 +1,157 @@
+let mockRunEffect = true;
+
+jest.mock('react', () => {
+  const actual = jest.requireActual('react');
+  return {
+    ...actual,
+    React: actual,
+    useEffect: jest.fn((fn) => {
+      if (mockRunEffect) {
+        mockRunEffect = false;
+        fn();
+      }
+    }),
+  };
+});
+
+import React from 'react';
+jest.mock('./my_country.scss', () => ({}));
+import { renderToStaticMarkup } from 'react-dom/server';
+import { AtAGlance } from './AtAGlance';
+import { getGroups, getMeetings, getConsultations } from '../../data/sharepointProvider';
+
+jest.mock('../../data/sharepointProvider', () => ({
+  getGroups: jest.fn((users) => users.map((u) => u.GroupName).filter(Boolean)),
+  getMeetings: jest.fn(),
+  getConsultations: jest.fn(),
+}));
+jest.mock('./IndicatorCard', () => ({
+  IndicatorCard: ({ labelText, valueText }) => (
+    <div>
+      {labelText}:{valueText}
+    </div>
+  ),
+}));
+jest.mock('./CountryProgress', () => ({
+  CountryProgress: () => <div>country-progress</div>,
+}));
+jest.mock('../HtmlBox', () => ({
+  HtmlBox: ({ html }) => <div>{html}</div>,
+}));
+
+describe('AtAGlance', () => {
+  const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+  const waitForMockCall = async (mockFn, retries = 20) => {
+    for (let i = 0; i < retries; i += 1) {
+      if (mockFn.mock.calls.length > 0) {
+        return;
+      }
+      await flush();
+    }
+  };
+
+  const baseConfiguration = {
+    UserListUrl: 'https://users',
+    OrganisationListUrl: 'https://orgs',
+    ConsultationListUrl: 'https://consultations?',
+    InquiryListUrl: 'https://inquiries?',
+    MeetingListUrl: 'https://meetings',
+    CountryProgressHtml: 'Country intro',
+    DashboardNoOfDisplayedYears: 1,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockRunEffect = true;
+    getMeetings.mockResolvedValue([
+      { Year: new Date().getFullYear(), IsPast: true, Countries: ['RO'], Group: ['group-a'] },
+      { Year: new Date().getFullYear(), IsPast: true, Countries: ['RO'], Group: ['wg-secret'] },
+    ]);
+    getConsultations.mockResolvedValue([
+      {
+        Year: new Date().getFullYear(),
+        Deadline: new Date(new Date().getTime() - 86400000),
+        ConsultationType: 'Consultation',
+        Respondants: ['RO'],
+        EionetGroups: ['group-a'],
+      },
+      {
+        Year: new Date().getFullYear(),
+        Deadline: new Date(new Date().getTime() - 86400000),
+        ConsultationType: 'Enquiry',
+        Respondants: ['RO'],
+        EionetGroups: ['wg-secret'],
+      },
+    ]);
+  });
+
+  test('renders representation cards and country section', async () => {
+    const html = renderToStaticMarkup(
+      <AtAGlance
+        users={[
+          { SignedIn: true, GroupName: 'A' },
+          { SignedIn: false, GroupName: 'B' },
+        ]}
+        organisations={[{ id: 1 }]}
+        country="RO"
+        userInfo={{ mail: 'nfp@example.org' }}
+        configuration={baseConfiguration}
+        availableGroups={['A', 'B', 'C']}
+      />,
+    );
+
+    await waitForMockCall(getConsultations);
+
+    expect(html).toContain('Representation:');
+    expect(html).toContain('members:2');
+    expect(html).toContain('members pending sign in:1');
+    expect(html).toContain('organisations:1');
+    expect(html).toContain('groups with nominations:2/3');
+    expect(html).toContain('groups with signed in users:1/3');
+    expect(html).toContain('Country intro');
+    expect(html).toContain('country-progress');
+
+    expect(getGroups).toHaveBeenCalled();
+    expect(getMeetings).toHaveBeenCalled();
+    expect(getConsultations).toHaveBeenCalled();
+  });
+
+  test('renders cards without country-specific section when country is missing', async () => {
+    const html = renderToStaticMarkup(
+      <AtAGlance
+        users={[{ SignedIn: false, GroupName: 'X' }]}
+        organisations={[]}
+        country=""
+        userInfo={{}}
+        configuration={baseConfiguration}
+        availableGroups={['X']}
+      />,
+    );
+
+    await flush();
+    await flush();
+
+    expect(html).toContain('members:1');
+    expect(html).toContain('groups with nominations:1/1');
+    expect(html).not.toContain('country-progress');
+    expect(html).not.toContain('Country intro');
+  });
+
+  test('supports default number of years when configuration is missing value', async () => {
+    renderToStaticMarkup(
+      <AtAGlance
+        users={[]}
+        organisations={[]}
+        country="RO"
+        userInfo={{}}
+        configuration={{ ...baseConfiguration, DashboardNoOfDisplayedYears: undefined }}
+        availableGroups={[]}
+      />,
+    );
+
+    await waitForMockCall(getConsultations);
+
+    expect(getMeetings).toHaveBeenCalled();
+    expect(getConsultations).toHaveBeenCalled();
+  });
+});