diff --git a/test/extra/NotificationTest.cpp b/test/extra/NotificationTest.cpp index 54e772d64..db4268160 100644 --- a/test/extra/NotificationTest.cpp +++ b/test/extra/NotificationTest.cpp @@ -9,11 +9,20 @@ // // SPDX-License-Identifier: Apache-2.0 +#include #include +#include +#include + +#include "UTransportMock.h" +#include "up-cpp/datamodel/serializer/UUri.h" namespace { +using namespace uprotocol::communication; +using namespace uprotocol::datamodel::serializer::uri; +using MsgDiff = google::protobuf::util::MessageDifferencer; -class TestFixture : public testing::Test { +class NotificationTest : public testing::Test { protected: // Run once per TEST_F. // Used to set up clean environments per test. @@ -22,16 +31,95 @@ class TestFixture : public testing::Test { // Run once per execution of the test application. // Used for setup of all tests. Has access to this instance. - TestFixture() = default; - ~TestFixture() = default; + NotificationTest() = default; + ~NotificationTest() = default; // Run once per execution of the test application. // Used only for global setup outside of tests. static void SetUpTestSuite() {} static void TearDownTestSuite() {} + + [[nodiscard]] uprotocol::v1::UUri buildValidTestTopic() const; + [[nodiscard]] uprotocol::v1::UUri buildValidDefaultSourceURI() const; }; -// TODO replace -TEST_F(TestFixture, SomeTestName) {} +[[nodiscard]] uprotocol::v1::UUri NotificationTest::buildValidDefaultSourceURI() + const { + uprotocol::v1::UUri testDefaultSourceURI_; + testDefaultSourceURI_.set_authority_name("10.0.0.1"); + testDefaultSourceURI_.set_ue_id(0x18000); + testDefaultSourceURI_.set_ue_version_major(0x1); + testDefaultSourceURI_.set_resource_id(0x0); + return testDefaultSourceURI_; +} + +[[nodiscard]] uprotocol::v1::UUri NotificationTest::buildValidTestTopic() + const { + uprotocol::v1::UUri testTopic_; + testTopic_.set_authority_name("10.0.0.2"); + testTopic_.set_ue_id(0x00011101); + testTopic_.set_ue_version_major(0xF8); + testTopic_.set_resource_id(0x8101); + return testTopic_; +} + +TEST_F(NotificationTest, NotificationSuccess) { + // Initialize + uprotocol::v1::UPayloadFormat format = + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_TEXT; + std::optional priority = + uprotocol::v1::UPriority::UPRIORITY_CS1; + + std::optional ttl = + std::chrono::milliseconds(1000); + uprotocol::v1::UUri testDefaultSourceURI = buildValidDefaultSourceURI(); + uprotocol::v1::UUri testTopic = buildValidTestTopic(); + + // Notify Sink + auto transportMockNotificationSink = + std::make_shared(testDefaultSourceURI); + + uprotocol::v1::UMessage capture_msg; + auto callback = [&capture_msg](const auto& message) { + capture_msg = message; + }; + + auto result = NotificationSink::create(transportMockNotificationSink, + std::move(callback), testTopic); + + // Notify Source + std::string testPayloadStr = "test_payload"; + auto transportMockNotificationSource_ = + std::make_shared(testDefaultSourceURI); + + auto movableTopic = testTopic; + + NotificationSource notificationSource( + transportMockNotificationSource_, std::move(movableTopic), + std::move(testDefaultSourceURI), format, priority, ttl); + + uprotocol::datamodel::builder::Payload testPayload(testPayloadStr, format); + auto status = notificationSource.notify(std::move(testPayload)); + + EXPECT_EQ( + AsString::serialize( + transportMockNotificationSource_->message_.attributes().source()), + AsString::serialize(transportMockNotificationSink->source_filter_)); + + EXPECT_EQ( + AsString::serialize( + transportMockNotificationSource_->message_.attributes().sink()), + AsString::serialize( + transportMockNotificationSink->sink_filter_.value())); + + // Manually bridge the two transports + transportMockNotificationSink->mockMessage( + transportMockNotificationSource_->message_); + + // Test + EXPECT_TRUE(MsgDiff::Equals(transportMockNotificationSource_->message_, + capture_msg)); + EXPECT_EQ(testPayloadStr, capture_msg.payload()); +} } // namespace diff --git a/test/extra/PublisherSubscriberTest.cpp b/test/extra/PublisherSubscriberTest.cpp index 54e772d64..b29d0a17c 100644 --- a/test/extra/PublisherSubscriberTest.cpp +++ b/test/extra/PublisherSubscriberTest.cpp @@ -9,29 +9,101 @@ // // SPDX-License-Identifier: Apache-2.0 +#include #include +#include "UTransportMock.h" +#include "up-cpp/communication/Publisher.h" +#include "up-cpp/communication/Subscriber.h" +#include "up-cpp/datamodel/serializer/UUri.h" + +using namespace uprotocol::communication; +using namespace uprotocol::v1; +using namespace uprotocol::datamodel::serializer::uri; +using MsgDiff = google::protobuf::util::MessageDifferencer; + namespace { +using namespace uprotocol::datamodel::builder; -class TestFixture : public testing::Test { +class TestPublisherSubscriber : public testing::Test { protected: // Run once per TEST_F. // Used to set up clean environments per test. - void SetUp() override {} + void SetUp() override { + source_.set_authority_name("10.0.0.1"); + source_.set_ue_id(0x00011101); + source_.set_ue_version_major(0xF1); + source_.set_resource_id(0x0); + + topic_.set_authority_name("10.0.0.1"); + topic_.set_ue_id(0x10010001); + topic_.set_ue_version_major(0xF8); + topic_.set_resource_id(0x8101); + transportMock_ = + std::make_shared(source_); + + format_ = UPayloadFormat::UPAYLOAD_FORMAT_TEXT; + priority_ = UPriority::UPRIORITY_CS2; + ttl_ = std::chrono::milliseconds(1000); + } + void TearDown() override {} // Run once per execution of the test application. // Used for setup of all tests. Has access to this instance. - TestFixture() = default; - ~TestFixture() = default; + TestPublisherSubscriber() = default; + ~TestPublisherSubscriber() = default; // Run once per execution of the test application. // Used only for global setup outside of tests. static void SetUpTestSuite() {} static void TearDownTestSuite() {} + + std::shared_ptr transportMock_; + UUri source_; + UUri topic_; + UPayloadFormat format_; + std::optional priority_; + std::optional ttl_; }; -// TODO replace -TEST_F(TestFixture, SomeTestName) {} +TEST_F(TestPublisherSubscriber, PubSubSuccess) { + // sub + auto transportSub = + std::make_shared(source_); + + uprotocol::v1::UMessage captured_message; + auto callback = [&captured_message](auto message) { + captured_message = message; + }; + + auto result = + Subscriber::subscribe(transportSub, topic_, std::move(callback)); + + // pub + std::string testPayloadStr = "test_payload"; + auto movableTopic = topic_; + Publisher publisher(transportMock_, std::move(movableTopic), format_, + priority_, ttl_); + + uprotocol::v1::UStatus retval; + retval.set_code(uprotocol::v1::UCode::OK); + transportMock_->send_status_ = retval; + + Payload testPayload(testPayloadStr, format_); + auto status = publisher.publish(std::move(testPayload)); + + // Test + EXPECT_EQ( + AsString::serialize(transportMock_->message_.attributes().source()), + AsString::serialize(transportSub->source_filter_)); + + // Manually bridge the two transports + transportSub->mockMessage(transportMock_->message_); + + // Test + EXPECT_TRUE(MsgDiff::Equals(transportMock_->message_, captured_message)); + EXPECT_EQ(testPayloadStr, captured_message.payload()); +} -} // namespace +} // namespace \ No newline at end of file