From fc2b24518367a7abc735cf105ff2c1da0582d27d Mon Sep 17 00:00:00 2001 From: Max Date: Wed, 28 May 2025 19:11:11 +0200 Subject: [PATCH 1/8] merge with add tests and changed description style --- include/up-cpp/utils/ProtoConverter.h | 37 ++++++++------------------- 1 file changed, 11 insertions(+), 26 deletions(-) diff --git a/include/up-cpp/utils/ProtoConverter.h b/include/up-cpp/utils/ProtoConverter.h index 93a4471db..20b0a181c 100644 --- a/include/up-cpp/utils/ProtoConverter.h +++ b/include/up-cpp/utils/ProtoConverter.h @@ -66,7 +66,7 @@ struct ProtoConverter { /// @return the built UnsubscribeRequest static UnsubscribeRequest BuildUnSubscribeRequest( const v1::UUri& subscription_topic); - + /// @brief Builds a FetchSubscriptionsRequest from the given topic /// /// @param topic the UUri of the topic to fetch subscriptions for @@ -91,18 +91,11 @@ struct ProtoConverter { /// @return the built NotificationsRequest static NotificationsRequest BuildNotificationsRequest(const v1::UUri& topic); - /** - * @brief Deserializes a protobuf message from a given payload. - * - * Parses the payload in `v1::UMessage` using `google::protobuf::Any`, - * returning a deserialized object of type `T` or an error if parsing fails. - * - * @tparam T The type to deserialize the message into. - * - * @param message The `v1::UMessage` containing the payload. - * - * @return `TOrStatus` with the deserialized object or an error status. - */ + /// @brief Deserializes a protobuf message from a given payload. + /// + /// @tparam T The type to deserialize the message into. + /// @param message The `v1::UMessage` containing the payload. + /// @return `TOrStatus` with the deserialized object or an error status. template static TOrStatus extractFromProtobuf(const v1::UMessage& message) { switch (message.attributes().payload_format()) { @@ -165,19 +158,11 @@ struct ProtoConverter { } } - /** - * @brief Serializes a protobuf object into a payload. - * - * Converts the given `proto` object to a payload using - * `google::protobuf::Any`. Returns the payload or an error status if - * serialization fails. - * - * @tparam T The type of the protobuf object to serialize. - * - * @param proto The protobuf object to be converted into a payload. - * - * @return `PayloadOrStatus` containing the payload or an error status. - */ + /// @brief Serializes a protobuf object into a payload. + /// + /// @tparam T The type of the protobuf object to serialize. + /// @param proto The protobuf object to be converted into a payload. + /// @return `PayloadOrStatus` containing the payload or an error status. template static PayloadOrStatus protoToPayload(const T& proto) { google::protobuf::Any any; From d521cf3b82072a7517fa35913f9e23bb39c89008 Mon Sep 17 00:00:00 2001 From: Max Date: Wed, 28 May 2025 19:24:44 +0200 Subject: [PATCH 2/8] added documentation to USubscription.h --- .../client/usubscription/v3/USubscription.h | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/include/up-cpp/client/usubscription/v3/USubscription.h b/include/up-cpp/client/usubscription/v3/USubscription.h index 7ad69e8d4..e3e4a676c 100644 --- a/include/up-cpp/client/usubscription/v3/USubscription.h +++ b/include/up-cpp/client/usubscription/v3/USubscription.h @@ -19,28 +19,58 @@ namespace uprotocol::core::usubscription::v3 { +/** + * + */ struct USubscription { + template using ResponseOrStatus = utils::Expected; virtual ~USubscription() = default; + /// @brief sends a subscription request to a USubscription backend and a + /// response on success or else a status code + /// + /// @param subscription_request containing a topic to subscribe to + /// @return SubscriptionReponse on success and UStatus else virtual ResponseOrStatus subscribe( const SubscriptionRequest& subscription_request) = 0; + /// @brief sends an unsubscribe request to a USubscription backend and a + /// response on success or else a status code + /// + /// @param unsubscribe_request containing a topic to unsubscribe + /// @return UnsubscribeResponse on success and UStatus else virtual ResponseOrStatus unsubscribe( const UnsubscribeRequest& unsubscribe_request) = 0; + /// @brief fetches all topic the client is subscribed to from the backend + /// + /// @param fetch_subscriptions_request + /// @return FetchSubscriptionsResponse on success and UStatus else virtual ResponseOrStatus fetch_subscriptions( const FetchSubscriptionsRequest& fetch_subscriptions_request) = 0; + /// @brief registers for notifications to a USubscription backend + /// + /// @param register_notifications_request + /// @return NotificationResponse on success and UStatus else virtual ResponseOrStatus register_for_notifications( const NotificationsRequest& register_notifications_request) = 0; + /// @brief unregisters for notifications to a USubscription backend + /// + /// @param unregister_notifications_request + /// @return NotificationResponse on success and UStatus else virtual ResponseOrStatus unregister_for_notifications( const NotificationsRequest& unregister_notifications_request) = 0; + /// @brief fetches all subscribers for a given topic from the backend + /// + /// @param fetch_subscriptions_request containing the topic for which the subscribers are fetched + /// @return FetchSubscriptionsResponse on success and UStatus else virtual ResponseOrStatus fetch_subscribers( const FetchSubscribersRequest& fetch_subscribers_request) = 0; }; From 9891c9326a0f5a01b0d229d36f975eeb3d8dfcec Mon Sep 17 00:00:00 2001 From: Max Date: Wed, 28 May 2025 19:27:48 +0200 Subject: [PATCH 3/8] changed comment style in RequestBuilder.h --- .../client/usubscription/v3/RequestBuilder.h | 115 ++++++++---------- 1 file changed, 49 insertions(+), 66 deletions(-) diff --git a/include/up-cpp/client/usubscription/v3/RequestBuilder.h b/include/up-cpp/client/usubscription/v3/RequestBuilder.h index c51c82652..6dcd2a45e 100644 --- a/include/up-cpp/client/usubscription/v3/RequestBuilder.h +++ b/include/up-cpp/client/usubscription/v3/RequestBuilder.h @@ -18,12 +18,10 @@ namespace uprotocol::core::usubscription::v3 { -/** - * @struct USubscriptionOptions - * @brief Additional details for uSubscription service. - * - * Each member represents an optional parameter for the uSubscription service. - */ +/// @struct USubscriptionOptions +/// @brief Additional details for uSubscription service. +/// +/// Each member represents an optional parameter for the uSubscription service. struct USubscriptionOptions { /// Permission level of the subscription request std::optional permission_level; @@ -39,83 +37,68 @@ struct USubscriptionOptions { std::optional subscription_details; }; -/** - * @brief Builds different requests using specified options. - * - * This struct facilitates the construction of requests based on - * `USubscriptionOptions`, providing methods to build different requests. - */ +/// @brief Builds different requests using specified options. +/// +/// This struct facilitates the construction of requests based on +/// `USubscriptionOptions`, providing methods to build different requests. struct RequestBuilder { - /** - * @brief Constructs a RequestBuilder with the given subscription options. - * - * @param options Subscription options to configure the requests. Defaults - * to empty options. - */ + + /// @brief Constructs a RequestBuilder with the given subscription options. + /// + /// @param options Subscription options to configure the requests. Defaults + /// to empty options. explicit RequestBuilder(USubscriptionOptions options = {}) : options_(std::move(options)) {} - /** - * @brief Builds a subscription request for a given topic. - * - * @param topic The `v1::UUri` representing the topic for the subscription. - * - * @return A `SubscriptionRequest` configured for the specified topic. - */ + /// @brief Builds a subscription request for a given topic. + /// + /// @param topic The `v1::UUri` representing the topic for the subscription. + /// + /// @return A `SubscriptionRequest` configured for the specified topic. SubscriptionRequest buildSubscriptionRequest(const v1::UUri& topic) const; - /** - * @brief Builds an unsubscription request for a given topic. - * - * @param topic The `v1::UUri` representing the topic to unsubscribe from. - * - * @return An `UnsubscribeRequest` configured for the specified topic. - */ + /// @brief Builds an unsubscription request for a given topic. + /// + /// @param topic The `v1::UUri` representing the topic to unsubscribe from. + /// + /// @return An `UnsubscribeRequest` configured for the specified topic. static UnsubscribeRequest buildUnsubscribeRequest(const v1::UUri& topic); - /** - * @brief Build fetch subscritions request for a given topic. - * - * @param topic The `v1::UUri` representing the topic to fetch. - * - * @return An `FetchSubscriptionsRequest` configured for the specified - * topic. - */ + /// @brief Build fetch subscritions request for a given topic. + /// + /// @param topic The `v1::UUri` representing the topic to fetch. + /// + /// @return An `FetchSubscriptionsRequest` configured for the specified + /// topic. static FetchSubscriptionsRequest buildFetchSubscriptionsRequest( const v1::UUri& topic); - /** - * @brief Build fetch subscritions request for a given subscriber. - * - * @param subscriber The `SubscriberInfo` representing the subscriber to - * fetch. - * - * @return An `FetchSubscriptionsRequest` configured for the specified - * subscriber. - */ + /// @brief Build fetch subscritions request for a given subscriber. + /// + /// @param subscriber The `SubscriberInfo` representing the subscriber to + /// fetch. + /// + /// @return An `FetchSubscriptionsRequest` configured for the specified + /// subscriber. static FetchSubscriptionsRequest buildFetchSubscriptionsRequest( const SubscriberInfo& subscriber); - /** - * @brief Build fetch subscribers request for a given topic. - * - * @param topic The `v1::UUri` representing the topic to fetch. - * - * @return An `FetchSubscribersRequest` configured for the specified topic. - */ + /// @brief Build fetch subscribers request for a given topic. + /// + /// @param topic The `v1::UUri` representing the topic to fetch. + /// + /// @return An `FetchSubscribersRequest` configured for the specified topic. static FetchSubscribersRequest buildFetchSubscribersRequest( const v1::UUri& topic); - /** - * @brief Build notifications request for a given topic. Subscription change - *notifications MUST use topic SubscriptionsChange with resource id 0x8000, - *as per the protobuf definition. - * - * @param topic The `v1::UUri` representing the topic to (un)register - *for/from. - * - * @return An `NotificationsRequest` configured for the specified topic. - */ + /// @brief Build notifications request for a given topic. Subscription change + ///notifications MUST use topic SubscriptionsChange with resource id 0x8000, + ///as per the protobuf definition. + /// + /// @param topic The `v1::UUri` representing the topic to (un)register + ///for/from. + /// + /// @return An `NotificationsRequest` configured for the specified topic. static NotificationsRequest buildNotificationsRequest(const v1::UUri& topic); private: From d137c7881d71c55e5ef7a4489e7c9afb76704319 Mon Sep 17 00:00:00 2001 From: Max Date: Wed, 28 May 2025 19:44:36 +0200 Subject: [PATCH 4/8] more documentation --- .../client/usubscription/v3/RequestBuilder.h | 13 +-- .../usubscription/v3/RpcClientUSubscription.h | 40 ++++++--- .../client/usubscription/v3/USubscription.h | 13 +-- include/up-cpp/communication/RpcClient.h | 2 +- include/up-cpp/utils/ProtoConverter.h | 27 +++--- src/utils/ProtoConverter.cpp | 36 ++++---- .../usubscription/v3/RequestBuilderTest.cpp | 88 ++++++++++-------- .../v3/RpcClientUSubscriptionTest.cpp | 90 ++++++++++--------- .../v3/USubscriptionUUriBuilderTest.cpp | 75 ++++++++-------- 9 files changed, 211 insertions(+), 173 deletions(-) diff --git a/include/up-cpp/client/usubscription/v3/RequestBuilder.h b/include/up-cpp/client/usubscription/v3/RequestBuilder.h index 6dcd2a45e..31402c086 100644 --- a/include/up-cpp/client/usubscription/v3/RequestBuilder.h +++ b/include/up-cpp/client/usubscription/v3/RequestBuilder.h @@ -42,7 +42,6 @@ struct USubscriptionOptions { /// This struct facilitates the construction of requests based on /// `USubscriptionOptions`, providing methods to build different requests. struct RequestBuilder { - /// @brief Constructs a RequestBuilder with the given subscription options. /// /// @param options Subscription options to configure the requests. Defaults @@ -91,15 +90,17 @@ struct RequestBuilder { static FetchSubscribersRequest buildFetchSubscribersRequest( const v1::UUri& topic); - /// @brief Build notifications request for a given topic. Subscription change - ///notifications MUST use topic SubscriptionsChange with resource id 0x8000, - ///as per the protobuf definition. + /// @brief Build notifications request for a given topic. Subscription + /// change + /// notifications MUST use topic SubscriptionsChange with resource id + /// 0x8000, as per the protobuf definition. /// /// @param topic The `v1::UUri` representing the topic to (un)register - ///for/from. + /// for/from. /// /// @return An `NotificationsRequest` configured for the specified topic. - static NotificationsRequest buildNotificationsRequest(const v1::UUri& topic); + static NotificationsRequest buildNotificationsRequest( + const v1::UUri& topic); private: USubscriptionOptions options_; ///< Options used to configure the requests. diff --git a/include/up-cpp/client/usubscription/v3/RpcClientUSubscription.h b/include/up-cpp/client/usubscription/v3/RpcClientUSubscription.h index aa7b4c003..70a34d697 100644 --- a/include/up-cpp/client/usubscription/v3/RpcClientUSubscription.h +++ b/include/up-cpp/client/usubscription/v3/RpcClientUSubscription.h @@ -46,10 +46,7 @@ namespace uprotocol::core::usubscription::v3 { using v3::SubscriptionRequest; using v3::UnsubscribeRequest; -/// @brief Interface for uEntities to create subscriptions. -/// -/// Like all L3 client APIs, the RpcClientUSubscription is a wrapper on top of -/// the L2 Communication APIs and USubscription service. +/// @brief Client which implements the USubscription interface struct RpcClientUSubscription : USubscription { using RpcClientUSubscriptionOrStatus = utils::Expected, v1::UStatus>; @@ -59,54 +56,69 @@ struct RpcClientUSubscription : USubscription { template Response invokeResponse(communication::RpcClient rpc_client); - /// @brief Subscribe to the topic + /// @brief Subscribes from a given topic /// + /// @param subscription_request The request object containing the topic to + /// subscribe to + /// @return Returns a SubscriptionResponse on success and a UStatus else utils::Expected subscribe( const SubscriptionRequest& subscription_request) override; - /// @brief Unsubscribe from the topic + /// @brief Unsubscribes from a given topic /// + /// @param unsubscribe_request The request object containing the topic to + /// unsubscribe from + /// @return Returns an UnsubscribeResponse on success and a UStatus else utils::Expected unsubscribe( const UnsubscribeRequest& unsubscribe_request) override; - /// @brief Fetch all subscriptions either by topic or subscriber + /// @brief Fetches the list of topics the client is subscribed to /// + /// @param fetch_subscriptions_request The request object + /// @return Returns a FetchSubscriptionsResponse on success and a UStatus + /// else utils::Expected fetch_subscriptions( const FetchSubscriptionsRequest& fetch_subscriptions_request) override; - /// @brief Fetch all subscribers + /// @brief Fetches the list of subscribers for a given topic /// + /// @param fetch_subscribers_request The request object containing the topic + /// for which the subscribers are to be fetched + /// @return Returns a FetchSubscribersResponse on success and a UStatus else utils::Expected fetch_subscribers( const FetchSubscribersRequest& fetch_subscribers_request) override; - /// @brief Register for notifications + /// @brief Registers to receive notifications /// + /// @param register_notifications_request The request object containing + /// the details to register for notifications + /// @return Returns a NotificationResponse on success and a UStatus else utils::Expected register_for_notifications( const NotificationsRequest& register_notifications_request) override; - /// @brief Unregister for notifications + /// @brief Unregisters from receiving notifications. /// + /// @param unregister_notifications_request The request object containing + /// the details needed to stop receiving notifications. + /// @return Returns a NotificationResponse on success and a UStatus else utils::Expected unregister_for_notifications( const NotificationsRequest& unregister_notifications_request) override; /// @brief Constructor /// - /// @param transport Transport to register with. + /// @param transport Transport used to send messages explicit RpcClientUSubscription( std::shared_ptr transport) : transport_(std::move(transport)) {} - /// @brief Destructor ~RpcClientUSubscription() override = default; private: - // Transport std::shared_ptr transport_; - // URI info about the uSubscription service USubscriptionUUriBuilder uuri_builder_; }; diff --git a/include/up-cpp/client/usubscription/v3/USubscription.h b/include/up-cpp/client/usubscription/v3/USubscription.h index e3e4a676c..8d0e4a092 100644 --- a/include/up-cpp/client/usubscription/v3/USubscription.h +++ b/include/up-cpp/client/usubscription/v3/USubscription.h @@ -19,11 +19,11 @@ namespace uprotocol::core::usubscription::v3 { -/** - * - */ +/// @brief Interface for uEntities to create subscriptions. +/// +/// Like all L3 client APIs, the RpcClientUSubscription is a wrapper on top of +/// the L2 Communication APIs and USubscription service. struct USubscription { - template using ResponseOrStatus = utils::Expected; @@ -45,7 +45,7 @@ struct USubscription { virtual ResponseOrStatus unsubscribe( const UnsubscribeRequest& unsubscribe_request) = 0; - /// @brief fetches all topic the client is subscribed to from the backend + /// @brief fetches all topics the client is subscribed to from the backend /// /// @param fetch_subscriptions_request /// @return FetchSubscriptionsResponse on success and UStatus else @@ -69,7 +69,8 @@ struct USubscription { /// @brief fetches all subscribers for a given topic from the backend /// - /// @param fetch_subscriptions_request containing the topic for which the subscribers are fetched + /// @param fetch_subscriptions_request containing the topic for which the + /// subscribers are fetched /// @return FetchSubscriptionsResponse on success and UStatus else virtual ResponseOrStatus fetch_subscribers( const FetchSubscribersRequest& fetch_subscribers_request) = 0; diff --git a/include/up-cpp/communication/RpcClient.h b/include/up-cpp/communication/RpcClient.h index d36f0c77a..07ee17711 100644 --- a/include/up-cpp/communication/RpcClient.h +++ b/include/up-cpp/communication/RpcClient.h @@ -185,7 +185,7 @@ struct RpcClient { return ResponseOrStatus( UnexpectedStatus(message_or_status.error())); } - + auto response_or_status = utils::ProtoConverter::extractFromProtobuf( message_or_status.value()); diff --git a/include/up-cpp/utils/ProtoConverter.h b/include/up-cpp/utils/ProtoConverter.h index 20b0a181c..8f5c3deaa 100644 --- a/include/up-cpp/utils/ProtoConverter.h +++ b/include/up-cpp/utils/ProtoConverter.h @@ -18,13 +18,13 @@ using TOrStatus = utils::Expected; using UnexpectedStatus = utils::Unexpected; using PayloadOrStatus = utils::Expected; +using core::usubscription::v3::FetchSubscribersRequest; +using core::usubscription::v3::FetchSubscriptionsRequest; +using core::usubscription::v3::NotificationsRequest; using uprotocol::core::usubscription::v3::SubscribeAttributes; using uprotocol::core::usubscription::v3::SubscriberInfo; using uprotocol::core::usubscription::v3::SubscriptionRequest; using uprotocol::core::usubscription::v3::UnsubscribeRequest; -using core::usubscription::v3::FetchSubscriptionsRequest; -using core::usubscription::v3::FetchSubscribersRequest; -using core::usubscription::v3::NotificationsRequest; struct ProtoConverter { /// @brief Converts std::chrono::time_point to google::protobuf::Timestamp @@ -71,25 +71,31 @@ struct ProtoConverter { /// /// @param topic the UUri of the topic to fetch subscriptions for /// @return the built FetchSubscriptionsRequest - static FetchSubscriptionsRequest BuildFetchSubscriptionsRequest(const v1::UUri& topic); + static FetchSubscriptionsRequest BuildFetchSubscriptionsRequest( + const v1::UUri& topic); - /// @brief Builds a FetchSubscriptionsRequest from the given subscriber information + /// @brief Builds a FetchSubscriptionsRequest from the given subscriber + /// information /// - /// @param subscriber the SubscriberInfo containing details of the subscriber + /// @param subscriber the SubscriberInfo containing details of the + /// subscriber /// @return the built FetchSubscriptionsRequest - static FetchSubscriptionsRequest BuildFetchSubscriptionsRequest(const SubscriberInfo& subscriber); + static FetchSubscriptionsRequest BuildFetchSubscriptionsRequest( + const SubscriberInfo& subscriber); /// @brief Builds a FetchSubscribersRequest from the given topic /// /// @param topic the UUri of the topic to fetch subscribers for /// @return the built FetchSubscribersRequest - static FetchSubscribersRequest BuildFetchSubscribersRequest(const v1::UUri& topic); + static FetchSubscribersRequest BuildFetchSubscribersRequest( + const v1::UUri& topic); /// @brief Builds a NotificationsRequest from the given topic /// /// @param topic the UUri of the topic to build a notification request for /// @return the built NotificationsRequest - static NotificationsRequest BuildNotificationsRequest(const v1::UUri& topic); + static NotificationsRequest BuildNotificationsRequest( + const v1::UUri& topic); /// @brief Deserializes a protobuf message from a given payload. /// @@ -144,8 +150,7 @@ struct ProtoConverter { UPayloadFormat_INT_MAX_SENTINEL_DO_NOT_USE_: { v1::UStatus status; status.set_code(v1::UCode::UNIMPLEMENTED); - status.set_message( - "Unimplemented payload format."); + status.set_message("Unimplemented payload format."); return TOrStatus(UnexpectedStatus(status)); } default: { diff --git a/src/utils/ProtoConverter.cpp b/src/utils/ProtoConverter.cpp index 2f0cc378f..b6ee5403a 100644 --- a/src/utils/ProtoConverter.cpp +++ b/src/utils/ProtoConverter.cpp @@ -84,32 +84,36 @@ UnsubscribeRequest ProtoConverter::BuildUnSubscribeRequest( return unsubscribe_request; } -FetchSubscriptionsRequest ProtoConverter::BuildFetchSubscriptionsRequest(const v1::UUri& topic) { - FetchSubscriptionsRequest fetch_subscriptions_request; - *fetch_subscriptions_request.mutable_topic() = topic; +FetchSubscriptionsRequest ProtoConverter::BuildFetchSubscriptionsRequest( + const v1::UUri& topic) { + FetchSubscriptionsRequest fetch_subscriptions_request; + *fetch_subscriptions_request.mutable_topic() = topic; - return fetch_subscriptions_request; + return fetch_subscriptions_request; } -FetchSubscriptionsRequest ProtoConverter::BuildFetchSubscriptionsRequest(const SubscriberInfo& subscriber) { - FetchSubscriptionsRequest fetch_subscriptions_request; - *fetch_subscriptions_request.mutable_subscriber() = subscriber; +FetchSubscriptionsRequest ProtoConverter::BuildFetchSubscriptionsRequest( + const SubscriberInfo& subscriber) { + FetchSubscriptionsRequest fetch_subscriptions_request; + *fetch_subscriptions_request.mutable_subscriber() = subscriber; - return fetch_subscriptions_request; + return fetch_subscriptions_request; } -FetchSubscribersRequest ProtoConverter::BuildFetchSubscribersRequest(const v1::UUri& topic) { - FetchSubscribersRequest fetch_subscribers_request; - *fetch_subscribers_request.mutable_topic() = topic; +FetchSubscribersRequest ProtoConverter::BuildFetchSubscribersRequest( + const v1::UUri& topic) { + FetchSubscribersRequest fetch_subscribers_request; + *fetch_subscribers_request.mutable_topic() = topic; - return fetch_subscribers_request; + return fetch_subscribers_request; } -NotificationsRequest ProtoConverter::BuildNotificationsRequest(const v1::UUri& topic) { - NotificationsRequest notifications_request; - *notifications_request.mutable_topic() = topic; +NotificationsRequest ProtoConverter::BuildNotificationsRequest( + const v1::UUri& topic) { + NotificationsRequest notifications_request; + *notifications_request.mutable_topic() = topic; - return notifications_request; + return notifications_request; } } // namespace uprotocol::utils diff --git a/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp b/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp index 2de6e0a82..c5b28646c 100644 --- a/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp +++ b/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp @@ -43,7 +43,8 @@ class RequestBuilderTest : public ::testing::Test { source_.set_ue_version_major(SOURCE_UE_VERSION_MAJOR); source_.set_resource_id(SOURCE_RESOURCE_ID); - wrong_topic_.set_authority_name("10.0.0.2"); // random different authority + wrong_topic_.set_authority_name( + "10.0.0.2"); // random different authority wrong_topic_.set_ue_id(SOURCE_UE_ID); wrong_topic_.set_ue_version_major(SOURCE_UE_VERSION_MAJOR); wrong_topic_.set_resource_id(SOURCE_RESOURCE_ID); @@ -83,70 +84,83 @@ TEST_F(RequestBuilderTest, BuildSubscriptionRequestWithOptions) { EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); EXPECT_NE(request.topic().SerializeAsString(), getWrongTopic().SerializeAsString()); - EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.SubscriptionRequest"); + EXPECT_EQ(request.GetTypeName(), + "uprotocol.core.usubscription.v3.SubscriptionRequest"); } TEST_F(RequestBuilderTest, BuildUnsubscribeRequest) { - v1::UUri topic = getSource(); - RequestBuilder builder(options_); + v1::UUri topic = getSource(); + RequestBuilder builder(options_); - UnsubscribeRequest request = builder.buildUnsubscribeRequest(topic); + UnsubscribeRequest request = builder.buildUnsubscribeRequest(topic); - // Verify the attributes in the request - EXPECT_TRUE(request.has_topic()); - EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), getWrongTopic().SerializeAsString()); - EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.UnsubscribeRequest"); + // Verify the attributes in the request + EXPECT_TRUE(request.has_topic()); + EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); + EXPECT_NE(request.topic().SerializeAsString(), + getWrongTopic().SerializeAsString()); + EXPECT_EQ(request.GetTypeName(), + "uprotocol.core.usubscription.v3.UnsubscribeRequest"); } TEST_F(RequestBuilderTest, BuildFetchSubscriptionsRequestWithTopic) { - v1::UUri topic = getSource(); + v1::UUri topic = getSource(); RequestBuilder builder(options_); - FetchSubscriptionsRequest request = builder.buildFetchSubscriptionsRequest(topic); + FetchSubscriptionsRequest request = + builder.buildFetchSubscriptionsRequest(topic); - // Verify the attributes in the request - EXPECT_TRUE(request.has_topic()); + // Verify the attributes in the request + EXPECT_TRUE(request.has_topic()); EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), getWrongTopic().SerializeAsString()); - EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.FetchSubscriptionsRequest"); + EXPECT_NE(request.topic().SerializeAsString(), + getWrongTopic().SerializeAsString()); + EXPECT_EQ(request.GetTypeName(), + "uprotocol.core.usubscription.v3.FetchSubscriptionsRequest"); } TEST_F(RequestBuilderTest, BuildFetchSubscriptionsRequestWithSubscriberInfo) { - SubscriberInfo subscriber; + SubscriberInfo subscriber; RequestBuilder builder(options_); - FetchSubscriptionsRequest request = builder.buildFetchSubscriptionsRequest(subscriber); + FetchSubscriptionsRequest request = + builder.buildFetchSubscriptionsRequest(subscriber); - // Verify the attributes in the request - EXPECT_FALSE(request.has_topic()); - EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.FetchSubscriptionsRequest"); + // Verify the attributes in the request + EXPECT_FALSE(request.has_topic()); + EXPECT_EQ(request.GetTypeName(), + "uprotocol.core.usubscription.v3.FetchSubscriptionsRequest"); } TEST_F(RequestBuilderTest, BuildFetchSubscribersRequest) { - v1::UUri topic = getSource(); - RequestBuilder builder(options_); + v1::UUri topic = getSource(); + RequestBuilder builder(options_); - FetchSubscribersRequest request = builder.buildFetchSubscribersRequest(topic); + FetchSubscribersRequest request = + builder.buildFetchSubscribersRequest(topic); - // Verify the attributes in the request - EXPECT_TRUE(request.has_topic()); - EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), getWrongTopic().SerializeAsString()); - EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.FetchSubscribersRequest"); + // Verify the attributes in the request + EXPECT_TRUE(request.has_topic()); + EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); + EXPECT_NE(request.topic().SerializeAsString(), + getWrongTopic().SerializeAsString()); + EXPECT_EQ(request.GetTypeName(), + "uprotocol.core.usubscription.v3.FetchSubscribersRequest"); } TEST_F(RequestBuilderTest, BuildNotificationsRequest) { - v1::UUri topic = getSource(); - RequestBuilder builder(options_); + v1::UUri topic = getSource(); + RequestBuilder builder(options_); - NotificationsRequest request = builder.buildNotificationsRequest(topic); + NotificationsRequest request = builder.buildNotificationsRequest(topic); - // Verify the attributes in the request - EXPECT_TRUE(request.has_topic()); - EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), getWrongTopic().SerializeAsString()); - EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.NotificationsRequest"); + // Verify the attributes in the request + EXPECT_TRUE(request.has_topic()); + EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); + EXPECT_NE(request.topic().SerializeAsString(), + getWrongTopic().SerializeAsString()); + EXPECT_EQ(request.GetTypeName(), + "uprotocol.core.usubscription.v3.NotificationsRequest"); } } // namespace uprotocol::core::usubscription::v3 diff --git a/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp b/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp index 2eb6f9bf9..c01703a78 100644 --- a/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp +++ b/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp @@ -11,8 +11,10 @@ using UMessage = uprotocol::v1::UMessage; using Payload = uprotocol::datamodel::builder::Payload; using ProtoConverter = uprotocol::utils::ProtoConverter; -using SubscriptionRequest = uprotocol::core::usubscription::v3::SubscriptionRequest; -using SubscriptionResponse = uprotocol::core::usubscription::v3::SubscriptionResponse; +using SubscriptionRequest = + uprotocol::core::usubscription::v3::SubscriptionRequest; +using SubscriptionResponse = + uprotocol::core::usubscription::v3::SubscriptionResponse; namespace { @@ -104,9 +106,9 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayload) { [&server_callback_executed, &server_capture, &server_response](const UMessage& message) -> std::optional { server_callback_executed = true; - auto request_or_status = ProtoConverter::extractFromProtobuf< - SubscriptionRequest>( - message); + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); if (!request_or_status.has_value()) { return std::nullopt; } @@ -126,14 +128,13 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayload) { const auto subscription_request = getRequestBuilder().buildSubscriptionRequest(getSubscriptionTopic()); - auto response_or_status_future = std::async( - std::launch::async, - [&client, &subscription_request]() - -> uprotocol::utils::Expected< - SubscriptionResponse, - uprotocol::v1::UStatus> { - return client.subscribe(subscription_request); - }); + auto response_or_status_future = + std::async(std::launch::async, + [&client, &subscription_request]() + -> uprotocol::utils::Expected { + return client.subscribe(subscription_request); + }); // wait to give the client time to send the request. Otherwise this would // cause a race condition @@ -172,19 +173,19 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoAnyPayload) { [&server_callback_executed, &server_capture, &server_response](const UMessage& message) -> std::optional { server_callback_executed = true; - auto request_or_status = ProtoConverter::extractFromProtobuf< - SubscriptionRequest>( - message); + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); if (!request_or_status.has_value()) { return std::nullopt; } server_capture = request_or_status.value(); - google::protobuf::Any any; - if(!any.PackFrom(server_response)) { - return std::nullopt; - } - Payload response_payload(any); - return response_payload; + google::protobuf::Any any; + if (!any.PackFrom(server_response)) { + return std::nullopt; + } + Payload response_payload(any); + return response_payload; }, uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF_WRAPPED_IN_ANY); @@ -198,14 +199,13 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoAnyPayload) { const auto subscription_request = getRequestBuilder().buildSubscriptionRequest(getSubscriptionTopic()); - auto response_or_status_future = std::async( - std::launch::async, - [&client, &subscription_request]() - -> uprotocol::utils::Expected< - SubscriptionResponse, - uprotocol::v1::UStatus> { - return client.subscribe(subscription_request); - }); + auto response_or_status_future = + std::async(std::launch::async, + [&client, &subscription_request]() + -> uprotocol::utils::Expected { + return client.subscribe(subscription_request); + }); // wait to give the client time to send the request. Otherwise this would // cause a race condition @@ -234,11 +234,12 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoAnyPayload) { server_response.SerializeAsString()); } -TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayloadDifferentTopic) { +TEST_F(RpcClientUSubscriptionTest, + SubscribeRoundtripWithValidProtoPayloadDifferentTopic) { bool server_callback_executed = false; SubscriptionRequest server_capture; SubscriptionResponse server_response; - + constexpr uint32_t TOPIC_UE = 4321; constexpr uint32_t TOPIC_RESOURCE_ID = 54321; uprotocol::v1::UUri wrong_subscription_topic; @@ -253,9 +254,9 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayloadDiffer [&server_callback_executed, &server_capture, &server_response](const UMessage& message) -> std::optional { server_callback_executed = true; - auto request_or_status = ProtoConverter::extractFromProtobuf< - SubscriptionRequest>( - message); + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); if (!request_or_status.has_value()) { return std::nullopt; } @@ -275,14 +276,13 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayloadDiffer const auto subscription_request = getRequestBuilder().buildSubscriptionRequest(getSubscriptionTopic()); - auto response_or_status_future = std::async( - std::launch::async, - [&client, &subscription_request]() - -> uprotocol::utils::Expected< - SubscriptionResponse, - uprotocol::v1::UStatus> { - return client.subscribe(subscription_request); - }); + auto response_or_status_future = + std::async(std::launch::async, + [&client, &subscription_request]() + -> uprotocol::utils::Expected { + return client.subscribe(subscription_request); + }); // wait to give the client time to send the request. Otherwise this would // cause a race condition @@ -306,7 +306,9 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayloadDiffer EXPECT_TRUE(getClientTransport()->getListener()); EXPECT_EQ(getClientTransport()->getSendCount(), 1); auto response_or_status = response_or_status_future.get(); - ASSERT_FALSE(response_or_status.has_value()); // Should fail because the topics do not match + ASSERT_FALSE( + response_or_status + .has_value()); // Should fail because the topics do not match } }; // namespace diff --git a/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp b/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp index b62ef5a85..fd623bc58 100644 --- a/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp +++ b/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp @@ -11,6 +11,7 @@ #include #include + #include "up-cpp/client/usubscription/v3/USubscriptionUUriBuilder.h" constexpr uint16_t RESOURCE_ID_TEST = 0x0001; @@ -19,52 +20,50 @@ constexpr uint16_t RESOURCE_ID_NOTIFICATION_ID = 0x8000; namespace uprotocol::core::usubscription::v3 { class USubscriptionUUriBuilderTest : public ::testing::Test { private: - v1::UUri expected_uri_; - v1::UUri wrong_uri_; -protected: - v1::UUri getExpectedUri() const { - return expected_uri_; - } - v1::UUri getWrongUri() const { - return wrong_uri_; - } - void SetUp() override { - expected_uri_.set_authority_name("core.usubscription"); - expected_uri_.set_ue_id(0); - expected_uri_.set_ue_version_major(3); + v1::UUri expected_uri_; + v1::UUri wrong_uri_; - wrong_uri_.set_authority_name("core.usubscription_wrong"); - wrong_uri_.set_ue_id(1); - wrong_uri_.set_ue_version_major(1); - wrong_uri_.set_resource_id(1); - } +protected: + v1::UUri getExpectedUri() const { return expected_uri_; } + v1::UUri getWrongUri() const { return wrong_uri_; } + void SetUp() override { + expected_uri_.set_authority_name("core.usubscription"); + expected_uri_.set_ue_id(0); + expected_uri_.set_ue_version_major(3); - void TearDown() override {} + wrong_uri_.set_authority_name("core.usubscription_wrong"); + wrong_uri_.set_ue_id(1); + wrong_uri_.set_ue_version_major(1); + wrong_uri_.set_resource_id(1); + } + void TearDown() override {} }; TEST_F(USubscriptionUUriBuilderTest, GetServiceUriWithResourceId) { - // Example test case for building a subscription UUri - auto expected_uri = getExpectedUri(); - expected_uri.set_resource_id(RESOURCE_ID_TEST); - USubscriptionUUriBuilder builder; - v1::UUri actual_uri = builder.getServiceUriWithResourceId(RESOURCE_ID_TEST); + // Example test case for building a subscription UUri + auto expected_uri = getExpectedUri(); + expected_uri.set_resource_id(RESOURCE_ID_TEST); + USubscriptionUUriBuilder builder; + v1::UUri actual_uri = builder.getServiceUriWithResourceId(RESOURCE_ID_TEST); - EXPECT_TRUE(actual_uri.IsInitialized()); - EXPECT_EQ(actual_uri.GetTypeName(), "uprotocol.v1.UUri"); - EXPECT_EQ(actual_uri.SerializeAsString(), expected_uri.SerializeAsString()); - EXPECT_NE(actual_uri.SerializeAsString(), getWrongUri().SerializeAsString()); + EXPECT_TRUE(actual_uri.IsInitialized()); + EXPECT_EQ(actual_uri.GetTypeName(), "uprotocol.v1.UUri"); + EXPECT_EQ(actual_uri.SerializeAsString(), expected_uri.SerializeAsString()); + EXPECT_NE(actual_uri.SerializeAsString(), + getWrongUri().SerializeAsString()); } -TEST_F(USubscriptionUUriBuilderTest, GetNotificationUri){ - auto expected_uri = getExpectedUri(); - expected_uri.set_resource_id(RESOURCE_ID_NOTIFICATION_ID); - USubscriptionUUriBuilder builder; - v1::UUri actual_uri = builder.getNotificationUri(); - EXPECT_TRUE(actual_uri.IsInitialized()); - EXPECT_EQ(actual_uri.GetTypeName(), "uprotocol.v1.UUri"); - EXPECT_EQ(actual_uri.SerializeAsString(), expected_uri.SerializeAsString()); - EXPECT_NE(actual_uri.SerializeAsString(), getWrongUri().SerializeAsString()); +TEST_F(USubscriptionUUriBuilderTest, GetNotificationUri) { + auto expected_uri = getExpectedUri(); + expected_uri.set_resource_id(RESOURCE_ID_NOTIFICATION_ID); + USubscriptionUUriBuilder builder; + v1::UUri actual_uri = builder.getNotificationUri(); + EXPECT_TRUE(actual_uri.IsInitialized()); + EXPECT_EQ(actual_uri.GetTypeName(), "uprotocol.v1.UUri"); + EXPECT_EQ(actual_uri.SerializeAsString(), expected_uri.SerializeAsString()); + EXPECT_NE(actual_uri.SerializeAsString(), + getWrongUri().SerializeAsString()); } -} // namespace uprotocol::core::usubscription::v3 +} // namespace uprotocol::core::usubscription::v3 From b2441d0c9f852b056cee6f55d07638a8a412875f Mon Sep 17 00:00:00 2001 From: Max Date: Wed, 28 May 2025 21:54:52 +0200 Subject: [PATCH 5/8] some test refactoring --- .../client/usubscription/v3/RequestBuilder.h | 18 ++--- .../usubscription/v3/RequestBuilder.cpp | 10 +-- .../usubscription/v3/RequestBuilderTest.cpp | 68 ++++++++----------- .../v3/USubscriptionUUriBuilderTest.cpp | 16 +---- 4 files changed, 44 insertions(+), 68 deletions(-) diff --git a/include/up-cpp/client/usubscription/v3/RequestBuilder.h b/include/up-cpp/client/usubscription/v3/RequestBuilder.h index 31402c086..ed75df836 100644 --- a/include/up-cpp/client/usubscription/v3/RequestBuilder.h +++ b/include/up-cpp/client/usubscription/v3/RequestBuilder.h @@ -61,7 +61,7 @@ struct RequestBuilder { /// @param topic The `v1::UUri` representing the topic to unsubscribe from. /// /// @return An `UnsubscribeRequest` configured for the specified topic. - static UnsubscribeRequest buildUnsubscribeRequest(const v1::UUri& topic); + UnsubscribeRequest buildUnsubscribeRequest(const v1::UUri& topic) const; /// @brief Build fetch subscritions request for a given topic. /// @@ -69,8 +69,8 @@ struct RequestBuilder { /// /// @return An `FetchSubscriptionsRequest` configured for the specified /// topic. - static FetchSubscriptionsRequest buildFetchSubscriptionsRequest( - const v1::UUri& topic); + FetchSubscriptionsRequest buildFetchSubscriptionsRequest( + const v1::UUri& topic) const; /// @brief Build fetch subscritions request for a given subscriber. /// @@ -79,16 +79,16 @@ struct RequestBuilder { /// /// @return An `FetchSubscriptionsRequest` configured for the specified /// subscriber. - static FetchSubscriptionsRequest buildFetchSubscriptionsRequest( - const SubscriberInfo& subscriber); + FetchSubscriptionsRequest buildFetchSubscriptionsRequest( + const SubscriberInfo& subscriber) const; /// @brief Build fetch subscribers request for a given topic. /// /// @param topic The `v1::UUri` representing the topic to fetch. /// /// @return An `FetchSubscribersRequest` configured for the specified topic. - static FetchSubscribersRequest buildFetchSubscribersRequest( - const v1::UUri& topic); + FetchSubscribersRequest buildFetchSubscribersRequest( + const v1::UUri& topic) const ; /// @brief Build notifications request for a given topic. Subscription /// change @@ -99,8 +99,8 @@ struct RequestBuilder { /// for/from. /// /// @return An `NotificationsRequest` configured for the specified topic. - static NotificationsRequest buildNotificationsRequest( - const v1::UUri& topic); + NotificationsRequest buildNotificationsRequest( + const v1::UUri& topic) const; private: USubscriptionOptions options_; ///< Options used to configure the requests. diff --git a/src/client/usubscription/v3/RequestBuilder.cpp b/src/client/usubscription/v3/RequestBuilder.cpp index cbdfb4af7..3e36c3b8c 100644 --- a/src/client/usubscription/v3/RequestBuilder.cpp +++ b/src/client/usubscription/v3/RequestBuilder.cpp @@ -25,27 +25,27 @@ SubscriptionRequest RequestBuilder::buildSubscriptionRequest( } UnsubscribeRequest RequestBuilder::buildUnsubscribeRequest( - const v1::UUri& topic) { + const v1::UUri& topic) const { return utils::ProtoConverter::BuildUnSubscribeRequest(topic); } FetchSubscriptionsRequest RequestBuilder::buildFetchSubscriptionsRequest( - const v1::UUri& topic) { + const v1::UUri& topic) const { return utils::ProtoConverter::BuildFetchSubscriptionsRequest(topic); } FetchSubscriptionsRequest RequestBuilder::buildFetchSubscriptionsRequest( - const SubscriberInfo& subscriber) { + const SubscriberInfo& subscriber) const { return utils::ProtoConverter::BuildFetchSubscriptionsRequest(subscriber); } FetchSubscribersRequest RequestBuilder::buildFetchSubscribersRequest( - const v1::UUri& topic) { + const v1::UUri& topic) const { return utils::ProtoConverter::BuildFetchSubscribersRequest(topic); } NotificationsRequest RequestBuilder::buildNotificationsRequest( - const v1::UUri& topic) { + const v1::UUri& topic) const { return utils::ProtoConverter::BuildNotificationsRequest(topic); } diff --git a/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp b/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp index c5b28646c..d30013735 100644 --- a/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp +++ b/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp @@ -29,12 +29,10 @@ namespace uprotocol::core::usubscription::v3 { class RequestBuilderTest : public ::testing::Test { private: v1::UUri source_; - v1::UUri wrong_topic_; protected: USubscriptionOptions options_; const v1::UUri& getSource() const { return source_; } - const v1::UUri& getWrongTopic() const { return wrong_topic_; } void SetUp() override { // Create a UUri object for testing @@ -43,17 +41,11 @@ class RequestBuilderTest : public ::testing::Test { source_.set_ue_version_major(SOURCE_UE_VERSION_MAJOR); source_.set_resource_id(SOURCE_RESOURCE_ID); - wrong_topic_.set_authority_name( - "10.0.0.2"); // random different authority - wrong_topic_.set_ue_id(SOURCE_UE_ID); - wrong_topic_.set_ue_version_major(SOURCE_UE_VERSION_MAJOR); - wrong_topic_.set_resource_id(SOURCE_RESOURCE_ID); - options_.permission_level = 2; options_.token = "sample_token"; options_.when_expire = - std::chrono::system_clock::now() + std::chrono::milliseconds(1000); - options_.sample_period_ms = std::chrono::milliseconds(1000); + std::chrono::system_clock::now() + std::chrono::milliseconds(1); + options_.sample_period_ms = std::chrono::seconds(1); options_.subscriber_details = google::protobuf::Any(); options_.subscription_details = google::protobuf::Any(); } @@ -73,58 +65,55 @@ class RequestBuilderTest : public ::testing::Test { }; TEST_F(RequestBuilderTest, BuildSubscriptionRequestWithOptions) { - v1::UUri topic = getSource(); - RequestBuilder builder(options_); + const v1::UUri topic = getSource(); + const RequestBuilder builder(options_); - SubscriptionRequest request = builder.buildSubscriptionRequest(topic); + SubscriptionRequest request; + ASSERT_NO_THROW(request = builder.buildSubscriptionRequest(topic)); // Verify the attributes in the request + //TODO(max) there should probably be some test that explicitely checks data from the options EXPECT_TRUE(request.has_topic()); EXPECT_TRUE(request.has_attributes()); EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), - getWrongTopic().SerializeAsString()); EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.SubscriptionRequest"); } TEST_F(RequestBuilderTest, BuildUnsubscribeRequest) { - v1::UUri topic = getSource(); - RequestBuilder builder(options_); + const v1::UUri topic = getSource(); + const RequestBuilder builder(options_); - UnsubscribeRequest request = builder.buildUnsubscribeRequest(topic); + UnsubscribeRequest request; + ASSERT_NO_THROW(request = builder.buildUnsubscribeRequest(topic)); // Verify the attributes in the request EXPECT_TRUE(request.has_topic()); EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), - getWrongTopic().SerializeAsString()); EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.UnsubscribeRequest"); } TEST_F(RequestBuilderTest, BuildFetchSubscriptionsRequestWithTopic) { - v1::UUri topic = getSource(); - RequestBuilder builder(options_); + const v1::UUri topic = getSource(); + const RequestBuilder builder(options_); - FetchSubscriptionsRequest request = - builder.buildFetchSubscriptionsRequest(topic); + FetchSubscriptionsRequest request; + ASSERT_NO_THROW(request = builder.buildFetchSubscriptionsRequest(topic)); // Verify the attributes in the request EXPECT_TRUE(request.has_topic()); EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), - getWrongTopic().SerializeAsString()); EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.FetchSubscriptionsRequest"); } TEST_F(RequestBuilderTest, BuildFetchSubscriptionsRequestWithSubscriberInfo) { - SubscriberInfo subscriber; - RequestBuilder builder(options_); + const SubscriberInfo subscriber; + const RequestBuilder builder(options_); - FetchSubscriptionsRequest request = - builder.buildFetchSubscriptionsRequest(subscriber); + FetchSubscriptionsRequest request; + ASSERT_NO_THROW(request =builder.buildFetchSubscriptionsRequest(subscriber)); // Verify the attributes in the request EXPECT_FALSE(request.has_topic()); @@ -133,32 +122,29 @@ TEST_F(RequestBuilderTest, BuildFetchSubscriptionsRequestWithSubscriberInfo) { } TEST_F(RequestBuilderTest, BuildFetchSubscribersRequest) { - v1::UUri topic = getSource(); - RequestBuilder builder(options_); + const v1::UUri topic = getSource(); + const RequestBuilder builder(options_); - FetchSubscribersRequest request = - builder.buildFetchSubscribersRequest(topic); + FetchSubscribersRequest request; + ASSERT_NO_THROW(request = builder.buildFetchSubscribersRequest(topic)); // Verify the attributes in the request EXPECT_TRUE(request.has_topic()); EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), - getWrongTopic().SerializeAsString()); EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.FetchSubscribersRequest"); } TEST_F(RequestBuilderTest, BuildNotificationsRequest) { - v1::UUri topic = getSource(); - RequestBuilder builder(options_); + const v1::UUri topic = getSource(); + const RequestBuilder builder(options_); - NotificationsRequest request = builder.buildNotificationsRequest(topic); + NotificationsRequest request; + ASSERT_NO_THROW(request = builder.buildNotificationsRequest(topic)); // Verify the attributes in the request EXPECT_TRUE(request.has_topic()); EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); - EXPECT_NE(request.topic().SerializeAsString(), - getWrongTopic().SerializeAsString()); EXPECT_EQ(request.GetTypeName(), "uprotocol.core.usubscription.v3.NotificationsRequest"); } diff --git a/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp b/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp index fd623bc58..082d16d1d 100644 --- a/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp +++ b/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp @@ -21,20 +21,14 @@ namespace uprotocol::core::usubscription::v3 { class USubscriptionUUriBuilderTest : public ::testing::Test { private: v1::UUri expected_uri_; - v1::UUri wrong_uri_; protected: v1::UUri getExpectedUri() const { return expected_uri_; } - v1::UUri getWrongUri() const { return wrong_uri_; } + void SetUp() override { expected_uri_.set_authority_name("core.usubscription"); expected_uri_.set_ue_id(0); expected_uri_.set_ue_version_major(3); - - wrong_uri_.set_authority_name("core.usubscription_wrong"); - wrong_uri_.set_ue_id(1); - wrong_uri_.set_ue_version_major(1); - wrong_uri_.set_resource_id(1); } void TearDown() override {} @@ -44,14 +38,12 @@ TEST_F(USubscriptionUUriBuilderTest, GetServiceUriWithResourceId) { // Example test case for building a subscription UUri auto expected_uri = getExpectedUri(); expected_uri.set_resource_id(RESOURCE_ID_TEST); - USubscriptionUUriBuilder builder; - v1::UUri actual_uri = builder.getServiceUriWithResourceId(RESOURCE_ID_TEST); + const USubscriptionUUriBuilder builder; + const v1::UUri actual_uri = builder.getServiceUriWithResourceId(RESOURCE_ID_TEST); EXPECT_TRUE(actual_uri.IsInitialized()); EXPECT_EQ(actual_uri.GetTypeName(), "uprotocol.v1.UUri"); EXPECT_EQ(actual_uri.SerializeAsString(), expected_uri.SerializeAsString()); - EXPECT_NE(actual_uri.SerializeAsString(), - getWrongUri().SerializeAsString()); } TEST_F(USubscriptionUUriBuilderTest, GetNotificationUri) { @@ -62,8 +54,6 @@ TEST_F(USubscriptionUUriBuilderTest, GetNotificationUri) { EXPECT_TRUE(actual_uri.IsInitialized()); EXPECT_EQ(actual_uri.GetTypeName(), "uprotocol.v1.UUri"); EXPECT_EQ(actual_uri.SerializeAsString(), expected_uri.SerializeAsString()); - EXPECT_NE(actual_uri.SerializeAsString(), - getWrongUri().SerializeAsString()); } } // namespace uprotocol::core::usubscription::v3 From 584fac6a634f1b5ec350b8d8c973399c1313b2bd Mon Sep 17 00:00:00 2001 From: Max Date: Thu, 29 May 2025 13:59:46 +0200 Subject: [PATCH 6/8] added more tests --- .../client/usubscription/v3/RequestBuilder.h | 8 + .../usubscription/v3/RequestBuilder.cpp | 6 + .../v3/RpcClientUSubscriptionTest.cpp | 290 +++++++++++++++++- 3 files changed, 295 insertions(+), 9 deletions(-) diff --git a/include/up-cpp/client/usubscription/v3/RequestBuilder.h b/include/up-cpp/client/usubscription/v3/RequestBuilder.h index ed75df836..f07ba1b53 100644 --- a/include/up-cpp/client/usubscription/v3/RequestBuilder.h +++ b/include/up-cpp/client/usubscription/v3/RequestBuilder.h @@ -42,6 +42,8 @@ struct USubscriptionOptions { /// This struct facilitates the construction of requests based on /// `USubscriptionOptions`, providing methods to build different requests. struct RequestBuilder { + + /// @brief Constructs a RequestBuilder with the given subscription options. /// /// @param options Subscription options to configure the requests. Defaults @@ -49,6 +51,12 @@ struct RequestBuilder { explicit RequestBuilder(USubscriptionOptions options = {}) : options_(std::move(options)) {} + /// @brief Sets the permission level for the requests build by the builder + /// + /// @param permission_level to be set + /// @return returns a reference to the builder struct to allow chaining + RequestBuilder& setPremissionLevel(uint32_t permission_level); + /// @brief Builds a subscription request for a given topic. /// /// @param topic The `v1::UUri` representing the topic for the subscription. diff --git a/src/client/usubscription/v3/RequestBuilder.cpp b/src/client/usubscription/v3/RequestBuilder.cpp index 3e36c3b8c..c0cf1084b 100644 --- a/src/client/usubscription/v3/RequestBuilder.cpp +++ b/src/client/usubscription/v3/RequestBuilder.cpp @@ -24,6 +24,12 @@ SubscriptionRequest RequestBuilder::buildSubscriptionRequest( return utils::ProtoConverter::BuildSubscriptionRequest(topic, attributes); } +RequestBuilder& RequestBuilder::setPremissionLevel(uint32_t permission_level) { + options_.permission_level = permission_level; + return *this; +} + + UnsubscribeRequest RequestBuilder::buildUnsubscribeRequest( const v1::UUri& topic) const { return utils::ProtoConverter::BuildUnSubscribeRequest(topic); diff --git a/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp b/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp index c01703a78..718d5d167 100644 --- a/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp +++ b/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp @@ -21,6 +21,10 @@ namespace { constexpr uint32_t UE_VERSION_MAJOR = 3; constexpr uint32_t CLIENT_UE_ID = 23492; +constexpr int ITERATIONS_TILL_TIMEOUT = 10; +constexpr std::chrono::milliseconds MILLISECONDS_PER_ITERATION = + std::chrono::milliseconds(50); + class RpcClientUSubscriptionTest : public testing::Test { protected: // Run once per TEST_F.s @@ -96,6 +100,10 @@ class RpcClientUSubscriptionTest : public testing::Test { ~RpcClientUSubscriptionTest() override = default; }; +// +//Tests for subscribe method +// + TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayload) { bool server_callback_executed = false; SubscriptionRequest server_capture; @@ -138,9 +146,6 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayload) { // wait to give the client time to send the request. Otherwise this would // cause a race condition - constexpr int ITERATIONS_TILL_TIMEOUT = 10; - constexpr std::chrono::milliseconds MILLISECONDS_PER_ITERATION = - std::chrono::milliseconds(100); int counter = ITERATIONS_TILL_TIMEOUT; while (counter > 0 && getClientTransport()->getSendCount() == 0) { counter--; @@ -209,9 +214,6 @@ TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoAnyPayload) { // wait to give the client time to send the request. Otherwise this would // cause a race condition - constexpr int ITERATIONS_TILL_TIMEOUT = 10; - constexpr std::chrono::milliseconds MILLISECONDS_PER_ITERATION = - std::chrono::milliseconds(100); int counter = ITERATIONS_TILL_TIMEOUT; while (counter > 0 && getClientTransport()->getSendCount() == 0) { counter--; @@ -286,9 +288,6 @@ TEST_F(RpcClientUSubscriptionTest, // wait to give the client time to send the request. Otherwise this would // cause a race condition - constexpr int ITERATIONS_TILL_TIMEOUT = 10; - constexpr std::chrono::milliseconds MILLISECONDS_PER_ITERATION = - std::chrono::milliseconds(100); int counter = ITERATIONS_TILL_TIMEOUT; while (counter > 0 && getClientTransport()->getSendCount() == 0) { counter--; @@ -311,4 +310,277 @@ TEST_F(RpcClientUSubscriptionTest, .has_value()); // Should fail because the topics do not match } +//////////////////////////////// +//Tests for unsubscribe method// +//////////////////////////////// + +using UnsubscibeRequest = uprotocol::core::usubscription::v3::UnsubscribeRequest; +using UnsubscribeResponse = uprotocol::core::usubscription::v3::UnsubscribeResponse; + +TEST_F(RpcClientUSubscriptionTest, UnsubscribeRoundtripWithValidProtoPayload) { + bool server_callback_executed = false; + UnsubscibeRequest server_capture; + UnsubscribeResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + Payload response_payload(server_response); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const auto unsubscribe_request = + getRequestBuilder().buildUnsubscribeRequest(getSubscriptionTopic()); + + auto response_or_status_future = + std::async(std::launch::async, + [&client, &unsubscribe_request]() + -> uprotocol::utils::Expected { + return client.unsubscribe(unsubscribe_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + unsubscribe_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + +TEST_F(RpcClientUSubscriptionTest, UnsubscribeRoundtripWithValidProtoAnyPayload) { + bool server_callback_executed = false; + UnsubscibeRequest server_capture; + UnsubscribeResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + google::protobuf::Any any; + if (!any.PackFrom(server_response)) { + return std::nullopt; + } + Payload response_payload(any); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF_WRAPPED_IN_ANY); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const auto unsubscribe_request = + getRequestBuilder().buildUnsubscribeRequest(getSubscriptionTopic()); + + auto response_or_status_future = + std::async(std::launch::async, + [&client, &unsubscribe_request]() + -> uprotocol::utils::Expected { + return client.unsubscribe(unsubscribe_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + unsubscribe_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + +//////////////////////////////// +//Tests for fetch_subscribers method// +//////////////////////////////// + +using FetchSubscribersRequest = uprotocol::core::usubscription::v3::FetchSubscribersRequest; +using FetchSubscribersResponse = uprotocol::core::usubscription::v3::FetchSubscribersResponse; + +TEST_F(RpcClientUSubscriptionTest, fetchSubscriberRoundtripWithValidProtoPayload) { + bool server_callback_executed = false; + FetchSubscribersRequest server_capture; + FetchSubscribersResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + Payload response_payload(server_response); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const auto fetch_subscribers_request = + getRequestBuilder().buildFetchSubscribersRequest(getSubscriptionTopic()); + + auto response_or_status_future = + std::async(std::launch::async, + [&client, &fetch_subscribers_request]() + -> uprotocol::utils::Expected { + return client.fetch_subscribers(fetch_subscribers_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + fetch_subscribers_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + +TEST_F(RpcClientUSubscriptionTest, FetchSubscriberRoundtripWithValidProtoAnyPayload) { + bool server_callback_executed = false; + FetchSubscribersRequest server_capture; + FetchSubscribersResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + google::protobuf::Any any; + if (!any.PackFrom(server_response)) { + return std::nullopt; + } + Payload response_payload(any); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF_WRAPPED_IN_ANY); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const auto fetch_subscribers_request = + getRequestBuilder().buildFetchSubscribersRequest(getSubscriptionTopic()); + + auto response_or_status_future = + std::async(std::launch::async, + [&client, &fetch_subscribers_request]() + -> uprotocol::utils::Expected { + return client.fetch_subscribers(fetch_subscribers_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + fetch_subscribers_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} }; // namespace From 0c60d3fd12b216b4d6d4517934ccac3eea7e33eb Mon Sep 17 00:00:00 2001 From: Max Date: Thu, 29 May 2025 14:28:05 +0200 Subject: [PATCH 7/8] added more tests --- .../client/usubscription/v3/RequestBuilder.h | 7 +- .../usubscription/v3/RequestBuilder.cpp | 1 - .../usubscription/v3/RequestBuilderTest.cpp | 6 +- .../v3/RpcClientUSubscriptionTest.cpp | 495 ++++++++++++++++-- .../v3/USubscriptionUUriBuilderTest.cpp | 3 +- 5 files changed, 472 insertions(+), 40 deletions(-) diff --git a/include/up-cpp/client/usubscription/v3/RequestBuilder.h b/include/up-cpp/client/usubscription/v3/RequestBuilder.h index f07ba1b53..ad16392d8 100644 --- a/include/up-cpp/client/usubscription/v3/RequestBuilder.h +++ b/include/up-cpp/client/usubscription/v3/RequestBuilder.h @@ -42,8 +42,6 @@ struct USubscriptionOptions { /// This struct facilitates the construction of requests based on /// `USubscriptionOptions`, providing methods to build different requests. struct RequestBuilder { - - /// @brief Constructs a RequestBuilder with the given subscription options. /// /// @param options Subscription options to configure the requests. Defaults @@ -96,7 +94,7 @@ struct RequestBuilder { /// /// @return An `FetchSubscribersRequest` configured for the specified topic. FetchSubscribersRequest buildFetchSubscribersRequest( - const v1::UUri& topic) const ; + const v1::UUri& topic) const; /// @brief Build notifications request for a given topic. Subscription /// change @@ -107,8 +105,7 @@ struct RequestBuilder { /// for/from. /// /// @return An `NotificationsRequest` configured for the specified topic. - NotificationsRequest buildNotificationsRequest( - const v1::UUri& topic) const; + NotificationsRequest buildNotificationsRequest(const v1::UUri& topic) const; private: USubscriptionOptions options_; ///< Options used to configure the requests. diff --git a/src/client/usubscription/v3/RequestBuilder.cpp b/src/client/usubscription/v3/RequestBuilder.cpp index c0cf1084b..7e30b4cbc 100644 --- a/src/client/usubscription/v3/RequestBuilder.cpp +++ b/src/client/usubscription/v3/RequestBuilder.cpp @@ -29,7 +29,6 @@ RequestBuilder& RequestBuilder::setPremissionLevel(uint32_t permission_level) { return *this; } - UnsubscribeRequest RequestBuilder::buildUnsubscribeRequest( const v1::UUri& topic) const { return utils::ProtoConverter::BuildUnSubscribeRequest(topic); diff --git a/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp b/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp index d30013735..6b5c0d50e 100644 --- a/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp +++ b/test/coverage/client/usubscription/v3/RequestBuilderTest.cpp @@ -72,7 +72,8 @@ TEST_F(RequestBuilderTest, BuildSubscriptionRequestWithOptions) { ASSERT_NO_THROW(request = builder.buildSubscriptionRequest(topic)); // Verify the attributes in the request - //TODO(max) there should probably be some test that explicitely checks data from the options + // TODO(max) there should probably be some test that explicitely checks data + // from the options EXPECT_TRUE(request.has_topic()); EXPECT_TRUE(request.has_attributes()); EXPECT_EQ(request.topic().SerializeAsString(), topic.SerializeAsString()); @@ -113,7 +114,8 @@ TEST_F(RequestBuilderTest, BuildFetchSubscriptionsRequestWithSubscriberInfo) { const RequestBuilder builder(options_); FetchSubscriptionsRequest request; - ASSERT_NO_THROW(request =builder.buildFetchSubscriptionsRequest(subscriber)); + ASSERT_NO_THROW(request = + builder.buildFetchSubscriptionsRequest(subscriber)); // Verify the attributes in the request EXPECT_FALSE(request.has_topic()); diff --git a/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp b/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp index 718d5d167..2703f459a 100644 --- a/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp +++ b/test/coverage/client/usubscription/v3/RpcClientUSubscriptionTest.cpp @@ -23,7 +23,7 @@ constexpr uint32_t CLIENT_UE_ID = 23492; constexpr int ITERATIONS_TILL_TIMEOUT = 10; constexpr std::chrono::milliseconds MILLISECONDS_PER_ITERATION = - std::chrono::milliseconds(50); + std::chrono::milliseconds(50); class RpcClientUSubscriptionTest : public testing::Test { protected: @@ -101,7 +101,7 @@ class RpcClientUSubscriptionTest : public testing::Test { }; // -//Tests for subscribe method +// Tests for subscribe method // TEST_F(RpcClientUSubscriptionTest, SubscribeRoundtripWithValidProtoPayload) { @@ -311,11 +311,13 @@ TEST_F(RpcClientUSubscriptionTest, } //////////////////////////////// -//Tests for unsubscribe method// +// Tests for unsubscribe method// //////////////////////////////// -using UnsubscibeRequest = uprotocol::core::usubscription::v3::UnsubscribeRequest; -using UnsubscribeResponse = uprotocol::core::usubscription::v3::UnsubscribeResponse; +using UnsubscibeRequest = + uprotocol::core::usubscription::v3::UnsubscribeRequest; +using UnsubscribeResponse = + uprotocol::core::usubscription::v3::UnsubscribeResponse; TEST_F(RpcClientUSubscriptionTest, UnsubscribeRoundtripWithValidProtoPayload) { bool server_callback_executed = false; @@ -327,8 +329,7 @@ TEST_F(RpcClientUSubscriptionTest, UnsubscribeRoundtripWithValidProtoPayload) { &server_response](const UMessage& message) -> std::optional { server_callback_executed = true; auto request_or_status = - ProtoConverter::extractFromProtobuf( - message); + ProtoConverter::extractFromProtobuf(message); if (!request_or_status.has_value()) { return std::nullopt; } @@ -380,7 +381,8 @@ TEST_F(RpcClientUSubscriptionTest, UnsubscribeRoundtripWithValidProtoPayload) { server_response.SerializeAsString()); } -TEST_F(RpcClientUSubscriptionTest, UnsubscribeRoundtripWithValidProtoAnyPayload) { +TEST_F(RpcClientUSubscriptionTest, + UnsubscribeRoundtripWithValidProtoAnyPayload) { bool server_callback_executed = false; UnsubscibeRequest server_capture; UnsubscribeResponse server_response; @@ -390,8 +392,7 @@ TEST_F(RpcClientUSubscriptionTest, UnsubscribeRoundtripWithValidProtoAnyPayload) &server_response](const UMessage& message) -> std::optional { server_callback_executed = true; auto request_or_status = - ProtoConverter::extractFromProtobuf( - message); + ProtoConverter::extractFromProtobuf(message); if (!request_or_status.has_value()) { return std::nullopt; } @@ -448,13 +449,16 @@ TEST_F(RpcClientUSubscriptionTest, UnsubscribeRoundtripWithValidProtoAnyPayload) } //////////////////////////////// -//Tests for fetch_subscribers method// +// Tests for fetch_subscribers method// //////////////////////////////// -using FetchSubscribersRequest = uprotocol::core::usubscription::v3::FetchSubscribersRequest; -using FetchSubscribersResponse = uprotocol::core::usubscription::v3::FetchSubscribersResponse; +using FetchSubscribersRequest = + uprotocol::core::usubscription::v3::FetchSubscribersRequest; +using FetchSubscribersResponse = + uprotocol::core::usubscription::v3::FetchSubscribersResponse; -TEST_F(RpcClientUSubscriptionTest, fetchSubscriberRoundtripWithValidProtoPayload) { +TEST_F(RpcClientUSubscriptionTest, + fetchSubscriberRoundtripWithValidProtoPayload) { bool server_callback_executed = false; FetchSubscribersRequest server_capture; FetchSubscribersResponse server_response; @@ -483,15 +487,16 @@ TEST_F(RpcClientUSubscriptionTest, fetchSubscriberRoundtripWithValidProtoPayload getClientTransport()); const auto fetch_subscribers_request = - getRequestBuilder().buildFetchSubscribersRequest(getSubscriptionTopic()); + getRequestBuilder().buildFetchSubscribersRequest( + getSubscriptionTopic()); - auto response_or_status_future = - std::async(std::launch::async, - [&client, &fetch_subscribers_request]() - -> uprotocol::utils::Expected { - return client.fetch_subscribers(fetch_subscribers_request); - }); + auto response_or_status_future = std::async( + std::launch::async, + [&client, &fetch_subscribers_request]() + -> uprotocol::utils::Expected { + return client.fetch_subscribers(fetch_subscribers_request); + }); // wait to give the client time to send the request. Otherwise this would // cause a race condition @@ -517,7 +522,8 @@ TEST_F(RpcClientUSubscriptionTest, fetchSubscriberRoundtripWithValidProtoPayload server_response.SerializeAsString()); } -TEST_F(RpcClientUSubscriptionTest, FetchSubscriberRoundtripWithValidProtoAnyPayload) { +TEST_F(RpcClientUSubscriptionTest, + FetchSubscriberRoundtripWithValidProtoAnyPayload) { bool server_callback_executed = false; FetchSubscribersRequest server_capture; FetchSubscribersResponse server_response; @@ -550,15 +556,159 @@ TEST_F(RpcClientUSubscriptionTest, FetchSubscriberRoundtripWithValidProtoAnyPayl getClientTransport()); const auto fetch_subscribers_request = - getRequestBuilder().buildFetchSubscribersRequest(getSubscriptionTopic()); + getRequestBuilder().buildFetchSubscribersRequest( + getSubscriptionTopic()); - auto response_or_status_future = - std::async(std::launch::async, - [&client, &fetch_subscribers_request]() - -> uprotocol::utils::Expected { - return client.fetch_subscribers(fetch_subscribers_request); - }); + auto response_or_status_future = std::async( + std::launch::async, + [&client, &fetch_subscribers_request]() + -> uprotocol::utils::Expected { + return client.fetch_subscribers(fetch_subscribers_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + fetch_subscribers_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + +//////////////////////////////// +// Tests for fetch_subscriptions method// +//////////////////////////////// + +using FetchSubscriptionsRequest = + uprotocol::core::usubscription::v3::FetchSubscriptionsRequest; +using FetchSubscriptionsResponse = + uprotocol::core::usubscription::v3::FetchSubscriptionsResponse; + +TEST_F(RpcClientUSubscriptionTest, + fetchSubscriptionsRoundtripWithValidProtoPayload) { + bool server_callback_executed = false; + FetchSubscriptionsRequest server_capture; + FetchSubscriptionsResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + Payload response_payload(server_response); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const uprotocol::core::usubscription::v3::SubscriberInfo subscriber_info; + const auto fetch_subscriptions_request = + getRequestBuilder().buildFetchSubscriptionsRequest(subscriber_info); + + auto response_or_status_future = std::async( + std::launch::async, + [&client, &fetch_subscriptions_request]() + -> uprotocol::utils::Expected { + return client.fetch_subscriptions(fetch_subscriptions_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + fetch_subscriptions_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + +TEST_F(RpcClientUSubscriptionTest, + fetchSubscriptionRoundtripWithValidProtoAnyPayload) { + bool server_callback_executed = false; + FetchSubscriptionsRequest server_capture; + FetchSubscriptionsResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + google::protobuf::Any any; + if (!any.PackFrom(server_response)) { + return std::nullopt; + } + Payload response_payload(any); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF_WRAPPED_IN_ANY); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const uprotocol::core::usubscription::v3::SubscriberInfo subscriber_info; + const auto fetch_subscribers_request = + getRequestBuilder().buildFetchSubscriptionsRequest(subscriber_info); + + auto response_or_status_future = std::async( + std::launch::async, + [&client, &fetch_subscribers_request]() + -> uprotocol::utils::Expected { + return client.fetch_subscriptions(fetch_subscribers_request); + }); // wait to give the client time to send the request. Otherwise this would // cause a race condition @@ -583,4 +733,287 @@ TEST_F(RpcClientUSubscriptionTest, FetchSubscriberRoundtripWithValidProtoAnyPayl EXPECT_EQ(response_or_status.value().SerializeAsString(), server_response.SerializeAsString()); } + +//////////////////////////////// +// Tests for register_for_notification method// +//////////////////////////////// + +using NotificationsRequest = + uprotocol::core::usubscription::v3::NotificationsRequest; +using NotificationsResponse = + uprotocol::core::usubscription::v3::NotificationsResponse; + +TEST_F(RpcClientUSubscriptionTest, + registerNotificationRoundtripWithValidProtoPayload) { + bool server_callback_executed = false; + NotificationsRequest server_capture; + NotificationsResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + Payload response_payload(server_response); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const auto notifications_request = + getRequestBuilder().buildNotificationsRequest(getSubscriptionTopic()); + + auto response_or_status_future = std::async( + std::launch::async, + [&client, ¬ifications_request]() + -> uprotocol::utils::Expected { + return client.register_for_notifications(notifications_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + notifications_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + +TEST_F(RpcClientUSubscriptionTest, + registerNotificationRoundtripWithValidProtoAnyPayload) { + bool server_callback_executed = false; + NotificationsRequest server_capture; + NotificationsResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + google::protobuf::Any any; + if (!any.PackFrom(server_response)) { + return std::nullopt; + } + Payload response_payload(any); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF_WRAPPED_IN_ANY); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const auto notifications_request = + getRequestBuilder().buildNotificationsRequest(getSubscriptionTopic()); + + auto response_or_status_future = std::async( + std::launch::async, + [&client, ¬ifications_request]() + -> uprotocol::utils::Expected { + return client.register_for_notifications(notifications_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + notifications_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + +//////////////////////////////// +// Tests for unregister_for_notification method// +//////////////////////////////// + +using NotificationsRequest = + uprotocol::core::usubscription::v3::NotificationsRequest; +using NotificationsResponse = + uprotocol::core::usubscription::v3::NotificationsResponse; + +TEST_F(RpcClientUSubscriptionTest, + unregisterNotificationRoundtripWithValidProtoPayload) { + bool server_callback_executed = false; + NotificationsRequest server_capture; + NotificationsResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + Payload response_payload(server_response); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const auto notifications_request = + getRequestBuilder().buildNotificationsRequest(getSubscriptionTopic()); + + auto response_or_status_future = std::async( + std::launch::async, + [&client, ¬ifications_request]() + -> uprotocol::utils::Expected { + return client.unregister_for_notifications(notifications_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + notifications_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + +TEST_F(RpcClientUSubscriptionTest, + unregisterNotificationRoundtripWithValidProtoAnyPayload) { + bool server_callback_executed = false; + NotificationsRequest server_capture; + NotificationsResponse server_response; + auto server_or_status = uprotocol::communication::RpcServer::create( + getServerTransport(), getServerMethodUuri(), + [&server_callback_executed, &server_capture, + &server_response](const UMessage& message) -> std::optional { + server_callback_executed = true; + auto request_or_status = + ProtoConverter::extractFromProtobuf( + message); + if (!request_or_status.has_value()) { + return std::nullopt; + } + server_capture = request_or_status.value(); + google::protobuf::Any any; + if (!any.PackFrom(server_response)) { + return std::nullopt; + } + Payload response_payload(any); + return response_payload; + }, + uprotocol::v1::UPayloadFormat::UPAYLOAD_FORMAT_PROTOBUF_WRAPPED_IN_ANY); + + ASSERT_TRUE(server_or_status.has_value()); + ASSERT_NE(server_or_status.value(), nullptr); + EXPECT_TRUE(getServerTransport()->getListener()); + + auto client = uprotocol::core::usubscription::v3::RpcClientUSubscription( + getClientTransport()); + + const auto notifications_request = + getRequestBuilder().buildNotificationsRequest(getSubscriptionTopic()); + + auto response_or_status_future = std::async( + std::launch::async, + [&client, ¬ifications_request]() + -> uprotocol::utils::Expected { + return client.unregister_for_notifications(notifications_request); + }); + + // wait to give the client time to send the request. Otherwise this would + // cause a race condition + int counter = ITERATIONS_TILL_TIMEOUT; + while (counter > 0 && getClientTransport()->getSendCount() == 0) { + counter--; + std::this_thread::sleep_for(MILLISECONDS_PER_ITERATION); + } + ASSERT_EQ(getClientTransport()->getSendCount(), 1); + EXPECT_TRUE(getClientTransport()->getListener()); + + (*getServerTransport()->getListener())(getClientTransport()->getMessage()); + EXPECT_TRUE(server_callback_executed); + EXPECT_EQ(server_capture.SerializeAsString(), + notifications_request.SerializeAsString()); + + getClientTransport()->mockMessage(getServerTransport()->getMessage()); + EXPECT_TRUE(getClientTransport()->getListener()); + EXPECT_EQ(getClientTransport()->getSendCount(), 1); + auto response_or_status = response_or_status_future.get(); + ASSERT_TRUE(response_or_status.has_value()); + EXPECT_EQ(response_or_status.value().SerializeAsString(), + server_response.SerializeAsString()); +} + }; // namespace diff --git a/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp b/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp index 082d16d1d..c27a62cbb 100644 --- a/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp +++ b/test/coverage/client/usubscription/v3/USubscriptionUUriBuilderTest.cpp @@ -39,7 +39,8 @@ TEST_F(USubscriptionUUriBuilderTest, GetServiceUriWithResourceId) { auto expected_uri = getExpectedUri(); expected_uri.set_resource_id(RESOURCE_ID_TEST); const USubscriptionUUriBuilder builder; - const v1::UUri actual_uri = builder.getServiceUriWithResourceId(RESOURCE_ID_TEST); + const v1::UUri actual_uri = + builder.getServiceUriWithResourceId(RESOURCE_ID_TEST); EXPECT_TRUE(actual_uri.IsInitialized()); EXPECT_EQ(actual_uri.GetTypeName(), "uprotocol.v1.UUri"); From 11b3f2702da42f69574a67121c56fc637bb003eb Mon Sep 17 00:00:00 2001 From: Max Date: Thu, 29 May 2025 22:10:45 +0200 Subject: [PATCH 8/8] small cleanup --- include/up-cpp/communication/RpcClient.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/include/up-cpp/communication/RpcClient.h b/include/up-cpp/communication/RpcClient.h index 07ee17711..ef218e04e 100644 --- a/include/up-cpp/communication/RpcClient.h +++ b/include/up-cpp/communication/RpcClient.h @@ -177,9 +177,11 @@ struct RpcClient { return ResponseOrStatus( UnexpectedStatus(payload_or_status.error())); } - datamodel::builder::Payload payload(payload_or_status.value()); - auto message_or_status = this->invokeMethod(std::move(payload)).get(); + datamodel::builder::Payload tmp_payload(payload_or_status.value()); + + auto message_or_status = + this->invokeMethod(std::move(tmp_payload)).get(); if (!message_or_status.has_value()) { return ResponseOrStatus( @@ -193,12 +195,10 @@ struct RpcClient { spdlog::error( "invokeProtoMethod: Error when extracting response from " "protobuf."); - return ResponseOrStatus( - UnexpectedStatus(response_or_status.error())); + return response_or_status; } - T response_message = response_or_status.value(); - return ResponseOrStatus(std::move(response_message)); + return ResponseOrStatus(response_or_status.value()); } /// @brief Default move constructor (defined in RpcClient.cpp)