305 lines
No EOL
12 KiB
C++
305 lines
No EOL
12 KiB
C++
#include "gtest/gtest.h"
|
|
#include "TestConnectionFlowBase.h"
|
|
#include "MockFullConfigRetriever.h"
|
|
|
|
#include <huestream/config/HueConfig.h>
|
|
|
|
using namespace testing;
|
|
using namespace huestream;
|
|
using namespace huestream::connectionflow;
|
|
|
|
void TestConnectionFlowBase::SetUp() {
|
|
auto settings = std::make_shared<HueSettings>();
|
|
settings->SetUseRenderThread(true);
|
|
HueConfig::GetInstance()->SetHueSettings(settings);
|
|
_stream = std::make_shared<MockStream>();
|
|
HueConfig::GetInstance()->SetStream(_stream);
|
|
_bridges = make_shared<BridgeList>(3);
|
|
_bridges->at(0) = make_shared<Bridge>("001788FFFE2007AA", "192.168.1.34", true);
|
|
_bridges->at(1) = make_shared<Bridge>("001788FFFE2007BB", "192.168.1.35", true);
|
|
_bridges->at(2) = make_shared<Bridge>("001788FFFE2007CC", "192.168.1.36", true);
|
|
_bridges->at(0)->SetApiversion("1.19.0");
|
|
_bridges->at(1)->SetApiversion("1.19.0");
|
|
_bridges->at(2)->SetApiversion("1.19.0");
|
|
_searchers = make_shared<vector<shared_ptr<MockBridgeSearcher>>>();
|
|
_authenticators = make_shared<vector<shared_ptr<MockBridgeAuthenticator>>>(3);
|
|
_factory = std::make_shared<MockConnectionFlowFactory>();
|
|
_messageDispatcher = std::make_shared<MessageDispatcherStub>();
|
|
EXPECT_CALL(*_factory, GetMessageDispatcher()).WillRepeatedly(Return(_messageDispatcher));
|
|
_storageAccesser = std::make_shared<MockBridgeStorageAccesser>();
|
|
EXPECT_CALL(*_factory, GetStorageAccesser()).WillRepeatedly(Return(_storageAccesser));
|
|
_fullConfigRetriever = std::make_shared<MockFullConfigRetriever>();
|
|
EXPECT_CALL(*_factory, CreateFullConfigRetriever()).WillRepeatedly(Return(_fullConfigRetriever));
|
|
_connectionFlow = std::make_shared<TestableConnectionFlow>(_factory);
|
|
}
|
|
|
|
void TestConnectionFlowBase::TearDown() {
|
|
HueConfig::GetInstance()->TearDown();
|
|
}
|
|
|
|
void TestConnectionFlowBase::set_autostart_based_on_param(int param) {
|
|
auto autoStart = true;
|
|
if (param == 0)
|
|
autoStart = false;
|
|
|
|
HueConfig::GetInstance()->GetHueSettings()->SetAutoStartAtConnection(autoStart);
|
|
}
|
|
|
|
void TestConnectionFlowBase::expect_message(Id id, FeedbackType type) {
|
|
EXPECT_CALL(*_connectionFlow, NewMessage(FbMessage(id, type))).Times(1);
|
|
}
|
|
void TestConnectionFlowBase::expect_message(Id id, FeedbackType type, BridgePtr bridge) {
|
|
EXPECT_CALL(*_connectionFlow, NewMessage(FbMessageWithBridge(id, type, bridge))).Times(1);
|
|
}
|
|
void TestConnectionFlowBase::expect_message(Id id, FeedbackType type, BridgePtr bridge, BridgeStatus status) {
|
|
EXPECT_CALL(*_connectionFlow, NewMessage(FbMessageWithBridgeAndStatus(id, type, bridge, status))).Times(1);
|
|
}
|
|
void TestConnectionFlowBase::expect_no_actions() {
|
|
EXPECT_CALL(*_factory, CreateSearcher()).Times(0);
|
|
EXPECT_CALL(*_factory, CreateAuthenticator()).Times(0);
|
|
|
|
for(auto searcher: *_searchers) {
|
|
if (searcher) {
|
|
EXPECT_CALL(*searcher, SearchNew(_)).Times(0);
|
|
EXPECT_CALL(*searcher, SearchNew(_,_)).Times(0);
|
|
}
|
|
}
|
|
for(auto authenticator: *_authenticators) {
|
|
if (authenticator) {
|
|
EXPECT_CALL(*authenticator, Authenticate(_,_)).Times(0);
|
|
}
|
|
}
|
|
EXPECT_CALL(*_fullConfigRetriever, Execute(_, _)).Times(0);
|
|
}
|
|
|
|
void TestConnectionFlowBase::expect_on_searcher_search_new(bool bruteForce) {
|
|
auto x = make_shared<MockBridgeSearcher>();
|
|
_searchers->push_back(x);
|
|
|
|
EXPECT_CALL(*_factory, CreateSearcher()).Times(1).WillOnce(Return(x));
|
|
EXPECT_CALL(*x, SearchNew(bruteForce,_)).Times(1).WillOnce(SaveArg<1>(&x->SearchNewCallback));
|
|
}
|
|
|
|
shared_ptr<MockBridgeSearcher> TestConnectionFlowBase::get_last_searcher() {
|
|
auto last = _searchers->size() - 1;
|
|
return _searchers->at(last);
|
|
}
|
|
shared_ptr<MockBridgeAuthenticator> TestConnectionFlowBase::get_last_authenticator() {
|
|
auto last = _authenticators->size() - 1;
|
|
return _authenticators->at(last);
|
|
}
|
|
void TestConnectionFlowBase::expect_on_searcher_abort() {
|
|
EXPECT_CALL(*get_last_searcher(), Abort()).Times(1);
|
|
}
|
|
void TestConnectionFlowBase::expect_on_authenticator_authenticate(int index) {
|
|
auto x = make_shared<MockBridgeAuthenticator>();
|
|
_authenticators->at(index) = x;
|
|
EXPECT_CALL(*_factory, CreateAuthenticator()).InSequence(s).WillOnce(Return(x));
|
|
EXPECT_CALL(*x, Authenticate(BridgeIpAddress(_bridges->at(index)->GetIpAddress()), _)).Times(1).WillOnce(SaveArg<1>(&x->autenticate_callback));
|
|
}
|
|
void TestConnectionFlowBase::expect_on_storage_accesser_load() {
|
|
EXPECT_CALL(*_storageAccesser, Load(_)).Times(1).WillOnce(SaveArg<0>(&_storageAccesser->load_callback));
|
|
}
|
|
|
|
void TestConnectionFlowBase::expect_on_storage_accesser_save() {
|
|
expect_message(START_SAVING, INFO);
|
|
EXPECT_CALL(*_storageAccesser, Save(_,_)).Times(1).WillOnce(SaveArg<1>(&_storageAccesser->save_callback));
|
|
}
|
|
void TestConnectionFlowBase::expect_on_storage_accesser_save(BridgePtr bridge) {
|
|
expect_message(START_SAVING, INFO);
|
|
EXPECT_CALL(*_storageAccesser, Save(BridgeAttributes(bridge), _)).Times(1).WillOnce(SaveArg<1>(&_storageAccesser->save_callback));
|
|
}
|
|
|
|
void TestConnectionFlowBase::finish_search_with_no_bridges(shared_ptr<MockBridgeSearcher> searcher) {
|
|
searcher->SearchNewCallback(std::make_shared<BridgeList>());
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::finish_search_with_one_bridge(shared_ptr<MockBridgeSearcher> searcher, int index) {
|
|
BridgeListPtr list = std::make_shared<BridgeList>();
|
|
list->push_back(_bridges->at(index));
|
|
searcher->SearchNewCallback(list);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::finish_search_with_three_bridges(shared_ptr<MockBridgeSearcher> searcher) {
|
|
BridgeListPtr list = std::make_shared<BridgeList>();
|
|
list->push_back(_bridges->at(0));
|
|
list->push_back(_bridges->at(1));
|
|
list->push_back(_bridges->at(2));
|
|
searcher->SearchNewCallback(list);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::searching_with_three_bridges_found_starts_pushlink_on_all_three_bridges() {
|
|
expect_message(FINISH_SEARCH_BRIDGES_FOUND, INFO);
|
|
expect_message(START_AUTHORIZING, INFO);
|
|
expect_message(PRESS_PUSH_LINK, USER);
|
|
expect_on_authenticator_authenticate(0);
|
|
expect_on_authenticator_authenticate(1);
|
|
expect_on_authenticator_authenticate(2);
|
|
finish_search_with_three_bridges(get_last_searcher());
|
|
}
|
|
|
|
void TestConnectionFlowBase::searching_with_one_bridge_found_starts_pushlink() {
|
|
int index = 0;
|
|
expect_message(FINISH_SEARCH_BRIDGES_FOUND, INFO);
|
|
expect_message(START_AUTHORIZING, INFO);
|
|
expect_message(PRESS_PUSH_LINK, USER);
|
|
expect_on_authenticator_authenticate(index);
|
|
finish_search_with_one_bridge(get_last_searcher(), index);
|
|
}
|
|
|
|
void TestConnectionFlowBase::searching_background_with_one_bridge_found_finishes(int index) {
|
|
expect_message(FINISH_SEARCH_BRIDGES_FOUND, INFO);
|
|
expect_message(DONE_BRIDGE_FOUND, INFO);
|
|
expect_message(PROCEDURE_FINISHED, INFO);
|
|
finish_search_with_one_bridge(get_last_searcher(), index);
|
|
}
|
|
|
|
void TestConnectionFlowBase::searching_background_with_no_bridge_found_finishes() {
|
|
expect_message(FINISH_SEARCHING_NO_BRIDGES_FOUND, INFO);
|
|
expect_message(DONE_NO_BRIDGE_FOUND, INFO);
|
|
expect_message(PROCEDURE_FINISHED, INFO);
|
|
finish_search_with_no_bridges(get_last_searcher());
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::searching_once_with_no_bridges_found_starts_new_bridge_search() {
|
|
auto searcher = get_last_searcher();
|
|
expect_message(FINISH_SEARCHING_NO_BRIDGES_FOUND, INFO);
|
|
expect_message(START_SEARCHING, INFO);
|
|
expect_on_searcher_search_new(true);
|
|
finish_search_with_no_bridges(searcher);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::searching_twice_with_no_bridges_found_finalizes() {
|
|
searching_twice_with_no_bridges_found_finalizes(std::make_shared<Bridge>(), false);
|
|
}
|
|
|
|
void TestConnectionFlowBase::searching_twice_with_no_bridges_found_finalizes(BridgePtr bridge, bool existingBridge) {
|
|
BridgeStatus status = BRIDGE_EMPTY;
|
|
Id messageId = NO_BRIDGE_FOUND;
|
|
if (existingBridge) {
|
|
status = BRIDGE_NOT_CONNECTABLE;
|
|
messageId = BRIDGE_NOT_FOUND;
|
|
}
|
|
|
|
auto searcher = get_last_searcher();
|
|
expect_message(FINISH_SEARCHING_NO_BRIDGES_FOUND, INFO);
|
|
expect_message(DONE_ACTION_REQUIRED, INFO, bridge, status);
|
|
expect_message(messageId, USER, bridge);
|
|
expect_on_storage_accesser_save(bridge);
|
|
finish_search_with_no_bridges(searcher);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::authorize_bridge(int index) {
|
|
_bridges->at(index)->SetIsAuthorized(true);
|
|
_bridges->at(index)->SetUser("TestUser");
|
|
_bridges->at(index)->SetClientKey("00000000000000000000000000000000");
|
|
}
|
|
|
|
void TestConnectionFlowBase::finish_authorization_successfully_and_retrieve_full_config(int index, unsigned int numGroups) {
|
|
finish_authorization_successfully(index);
|
|
retrieve_full_config(index, numGroups);
|
|
}
|
|
|
|
void TestConnectionFlowBase::finish_authorization_successfully(int index) {
|
|
authorize_bridge(index);
|
|
|
|
expect_message(FINISH_AUTHORIZING_AUTHORIZED, INFO);
|
|
expect_initiate_full_config_retrieval();
|
|
|
|
_authenticators->at(index)->autenticate_callback(_bridges->at(index));
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::expect_initiate_full_config_retrieval()
|
|
{
|
|
expect_message(START_RETRIEVING, INFO);
|
|
expect_on_full_config_retriever_execute();
|
|
}
|
|
|
|
void TestConnectionFlowBase::retrieve_full_config(int index, unsigned int numGroups) {
|
|
set_bridge_in_full_config(numGroups);
|
|
|
|
if (numGroups == 0) {
|
|
expect_message(FINISH_RETRIEVING_ACTION_REQUIRED, INFO, _bridges->at(index), BRIDGE_NO_GROUP_AVAILABLE);
|
|
expect_message(DONE_ACTION_REQUIRED, INFO, _bridges->at(index), BRIDGE_NO_GROUP_AVAILABLE);
|
|
expect_message(NO_GROUP_AVAILABLE, USER, _bridges->at(index));
|
|
} else if (numGroups == 1) {
|
|
expect_message(FINISH_RETRIEVING_READY_TO_START, INFO, _bridges->at(index), BRIDGE_OK);
|
|
} else if (numGroups > 1) {
|
|
expect_message(FINISH_RETRIEVING_ACTION_REQUIRED, INFO, _bridges->at(index), BRIDGE_INVALID_GROUP_SELECTED);
|
|
expect_message(DONE_ACTION_REQUIRED, INFO, _bridges->at(index), BRIDGE_INVALID_GROUP_SELECTED);
|
|
expect_message(SELECT_GROUP, USER, _bridges->at(index), BRIDGE_INVALID_GROUP_SELECTED);
|
|
}
|
|
|
|
expect_on_storage_accesser_save();
|
|
|
|
_fullConfigRetriever->RetrieveCallback(OPERATION_SUCCESS, _fullConfigRetriever->Bridge);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::finish_with_stream_start(BridgePtr bridge) {
|
|
expect_message(FINISH_SAVING_SAVED, INFO);
|
|
expect_message(START_ACTIVATING, INFO);
|
|
expect_message(FINISH_ACTIVATING_ACTIVE, INFO, bridge, BRIDGE_OK);
|
|
expect_message(DONE_COMPLETED, INFO);
|
|
expect_message(PROCEDURE_FINISHED, INFO);
|
|
if (HueConfig::GetInstance()->GetHueSettings()->UseRenderThread()) {
|
|
EXPECT_CALL(*_stream, StartWithRenderThread(bridge)).WillOnce(Return(true));
|
|
} else {
|
|
EXPECT_CALL(*_stream, Start(bridge)).WillOnce(Return(true));
|
|
}
|
|
_storageAccesser->save_callback(OPERATION_SUCCESS);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::finish_without_stream_start(bool completed) {
|
|
expect_message(FINISH_SAVING_SAVED, INFO);
|
|
if (completed) {
|
|
expect_message(DONE_COMPLETED, INFO);
|
|
}
|
|
expect_message(PROCEDURE_FINISHED, INFO);
|
|
_storageAccesser->save_callback(OPERATION_SUCCESS);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::finish(BridgePtr bridge, bool completed) {
|
|
if (HueConfig::GetInstance()->GetHueSettings()->AutoStartAtConnection() && completed) {
|
|
finish_with_stream_start(bridge);
|
|
} else {
|
|
finish_without_stream_start(completed);
|
|
}
|
|
}
|
|
|
|
void TestConnectionFlowBase::abort_finalizes() {
|
|
expect_message(DONE_ABORTED, INFO);
|
|
expect_message(PROCEDURE_FINISHED, INFO);
|
|
_connectionFlow->Abort();
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::searching_with_abort_finalizes() {
|
|
expect_on_searcher_abort();
|
|
abort_finalizes();
|
|
}
|
|
|
|
void TestConnectionFlowBase::select_group_existing(int bridgeindex, int groupid) {
|
|
expect_message(PROCEDURE_STARTED, INFO);
|
|
expect_on_storage_accesser_save();
|
|
_connectionFlow->SelectGroup(groupid);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
}
|
|
|
|
void TestConnectionFlowBase::select_group_not_existing(int bridgeindex, int groupid) {
|
|
expect_message(PROCEDURE_STARTED, INFO);
|
|
expect_message(DONE_ACTION_REQUIRED, INFO);
|
|
expect_message(SELECT_GROUP, USER, _bridges->at(bridgeindex), BRIDGE_INVALID_GROUP_SELECTED);
|
|
expect_on_storage_accesser_save();
|
|
_connectionFlow->SelectGroup(groupid);
|
|
_messageDispatcher->ExecutePendingActions();
|
|
} |