Exemplo n.º 1
0
def test_Router_register_template_builder(processor_examples):
    example_router = route.Router()
    example_template_builder = processor_examples.get_example_template_builder()

    example_router.register_template_builder(
        region_name="reg", sample_name="signal", systematic_name="sys", template="Up"
    )(example_template_builder)

    assert example_router.template_builders == [
        {
            "region": "reg",
            "sample": "signal",
            "systematic": "sys",
            "template": "Up",
            "name": "example_template_builder",
            "func": example_template_builder,
        }
    ]
Exemplo n.º 2
0
def test_Router__register_processor(processor_examples):
    example_router = route.Router()
    example_template_builder = processor_examples.get_example_template_builder()

    example_router._register_processor(
        example_router.template_builders,
        region_name="reg",
        sample_name="signal",
        systematic_name="sys",
        template="Up",
    )(example_template_builder)

    assert example_router.template_builders == [
        {
            "region": "reg",
            "sample": "signal",
            "systematic": "sys",
            "template": "Up",
            "name": "example_template_builder",
            "func": example_template_builder,
        }
    ]

    # test registration with no details specified
    example_router._register_processor(
        example_router.template_builders,
        region_name=None,
        sample_name=None,
        systematic_name=None,
        template=None,
    )(example_template_builder)

    assert example_router.template_builders[-1] == {
        "region": "*",
        "sample": "*",
        "systematic": "*",
        "template": "*",
        "name": "example_template_builder",
        "func": example_template_builder,
    }
Exemplo n.º 3
0
def test_Router__find_template_builder_match(processor_examples):
    example_router = route.Router()
    example_template_builder = processor_examples.get_example_template_builder()

    # no wrapper defined
    with pytest.raises(ValueError, match="no template builder wrapper defined"):
        example_router._find_template_builder_match("", "", "", "")

    def example_wrapper(func):
        @functools.wraps(func)
        def wrapper(reg, sam, sys, tem):
            # return the bin yield of the histogram to have something to compare
            return func(reg, sam, sys, tem).view().value

        return wrapper

    # wrapper defined, but no match available
    example_router.template_builder_wrapper = example_wrapper
    assert example_router._find_template_builder_match("", "", "", "") is None

    # match exists
    with mock.patch(
        "cabinetry.route.Router._find_match", return_value=example_template_builder
    ) as mock_find:
        wrapped_builder = example_router._find_template_builder_match("reg", "", "", "")
        assert mock_find.call_args_list == [(([], "reg", "", "", ""), {})]

        # need to verify that wrapped template builder is wrapped with right function
        expected_wrap = example_wrapper(example_template_builder)
        assert wrapped_builder.__name__ == expected_wrap.__name__

        # a direct assert of equality fails
        # assert wrapped_builder == expected_wrap

        # compare instead the behavior for an example call
        assert wrapped_builder({}, {}, {}, {}) == expected_wrap({}, {}, {}, {})
Exemplo n.º 4
0
def test_Router__find_match(processor_examples, caplog):
    caplog.set_level(logging.DEBUG)
    example_router = route.Router()
    example_template_builder = processor_examples.get_example_template_builder()

    def other_processor():
        pass

    example_processor_specification = {
        "region": "r?g",
        "sample": "sig*",
        "systematic": "*",
        "template": "Up",
        "name": "example_template_builder",
        "func": example_template_builder,
    }
    other_processor_specification = {
        "region": "abc",
        "sample": "*",
        "systematic": "*",
        "template": "*",
        "name": "other_processor",
        "func": other_processor,
    }
    example_router.template_builders = [
        other_processor_specification,
        example_processor_specification,
    ]

    # get a single match
    assert (
        example_router._find_match(
            example_router.template_builders, "reg", "signal", "sys", "Up"
        )
        is example_template_builder
    )

    # no matches available
    assert (
        example_router._find_match(
            example_router.template_builders, "reg", "background", "sys", "Up"
        )
        is None
    )

    # multiple matches
    caplog.clear()
    example_router.template_builders = [
        example_processor_specification,
        example_processor_specification,
    ]
    assert (
        example_router._find_match(
            example_router.template_builders, "reg", "signal", "sys", "Up"
        )
        is example_template_builder
    )

    assert (
        "found 2 matches, continuing with the first one (example_template_builder)"
        in [rec.message for rec in caplog.records]
    )
    caplog.clear()
Exemplo n.º 5
0
def test_Router():
    router = route.Router()
    assert router.template_builders == []
    assert router.template_builder_wrapper is None