Alexei Frolov | 26e3ae6 | 2020-05-04 17:06:17 -0700 | [diff] [blame] | 1 | // Copyright 2020 The Pigweed Authors |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| 4 | // use this file except in compliance with the License. You may obtain a copy of |
| 5 | // the License at |
| 6 | // |
| 7 | // https://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 11 | // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 12 | // License for the specific language governing permissions and limitations under |
| 13 | // the License. |
| 14 | |
| 15 | #include "pw_rpc/server.h" |
| 16 | |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 17 | #include <array> |
| 18 | #include <cstdint> |
| 19 | |
Alexei Frolov | 26e3ae6 | 2020-05-04 17:06:17 -0700 | [diff] [blame] | 20 | #include "gtest/gtest.h" |
Wyatt Hepler | f298de4 | 2021-03-19 15:06:36 -0700 | [diff] [blame] | 21 | #include "pw_assert/check.h" |
Wyatt Hepler | cbd09c2 | 2020-09-15 11:17:24 -0700 | [diff] [blame] | 22 | #include "pw_rpc/internal/method.h" |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 23 | #include "pw_rpc/internal/packet.h" |
Wyatt Hepler | cbd09c2 | 2020-09-15 11:17:24 -0700 | [diff] [blame] | 24 | #include "pw_rpc/internal/test_method.h" |
Alexei Frolov | 9a4d6bf | 2020-08-04 10:33:26 -0700 | [diff] [blame] | 25 | #include "pw_rpc/service.h" |
Wyatt Hepler | 8aa0292 | 2020-07-17 08:54:37 -0700 | [diff] [blame] | 26 | #include "pw_rpc_private/internal_test_utils.h" |
Alexei Frolov | 26e3ae6 | 2020-05-04 17:06:17 -0700 | [diff] [blame] | 27 | |
| 28 | namespace pw::rpc { |
| 29 | namespace { |
| 30 | |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 31 | using std::byte; |
| 32 | |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 33 | using internal::Packet; |
| 34 | using internal::PacketType; |
Wyatt Hepler | cbd09c2 | 2020-09-15 11:17:24 -0700 | [diff] [blame] | 35 | using internal::TestMethod; |
Alexei Frolov | a4d7150 | 2020-10-14 12:43:14 -0700 | [diff] [blame] | 36 | using internal::TestMethodUnion; |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 37 | |
Alexei Frolov | 9a4d6bf | 2020-08-04 10:33:26 -0700 | [diff] [blame] | 38 | class TestService : public Service { |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 39 | public: |
| 40 | TestService(uint32_t service_id) |
Alexei Frolov | 9a4d6bf | 2020-08-04 10:33:26 -0700 | [diff] [blame] | 41 | : Service(service_id, methods_), |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 42 | methods_{ |
Wyatt Hepler | cbd09c2 | 2020-09-15 11:17:24 -0700 | [diff] [blame] | 43 | TestMethod(100), |
| 44 | TestMethod(200), |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 45 | } {} |
| 46 | |
Alexei Frolov | a4d7150 | 2020-10-14 12:43:14 -0700 | [diff] [blame] | 47 | const TestMethod& method(uint32_t id) { |
| 48 | for (TestMethodUnion& method : methods_) { |
| 49 | if (method.method().id() == id) { |
| 50 | return method.test_method(); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 51 | } |
| 52 | } |
| 53 | |
| 54 | PW_CRASH("Invalid method ID %u", static_cast<unsigned>(id)); |
| 55 | } |
| 56 | |
| 57 | private: |
Alexei Frolov | a4d7150 | 2020-10-14 12:43:14 -0700 | [diff] [blame] | 58 | std::array<TestMethodUnion, 2> methods_; |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 59 | }; |
| 60 | |
| 61 | class BasicServer : public ::testing::Test { |
| 62 | protected: |
| 63 | static constexpr byte kDefaultPayload[] = { |
| 64 | byte(0x82), byte(0x02), byte(0xff), byte(0xff)}; |
| 65 | |
| 66 | BasicServer() |
Wyatt Hepler | 51a2eb7 | 2020-06-04 14:47:00 -0700 | [diff] [blame] | 67 | : channels_{ |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 68 | Channel::Create<1>(&output_), |
| 69 | Channel::Create<2>(&output_), |
| 70 | Channel(), // available for assignment |
| 71 | }, |
| 72 | server_(channels_), |
| 73 | service_(42) { |
| 74 | server_.RegisterService(service_); |
| 75 | } |
| 76 | |
Wyatt Hepler | e2cbadf | 2020-06-22 11:21:45 -0700 | [diff] [blame] | 77 | std::span<const byte> EncodeRequest( |
| 78 | PacketType type, |
| 79 | uint32_t channel_id, |
| 80 | uint32_t service_id, |
| 81 | uint32_t method_id, |
| 82 | std::span<const byte> payload = kDefaultPayload) { |
Alexei Frolov | 3f2d008 | 2020-10-04 22:30:39 -0700 | [diff] [blame] | 83 | auto result = Packet(type, channel_id, service_id, method_id, payload) |
| 84 | .Encode(request_buffer_); |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 85 | EXPECT_EQ(OkStatus(), result.status()); |
Alexei Frolov | 3f2d008 | 2020-10-04 22:30:39 -0700 | [diff] [blame] | 86 | return result.value_or(ConstByteSpan()); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 87 | } |
| 88 | |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 89 | TestOutput<128> output_; |
| 90 | std::array<Channel, 3> channels_; |
| 91 | Server server_; |
| 92 | TestService service_; |
| 93 | |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 94 | private: |
| 95 | byte request_buffer_[64]; |
| 96 | }; |
| 97 | |
| 98 | TEST_F(BasicServer, ProcessPacket_ValidMethod_InvokesMethod) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 99 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 100 | server_.ProcessPacket( |
| 101 | EncodeRequest(PacketType::REQUEST, 1, 42, 100), output_)); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 102 | |
Wyatt Hepler | cbd09c2 | 2020-09-15 11:17:24 -0700 | [diff] [blame] | 103 | const TestMethod& method = service_.method(100); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 104 | EXPECT_EQ(1u, method.last_channel_id()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 105 | ASSERT_EQ(sizeof(kDefaultPayload), method.last_request().payload().size()); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 106 | EXPECT_EQ(std::memcmp(kDefaultPayload, |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 107 | method.last_request().payload().data(), |
| 108 | method.last_request().payload().size()), |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 109 | 0); |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 110 | } |
Alexei Frolov | 5d6d392 | 2020-05-08 13:57:02 -0700 | [diff] [blame] | 111 | |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 112 | TEST_F(BasicServer, ProcessPacket_IncompletePacket_NothingIsInvoked) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 113 | EXPECT_EQ(Status::DataLoss(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 114 | server_.ProcessPacket( |
| 115 | EncodeRequest(PacketType::REQUEST, 0, 42, 101), output_)); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 116 | EXPECT_EQ(Status::DataLoss(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 117 | server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 0, 101), |
| 118 | output_)); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 119 | EXPECT_EQ(Status::DataLoss(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 120 | server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 0), |
| 121 | output_)); |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 122 | |
| 123 | EXPECT_EQ(0u, service_.method(100).last_channel_id()); |
| 124 | EXPECT_EQ(0u, service_.method(200).last_channel_id()); |
| 125 | } |
| 126 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 127 | TEST_F(BasicServer, ProcessPacket_NoChannel_SendsNothing) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 128 | EXPECT_EQ(Status::DataLoss(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 129 | server_.ProcessPacket( |
| 130 | EncodeRequest(PacketType::REQUEST, 0, 42, 101), output_)); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 131 | |
| 132 | EXPECT_EQ(output_.packet_count(), 0u); |
| 133 | } |
| 134 | |
| 135 | TEST_F(BasicServer, ProcessPacket_NoService_SendsDataLoss) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 136 | EXPECT_EQ(Status::DataLoss(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 137 | server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 0, 101), |
| 138 | output_)); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 139 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 140 | EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 141 | EXPECT_EQ(output_.sent_packet().status(), Status::DataLoss()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | TEST_F(BasicServer, ProcessPacket_NoMethod_SendsDataLoss) { |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 145 | EXPECT_EQ(Status::DataLoss(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 146 | server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 0), |
| 147 | output_)); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 148 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 149 | EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 150 | EXPECT_EQ(output_.sent_packet().status(), Status::DataLoss()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 153 | TEST_F(BasicServer, ProcessPacket_InvalidMethod_NothingIsInvoked) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 154 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 155 | server_.ProcessPacket( |
| 156 | EncodeRequest(PacketType::REQUEST, 1, 42, 101), output_)); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 157 | |
| 158 | EXPECT_EQ(0u, service_.method(100).last_channel_id()); |
| 159 | EXPECT_EQ(0u, service_.method(200).last_channel_id()); |
| 160 | } |
| 161 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 162 | TEST_F(BasicServer, ProcessPacket_InvalidMethod_SendsError) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 163 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 164 | server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 27), |
| 165 | output_)); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 166 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 167 | const Packet& packet = output_.sent_packet(); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 168 | EXPECT_EQ(packet.type(), PacketType::SERVER_ERROR); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 169 | EXPECT_EQ(packet.channel_id(), 1u); |
| 170 | EXPECT_EQ(packet.service_id(), 42u); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 171 | EXPECT_EQ(packet.method_id(), 27u); // No method ID 27 |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 172 | EXPECT_EQ(packet.status(), Status::NotFound()); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 173 | } |
| 174 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 175 | TEST_F(BasicServer, ProcessPacket_InvalidService_SendsError) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 176 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 177 | server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 43, 27), |
| 178 | output_)); |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 179 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 180 | const Packet& packet = output_.sent_packet(); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 181 | EXPECT_EQ(packet.type(), PacketType::SERVER_ERROR); |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 182 | EXPECT_EQ(packet.channel_id(), 1u); |
Wyatt Hepler | 60161aa | 2020-07-21 23:29:47 -0700 | [diff] [blame] | 183 | EXPECT_EQ(packet.service_id(), 43u); // No service ID 43 |
| 184 | EXPECT_EQ(packet.method_id(), 27u); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 185 | EXPECT_EQ(packet.status(), Status::NotFound()); |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 186 | } |
| 187 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 188 | TEST_F(BasicServer, ProcessPacket_UnassignedChannel_AssignsToAvailableSlot) { |
Wyatt Hepler | 51a2eb7 | 2020-06-04 14:47:00 -0700 | [diff] [blame] | 189 | TestOutput<128> unassigned_output; |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 190 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 191 | server_.ProcessPacket( |
| 192 | EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 100), |
| 193 | unassigned_output)); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 194 | EXPECT_EQ(channels_[2].id(), 99u); |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Wyatt Hepler | 80f26ff | 2020-06-01 09:30:17 -0700 | [diff] [blame] | 197 | TEST_F(BasicServer, |
| 198 | ProcessPacket_UnassignedChannel_SendsResourceExhaustedIfCannotAssign) { |
| 199 | channels_[2] = Channel::Create<3>(&output_); // Occupy only available channel |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 200 | |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 201 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 202 | server_.ProcessPacket( |
| 203 | EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 27), |
| 204 | output_)); |
Alexei Frolov | 33a1e8f | 2020-05-26 08:39:32 -0700 | [diff] [blame] | 205 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 206 | const Packet& packet = output_.sent_packet(); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 207 | EXPECT_EQ(packet.status(), Status::ResourceExhausted()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 208 | EXPECT_EQ(packet.channel_id(), 99u); |
| 209 | EXPECT_EQ(packet.service_id(), 42u); |
| 210 | EXPECT_EQ(packet.method_id(), 27u); |
Alexei Frolov | 26e3ae6 | 2020-05-04 17:06:17 -0700 | [diff] [blame] | 211 | } |
| 212 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 213 | TEST_F(BasicServer, ProcessPacket_Cancel_MethodNotActive_SendsError) { |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 214 | // Set up a fake ServerWriter representing an ongoing RPC. |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 215 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 216 | server_.ProcessPacket(EncodeRequest(PacketType::CANCEL, 1, 42, 100), |
| 217 | output_)); |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 218 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 219 | const Packet& packet = output_.sent_packet(); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 220 | EXPECT_EQ(packet.type(), PacketType::SERVER_ERROR); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 221 | EXPECT_EQ(packet.channel_id(), 1u); |
| 222 | EXPECT_EQ(packet.service_id(), 42u); |
| 223 | EXPECT_EQ(packet.method_id(), 100u); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 224 | EXPECT_EQ(packet.status(), Status::FailedPrecondition()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 225 | } |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 226 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 227 | class MethodPending : public BasicServer { |
| 228 | protected: |
| 229 | MethodPending() |
| 230 | : call_(static_cast<internal::Server&>(server_), |
| 231 | static_cast<internal::Channel&>(channels_[0]), |
| 232 | service_, |
| 233 | service_.method(100)), |
| 234 | writer_(call_) { |
| 235 | ASSERT_TRUE(writer_.open()); |
| 236 | } |
| 237 | |
| 238 | internal::ServerCall call_; |
| 239 | internal::BaseServerWriter writer_; |
| 240 | }; |
| 241 | |
| 242 | TEST_F(MethodPending, ProcessPacket_Cancel_ClosesServerWriter) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 243 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 244 | server_.ProcessPacket(EncodeRequest(PacketType::CANCEL, 1, 42, 100), |
| 245 | output_)); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 246 | |
| 247 | EXPECT_FALSE(writer_.open()); |
| 248 | } |
| 249 | |
| 250 | TEST_F(MethodPending, ProcessPacket_Cancel_SendsStreamEndPacket) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 251 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 252 | server_.ProcessPacket(EncodeRequest(PacketType::CANCEL, 1, 42, 100), |
| 253 | output_)); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 254 | |
| 255 | const Packet& packet = output_.sent_packet(); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 256 | EXPECT_EQ(packet.type(), PacketType::SERVER_STREAM_END); |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 257 | EXPECT_EQ(packet.channel_id(), 1u); |
| 258 | EXPECT_EQ(packet.service_id(), 42u); |
| 259 | EXPECT_EQ(packet.method_id(), 100u); |
| 260 | EXPECT_TRUE(packet.payload().empty()); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 261 | EXPECT_EQ(packet.status(), Status::Cancelled()); |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 262 | } |
| 263 | |
Alexei Frolov | 062ed18 | 2020-09-28 16:23:06 -0700 | [diff] [blame] | 264 | TEST_F(MethodPending, |
| 265 | ProcessPacket_ClientError_ClosesServerWriterWithoutStreamEnd) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 266 | EXPECT_EQ(OkStatus(), |
Alexei Frolov | 062ed18 | 2020-09-28 16:23:06 -0700 | [diff] [blame] | 267 | server_.ProcessPacket( |
| 268 | EncodeRequest(PacketType::CLIENT_ERROR, 1, 42, 100), output_)); |
| 269 | |
| 270 | EXPECT_FALSE(writer_.open()); |
| 271 | EXPECT_EQ(output_.packet_count(), 0u); |
| 272 | } |
| 273 | |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 274 | TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectChannel) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 275 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 276 | server_.ProcessPacket(EncodeRequest(PacketType::CANCEL, 2, 42, 100), |
| 277 | output_)); |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 278 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 279 | EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 280 | EXPECT_EQ(output_.sent_packet().status(), Status::FailedPrecondition()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 281 | EXPECT_TRUE(writer_.open()); |
| 282 | } |
| 283 | |
| 284 | TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectService) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 285 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 286 | server_.ProcessPacket(EncodeRequest(PacketType::CANCEL, 1, 43, 100), |
| 287 | output_)); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 288 | |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 289 | EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 290 | EXPECT_EQ(output_.sent_packet().status(), Status::NotFound()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 291 | EXPECT_EQ(output_.sent_packet().service_id(), 43u); |
Wyatt Hepler | 60161aa | 2020-07-21 23:29:47 -0700 | [diff] [blame] | 292 | EXPECT_EQ(output_.sent_packet().method_id(), 100u); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 293 | EXPECT_TRUE(writer_.open()); |
| 294 | } |
| 295 | |
| 296 | TEST_F(MethodPending, ProcessPacket_CancelIncorrectMethod) { |
Wyatt Hepler | 1b3da3a | 2021-01-07 13:26:57 -0800 | [diff] [blame] | 297 | EXPECT_EQ(OkStatus(), |
Wyatt Hepler | a921116 | 2021-06-12 15:40:11 -0700 | [diff] [blame^] | 298 | server_.ProcessPacket(EncodeRequest(PacketType::CANCEL, 1, 42, 101), |
| 299 | output_)); |
Wyatt Hepler | 0f26235 | 2020-07-29 09:51:27 -0700 | [diff] [blame] | 300 | EXPECT_EQ(output_.sent_packet().type(), PacketType::SERVER_ERROR); |
Wyatt Hepler | d78f7c6 | 2020-09-28 14:27:32 -0700 | [diff] [blame] | 301 | EXPECT_EQ(output_.sent_packet().status(), Status::NotFound()); |
Wyatt Hepler | 712d367 | 2020-07-13 15:52:11 -0700 | [diff] [blame] | 302 | EXPECT_TRUE(writer_.open()); |
Wyatt Hepler | af83568 | 2020-06-17 11:42:53 -0700 | [diff] [blame] | 303 | } |
| 304 | |
Alexei Frolov | 26e3ae6 | 2020-05-04 17:06:17 -0700 | [diff] [blame] | 305 | } // namespace |
| 306 | } // namespace pw::rpc |