SphinxTaskReducersManagerTest.cpp

Go to the documentation of this file.

/*
 * SphinxTaskReducersManager.cpp
 *
 *  Created on: May 16, 2013
 *      Author: igor
 */
#include <gmock/gmock.h>
#include "Exceptions.hpp"
#include "SphinxExceptions.hpp"
#include "Mocks.hpp"
#include "ScheduleStrategySingle.hpp"
#include "SphinxTaskReducersManager.hpp"
#include "SphinxReduceJobBuilder.hpp"
#include "SphinxTaskReducerFactory.hpp"

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

using ::testing::_;
using ::testing::Return;
using ::testing::ReturnRef;
using ::testing::ReturnPointee;
using ::testing::Throw;
using ::testing::Eq;


class SphinxTaskReducersManagerTest: public ::testing::Test{
  protected:
    virtual void SetUp(){
      sphinxTaskReducersStorage.assign(new SphinxTaskReducersStorageMock());
      sphinxTaskReducerFactory.assign(new SphinxTaskReducerFactoryMock());
      sphinxResultJSONConvertor.assign(new SphinxResultJSONConvertorMock());
      sphinxTaskReducer.assign(new SphinxTaskReducerMock());
    }

    virtual void TearDown(){
      sphinxTaskReducersStorage.assign(NULL);
      sphinxTaskReducerFactory.assign(NULL);
      sphinxResultJSONConvertor.assign(NULL);
      sphinxTaskReducer.assign(NULL);
    }

    SharedPtr<SphinxTaskReducersStorageMock> sphinxTaskReducersStorage;
    SharedPtr<SphinxTaskReducerFactoryMock> sphinxTaskReducerFactory;
    SharedPtr<SphinxResultJSONConvertorMock> sphinxResultJSONConvertor;
    SharedPtr<SphinxTaskReducerMock> sphinxTaskReducer;
};


TEST_F(SphinxTaskReducersManagerTest, canFindSphinxTaskReducerByTaskId)
{
  unsigned long long existTaskId = 2;

  SphinxTaskReducersManager sphinxTaskReducersManager(sphinxTaskReducersStorage,
                              sphinxTaskReducerFactory, sphinxResultJSONConvertor);

  EXPECT_CALL(*sphinxTaskReducersStorage.get(), findByKey(_))
              .WillOnce(ReturnPointee(&sphinxTaskReducer));
  ASSERT_THAT(sphinxTaskReducersManager.isReducerExist(existTaskId), true);
}



TEST_F(SphinxTaskReducersManagerTest, canntFindSphinxTaskReducerByTaskId)
{
  unsigned long long noExistTaskId = 7;
  NotFoundByKeyException notFoundSphinxTaskReducerException("No item in the storage");

  SphinxTaskReducersManager sphinxTaskReducersManager(sphinxTaskReducersStorage,
                              sphinxTaskReducerFactory, sphinxResultJSONConvertor);

  EXPECT_CALL(*sphinxTaskReducersStorage.get(), findByKey(_))
              .WillOnce(Throw(notFoundSphinxTaskReducerException));
  ASSERT_THAT(sphinxTaskReducersManager.isReducerExist(noExistTaskId), false);
}


TEST_F(SphinxTaskReducersManagerTest, createNewSphinxTaskReducerForTaskId)
{
  unsigned long long newTaskId = 3;

  SphinxTaskReducersManager sphinxTaskReducersManager(sphinxTaskReducersStorage,
                            sphinxTaskReducerFactory, sphinxResultJSONConvertor);

  EXPECT_CALL(*sphinxTaskReducerFactory.get(), create())
              .WillOnce(ReturnPointee(&sphinxTaskReducer));
  EXPECT_CALL(*sphinxTaskReducersStorage.get(), addWithKey(Eq(newTaskId), _))
              .Times(1);

  sphinxTaskReducersManager.createReducer(newTaskId);
}


TEST_F(SphinxTaskReducersManagerTest, convertJSONtoSphinxResultAndFillItInSphinxTaskReducer)
{
  unsigned long long existTaskId = 7;
  string json = "fake JSON";
  SharedPtr<SphinxResultData> buildFromJSONSphinxResult;

  SphinxTaskReducersManager sphinxTaskReducersManager(sphinxTaskReducersStorage,
                            sphinxTaskReducerFactory, sphinxResultJSONConvertor);

  EXPECT_CALL(*sphinxResultJSONConvertor.get(), convertToSphinxResultDataFrom(Eq(json)))
              .WillOnce(ReturnPointee(&buildFromJSONSphinxResult));
  EXPECT_CALL(*sphinxTaskReducersStorage.get(), findByKey(Eq(existTaskId)))
              .WillOnce(ReturnPointee(&sphinxTaskReducer));
  EXPECT_CALL(*sphinxTaskReducer.get(), addData(_))
              .Times(1);

  sphinxTaskReducersManager.addDataInReducer(existTaskId, json);
}


TEST_F(SphinxTaskReducersManagerTest, throwExceptionWhileEncounterJSONStructureError)
{
  unsigned long long existTaskId = 7;
  string badStructuredJSON = "bad structure";
  WrongJSONStructureException wrongJSONStructureException("");

  SphinxTaskReducersManager sphinxTaskReducersManager(sphinxTaskReducersStorage,
                            sphinxTaskReducerFactory, sphinxResultJSONConvertor);

  EXPECT_CALL(*sphinxResultJSONConvertor.get(), convertToSphinxResultDataFrom(_))
              .WillOnce(Throw(wrongJSONStructureException));
  ASSERT_THROW(sphinxTaskReducersManager.addDataInReducer(existTaskId,
                                                             badStructuredJSON),
               WrongJSONStructureException);
}


TEST_F(SphinxTaskReducersManagerTest, runReduceForSphinxTaskReducerByTaskIdAndConvertResultToJSON)
{
  unsigned long long reducedTaskId = 4;
  ScheduleStrategySingle scheduleStrategy;
  SharedPtr<SphinxResultData> reducedSphinxResult;
  SphinxResultTrancaterMock SphinxResultTrancater;

  SphinxTaskReducersManager sphinxTaskReducersManager(sphinxTaskReducersStorage,
                            sphinxTaskReducerFactory, sphinxResultJSONConvertor);

  EXPECT_CALL(*sphinxTaskReducersStorage.get(), findByKey(Eq(reducedTaskId)))
             .WillOnce(ReturnPointee(&sphinxTaskReducer));
  EXPECT_CALL(*sphinxTaskReducerFactory.get(), getScheduleStrategy())
             .WillOnce(ReturnRef(scheduleStrategy));
  EXPECT_CALL(*sphinxTaskReducer.get(), reduce(_))
             .Times(1);
  EXPECT_CALL(*sphinxTaskReducer.get(), getResult())
             .WillOnce(ReturnPointee(&reducedSphinxResult));
  EXPECT_CALL(*sphinxTaskReducerFactory.get(), getSphinxResultTrancater())
             .WillOnce(ReturnRef(SphinxResultTrancater));
  EXPECT_CALL(SphinxResultTrancater, trancate(Eq(reducedSphinxResult)))
             .WillOnce(ReturnPointee(&reducedSphinxResult));
  EXPECT_CALL(*sphinxResultJSONConvertor.get(), convertToJSONFrom(Eq(reducedSphinxResult)))
             .Times(1);

  sphinxTaskReducersManager.runReduceTaskForTaskId(reducedTaskId);
}


TEST_F(SphinxTaskReducersManagerTest, deleteSphinxTaskReducerByTaskId)
{
  unsigned long long taskId = 3;

  SphinxTaskReducersManager sphinxTaskReducersManager(sphinxTaskReducersStorage,
                            sphinxTaskReducerFactory, sphinxResultJSONConvertor);

  EXPECT_CALL(*sphinxTaskReducersStorage.get(), deleteByKey(Eq(taskId)))
               .Times(1);

  sphinxTaskReducersManager.deleteReducerBy(taskId);
}