Skip to content

Commit

Permalink
backend: update proto files
Browse files Browse the repository at this point in the history 
* Simplify mission by removing the MissionItems struct
* Merge SubscribeDiscover and SubscribeTimeout into SubscribeConnectionState
* Add camera photo interval to MissionItem
  • Loading branch information
@JonasVautherin
JonasVautherin committed Feb 6, 2019
1 parent 20cd93a commit a2463f4
Show file tree
Hide file tree
Showing 5 changed files with 92 additions and 202 deletions.
2 changes: 1 addition & 1 deletion backend/proto
Submodule proto updated from d117c0 to 222023
41 changes: 24 additions & 17 deletions backend/src/core/core_service_impl.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,27 +16,20 @@ class CoreServiceImpl final : public dronecode_sdk::rpc::core::CoreService::Serv
_stop_future(_stop_promise.get_future())
{}

grpc::Status SubscribeDiscover(grpc::ServerContext * /* context */,
const rpc::core::SubscribeDiscoverRequest * /* request */,
grpc::ServerWriter<rpc::core::DiscoverResponse> *writer) override
grpc::Status SubscribeConnectionState(
grpc::ServerContext * /* context */,
const rpc::core::SubscribeConnectionStateRequest * /* request */,
grpc::ServerWriter<rpc::core::ConnectionStateResponse> *writer) override
{
_dc.register_on_discover([&writer](const uint64_t uuid) {
dronecode_sdk::rpc::core::DiscoverResponse rpc_discover_response;
rpc_discover_response.set_uuid(uuid);
writer->Write(rpc_discover_response);
const auto rpc_connection_state_response = createRpcConnectionStateResponse(uuid, true);
writer->Write(rpc_connection_state_response);
});

_stop_future.wait();
return grpc::Status::OK;
}

grpc::Status SubscribeTimeout(grpc::ServerContext * /* context */,
const rpc::core::SubscribeTimeoutRequest * /* request */,
grpc::ServerWriter<rpc::core::TimeoutResponse> *writer) override
{
_dc.register_on_timeout([&writer](const uint64_t /* uuid */) {
dronecode_sdk::rpc::core::TimeoutResponse rpc_timeout_response;
writer->Write(rpc_timeout_response);
_dc.register_on_timeout([&writer](const uint64_t uuid) {
const auto rpc_connection_state_response =
createRpcConnectionStateResponse(uuid, false);
writer->Write(rpc_connection_state_response);
});

_stop_future.wait();
Expand Down Expand Up @@ -68,7 +61,21 @@ class CoreServiceImpl final : public dronecode_sdk::rpc::core::CoreService::Serv
private:
DronecodeSDK &_dc;
std::promise<void> _stop_promise;

std::future<void> _stop_future;

static dronecode_sdk::rpc::core::ConnectionStateResponse
createRpcConnectionStateResponse(const uint64_t uuid, const bool is_connected)
{
auto rpc_connection_state = new rpc::core::ConnectionState();
rpc_connection_state->set_uuid(uuid);
rpc_connection_state->set_is_connected(is_connected);

dronecode_sdk::rpc::core::ConnectionStateResponse rpc_connection_state_response;
rpc_connection_state_response.set_allocated_connection_state(rpc_connection_state);

return rpc_connection_state_response;
}
};

} // namespace backend
Expand Down
32 changes: 3 additions & 29 deletions backend/src/plugins/mission/mission_service_impl.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -44,14 +44,10 @@ class MissionServiceImpl final : public dronecode_sdk::rpc::mission::MissionServ
auto rpc_mission_result = generateRPCMissionResult(result);
response->set_allocated_mission_result(rpc_mission_result);

auto rpc_mission = new rpc::mission::MissionItems();

for (const auto mission_item : mission_items) {
auto rpc_mission_item = rpc_mission->add_mission_items();
auto rpc_mission_item = response->add_mission_items();
translateMissionItem(mission_item, rpc_mission_item);
}

response->set_allocated_mission_items(rpc_mission);
}

result_promise.set_value();
Expand Down Expand Up @@ -142,29 +138,6 @@ class MissionServiceImpl final : public dronecode_sdk::rpc::mission::MissionServ
return grpc::Status::OK;
}

grpc::Status GetCurrentMissionItemIndex(
grpc::ServerContext * /* context */,
const rpc::mission::GetCurrentMissionItemIndexRequest * /* request */,
rpc::mission::GetCurrentMissionItemIndexResponse *response) override
{
if (response != nullptr) {
response->set_index(_mission.current_mission_item());
}

return grpc::Status::OK;
}

grpc::Status GetMissionCount(grpc::ServerContext * /* context */,
const rpc::mission::GetMissionCountRequest * /* request */,
rpc::mission::GetMissionCountResponse *response) override
{
if (response != nullptr) {
response->set_count(_mission.total_mission_items());
}

return grpc::Status::OK;
}

grpc::Status SubscribeMissionProgress(
grpc::ServerContext * /* context */,
const dronecode_sdk::rpc::mission::SubscribeMissionProgressRequest * /* request */,
Expand Down Expand Up @@ -236,6 +209,7 @@ class MissionServiceImpl final : public dronecode_sdk::rpc::mission::MissionServ
rpc_mission_item->set_camera_action(
translateCameraAction(mission_item->get_camera_action()));
rpc_mission_item->set_loiter_time_s(mission_item->get_loiter_time_s());
rpc_mission_item->set_camera_photo_interval_s(mission_item->get_camera_photo_interval_s());
}

static rpc::mission::MissionItem::CameraAction
Expand Down Expand Up @@ -304,7 +278,7 @@ class MissionServiceImpl final : public dronecode_sdk::rpc::mission::MissionServ
std::vector<std::shared_ptr<MissionItem>> mission_items;

if (request != nullptr) {
for (auto rpc_mission_item : request->mission_items().mission_items()) {
for (auto rpc_mission_item : request->mission_items()) {
mission_items.push_back(translateRPCMissionItem(rpc_mission_item));
}
}
Expand Down
175 changes: 61 additions & 114 deletions backend/test/core_service_impl_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,15 +18,11 @@ using MockDronecodeSDK = NiceMock<dronecode_sdk::testing::MockDronecodeSDK>;
using CoreServiceImpl = dronecode_sdk::backend::CoreServiceImpl<MockDronecodeSDK>;
using CoreService = dronecode_sdk::rpc::core::CoreService;

using DiscoverResponse = dronecode_sdk::rpc::core::DiscoverResponse;
using TimeoutResponse = dronecode_sdk::rpc::core::TimeoutResponse;
using ConnectionStateResponse = dronecode_sdk::rpc::core::ConnectionStateResponse;

static constexpr auto DEFAULT_BACKEND_PORT = 50051;
static constexpr auto DEFAULT_BACKEND_ADDRESS = "localhost";

static constexpr uint64_t ARBITRARY_UINT64_T = 42;
static constexpr uint64_t ARBITRARY_SMALL_INT = 11;

class CoreServiceImplTest : public ::testing::Test {
protected:
virtual void SetUp()
Expand All @@ -46,8 +42,7 @@ class CoreServiceImplTest : public ::testing::Test {
virtual void TearDown() { _server->Shutdown(); }

void checkPluginIsRunning(const std::string plugin_name);
std::future<void> subscribeDiscoverAsync(std::vector<uint64_t> &uuids);
std::future<void> subscribeTimeoutAsync(int *stream_count);
std::future<void> subscribeConnectionStateAsync(std::vector<std::pair<uint64_t, bool>> &events);

std::unique_ptr<CoreServiceImpl> _core_service{};
std::unique_ptr<MockDronecodeSDK> _dc{};
Expand Down Expand Up @@ -114,159 +109,111 @@ TEST_F(CoreServiceImplTest, portIsDefaultInPluginInfos)
}
}

TEST_F(CoreServiceImplTest, subscribeDiscoverActuallySubscribes)
TEST_F(CoreServiceImplTest, subscribeConnectionStateSubscribesToDiscover)
{
EXPECT_CALL(*_dc, register_on_discover(_)).Times(1);
grpc::ClientContext context;
dronecode_sdk::rpc::core::SubscribeDiscoverRequest request;
dronecode_sdk::rpc::core::SubscribeConnectionStateRequest request;

_stub->SubscribeDiscover(&context, request);
_stub->SubscribeConnectionState(&context, request);
_core_service->stop();
}

TEST_F(CoreServiceImplTest, discoverStreamEmptyIfCallbackNotCalled)
TEST_F(CoreServiceImplTest, subscribeConnectionStateSubscribesToTimeout)
{
std::vector<uint64_t> uuids;
auto uuids_stream_future = subscribeDiscoverAsync(uuids);
EXPECT_CALL(*_dc, register_on_timeout(_)).Times(1);
grpc::ClientContext context;
dronecode_sdk::rpc::core::SubscribeConnectionStateRequest request;

_stub->SubscribeConnectionState(&context, request);
_core_service->stop();
uuids_stream_future.wait();
}

TEST_F(CoreServiceImplTest, connectionStateStreamEmptyIfCallbackNotCalled)
{
std::vector<std::pair<uint64_t, bool>> events;
auto events_stream_future = subscribeConnectionStateAsync(events);

_core_service->stop();
events_stream_future.wait();

EXPECT_EQ(0, uuids.size());
EXPECT_EQ(0, events.size());
}

std::future<void> CoreServiceImplTest::subscribeDiscoverAsync(std::vector<uint64_t> &uuids)
std::future<void>
CoreServiceImplTest::subscribeConnectionStateAsync(std::vector<std::pair<uint64_t, bool>> &events)
{
return std::async(std::launch::async, [&]() {
grpc::ClientContext context;
dronecode_sdk::rpc::core::SubscribeDiscoverRequest request;
auto response_reader = _stub->SubscribeDiscover(&context, request);
dronecode_sdk::rpc::core::SubscribeConnectionStateRequest request;
auto response_reader = _stub->SubscribeConnectionState(&context, request);

dronecode_sdk::rpc::core::DiscoverResponse response;
dronecode_sdk::rpc::core::ConnectionStateResponse response;
while (response_reader->Read(&response)) {
uuids.push_back(response.uuid());
events.push_back(std::make_pair(response.connection_state().uuid(),
response.connection_state().is_connected()));
}
});
}

TEST_F(CoreServiceImplTest, discoverSendsOneUUID)
TEST_F(CoreServiceImplTest, connectionStatesSendsOneEvents)
{
const int expected_uuid = 42;
const bool expected_connection_state = true;
std::promise<void> subscription_promise;
auto subscription_future = subscription_promise.get_future();
dronecode_sdk::testing::event_callback_t event_callback;
EXPECT_CALL(*_dc, register_on_discover(_))
.WillOnce(SaveCallback(&event_callback, &subscription_promise));

std::vector<uint64_t> uuids;
auto uuids_stream_future = subscribeDiscoverAsync(uuids);
std::vector<std::pair<uint64_t, bool>> events;
auto uuids_stream_future = subscribeConnectionStateAsync(events);
subscription_future.wait();
event_callback(expected_uuid);
_core_service->stop();
uuids_stream_future.wait();

ASSERT_EQ(1, uuids.size());
EXPECT_EQ(expected_uuid, uuids.at(0));
ASSERT_EQ(1, events.size());
EXPECT_EQ(expected_uuid, events.at(0).first);
EXPECT_EQ(expected_connection_state, events.at(0).second);
}

TEST_F(CoreServiceImplTest, discoverSendsMultipleUUIDs)
TEST_F(CoreServiceImplTest, connectionStateSendsMultipleEvents)
{
const int uuid0 = 234132413;
const int uuid1 = 948789299;
const int uuid2 = 861987343;
std::promise<void> subscription_promise;
auto subscription_future = subscription_promise.get_future();
dronecode_sdk::testing::event_callback_t event_callback;
EXPECT_CALL(*_dc, register_on_discover(_))
.WillOnce(SaveCallback(&event_callback, &subscription_promise));
std::promise<void> discover_subscription_promise;
auto discover_subscription_future = discover_subscription_promise.get_future();

std::vector<uint64_t> uuids;
auto uuids_stream_future = subscribeDiscoverAsync(uuids);
subscription_future.wait();
event_callback(uuid0);
event_callback(uuid1);
event_callback(uuid2);
_core_service->stop();
uuids_stream_future.wait();

ASSERT_EQ(3, uuids.size());
EXPECT_EQ(uuid0, uuids.at(0));
EXPECT_EQ(uuid1, uuids.at(1));
EXPECT_EQ(uuid2, uuids.at(2));
}

TEST_F(CoreServiceImplTest, subscribeTimeoutActuallySubscribes)
{
EXPECT_CALL(*_dc, register_on_timeout(_)).Times(1);
grpc::ClientContext context;
dronecode_sdk::rpc::core::SubscribeTimeoutRequest request;
std::promise<void> timeout_subscription_promise;
auto timeout_subscription_future = timeout_subscription_promise.get_future();

_stub->SubscribeTimeout(&context, request);
_core_service->stop();
}

TEST_F(CoreServiceImplTest, timeoutStreamEmptyIfCallbackNotCalled)
{
int count = 0;
auto timeout_stream_future = subscribeTimeoutAsync(&count);

_core_service->stop();
timeout_stream_future.wait();

EXPECT_EQ(0, count);
}

std::future<void> CoreServiceImplTest::subscribeTimeoutAsync(int *stream_count)
{
return std::async(std::launch::async, [this, stream_count]() {
grpc::ClientContext context;
dronecode_sdk::rpc::core::SubscribeTimeoutRequest request;
auto response_reader = _stub->SubscribeTimeout(&context, request);

dronecode_sdk::rpc::core::TimeoutResponse response;
while (response_reader->Read(&response)) {
(*stream_count)++;
}
});
}

TEST_F(CoreServiceImplTest, timeoutIsCalledOnce)
{
std::promise<void> subscription_promise;
auto subscription_future = subscription_promise.get_future();
dronecode_sdk::testing::event_callback_t event_callback;
EXPECT_CALL(*_dc, register_on_timeout(_))
.WillOnce(SaveCallback(&event_callback, &subscription_promise));

int count = 0;
auto timeout_stream_future = subscribeTimeoutAsync(&count);
subscription_future.wait();
event_callback(ARBITRARY_UINT64_T);
_core_service->stop();
timeout_stream_future.wait();

EXPECT_EQ(1, count);
}
dronecode_sdk::testing::event_callback_t discover_callback;
EXPECT_CALL(*_dc, register_on_discover(_))
.WillOnce(SaveCallback(&discover_callback, &discover_subscription_promise));

TEST_F(CoreServiceImplTest, timeoutIsCalledMultipleTimes)
{
const int expected_count = ARBITRARY_SMALL_INT;
std::promise<void> subscription_promise;
auto subscription_future = subscription_promise.get_future();
dronecode_sdk::testing::event_callback_t event_callback;
dronecode_sdk::testing::event_callback_t timeout_callback;
EXPECT_CALL(*_dc, register_on_timeout(_))
.WillOnce(SaveCallback(&event_callback, &subscription_promise));

int count = 0;
auto timeout_stream_future = subscribeTimeoutAsync(&count);
subscription_future.wait();
for (int i = 0; i < expected_count; i++) {
event_callback(ARBITRARY_UINT64_T);
}
.WillOnce(SaveCallback(&timeout_callback, &timeout_subscription_promise));

std::vector<std::pair<uint64_t, bool>> events;
auto events_stream_future = subscribeConnectionStateAsync(events);
discover_subscription_future.wait();
timeout_subscription_future.wait();
discover_callback(uuid0);
timeout_callback(uuid1);
timeout_callback(uuid2);
_core_service->stop();
timeout_stream_future.wait();

EXPECT_EQ(expected_count, count);
events_stream_future.wait();

ASSERT_EQ(3, events.size());
EXPECT_EQ(uuid0, events.at(0).first);
EXPECT_EQ(true, events.at(0).second);
EXPECT_EQ(uuid1, events.at(1).first);
EXPECT_EQ(false, events.at(1).second);
EXPECT_EQ(uuid2, events.at(2).first);
EXPECT_EQ(false, events.at(2).second);
}

} // namespace
Loading

0 comments on commit a2463f4

Please sign in to comment.