libnos/generator/test/test.cpp

/*
 * 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") {
    typename std::remove_const<decltype(msg)>::type 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));
}