Пример #1
0
def test_compute_state():
    local_result = local.LocalResult(
        cached=None,
        item="Some_other_Service",
        state='P',
        text="Result is computed from two values",
        perfdata=[
            local.Perfdata(
                name="value1",
                value=10,
                levels=(30, 50, None, None),
                tuple=("value1", 10, 30, 50, None, None),
            ),
            local.Perfdata(
                name="value2",
                value=20,
                levels=(20, 50, 10, 0),
                tuple=("value2", 20, 20, 50, 0, 100),
            )
        ],
    )

    assert list(local.check_local("", {}, {"": local_result})) == [
        Result(state=state.OK, summary="Result is computed from two values"),
        Result(state=state.OK, summary="value1: 10.00"),
        Metric("value1", 10, levels=(30, 50)),
        Result(state=state.WARN, summary="value2: 20.00 (warn/crit at 20.00/50.00)"),
        Metric("value2", 20, levels=(20, 50), boundaries=(0, 100)),
    ]
Пример #2
0
def test_fix_state():
    local_result = local.LocalResult(
        cached=None,
        item="NotGood",
        state=State.CRIT,
        apply_levels=False,
        text="A critical check",
        perfdata=[
            local.Perfdata(
                name="V",
                value=120,
                levels_upper=(50, 100),
                levels_lower=None,
                boundaries=(0, 1000),
            )
        ],
    )

    assert list(
        local.check_local(
            "NotGood", {},
            local.LocalSection(errors=[],
                               data={"NotGood": local_result}))) == [
                                   Result(state=State.CRIT,
                                          summary="A critical check"),
                                   Result(state=State.OK, summary='V: 120.00'),
                                   Metric("V", 120, boundaries=(0, 1000)),
                               ]
Пример #3
0
def test_compute_state():
    local_result = local.LocalResult(
        cache_info=None,
        item="Some_other_Service",
        state=State.OK,
        apply_levels=True,
        text="Result is computed from two values",
        perfdata=[
            local.Perfdata(
                name="value1",
                value=10,
                levels_upper=(30, 50),
                levels_lower=None,
                boundaries=(None, None),
            ),
            local.Perfdata(
                name="value2",
                value=20,
                levels_upper=(20, 50),
                levels_lower=(10, 0),
                boundaries=(0, 100),
            ),
        ],
    )

    assert list(
        local.check_local("", {}, local.LocalSection(errors=[], data={"": local_result}))
    ) == [
        Result(state=State.OK, summary="Result is computed from two values"),
        Result(state=State.OK, summary="Value 1: 10.00"),
        Metric("value1", 10, levels=(30.0, 50.0)),
        Result(state=State.WARN, summary="Value 2: 20.00 (warn/crit at 20.00/50.00)"),
        Metric("value2", 20, levels=(20, 50), boundaries=(0, 100)),
    ]
Пример #4
0
def test_fix_state():
    local_result = local.LocalResult(
        cached=None,
        item="NotGood",
        state=2,
        text="A critical check",
        perfdata=[
            local.Perfdata(
                name="V",
                value=120,
                levels=(50, 100, None, None),
                tuple=("V", 120, 50, 100, 0, 1000),
            )
        ],
    )

    assert list(local.check_local("NotGood", {},
                                  {"NotGood": local_result})) == [
                                      Result(state=state.CRIT,
                                             summary="A critical check"),
                                      Metric("V",
                                             120,
                                             levels=(50, 100),
                                             boundaries=(0, 1000)),
                                  ]
Пример #5
0
def test_cached():
    local_result = local.LocalResult(
        cached=(361, 314, 120),
        item="Cached",
        state=0,
        text="A cached data service",
        perfdata=[],
    )

    assert list(local.check_local("", {}, {"": local_result})) == [
        Result(state=state.OK, summary="A cached data service"),
        Result(
            state=state.OK,
            summary=("Cache generated 6 minutes 1 second ago, "
                     "Cache interval: 2 minutes 0 seconds, "
                     "Elapsed cache lifespan: 314%"),
        ),
    ]
Пример #6
0
def test_invalid_metric_name_does_not_crash() -> None:
    assert list(
        local.check_local(
            "MyService",
            {},
            local.parse_local([["0", "MyService", "invalid:name=1", "This", "is", "a", "summary"]]),
        )
    ) == [
        Result(state=State.OK, summary="This is a summary"),
        Result(
            state=State.WARN,
            summary="Invalid metric name: 'invalid:name'",
            details=(
                "The metric name 'invalid:name' is invalid. It will not be recorded. "
                "Problem: invalid character(s) in metric name: ':'"
            ),
        ),
        Result(state=State.OK, summary="Invalid:name: 1.00"),
    ]
Пример #7
0
def test_cached():
    local_result = local.LocalResult(
        cached=(361, 314, 120),
        item="Cached",
        state=State.OK,
        apply_levels=False,
        text="A cached data service",
        perfdata=[],
    )

    assert list(
        local.check_local(
            "", {},
            local.LocalSection(errors=[], data={"": local_result}))) == [
                Result(state=State.OK, summary="A cached data service"),
                Result(
                    state=State.OK,
                    summary=("Cache generated 6 minutes 1 second ago, "
                             "Cache interval: 2 minutes 0 seconds, "
                             "Elapsed cache lifespan: 314.00%"),
                ),
            ]
Пример #8
0
def test_cached(age, expected):
    local_result = local.LocalResult(
        cache_info=CacheInfo(
            age=age,
            cache_interval=120,
        ),
        item="Cached",
        state=State.OK,
        apply_levels=False,
        text="A cached data service",
        perfdata=[],
    )

    assert list(
        local.check_local("", {}, local.LocalSection(errors=[], data={"": local_result}))
    ) == [
        Result(state=State.OK, summary="A cached data service"),
        Result(
            state=State.OK,
            summary=f"{expected}",
        ),
    ]