test_celery_worker.py

"""
just checks that the worker methods call the right functions
and some data ends up in the right place ... otherwise not very detailed
"""
import re

import pytest

from inventory_provider.tasks import worker
from inventory_provider.tasks.common import _get_redis


def backend_db():
    return _get_redis({
        'redis': {
            'hostname': None,
            'port': None
        },
        'redis-databases': [0, 7]
    }).db


def test_netconf_refresh_config(mocked_worker_module, router):
    if router in ['qfx.par.fr.geant.net', 'qfx.fra.de.geant.net']:
        # expected to fail
        pytest.skip(f'test data has no community string for {router}')
    del backend_db()['netconf:' + router]
    worker.reload_router_config_chorded(router)
    assert backend_db()['netconf:' + router]


def test_snmp_refresh_interfaces(mocked_worker_module, router):

    def _wanted(s):
        return s.startswith(f'snmp-interfaces-single:{router}')

    def _ifc_keys():
        return filter(_wanted, backend_db().keys())

    del backend_db()[f'snmp-interfaces:{router}']
    for k in list(_ifc_keys()):
        del backend_db()[k]

    worker.snmp_refresh_interfaces_chorded(router, 'fake-community', [])
    assert backend_db()['snmp-interfaces:' + router]
    assert list(_ifc_keys())


def test_snmp_refresh_peerings(mocked_worker_module, router):

    def _wanted(s):
        return s.startswith('snmp-peerings:')

    def _ifc_keys():
        return filter(_wanted, backend_db().keys())

    for k in list(_ifc_keys()):
        del backend_db()[k]

    worker.snmp_refresh_peerings_chorded(router, 'fake-community', [])
    assert list(_ifc_keys())


def test_reload_router_config(mocked_worker_module, router, mocker):

    if router.startswith('qfx'):
        # test env hack (router doesn't have snmp acl for us)
        mocker.patch('inventory_provider.juniper.snmp_community_string') \
            .return_value = 'blah'

    saved_data = {}
    for key in ('netconf:' + router, 'snmp-interfaces:' + router):
        saved_data[key] = backend_db().pop(key)

    saved_peerings = {}
    for key in backend_db().keys():
        if re.match(r'^snmp-peerings:\d.*', key):
            saved_peerings[key] = backend_db()[key]
    for key in saved_peerings.keys():
        del backend_db()[key]

    assert 'netconf:' + router not in backend_db()
    assert 'snmp-interfaces:' + router not in backend_db()

    def _mocked_retrieve_and_persist_netconf_config(*args, **kwargs):
        key = 'netconf:' + args[0]
        backend_db()[key] = saved_data[key]
        return saved_data[key]
    mocker.patch(
        'inventory_provider.tasks.worker.retrieve_and_persist_netconf_config',
        _mocked_retrieve_and_persist_netconf_config)

    def _mocked_snmp_refresh_interfaces_chorded(*args, **kwargs):
        assert len(args) == 4
        key = 'snmp-interfaces:' + args[0]
        backend_db()[key] = saved_data[key]

    mocker.patch(
        'inventory_provider.tasks.worker.snmp_refresh_interfaces_chorded',
        _mocked_snmp_refresh_interfaces_chorded)

    def _mocked_snmp_refresh_peerings_chorded(*args, **kwargs):
        assert len(args) == 3
        backend_db().update(saved_peerings)
    mocker.patch(
        'inventory_provider.tasks.worker.snmp_refresh_peerings_chorded',
        _mocked_snmp_refresh_peerings_chorded)

    def _mocked_update_status(self, **kwargs):
        pass
    mocker.patch(
        'inventory_provider.tasks.worker.InventoryTask.update_state',
        _mocked_update_status)

    worker.reload_router_config_chorded(router)
    assert 'netconf:' + router in backend_db()
    assert 'snmp-interfaces:' + router in backend_db()