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.

13.1 KB
Raw Blame
import { Route, Router } from '@solidjs/router';
import { cleanup, render, screen } from '@solidjs/testing-library';
import { afterEach, describe, expect, it, vi } from 'vitest';
import {
  ActionIconButton,
  Button,
  ButtonLink,
  CommandCopyButton,
  CopyValueButton,
  DrawerHeaderActionButton,
  DrawerHeaderActionGroup,
  DrawerHeaderIconButton,
} from './Button';

describe('Button', () => {
  afterEach(() => {
    cleanup();
    window.history.replaceState({}, '', '/');
  });

  it('renders command buttons with the shared secondary shell', () => {
    const onClick = vi.fn();

    render(() => (
      <Button variant="secondary" size="sm" class="gap-2 px-3" onClick={onClick}>
        Add agent
      </Button>
    ));

    const button = screen.getByRole('button', { name: 'Add agent' });
    expect(button).toHaveAttribute('type', 'button');
    expect(button).toHaveClass('bg-surface');
    expect(button).toHaveClass('border-border');
    expect(button).toHaveClass('px-3');
    expect(button).toHaveClass('min-h-11');
    expect(button).toHaveClass('sm:min-h-0');

    button.click();
    expect(onClick).toHaveBeenCalledTimes(1);
  });

  it('disables loading command buttons through the shared primitive', () => {
    render(() => (
      <Button variant="secondary" size="sm" isLoading>
        Refresh
      </Button>
    ));

    expect(screen.getByRole('button', { name: 'Refresh' })).toBeDisabled();
  });

  it('renders settings action buttons through named size and variants', () => {
    render(() => (
      <>
        <Button variant="primary" size="settingsAction">
          Save source
        </Button>
        <Button variant="dangerOutline" size="settingsAction">
          Remove source
        </Button>
        <Button variant="success" size="settingsAction">
          Open infrastructure
        </Button>
        <Button variant="warningSolid" size="sm">
          Review approvals
        </Button>
        <Button variant="successOutline" size="settingsAction">
          Open inventory
        </Button>
        <Button variant="successGhost" size="settingsAction">
          Dismiss
        </Button>
        <Button variant="dangerGhost" size="xs">
          Remove member
        </Button>
        <Button variant="info" size="settingsAction">
          View reference
        </Button>
        <Button variant="secondary" size="settingsActionXs">
          Preview payload
        </Button>
      </>
    ));

    const saveButton = screen.getByRole('button', { name: 'Save source' });
    expect(saveButton).toHaveClass('min-h-11');
    expect(saveButton).toHaveClass('sm:min-h-9');
    expect(saveButton).toHaveClass('bg-blue-600');

    const removeButton = screen.getByRole('button', { name: 'Remove source' });
    expect(removeButton).toHaveClass('min-h-11');
    expect(removeButton).toHaveClass('border-rose-300');
    expect(removeButton).toHaveClass('text-rose-700');

    const openInfrastructureButton = screen.getByRole('button', { name: 'Open infrastructure' });
    expect(openInfrastructureButton).toHaveClass('bg-emerald-600');
    expect(openInfrastructureButton).toHaveClass('text-white');

    const reviewApprovalsButton = screen.getByRole('button', { name: 'Review approvals' });
    expect(reviewApprovalsButton).toHaveClass('bg-amber-600');
    expect(reviewApprovalsButton).toHaveClass('text-white');

    const openInventoryButton = screen.getByRole('button', { name: 'Open inventory' });
    expect(openInventoryButton).toHaveClass('border-emerald-300');
    expect(openInventoryButton).toHaveClass('text-emerald-900');

    const dismissButton = screen.getByRole('button', { name: 'Dismiss' });
    expect(dismissButton).toHaveClass('border-transparent');
    expect(dismissButton).toHaveClass('text-emerald-900');

    const removeMemberButton = screen.getByRole('button', { name: 'Remove member' });
    expect(removeMemberButton).toHaveClass('border-transparent');
    expect(removeMemberButton).toHaveClass('text-red-600');
    expect(removeMemberButton).toHaveClass('text-xs');
    expect(removeMemberButton).toHaveClass('min-h-11');

    const infoButton = screen.getByRole('button', { name: 'View reference' });
    expect(infoButton).toHaveClass('border-blue-200');
    expect(infoButton).toHaveClass('bg-blue-50');
    expect(infoButton).toHaveClass('text-blue-700');

    const previewButton = screen.getByRole('button', { name: 'Preview payload' });
    expect(previewButton).toHaveClass('min-h-11');
    expect(previewButton).toHaveClass('text-xs');
    expect(previewButton).toHaveClass('px-3');
  });

  it('renders command-copy icon buttons through the shared primitive', () => {
    const onClick = vi.fn();

    render(() => <CommandCopyButton onClick={onClick} label="Copy install command" />);

    const button = screen.getByRole('button', { name: 'Copy install command' });
    expect(button).toHaveAttribute('type', 'button');
    expect(button).toHaveAttribute('title', 'Copy install command');
    expect(button).toHaveClass('absolute');
    expect(button).toHaveClass('right-2');
    expect(button).toHaveClass('top-2');
    expect(button).toHaveClass('min-h-10');
    expect(button).toHaveClass('min-w-10');
    expect(button).toHaveClass('bg-surface-hover');
    expect(button).toHaveClass('p-2');

    button.click();
    expect(onClick).toHaveBeenCalledTimes(1);
  });

  it('renders copy-value icon and chip buttons through the shared primitive', () => {
    const onCopy = vi.fn();
    const onParentClick = vi.fn();

    render(() => (
      <>
        <CopyValueButton
          value="  https://example.test  "
          copied={false}
          onCopyValue={onCopy}
          label="Copy URL"
        />
        <CopyValueButton
          value="8443/tcp"
          copied
          onCopyValue={onCopy}
          label="Copy 8443/tcp"
          variant="chip"
          size="chip"
        >
          <span>8443/tcp</span>
        </CopyValueButton>
        <CopyValueButton value=" " onCopyValue={onCopy} label="Copy blank" />
        <div onClick={onParentClick}>
          <CopyValueButton
            value="nested"
            onCopyValue={onCopy}
            label="Copy nested"
            stopPropagation
          />
        </div>
      </>
    ));

    const copyUrlButton = screen.getByRole('button', { name: 'Copy URL' });
    expect(copyUrlButton).toHaveClass('border-border');
    expect(copyUrlButton).toHaveClass('min-h-6');
    expect(copyUrlButton).toHaveClass('min-w-6');
    expect(copyUrlButton).toHaveClass('min-h-7');
    copyUrlButton.click();
    expect(onCopy).toHaveBeenCalledWith('https://example.test');

    const chipButton = screen.getByRole('button', { name: 'Copy 8443/tcp' });
    expect(chipButton).toHaveClass('bg-surface-alt');
    expect(chipButton).toHaveClass('text-[10px]');
    expect(chipButton).toHaveClass('min-h-6');
    expect(chipButton).toHaveClass('min-w-6');

    expect(screen.getByRole('button', { name: 'Copy blank' })).toBeDisabled();

    screen.getByRole('button', { name: 'Copy nested' }).click();
    expect(onCopy).toHaveBeenCalledWith('nested');
    expect(onParentClick).not.toHaveBeenCalled();
  });

  it('renders compact action icon buttons through the shared primitive', () => {
    const onClick = vi.fn();

    render(() => (
      <>
        <ActionIconButton label="Queued edit" tone="accentGhost" size="2xs">
          <span aria-hidden="true">Q</span>
        </ActionIconButton>
        <ActionIconButton label="Edit thresholds" tone="accent" size="xs" onClick={onClick}>
          <span aria-hidden="true">E</span>
        </ActionIconButton>
        <ActionIconButton label="Open help" tone="outline" size="md">
          <span aria-hidden="true">?</span>
        </ActionIconButton>
        <ActionIconButton label="Notifications enabled" tone="outlineSelected" size="md">
          <span aria-hidden="true">N</span>
        </ActionIconButton>
        <ActionIconButton label="Send message" tone="primary" size="lg">
          <span aria-hidden="true">S</span>
        </ActionIconButton>
        <ActionIconButton label="Promote queued follow-up" tone="accentGhost" size="xs">
          <span aria-hidden="true">P</span>
        </ActionIconButton>
        <ActionIconButton label="Dismiss warning" tone="warningGhost" size="sm">
          <span aria-hidden="true">W</span>
        </ActionIconButton>
        <ActionIconButton label="Download fallback" tone="warningOutline" size="sm">
          <span aria-hidden="true">D</span>
        </ActionIconButton>
        <ActionIconButton label="Dismiss info" tone="infoGhost" size="xs">
          <span aria-hidden="true">I</span>
        </ActionIconButton>
      </>
    ));

    const button = screen.getByRole('button', { name: 'Edit thresholds' });
    expect(button).toHaveAttribute('type', 'button');
    expect(button).toHaveAttribute('title', 'Edit thresholds');
    expect(button).toHaveClass('h-6');
    expect(button).toHaveClass('w-6');
    expect(button).toHaveClass('bg-blue-50');

    const queuedEditButton = screen.getByRole('button', { name: 'Queued edit' });
    expect(queuedEditButton).toHaveClass('h-6');
    expect(queuedEditButton).toHaveClass('w-6');
    expect(queuedEditButton).toHaveClass('min-h-6');
    expect(queuedEditButton).toHaveClass('min-w-6');
    expect(screen.getByRole('button', { name: 'Open help' })).toHaveClass('border-border');
    expect(screen.getByRole('button', { name: 'Notifications enabled' })).toHaveClass(
      'bg-surface-alt',
    );
    expect(screen.getByRole('button', { name: 'Send message' })).toHaveClass('h-9');
    expect(screen.getByRole('button', { name: 'Send message' })).toHaveClass('bg-blue-600');
    expect(screen.getByRole('button', { name: 'Promote queued follow-up' })).toHaveClass(
      'text-blue-700',
    );
    expect(screen.getByRole('button', { name: 'Dismiss warning' })).toHaveClass('text-amber-700');
    expect(screen.getByRole('button', { name: 'Download fallback' })).toHaveClass(
      'border-amber-200',
    );
    expect(screen.getByRole('button', { name: 'Dismiss info' })).toHaveClass('text-cyan-500');

    button.click();
    expect(onClick).toHaveBeenCalledTimes(1);
  });

  it('renders drawer header actions through the shared button family', () => {
    const onAsk = vi.fn();
    const onClose = vi.fn();

    render(() => (
      <DrawerHeaderActionGroup data-testid="drawer-actions">
        <DrawerHeaderActionButton onClick={onAsk} aria-label="Ask about alpha">
          Ask
        </DrawerHeaderActionButton>
        <DrawerHeaderActionButton disabled aria-label="Copy alpha">
          Copy
        </DrawerHeaderActionButton>
        <DrawerHeaderIconButton onClick={onClose} aria-label="Close drawer">
          x
        </DrawerHeaderIconButton>
      </DrawerHeaderActionGroup>
    ));

    const group = screen.getByTestId('drawer-actions');
    expect(group).toHaveClass('shrink-0');
    expect(group).toHaveClass('gap-1.5');

    const ask = screen.getByRole('button', { name: 'Ask about alpha' });
    expect(ask).toHaveAttribute('type', 'button');
    expect(ask).toHaveClass('h-8');
    expect(ask).toHaveClass('bg-surface');
    ask.click();
    expect(onAsk).toHaveBeenCalledTimes(1);

    expect(screen.getByRole('button', { name: 'Copy alpha' })).toBeDisabled();

    const close = screen.getByRole('button', { name: 'Close drawer' });
    expect(close).toHaveClass('w-8');
    close.click();
    expect(onClose).toHaveBeenCalledTimes(1);
  });

  it('renders in-app button links through the router', () => {
    render(() => (
      <Router>
        <Route
          path="/"
          component={() => (
            <ButtonLink href="/standalone/availability" size="sm">
              View checks
            </ButtonLink>
          )}
        />
      </Router>
    ));

    const link = screen.getByRole('link', { name: 'View checks' });
    expect(link).toHaveAttribute('href', '/standalone/availability');
    expect(link).not.toHaveAttribute('target');
    expect(link).toHaveClass('bg-surface');
  });

  it('renders external or new-tab button links as safe native anchors', () => {
    render(() => (
      <Router>
        <Route
          path="/"
          component={() => (
            <ButtonLink href="https://example.com/docs" target="_blank" size="sm">
              Docs
            </ButtonLink>
          )}
        />
      </Router>
    ));

    const link = screen.getByRole('link', { name: 'Docs' });
    expect(link).toHaveAttribute('href', 'https://example.com/docs');
    expect(link).toHaveAttribute('target', '_blank');
    expect(link).toHaveAttribute('rel', 'noopener noreferrer');
  });

  it('can preserve opener access for trusted new-tab button links', () => {
    render(() => (
      <Router>
        <Route
          path="/"
          component={() => (
            <ButtonLink
              href="/auth/license-purchase-start?feature=relay"
              target="_blank"
              preserveOpener
              size="sm"
            >
              Purchase
            </ButtonLink>
          )}
        />
      </Router>
    ));

    const link = screen.getByRole('link', { name: 'Purchase' });
    expect(link).toHaveAttribute('href', '/auth/license-purchase-start?feature=relay');
    expect(link).toHaveAttribute('target', '_blank');
    expect(link).not.toHaveAttribute('rel');
  });
});