def test_load_from_env_multiple_device_and_token(monkeypatch): """Test creating multiple devices when the different tokens are defined using an environment variable.""" mock_provider = "MockProvider" mock_qiskit_device = MockQiskitDeviceInit() with monkeypatch.context() as m: m.setattr(ibmq.QiskitDevice, "__init__", mock_qiskit_device.mocked_init) creds = [] def enable_account(new_creds): creds.append(new_creds) def active_account(): if len(creds) != 0: return {"token": creds[-1]} m.setattr(ibmq.IBMQ, "enable_account", enable_account) m.setattr(ibmq.IBMQ, "disable_account", lambda: None) m.setattr(ibmq.IBMQ, "active_account", active_account) m.setenv("IBMQX_TOKEN", "TOKEN1") dev1 = IBMQDevice(wires=1, provider=mock_provider) # first login assert creds == ["TOKEN1"] dev1 = IBMQDevice(wires=1, provider=mock_provider) # same token, login is elided assert creds == ["TOKEN1"] m.setenv("IBMQX_TOKEN", "TOKEN2") dev2 = IBMQDevice(wires=1, provider=mock_provider) # second login assert creds == ["TOKEN1", "TOKEN2"]
def test_load_from_env_multiple_device(token, monkeypatch): """Test creating multiple IBMQ devices when the environment variable for the IBMQ token was set.""" monkeypatch.setenv("IBMQX_TOKEN", token) dev1 = IBMQDevice(wires=1) dev2 = IBMQDevice(wires=1) assert dev1.provider.credentials.is_ibmq() assert dev2.provider.credentials.is_ibmq()
def test_custom_provider_hub_group_project(monkeypatch): """Tests that the custom arguments passed during device instantiation are used when calling get_provider.""" mock_qiskit_device = MockQiskitDeviceInit() monkeypatch.setenv("IBMQX_TOKEN", '1') custom_hub = "SomeHub" custom_group = "SomeGroup" custom_project = "SomeProject" with monkeypatch.context() as m: m.setattr(ibmq.QiskitDevice, "__init__", mock_qiskit_device.mocked_init) m.setattr(ibmq.IBMQ, "get_provider", mock_get_provider) m.setattr(ibmq.IBMQ, "enable_account", lambda *args, **kwargs: None) # Here mocking to a value such that it is not None m.setattr(ibmq.IBMQ, "active_account", lambda *args, **kwargs: {"token": '1'}) dev = IBMQDevice( wires=2, backend="ibmq_qasm_simulator", hub=custom_hub, group=custom_group, project=custom_project, ) assert mock_qiskit_device.provider[0] == () assert mock_qiskit_device.provider[1] == { "hub": custom_hub, "group": custom_group, "project": custom_project, }
def test_batch_execute_parameter_shift(token, tol, shots, mocker): """Test that devices provide correct result computing the gradient of a circuit using the parameter-shift rule and the batch execution pipeline.""" IBMQ.enable_account(token) dev = IBMQDevice(wires=3, backend="ibmq_qasm_simulator", shots=shots) spy1 = mocker.spy(dev, "batch_execute") spy2 = mocker.spy(dev.backend, "run") @qml.qnode(dev, diff_method="parameter-shift") def circuit(x, y): qml.RX(x, wires=[0]) qml.RY(y, wires=[1]) qml.CNOT(wires=[0, 1]) return qml.expval(qml.PauliZ(0) @ qml.PauliX(1) @ qml.PauliZ(2)) x = qml.numpy.array(0.543, requires_grad=True) y = qml.numpy.array(0.123, requires_grad=True) res = qml.grad(circuit)(x, y) expected = np.array([[-np.sin(y) * np.sin(x), np.cos(y) * np.cos(x)]]) assert np.allclose(res, expected, **tol) # Check that QiskitDevice.batch_execute was called once assert spy1.call_count == 2 # Check that run was called twice: for the partial derivatives and for # running the circuit assert spy2.call_count == 2
def test_account_error(monkeypatch): # Token is passed such that the test is skipped if no token was provided with pytest.raises(IBMQAccountError, match="No active IBM Q account"): with monkeypatch.context() as m: m.delenv("IBMQX_TOKEN", raising=False) IBMQDevice(wires=1)
def test_simple_circuit_with_batch_params(token, tol, shots, mocker): """Test that executing a simple circuit with batched parameters is submitted to IBMQ once.""" IBMQ.enable_account(token) dev = IBMQDevice(wires=2, backend="ibmq_qasm_simulator", shots=shots) @qml.batch_params(all_operations=True) @qml.qnode(dev) def circuit(theta, phi): qml.RX(theta, wires=0) qml.RX(phi, wires=1) qml.CNOT(wires=[0, 1]) return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)) # Check that we run only once spy1 = mocker.spy(dev, "batch_execute") spy2 = mocker.spy(dev.backend, "run") # Batch the input parameters batch_dim = 3 theta = np.linspace(0, 0.543, batch_dim) phi = np.linspace(0, 0.123, batch_dim) res = circuit(theta, phi) assert np.allclose(res[:, 0], np.cos(theta), **tol) assert np.allclose(res[:, 1], np.cos(theta) * np.cos(phi), **tol) # Check that IBMQBackend.run was called once assert spy1.call_count == 1 assert spy2.call_count == 1
def test_simple_circuit(token, tol, shots): IBMQ.enable_account(token) dev = IBMQDevice(wires=2, backend="ibmq_qasm_simulator", shots=shots) @qml.qnode(dev) def circuit(theta, phi): qml.RX(theta, wires=0) qml.RX(phi, wires=0) qml.CNOT(wires=[0, 1]) return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)) theta = 0.432 phi = 0.123 res = circuit(theta, phi) expected = np.array([np.cos(theta), np.cos(theta) * np.cos(phi)]) assert np.allclose(res, expected, **tol)
def test_custom_provider(monkeypatch): """Tests that a custom provider can be passed when creating an IBMQ device.""" mock_provider = "MockProvider" mock_qiskit_device = MockQiskitDeviceInit() with monkeypatch.context() as m: m.setattr(ibmq.QiskitDevice, "__init__", mock_qiskit_device.mocked_init) m.setattr(ibmq.IBMQ, "enable_account", lambda *args, **kwargs: None) # Here mocking to a value such that it is not None m.setattr(ibmq.IBMQ, "active_account", lambda *args, **kwargs: True) dev = IBMQDevice(wires=2, backend='ibmq_qasm_simulator', provider=mock_provider) assert mock_qiskit_device.provider == mock_provider
def test_track(token): """Test that the tracker works.""" IBMQ.enable_account(token) dev = IBMQDevice(wires=1, backend="ibmq_qasm_simulator", shots=1) dev.tracker.active = True @qml.qnode(dev) def circuit(): qml.PauliX(wires=0) return qml.probs(wires=0) circuit() assert "job_time" in dev.tracker.history if "job_time" in dev.tracker.history: assert "creating" in dev.tracker.history["job_time"][0] assert "validating" in dev.tracker.history["job_time"][0] assert "queued" in dev.tracker.history["job_time"][0] assert "running" in dev.tracker.history["job_time"][0] assert len(dev.tracker.history["job_time"][0]) == 4
def test_default_provider(monkeypatch): """Tests that the default provider is used when no custom provider was specified.""" mock_qiskit_device = MockQiskitDeviceInit() with monkeypatch.context() as m: m.setattr(ibmq.QiskitDevice, "__init__", mock_qiskit_device.mocked_init) m.setattr(ibmq.IBMQ, "get_provider", mock_get_provider) m.setattr(ibmq.IBMQ, "enable_account", lambda *args, **kwargs: None) # Here mocking to a value such that it is not None m.setattr(ibmq.IBMQ, "active_account", lambda *args, **kwargs: True) dev = IBMQDevice(wires=2, backend='ibmq_qasm_simulator') assert mock_qiskit_device.provider[0] == () assert mock_qiskit_device.provider[1] == { 'hub': 'ibm-q', 'group': 'open', 'project': 'main' }
def test_probability(token, tol, shots): """Test that the probs function works.""" IBMQ.enable_account(token) dev = IBMQDevice(wires=2, backend="ibmq_qasm_simulator", shots=shots) dev_analytic = qml.device("default.qubit", wires=2, shots=None) x = [0.2, 0.5] def circuit(x): qml.RX(x[0], wires=0) qml.RY(x[1], wires=0) qml.CNOT(wires=[0, 1]) return qml.probs(wires=[0, 1]) prob = qml.QNode(circuit, dev) prob_analytic = qml.QNode(circuit, dev_analytic) # Calling the hardware only once hw_prob = prob(x) assert np.isclose(hw_prob.sum(), 1, **tol) assert np.allclose(prob_analytic(x), hw_prob, **tol) assert not np.array_equal(prob_analytic(x), hw_prob)
def test_default_provider(monkeypatch): """Tests that the default provider is used when no custom provider was specified.""" mock_qiskit_device = MockQiskitDeviceInit() monkeypatch.setenv("IBMQX_TOKEN", '1') with monkeypatch.context() as m: m.setattr(ibmq.QiskitDevice, "__init__", mock_qiskit_device.mocked_init) m.setattr(ibmq.IBMQ, "get_provider", mock_get_provider) m.setattr(ibmq.IBMQ, "enable_account", lambda *args, **kwargs: None) # Here mocking to a value such that it is not None m.setattr(ibmq.IBMQ, "active_account", lambda *args, **kwargs: {"token": '1'}) dev = IBMQDevice(wires=2, backend="ibmq_qasm_simulator") assert mock_qiskit_device.provider[0] == () assert mock_qiskit_device.provider[1] == { "hub": "ibm-q", "group": "open", "project": "main" }
def test_load_from_env(token, monkeypatch): """test loading an IBMQ device from an env variable""" monkeypatch.setenv("IBMQX_TOKEN", token) dev = IBMQDevice(wires=1) assert dev.provider.credentials.is_ibmq()
def test_load_from_disk(token): IBMQ.save_account(token) dev = IBMQDevice(wires=1) assert dev.provider.credentials.is_ibmq() IBMQ.delete_account()
def test_load_from_disk(token): """Test loading the account credentials and the device from disk.""" IBMQ.save_account(token) dev = IBMQDevice(wires=1) assert dev.provider.credentials.is_ibmq() IBMQ.delete_account()
def test_load_kwargs_takes_precedence(token, monkeypatch): """Test that with a potentially valid token stored as an environment variable, passing the token as a keyword argument takes precedence.""" monkeypatch.setenv("IBMQX_TOKEN", "SomePotentiallyValidToken") dev = IBMQDevice(wires=1, ibmqx_token=token) assert dev.provider.credentials.is_ibmq()
def test_account_already_loaded(token): """Test loading an IBMQ device using an already loaded account""" IBMQ.enable_account(token) dev = IBMQDevice(wires=1) assert dev.provider.credentials.is_ibmq()
def test_account_error(): # Token is passed such that the test is skipped if no token was provided with pytest.raises(IBMQAccountError, match="No active IBM Q account"): IBMQDevice(wires=1)