def test_output_service_loop():
    scheduler = Scheduler("scheduler")
    mock_output_service = MockQueuedService(quick_death=True)
    timer = Timer(scheduler, mock_output_pid=mock_output_service)

    # join and block, waiting for event loop to execute once
    # and then exits. Mock manually controls the event loop.
    gevent.joinall([mock_output_service.start(), timer.start()])
    assert mock_output_service.event_loop_ack is True
    assert mock_output_service.get_state() == BaseStates.Idle
def test_output_service_write():
    # create ServiceManager and add services
    service_manager = ServiceManager("service-manager")

    # add worker
    worker_name = "test-worker-1"
    test_worker_1 = TestWorker(worker_name)
    service_meta = ServiceMetaData(worker_name, recovery_enabled=False)
    service_manager.add_service(test_worker_1, service_meta)

    # add output service
    scheduler = Scheduler("scheduler")
    service_alias = "mock-output-service"
    mock_output_service = MockQueuedService(quick_death=True)
    service_meta = ServiceMetaData(service_alias)
    timer = Timer(scheduler, mock_output_pid=mock_output_service)
    service_manager.add_service(mock_output_service, service_meta)

    assert test_worker_1.get_state() == BaseStates.Idle
    assert mock_output_service.get_state() == BaseStates.Idle

    # join and block, waiting for event loop to execute once
    # and then exits. Mock manually controls the event loop.
    # Manually starting services rather than using service_manager
    gevent.joinall(
        [test_worker_1.start(),
         mock_output_service.start(),
         timer.start()])

    # Assert that state is started. State will not be stopped
    # or idle because the services were manually called. Except
    # for the Mock service which will be idle. See the code.
    assert test_worker_1.get_state() == BaseStates.Started
    assert mock_output_service.get_state() == BaseStates.Idle

    # the services ran and I expect the test worker to have queried
    # the directory proxy and found the output service, writing to it.
    result = mock_output_service.get()
    assert result is not None
    assert result == "test-worker-work-result"
    assert mock_output_service.size() == 0
예제 #3
0
def test_os():
    """
    At this point we've tested BaseService, so I expect
    the following to work.

    Note: It is now prudent to leave this test or slowly invalidate it
          and instead use the CannedOS. See
          `v2/services/freezer_services_test.py` as an example

    :return:
    """

    scheduler = Scheduler("scheduler")

    # create services
    test_worker_1 = TestWorker("test-worker-1", worker_interval)
    test_worker_2 = TestWorker("test-worker-2", worker_interval)
    mock_queue_service = MockQueuedService()

    # schedule services
    scheduler.add_service(test_worker_1)
    scheduler.add_service(test_worker_2)
    scheduler.add_service(mock_queue_service)
    assert scheduler.get_services_count() == 3

    # test for existence of a service manager
    assert scheduler.get_service_manager() is not None

    # test that a child worker has access to the service_manager proxy
    test_worker_1_service = scheduler.get_service_manager(
    ).get_directory_service_proxy().get_service("test-worker-1")
    assert test_worker_1_service is not None
    # assert that the service is exactly as what was started
    assert test_worker_1_service == test_worker_1

    # assert that the service has a reference to the directory proxy
    directory_proxy = test_worker_1.get_directory_service_proxy()
    assert directory_proxy is not None
    assert directory_proxy.get_service_count() == 3

    # assert all the same all around
    assert directory_proxy.get_service(
        "test-worker-1") == test_worker_1_service

    # direct check to make sure
    assert directory_proxy._service_manager_directory == scheduler.get_service_manager(
    ).service_directory

    # start test timer
    timer = Timer(scheduler, mock_output_pid=mock_queue_service)

    # take timing from start to finish
    t1 = time.time()
    gevent.joinall([scheduler.start(), timer.start()])  # blocks

    t2 = time.time()
    t3 = t2 - t1
    assert t3 > scheduler_interval

    # stop was called, check all states
    assert scheduler.get_service_manager().get_state() == BaseStates.Stopped
    assert scheduler.get_state() == BaseStates.Stopped
    for pid_key, pid in scheduler.get_services():
        assert pid.get_state() == BaseStates.Stopped