ALCBaselineModellingPresenterTest.h

#ifndef MANTIDQT_CUSTOMINTERFACES_ALCBASELINEMODELLINGTEST_H_
#define MANTIDQT_CUSTOMINTERFACES_ALCBASELINEMODELLINGTEST_H_

#include <cxxtest/TestSuite.h>
#include <gmock/gmock.h>

#include <boost/scoped_ptr.hpp>
#include <boost/assign/list_of.hpp>

#include "MantidAPI/FunctionFactory.h"
#include "MantidAPI/FrameworkManager.h"
#include "MantidAPI/WorkspaceFactory.h"

#include "MantidQtCustomInterfaces/Muon/ALCBaselineModellingPresenter.h"

using namespace MantidQt::CustomInterfaces;
using namespace testing;
using boost::scoped_ptr;

class MockALCBaselineModellingView : public IALCBaselineModellingView
{
public:
  void requestFit() { emit fitRequested(); }
  void requestAddSection() { emit addSectionRequested(); }
  void requestRemoveSection(int row) { emit removeSectionRequested(row); }
  void modifySectionRow(int row) { emit sectionRowModified(row); }
  void modifySectionSelector(int index) { emit sectionSelectorModified(index); }

  MOCK_METHOD0(initialize, void());

  MOCK_CONST_METHOD0(function, QString());
  MOCK_CONST_METHOD1(sectionRow, SectionRow(int));

  MOCK_METHOD1(setDataCurve, void(const QwtData&));
  MOCK_METHOD1(setCorrectedCurve, void(const QwtData&));
  MOCK_METHOD1(setBaselineCurve, void(const QwtData&));
  MOCK_METHOD1(setFunction, void(const QString&));

  MOCK_CONST_METHOD0(noOfSectionRows, int());
  MOCK_METHOD1(setNoOfSectionRows, void(int));
  MOCK_METHOD2(setSectionRow, void(int, SectionRow));

  MOCK_CONST_METHOD1(sectionSelector, SectionSelector(int));
  MOCK_METHOD2(addSectionSelector, void(int, SectionSelector));
  MOCK_METHOD2(updateSectionSelector, void(int, SectionSelector));
  MOCK_METHOD1(deleteSectionSelector, void(int));

  MOCK_METHOD1(setSectionSelectors, void(const std::vector<SectionSelector>&));
  MOCK_METHOD3(updateSectionSelector, void(size_t, double, double));

  MOCK_METHOD1(displayError, void(const QString&));

  MOCK_METHOD0(help, void());
};

class MockALCBaselineModellingModel : public IALCBaselineModellingModel
{
public:
  void changeData() { emit dataChanged(); }
  void changeFittedFunction() { emit fittedFunctionChanged(); }
  void changeCorrectedData() { emit correctedDataChanged(); }

  MOCK_CONST_METHOD0(fittedFunction, IFunction_const_sptr());
  MOCK_CONST_METHOD0(correctedData, MatrixWorkspace_const_sptr());
  MOCK_CONST_METHOD0(data, MatrixWorkspace_const_sptr());

  MOCK_METHOD2(fit, void(IFunction_const_sptr, const std::vector<Section>&));
};

MATCHER_P(FunctionName, name, "") { return arg->name() == name; }

MATCHER_P3(FunctionParameter, param, value, delta, "")
{
  return fabs(arg->getParameter(param) - value) < delta;
}

MATCHER_P3(QwtDataX, i, value, delta, "") { return fabs(arg.x(i) - value) < delta; }
MATCHER_P3(QwtDataY, i, value, delta, "") { return fabs(arg.y(i) - value) < delta; }

class ALCBaselineModellingPresenterTest : public CxxTest::TestSuite
{
  MockALCBaselineModellingView* m_view;
  MockALCBaselineModellingModel* m_model;
  ALCBaselineModellingPresenter* m_presenter;

  // To save myself some typing
  IALCBaselineModellingView::SectionRow sectionRow(double min, double max)
  {
    return std::make_pair(QString::number(min), QString::number(max));
  }

public:
  // This pair of boilerplate methods prevent the suite being created statically
  // This means the constructor isn't called when running otherl tests
  static ALCBaselineModellingPresenterTest *createSuite() { return new ALCBaselineModellingPresenterTest(); }
  static void destroySuite( ALCBaselineModellingPresenterTest *suite ) { delete suite; }

  ALCBaselineModellingPresenterTest()
  {
    FrameworkManager::Instance(); // To make sure everything is initialized
  }

  void setUp()
  {
    m_view = new NiceMock<MockALCBaselineModellingView>();
    m_model = new NiceMock<MockALCBaselineModellingModel>();
    m_presenter = new ALCBaselineModellingPresenter(m_view, m_model);
    m_presenter->initialize();
  }

  void tearDown()
  {
    TS_ASSERT(Mock::VerifyAndClearExpectations(m_view));
    TS_ASSERT(Mock::VerifyAndClearExpectations(m_model));

    delete m_presenter;
    delete m_model;
    delete m_view;
  }

  // Creates a workspace with x = [1,2,3...size], y = x + deltaY and e = 1
  MatrixWorkspace_sptr createTestWs(size_t size, double deltaY = 0)
  {
    MatrixWorkspace_sptr ws = WorkspaceFactory::Instance().create("Workspace2D", 1, size, size);

    for (size_t i = 0; i < size; ++i)
    {
      ws->dataX(0)[i] = static_cast<double>(i + 1);
      ws->dataY(0)[i] = ws->dataX(0)[i] + deltaY;
      ws->dataE(0)[i] = 1;
    }

    return ws;
  }

  void test_initialize()
  {
    // Not using m_view and m_present, because they are already initialized after setUp()
    MockALCBaselineModellingView view;
    MockALCBaselineModellingModel model;
    ALCBaselineModellingPresenter presenter(&view, &model);
    EXPECT_CALL(view, initialize()).Times(1);
    presenter.initialize();
  }

  void test_dataChanged()
  {
    ON_CALL(*m_view, noOfSectionRows()).WillByDefault(Return(3));
    ON_CALL(*m_model, data()).WillByDefault(Return(createTestWs(3, 1)));

    EXPECT_CALL(*m_view, setDataCurve(AllOf(Property(&QwtData::size, 3),
                                            QwtDataX(0, 1, 1E-8), QwtDataX(2, 3, 1E-8),
                                            QwtDataY(0, 2, 1E-8), QwtDataY(2, 4, 1E-8))));

    // Data changed -> clear sections
    EXPECT_CALL(*m_view, setNoOfSectionRows(0));
    EXPECT_CALL(*m_view, deleteSectionSelector(0));
    EXPECT_CALL(*m_view, deleteSectionSelector(1));
    EXPECT_CALL(*m_view, deleteSectionSelector(2));

    m_model->changeData();
  }

  void test_correctedChanged()
  {
    ON_CALL(*m_model, correctedData()).WillByDefault(Return(createTestWs(3, 2)));

    EXPECT_CALL(*m_view, setCorrectedCurve(AllOf(Property(&QwtData::size, 3),
                                            QwtDataX(0, 1, 1E-8), QwtDataX(2, 3, 1E-8),
                                            QwtDataY(0, 3, 1E-8), QwtDataY(2, 5, 1E-8))));

    m_model->changeCorrectedData();
  }

  void test_correctedChanged_toEmpty()
  {
    ON_CALL(*m_model, correctedData()).WillByDefault(Return(MatrixWorkspace_const_sptr()));

    EXPECT_CALL(*m_view, setCorrectedCurve(Property(&QwtData::size, 0)));

    m_model->changeCorrectedData();
  }

  void test_fittedFunctionChanged()
  {
    auto f = FunctionFactory::Instance().createInitialized("name=FlatBackground,A0=5");

    ON_CALL(*m_model, fittedFunction()).WillByDefault(Return(f));
    ON_CALL(*m_model, data()).WillByDefault(Return(createTestWs(3)));

    EXPECT_CALL(*m_view, setFunction(QString::fromStdString(f->asString())));

    EXPECT_CALL(*m_view, setBaselineCurve(AllOf(Property(&QwtData::size, 3),
                                                QwtDataX(0, 1, 1E-8), QwtDataX(2, 3, 1E-8),
                                                QwtDataY(0, 5, 1E-8), QwtDataY(2, 5, 1E-8))));

    m_model->changeFittedFunction();
  }

  void test_fittedFunctionChanged_toEmpty()
  {
    ON_CALL(*m_model, fittedFunction()).WillByDefault(Return(IFunction_const_sptr()));

    EXPECT_CALL(*m_view, setFunction(QString("")));
    EXPECT_CALL(*m_view, setBaselineCurve(Property(&QwtData::size, 0)));

    m_model->changeFittedFunction();
  }


  void test_addSection()
  {
    ON_CALL(*m_model, data()).WillByDefault(Return(createTestWs(10)));
    ON_CALL(*m_view, noOfSectionRows()).WillByDefault(Return(1));

    Expectation tableExtended = EXPECT_CALL(*m_view, setNoOfSectionRows(2));

    EXPECT_CALL(*m_view, setSectionRow(1, Pair(QString("1"), QString("10")))).After(tableExtended);

    EXPECT_CALL(*m_view, addSectionSelector(1, Pair(1,10)));

    m_view->requestAddSection();
  }

  void test_removeSection()
  {
    ON_CALL(*m_view, noOfSectionRows()).WillByDefault(Return(3));
    ON_CALL(*m_view, sectionRow(0)).WillByDefault(Return(sectionRow(1,2)));
    ON_CALL(*m_view, sectionRow(1)).WillByDefault(Return(sectionRow(3,4)));
    ON_CALL(*m_view, sectionRow(2)).WillByDefault(Return(sectionRow(5,6)));

    Expectation tableShrinked = EXPECT_CALL(*m_view, setNoOfSectionRows(2));

    EXPECT_CALL(*m_view, setSectionRow(0, Pair(QString("1"), QString("2")))).After(tableShrinked);
    EXPECT_CALL(*m_view, setSectionRow(1, Pair(QString("5"), QString("6")))).After(tableShrinked);

    ExpectationSet selectorsCleared;

    selectorsCleared += EXPECT_CALL(*m_view, deleteSectionSelector(0));
    selectorsCleared += EXPECT_CALL(*m_view, deleteSectionSelector(1));
    selectorsCleared += EXPECT_CALL(*m_view, deleteSectionSelector(2));

    EXPECT_CALL(*m_view, addSectionSelector(0, Pair(1,2))).After(selectorsCleared);
    EXPECT_CALL(*m_view, addSectionSelector(1, Pair(5,6))).After(selectorsCleared);

    m_view->requestRemoveSection(1);
  }

  void test_onSectionSelectorModified()
  {
    ON_CALL(*m_view, sectionSelector(5)).WillByDefault(Return(std::make_pair(1,2)));

    EXPECT_CALL(*m_view, setSectionRow(5, Pair(QString("1"), QString("2"))));

    m_view->modifySectionSelector(5);
  }

  void test_onSectionRowModified()
  {
    IALCBaselineModellingView::SectionRow row(QString("3"), QString("4"));
    ON_CALL(*m_view, sectionRow(4)).WillByDefault(Return(row));

    EXPECT_CALL(*m_view, updateSectionSelector(4, Pair(3,4)));
    m_view->modifySectionRow(4);
  }

  void test_fit()
  {
    ON_CALL(*m_view, noOfSectionRows()).WillByDefault(Return(2));
    ON_CALL(*m_view, sectionRow(0)).WillByDefault(Return(sectionRow(10,20)));
    ON_CALL(*m_view, sectionRow(1)).WillByDefault(Return(sectionRow(40,55)));

    ON_CALL(*m_view, function()).WillByDefault(Return(QString("name=FlatBackground,A0=3")));

    EXPECT_CALL(*m_model, fit(AllOf(FunctionName("FlatBackground"),
                                    FunctionParameter("A0", 3, 1E-8)),
                              ElementsAre(Pair(10, 20),
                                          Pair(40, 55))));

    m_view->requestFit();
  }

  void test_fit_exception()
  {
    // Any valid set of sections
    ON_CALL(*m_view, noOfSectionRows()).WillByDefault(Return(1));
    ON_CALL(*m_view, sectionRow(0)).WillByDefault(Return(sectionRow(1,2)));

    // Valid function
    ON_CALL(*m_view, function()).WillByDefault(Return(QString("name=FlatBackground,A0=3")));

    std::string errorMsg = "Bad error";

    ON_CALL(*m_model, fit(_,_)).WillByDefault(Throw(std::runtime_error(errorMsg)));
    EXPECT_CALL(*m_view, displayError(QString::fromStdString(errorMsg)));

    m_view->requestFit();
  }

  void test_fit_badFunction()
  {
    // Any valid set of sections
    ON_CALL(*m_view, noOfSectionRows()).WillByDefault(Return(1));
    ON_CALL(*m_view, sectionRow(0)).WillByDefault(Return(sectionRow(1,2)));

    // Invalid function
    ON_CALL(*m_view, function()).WillByDefault(Return(QString("bla-bla")));

    EXPECT_CALL(*m_model, fit(_,_)).Times(0);
    EXPECT_CALL(*m_view, displayError(_));

    m_view->requestFit();
  }

  void test_fit_emptyFunction()
  {
    // Any valid set of sections
    ON_CALL(*m_view, noOfSectionRows()).WillByDefault(Return(1));
    ON_CALL(*m_view, sectionRow(0)).WillByDefault(Return(sectionRow(1,2)));

    // Empty function
    ON_CALL(*m_view, function()).WillByDefault(Return(QString("")));

    EXPECT_CALL(*m_model, fit(_,_)).Times(0);
    EXPECT_CALL(*m_view, displayError(_));

    m_view->requestFit();
  }

  void test_fit_noSections()
  {
    // No sections
    ON_CALL(*m_view, noOfSectionRows()).WillByDefault(Return(0));

    // Any valid function
    ON_CALL(*m_view, function()).WillByDefault(Return(QString("name=FlatBackground,A0=0")));

    EXPECT_CALL(*m_model, fit(_,_)).Times(0);
    EXPECT_CALL(*m_view, displayError(_));

    m_view->requestFit();
  }

  void test_helpPage ()
  {
    EXPECT_CALL(*m_view, help()).Times(1);
    m_view->help();
  }
};


#endif /* MANTIDQT_CUSTOMINTERFACES_ALCBASELINEMODELLINGTEST_H_ */