| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * 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 |
| * |
| * http://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 <Hello.client.h> |
| #include <MockHello.client.h> |
| |
| #include <google/protobuf/util/message_differencer.h> |
| |
| #include <nos/MockNuggetClient.h> |
| |
| #include <gtest/gtest.h> |
| |
| using ::google::protobuf::util::MessageDifferencer; |
| |
| using ::nos::MockNuggetClient; |
| using ::nos::generator::test::EmptyRequest; |
| using ::nos::generator::test::EmptyResponse; |
| using ::nos::generator::test::GreetRequest; |
| using ::nos::generator::test::GreetResponse; |
| using ::nos::generator::test::Hello; |
| using ::nos::generator::test::IHello; |
| using ::nos::generator::test::MockHello; |
| |
| using ::testing::_; |
| using ::testing::DoAll; |
| using ::testing::Eq; |
| using ::testing::Return; |
| using ::testing::SetArgPointee; |
| |
| MATCHER_P(ProtoMessageEq, msg, "") { return MessageDifferencer::Equals(arg, msg); } |
| |
| // Check the message is the same rather than the encoded bytes as different |
| // bytes could decode to the same message. |
| MATCHER_P(DecodesToProtoMessage, msg, "Vector does not decode to correct message") { |
| decltype(msg) decoded; |
| return decoded.ParseFromArray(arg.data(), arg.size()) |
| && MessageDifferencer::Equals(decoded, msg); |
| } |
| |
| // The method's ID is based on the order of declaration in the service. |
| TEST(GeneratedServiceClientTest, MethodsHaveCorrectIds) { |
| MockNuggetClient client; |
| Hello service{client}; |
| |
| EXPECT_CALL(client, CallApp(APP_ID_TEST, 2, _, _)).WillOnce(Return(APP_SUCCESS)); |
| EXPECT_CALL(client, CallApp(APP_ID_TEST, 0, _, _)).WillOnce(Return(APP_SUCCESS)); |
| EXPECT_CALL(client, CallApp(APP_ID_TEST, 1, _, _)).WillOnce(Return(APP_SUCCESS)); |
| |
| EmptyRequest request; |
| EmptyResponse response; |
| |
| service.Third(request, &response); |
| service.First(request, &response); |
| service.Second(request, &response); |
| } |
| |
| // Both request and response messages are exchanged successfully. |
| TEST(GeneratedServiceClientTest, DataSuccessfullyExchanged) { |
| MockNuggetClient client; |
| Hello service{client}; |
| |
| GreetRequest request; |
| request.set_who("Tester"); |
| request.set_age(78); |
| |
| GreetResponse response; |
| response.set_greeting("Hello, Tester age 78"); |
| |
| std::vector<uint8_t> responseBytes(response.ByteSize()); |
| ASSERT_TRUE(response.SerializeToArray(responseBytes.data(), responseBytes.size())); |
| |
| EXPECT_CALL(client, CallApp(_, _, DecodesToProtoMessage(request), _)) |
| .WillOnce(DoAll(SetArgPointee<3>(responseBytes), Return(APP_SUCCESS))); |
| |
| GreetResponse real_response; |
| EXPECT_THAT(service.Greet(request, &real_response), Eq(APP_SUCCESS)); |
| EXPECT_THAT(real_response, ProtoMessageEq(response)); |
| } |
| |
| // The response can be ignored but the request is still passed on. |
| TEST(GeneratedServiceClientTest, NullptrResponseBufferIgnoresResponseData) { |
| MockNuggetClient client; |
| Hello service{client}; |
| |
| GreetRequest request; |
| request.set_who("Silence"); |
| request.set_age(10); |
| |
| EXPECT_CALL(client, CallApp(_, _, DecodesToProtoMessage(request), Eq(nullptr))) |
| .WillOnce(Return(APP_SUCCESS)); |
| |
| EXPECT_THAT(service.Greet(request, nullptr), Eq(APP_SUCCESS)); |
| } |
| |
| // Errors from the chip should be forwarded to the caller without decoding the |
| // response |
| TEST(GeneratedServiceClientTest, AppErrorsPropagatedWithoutResponseDecode) { |
| MockNuggetClient client; |
| Hello service{client}; |
| |
| GreetResponse response; |
| response.set_greeting("Ignore me"); |
| |
| std::vector<uint8_t> responseBytes(response.ByteSize()); |
| ASSERT_TRUE(response.SerializeToArray(responseBytes.data(), responseBytes.size())); |
| |
| EXPECT_CALL(client, CallApp(_, _, _, _)) |
| .WillOnce(DoAll(SetArgPointee<3>(responseBytes), Return(APP_ERROR_BOGUS_ARGS))); |
| |
| GreetRequest request; |
| GreetResponse real_response; |
| EXPECT_THAT(service.Greet(request, &real_response), Eq(APP_ERROR_BOGUS_ARGS)); |
| EXPECT_THAT(real_response, ProtoMessageEq(GreetResponse{})); |
| } |
| |
| // Invalid encoding of a response message results in an RPC error |
| TEST(GeneratedServiceClientTest, GarbledResponseIsRpcFailure) { |
| MockNuggetClient client; |
| Hello service{client}; |
| |
| std::vector<uint8_t> garbledResponse{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; |
| EXPECT_CALL(client, CallApp(_, _, _, _)) |
| .WillOnce(DoAll(SetArgPointee<3>(garbledResponse), Return(APP_SUCCESS))); |
| |
| GreetRequest request; |
| GreetResponse response; |
| EXPECT_THAT(service.Greet(request, &response), Eq(APP_ERROR_RPC)); |
| } |
| |
| // Sending too much data will fail before beginning a transaction with the chip. |
| TEST(GeneratedServiceClientTest, RequestLargerThanBuffer) { |
| MockNuggetClient client; |
| Hello service{client}; |
| |
| EXPECT_CALL(client, CallApp(_, _, _, _)).Times(0); |
| |
| GreetRequest request; |
| request.set_who("This is far too long for the buffer so should fail"); |
| |
| GreetResponse response; |
| EXPECT_THAT(service.Greet(request, &response), Eq(APP_ERROR_TOO_MUCH)); |
| } |
| |
| // Example using generate service mocks. |
| TEST(GeneratedServiceClientTest, CanUseGeneratedMocks) { |
| MockHello mockService; |
| |
| GreetResponse response; |
| constexpr auto mockGreeting = "I made this up"; |
| response.set_greeting(mockGreeting); |
| |
| EXPECT_CALL(mockService, Greet(_, _)) |
| .WillOnce(DoAll(SetArgPointee<1>(response), Return(APP_SUCCESS))); |
| |
| // Use as an instance of the service to mimic a real test |
| IHello& service = mockService; |
| GreetRequest request; |
| GreetResponse real_response; |
| EXPECT_THAT(service.Greet(request, &real_response), Eq(APP_SUCCESS)); |
| EXPECT_THAT(real_response, ProtoMessageEq(response)); |
| } |