test_deviceStartCyclic.cpp

Go to the documentation of this file.

 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "mocks/mockCyclicController.h"
#include "mocks/mockRPCCon.h"
#include "profinet/device.h"
 
using ::testing::_;
using ::testing::InSequence;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::StrictMock;
using ::testing::Throw;
 
namespace profinet::device
{
 
namespace
{
 
constexpr MacAddress kControllerMac{
    0x00,
    0x11,
    0x22,
    0x33,
    0x44,
    0x55,
};
 
dcp::DCPDeviceDescription MakeDeviceDescription()
{
  // Adapt this construction to the actual DCPDeviceDescription constructor
  // used by the project.
  dcp::DCPDeviceDescription info(String2Mac("02:00:00:00:00:01"), {});
  info.name = "dev";
  info.ip = "192.168.0.10";
  return info;
}
 
std::optional<rpc::IOCRSetup> MakeIocrSetup()
{
  std::optional<rpc::IOCRSetup> setup = rpc::IOCRSetup{};
  setup->sendClockFactor = 32;
  setup->reductionRatio = 32;
  setup->watchdogFactor = 3;
  return setup;
}
 
} // namespace
 
class StartCyclicTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    auto mockRpc = std::make_unique<testing::NiceMock<rpc::MockRPCCon>>();
    rpc = mockRpc.get();
 
    device = std::make_unique<ProfinetDevice>(
        MakeDeviceDescription(),
        "eth0",
        kControllerMac,
        1.0,
        std::move(mockRpc));
  }
 
  std::unique_ptr<ProfinetDevice> device;
  rpc::MockRPCCon* rpc = nullptr;
};
 
TEST_F(StartCyclicTests, ConnectsWithAlarmCrAndIocrSetup)
{
  EXPECT_CALL(*rpc, Connect(_, false, _))
      .WillOnce(Return(std::nullopt));
 
  auto iocrSetup = MakeIocrSetup();
  std::optional<rpc::ConnectResult> result;
  result = rpc::ConnectResult{};
 
  EXPECT_CALL(*rpc, Connect(_, true, iocrSetup))
      .WillOnce(Return(result));
 
  const auto& setup = iocrSetup.value();
  EXPECT_THROW(device->StartCyclic(setup),
               std::runtime_error);
}
TEST_F(StartCyclicTests, StartsRtAfterPrmEndAndApplicationReady)
{
  rpc::ConnectResult connectResult{};
  //  connectResult.hasCyclic = true;
  connectResult.inputFrameId = 0xC001;
  connectResult.outputFrameId = 0x8002;
 
  auto mockController = std::make_unique<testing::NiceMock<cyclic::MockCyclicController>>();
  auto* controller = mockController.get();
 
  testing::InSequence sequence;
 
  EXPECT_CALL(*rpc, Connect(_, false, _))
      .WillOnce(Return(std::nullopt));
 
  EXPECT_CALL(*rpc, Connect(_, true, _))
      .WillOnce(Return(connectResult));
 
  EXPECT_CALL(*rpc, PrmEnd())
      .WillOnce(Return(Bytes{}));
 
  EXPECT_CALL(*rpc, ApplicationReady(30.0))
      .WillOnce(Return(Bytes{}));
 
  EXPECT_CALL(*controller, Start(_, _));
 
  auto result = device->StartCyclic(MakeIocrSetup().value(), 3, std::move(mockController));
 
  EXPECT_EQ(result.get(), controller);
}
 
TEST_F(StartCyclicTests, MissingCyclicResultFailsStartup)
{
  rpc::ConnectResult connectResult{};
  // connectResult.hasCyclic = false;
 
  EXPECT_CALL(*rpc, Connect(_, false, _))
      .WillOnce(Return(std::nullopt));
 
  EXPECT_CALL(*rpc, Connect(_, true, _))
      .WillOnce(Return(connectResult));
 
  EXPECT_THROW(device->StartCyclic(MakeIocrSetup().value()),
               std::runtime_error);
}
TEST_F(StartCyclicTests, ApplicationReadyFailurePropagates)
{
  rpc::ConnectResult connectResult{};
  // connectResult.hasCyclic = true;
  connectResult.inputFrameId = 0xC001;
  connectResult.outputFrameId = 0x8002;
 
  EXPECT_CALL(*rpc, Connect(_, false, _))
      .WillOnce(Return(std::nullopt));
 
  EXPECT_CALL(*rpc, Connect(_, true, _))
      .WillOnce(Return(connectResult));
 
  EXPECT_CALL(*rpc, PrmEnd())
      .WillOnce(Return(Bytes{}));
 
  EXPECT_CALL(*rpc, ApplicationReady(30.0))
      .WillOnce(Throw(std::runtime_error("timeout")));
 
  auto mockController =
      std::make_unique<testing::NiceMock<cyclic::MockCyclicController>>();
 
  EXPECT_CALL(*mockController, Start(_, _)).Times(0);
 
  EXPECT_THROW(device->StartCyclic(MakeIocrSetup().value(), 3, std::move(mockController)),
               std::runtime_error);
 
  EXPECT_TRUE(device->IsConnected());
}
 
TEST_F(StartCyclicTests, ApplicationReadyFailureDoesNotStartRt)
{
  rpc::ConnectResult connectResult{};
  // connectResult.hasCyclic = true;
  connectResult.inputFrameId = 0xC001;
  connectResult.outputFrameId = 0x8002;
 
  EXPECT_CALL(*rpc, Connect(_, false, _))
      .WillOnce(Return(std::nullopt));
 
  EXPECT_CALL(*rpc, Connect(_, true, _))
      .WillOnce(Return(connectResult));
 
  EXPECT_CALL(*rpc, PrmEnd())
      .WillOnce(Return(Bytes{}));
 
  EXPECT_CALL(*rpc, ApplicationReady(30.0))
      .WillOnce(Throw(std::runtime_error("timeout")));
 
  auto mockController =
      std::make_unique<testing::NiceMock<cyclic::MockCyclicController>>();
 
  EXPECT_CALL(*mockController, Start(_, _)).Times(0);
 
  EXPECT_THROW(device->StartCyclic(MakeIocrSetup().value(), 3, std::move(mockController)),
               std::runtime_error);
}
TEST(StartCyclicOrderingTests, StartsRtAfterApplicationReadyWhenDisabled)
{
  GTEST_SKIP() << "Current StartCyclic API has no start_rt_before_prm_end option.";
}
 
TEST(StartCyclicOrderingTests, ApplicationReadyCanBeSkipped)
{
  GTEST_SKIP() << "Current StartCyclic API has no confirm_application_ready option.";
}
 
TEST_F(StartCyclicTests, CommitsConnectedDeviceState)
{
  rpc::ConnectResult connectResult{};
  // connectResult.hasCyclic = true;
  connectResult.inputFrameId = 0xC001;
  connectResult.outputFrameId = 0x8002;
 
  EXPECT_CALL(*rpc, Connect(_, false, _))
      .WillOnce(Return(std::nullopt));
 
  EXPECT_CALL(*rpc, Connect(_, true, _))
      .WillOnce(Return(connectResult));
 
  EXPECT_CALL(*rpc, PrmEnd())
      .WillOnce(Return(Bytes{}));
 
  EXPECT_CALL(*rpc, ApplicationReady(30.0))
      .WillOnce(Return(Bytes{}));
 
  auto mockController =
      std::make_unique<testing::NiceMock<cyclic::MockCyclicController>>();
 
  EXPECT_CALL(*mockController, Start(_, _));
 
  auto result = device->StartCyclic(
      MakeIocrSetup().value(),
      3,
      std::move(mockController));
 
  EXPECT_NE(result, nullptr);
  EXPECT_TRUE(device->IsConnected());
}
 
TEST_F(StartCyclicTests, RequestsAlarmCrConnection)
{
  rpc::ConnectResult connectResult{};
  //  connectResult.hasCyclic = true;
  connectResult.inputFrameId = 0xC001;
  connectResult.outputFrameId = 0x8002;
 
  EXPECT_CALL(*rpc, Connect(_, false, _))
      .WillOnce(Return(std::nullopt));
 
  EXPECT_CALL(
      *rpc,
      Connect(
          _,
          true,
          testing::Truly(
              [](const std::optional<rpc::IOCRSetup>& setup)
  {
    return setup.has_value() &&
           setup->sendClockFactor == 32 &&
           setup->reductionRatio == 32 &&
           setup->watchdogFactor == 3;
  })))
      .WillOnce(Return(connectResult));
 
  EXPECT_CALL(*rpc, PrmEnd())
      .WillOnce(Return(Bytes{}));
 
  EXPECT_CALL(*rpc, ApplicationReady(30.0))
      .WillOnce(Return(Bytes{}));
 
  auto mockController =
      std::make_unique<testing::NiceMock<cyclic::MockCyclicController>>();
 
  EXPECT_CALL(*mockController, Start(_, _));
 
  device->StartCyclic(
      MakeIocrSetup().value(),
      3,
      std::move(mockController));
}
 
TEST(StartCyclicArHandlingTests, ReleasesExistingArBeforeNewConnect)
{
  GTEST_SKIP() << "Current StartCyclic uses EnsureConnected() and reuses an existing AR.";
}
 
TEST(StartCyclicArHandlingTests, StopsAlarmListenerBeforeReplacingAr)
{
  GTEST_SKIP() << "Current StartCyclic does not replace an existing AR.";
}
 
TEST(StartCyclicRollbackTests, PrmEndFailureRollsBack)
{
  GTEST_SKIP() << "Current StartCyclic has no rollback path.";
}
 
TEST(StartCyclicRollbackTests, MissingCyclicResultRollsBack)
{
  GTEST_SKIP() << "Requires injectable RPCCon test seam.";
}
 
TEST(StartCyclicRollbackTests, ApplicationReadyFailureStopsStartedRt)
{
  GTEST_SKIP() << "Current StartCyclic starts RT only after ApplicationReady.";
}
 
TEST(StartCyclicRollbackTests, ReleaseFailureDoesNotMaskOriginalError)
{
  GTEST_SKIP() << "Current StartCyclic has no explicit rollback/release path.";
}
 
} // namespace profinet::device