feat: Add experimental reolink media support (#1694)

* feat: Add experimental rich reolink support.

* Formatting fix

tests/utils/ha/index.test.ts

@@ -1,8 +1,10 @@
 import { HomeAssistant } from '@dermotduffy/custom-card-helpers';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import {
+  canonicalizeHAURL,
   getEntityIcon,
   hasHAConnectionStateChanged,
+  isHARelativeURL,
 } from '../../../src/utils/ha/index.js';
 import { createHASS, createStateEntity } from '../../test-utils.js';
 
@@ -67,3 +69,32 @@ describe('getEntityIcon', () => {
     expect(getEntityIcon(createHASS(), 'camera.test')).toBe('mdi:video');
   });
 });
+
+describe('isHARelativeURL', () => {
+  it('should return true when URL is HA relative', () => {
+    expect(isHARelativeURL('/api/foo')).toBeTruthy();
+  });
+
+  it('should return false when URL is not HA relative', () => {
+    expect(isHARelativeURL('http://localhost/api/foo')).toBeFalsy();
+  });
+});
+
+describe('canonicalizeHAURL', () => {
+  it('should return canonicalized HA url', () => {
+    const hass = createHASS();
+    vi.mocked(hass.hassUrl).mockReturnValue('http://localhost:8123/foo/bar');
+
+    expect(canonicalizeHAURL(hass, '/api/foo')).toBe('http://localhost:8123/foo/bar');
+  });
+
+  it('should return untouched URL when not HA relative', () => {
+    expect(canonicalizeHAURL(createHASS(), 'http://localhost:8123/foo/bar')).toBe(
+      'http://localhost:8123/foo/bar',
+    );
+  });
+
+  it('should return null without a URL', () => {
+    expect(canonicalizeHAURL(createHASS())).toBeNull();
+  });
+});

tests/utils/ha/integration/index.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getIntegrationManifest } from '../../../../src/utils/ha/integration';
+import { integrationManifestSchema } from '../../../../src/utils/ha/integration/types';
+import { homeAssistantWSRequest } from '../../../../src/utils/ha/ws-request';
+import { createHASS } from '../../../test-utils';
+
+vi.mock('../../../../src/utils/ha/ws-request');
+
+describe('getIntegrationManifest', () => {
+  it('should get integration manifest', async () => {
+    const hass = createHASS();
+    await getIntegrationManifest(hass, 'INTEGRATION');
+    expect(homeAssistantWSRequest).toHaveBeenCalledWith(
+      hass,
+      integrationManifestSchema,
+      { type: 'manifest/get', integration: 'INTEGRATION' },
+    );
+  });
+});

tests/utils/ha/registry/device/index.test.ts

@@ -1,12 +1,12 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { homeAssistantWSRequest } from '../../../../../src/utils/ha';
-import { createHASS, createRegistryDevice } from '../../../../test-utils.js';
 import {
   createDeviceRegistryCache,
   DeviceRegistryManager,
 } from '../../../../../src/utils/ha/registry/device';
+import { homeAssistantWSRequest } from '../../../../../src/utils/ha/ws-request';
+import { createHASS, createRegistryDevice } from '../../../../test-utils.js';
 
-vi.mock('../../../../../src/utils/ha');
+vi.mock('../../../../../src/utils/ha/ws-request');
 vi.spyOn(global.console, 'warn').mockImplementation(() => true);
 
 describe('DeviceRegistryManager', () => {

tests/utils/ha/registry/entity/index.test.ts

@@ -1,12 +1,12 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { homeAssistantWSRequest } from '../../../../../src/utils/ha';
 import {
   createEntityRegistryCache,
   EntityRegistryManager,
 } from '../../../../../src/utils/ha/registry/entity';
+import { homeAssistantWSRequest } from '../../../../../src/utils/ha/ws-request';
 import { createHASS, createRegistryEntity } from '../../../../test-utils.js';
 
-vi.mock('../../../../../src/utils/ha');
+vi.mock('../../../../../src/utils/ha/ws-request');
 vi.spyOn(global.console, 'warn').mockImplementation(() => true);
 
 describe('EntityRegistryManager', () => {

tests/utils/ha/web-proxy.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+import { CameraProxyConfig } from '../../../src/camera-manager/types.js';
+import {
+  addDynamicProxyURL,
+  getWebProxiedURL,
+  shouldUseWebProxy,
+} from '../../../src/utils/ha/web-proxy.js';
+import { createHASS } from '../../test-utils.js';
+
+describe('getWebProxiedURL', () => {
+  it('should return proxied URL with v != 0', () => {
+    expect(getWebProxiedURL('http://example.com', 2)).toBe(
+      '/api/hass_web_proxy/v2/?url=http%3A%2F%2Fexample.com',
+    );
+  });
+
+  it('should return proxied URL with default v', () => {
+    expect(getWebProxiedURL('http://example.com')).toBe(
+      '/api/hass_web_proxy/v0/?url=http%3A%2F%2Fexample.com',
+    );
+  });
+});
+
+describe('shouldUseWebProxy', () => {
+  const createProxyConfig = (
+    config: Partial<CameraProxyConfig> = {},
+  ): CameraProxyConfig => ({
+    media: true,
+    ssl_verification: true,
+    ssl_ciphers: 'default',
+    dynamic: true,
+    ...config,
+  });
+
+  it('should return false without a the proxy installed', () => {
+    const hass = createHASS();
+    hass.config.components = [];
+
+    expect(shouldUseWebProxy(hass, createProxyConfig())).toBe(false);
+  });
+
+  it('should return when proxy config does not want proxying', () => {
+    const hass = createHASS();
+    hass.config.components = ['hass_web_proxy'];
+
+    const proxyConfig = createProxyConfig({ media: false });
+    expect(shouldUseWebProxy(hass, proxyConfig, 'media')).toBe(false);
+  });
+
+  it('should return when proxy config does want proxying', () => {
+    const hass = createHASS();
+    hass.config.components = ['hass_web_proxy'];
+
+    const proxyConfig = createProxyConfig({ media: true });
+    expect(shouldUseWebProxy(hass, proxyConfig, 'media')).toBe(true);
+  });
+});
+
+describe('addDynamicProxyURL', () => {
+  it('should add dynamic proxy URL', async () => {
+    const hass = createHASS();
+
+    await addDynamicProxyURL(hass, 'http://example.com', {
+      urlID: 'id',
+      sslVerification: true,
+      sslCiphers: 'modern',
+      openLimit: 5,
+      ttl: 60,
+      allowUnauthenticated: false,
+    });
+
+    expect(hass.callService).toHaveBeenCalledWith(
+      'hass_web_proxy',
+      'create_proxied_url',
+      {
+        url_pattern: 'http://example.com',
+        url_id: 'id',
+        ssl_verification: true,
+        ssl_ciphers: 'modern',
+        open_limit: 5,
+        ttl: 60,
+        allow_unauthenticated: false,
+      },
+    );
+  });
+});