Пример #1
0
def test_list_time_slots(client_constructor):
    grpc_client = setup_mock_(client_constructor)
    results = [
        quantum.QuantumTimeSlot(
            processor_name='potofgold',
            start_time=Timestamp(seconds=1000020000),
            end_time=Timestamp(seconds=1000040000),
            time_slot_type=quantum.QuantumTimeSlot.TimeSlotType.MAINTENANCE,
            maintenance_config=quantum.QuantumTimeSlot.MaintenanceConfig(
                title='Testing', description='Testing some new configuration.'
            ),
        ),
        quantum.QuantumTimeSlot(
            processor_name='potofgold',
            start_time=Timestamp(seconds=1000010000),
            end_time=Timestamp(seconds=1000020000),
            time_slot_type=quantum.QuantumTimeSlot.TimeSlotType.RESERVATION,
            reservation_config=quantum.QuantumTimeSlot.ReservationConfig(
                project_id='super_secret_quantum'
            ),
        ),
    ]
    grpc_client.list_quantum_time_slots.return_value = Pager(results)

    client = EngineClient()
    assert client.list_time_slots('proj', 'processor0') == results
Пример #2
0
def test_update_reservation(client_constructor):
    grpc_client = setup_mock_(client_constructor)
    name = 'projects/proj/processors/processor0/reservations/papar-party-44'
    result = qtypes.QuantumReservation(
        name=name,
        start_time=Timestamp(seconds=1000001000),
        end_time=Timestamp(seconds=1000002000),
        whitelisted_users=['*****@*****.**'],
    )
    grpc_client.update_quantum_reservation.return_value = result

    client = EngineClient()
    assert (client.update_reservation(
        'proj',
        'processor0',
        'papar-party-44',
        start=datetime.datetime.fromtimestamp(1000001000),
        end=datetime.datetime.fromtimestamp(1000002000),
        whitelisted_users=['*****@*****.**'],
    ) == result)
    kwargs = grpc_client.update_quantum_reservation.call_args[1]
    assert kwargs == {
        'name':
        name,
        'quantum_reservation':
        result,
        'update_mask':
        FieldMask(paths=['start_time', 'end_time', 'whitelisted_users'])
    }
Пример #3
0
def test_set_job_labels(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    grpc_client.get_quantum_job.return_value = quantum.QuantumJob(
        labels={'color': 'red', 'weather': 'sun', 'run': '1'}, label_fingerprint='hash'
    )
    result = quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job0')
    grpc_client.update_quantum_job.return_value = result

    client = EngineClient()
    labels = {'hello': 'world', 'color': 'blue', 'run': '1'}
    assert client.set_job_labels('proj', 'prog', 'job0', labels) == result
    grpc_client.update_quantum_job.assert_called_with(
        quantum.UpdateQuantumJobRequest(
            name='projects/proj/programs/prog/jobs/job0',
            quantum_job=quantum.QuantumJob(
                name='projects/proj/programs/prog/jobs/job0',
                labels=labels,
                label_fingerprint='hash',
            ),
            update_mask=FieldMask(paths=['labels']),
        )
    )

    assert client.set_job_labels('proj', 'prog', 'job0', {}) == result
    grpc_client.update_quantum_job.assert_called_with(
        quantum.UpdateQuantumJobRequest(
            name='projects/proj/programs/prog/jobs/job0',
            quantum_job=quantum.QuantumJob(
                name='projects/proj/programs/prog/jobs/job0', label_fingerprint='hash'
            ),
            update_mask=FieldMask(paths=['labels']),
        )
    )
Пример #4
0
def test_get_reservation_exception(client_constructor):
    grpc_client = setup_mock_(client_constructor)
    grpc_client.get_quantum_reservation.side_effect = exceptions.BadRequest('boom')

    client = EngineClient()
    with pytest.raises(EngineException, match='boom'):
        client.get_reservation('proj', 'processor0', 'goog')
Пример #5
0
def test_set_job_labels(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    grpc_client.get_quantum_job.return_value = qtypes.QuantumJob(
        labels={
            'color': 'red',
            'weather': 'sun',
            'run': '1'
        },
        label_fingerprint='hash')
    result = qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job0')
    grpc_client.update_quantum_job.return_value = result

    client = EngineClient()
    labels = {'hello': 'world', 'color': 'blue', 'run': '1'}
    assert client.set_job_labels('proj', 'prog', 'job0', labels) == result
    assert grpc_client.update_quantum_job.call_args[0] == (
        'projects/proj/programs/prog/jobs/job0',
        qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job0',
                          labels=labels,
                          label_fingerprint='hash'),
        qtypes.field_mask_pb2.FieldMask(paths=['labels']))

    assert client.set_job_labels('proj', 'prog', 'job0', {}) == result
    assert grpc_client.update_quantum_job.call_args[0] == (
        'projects/proj/programs/prog/jobs/job0',
        qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job0',
                          label_fingerprint='hash'),
        qtypes.field_mask_pb2.FieldMask(paths=['labels']))
Пример #6
0
def test_update_reservation(client_constructor):
    grpc_client = setup_mock_(client_constructor)
    name = 'projects/proj/processors/processor0/reservations/papar-party-44'
    result = quantum.QuantumReservation(
        name=name,
        start_time=Timestamp(seconds=1000001000),
        end_time=Timestamp(seconds=1000002000),
        whitelisted_users=['*****@*****.**'],
    )
    grpc_client.update_quantum_reservation.return_value = result

    client = EngineClient()
    assert (
        client.update_reservation(
            'proj',
            'processor0',
            'papar-party-44',
            start=datetime.datetime.fromtimestamp(1000001000),
            end=datetime.datetime.fromtimestamp(1000002000),
            whitelisted_users=['*****@*****.**'],
        )
        == result
    )
    grpc_client.update_quantum_reservation.assert_called_with(
        quantum.UpdateQuantumReservationRequest(
            name=name,
            quantum_reservation=result,
            update_mask=FieldMask(paths=['start_time', 'end_time', 'whitelisted_users']),
        )
    )
Пример #7
0
def test_cancel_job(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    client = EngineClient()
    assert not client.cancel_job('proj', 'prog', 'job0')
    assert grpc_client.cancel_quantum_job.call_args[0] == (
        'projects/proj/programs/prog/jobs/job0',)
Пример #8
0
def test_set_job_description(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    result = quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job0')
    grpc_client.update_quantum_job.return_value = result

    client = EngineClient()
    assert client.set_job_description('proj', 'prog', 'job0', 'A job') == result
    grpc_client.update_quantum_job.assert_called_with(
        quantum.UpdateQuantumJobRequest(
            name='projects/proj/programs/prog/jobs/job0',
            quantum_job=quantum.QuantumJob(
                name='projects/proj/programs/prog/jobs/job0', description='A job'
            ),
            update_mask=FieldMask(paths=['description']),
        )
    )

    assert client.set_job_description('proj', 'prog', 'job0', '') == result
    grpc_client.update_quantum_job.assert_called_with(
        quantum.UpdateQuantumJobRequest(
            name='projects/proj/programs/prog/jobs/job0',
            quantum_job=quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job0'),
            update_mask=FieldMask(paths=['description']),
        )
    )
Пример #9
0
def test_cancel_job(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    client = EngineClient()
    assert not client.cancel_job('proj', 'prog', 'job0')
    grpc_client.cancel_quantum_job.assert_called_with(
        quantum.CancelQuantumJobRequest(name='projects/proj/programs/prog/jobs/job0')
    )
Пример #10
0
def test_api_doesnt_retry_not_found_errors(client_constructor):
    grpc_client = setup_mock_(client_constructor)
    grpc_client.get_quantum_program.side_effect = exceptions.NotFound('not found')

    client = EngineClient()
    with pytest.raises(EngineException, match='not found'):
        client.get_program('proj', 'prog', False)
    assert grpc_client.get_quantum_program.call_count == 1
Пример #11
0
def test_api_retry_5xx_errors(client_constructor):
    grpc_client = setup_mock_(client_constructor)
    grpc_client.get_quantum_program.side_effect = exceptions.ServiceUnavailable('internal error')

    client = EngineClient(max_retry_delay_seconds=0.3)
    with pytest.raises(TimeoutError, match='Reached max retry attempts.*internal error'):
        client.get_program('proj', 'prog', False)
    assert grpc_client.get_quantum_program.call_count == 3
Пример #12
0
def test_get_reservation_not_found(client_constructor):
    grpc_client = setup_mock_(client_constructor)
    name = 'projects/proj/processors/processor0/reservations/papar-party-44'
    grpc_client.get_quantum_reservation.side_effect = exceptions.NotFound('not found')

    client = EngineClient()
    assert client.get_reservation('proj', 'processor0', 'papar-party-44') is None
    grpc_client.get_quantum_reservation.assert_called_with(
        quantum.GetQuantumReservationRequest(name=name)
    )
Пример #13
0
def test_get_current_calibration_does_not_exist(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    grpc_client.get_quantum_calibration.side_effect = exceptions.NotFound(
        'not found')

    client = EngineClient()
    assert client.get_current_calibration('proj', 'processor0') is None
    assert grpc_client.get_quantum_calibration.call_args[0] == (
        'projects/proj/processors/processor0/calibrations/current',)
Пример #14
0
def test_get_processor(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    result = qtypes.QuantumProcessor(name='projects/proj/processors/processor0')
    grpc_client.get_quantum_processor.return_value = result

    client = EngineClient()
    assert client.get_processor('proj', 'processor0') == result
    assert grpc_client.get_quantum_processor.call_args[0] == (
        'projects/proj/processors/processor0',)
Пример #15
0
def test_list_program_filters(client_constructor, expected_filter,
                              created_before, created_after, labels):
    grpc_client = setup_mock_(client_constructor)
    client = EngineClient()
    client.list_programs(project_id='proj',
                         created_before=created_before,
                         created_after=created_after,
                         has_labels=labels)
    assert grpc_client.list_quantum_programs.call_args[1] == {
        'filter_': expected_filter,
    }
Пример #16
0
def test_get_current_calibration(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    result = qtypes.QuantumCalibration(
        name='projects/proj/processors/processor0/calibrations/123456')
    grpc_client.get_quantum_calibration.return_value = result

    client = EngineClient()
    assert client.get_current_calibration('proj', 'processor0') == result
    assert grpc_client.get_quantum_calibration.call_args[0] == (
        'projects/proj/processors/processor0/calibrations/current',)
Пример #17
0
def test_job_results(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    result = qtypes.QuantumResult(
        parent='projects/proj/programs/prog/jobs/job0')
    grpc_client.get_quantum_result.return_value = result

    client = EngineClient()
    assert client.get_job_results('proj', 'prog', 'job0') == result
    assert grpc_client.get_quantum_result.call_args[0] == (
        'projects/proj/programs/prog/jobs/job0',)
Пример #18
0
def test_api_retry_times(client_constructor, mock_sleep):
    grpc_client = setup_mock_(client_constructor)
    grpc_client.get_quantum_program.side_effect = exceptions.ServiceUnavailable('internal error')

    client = EngineClient(max_retry_delay_seconds=0.3)
    with pytest.raises(TimeoutError, match='Reached max retry attempts.*internal error'):
        client.get_program('proj', 'prog', False)
    assert grpc_client.get_quantum_program.call_count == 3

    assert len(mock_sleep.call_args_list) == 2
    assert all(x == y for (x, _), y in zip(mock_sleep.call_args_list, [(0.1,), (0.2,)]))
Пример #19
0
def test_delete_program(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    client = EngineClient()
    assert not client.delete_program('proj', 'prog')
    assert grpc_client.delete_quantum_program.call_args[0] == (
        'projects/proj/programs/prog', False)

    assert not client.delete_program('proj', 'prog', delete_jobs=True)
    assert grpc_client.delete_quantum_program.call_args[0] == (
        'projects/proj/programs/prog', True)
Пример #20
0
def test_get_processor(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    result = quantum.QuantumProcessor(name='projects/proj/processors/processor0')
    grpc_client.get_quantum_processor.return_value = result

    client = EngineClient()
    assert client.get_processor('proj', 'processor0') == result
    grpc_client.get_quantum_processor.assert_called_with(
        quantum.GetQuantumProcessorRequest(name='projects/proj/processors/processor0')
    )
Пример #21
0
def test_job_results(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    result = quantum.QuantumResult(parent='projects/proj/programs/prog/jobs/job0')
    grpc_client.get_quantum_result.return_value = result

    client = EngineClient()
    assert client.get_job_results('proj', 'prog', 'job0') == result
    grpc_client.get_quantum_result.assert_called_with(
        quantum.GetQuantumResultRequest(parent='projects/proj/programs/prog/jobs/job0')
    )
Пример #22
0
def test_get_program(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    result = qtypes.QuantumProgram(name='projects/proj/programs/prog')
    grpc_client.get_quantum_program.return_value = result

    client = EngineClient()
    assert client.get_program('proj', 'prog', False) == result
    assert grpc_client.get_quantum_program.call_args[0] == ('projects/proj/programs/prog', False)

    assert client.get_program('proj', 'prog', True) == result
    assert grpc_client.get_quantum_program.call_args[0] == ('projects/proj/programs/prog', True)
Пример #23
0
def test_get_current_calibration_does_not_exist(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    grpc_client.get_quantum_calibration.side_effect = exceptions.NotFound('not found')

    client = EngineClient()
    assert client.get_current_calibration('proj', 'processor0') is None
    grpc_client.get_quantum_calibration.assert_called_with(
        quantum.GetQuantumCalibrationRequest(
            name='projects/proj/processors/processor0/calibrations/current'
        )
    )
Пример #24
0
def test_get_reservation_not_found(client_constructor):
    grpc_client = setup_mock_(client_constructor)
    name = 'projects/proj/processors/processor0/reservations/papar-party-44'
    grpc_client.get_quantum_reservation.side_effect = exceptions.NotFound(
        'not found')

    client = EngineClient()
    assert (client.get_reservation('proj', 'processor0',
                                   'papar-party-44') == None)
    kwargs = grpc_client.get_quantum_reservation.call_args[1]
    assert kwargs == {
        'name': name,
    }
Пример #25
0
def test_delete_program(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    client = EngineClient()
    assert not client.delete_program('proj', 'prog')
    grpc_client.delete_quantum_program.assert_called_with(
        quantum.DeleteQuantumProgramRequest(name='projects/proj/programs/prog', delete_jobs=False)
    )

    assert not client.delete_program('proj', 'prog', delete_jobs=True)
    grpc_client.delete_quantum_program.assert_called_with(
        quantum.DeleteQuantumProgramRequest(name='projects/proj/programs/prog', delete_jobs=True)
    )
Пример #26
0
def test_list_program(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    results = [
        quantum.QuantumProgram(name='projects/proj/programs/prog1'),
        quantum.QuantumProgram(name='projects/proj/programs/prog2'),
    ]
    grpc_client.list_quantum_programs.return_value = results

    client = EngineClient()
    assert client.list_programs(project_id='proj') == results
    grpc_client.list_quantum_programs.assert_called_with(
        quantum.ListQuantumProgramsRequest(parent='projects/proj', filter='')
    )
Пример #27
0
def test_list_calibrations(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    results = [
        quantum.QuantumCalibration(name='projects/proj/processor/processor0/calibrations/123456'),
        quantum.QuantumCalibration(name='projects/proj/processor/processor1/calibrations/224466'),
    ]
    grpc_client.list_quantum_calibrations.return_value = Pager(results)

    client = EngineClient()
    assert client.list_calibrations('proj', 'processor0') == results
    grpc_client.list_quantum_calibrations.assert_called_with(
        quantum.ListQuantumCalibrationsRequest(parent='projects/proj/processors/processor0')
    )
Пример #28
0
def test_list_processors(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    results = [
        quantum.QuantumProcessor(name='projects/proj/processor/processor0'),
        quantum.QuantumProcessor(name='projects/proj/processor/processor1'),
    ]
    grpc_client.list_quantum_processors.return_value = Pager(results)

    client = EngineClient()
    assert client.list_processors('proj') == results
    grpc_client.list_quantum_processors.assert_called_with(
        quantum.ListQuantumProcessorsRequest(parent='projects/proj')
    )
Пример #29
0
def test_get_current_calibration(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    result = quantum.QuantumCalibration(
        name='projects/proj/processors/processor0/calibrations/123456'
    )
    grpc_client.get_quantum_calibration.return_value = result

    client = EngineClient()
    assert client.get_current_calibration('proj', 'processor0') == result
    grpc_client.get_quantum_calibration.assert_called_with(
        quantum.GetQuantumCalibrationRequest(
            name='projects/proj/processors/processor0/calibrations/current'
        )
    )
Пример #30
0
def test_list_program(client_constructor):
    grpc_client = setup_mock_(client_constructor)

    results = [
        qtypes.QuantumProgram(name='projects/proj/programs/prog1'),
        qtypes.QuantumProgram(name='projects/proj/programs/prog2'),
    ]
    grpc_client.list_quantum_programs.return_value = results

    client = EngineClient()
    assert client.list_programs(project_id='proj') == results
    assert grpc_client.list_quantum_programs.call_args[0] == ('projects/proj',)
    assert grpc_client.list_quantum_programs.call_args[1] == {
        'filter_': '',
    }