def test_non_culled_host_is_not_removed(
    event_producer_mock, event_datetime_mock, db_create_host, db_get_hosts, inventory_config
):
    staleness_timestamps = get_staleness_timestamps()
    created_hosts = []

    for stale_timestamp in (
        staleness_timestamps["stale_warning"],
        staleness_timestamps["stale"],
        staleness_timestamps["fresh"],
    ):
        host = minimal_db_host(stale_timestamp=stale_timestamp.isoformat(), reporter="some reporter")
        created_host = db_create_host(host)
        created_hosts.append(created_host)

    created_host_ids = [host.id for host in created_hosts]
    retrieved_hosts = db_get_hosts(created_host_ids)

    assert created_host_ids == [host.id for host in retrieved_hosts]

    threadctx.request_id = UNKNOWN_REQUEST_ID_VALUE
    host_reaper_run(
        inventory_config,
        mock.Mock(),
        db.session,
        event_producer_mock,
        shutdown_handler=mock.Mock(**{"shut_down.return_value": False}),
    )

    retrieved_hosts = db_get_hosts(created_host_ids)

    assert created_host_ids == [host.id for host in retrieved_hosts]
    assert event_producer_mock.event is None
def test_reaper_shutdown_handler(event_datetime_mock, db_create_host, db_get_hosts, inventory_config):
    staleness_timestamps = get_staleness_timestamps()
    created_host_ids = []

    host_count = 3
    for _ in range(host_count):
        host_data = minimal_db_host(
            stale_timestamp=staleness_timestamps["culled"].isoformat(), reporter="some reporter"
        )
        created_host = db_create_host(host_data)
        created_host_ids.append(created_host.id)

    created_hosts = db_get_hosts(created_host_ids)
    assert created_hosts.count() == host_count

    event_producer_mock = mock.Mock()

    threadctx.request_id = UNKNOWN_REQUEST_ID_VALUE
    host_reaper_run(
        inventory_config,
        mock.Mock(),
        db.session,
        event_producer_mock,
        shutdown_handler=mock.Mock(**{"shut_down.side_effect": (False, True)}),
    )

    remaining_hosts = db_get_hosts(created_host_ids)
    assert remaining_hosts.count() == 1
    assert event_producer_mock.write_event.call_count == 2
Пример #3
0
 def _run_host_reaper(self):
     with patch("app.queue.events.datetime",
                **{"now.return_value": self.now_timestamp}):
         with self.app.app_context():
             config = self.app.config["INVENTORY_CONFIG"]
             host_reaper_run(config, mock.Mock(), db.session,
                             self.event_producer)
def test_culled_host_is_removed(event_producer_mock, event_datetime_mock,
                                db_create_host, db_get_host, inventory_config):
    staleness_timestamps = get_staleness_timestamps()

    host = minimal_db_host(
        stale_timestamp=staleness_timestamps["culled"].isoformat(),
        reporter="some reporter")
    created_host = db_create_host(host)

    assert db_get_host(created_host.id)

    threadctx.request_id = UNKNOWN_REQUEST_ID_VALUE
    host_reaper_run(
        inventory_config,
        mock.Mock(),
        db.session,
        event_producer_mock,
        shutdown_handler=mock.Mock(**{"shut_down.return_value": False}),
    )

    assert not db_get_host(created_host.id)

    assert_delete_event_is_valid(event_producer=event_producer_mock,
                                 host=created_host,
                                 timestamp=event_datetime_mock)
Пример #5
0
def test_reaper_stops_after_kafka_producer_error(send_side_effects,
                                                 event_producer,
                                                 db_create_multiple_hosts,
                                                 db_get_hosts,
                                                 inventory_config, mocker):
    mocker.patch("lib.host_delete.kafka_available")

    event_producer._kafka_producer.send.side_effect = send_side_effects

    staleness_timestamps = get_staleness_timestamps()

    host_count = 3
    created_hosts = db_create_multiple_hosts(
        how_many=host_count,
        extra_data={"stale_timestamp": staleness_timestamps["culled"]})
    created_host_ids = [str(host.id) for host in created_hosts]

    hosts = db_get_hosts(created_host_ids)
    assert hosts.count() == host_count

    threadctx.request_id = UNKNOWN_REQUEST_ID_VALUE

    with pytest.raises(KafkaError):
        host_reaper_run(
            inventory_config,
            mock.Mock(),
            db.session,
            event_producer,
            shutdown_handler=mock.Mock(**{"shut_down.return_value": False}),
        )

    remaining_hosts = db_get_hosts(created_host_ids)
    assert remaining_hosts.count() == 2
    assert event_producer._kafka_producer.send.call_count == 2
Пример #6
0
def test_unknown_host_is_not_removed(event_producer_mock,
                                     db_create_host_in_unknown_state,
                                     db_get_host, inventory_config):
    created_host = db_create_host_in_unknown_state
    retrieved_host = db_get_host(created_host.id)

    assert retrieved_host
    assert retrieved_host.stale_timestamp is None
    assert retrieved_host.reporter is None

    threadctx.request_id = UNKNOWN_REQUEST_ID_VALUE
    host_reaper_run(
        inventory_config,
        mock.Mock(),
        db.session,
        event_producer_mock,
        shutdown_handler=mock.Mock(**{"shut_down.return_value": False}),
    )

    assert event_producer_mock.event is None
def test_culled_edge_host_is_not_removed(event_producer_mock, db_create_host,
                                         db_get_host, inventory_config):
    staleness_timestamps = get_staleness_timestamps()

    host = minimal_db_host(
        stale_timestamp=staleness_timestamps["culled"],
        reporter="some reporter",
        system_profile_facts={"host_type": "edge"},
    )
    created_host = db_create_host(host=host)

    assert db_get_host(created_host.id)

    threadctx.request_id = UNKNOWN_REQUEST_ID_VALUE
    host_reaper_run(
        inventory_config,
        mock.Mock(),
        db.session,
        event_producer_mock,
        shutdown_handler=mock.Mock(**{"shut_down.return_value": False}),
    )

    assert db_get_host(created_host.id)