@polderlabs/bizar 6.2.5 → 7.0.0

package/bizar-dash/tests/ui/data/Sparkline.test.tsx

@@ -0,0 +1,56 @@
+// tests/ui/data/Sparkline.test.tsx — Wave 2B
+
+import { render } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { Sparkline } from '../../../src/web/ui/data/Sparkline';
+
+describe('Sparkline', () => {
+  it('renders an svg with the configured width/height/viewBox', () => {
+    const { container } = render(
+      <Sparkline data={[1, 2, 3, 4, 5]} width={120} height={30} />,
+    );
+    const svg = container.querySelector('svg');
+    expect(svg).toBeInTheDocument();
+    expect(svg).toHaveAttribute('width', '120');
+    expect(svg).toHaveAttribute('height', '30');
+    expect(svg).toHaveAttribute('viewBox', '0 0 120 30');
+    expect(svg).toHaveAttribute('role', 'img');
+  });
+
+  it('draws a line + area path with non-empty `d`', () => {
+    const { container } = render(<Sparkline data={[2, 4, 1, 7, 3]} />);
+    const paths = container.querySelectorAll('path');
+    expect(paths.length).toBe(2);
+    const line = container.querySelector('.bd-sparkline__line');
+    const area = container.querySelector('.bd-sparkline__fill');
+    expect(line?.getAttribute('d')).toMatch(/^M/);
+    expect(area?.getAttribute('d')).toMatch(/^M/);
+  });
+
+  it('renders nothing when data is empty (no paths)', () => {
+    const { container } = render(<Sparkline data={[]} />);
+    expect(container.querySelectorAll('path').length).toBe(0);
+  });
+
+  it('applies the supplied stroke / fill colours', () => {
+    const { container } = render(
+      <Sparkline
+        data={[1, 2, 3]}
+        stroke="var(--chart-2)"
+        fill="var(--info-subtle)"
+      />,
+    );
+    const line = container.querySelector('.bd-sparkline__line');
+    const area = container.querySelector('.bd-sparkline__fill');
+    expect(line).toHaveAttribute('stroke', 'var(--chart-2)');
+    expect(area).toHaveAttribute('fill', 'var(--info-subtle)');
+  });
+
+  it('accepts a custom aria-label', () => {
+    const { container } = render(
+      <Sparkline data={[1, 2, 3]} ariaLabel="Latency over time" />,
+    );
+    const svg = container.querySelector('svg');
+    expect(svg).toHaveAttribute('aria-label', 'Latency over time');
+  });
+});

package/bizar-dash/tests/ui/data/StatTile.test.tsx

@@ -0,0 +1,69 @@
+// tests/ui/data/StatTile.test.tsx — Wave 2B
+
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { Star } from 'lucide-react';
+import { StatTile } from '../../../src/web/ui/data/StatTile';
+
+describe('StatTile', () => {
+  it('shows the label and value', () => {
+    render(<StatTile label="Revenue" value="$12,400" />);
+    expect(screen.getByText('Revenue')).toBeInTheDocument();
+    expect(screen.getByText('$12,400')).toBeInTheDocument();
+  });
+
+  it('renders the unit next to the value', () => {
+    render(<StatTile label="Latency" value={120} unit="ms" />);
+    expect(screen.getByText('120')).toBeInTheDocument();
+    expect(screen.getByText('ms')).toBeInTheDocument();
+  });
+
+  it('applies up/down colour to delta', () => {
+    const { container: up } = render(
+      <StatTile label="G" value={1} delta={{ value: 12, direction: 'up' }} />,
+    );
+    expect(up.querySelector('.bd-stat-tile__delta--up')).toBeInTheDocument();
+
+    const { container: down } = render(
+      <StatTile label="L" value={1} delta={{ value: 5, direction: 'down' }} />,
+    );
+    expect(down.querySelector('.bd-stat-tile__delta--down')).toBeInTheDocument();
+  });
+
+  it('renders an icon when supplied', () => {
+    render(<StatTile label="Stars" value={42} icon={<Star data-testid="icon" />} />);
+    expect(screen.getByTestId('icon')).toBeInTheDocument();
+  });
+
+  it('renders an anchor and navigates when href is set', () => {
+    render(<StatTile label="Open" value={1} href="/details" />);
+    const anchor = screen.getByRole('link');
+    expect(anchor).toHaveAttribute('href', '/details');
+  });
+
+  it('renders the skeleton and hides value while loading', () => {
+    const { container } = render(
+      <StatTile label="X" value="$1" loading delta={{ value: 1, direction: 'up' }} />,
+    );
+    expect(container.querySelector('.bd-stat-tile__skeleton')).toBeInTheDocument();
+    // delta must be suppressed under loading
+    expect(container.querySelector('.bd-stat-tile__delta')).toBeNull();
+  });
+
+  it('fires onClick when wrapped in a clickable surface', async () => {
+    // Direct click test on a NavLink equivalent — StatTile routes via href,
+    // so click is fired by the browser. We can assert the anchor exists and
+    // is clickable; for an explicit onClick we'd wrap in a div with handler.
+    const handler = vi.fn();
+    const { container } = render(
+      <div onClick={handler}>
+        <StatTile label="X" value={1} />
+      </div>,
+    );
+    const tile = container.querySelector('.bd-stat-tile');
+    expect(tile).toBeInTheDocument();
+    await userEvent.click(tile!);
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+});

package/bizar-dash/tests/ui/feedback/Badge.test.tsx

@@ -0,0 +1,41 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { Badge } from '../../../src/web/ui/feedback/Badge';
+
+describe('Badge', () => {
+  it('renders its children text', () => {
+    render(<Badge>Beta</Badge>);
+    expect(screen.getByText('Beta')).toBeInTheDocument();
+  });
+
+  it('applies the neutral variant by default', () => {
+    const { container } = render(<Badge>x</Badge>);
+    expect(container.querySelector('.bizar-badge--neutral')).toBeInTheDocument();
+  });
+
+  it.each([
+    ['info', 'bizar-badge--info'],
+    ['success', 'bizar-badge--success'],
+    ['warning', 'bizar-badge--warning'],
+    ['danger', 'bizar-badge--danger'],
+    ['accent', 'bizar-badge--accent'],
+  ] as const)('applies the %s variant modifier', (variant, cls) => {
+    const { container } = render(<Badge variant={variant}>x</Badge>);
+    expect(container.querySelector(`.${cls}`)).toBeInTheDocument();
+  });
+
+  it('applies the sm size modifier', () => {
+    const { container } = render(<Badge size="sm">x</Badge>);
+    expect(container.querySelector('.bizar-badge--sm')).toBeInTheDocument();
+  });
+
+  it('applies the md size by default', () => {
+    const { container } = render(<Badge>x</Badge>);
+    expect(container.querySelector('.bizar-badge--md')).toBeInTheDocument();
+  });
+
+  it('renders as a <span>', () => {
+    const { container } = render(<Badge>x</Badge>);
+    expect(container.querySelector('span.bizar-badge')).toBeInTheDocument();
+  });
+});

package/bizar-dash/tests/ui/feedback/Dialog.test.tsx

@@ -0,0 +1,99 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { Dialog } from '../../../src/web/ui/feedback/Dialog';
+
+describe('Dialog', () => {
+  it('renders nothing when open=false', () => {
+    render(
+      <Dialog open={false} onClose={() => {}}>
+        body
+      </Dialog>,
+    );
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('renders the dialog with title and description when open', () => {
+    render(
+      <Dialog
+        open
+        onClose={() => {}}
+        title="Confirm delete"
+        description="This cannot be undone."
+      >
+        Are you sure?
+      </Dialog>,
+    );
+    const dialog = screen.getByRole('dialog');
+    expect(dialog).toBeInTheDocument();
+    expect(screen.getByText('Confirm delete')).toBeInTheDocument();
+    expect(screen.getByText('This cannot be undone.')).toBeInTheDocument();
+    expect(screen.getByText('Are you sure?')).toBeInTheDocument();
+  });
+
+  it('closes when Escape is pressed', async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    render(
+      <Dialog open onClose={onClose} title="t">
+        body
+      </Dialog>,
+    );
+    await user.keyboard('{Escape}');
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not close on Escape when persistent', async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    render(
+      <Dialog open onClose={onClose} title="t" persistent>
+        body
+      </Dialog>,
+    );
+    await user.keyboard('{Escape}');
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it('closes when the close icon is clicked', async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    render(
+      <Dialog open onClose={onClose} title="t">
+        body
+      </Dialog>,
+    );
+    await user.click(screen.getByLabelText('Close dialog'));
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders the actions slot in the footer', () => {
+    render(
+      <Dialog
+        open
+        onClose={() => {}}
+        title="t"
+        actions={
+          <>
+            <button>Cancel</button>
+            <button>Confirm</button>
+          </>
+        }
+      >
+        body
+      </Dialog>,
+    );
+    expect(screen.getByText('Cancel')).toBeInTheDocument();
+    expect(screen.getByText('Confirm')).toBeInTheDocument();
+  });
+
+  it('sets aria-modal and role="dialog"', () => {
+    render(
+      <Dialog open onClose={() => {}} title="t">
+        body
+      </Dialog>,
+    );
+    const dialog = screen.getByRole('dialog');
+    expect(dialog).toHaveAttribute('aria-modal', 'true');
+  });
+});

package/bizar-dash/tests/ui/feedback/ProgressBar.test.tsx

@@ -0,0 +1,66 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { ProgressBar } from '../../../src/web/ui/feedback/ProgressBar';
+
+describe('ProgressBar', () => {
+  it('renders with role="progressbar"', () => {
+    render(<ProgressBar value={50} />);
+    expect(screen.getByRole('progressbar')).toBeInTheDocument();
+  });
+
+  it('reports aria-valuenow/aria-valuemin/aria-valuemax', () => {
+    render(<ProgressBar value={40} max={200} />);
+    const bar = screen.getByRole('progressbar');
+    expect(bar).toHaveAttribute('aria-valuenow', '40');
+    expect(bar).toHaveAttribute('aria-valuemin', '0');
+    expect(bar).toHaveAttribute('aria-valuemax', '200');
+  });
+
+  it('renders the fill at the correct percentage width', () => {
+    const { container } = render(<ProgressBar value={25} max={100} />);
+    const fill = container.querySelector('.bizar-progress__fill') as HTMLElement;
+    expect(fill.style.width).toBe('25%');
+  });
+
+  it('clamps value to max', () => {
+    const { container } = render(<ProgressBar value={150} max={100} />);
+    const fill = container.querySelector('.bizar-progress__fill') as HTMLElement;
+    expect(fill.style.width).toBe('100%');
+  });
+
+  it('clamps value to 0 (negative input)', () => {
+    const { container } = render(<ProgressBar value={-10} />);
+    const fill = container.querySelector('.bizar-progress__fill') as HTMLElement;
+    expect(fill.style.width).toBe('0%');
+  });
+
+  it('omits aria-valuenow for indeterminate', () => {
+    render(<ProgressBar indeterminate />);
+    const bar = screen.getByRole('progressbar');
+    expect(bar).not.toHaveAttribute('aria-valuenow');
+  });
+
+  it('applies the indeterminate modifier class', () => {
+    const { container } = render(<ProgressBar indeterminate />);
+    expect(
+      container.querySelector('.bizar-progress--indeterminate'),
+    ).toBeInTheDocument();
+  });
+
+  it('applies a size modifier', () => {
+    const { container } = render(<ProgressBar size="lg" />);
+    expect(container.querySelector('.bizar-progress--lg')).toBeInTheDocument();
+  });
+
+  it('renders the label above the bar when provided', () => {
+    render(<ProgressBar value={10} label="Uploading" />);
+    expect(screen.getByText('Uploading')).toBeInTheDocument();
+  });
+
+  it('applies a variant modifier to the fill', () => {
+    const { container } = render(<ProgressBar variant="danger" />);
+    expect(
+      container.querySelector('.bizar-progress__fill--danger'),
+    ).toBeInTheDocument();
+  });
+});

package/bizar-dash/tests/ui/feedback/StatusDot.test.tsx

@@ -0,0 +1,41 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { StatusDot } from '../../../src/web/ui/feedback/StatusDot';
+
+describe('StatusDot', () => {
+  it('renders with the success color when variant=success', () => {
+    const { container } = render(<StatusDot variant="success" />);
+    expect(container.querySelector('.bizar-status-dot--success')).toBeInTheDocument();
+  });
+
+  it.each([
+    ['neutral', 'bizar-status-dot--neutral'],
+    ['info', 'bizar-status-dot--info'],
+    ['warning', 'bizar-status-dot--warning'],
+    ['danger', 'bizar-status-dot--danger'],
+  ] as const)('applies the %s variant modifier', (variant, cls) => {
+    const { container } = render(<StatusDot variant={variant} />);
+    expect(container.querySelector(`.${cls}`)).toBeInTheDocument();
+  });
+
+  it('applies the pulse class when pulse is true', () => {
+    const { container } = render(<StatusDot pulse />);
+    expect(container.querySelector('.bizar-status-dot--pulse')).toBeInTheDocument();
+  });
+
+  it('applies the sm size class', () => {
+    const { container } = render(<StatusDot size="sm" />);
+    expect(container.querySelector('.bizar-status-dot--sm')).toBeInTheDocument();
+  });
+
+  it('uses role=status and aria-label when label is provided', () => {
+    render(<StatusDot variant="success" label="Live" />);
+    const dot = screen.getByRole('status');
+    expect(dot).toHaveAttribute('aria-label', 'Live');
+  });
+
+  it('renders as a <span>', () => {
+    const { container } = render(<StatusDot />);
+    expect(container.querySelector('span.bizar-status-dot')).toBeInTheDocument();
+  });
+});

package/bizar-dash/tests/ui/feedback/Toast.test.tsx

@@ -0,0 +1,124 @@
+import { act, render, screen, fireEvent } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { ToastProvider, useToast } from '../../../src/web/ui/feedback/Toast';
+
+function Harness(): React.JSX.Element {
+  const t = useToast();
+  return (
+    <div>
+      <button onClick={() => t.info('info-msg')}>info</button>
+      <button onClick={() => t.success('success-msg')}>success</button>
+      <button onClick={() => t.warning('warn-msg')}>warning</button>
+      <button onClick={() => t.error('error-msg')}>error</button>
+    </div>
+  );
+}
+
+describe('Toast (Bizar design system)', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('renders each of the four toast variants', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <Harness />
+      </ToastProvider>,
+    );
+
+    await user.click(screen.getByText('info'));
+    await user.click(screen.getByText('success'));
+    await user.click(screen.getByText('warning'));
+    await user.click(screen.getByText('error'));
+
+    expect(screen.getByText('info-msg')).toBeInTheDocument();
+    expect(screen.getByText('success-msg')).toBeInTheDocument();
+    expect(screen.getByText('warn-msg')).toBeInTheDocument();
+    expect(screen.getByText('error-msg')).toBeInTheDocument();
+  });
+
+  it('auto-dismisses info toasts after the default duration', () => {
+    vi.useFakeTimers();
+    render(
+      <ToastProvider>
+        <Harness />
+      </ToastProvider>,
+    );
+    fireEvent.click(screen.getByText('info'));
+    expect(screen.getByText('info-msg')).toBeInTheDocument();
+    act(() => {
+      vi.advanceTimersByTime(4000);
+    });
+    expect(screen.queryByText('info-msg')).not.toBeInTheDocument();
+  });
+
+  it('error toasts stick around longer than info toasts', () => {
+    vi.useFakeTimers();
+    render(
+      <ToastProvider>
+        <Harness />
+      </ToastProvider>,
+    );
+    fireEvent.click(screen.getByText('error'));
+    expect(screen.getByText('error-msg')).toBeInTheDocument();
+    // 4000ms is the default for info but errors should still be visible
+    // until the 6000ms mark.
+    act(() => {
+      vi.advanceTimersByTime(4000);
+    });
+    expect(screen.getByText('error-msg')).toBeInTheDocument();
+  });
+
+  it('dismisses on manual close button click', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <Harness />
+      </ToastProvider>,
+    );
+    await user.click(screen.getByText('info'));
+    expect(screen.getByText('info-msg')).toBeInTheDocument();
+    await user.click(screen.getByLabelText('Dismiss notification'));
+    expect(screen.queryByText('info-msg')).not.toBeInTheDocument();
+  });
+
+  it('caps the visible queue at 5 and evicts the oldest', async () => {
+    const user = userEvent.setup();
+    function SpamHarness(): React.JSX.Element {
+      const t = useToast();
+      return (
+        <button
+          onClick={() => {
+            for (let i = 0; i < 7; i++) t.info(`toast-${i}`);
+          }}
+        >
+          spam
+        </button>
+      );
+    }
+    render(
+      <ToastProvider>
+        <SpamHarness />
+      </ToastProvider>,
+    );
+    await user.click(screen.getByText('spam'));
+    // Only the last 5 should remain visible (indices 2..6).
+    expect(screen.queryByText('toast-0')).not.toBeInTheDocument();
+    expect(screen.queryByText('toast-1')).not.toBeInTheDocument();
+    expect(screen.getByText('toast-2')).toBeInTheDocument();
+    expect(screen.getByText('toast-6')).toBeInTheDocument();
+  });
+
+  it('useToast throws when used outside a provider', () => {
+    function Orphan(): React.JSX.Element {
+      useToast();
+      return <></>;
+    }
+    // Suppress React's error boundary console output for this expected throw.
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    expect(() => render(<Orphan />)).toThrow(/ToastProvider/);
+    spy.mockRestore();
+  });
+});

package/bizar-dash/tests/ui/feedback/Tooltip.test.tsx

@@ -0,0 +1,102 @@
+import { act, render, screen, fireEvent } from '@testing-library/react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { Tooltip } from '../../../src/web/ui/feedback/Tooltip';
+
+describe('Tooltip', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('shows the popup on pointerEnter after the default delay', () => {
+    vi.useFakeTimers();
+    render(
+      <Tooltip content="Hello world">
+        <button>trigger</button>
+      </Tooltip>,
+    );
+    fireEvent.pointerEnter(screen.getByText('trigger'));
+    expect(screen.queryByRole('tooltip')).not.toBeInTheDocument();
+    act(() => {
+      vi.advanceTimersByTime(200);
+    });
+    expect(screen.getByRole('tooltip')).toBeInTheDocument();
+    expect(screen.getByRole('tooltip')).toHaveTextContent('Hello world');
+  });
+
+  it('hides the popup on pointerLeave', () => {
+    vi.useFakeTimers();
+    render(
+      <Tooltip content="Hi">
+        <button>trigger</button>
+      </Tooltip>,
+    );
+    fireEvent.pointerEnter(screen.getByText('trigger'));
+    act(() => {
+      vi.advanceTimersByTime(200);
+    });
+    expect(screen.getByRole('tooltip')).toBeInTheDocument();
+    fireEvent.pointerLeave(screen.getByText('trigger'));
+    expect(screen.queryByRole('tooltip')).not.toBeInTheDocument();
+  });
+
+  it('sets aria-describedby on the wrapped child while open', () => {
+    vi.useFakeTimers();
+    render(
+      <Tooltip content="hi">
+        <button>trigger</button>
+      </Tooltip>,
+    );
+    const trigger = screen.getByText('trigger');
+    expect(trigger).not.toHaveAttribute('aria-describedby');
+    fireEvent.pointerEnter(trigger);
+    act(() => {
+      vi.advanceTimersByTime(200);
+    });
+    const popup = screen.getByRole('tooltip');
+    expect(trigger.getAttribute('aria-describedby')).toBe(popup.id);
+  });
+
+  it('respects a custom delay', () => {
+    vi.useFakeTimers();
+    render(
+      <Tooltip content="lazy" delay={500}>
+        <button>trigger</button>
+      </Tooltip>,
+    );
+    fireEvent.pointerEnter(screen.getByText('trigger'));
+    expect(screen.queryByRole('tooltip')).not.toBeInTheDocument();
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    expect(screen.getByRole('tooltip')).toBeInTheDocument();
+  });
+
+  it('applies a side modifier to the popup', () => {
+    vi.useFakeTimers();
+    const { container } = render(
+      <Tooltip content="hi" side="bottom">
+        <button>trigger</button>
+      </Tooltip>,
+    );
+    fireEvent.pointerEnter(screen.getByText('trigger'));
+    act(() => {
+      vi.advanceTimersByTime(200);
+    });
+    const popup = container.querySelector('.bizar-tooltip__popup--bottom');
+    expect(popup).toBeInTheDocument();
+  });
+
+  it('does not show the popup before the delay elapses', () => {
+    vi.useFakeTimers();
+    render(
+      <Tooltip content="soon" delay={100}>
+        <button>trigger</button>
+      </Tooltip>,
+    );
+    fireEvent.pointerEnter(screen.getByText('trigger'));
+    act(() => {
+      vi.advanceTimersByTime(50);
+    });
+    expect(screen.queryByRole('tooltip')).not.toBeInTheDocument();
+  });
+});

package/bizar-dash/tests/ui/layout/AppShell.test.tsx

@@ -0,0 +1,50 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { AppShell } from '../../../src/web/ui/layout/AppShell';
+
+describe('AppShell', () => {
+  it('renders topbar, sidebar, and main content', () => {
+    render(
+      <AppShell
+        topbar={<div>Topbar slot</div>}
+        sidebar={<div>Sidebar slot</div>}
+      >
+        <div>Page body</div>
+      </AppShell>,
+    );
+    expect(screen.getByText('Topbar slot')).toBeInTheDocument();
+    expect(screen.getByText('Sidebar slot')).toBeInTheDocument();
+    expect(screen.getByText('Page body')).toBeInTheDocument();
+  });
+
+  it('applies the collapsed modifier when sidebarCollapsed=true', () => {
+    const { container } = render(
+      <AppShell sidebar={<div>Sidebar slot</div>} sidebarCollapsed>
+        <div>Body</div>
+      </AppShell>,
+    );
+    const sidebar = container.querySelector('.bizar-app-shell__sidebar');
+    expect(sidebar).toBeInTheDocument();
+    expect(sidebar?.className).toContain('bizar-app-shell__sidebar--collapsed');
+    expect(sidebar).toHaveAttribute('aria-hidden', 'true');
+  });
+
+  it('renders without a sidebar when none provided', () => {
+    const { container } = render(<AppShell>Body only</AppShell>);
+    expect(
+      container.querySelector('.bizar-app-shell__sidebar'),
+    ).not.toBeInTheDocument();
+    expect(screen.getByText('Body only')).toBeInTheDocument();
+  });
+
+  it('places children inside the main content area', () => {
+    const { container } = render(
+      <AppShell>
+        <p>In main</p>
+      </AppShell>,
+    );
+    const main = container.querySelector('.bizar-app-shell__main');
+    expect(main).toBeInTheDocument();
+    expect(main?.contains(screen.getByText('In main'))).toBe(true);
+  });
+});