Mocks.hpp

Go to the documentation of this file.

/*
 * Mocks.h
 *
 *  Created on: May 6, 2013
 *      Author: igor
 */

#ifndef MOCKS_H_
#define MOCKS_H_

#include <gmock/gmock.h>
#include "SphinxResultTransformerIf.hpp"
#include "SphinxResultBuilderIf.hpp"
#include "SphinxReduceJobBuilderIf.hpp"
#include "SphinxResultDataAccumulatorFactoryIf.hpp"
#include "SphinxTaskReducersStorageIf.hpp"
#include "SphinxTaskReducerFactoryIf.hpp"
#include "SphinxResultJSONConvertorIf.hpp"
#include "SphinxTaskReducerIf.hpp"
#include "SphinxResultSorterIf.hpp"
#include "SphinxResultTruncaterIf.hpp"

using namespace HCE::reduce::core;
using namespace HCE::sphinx::reduce_task;
using namespace HCE::sphinx;
using namespace Poco;
using namespace std;

class SphinxResultTransformerMock: public SphinxResultTransformerIf{
  public:
    MOCK_METHOD2(extractWeightKeys, void(const Poco::SharedPtr<SphinxResultData> &sphinxResultData,
                   std::vector<std::pair<std::string, unsigned long long> > &extractedWeightKeys));
};


class SphinxResultBuilderMock: public SphinxResultBuilderIf{
public:
  MOCK_METHOD3(build, Poco::SharedPtr<SphinxResultData>(
                      Poco::SharedPtr<SphinxReduceDataStorage> &sphinxDataStorage,
                      const Poco::SharedPtr<HCE::reduce::core::ReduceResultIf> &sphinxReduceResult,
                      const std::vector<SphinxRequestInfo>& requestInfo));

  MOCK_METHOD2(buildFromUsingKeys, Poco::SharedPtr<SphinxResultData>(
                   const Poco::SharedPtr<SphinxResultData> &sphinxResultData,
                   std::vector<std::pair<std::string, unsigned long long> > &selectWeightKeys));
};


class SphinxReduceJobBuilderMock: public SphinxReduceJobBuilderIf{
  public:
    MOCK_METHOD0(build, Poco::SharedPtr<HCE::reduce::core::ReduceJobIf>());
};


class SphinxResultDataAccumulatorFactoryMock: public SphinxResultDataAccumulatorFactoryIf{
public:
  MOCK_METHOD1(build, SharedPtr<SphinxResultDataAccumulatorIf>
                               (SharedPtr<SphinxReduceDataStorage>& dataStorage));
};


class SphinxResultDataAccumulatorMock: public SphinxResultDataAccumulatorIf{
public:
  MOCK_METHOD1_T(accumulate, void(SphinxResultData& sphinxResultData));
  MOCK_METHOD0_T(getAllSphinxRequestInfo, std::vector<SphinxRequestInfo>&());
  MOCK_METHOD0_T(getSphinxDataStorage, Poco::SharedPtr<SphinxReduceDataStorage>());
};


class SphinxTaskReducersStorageMock: public SphinxTaskReducersStorageIf{
public:
  MOCK_METHOD1(findByKey,
                 SharedPtr<SphinxTaskReducerIf>(unsigned long long taskId));
  MOCK_METHOD1(deleteByKey, void(unsigned long long taskId));
  MOCK_METHOD2(addWithKey, void(unsigned long long taskId,
                 SharedPtr<SphinxTaskReducerIf>&sphinxTaskReducer));
};


class SphinxTaskReducerFactoryMock: public SphinxTaskReducerFactoryIf{
public:
  MOCK_METHOD0(create, SharedPtr<SphinxTaskReducerIf>());
  MOCK_METHOD0(getScheduleStrategy, ScheduleStrategyIf&());
  MOCK_METHOD0(getSphinxResultTrancater, SphinxResultTruncaterIf&());
};


class SphinxResultJSONConvertorMock: public SphinxResultJSONConvertorIf{
public:
  MOCK_METHOD1(convertToSphinxResultDataFrom, SharedPtr<SphinxResultData>(const string& json));
  MOCK_METHOD1(convertToJSONFrom, string(const SharedPtr<SphinxResultData>& sphinxResultData));
};


class SphinxTaskReducerMock: public SphinxTaskReducerIf{
public:

  MOCK_METHOD1(addData, void(SphinxResultData& sphinxResultData));
  MOCK_METHOD1(reduce, void(ScheduleStrategyIf &scheduleStrategy));
  MOCK_METHOD0(getResult, SharedPtr<SphinxResultData>());
};


class SphinxResultSortedMock: public SphinxResultSorterIf{
public:
  MOCK_METHOD1(sortByWeight, void(
                          std::vector<std::pair<std::string, unsigned long long> > &weightDocIds));
};


class SphinxResultTrancaterMock: public SphinxResultTruncaterIf{
public:
  MOCK_METHOD1(trancate, SharedPtr<SphinxResultData>(SharedPtr<SphinxResultData>& sphinxResultData));
};

#endif /* MOCKS_H_ */