Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

5.4 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import {
  getSSOCopySuccessMessage,
  getSSOCopyErrorMessage,
  getSSOProviderAddButtonLabel,
  getSSOCertificatePresentation,
  getSSOConnectionTestErrorMessage,
  getSSOConnectionTestFailureMessage,
  getSSOConnectionTestSuccessMessage,
  getSSOEndpointUnavailableHint,
  getSSOProviderCardClass,
  getSSOProviderDeleteErrorMessage,
  getSSOProviderDeleteSuccessMessage,
  getSSOProviderDetailsLoadErrorMessage,
  getSSOProviderEmptyStateDescription,
  getSSOProviderEmptyStateTitle,
  getSSOMetadataFetchErrorMessage,
  getSSOMetadataUrlRequiredMessage,
  getSSOProvidersLoadingState,
  getSSOProvidersLoadErrorMessage,
  getSSOProviderModalTitle,
  getSSOProviderSaveErrorMessage,
  getSSOProviderSaveSuccessMessage,
  getSSOProviderSummary,
  getSSOProviderToggleErrorMessage,
  getSSOProviderToggleSuccessMessage,
  getSSOProviderTypeBadgeClass,
  getSSOProviderTypeLabel,
  getSSOSamlFeatureGateCopy,
  getSSOTestResultPresentation,
} from '../ssoProviderPresentation';

describe('ssoProviderPresentation', () => {
  it('formats provider labels and summaries canonically', () => {
    expect(getSSOProviderTypeLabel('oidc')).toBe('OIDC');
    expect(getSSOProviderTypeLabel('saml')).toBe('SAML');
    expect(getSSOProviderAddButtonLabel('oidc')).toBe('Add OIDC');
    expect(getSSOProviderAddButtonLabel('saml')).toBe('Add SAML');
    expect(getSSOProviderModalTitle(false, 'saml')).toBe('Add SAML Provider');
    expect(getSSOProviderEmptyStateTitle()).toBe('No SSO providers configured');
    expect(getSSOProviderEmptyStateDescription()).toBe(
      'Add an OIDC or SAML provider to get started.',
    );
    expect(getSSOProvidersLoadingState()).toEqual({ text: 'Loading SSO providers…' });
    expect(getSSOProviderTypeBadgeClass()).toContain('bg-surface-hover');
    expect(
      getSSOProviderSummary({
        type: 'oidc',
        oidcIssuerUrl: 'https://login.example.com/realms/pulse',
      }),
    ).toBe('https://login.example.com/realms/pulse');
    expect(
      getSSOProviderSummary({
        type: 'saml',
        samlIdpEntityId: 'https://idp.example.com/entity',
        samlMetadataUrl: 'https://idp.example.com/metadata',
      }),
    ).toBe('https://idp.example.com/entity');
  });

  it('returns capability-focused SAML feature gate copy', () => {
    expect(getSSOSamlFeatureGateCopy()).toMatchObject({
      title: 'Single Sign-On',
      subtitle: 'Single Sign-On',
      body: expect.stringContaining('included with Community'),
    });
    expect(getSSOSamlFeatureGateCopy().body).not.toContain('Pro');
  });

  it('formats provider card and test result tones canonically', () => {
    expect(getSSOProviderCardClass(true)).toContain('bg-surface');
    expect(getSSOProviderCardClass(false)).toContain('opacity-60');
    expect(getSSOTestResultPresentation(true).panelClass).toContain('bg-green-50');
    expect(getSSOTestResultPresentation(false).panelClass).toContain('bg-red-50');
  });

  it('formats provider operational messages canonically', () => {
    expect(getSSOProvidersLoadErrorMessage()).toBe('Unable to load SSO providers.');
    expect(getSSOProviderDetailsLoadErrorMessage()).toBe('Unable to load SSO provider details.');
    expect(getSSOProviderSaveSuccessMessage(true)).toBe('SSO provider has been updated.');
    expect(getSSOProviderSaveSuccessMessage(false)).toBe('SSO provider has been created.');
    expect(getSSOProviderSaveErrorMessage('boom')).toBe('Unable to save the SSO provider: boom');
    expect(getSSOProviderDeleteSuccessMessage()).toBe('SSO provider has been removed.');
    expect(getSSOProviderDeleteErrorMessage()).toBe('Unable to remove the SSO provider.');
    expect(getSSOProviderToggleSuccessMessage(true)).toBe('SSO provider has been enabled.');
    expect(getSSOProviderToggleSuccessMessage(false)).toBe('SSO provider has been disabled.');
    expect(getSSOProviderToggleErrorMessage()).toBe('Unable to update the SSO provider.');
    expect(getSSOCopyErrorMessage('Callback URL')).toContain('Select and copy the URL manually.');
    expect(getSSOCopySuccessMessage('XML')).toBe('XML has been copied to the clipboard.');
    expect(getSSOConnectionTestSuccessMessage()).toBe('Connection test completed successfully.');
    expect(getSSOConnectionTestFailureMessage('Bad certificate')).toBe(
      'Connection test failed: Bad certificate',
    );
    expect(getSSOConnectionTestErrorMessage()).toBe('Unable to run the connection test.');
    expect(getSSOMetadataUrlRequiredMessage()).toBe('Enter an IdP metadata URL.');
    expect(getSSOMetadataFetchErrorMessage('timeout')).toBe(
      'Unable to preview SAML metadata. Check the connection and metadata URL, then try again. Your draft has not been saved.',
    );
  });

  it('points admins at the public URL setting when an endpoint URL is unavailable', () => {
    expect(getSSOEndpointUnavailableHint('Callback / Redirect URL')).toBe(
      'Set the public URL in Settings > System to generate the correct Callback / Redirect URL.',
    );
    expect(getSSOEndpointUnavailableHint('SP metadata and ACS URLs')).toBe(
      'Set the public URL in Settings > System to generate the correct SP metadata and ACS URLs.',
    );
  });

  it('formats certificate tone and expired label canonically', () => {
    expect(getSSOCertificatePresentation(true).containerClass).toContain('bg-red-100');
    expect(getSSOCertificatePresentation(false).containerClass).toContain('bg-surface-hover');
    expect(getSSOCertificatePresentation(true).expiredLabel).toBe('(Expired!)');
  });
});