def METHOD_NAME(
    testerchain,
    test_registry,
    ursulas,
    threshold_staking,
    application_economics,
    ursula_test_config,
    mocker,
):
    #
    # Setup
    #
    application_agent = ContractAgency.get_agent(
        PREApplicationAgent,
        registry=test_registry,
        provider_uri=TEST_ETH_PROVIDER_URI,
    )
    (
        creator,
        _staking_provider,
        operator_address,
        *everyone_else,
    ) = testerchain.client.accounts
    existing_ursula, other_ursula, *the_others = list(ursulas)
    # We start with an ursula with no tokens staked
    owner, _, _ = threshold_staking.functions.rolesOf(_staking_provider).call()
    assert owner == NULL_ADDRESS
    # make an staking_providers and some stakes
    min_authorization = application_economics.min_authorization
    tx = threshold_staking.functions.setRoles(_staking_provider).transact()
    testerchain.wait_for_receipt(tx)
    tx = threshold_staking.functions.setStakes(
        _staking_provider, min_authorization, 0, 0
    ).transact()
    testerchain.wait_for_receipt(tx)
    # now lets bond this worker
    tpower = TransactingPower(
        account=_staking_provider, signer=Web3Signer(testerchain.client)
    )
    application_agent.bond_operator(
        staking_provider=_staking_provider,
        operator=operator_address,
        transacting_power=tpower,
    )
    # Make the Operator
    ursulas = make_ursulas(ursula_test_config, [_staking_provider], [operator_address])
    ursula = ursulas[0]
    ursula.run(
        preflight=False,
        discovery=False,
        start_reactor=False,
        worker=True,
        eager=True,
        block_until_ready=True,
    )  # "start" services
    start_pytest_ursula_services(ursula=ursula)
    # The worker is valid and can be verified (even with the force option)
    ursula.verify_node(
        force=True,
        registry=test_registry,
        network_middleware_client=ursula.network_middleware.client,
        eth_provider_uri=ursula.eth_provider_uri,
    )
    # In particular, we know that it's bonded to a staker who is really staking.
    assert ursula.is_confirmed
    assert ursula._staking_provider_is_really_staking(
        registry=test_registry, eth_provider_uri=TEST_ETH_PROVIDER_URI
    )
    # OK. Now we learn about this new worker.
    assert existing_ursula.remember_node(ursula)
    # Mock that ursula stops staking
    def mock_is_authorized(staking_provider: ChecksumAddress):
        if staking_provider == ursula.checksum_address:
            return False
        return True
    mocker.patch.object(
        application_agent, "is_authorized", side_effect=mock_is_authorized
    )
    # OK...so...the staker is not staking anymore ...
    assert not ursula._staking_provider_is_really_staking(
        registry=test_registry, eth_provider_uri=TEST_ETH_PROVIDER_URI
    )
    # ... but the worker node still is "verified" (since we're not forcing on-chain verification)
    ursula.verify_node(
        registry=test_registry,
        network_middleware_client=ursula.network_middleware.client,
    )
    # If we force, on-chain verification, the worker is of course not verified
    with pytest.raises(ursula.NotStaking):
        ursula.verify_node(
            force=True,
            registry=test_registry,
            network_middleware_client=ursula.network_middleware.client,
            eth_provider_uri=TEST_ETH_PROVIDER_URI,
        )
    #
    # TODO node verification is cached for a certain amount of time before rechecking; so unclear
    #  how to adjust the following code.
    #
    # warnings = []
    # def warning_trapper(event):
    #     if event['log_level'] == LogLevel.warn:
    #         warnings.append(event)
    # Let's learn from this invalid node
    # existing_ursula._current_teacher_node = ursula
    # globalLogPublisher.addObserver(warning_trapper)
    # existing_ursula.learn_from_teacher_node(eager=True)
    # # lonely_blockchain_learner.remember_node(worker)  # The same problem occurs if we directly try to remember this node
    # globalLogPublisher.removeObserver(warning_trapper)
    # TODO: What should we really check here? (#1075)
    # assert len(warnings) == 1
    # warning = warnings[-1]['log_format']
    # assert str(ursula) in warning
    # assert "no active stakes" in warning  # TODO: Cleanup logging templates
    # assert ursula not in existing_ursula.known_nodes
    # TODO: Write a similar test but for detached worker (#1075)
    #   Unclear that this case is still valid - detached workers get automatically shut-down