def test_status__already_final_state(mock_backend, requests_mock): # pylint: disable=invalid-name
"""Test status() returns early when the job is already completed.
Args:
mock_backend (MockBackend): A fake/mock IonQBackend.
requests_mock (:class:`request_mock.Mocker`): A requests mocker.
"""
# Create a job:
job_id = "test_id"
job_result = conftest.dummy_job_response(job_id, status="completed")
client = mock_backend.client
# Mock the fetch from `result`, since status should still be "initializing".
fetch_path = client.make_path("jobs", job_id)
requests_mock.get(fetch_path, status_code=200, json=job_result)
# Create a job ref (this does not call status, since circuit is not None).
job = ionq_job.IonQJob(mock_backend, "test_id")
# Call status:
# fmt: off
#import pdb; pdb.set_trace()
with spy(client, "retrieve_job") as job_fetch_spy:
actual_status = job.status()
job_fetch_spy.assert_not_called()
assert actual_status is job._status is jobstatus.JobStatus.DONE
def formatted_result(provider):
"""Fixture for auto-injecting a formatted IonQJob result object into a
a sub-class of ``unittest.TestCase``.
Args:
provider (IonQProvider): Injected provider from :meth:`provider`.
Returns:
Result: A qiskit result from making a fake API call with StubbedClient.
"""
# Dummy job ID for formatted results fixture.
job_id = "test_id"
# Create a backend and client to use for accessing the job.
backend = provider.get_backend("ionq_qpu")
client = backend.create_client()
# Create the request path for accessing the dummy job:
path = client.make_path("jobs", job_id)
# mock a job response
with _default_requests_mock() as requests_mock:
# Mock the response with our dummy job response.
requests_mock.get(path, json=dummy_job_response(job_id))
# Create the job (this calls self.status(), which will fetch the job).
job = ionq_job.IonQJob(backend, job_id, client)
# Yield so that the mock context manager properly unwinds.
yield job.result()
def test_result__from_circuit(mock_backend, requests_mock):
"""Test result fetching when the job did not already exist at creation time.
Args:
mock_backend (MockBackend): A fake/mock IonQBackend.
requests_mock (:class:`request_mock.Mocker`): A requests mocker.
"""
# Create the job:
job_id = "test_id"
job_result = conftest.dummy_job_response(job_id)
client = mock_backend.client
# Create a job ref (this does not call status, since circuit is not None).
job = ionq_job.IonQJob(mock_backend, None, circuit=QuantumCircuit(1, 1))
# Mock the create:
create_path = client.make_path("jobs")
requests_mock.post(create_path, status_code=200, json=job_result)
# Submit the job.
job.submit()
# Mock the fetch from `result`, since status should still be "initializing".
fetch_path = client.make_path("jobs", job_id)
requests_mock.get(fetch_path, status_code=200, json=job_result)
# Validate the new job_id.
assert job.result().job_id == "test_id"
def test_result__timeout(mock_backend, requests_mock):
"""Test that timeouts are re-raised as IonQJobTimeoutErrors.
Args:
mock_backend (MockBackend): A fake/mock IonQBackend.
requests_mock (:class:`request_mock.Mocker`): A requests mocker.
"""
# Create the job:
job_id = "test_id"
client = mock_backend.client
job_result = conftest.dummy_job_response(job_id)
job_result.update({"status": "submitted"})
# Mock the job response API call.
path = client.make_path("jobs", job_id)
requests_mock.get(path, status_code=200, json=job_result)
# Create a job ref (this will call .status() to fetch our mock above)
job = ionq_job.IonQJob(mock_backend, job_id)
# Patch `wait_for_final_state` to force throwing a timeout.
exc_patch = mock.patch.object(job,
"wait_for_final_state",
side_effect=q_exc.JobTimeoutError())
# Use the patch, then expect `result` to raise out.
with exc_patch, pytest.raises(exceptions.IonQJobTimeoutError) as exc_info:
job.result()
assert exc_info.value.message == "Timed out waiting for job to complete."
def test_cancel(mock_backend, requests_mock):
"""Test cancelling the job will use a client to cancel the job via the API.
Args:
mock_backend (MockBackend): A fake/mock IonQBackend.
requests_mock (:class:`request_mock.Mocker`): A requests mocker.
"""
# Mock the initial status call.
job_id = "test_id"
client = mock_backend.client
fetch_path = client.make_path("jobs", job_id)
requests_mock.get(
fetch_path,
status_code=200,
json=conftest.dummy_job_response(job_id),
)
# Mock a request to cancel.
cancel_path = client.make_path("jobs", job_id, "status", "cancel")
requests_mock.put(cancel_path, status_code=200, json={})
# Create the job:
job = ionq_job.IonQJob(mock_backend, job_id)
# Tell the job to cancel.
with spy(mock_backend.client, "cancel_job") as cancel_spy:
job.cancel()
# Verify that the API was called to cancel the job.
cancel_spy.assert_called_with(job_id)
def test_submit(mock_backend, requests_mock):
"""Test that job submission calls the IonQ API via the job's client.
Args:
mock_backend (MockBackend): A fake/mock IonQBackend.
requests_mock (:class:`request_mock.Mocker`): A requests mocker.]
"""
client = mock_backend.client
# Mock the initial status call.
fetch_path = mock_backend.client.make_path("jobs")
requests_mock.post(
fetch_path,
status_code=200,
json=conftest.dummy_job_response("server_job_id"),
)
# Create a job ref (this does not call status, since circuit is not None).
job = ionq_job.IonQJob(mock_backend, None, circuit=QuantumCircuit(1, 1))
with spy(client, "submit_job") as submit_spy:
job.submit()
# Validate the job was submitted to the API client.
submit_spy.assert_called_with(job=job)
assert job._job_id == "server_job_id"
def test_submit__without_circuit(mock_backend, requests_mock):
"""Test the behavior of attempting to submit a job with no circuit.
Args:
mock_backend (MockBackend): A fake/mock IonQBackend.
requests_mock (:class:`request_mock.Mocker`): A requests mocker.
"""
job_id = "test_id"
# Mock the initial status call.
fetch_path = mock_backend.client.make_path("jobs", job_id)
requests_mock.get(
fetch_path,
status_code=200,
json=conftest.dummy_job_response(job_id),
)
# Create the job (this calls .status())
job = ionq_job.IonQJob(mock_backend, job_id)
with pytest.raises(exceptions.IonQJobError) as exc_info:
job.submit()
expected_err = ("Cannot submit a job without a circuit. "
"Please create a job with a circuit and try again.")
assert exc_info.value.message == expected_err
def test_status__no_job_id(mock_backend):
"""Test status() returns early when the job has not yet been created.
Args:
mock_backend (MockBackend): A fake/mock IonQBackend.
"""
# Create a job:
# Create a job ref (this does not call status, since circuit is not None).
job = ionq_job.IonQJob(mock_backend, None, circuit=QuantumCircuit(1, 1))
assert job._status == jobstatus.JobStatus.INITIALIZING
# Call status:
with spy(mock_backend.client, "retrieve_job") as job_fetch_spy:
actual_status = job.status()
job_fetch_spy.assert_not_called()
assert actual_status is job._status is jobstatus.JobStatus.INITIALIZING
def test_result(mock_backend, requests_mock):
"""Test basic "happy path" for result fetching.
Args:
mock_backend (MockBackend): A fake/mock IonQBackend.
requests_mock (:class:`request_mock.Mocker`): A requests mocker.
"""
# Create the job:
job_id = "test_id"
client = mock_backend.client
job_result = conftest.dummy_job_response(job_id)
# Mock the job response API call.
path = client.make_path("jobs", job_id)
requests_mock.get(path, status_code=200, json=job_result)
# Create a job ref (this will call .status() to fetch our mock above)
job = ionq_job.IonQJob(mock_backend, job_id)
assert job.result().job_id == "test_id"