actionmap.yaml

#############################
#       unittests.py        #
#############################
unittests:
    category_help: Launch unit tests. ONLY FOR DEV
    actions:

        ### unittests_launch()
        launch:
            action_help: launch all unit tests
            arguments:
                -m:
                    full: --module
                    help: name of the module you want to test
                -y:
                    full: --yes
                    help: "Yes I'm sure I want to launch unit test, I'M NOT RUNNING ON PROD"
                    action: store_true
                -i:
                    full: --ipdb
                    help: "Launch ipdb on error"
                    action: store_true

unittests.py

import os
import sys
import json

from moulinette.core import MoulinetteError

from settings import settings_get, settings_list, _get_settings, settings_set, settings_default, settings_reset, SETTINGS_PATH_OTHER_LOCATION, SETTINGS_PATH

MODULES = {}


def register(module_name):
    def _register(func):
        MODULES.setdefault(module_name, set()).add(func)
        return func

    return _register


def unittests_launch(module=None, yes=False, ipdb=False):
    if not yes:
        print "You are not sure of what you are doing (DO NOT LAUNCH THIS COMMAND IN PROD), abording"
        return

    if module is not None and module not in MODULES:
        print "Module '%s' doesn't have any tests. Available modules are : %s" % (module, ", ".join(MODULES.keys()))
        return

    if module is None:
        modules = MODULES.keys()
    else:
        modules = [module]

    failed = 0
    total = 0

    for module in modules:
        for test in MODULES[module]:
            total += 1
            set_up()
            try:
                if ipdb:
                    from ipdb import launch_ipdb_on_exception
                    with launch_ipdb_on_exception():
                        test()
                else:
                    test()
            except Exception as e:
                print "* %s FAILED" % test.__name__
                import traceback
                traceback.print_exc()
                print e
                failed += 1
            else:
                print "* %s OK" % test.__name__
            finally:
                tear_down()

    if failed:
        print "ERROR %s tests failed out of %s" % (failed, total)
        sys.exit(1)

    print
    print "All tests succeded \o/"


def assertEqual(a, b):
    # == can have different behavior than !=
    if not (a == b):
        raise AssertionError("%s != %s" % (a, b))


def assertNotEqual(a, b):
    # == can have different behavior than !=
    if not (a != b):
        raise AssertionError("%s != %s" % (a, b))


def assertRaise(exception_, func, *args, **kwargs):
    try:
        func(*args, **kwargs)
    except exception_:
        pass
    else:
        raise AssertionError("%s should have raise %s with arguments %s and %s" % (func.__name__, exception_.__name__, args, kwargs))


def set_up():
    os.system("mv /etc/yunohost/settings.json /etc/yunohost/settings.json.saved")


def tear_down():
    os.system("mv /etc/yunohost/settings.json.saved /etc/yunohost/settings.json")


@register("settings")
def test_settings_get_bool():
    assertEqual(settings_get("example.bool"), {"type": "bool", "value": True, "default": True, "description": "Example boolean option"})


@register("settings")
def test_settings_get_int():
    assertEqual(settings_get("example.int"), {"type": "int", "value": 42, "default": 42, "description": "Example int option"})


@register("settings")
def test_settings_get_string():
    assertEqual(settings_get("example.string"), {"type": "string", "value": "yolo swag", "default": "yolo swag", "description": "Example string option"})


@register("settings")
def test_settings_get_enum():
    assertEqual(settings_get("example.enum"), {"type": "enum", "value": "a", "default": "a", "description": "Example enum option", "choices": ["a", "b", "c"]})


@register("settings")
def test_settings_get_doesnt_exists():
    assertRaise(MoulinetteError, settings_get, "doesnt.exists")


@register("settings")
def test_settings_list():
    assertEqual(settings_list(), _get_settings())


@register("settings")
def test_settings_set():
    settings_set("example.bool", False)
    assertEqual(settings_get("example.bool")["value"], False)


@register("settings")
def test_settings_set_int():
    settings_set("example.int", 21)
    assertEqual(settings_get("example.int")["value"], 21)


@register("settings")
def test_settings_set_enum():
    settings_set("example.enum", "c")
    assertEqual(settings_get("example.enum")["value"], "c")


@register("settings")
def test_settings_set_doesexit():
    assertRaise(MoulinetteError, settings_set, "doesnt.exist", True)


@register("settings")
def test_settings_set_bad_type_bool():
    assertRaise(MoulinetteError, settings_set, "example.bool", 42)
    assertRaise(MoulinetteError, settings_set, "example.bool", "pouet")


@register("settings")
def test_settings_set_bad_type_int():
    assertRaise(MoulinetteError, settings_set, "example.int", True)
    assertRaise(MoulinetteError, settings_set, "example.int", "pouet")


@register("settings")
def test_settings_set_bad_type_string():
    assertRaise(MoulinetteError, settings_set, "example.string", True)
    assertRaise(MoulinetteError, settings_set, "example.string", 42)


@register("settings")
def test_settings_set_bad_value_enum():
    assertRaise(MoulinetteError, settings_set, "example.enum", True)
    assertRaise(MoulinetteError, settings_set, "example.enum", "e")
    assertRaise(MoulinetteError, settings_set, "example.enum", 42)
    assertRaise(MoulinetteError, settings_set, "example.enum", "pouet")


@register("settings")
def test_settings_list_modified():
    settings_set("example.int", 21)
    assertEqual(settings_list()["example.int"]["value"], 21)


@register("settings")
def test_default():
    settings_set("example.int", 21)
    assertEqual(settings_get("example.int")["value"], 21)
    settings_default("example.int")
    assertEqual(settings_get("example.int")["value"], settings_get("example.int")["default"])


@register("settings")
def test_settings_default_doesexit():
    assertRaise(MoulinetteError, settings_default, "doesnt.exist")


@register("settings")
def test_settings_reset_no_yes():
    assertRaise(MoulinetteError, settings_reset)


@register("settings")
def test_reset():
    settings_before = settings_list()
    settings_set("example.bool", False)
    settings_set("example.int", 21)
    settings_set("example.string", "pif paf pouf")
    settings_set("example.enum", "c")
    assertNotEqual(settings_before, settings_list())
    settings_reset(yes=True)
    assertEqual(settings_before, settings_list())


@register("settings")
def test_reset_backup():
    settings_before = settings_list()
    settings_set("example.bool", False)
    settings_set("example.int", 21)
    settings_set("example.string", "pif paf pouf")
    settings_set("example.enum", "c")
    settings_after_modification = settings_list()
    assertNotEqual(settings_before, settings_after_modification)
    old_settings_backup_path = settings_reset(yes=True)["old_settings_backup_path"]

    for i in settings_after_modification:
        del settings_after_modification[i]["description"]

    assertEqual(settings_after_modification, json.load(open(old_settings_backup_path, "r")))


@register("settings")
def test_unknown_keys():
    unknown_settings_path = SETTINGS_PATH_OTHER_LOCATION % "unknown"
    unknown_setting = {
        "unkown_key": {"value": 42, "default": 31, "type": "int"},
    }
    open(SETTINGS_PATH, "w").write(json.dumps(unknown_setting))

    # stimulate a write
    settings_reset(yes=True)

    assertEqual(unknown_setting, json.load(open(unknown_settings_path, "r")))