unifi/test/test.ts

import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as unifi from '../ts/index.js';

// =============================================================================
// UNIT TESTS - No credentials needed, tests class structure and exports
// =============================================================================

tap.test('should export all main classes', async () => {
  // Entry point classes
  expect(unifi.UnifiAccount).toBeDefined();
  expect(unifi.UnifiController).toBeDefined();
  expect(unifi.UnifiProtect).toBeDefined();
  expect(unifi.UnifiAccess).toBeDefined();

  // Manager classes
  expect(unifi.SiteManager).toBeDefined();
  expect(unifi.HostManager).toBeDefined();
  expect(unifi.DeviceManager).toBeDefined();
  expect(unifi.ClientManager).toBeDefined();
  expect(unifi.CameraManager).toBeDefined();
  expect(unifi.DoorManager).toBeDefined();

  // Resource classes
  expect(unifi.UnifiSite).toBeDefined();
  expect(unifi.UnifiHost).toBeDefined();
  expect(unifi.UnifiDevice).toBeDefined();
  expect(unifi.UnifiClient).toBeDefined();
  expect(unifi.UnifiCamera).toBeDefined();
  expect(unifi.UnifiDoor).toBeDefined();

  // HTTP client
  expect(unifi.UnifiHttp).toBeDefined();
});

tap.test('should instantiate UnifiAccount', async () => {
  const account = new unifi.UnifiAccount({
    apiKey: 'test-api-key',
  });

  expect(account).toBeInstanceOf(unifi.UnifiAccount);
  expect(account.siteManager).toBeInstanceOf(unifi.SiteManager);
  expect(account.hostManager).toBeInstanceOf(unifi.HostManager);
});

tap.test('should instantiate UnifiController', async () => {
  const controller = new unifi.UnifiController({
    host: '192.168.1.1',
    username: 'admin',
    password: 'password',
    controllerType: 'unifi-os',
  });

  expect(controller).toBeInstanceOf(unifi.UnifiController);
  expect(controller.deviceManager).toBeInstanceOf(unifi.DeviceManager);
  expect(controller.clientManager).toBeInstanceOf(unifi.ClientManager);
  expect(controller.isAuthenticated()).toBeFalse();
});

tap.test('should instantiate UnifiProtect', async () => {
  const protect = new unifi.UnifiProtect({
    host: '192.168.1.1',
    username: 'admin',
    password: 'password',
  });

  expect(protect).toBeInstanceOf(unifi.UnifiProtect);
  expect(protect.cameraManager).toBeInstanceOf(unifi.CameraManager);
  expect(protect.isAuthenticated()).toBeFalse();
});

tap.test('should instantiate UnifiAccess', async () => {
  const access = new unifi.UnifiAccess({
    host: '192.168.1.1',
    token: 'test-bearer-token',
  });

  expect(access).toBeInstanceOf(unifi.UnifiAccess);
  expect(access.doorManager).toBeInstanceOf(unifi.DoorManager);
});

tap.test('should create UnifiSite from API object', async () => {
  const site = unifi.UnifiSite.createFromApiObject({
    siteId: 'site-123',
    name: 'Test Site',
    description: 'A test site',
    isDefault: true,
    timezone: 'UTC',
  });

  expect(site.siteId).toEqual('site-123');
  expect(site.name).toEqual('Test Site');
  expect(site.isDefault).toBeTrue();
});

tap.test('should create UnifiDevice from API object', async () => {
  const device = unifi.UnifiDevice.createFromApiObject({
    _id: 'dev-123',
    mac: '00:11:22:33:44:55',
    model: 'UAP-AC-Pro',
    type: 'uap',
    name: 'Living Room AP',
    site_id: 'default',
    adopted: true,
    ip: '192.168.1.100',
    state: 1,
    version: '6.0.0',
  });

  expect(device._id).toEqual('dev-123');
  expect(device.mac).toEqual('00:11:22:33:44:55');
  expect(device.isOnline()).toBeTrue();
  expect(device.isAccessPoint()).toBeTrue();
  expect(device.isSwitch()).toBeFalse();
  expect(device.getDisplayName()).toEqual('Living Room AP');
});

tap.test('should create UnifiClient from API object', async () => {
  const client = unifi.UnifiClient.createFromApiObject({
    _id: 'client-123',
    mac: 'aa:bb:cc:dd:ee:ff',
    site_id: 'default',
    is_wired: false,
    hostname: 'laptop',
    ip: '192.168.1.50',
    essid: 'HomeWiFi',
    signal: -55,
    tx_bytes: 1073741824,
    rx_bytes: 2147483648,
  });

  expect(client._id).toEqual('client-123');
  expect(client.isWireless()).toBeTrue();
  expect(client.getConnectionType()).toEqual('Wireless (HomeWiFi)');
  expect(client.getSignalQuality()).toEqual('Good');
  expect(client.getDataUsage()).toEqual(3221225472);
});

tap.test('should create UnifiCamera from API object', async () => {
  const camera = unifi.UnifiCamera.createFromApiObject({
    id: 'cam-123',
    mac: '00:11:22:33:44:66',
    host: '192.168.1.101',
    name: 'Front Door',
    type: 'UVC-G4-Doorbell',
    state: 'CONNECTED',
    isConnected: true,
    isRecording: true,
    featureFlags: {
      hasSmartDetect: true,
      hasMic: true,
      hasSpeaker: true,
    },
    lastMotion: Date.now() - 30000,
  });

  expect(camera.id).toEqual('cam-123');
  expect(camera.isOnline()).toBeTrue();
  expect(camera.isDoorbell()).toBeTrue();
  expect(camera.hasSmartDetect()).toBeTrue();
  expect(camera.hasRecentMotion(60)).toBeTrue();
});

tap.test('should create UnifiDoor from API object', async () => {
  const door = unifi.UnifiDoor.createFromApiObject({
    unique_id: 'door-123',
    name: 'Main Entrance',
    alias: 'Front Door',
    door_lock_relay_status: 'lock',
    door_position_status: 'close',
  });

  expect(door.unique_id).toEqual('door-123');
  expect(door.getDisplayName()).toEqual('Front Door');
  expect(door.isLocked()).toBeTrue();
  expect(door.isClosed()).toBeTrue();
  expect(door.getStatus()).toEqual('Locked, Closed');
});

export default tap.start();