hce-node/html/_sphinx_reducer_test_mock_8cpp_source.html

/*

 * SphinxReducerTestMock.cpp

 *

 *  Created on: May 7, 2013

 *      Author: igor

 */

#include <gtest/gtest.h>

#include <string>

#include "SphinxTaskReducer.hpp"

#include <SphinxResultData.hpp>

#include "SphinxResultTransformer.hpp"

#include <Poco/SharedPtr.h>

#include "SphinxResultCompareUtils.hpp"

#include "SphinxResultBuilder.hpp"

#include "SphinxReduceJobBuilder.hpp"

#include "ScheduleStrategySingle.hpp"

#include "Mocks.hpp"

#include "CoreMocks.hpp"


using namespace HCE::sphinx;

using namespace HCE::sphinx::reduce_task;

using namespace HCE::reduce::core;

using namespace Poco;

using namespace std;


using ::testing::_;

using ::testing::InSequence;

using ::testing::SetArgReferee;

using ::testing::Return;

using ::testing::ReturnPointee;

using ::testing::ReturnRef;

using ::testing::Eq;


TEST(SphinxReducerTestMock, fillDataStorage)

{

  SphinxResultBuilderMock sphinxResultBuilder;

  SphinxResultDataAccumulatorFactoryMock sphinxResultDataAccumulatorFactory;

  SharedPtr<SphinxResultDataAccumulatorMock>sphinxResultDataAccumulator(

                                        new SphinxResultDataAccumulatorMock());

  SphinxReduceJobBuilderMock sphinxReduceJobBuilder;

  ScheduleStrategyMock scheduleStrategy;


  SharedPtr<SphinxReduceDataStorage>sphinxReduceDataStorage(new SphinxReduceDataStorage());

  SharedPtr<SphinxReduceResult>sphinxReduceResult(new SphinxReduceResult());

  SharedPtr<ReduceJobMock> sphinxReduceJobMock(new ReduceJobMock());


  SharedPtr<SphinxResultData> sphinxResultAfterReducing;

  vector<SphinxRequestInfo> requestInfo;


  InSequence s;

  EXPECT_CALL(sphinxReduceJobBuilder, build())

             .WillOnce(ReturnPointee(&sphinxReduceJobMock));


  EXPECT_CALL(*sphinxReduceJobMock.get(), getDataStorage())

             .WillOnce(ReturnPointee(&sphinxReduceDataStorage));


  EXPECT_CALL(sphinxResultDataAccumulatorFactory, build(_))

             .WillOnce(ReturnPointee(&sphinxResultDataAccumulator));


  EXPECT_CALL(*sphinxResultDataAccumulator.get(), accumulate(_))

             .Times(2);

  EXPECT_CALL(scheduleStrategy, executeJob(_))

              .Times(1);

  //getResult

  EXPECT_CALL(*sphinxReduceJobMock.get(), getReduceResult())

              .WillOnce(ReturnPointee(&sphinxReduceResult));

  EXPECT_CALL(*sphinxResultDataAccumulator.get(), getSphinxDataStorage())

              .WillOnce(ReturnPointee(&sphinxReduceDataStorage));

  EXPECT_CALL(*sphinxResultDataAccumulator.get(), getAllSphinxRequestInfo())

              .WillOnce(ReturnRef(requestInfo));

  EXPECT_CALL(sphinxResultBuilder, build(_, _,_))

                .WillOnce(ReturnPointee(&sphinxResultAfterReducing));


  SphinxTaskReducer sphinxReducer(sphinxResultBuilder, sphinxReduceJobBuilder,

                                  sphinxResultDataAccumulatorFactory);


  SphinxResultData sphinxResultData1;

  SphinxResultData sphinxResultData2;


  sphinxReducer.addData(sphinxResultData1);

  sphinxReducer.addData(sphinxResultData2);

  sphinxReducer.reduce(scheduleStrategy);

  sphinxResultAfterReducing = sphinxReducer.getResult();

}