HandlerMocks.hpp

Go to the documentation of this file.

#ifndef HANDLERMOCKS_H_
#define HANDLERMOCKS_H_

#include <gmock/gmock.h>
#include "ReducingPartsCountersStorageIf.hpp"
#include "ReduceAdditionsStorageIf.hpp"
#include "TaskReducersManagerFactoryIf.hpp"
#include "ReducingExceptionsTranslatorIf.hpp"
#include "SupportNotifierIf.hpp"
#include "ReducingInputMessage.hpp"
#include "ReducingOutputMessageBuilderIf.hpp"
#include "TaskReducersManagerIf.hpp"

using namespace HCE;
using namespace HCE::reduce;
using namespace HCE::reduce::additions;
using namespace HCE::reduce_types;
using namespace Poco;
using namespace std;


class ReducingPartsCountersStorageMock: public ReducingPartsCountersStorageIf{
public:
  MOCK_METHOD1(findBy, bool(unsigned long long keyId));
  MOCK_METHOD1(deleteBy, void(unsigned long long keyId));
  MOCK_METHOD1(addReducingPartsCounterWithKey, void(unsigned long long keyId));
  MOCK_METHOD1(incrementBy, void(unsigned long long keyId));
  MOCK_METHOD1(getAccumulateReducingParts, int(unsigned long long keyId));
  MOCK_METHOD0(getTotalTasksNumber, unsigned int());
};


class ReduceAdditionsStorageMock: public ReduceAdditionsStorageIf{
public:
  MOCK_METHOD1(findBy, Poco::SharedPtr<additions::TaskReducersManagerIf>(HCE::types::MessageType key));
  MOCK_METHOD1(findBy, Poco::SharedPtr<additions::TaskReducersManagerIf>(unsigned long long secondKey));
  MOCK_METHOD1(deleteBy, void (unsigned long long secondKey));
  MOCK_METHOD2(addWith, void(HCE::types::MessageType key,
                             Poco::SharedPtr<additions::TaskReducersManagerIf> taskReducersManager));
  MOCK_METHOD2(addWith, void(unsigned long long secondKey,
                             Poco::SharedPtr<additions::TaskReducersManagerIf> taskReducersManager));
};


class TaskReducersManagerFactoryMock: public TaskReducersManagerFactoryIf{
public:
  MOCK_METHOD1(build, Poco::SharedPtr<additions::TaskReducersManagerIf>(types::MessageType managerType));
};

class ReducingExceptionsTranslatorMock: public ReducingExceptionsTranslatorIf{
public:
  MOCK_METHOD1(translateToErrorCode, int(const NotFoundByKeyException& e));
  MOCK_METHOD1(translateToErrorMsg, string(const NotFoundByKeyException& e));
};


class SupportNotifierMock: public SupportNotifierIf{
public:
  MOCK_METHOD2(notifyWrongJSONStructure, void(unsigned long long itemId,
               const SharedPtr<ReducingInputMessage>& reducingInputMessage));
  MOCK_METHOD1(notifyNotFoundItemException, void(const NotFoundByKeyException& e));
};


class ReducingOutputMessageBuilderMock: public ReducingOutputMessageBuilderIf
{
public:
  MOCK_METHOD3(build, SharedPtr<ReducingOutputMessage>(const types::MessageType& msgType,
                                                       const int ttl, const string& json));
  MOCK_METHOD1(build, SharedPtr<ReducingOutputMessage>
                      (const NotFoundByKeyException& e));
};


class TaskReducersManagerMock: public TaskReducersManagerIf {
public:
  MOCK_METHOD0(getType, types::MessageType());
  MOCK_METHOD1(isReducerExist, bool(unsigned long long reduceTaskId));
  MOCK_METHOD1(createReducer, void(unsigned long long reduceTaskId));
  MOCK_METHOD2(addDataInReducer, void(unsigned long long reduceTaskId, const std::string& json));
  MOCK_METHOD1(runReduceTaskForTaskId,  std::string(unsigned long long reduceTaskId));
  MOCK_METHOD1(deleteReducerBy, void(unsigned long long reduceTaskId));
};

#endif