testinsertlibrary.cpp

/*
 * This file is part of the Cutelee template system.
 *
 * Copyright (c) 2020 Matthias Fehring <mf@huessenbergnetz.de>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either version
 * 2.1 of the Licence, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef INSERTLIBRARYTEST_H
#define INSERTLIBRARYTEST_H

#include <QTest>
#include <QDebug>

#include "coverageobject.h"
#include "engine.h"
#include "cutelee_paths.h"
#include "template.h"
#include "node.h"
#include "parser.h"
#include "taglibraryinterface.h"
#include "exception.h"

#define TESTLIBRARYTAG_RENDER_VALUE "Hello World!"

using namespace Cutelee;

class TestInsertLibrary : public CoverageObject
{
    Q_OBJECT

private Q_SLOTS:
    void initTestCase();
    void cleanupTestCase();

    void testInsertedLibraryTag();
    void testLoadInsertedLibraryTag();

private:
    std::shared_ptr<InMemoryTemplateLoader> m_loader;
    Engine *m_engine = nullptr;
};

class TestLibraryTagFactory : public AbstractNodeFactory
{
    Node *getNode(const QString &tagContent, Parser *p) const override;
};

class TestLibraryTag : public Node
{
    Q_OBJECT
public:
    explicit TestLibraryTag(Parser *parser = nullptr) : Node(parser) {}

    void render(Cutelee::OutputStream *stream, Cutelee::Context *gc) const override;
};

Node *TestLibraryTagFactory::getNode(const QString &tagContent, Parser *p) const
{
    Q_UNUSED(tagContent)
    return new TestLibraryTag(p);
}

void TestLibraryTag::render(Cutelee::OutputStream *stream, Cutelee::Context *gc) const
{
    Q_UNUSED(gc);
    *stream << QStringLiteral(TESTLIBRARYTAG_RENDER_VALUE);
}

class TestLibrary : public QObject, public TagLibraryInterface
{
    Q_OBJECT
    Q_INTERFACES(Cutelee::TagLibraryInterface)
public:
    explicit TestLibrary(QObject *parent = nullptr) : QObject(parent) {}

    virtual QHash<QString, AbstractNodeFactory*> nodeFactories(const QString &name = QString()) override
    {
        Q_UNUSED(name);
        QHash<QString, AbstractNodeFactory*> ret{
            {QStringLiteral("test_library_tag"), new TestLibraryTagFactory()}
        };
        return ret;
    }
};

class TestLoadLibrary : public QObject, public TagLibraryInterface
{
    Q_OBJECT
    Q_INTERFACES(Cutelee::TagLibraryInterface)
public:
    explicit TestLoadLibrary(QObject *parent = nullptr) : QObject(parent) {}

    virtual QHash<QString, AbstractNodeFactory*> nodeFactories(const QString &name = QString()) override
    {
        Q_UNUSED(name);
        QHash<QString, AbstractNodeFactory*> ret{
            {QStringLiteral("test_load_library_tag"), new TestLibraryTagFactory()}
        };
        return ret;
    }
};

void TestInsertLibrary::initTestCase()
{
    m_engine = new Engine(this);
    QVERIFY(m_engine);

    m_loader = std::shared_ptr<InMemoryTemplateLoader>(new InMemoryTemplateLoader());
    m_engine->addTemplateLoader(m_loader);

    m_engine->setPluginPaths({QStringLiteral(CUTELEE_PLUGIN_PATH)});

    m_engine->insertDefaultLibrary(QStringLiteral("test_library"), new TestLibrary(m_engine));

    m_engine->insertLibrary(QStringLiteral("test_load_library"), new TestLoadLibrary(m_engine));
}

void TestInsertLibrary::cleanupTestCase()
{
    delete m_engine;
}

void TestInsertLibrary::testInsertedLibraryTag()
{
    auto t = m_engine->newTemplate(QStringLiteral("{% test_library_tag %}"), QStringLiteral("testInsertedLibraryTag"));

    Context context;

    const QString result = t->render(&context);

    QCOMPARE(result, QStringLiteral(TESTLIBRARYTAG_RENDER_VALUE));
}

void TestInsertLibrary::testLoadInsertedLibraryTag()
{
    Context context;

    auto t1 = m_engine->newTemplate(QStringLiteral("{% test_load_library_tag %}"), QStringLiteral("testLoadInsertedLibraryTag1"));

    const QString result1 = t1->render(&context);

    QVERIFY(result1.isEmpty());

    auto t2 = m_engine->newTemplate(QStringLiteral("{% load test_load_library %}{% test_load_library_tag %}"), QStringLiteral("testLoadInsertedLibraryTag2"));

    const QString result2 = t2->render(&context);

    QCOMPARE(result2, QStringLiteral(TESTLIBRARYTAG_RENDER_VALUE));
}

QTEST_MAIN(TestInsertLibrary)

#include "testinsertlibrary.moc"

#endif // INSERTLIBRARYTEST_H