Esempio n. 1
0
def test_list_diff():

    el3 = {"name": "el3"}

    test1 = {"pipelines": {"foo1": [{"name": "el1"}, {"name": "el2"}, el3]}}

    cfg = config_diff.Config(test1)

    assert len(cfg["pipelines"]["foo1"]) == 3

    watcher = CallbackWatcher()
    cfg.add_callback(watcher.on_callback)

    # test equality
    assert cfg["pipelines"]["foo1"] == test1["pipelines"]["foo1"]

    del cfg["pipelines"]["foo1"][0]
    cfg["pipelines"]["foo1"].remove(el3)
    assert len(cfg["pipelines"]["foo1"]) == 1

    log.info("Config %s", cfg)

    tries = 5
    while watcher.event is None:
        sleep(0.1)
        tries -= 1
        if tries == 0:
            raise Exception("Callback not triggered")

    cfg["pipelines"]["foo1"][0]["name"] = "hello"

    assert len(watcher.event.get_paths()) == 3
    assert watcher.event.get_root() is not None
Esempio n. 2
0
def test_embed_list_diff():

    test1 = {
        "list": [
            {
                "v": ["a", "b"]
            },
            {
                "v": ["c", "d"]
            },
        ]
    }

    cfg = config_diff.Config(test1)

    assert isinstance(cfg["list"][0]["v"], config_diff.ConfigList)
    assert cfg["list"][1] == test1["list"][1]

    test1["list"].clear()
    cfg.sync(test1)

    assert len(test1["list"]) == 0

    cfg["list"].insert(0, {"v": ["e", "f"]})
    assert len(cfg["list"]) == 1

    cfg["list"] += [{"v": ["g", "h"]}]
    assert len(cfg["list"]) == 2

    cfg["list"].extend([{"v": ["i", "l"]}])
    assert len(cfg["list"]) == 3

    cfg["list"][0] = {"v": []}
    assert len(cfg["list"]) == 3
    assert len(cfg["list"][0]["v"]) == 0
Esempio n. 3
0
def test_list_eq():

    test1 = [
        {
            "v": ["a", "b"]
        },
        {
            "v": ["c", "d"]
        },
    ]
    test2 = [
        {
            "v": ["a", "b"]
        },
    ]
    test3 = [
        {
            "v": ["c", "d"]
        },
        {
            "v": ["a", "b"]
        },
    ]
    cfg = config_diff.Config(test1)

    assert isinstance(cfg, config_diff.ConfigList)
    assert cfg[1] == test1[1]
    assert cfg == test1
    assert cfg != test2
    assert cfg != test3
def test_list_ops():

    test1 = [
        {"v": ["a", "b"]},
        {"v": ["c", "d"]},
    ]
    cfg = config_diff.Config(test1)

    assert isinstance(cfg, config_diff.ConfigList)
    assert cfg[1] == test1[1]

    cfg.append({ "v": ["e", "f"] })
    
    assert cfg[2]["v"][0] == "e"
Esempio n. 5
0
def test_callbacks():

    test1 = {
        "version": "1.2.3",
        "logging": {
            "level": "WARN",
            "options": ["a", "b", "c"]
        }
    }

    cfg = config_diff.Config(test1)

    assert cfg.get("version") == test1["version"]
    assert cfg["logging"]["level"] == test1["logging"]["level"]

    def test1_cb(event: config_diff.ConfigChangedEvent):
        # print("***** event", event)
        if event.get_name() == "level":
            assert event.new_value == "DEBUG" or event.new_value == "INFO"

    cfg.add_callback(test1_cb)

    test1["logging"]["level"] = "DEBUG"
    cfg.update(test1)
    cfg["logging"]["level"] = "INFO"

    def test2_cb(event: config_diff.ConfigChangedEvent):
        assert len(cfg["logging"]["options"]) >= 3

    cfg.add_callback(test2_cb)

    test1["logging"]["options"].append('d')
    cfg.update(test1)

    cfg["logging"]["options"][0] = 'y'

    assert cfg["logging"]["options"][0] == 'y'

    def test3_cb(event: config_diff.ConfigChangedEvent):
        raise Exception("ouch!")

    cfg.add_callback(test3_cb)

    cfg["logging"]["options"].append("z")

    assert len(cfg["logging"]["options"]) == 5
def test_dict_ops():

    test1 = {
        "obj": {}, 
        "num": 1
    }
    cfg = config_diff.Config(test1)

    assert isinstance(cfg, config_diff.ConfigDict)
    assert cfg == test1

    cfg["obj"]["add"] = True
    cfg["obj"]["remove"] = False
    del cfg["obj"]["remove"]
    del cfg["obj"]["add"]

    cfg["num"] += 1
    cfg["num"] -=1

    assert cfg == test1
Esempio n. 7
0
def test_callbacks():

    watcher = CallbackWatcher()

    test1 = {"version": "1.2.3"}

    cfg = config_diff.Config(test1)

    cfg.add_callback(watcher.on_callback)

    cfg.set("version", "3.2.1")

    assert cfg.get("version") == "3.2.1"
    assert watcher.event is not None

    cfg.remove_callback(watcher.on_callback)

    def cb1(ev):
        pass

    cfg.remove_callback(cb1)

    assert len(cfg.get_callbacks()) == 0
Esempio n. 8
0
def test_accessors():

    test1 = {
        "version": "1.2.3",
        "logging": {
            "level": "string"
        },
        "ai_models": {
            "image_detection": {
                "model": {
                    "tflite": "string",
                    "edgetpu": "string"
                },
                "labels": "string",
                "top_k": 2,
                "precision": 0.8
            }
        },
        "pipelines": {
            "front_door_watch": [{
                "source": "src_recorded_cam_feed"
            }]
        }
    }

    cfg = config_diff.Config(test1)

    assert cfg.get("version") == test1["version"]
    assert cfg["ai_models"]["image_detection"]["model"]["edgetpu"] == test1[
        "ai_models"]["image_detection"]["model"]["edgetpu"]
    assert len(cfg["pipelines"]["front_door_watch"]) == 1

    version1 = "1.2.3.4"
    cfg.set("version", version1)
    assert cfg.get("version") == version1
    assert cfg.get("non_existant", "ok") == "ok"
def test_to_values():

    val = {"name": "el3"}
    cfg = config_diff.Config(val)

    assert val == cfg.to_values()