test_device.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include "mocks/mockAlarmListener.h"
#include "mocks/mockRPCCon.h"
#include "profinet/device.h"
 
using namespace profinet;
using namespace profinet::device;
namespace profinet::device
{
 
class DeviceTest : public ::testing::Test
{
};
 
TEST_F(DeviceTest, ParseMacAcceptsColonDashAndDotSeparators)
{
  auto a = ParseMac("aa:bb:cc:dd:ee:ff");
  auto b = ParseMac("AA-BB-CC-DD-EE-FF");
  auto c = ParseMac("aa.bb.cc.dd.ee.ff");
 
  ASSERT_TRUE(a.has_value());
  ASSERT_TRUE(b.has_value());
  ASSERT_TRUE(c.has_value());
 
  EXPECT_EQ(*a, *b);
  EXPECT_EQ(*a, *c);
  EXPECT_EQ((*a)[0], static_cast<std::uint8_t>(0xAA));
  EXPECT_EQ((*a)[5], static_cast<std::uint8_t>(0xFF));
}
 
TEST_F(DeviceTest, ParseMacRejectsNonMacStrings)
{
  EXPECT_FALSE(ParseMac("my-device-name").has_value());
  EXPECT_FALSE(ParseMac("").has_value());
  EXPECT_FALSE(ParseMac("aa:bb:cc:dd:ee").has_value());
  EXPECT_FALSE(ParseMac("aa:bb:cc:dd:ee:ff:11").has_value());
  EXPECT_FALSE(ParseMac("gg:bb:cc:dd:ee:ff").has_value());
}
 
TEST_F(DeviceTest, IsMacAddressMatchesParseMac)
{
  EXPECT_TRUE(IsMacAddress("aa:bb:cc:dd:ee:ff"));
  EXPECT_FALSE(IsMacAddress("plc-station-1"));
}
 
TEST_F(DeviceTest, DeviceInfoHelpersReturnEmptyOrZeroWhenIm0Unset)
{
  const DeviceInfo info;
 
  EXPECT_EQ(info.SerialNumber(), "");
  EXPECT_EQ(info.OrderId(), "");
  EXPECT_EQ(info.HardwareRevision(), static_cast<std::uint16_t>(0));
  EXPECT_EQ(info.SoftwareRevision(), "");
}
 
TEST_F(DeviceTest, DeviceInfoHelpersExtractAndTrimIm0Fields)
{
  DeviceInfo info;
  PNInM0 im0;
 
  im0.orderId = "MyOrder123      ";
  im0.imSerialNumber = "SN00042         ";
  im0.imHardwareRevision = 3;
  im0.swRevisionPrefix = 'V';
  im0.imSwRevisionFunctionalEnhancement = 1;
  im0.imSwRevisionBugFix = 2;
  im0.imSwRevisionInternalChange = 3;
 
  info.im0 = im0;
 
  EXPECT_EQ(info.SerialNumber(), "SN00042");
  EXPECT_EQ(info.OrderId(), "MyOrder123");
  EXPECT_EQ(info.HardwareRevision(), static_cast<std::uint16_t>(3));
  EXPECT_EQ(info.SoftwareRevision(), "V1.2.3");
}
 
TEST_F(DeviceTest, FromDcpInfoConstructsWithoutDiscovery)
{
  dcp::DCPDeviceDescription info(
      String2Mac("aa:bb:cc:dd:ee:ff"),
      {});
 
  info.name = "test-device";
  info.ip = "192.168.1.50";
 
  // "lo" is used here purely so get_mac() succeeds in this sandboxed
  // test environment; no packets are sent.
  const ProfinetDevice dev = ProfinetDevice::FromDcpInfo(info, "lo");
 
  EXPECT_EQ(dev.Name(), "test-device");
  EXPECT_EQ(dev.Ip(), "192.168.1.50");
  EXPECT_FALSE(dev.IsConnected());
  EXPECT_NE(
      dev.ToString().find("disconnected"),
      std::string::npos);
}
 
TEST_F(DeviceTest, DiscoverWithUnknownMacThrowsDcpDeviceNotFoundError)
{
  // No device will ever claim this MAC on "lo", and the discovery
  // timeout is kept short so the test doesn't hang.
  EXPECT_THROW(
      ProfinetDevice::Discover(
          "aa:bb:cc:dd:ee:ff",
          "lo",
          /*timeoutSec=*/1.0),
      DCPDeviceNotFoundError);
}
 
TEST(DeviceMoveTests, MoveConstructionDisconnectsSource)
{
  constexpr MacAddress kControllerMac{
      0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
 
  dcp::DCPDeviceDescription info(
      String2Mac("aa:bb:cc:dd:ee:ff"),
      {});
 
  info.name = "test-device";
  info.ip = "192.168.1.50";
 
  auto mock = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
  auto* rpc = mock.get();
  ProfinetDevice source(info, "eth0", kControllerMac, 5.0, std::move(mock));
 
  source.Connect();
 
  ProfinetDevice destination(std::move(source));
 
  EXPECT_EQ(destination.Mac(), "aa:bb:cc:dd:ee:ff");
  EXPECT_EQ(destination.Name(), "test-device");
 
  EXPECT_TRUE(destination.IsConnected());
  EXPECT_FALSE(source.IsConnected());
}
 
TEST(DeviceMoveTests, MoveAssignmentReleasesDestinationFirst)
{
  constexpr MacAddress kControllerMac{
      0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
 
  dcp::DCPDeviceDescription info1(
      String2Mac("aa:bb:cc:dd:ee:ff"),
      {});
 
  info1.name = "test-device";
  info1.ip = "192.168.1.50";
 
  auto mock1 = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
 
  ProfinetDevice source(info1, "eth0", kControllerMac, 5.0, std::move(mock1));
  source.Connect();
 
  dcp::DCPDeviceDescription info2(
      String2Mac("00:11:22:33:44:55"),
      {});
  info2.name = "test-device2";
  info2.ip = "192.168.1.80";
 
  auto mockRpcDestination = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
  auto* rpcDestination = mockRpcDestination.get();
  auto mockAlarmListenerDestination = std::make_unique<testing::NiceMock<MockAlarmListener>>();
 
  auto* alarmListenerDestination = mockAlarmListenerDestination.get();
  {
    testing::InSequence sequence;
    EXPECT_CALL(*alarmListenerDestination, Stop)
        .Times(1);
    EXPECT_CALL(*rpcDestination, Close)
        .Times(1);
  }
  ProfinetDevice destination(info2, "eth0", kControllerMac, 5.0, std::move(mockRpcDestination), std::move(mockAlarmListenerDestination));
  destination.Connect();
  EXPECT_TRUE(destination.IsConnected());
 
  destination = std::move(source);
 
  EXPECT_TRUE(destination.IsConnected());
  EXPECT_FALSE(source.IsConnected());
}
 
TEST(DeviceMoveTests, MovedFromDeviceCanBeDestroyedSafely)
{
  constexpr MacAddress kControllerMac{
      0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
 
  dcp::DCPDeviceDescription info(
      String2Mac("aa:bb:cc:dd:ee:ff"),
      {});
 
  info.name = "test-device";
  info.ip = "192.168.1.50";
 
  auto mock = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
  ProfinetDevice source(info, "eth0", kControllerMac, 5.0, std::move(mock));
 
  source.Connect();
  {
    auto destination = std::move(source);
  }
  SUCCEED();
}
 
class MockDcpScanner final : public IDcpScanner
{
 public:
  MOCK_METHOD(dcp::ResponseMap, Scan, (const std::string& interface, double timeoutSec), (override));
};
class MockMacAddressProvider final : public IMacAddressProvider
{
 public:
  MOCK_METHOD(MacAddress, GetMac, (const std::string& interface), (override));
};
 
class ProfinetScannerTest : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    scanner = std::make_unique<MockDcpScanner>();
    mockDcpScanner = scanner.get();
 
    macAddressProvider = std::make_unique<MockMacAddressProvider>();
    mockMacAddressProvider = macAddressProvider.get();
  }
 
  void ConfigureScanResults(const dcp::ResponseMap& responses, double timeoutSec)
  {
    EXPECT_CALL(*mockDcpScanner, Scan("eth0", timeoutSec))
        .WillOnce(::testing::Return(responses));
  }
  struct TestScanDevice
  {
    std::string mac;
 
    std::string name;
 
    std::string ip;
  };
 
  dcp::ResponseMap CreateScanResponses(std::initializer_list<TestScanDevice> devices)
  {
    dcp::ResponseMap responses;
 
    for (const auto& device : devices)
    {
      const MacAddress mac = String2Mac(device.mac);
 
      auto& blocks = responses[mac];
 
      blocks[dcp::MakeBlockKey(DcpOption::Device, DcpDeviceSuboption::Name)] = Bytes(device.name.begin(), device.name.end());
 
      const auto ip = Ip2String(device.ip);
      blocks[dcp::MakeBlockKey(DcpOption::Ip, DcpIpSuboption::IpParameter)] = Bytes(ip.begin(), ip.end());
    }
 
    return responses;
  }
 
  [[nodiscard]] static double GetDeviceTimeout(const ProfinetDevice& device)
  {
    return device.timeout;
  }
 
  MockDcpScanner* mockDcpScanner = nullptr;
  std::unique_ptr<MockDcpScanner> scanner;
 
  MockMacAddressProvider* mockMacAddressProvider = nullptr;
  std::unique_ptr<MockMacAddressProvider> macAddressProvider;
  static constexpr MacAddress kMacA{0x02, 0x00, 0x00, 0x00, 0x00, 0x0A};
};
 
TEST_F(ProfinetScannerTest, ScanPreservesZeroTimeout)
{
  const auto responses = CreateScanResponses({
      {
          .mac = "AA:BB:CC:DD:EE:01",
          .name = "valve",
          .ip = "192.168.1.10",
      },
      {
          .mac = "AA:BB:CC:DD:EE:02",
          .name = "valve",
          .ip = "192.168.1.11",
      },
  });
 
  EXPECT_CALL(*mockDcpScanner, Scan("eth0", 0.0))
      .WillOnce(::testing::Return(responses));
 
  EXPECT_CALL(*mockMacAddressProvider, GetMac("eth0"))
      .WillOnce(::testing::Return(kMacA));
 
  const auto devices = Scan("eth0", 0.0, std::move(scanner), std::move(macAddressProvider));
 
  ASSERT_EQ(devices.size(), responses.size());
 
  for (const auto& device : devices)
  {
    EXPECT_DOUBLE_EQ(GetDeviceTimeout(device), 0.0);
  }
}
 
TEST_F(ProfinetScannerTest, ScanPreservesShortTimeout)
{
  constexpr double timeoutSec = 0.1;
  const auto responses = CreateScanResponses({{
                                                  .mac = "AA:BB:CC:DD:EE:01",
                                                  .name = "valve",
                                                  .ip = "192.168.1.10",
                                              },
                                              {
                                                  .mac = "AA:BB:CC:DD:EE:02",
                                                  .name = "valve",
                                                  .ip = "192.168.1.11",
                                              },
                                              {
                                                  .mac = "AA:BB:CC:DD:EE:03",
                                                  .name = "valve",
                                                  .ip = "192.168.1.12",
                                              }});
 
  EXPECT_CALL(*mockDcpScanner, Scan("eth0", timeoutSec))
      .WillOnce(::testing::Return(responses));
 
  EXPECT_CALL(*mockMacAddressProvider, GetMac("eth0"))
      .WillOnce(::testing::Return(kMacA));
 
  const auto devices = Scan("eth0", timeoutSec, std::move(scanner), std::move(macAddressProvider));
 
  ASSERT_EQ(devices.size(), responses.size());
 
  for (const auto& device : devices)
  {
    EXPECT_DOUBLE_EQ(GetDeviceTimeout(device), timeoutSec);
  }
}
 
TEST_F(ProfinetScannerTest, ScanPreservesLongTimeout)
{
  constexpr double timeoutSec = 30.0;
  const auto responses = CreateScanResponses({{
                                                  .mac = "AA:BB:CC:DD:EE:01",
                                                  .name = "valve",
                                                  .ip = "192.168.1.10",
                                              },
                                              {
                                                  .mac = "AA:BB:CC:DD:EE:02",
                                                  .name = "valve",
                                                  .ip = "192.168.1.11",
                                              },
                                              {
                                                  .mac = "AA:BB:CC:DD:EE:03",
                                                  .name = "valve",
                                                  .ip = "192.168.1.12",
                                              }});
 
  EXPECT_CALL(*mockDcpScanner, Scan("eth0", timeoutSec))
      .WillOnce(::testing::Return(responses));
 
  EXPECT_CALL(*mockMacAddressProvider, GetMac("eth0"))
      .WillOnce(::testing::Return(kMacA));
 
  const auto devices = Scan("eth0", timeoutSec, std::move(scanner), std::move(macAddressProvider));
 
  ASSERT_EQ(devices.size(), responses.size());
 
  for (const auto& device : devices)
  {
    EXPECT_DOUBLE_EQ(GetDeviceTimeout(device), timeoutSec);
  }
}
 
TEST_F(ProfinetScannerTest, ScanCreatesDeviceForEveryResponse)
{
  constexpr double timeoutSec = 5.0;
  const auto responses = CreateScanResponses({{
                                                  .mac = "AA:BB:CC:DD:EE:01",
                                                  .name = "valve",
                                                  .ip = "192.168.1.10",
                                              },
                                              {
                                                  .mac = "AA:BB:CC:DD:EE:02",
                                                  .name = "valve",
                                                  .ip = "192.168.1.11",
                                              }});
  EXPECT_CALL(*mockMacAddressProvider, GetMac("eth0"))
      .WillOnce(::testing::Return(kMacA));
 
  ConfigureScanResults(responses, timeoutSec);
 
  const auto devices = Scan("eth0", timeoutSec, std::move(scanner), std::move(macAddressProvider));
 
  EXPECT_EQ(devices.size(), 2U);
}
 
TEST_F(ProfinetScannerTest, ScanDictKeepsDuplicateStationNames)
{
  constexpr double timeoutSec = 5.0;
 
  const auto responses = CreateScanResponses(
      {
          {"AA:BB:CC:DD:EE:01", "valve", "192.168.1.10"},
          {"AA:BB:CC:DD:EE:02", "valve", "192.168.1.11"},
      });
  EXPECT_CALL(*mockMacAddressProvider, GetMac("eth0"))
      .WillOnce(::testing::Return(kMacA));
 
  ConfigureScanResults(responses, timeoutSec);
 
  const auto result = ScanDict("eth0", timeoutSec, std::move(scanner), std::move(macAddressProvider));
 
  ASSERT_EQ(result.size(), 2U);
 
  ASSERT_NE(result.find("aa:bb:cc:dd:ee:01"), result.end());
 
  ASSERT_NE(result.find("aa:bb:cc:dd:ee:02"), result.end());
 
  EXPECT_EQ(result.at("aa:bb:cc:dd:ee:01").name, "valve");
 
  EXPECT_EQ(result.at("aa:bb:cc:dd:ee:02").name, "valve");
}
 
TEST_F(ProfinetScannerTest, ScanDictKeepsEmptyStationNames)
{
  constexpr double timeoutSec = 5.0;
 
  const auto responses = CreateScanResponses(
      {
          {"AA:BB:CC:DD:EE:01", "", "192.168.1.10"},
          {"AA:BB:CC:DD:EE:02", "", "192.168.1.11"},
      });
 
  EXPECT_CALL(*mockMacAddressProvider, GetMac("eth0"))
      .WillOnce(::testing::Return(kMacA));
 
  ConfigureScanResults(responses, timeoutSec);
 
  const auto result = ScanDict("eth0", timeoutSec, std::move(scanner), std::move(macAddressProvider));
 
  ASSERT_EQ(result.size(), 2U);
 
  ASSERT_NE(result.find("aa:bb:cc:dd:ee:01"), result.end());
 
  ASSERT_NE(result.find("aa:bb:cc:dd:ee:02"), result.end());
 
  EXPECT_TRUE(result.at("aa:bb:cc:dd:ee:01").name.empty());
 
  EXPECT_TRUE(result.at("aa:bb:cc:dd:ee:02").name.empty());
}
} // namespace profinet::device