blob: 5d27c1d56d7c7fba69b0465dc9afaa5992654991 [file] [log] [blame]
// Copyright 2021 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#include "gtest/gtest.h"
#include "pw_preprocessor/compiler.h"
#include "pw_rpc/internal/hash.h"
#include "pw_rpc/internal/test_utils.h"
#include "pw_rpc/nanopb/test_method_context.h"
#include "pw_rpc_nanopb_private/internal_test_utils.h"
#include "pw_rpc_test_protos/test.rpc.pb.h"
PW_MODIFY_DIAGNOSTICS_PUSH();
PW_MODIFY_DIAGNOSTIC(ignored, "-Wmissing-field-initializers");
namespace pw::rpc {
namespace test {
class TestService final
: public pw_rpc::nanopb::TestService::Service<TestService> {
public:
Status TestUnaryRpc(const pw_rpc_test_TestRequest& request,
pw_rpc_test_TestResponse& response) {
response.value = request.integer + 1;
return static_cast<Status::Code>(request.status_code);
}
void TestAnotherUnaryRpc(
const pw_rpc_test_TestRequest& request,
NanopbUnaryResponder<pw_rpc_test_TestResponse>& responder) {
pw_rpc_test_TestResponse response{};
EXPECT_EQ(OkStatus(),
responder.Finish(response, TestUnaryRpc(request, response)));
}
static void TestServerStreamRpc(
const pw_rpc_test_TestRequest& request,
ServerWriter<pw_rpc_test_TestStreamResponse>& writer) {
for (int i = 0; i < request.integer; ++i) {
EXPECT_EQ(
OkStatus(),
writer.Write({.chunk = {}, .number = static_cast<uint32_t>(i)}));
}
EXPECT_EQ(OkStatus(),
writer.Finish(static_cast<Status::Code>(request.status_code)));
}
void TestClientStreamRpc(
ServerReader<pw_rpc_test_TestRequest, pw_rpc_test_TestStreamResponse>&
new_reader) {
reader = std::move(new_reader);
}
void TestBidirectionalStreamRpc(
ServerReaderWriter<pw_rpc_test_TestRequest,
pw_rpc_test_TestStreamResponse>& new_reader_writer) {
reader_writer = std::move(new_reader_writer);
}
ServerReader<pw_rpc_test_TestRequest, pw_rpc_test_TestStreamResponse> reader;
ServerReaderWriter<pw_rpc_test_TestRequest, pw_rpc_test_TestStreamResponse>
reader_writer;
};
} // namespace test
namespace {
using internal::ClientContextForTest;
TEST(NanopbCodegen, CompilesProperly) {
test::TestService service;
EXPECT_EQ(service.id(), internal::Hash("pw.rpc.test.TestService"));
EXPECT_STREQ(service.name(), "TestService");
}
TEST(NanopbCodegen, Server_InvokeUnaryRpc) {
PW_NANOPB_TEST_METHOD_CONTEXT(test::TestService, TestUnaryRpc) context;
EXPECT_EQ(OkStatus(),
context.call({.integer = 123, .status_code = OkStatus().code()}));
EXPECT_EQ(124, context.response().value);
EXPECT_EQ(Status::InvalidArgument(),
context.call({.integer = 999,
.status_code = Status::InvalidArgument().code()}));
EXPECT_EQ(1000, context.response().value);
}
TEST(NanopbCodegen, Server_InvokeAsyncUnaryRpc) {
PW_NANOPB_TEST_METHOD_CONTEXT(test::TestService, TestAnotherUnaryRpc) context;
context.call({.integer = 123, .status_code = OkStatus().code()});
EXPECT_EQ(OkStatus(), context.status());
EXPECT_EQ(124, context.response().value);
context.call(
{.integer = 999, .status_code = Status::InvalidArgument().code()});
EXPECT_EQ(Status::InvalidArgument(), context.status());
EXPECT_EQ(1000, context.response().value);
}
TEST(NanopbCodegen, Server_InvokeServerStreamingRpc) {
PW_NANOPB_TEST_METHOD_CONTEXT(test::TestService, TestServerStreamRpc) context;
context.call({.integer = 0, .status_code = Status::Aborted().code()});
EXPECT_EQ(Status::Aborted(), context.status());
EXPECT_TRUE(context.done());
EXPECT_EQ(context.total_responses(), 0u);
context.call({.integer = 4, .status_code = OkStatus().code()});
ASSERT_EQ(4u, context.responses().size());
for (size_t i = 0; i < context.responses().size(); ++i) {
EXPECT_EQ(context.responses()[i].number, i);
}
EXPECT_EQ(OkStatus().code(), context.status());
}
TEST(NanopbCodegen, Server_InvokeServerStreamingRpc_ManualWriting) {
PW_NANOPB_TEST_METHOD_CONTEXT(test::TestService, TestServerStreamRpc, 4)
context;
ASSERT_EQ(4u, context.max_packets());
auto writer = context.writer();
EXPECT_EQ(OkStatus(), writer.Write({.chunk = {}, .number = 3}));
EXPECT_EQ(OkStatus(), writer.Write({.chunk = {}, .number = 6}));
EXPECT_EQ(OkStatus(), writer.Write({.chunk = {}, .number = 9}));
EXPECT_FALSE(context.done());
EXPECT_EQ(OkStatus(), writer.Finish(Status::Cancelled()));
ASSERT_TRUE(context.done());
EXPECT_EQ(Status::Cancelled(), context.status());
ASSERT_EQ(3u, context.responses().size());
EXPECT_EQ(context.responses()[0].number, 3u);
EXPECT_EQ(context.responses()[1].number, 6u);
EXPECT_EQ(context.responses()[2].number, 9u);
}
TEST(NanopbCodegen, Server_InvokeClientStreamingRpc) {
PW_NANOPB_TEST_METHOD_CONTEXT(test::TestService, TestClientStreamRpc) context;
context.call();
pw_rpc_test_TestRequest request = {};
context.service().reader.set_on_next(
[&request](const pw_rpc_test_TestRequest& req) { request = req; });
context.SendClientStream({.integer = -99, .status_code = 10});
EXPECT_EQ(request.integer, -99);
EXPECT_EQ(request.status_code, 10u);
ASSERT_EQ(OkStatus(),
context.service().reader.Finish({.chunk = {}, .number = 3},
Status::Unimplemented()));
EXPECT_EQ(Status::Unimplemented(), context.status());
EXPECT_EQ(context.response().number, 3u);
}
TEST(NanopbCodegen, Server_InvokeBidirectionalStreamingRpc) {
PW_NANOPB_TEST_METHOD_CONTEXT(test::TestService, TestBidirectionalStreamRpc)
context;
context.call();
pw_rpc_test_TestRequest request = {};
context.service().reader_writer.set_on_next(
[&request](const pw_rpc_test_TestRequest& req) { request = req; });
context.SendClientStream({.integer = -99, .status_code = 10});
EXPECT_EQ(request.integer, -99);
EXPECT_EQ(request.status_code, 10u);
ASSERT_EQ(OkStatus(),
context.service().reader_writer.Write({.chunk = {}, .number = 2}));
EXPECT_EQ(context.responses()[0].number, 2u);
ASSERT_EQ(OkStatus(),
context.service().reader_writer.Finish(Status::NotFound()));
EXPECT_EQ(Status::NotFound(), context.status());
}
TEST(NanopbCodegen, ClientCall_DefaultConstructor) {
NanopbUnaryReceiver<pw_rpc_test_TestResponse> unary_call;
NanopbClientReader<pw_rpc_test_TestStreamResponse> server_streaming_call;
}
using TestServiceClient = test::pw_rpc::nanopb::TestService::Client;
TEST(NanopbCodegen, Client_InvokesUnaryRpcWithCallback) {
constexpr uint32_t kServiceId = internal::Hash("pw.rpc.test.TestService");
constexpr uint32_t kMethodId = internal::Hash("TestUnaryRpc");
ClientContextForTest<128, 99, kServiceId, kMethodId> context;
TestServiceClient test_client(context.client(), context.channel().id());
struct {
Status last_status = Status::Unknown();
int response_value = -1;
} result;
auto call = test_client.TestUnaryRpc(
{.integer = 123, .status_code = 0},
[&result](const pw_rpc_test_TestResponse& response, Status status) {
result.last_status = status;
result.response_value = response.value;
});
EXPECT_TRUE(call.active());
EXPECT_EQ(context.output().total_packets(), 1u);
auto packet =
static_cast<const internal::test::FakeChannelOutput&>(context.output())
.last_packet();
EXPECT_EQ(packet.channel_id(), context.channel().id());
EXPECT_EQ(packet.service_id(), kServiceId);
EXPECT_EQ(packet.method_id(), kMethodId);
PW_DECODE_PB(pw_rpc_test_TestRequest, sent_proto, packet.payload());
EXPECT_EQ(sent_proto.integer, 123);
PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response));
EXPECT_EQ(result.last_status, OkStatus());
EXPECT_EQ(result.response_value, 42);
EXPECT_FALSE(call.active());
}
TEST(NanopbCodegen, Client_InvokesServerStreamingRpcWithCallback) {
constexpr uint32_t kServiceId = internal::Hash("pw.rpc.test.TestService");
constexpr uint32_t kMethodId = internal::Hash("TestServerStreamRpc");
ClientContextForTest<128, 99, kServiceId, kMethodId> context;
TestServiceClient test_client(context.client(), context.channel().id());
struct {
bool active = true;
Status stream_status = Status::Unknown();
int response_value = -1;
} result;
auto call = test_client.TestServerStreamRpc(
{.integer = 123, .status_code = 0},
[&result](const pw_rpc_test_TestStreamResponse& response) {
result.active = true;
result.response_value = response.number;
},
[&result](Status status) {
result.active = false;
result.stream_status = status;
});
EXPECT_TRUE(call.active());
EXPECT_EQ(context.output().total_packets(), 1u);
auto packet =
static_cast<const internal::test::FakeChannelOutput&>(context.output())
.last_packet();
EXPECT_EQ(packet.channel_id(), context.channel().id());
EXPECT_EQ(packet.service_id(), kServiceId);
EXPECT_EQ(packet.method_id(), kMethodId);
PW_DECODE_PB(pw_rpc_test_TestRequest, sent_proto, packet.payload());
EXPECT_EQ(sent_proto.integer, 123);
PW_ENCODE_PB(
pw_rpc_test_TestStreamResponse, response, .chunk = {}, .number = 11u);
EXPECT_EQ(OkStatus(), context.SendServerStream(response));
EXPECT_TRUE(result.active);
EXPECT_EQ(result.response_value, 11);
EXPECT_EQ(OkStatus(), context.SendResponse(Status::NotFound()));
EXPECT_FALSE(result.active);
EXPECT_EQ(result.stream_status, Status::NotFound());
}
TEST(NanopbCodegen, Client_StaticMethod_InvokesUnaryRpcWithCallback) {
constexpr uint32_t kServiceId = internal::Hash("pw.rpc.test.TestService");
constexpr uint32_t kMethodId = internal::Hash("TestUnaryRpc");
ClientContextForTest<128, 99, kServiceId, kMethodId> context;
struct {
Status last_status = Status::Unknown();
int response_value = -1;
} result;
auto call = test::pw_rpc::nanopb::TestService::TestUnaryRpc(
context.client(),
context.channel().id(),
{.integer = 123, .status_code = 0},
[&result](const pw_rpc_test_TestResponse& response, Status status) {
result.last_status = status;
result.response_value = response.value;
});
EXPECT_TRUE(call.active());
EXPECT_EQ(context.output().total_packets(), 1u);
auto packet =
static_cast<const internal::test::FakeChannelOutput&>(context.output())
.last_packet();
EXPECT_EQ(packet.channel_id(), context.channel().id());
EXPECT_EQ(packet.service_id(), kServiceId);
EXPECT_EQ(packet.method_id(), kMethodId);
PW_DECODE_PB(pw_rpc_test_TestRequest, sent_proto, packet.payload());
EXPECT_EQ(sent_proto.integer, 123);
PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response));
EXPECT_EQ(result.last_status, OkStatus());
EXPECT_EQ(result.response_value, 42);
}
TEST(NanopbCodegen, Client_StaticMethod_InvokesServerStreamingRpcWithCallback) {
constexpr uint32_t kServiceId = internal::Hash("pw.rpc.test.TestService");
constexpr uint32_t kMethodId = internal::Hash("TestServerStreamRpc");
ClientContextForTest<128, 99, kServiceId, kMethodId> context;
struct {
bool active = true;
Status stream_status = Status::Unknown();
int response_value = -1;
} result;
auto call = test::pw_rpc::nanopb::TestService::TestServerStreamRpc(
context.client(),
context.channel().id(),
{.integer = 123, .status_code = 0},
[&result](const pw_rpc_test_TestStreamResponse& response) {
result.active = true;
result.response_value = response.number;
},
[&result](Status status) {
result.active = false;
result.stream_status = status;
});
EXPECT_TRUE(call.active());
EXPECT_EQ(context.output().total_packets(), 1u);
auto packet =
static_cast<const internal::test::FakeChannelOutput&>(context.output())
.last_packet();
EXPECT_EQ(packet.channel_id(), context.channel().id());
EXPECT_EQ(packet.service_id(), kServiceId);
EXPECT_EQ(packet.method_id(), kMethodId);
PW_DECODE_PB(pw_rpc_test_TestRequest, sent_proto, packet.payload());
EXPECT_EQ(sent_proto.integer, 123);
PW_ENCODE_PB(
pw_rpc_test_TestStreamResponse, response, .chunk = {}, .number = 11u);
EXPECT_EQ(OkStatus(), context.SendServerStream(response));
EXPECT_TRUE(result.active);
EXPECT_EQ(result.response_value, 11);
EXPECT_EQ(OkStatus(), context.SendResponse(Status::NotFound()));
EXPECT_FALSE(result.active);
EXPECT_EQ(result.stream_status, Status::NotFound());
}
} // namespace
} // namespace pw::rpc
PW_MODIFY_DIAGNOSTICS_POP();