Initial commit

Lts/Services/AudioVideoManagement/UnitTests/audio_video_handler_impl_test.cpp

@@ -0,0 +1,602 @@
+/**
+  * @RDE_HEADER@
+  * AudioVideoHandlerImplTest
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Fröbel, NLSE, 2018-01-09
+  */
+
+#include "audio_video_handler_impl_test.h"
+#include <AudioVideoManagement/audio_video_handler_impl.h>
+#include <AudioVideoManagement/asset.h>
+#include <AudioVideoManagement/mounting_point.h>
+#include <AudioVideoManagement/exercise.h>
+#include <AudioVideoManagement/avm.hpp>
+#include <InfrastructureManagement/ism.hpp>
+#include <LtsUtilsCore/json_object.h>
+#include <QtGlobal>
+#include <boost/optional.hpp>
+#include <map>
+#include <string>
+#include <vector>
+#include <utility>
+#include <memory>
+
+using namespace AudioVideoManagement;
+using namespace InfrastructureManagement;
+using LtsUtils::JsonObject;
+
+namespace
+{
+
+int streamCount(const Streams &streams)
+{
+  if (streams.second)
+    return 2;
+  return 1;
+}
+
+class DbMock : public AudioVideoHandlerImpl::IDbProxy
+{
+public:
+  const Streams &findStreams(AssetId id) const override
+  {
+    auto   found = m_cache.find(id);
+    Q_ASSERT(found != m_cache.end());
+    return found->second;
+  }
+
+  const Streams &findStreams(Asset *asset) override
+  {
+    Q_ASSERT(asset);
+    return findStreams(asset->data().id());
+  }
+
+  bool isEmpty() const { return m_cache.empty(); }
+
+  int  deviceCount() const    { return m_cache.size(); }
+
+  int  streamCount() const
+  {
+    int   count = 0;
+    for (const auto &streams: m_cache)
+      count += ::streamCount(streams.second);
+    return count;
+  }
+
+  void insert(Streams &streams) override
+  {
+    streams.first.id = ++m_nextId;
+    if (streams.second)
+      streams.second->id = ++m_nextId;
+    link(streams);
+    auto   insertResult = m_cache.insert(std::make_pair(streams.assetId(), streams));
+    Q_ASSERT(insertResult.second);
+  }
+
+  /**
+   * We simply maintain the ids or give a new id to a possibly new entry.
+   */
+  void update(Streams &newStreams) override
+  {
+    auto   found = m_cache.find(newStreams.assetId());
+    Q_ASSERT(found != m_cache.end());
+    const Streams   oldStreams = found->second;
+
+    newStreams.first.id = oldStreams.first.id;
+    if (newStreams.second)
+    {
+      if (oldStreams.second)
+        newStreams.second->id = oldStreams.second->id;
+      else
+        newStreams.second->id = ++m_nextId;
+    }
+
+    link(newStreams);
+    found->second = newStreams; // update cache
+  }
+
+  void remove(Asset *asset) override
+  {
+    Q_ASSERT(asset);
+    auto   count = m_cache.erase(asset->data().id());
+    Q_ASSERT(count == 1);
+  }
+
+private:
+  void link(Streams& streams)
+  {
+    if (!streams.second)
+    {
+      streams.first.link = 0;
+      return;
+    }
+
+    streams.first.link = streams.second->id;
+    streams.second->link = streams.first.id;
+  }
+
+  int                          m_nextId{0};
+  std::map<AssetId, Streams>   m_cache;
+};
+
+
+class DtsSpy : public AudioVideoHandlerImpl::IDtsProxy
+{
+public:
+  void publish(const Stream &stream) override
+  {
+    m_published.push_back(stream);
+  }
+
+  void remove(uint64_t streamId) override
+  {
+    m_removed.push_back(streamId);
+  }
+
+  bool isEmpty() const { return m_published.empty() && m_removed.empty(); }
+
+  void reset()
+  {
+    m_published.clear();
+    m_removed.clear();
+  }
+
+  std::vector<Stream>     m_published;
+  std::vector<uint64_t>   m_removed;
+};
+
+
+Asset *createAsset(int id, MountingPointType mpType, const std::string &properties)
+{
+  InstrumentationAsset   data;
+  data.id(id);
+  data.name(QStringLiteral("ASSET_000%1").arg(id).toUtf8().constData());
+  data.hostname(QStringLiteral("host_000%1").arg(id).toUtf8().constData());
+  data.mountingPointTypeId(mpType);
+  data.properties(properties);
+
+  return new Asset(data);
+}
+
+MountingPoint *createMountingPoint(int id, MountingPointType mpType)
+{
+  StructureElement   data;
+  data.id(id);
+  data.name(QStringLiteral("MP_000%1").arg(id).toUtf8().constData());
+  data.displayName(QStringLiteral("display name %1").arg(id).toUtf8().constData());
+  data.structureElementTypeId(StructureElementType::MountingPoint);
+  data.mountingPointTypeId(mpType);
+  data.properties("{}");
+
+  return new MountingPoint(data);
+}
+
+void setProperties(Asset *asset, const std::string &newProperties)
+{
+  Q_ASSERT(asset);
+  InstrumentationAsset   data = asset->data();
+  data.properties(newProperties);
+  asset->update(data);
+}
+
+void setDisplayName(MountingPoint *mp, const std::string &newDisplayName)
+{
+  Q_ASSERT(mp);
+  StructureElement   data = mp->data();
+  data.displayName(newDisplayName);
+  mp->update(data);
+}
+
+void setRecording(MountingPoint *mp, bool on)
+{
+  Q_ASSERT(mp);
+  StructureElement   data = mp->data();
+  if (on)
+    data.properties(R"({"record": true})");
+  else
+    data.properties(R"({"record": false})");
+  mp->update(data);
+}
+
+void mount(Asset *asset, MountingPoint *mp)
+{
+  Q_ASSERT(asset);
+  InstrumentationAsset   data = asset->data();
+  data.assetStateId(InstrumentationAssetState::Mounted);
+  asset->update(data);
+  asset->mount(mp);
+}
+
+Database::AvmDeviceConfig   dcEntry(int64_t id, const std::string &context, const std::string &type, const std::string &name, const std::string &controller, const std::string &definition, int32_t link)
+{
+  Database::AvmDeviceConfig   dc;
+  dc.id         = id;
+  dc.context    = QString::fromStdString(context);
+  dc.type       = QString::fromStdString(type);
+  dc.name       = QString::fromStdString(name);
+  dc.controller = QString::fromStdString(controller);
+  dc.definition = QString::fromStdString(definition);
+  dc.link       = link;
+  return dc;
+}
+
+bool operator==(const Database::AvmDeviceConfig &lhs, const Database::AvmDeviceConfig &rhs)
+{
+  if (lhs.id != rhs.id)
+    return false;
+  if (lhs.context != rhs.context)
+    return false;
+  if (lhs.type != rhs.type)
+    return false;
+  if (lhs.name != rhs.name)
+    return false;
+  if (lhs.controller != rhs.controller)
+    return false;
+  if (lhs.definition != rhs.definition)
+    return false;
+  if (lhs.link != rhs.link)
+    return false;
+
+  return true;
+}
+
+} // anonymous namespace
+
+
+namespace AudioVideoManagement
+{
+
+AudioVideoHandlerImplTest::AudioVideoHandlerImplTest() = default;
+AudioVideoHandlerImplTest::~AudioVideoHandlerImplTest() = default;
+
+/**
+ * Create Assets and MountingPoints.
+ * They will be mounted already but left in the pool exercise.
+ */
+void AudioVideoHandlerImplTest::init()
+{
+  m_nextAssetId = 0;
+  m_nextMpId = 0;
+  m_pool.reset(new Exercise(ExerciseContext::defaultContext()));
+  m_exercise.reset(new Exercise(ExerciseContext(42)));
+
+  m_indoorCam        = createAsset(++m_nextAssetId, MountingPointType::IndoorCamera, R"({"type": "vapix"})");
+  m_outdoorCam       = createAsset(++m_nextAssetId, MountingPointType::OutdoorCamera, R"({"type": "vapix"})");
+  m_announcementUnit = createAsset(++m_nextAssetId, MountingPointType::AnnouncementUnit, R"({"type": "vapix"})");
+
+  m_mpIndoor           = createMountingPoint(++m_nextMpId, MountingPointType::IndoorCamera);
+  m_mpOutdoor          = createMountingPoint(++m_nextMpId, MountingPointType::OutdoorCamera);
+  m_mpAnnouncementUnit = createMountingPoint(++m_nextMpId, MountingPointType::AnnouncementUnit);
+
+  mount(m_indoorCam, m_mpIndoor);
+  mount(m_outdoorCam, m_mpOutdoor);
+  mount(m_announcementUnit, m_mpAnnouncementUnit);
+
+  m_pool->add(std::unique_ptr<Asset>(m_indoorCam));
+  m_pool->add(std::unique_ptr<Asset>(m_outdoorCam));
+  m_pool->add(std::unique_ptr<Asset>(m_announcementUnit));
+  m_pool->add(std::unique_ptr<MountingPoint>(m_mpIndoor));
+  m_pool->add(std::unique_ptr<MountingPoint>(m_mpOutdoor));
+  m_pool->add(std::unique_ptr<MountingPoint>(m_mpAnnouncementUnit));
+}
+
+void AudioVideoHandlerImplTest::cleanup()
+{
+  m_pool.reset();
+  m_exercise.reset();
+}
+
+/**
+ * Assign a camera to an Exercise that neither has microphone nor speaker.
+ */
+void AudioVideoHandlerImplTest::testAssignCameraVideo()
+{
+  DbMock                  dbMock;
+  DtsSpy                  dtsSpy;
+  AudioVideoHandlerImpl   handler(m_exercise.get(), &dbMock, &dtsSpy);
+  handler.onContextActivated();
+  QVERIFY(dbMock.isEmpty());
+  QVERIFY(dtsSpy.isEmpty());
+
+  m_pool->moveMountedTo(m_indoorCam, m_exercise.get(), boost::none);
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 1);
+  QVERIFY(dtsSpy.m_removed.empty());
+
+  // verify DB
+  const Streams   &streams = dbMock.findStreams(m_indoorCam->data().id());
+  QVERIFY(!streams.second);
+  QVERIFY(streams.first == dcEntry(1, "ex_42", "AXIS_VIDEO_CHANNEL", "av_0001", "EXCAVS01", "url=rtsp://root:root@host_0001:554;mode=1;", 0));
+
+  // verify DDS
+  QCOMPARE(dtsSpy.m_published[0], Stream(1, "av_0001", StreamType::Video, m_mpIndoor->data().id()));
+}
+
+/**
+ * Assign a Camera to an Exercise that has a microphone.
+ */
+void AudioVideoHandlerImplTest::testAssignCameraVideoAudioIn()
+{
+  testAssignCameraVideoAudio(R"({"type": "vapix", "hasMicrophone": true})", StreamType::AudioIn);
+}
+
+/**
+ * Assign a Camera to an Exercise that has a speaker.
+ */
+void AudioVideoHandlerImplTest::testAssignCameraVideoAudioOut()
+{
+  testAssignCameraVideoAudio(R"({"type": "vapix", "hasSpeaker": true})", StreamType::AudioOut);
+}
+
+/**
+ * Assign a Camera to an Exercise that has both, microphone and speaker.
+ */
+void AudioVideoHandlerImplTest::testAssignCameraVideoAudioInOut()
+{
+  testAssignCameraVideoAudio(R"({"type": "vapix", "hasMicrophone": true, "hasSpeaker": true})", StreamType::AudioInOut);
+}
+
+void AudioVideoHandlerImplTest::testAssignCameraVideoAudio(const std::string &camProperties, StreamType expectedStreamType)
+{
+  DbMock                  dbMock;
+  DtsSpy                  dtsSpy;
+  AudioVideoHandlerImpl   handler(m_exercise.get(), &dbMock, &dtsSpy);
+
+  // Change the Asset's properties before activating the context.
+  setProperties(m_outdoorCam, camProperties);
+  handler.onContextActivated();
+
+  m_pool->moveMountedTo(m_outdoorCam, m_exercise.get(), boost::none);
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 2);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 2);
+  QVERIFY(dtsSpy.m_removed.empty());
+
+  // verfiy DB
+  const Streams   &streams = dbMock.findStreams(m_outdoorCam->data().id());
+  QVERIFY(streams.second);
+  QVERIFY(streams.first   == dcEntry(1, "ex_42", "AXIS_VIDEO_CHANNEL", "av_0002", "EXCAVS01", "url=rtsp://root:root@host_0002:554;mode=1;", 2));
+  QVERIFY(*streams.second == dcEntry(2, "ex_42", "AXIS_AUDIO_CHANNEL", "av_0002", "EXCAVS01", "url=http://root:root@host_0002:80;mode=1;", 1));
+
+  // verify DDS
+  const Stream   &videoStream = dtsSpy.m_published[0];
+  QCOMPARE(videoStream, Stream(1, "av_0002", StreamType::Video, m_mpOutdoor->data().id()));
+  const Stream   &audioStream = dtsSpy.m_published[1];
+  QCOMPARE(audioStream, Stream(2, "av_0002", expectedStreamType, m_mpOutdoor->data().id()));
+}
+
+/**
+ * Assign an AnnouncementUnit to an exercise.
+ */
+void AudioVideoHandlerImplTest::testAssignAnnouncementUnit()
+{
+  DbMock                  dbMock;
+  DtsSpy                  dtsSpy;
+  AudioVideoHandlerImpl   handler(m_exercise.get(), &dbMock, &dtsSpy);
+  handler.onContextActivated();
+
+  m_pool->moveMountedTo(m_announcementUnit, m_exercise.get(), boost::none);
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 1);
+  QVERIFY(dtsSpy.m_removed.empty());
+
+  // verfiy DB
+  const Streams   &streams = dbMock.findStreams(m_announcementUnit->data().id());
+  QVERIFY(!streams.second);
+  QVERIFY(streams.first == dcEntry(1, "ex_42", "AXIS_AUDIO_CHANNEL", "av_0003", "EXCAVS01", "url=http://root:root@host_0003:80;codec=aac;mode=1;", 0));
+
+  // verify DDS
+  QCOMPARE(dtsSpy.m_published[0], Stream(1, "av_0003", StreamType::AudioOut, m_mpAnnouncementUnit->data().id()));
+}
+
+/**
+ * In this test we assign Assets to the Exercise *before* the Exercise gets activated.
+ */
+void AudioVideoHandlerImplTest::testAssignBeforeActivation()
+{
+  DbMock                  dbMock;
+  DtsSpy                  dtsSpy;
+  AudioVideoHandlerImpl   handler(m_exercise.get(), &dbMock, &dtsSpy);
+
+  m_pool->moveMountedTo(m_indoorCam, m_exercise.get(), boost::none);
+  m_pool->moveMountedTo(m_outdoorCam, m_exercise.get(), boost::none);
+  m_pool->moveMountedTo(m_announcementUnit, m_exercise.get(), boost::none);
+
+  QVERIFY(dbMock.isEmpty());
+  QVERIFY(dtsSpy.isEmpty());
+
+  handler.onContextActivated();
+
+  QCOMPARE(dbMock.deviceCount(), 3);
+  QCOMPARE(dbMock.streamCount(), 3);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 3);
+}
+
+void AudioVideoHandlerImplTest::testUnassignCameraVideo()
+{
+  DbMock                  dbMock;
+  DtsSpy                  dtsSpy;
+  AudioVideoHandlerImpl   handler(m_exercise.get(), &dbMock, &dtsSpy);
+
+  m_pool->moveMountedTo(m_indoorCam, m_exercise.get(), boost::none);
+  handler.onContextActivated();
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 1);
+  QVERIFY(dtsSpy.m_removed.empty());
+
+  dtsSpy.reset();
+  m_exercise->moveMountedTo(m_indoorCam, m_pool.get(), boost::none);
+  QVERIFY(dbMock.isEmpty());
+  QVERIFY(dtsSpy.m_published.empty());
+  QCOMPARE(static_cast<int>(dtsSpy.m_removed.size()), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_removed[0]), 1);
+}
+
+/**
+ * Update a Camera while it is assigned.
+ */
+void AudioVideoHandlerImplTest::testUpdateRemoveAssignedAsset()
+{
+  DbMock                  dbMock;
+  DtsSpy                  dtsSpy;
+  AudioVideoHandlerImpl   handler(m_exercise.get(), &dbMock, &dtsSpy);
+
+  m_pool->moveMountedTo(m_indoorCam, m_exercise.get(), boost::none);
+  handler.onContextActivated();
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 1);
+  QVERIFY(dtsSpy.m_removed.empty());
+
+
+  // add microphone to Camera => one additional audio stream
+  dtsSpy.reset();
+  setProperties(m_indoorCam, R"({"type": "vapix", "hasMicrophone": true})");
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 2);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 2); // one updated, one new
+  QVERIFY(dtsSpy.m_removed.empty());
+
+  // verify DB
+  Streams   streams = dbMock.findStreams(m_indoorCam->data().id());
+  QVERIFY(streams.second);
+  QVERIFY(streams.first   == dcEntry(1, "ex_42", "AXIS_VIDEO_CHANNEL", "av_0001", "EXCAVS01", "url=rtsp://root:root@host_0001:554;mode=1;", 2));
+  QVERIFY(*streams.second == dcEntry(2, "ex_42", "AXIS_AUDIO_CHANNEL", "av_0001", "EXCAVS01", "url=http://root:root@host_0001:80;mode=1;", 1));
+
+  // verify DDS
+  QCOMPARE(dtsSpy.m_published[0], Stream(1, "av_0001", StreamType::Video, m_mpIndoor->data().id()));
+  QCOMPARE(dtsSpy.m_published[1], Stream(2, "av_0001", StreamType::AudioIn, m_mpIndoor->data().id()));
+
+
+  // remove microphone again => removal of audio stream
+  dtsSpy.reset();
+  setProperties(m_indoorCam, R"({"type": "vapix", "hasMicrophone": false})");
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 1); // one updated
+  QCOMPARE(static_cast<int>(dtsSpy.m_removed.size()), 1);
+
+  // verify DB
+  streams = dbMock.findStreams(m_indoorCam->data().id());
+  QVERIFY(!streams.second);
+  QVERIFY(streams.first == dcEntry(1, "ex_42", "AXIS_VIDEO_CHANNEL", "av_0001", "EXCAVS01", "url=rtsp://root:root@host_0001:554;mode=1;", 0));
+
+  // verify DDS
+  QCOMPARE(dtsSpy.m_published[0], Stream(1, "av_0001", StreamType::Video, m_mpIndoor->data().id()));
+  QCOMPARE(static_cast<int>(dtsSpy.m_removed[0]), 2);
+
+
+  // unassign the Camera
+  dtsSpy.reset();
+  m_exercise->moveMountedTo(m_indoorCam, m_pool.get(), boost::none);
+  QCOMPARE(dbMock.deviceCount(), 0);
+  QVERIFY(dtsSpy.m_published.empty());
+  QCOMPARE(static_cast<int>(dtsSpy.m_removed.size()), 1);
+
+  // verify DDS
+  QCOMPARE(static_cast<int>(dtsSpy.m_removed[0]), 1);
+}
+
+/**
+ * Update the MountingPoint of an assigned Asset.
+ */
+void AudioVideoHandlerImplTest::testUpdateAssignedMountingPoint()
+{
+  DbMock                  dbMock;
+  DtsSpy                  dtsSpy;
+  AudioVideoHandlerImpl   handler(m_exercise.get(), &dbMock, &dtsSpy);
+
+  m_pool->moveMountedTo(m_indoorCam, m_exercise.get(), boost::none);
+  handler.onContextActivated();
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 1);
+  QVERIFY(dtsSpy.m_removed.empty());
+
+  // Change the displayName of the MountingPoint.
+  // We now distinguish between internal stream name and display name.
+  // Updating the displayName property of a MountingPoint does not change the internal stream name.
+  dtsSpy.reset();
+  setDisplayName(m_mpIndoor, "updated display name");
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 1);
+  QVERIFY(dtsSpy.m_removed.empty());
+
+  // verify DB
+  Streams   streams = dbMock.findStreams(m_indoorCam->data().id());
+  QVERIFY(!streams.second);
+  QVERIFY(streams.first == dcEntry(1, "ex_42", "AXIS_VIDEO_CHANNEL", "av_0001", "EXCAVS01", "url=rtsp://root:root@host_0001:554;mode=1;", 0));
+
+  // verify DDS
+  QCOMPARE(dtsSpy.m_published[0], Stream(1, "av_0001", StreamType::Video, m_mpIndoor->data().id()));
+
+
+  // set recording-flag on MountingPoint
+  dtsSpy.reset();
+  setRecording(m_mpIndoor, true);
+  QCOMPARE(dbMock.deviceCount(), 1);
+  QCOMPARE(dbMock.streamCount(), 1);
+  QCOMPARE(static_cast<int>(dtsSpy.m_published.size()), 1);
+  QVERIFY(dtsSpy.m_removed.empty());
+
+  // verify DB
+  streams = dbMock.findStreams(m_indoorCam->data().id());
+  QVERIFY(!streams.second);
+  QVERIFY(streams.first == dcEntry(1, "ex_42", "AXIS_VIDEO_CHANNEL", "av_0001", "EXCAVS01", "url=rtsp://root:root@host_0001:554;mode=1;recording=ECRS@EXCAVS01;recordcontrol=prealarm;", 0));
+
+  // verify DDS
+  QCOMPARE(dtsSpy.m_published[0], Stream(1, "av_0001", StreamType::Video, m_mpIndoor->data().id())); // no change here
+}
+
+void AudioVideoHandlerImplTest::testDeviceDefinitionCameraVideo()
+{
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionCameraVideo("host", JsonObject::fromJson(R"({"type": "vapix"})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=rtsp://root:root@host:554;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionCameraVideo("host", JsonObject::fromJson(R"({"type": "vapix", "username": "user", "password": "1234"})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=rtsp://user:1234@host:554;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionCameraVideo("host", JsonObject::fromJson(R"({"type": "vapix", "port": 123})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=rtsp://root:root@host:123;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionCameraVideo("host", JsonObject::fromJson(R"({"type": "vapix"})"), JsonObject::fromJson(R"({"record": true})")),
+           QStringLiteral("url=rtsp://root:root@host:554;mode=1;recording=ECRS@EXCAVS01;recordcontrol=prealarm;"));
+}
+
+void AudioVideoHandlerImplTest::testDeviceDefinitionCameraAudio()
+{
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionCameraAudio("host", JsonObject::fromJson(R"({"type": "vapix"})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=http://root:root@host:80;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionCameraAudio("host", JsonObject::fromJson(R"({"type": "vapix", "username": "user", "password": "1234"})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=http://user:1234@host:80;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionCameraAudio("host", JsonObject::fromJson(R"({"type": "vapix", "audioPort": 88})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=http://root:root@host:88;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionCameraAudio("host", JsonObject::fromJson(R"({"type": "vapix"})"), JsonObject::fromJson(R"({"record": true})")),
+           QStringLiteral("url=http://root:root@host:80;mode=1;recording=ECRS@EXCAVS01;recordcontrol=prealarm;"));
+}
+
+void AudioVideoHandlerImplTest::testDeviceDefinitionAnnouncementUnit()
+{
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionAnnouncementUnit("host", JsonObject::fromJson(R"({"type": "vapix"})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=http://root:root@host:80;codec=aac;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionAnnouncementUnit("host", JsonObject::fromJson(R"({"type": "vapix", "username": "user", "password": "1234"})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=http://user:1234@host:80;codec=aac;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionAnnouncementUnit("host", JsonObject::fromJson(R"({"type": "vapix", "audioPort": 88})"), JsonObject::fromJson(R"({})")),
+           QStringLiteral("url=http://root:root@host:88;codec=aac;mode=1;"));
+
+  QCOMPARE(AudioVideoHandlerImpl::deviceDefinitionAnnouncementUnit("host", JsonObject::fromJson(R"({"type": "vapix"})"), JsonObject::fromJson(R"({"record": true})")),
+           QStringLiteral("url=http://root:root@host:80;codec=aac;mode=1;recording=ECRS@EXCAVS01;"));
+}
+
+} // namespace AudioVideoManagement