tabletcommand-backend-models 7.4.32 → 7.4.34

package/src/test/audio-stream-authentication.ts

@@ -0,0 +1,81 @@
+import { assert } from "chai";
+import "mocha";
+
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("AudioStreamAuthentication", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let testItem: Partial<m.AudioStreamAuthentication>;
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    const mock = mockModule({
+      mongoose
+    });
+    testItem = mock.audioStreamAuthentication;
+    await mock.cleanup();
+  });
+
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("is saved", async function() {
+    assert.isObject(testItem);
+    const item = new models.AudioStreamAuthentication(testItem);
+    const sut = await item.save();
+    assert.isNotNull(sut._id);
+    assert.isNotNull(sut.id);
+    assert.equal(sut._id.toString(), testItem._id?.toString());
+
+    assert.equal(sut.name, "test-stream");
+    assert.equal(sut.rotateInterval, 3600);
+
+    assert.isObject(sut.secret);
+    assert.equal(sut.secret?.iv, testItem.secret?.iv);
+    assert.equal(sut.secret?.encryptedData, testItem.secret?.encryptedData);
+  });
+
+  it("enforces unique name constraint", async function() {
+    const item1 = new models.AudioStreamAuthentication(testItem);
+    await item1.save();
+
+    const item2 = new models.AudioStreamAuthentication({
+      name: "test-stream",
+      secret: {
+        iv: "different-iv",
+        encryptedData: "different-data"
+      },
+      rotateInterval: 7200,
+    });
+
+    try {
+      await item2.save();
+      assert.fail("Should have thrown duplicate key error");
+    } catch (error) {
+      assert.include(String((error as Error).message), "duplicate key");
+    }
+  });
+
+  it("allows different names", async function() {
+    const item1 = new models.AudioStreamAuthentication(testItem);
+    await item1.save();
+
+    const item2 = new models.AudioStreamAuthentication({
+      name: "different-stream",
+      secret: {
+        iv: "different-iv",
+        encryptedData: "different-data"
+      },
+      rotateInterval: 7200,
+    });
+
+    const sut = await item2.save();
+    assert.isNotNull(sut._id);
+    assert.equal(sut.name, "different-stream");
+    assert.equal(sut.rotateInterval, 7200);
+  });
+});

package/src/test/audio-stream.ts

@@ -0,0 +1,230 @@
+import { assert } from "chai";
+import "mocha";
+
+import * as m from "../index";
+import * as config from "./config";
+import mockModule from "./mock";
+
+describe("AudioStream", function() {
+  let models: m.BackendModels, mongoose: m.MongooseModule;
+  let authRecord: m.AudioStreamAuthentication;
+
+  beforeEach(async function() {
+    const c = await m.connect(config.url);
+    models = c.models;
+    mongoose = c.mongoose;
+    const mock = mockModule({
+      mongoose
+    });
+    await mock.cleanup();
+
+    // Create an AudioStreamAuthentication record to reference
+    const authItem = new models.AudioStreamAuthentication({
+      name: "test-auth-record",
+      secret: {
+        iv: "test-iv",
+        encryptedData: "test-encrypted-data"
+      },
+      rotateInterval: 3600,
+    });
+    authRecord = await authItem.save();
+  });
+
+  afterEach(async function() {
+    await mongoose.disconnect();
+  });
+
+  it("saves Department with AudioStream authentication", async function() {
+    const department = new models.Department({
+      department: "Test Fire Department",
+      apikey: "test-api-key-123",
+      audioConfiguration: [
+        {
+          group: "Fire Dispatch",
+          order: 1,
+          streams: [
+            {
+              description: "Main Dispatch Channel",
+              channel: "CH1",
+              url: "https://example.com/stream1",
+              order: 1,
+              authentication: {
+                authId: authRecord._id,
+                app: "test-app",
+                streamKey: "stream-key-123",
+              }
+            }
+          ]
+        }
+      ]
+    });
+
+    const saved = await department.save();
+
+    assert.isNotNull(saved._id);
+    assert.isArray(saved.audioConfiguration);
+    assert.equal(saved.audioConfiguration.length, 1);
+
+    const group = saved.audioConfiguration[0];
+    if (!group) {
+      assert.fail("Group should be defined");
+      return;
+    }
+    assert.equal(group.group, "Fire Dispatch");
+    assert.equal(group.order, 1);
+    assert.equal(group.streams.length, 1);
+
+    const stream = group.streams[0];
+    if (!stream) {
+      assert.fail("Stream should be defined");
+      return;
+    }
+    assert.equal(stream.description, "Main Dispatch Channel");
+    assert.equal(stream.channel, "CH1");
+    assert.equal(stream.url, "https://example.com/stream1");
+    assert.equal(stream.order, 1);
+
+    // Verify authentication
+    assert.isObject(stream.authentication);
+    if (!stream.authentication) {
+      assert.fail("Authentication should be defined");
+      return;
+    }
+    assert.equal(stream.authentication.authId.toString(), authRecord._id.toString());
+    assert.equal(stream.authentication.app, "test-app");
+    assert.equal(stream.authentication.streamKey, "stream-key-123");
+  });
+
+  it("saves Department with AudioStream without authentication", async function() {
+    const department = new models.Department({
+      department: "Test Fire Department 2",
+      apikey: "test-api-key-456",
+      audioConfiguration: [
+        {
+          group: "Police Dispatch",
+          order: 1,
+          streams: [
+            {
+              description: "Public Channel",
+              channel: "CH2",
+              url: "https://example.com/stream2",
+              order: 1,
+            }
+          ]
+        }
+      ]
+    });
+
+    const saved = await department.save();
+
+    assert.isNotNull(saved._id);
+    assert.isArray(saved.audioConfiguration);
+    assert.equal(saved.audioConfiguration.length, 1);
+
+    const group = saved.audioConfiguration[0];
+    if (!group) {
+      assert.fail("Group should be defined");
+      return;
+    }
+    const stream = group.streams[0];
+    if (!stream) {
+      assert.fail("Stream should be defined");
+      return;
+    }
+    assert.equal(stream.description, "Public Channel");
+    assert.isUndefined(stream.authentication);
+  });
+
+  it("saves Department with mixed AudioStreams (with and without auth)", async function() {
+    const department = new models.Department({
+      department: "Test Mixed Department",
+      apikey: "test-api-key-789",
+      audioConfiguration: [
+        {
+          group: "Dispatch Channels",
+          order: 1,
+          streams: [
+            {
+              description: "Secure Channel",
+              channel: "CH1",
+              url: "https://example.com/secure",
+              order: 1,
+              authentication: {
+                authId: authRecord._id,
+                app: "secure-app",
+                streamKey: "secure-key-456",
+              }
+            },
+            {
+              description: "Public Channel",
+              channel: "CH2",
+              url: "https://example.com/public",
+              order: 2,
+            }
+          ]
+        }
+      ]
+    });
+
+    const saved = await department.save();
+
+    const group = saved.audioConfiguration[0];
+    if (!group) {
+      assert.fail("Group should be defined");
+      return;
+    }
+    assert.equal(group.streams.length, 2);
+
+    const secureStream = group.streams[0];
+    if (!secureStream) {
+      assert.fail("Secure stream should be defined");
+      return;
+    }
+    assert.isObject(secureStream.authentication);
+    if (!secureStream.authentication) {
+      assert.fail("Authentication should be defined");
+      return;
+    }
+    assert.equal(secureStream.authentication.app, "secure-app");
+
+    const publicStream = group.streams[1];
+    if (!publicStream) {
+      assert.fail("Public stream should be defined");
+      return;
+    }
+    assert.isUndefined(publicStream.authentication);
+  });
+
+  it("validates required authentication fields when present", async function() {
+    const department = new models.Department({
+      department: "Test Invalid Department",
+      apikey: "test-api-key-invalid",
+      audioConfiguration: [
+        {
+          group: "Test Group",
+          order: 1,
+          streams: [
+            {
+              description: "Invalid Stream",
+              channel: "CH1",
+              url: "https://example.com/invalid",
+              order: 1,
+              authentication: {
+                authId: authRecord._id,
+                app: "test-app",
+                // Missing streamKey - should fail validation
+              } as unknown as { authId: m.AudioStreamAuthentication["_id"]; app: string; streamKey: string; }
+            }
+          ]
+        }
+      ]
+    });
+
+    try {
+      await department.save();
+      assert.fail("Should have thrown validation error");
+    } catch (error) {
+      assert.include(String((error as Error).message), "streamKey");
+    }
+  });
+});

package/src/test/department.ts

@@ -15,6 +15,7 @@ describe("Department", function() {
       mongoose
     });
     testItem = mock.department;
+    await mock.cleanup();
   });
 
   afterEach(async function() {

package/src/test/mock.ts

@@ -939,6 +939,16 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     },
   };
 
+  const audioStreamAuthentication = {
+    _id: new mongoose.Types.ObjectId(),
+    name: "test-stream",
+    secret: {
+      iv: "a1b2c3d4e5f6",
+      encryptedData: "encrypted-secret-data-here"
+    },
+    rotateInterval: 3600,
+  };
+
   const gstMapping = {
     _id: new mongoose.Types.ObjectId(),
     departmentId: "d123",
@@ -1475,6 +1485,7 @@ export default function mockModule(dependencies: { mongoose: Mongoose; }) {
     agency,
     arcGISGroup,
     assignment,
+    audioStreamAuthentication,
     battalion,
     cadIncident,
     cadIncidentBlock,

package/src/types/audio-stream-authentication.ts

@@ -0,0 +1,9 @@
+import { Types } from "mongoose";
+import { EncryptedDataType } from "./common";
+
+export interface AudioStreamAuthenticationType {
+  _id: Types.ObjectId,
+  secret: EncryptedDataType,
+  rotateInterval: number,
+  name: string,
+}

package/src/types/department.ts

@@ -243,11 +243,18 @@ export interface WebDisclaimerType {
   enabled: boolean,
 }
 
+export interface AudioStreamAuthType {
+  authId: Types.ObjectId,
+  app: string,
+  streamKey: string,
+}
+
 export interface AudioStreamType {
   description: string,
   channel: string,
   url: string,
   order: number,
+  authentication?: AudioStreamAuthType,
 }
 
 export interface AudioStreamGroupType {