public void TestRuntimeCapabilities()
{
var services = Startup.CreateServiceProvider("Workspace.QPRGen1");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
// Choose an operation with measurement result comparison, which should
// fail to compile on QPRGen0 targets but succeed on QPRGen1 targets
var submissionContext = new AzureSubmissionContext()
{
OperationName = "Tests.qss.CompareMeasurementResult"
};
ExpectSuccess <IEnumerable <TargetStatusInfo> >(ConnectToWorkspaceAsync(azureClient));
// Set up workspace with mock providers
var azureWorkspace = azureClient.ActiveWorkspace as MockAzureWorkspace;
Assert.IsNotNull(azureWorkspace);
azureWorkspace?.AddProviders("ionq", "honeywell");
// Verify that IonQ job fails to compile (QPRGen0)
ExpectSuccess <TargetStatusInfo>(azureClient.SetActiveTargetAsync(new MockChannel(), "ionq.mock"));
ExpectError(AzureClientError.InvalidEntryPoint, azureClient.SubmitJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
// Verify that Honeywell job can be successfully submitted (QPRGen1)
ExpectSuccess <TargetStatusInfo>(azureClient.SetActiveTargetAsync(new MockChannel(), "honeywell.mock"));
var job = ExpectSuccess <CloudJob>(azureClient.SubmitJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
Assert.IsNotNull(job);
}
public void TestJobExecutionWithArrayInput()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
// connect
var targets = ExpectSuccess <IEnumerable <TargetStatusInfo> >(ConnectToWorkspaceAsync(azureClient));
Assert.IsFalse(targets.Any());
// add a target
var azureWorkspace = azureClient.ActiveWorkspace as MockAzureWorkspace;
Assert.IsNotNull(azureWorkspace);
azureWorkspace?.AddProviders("ionq");
// set the active target
var target = ExpectSuccess <TargetStatusInfo>(azureClient.SetActiveTargetAsync(new MockChannel(), "ionq.simulator"));
Assert.AreEqual("ionq.simulator", target.TargetId);
// execute the job and verify that the results are retrieved successfully
var submissionContext = new AzureSubmissionContext()
{
OperationName = "Tests.qss.SayHelloWithArray",
InputParameters = AbstractMagic.ParseInputParameters("{\"names\": [\"foo\", \"bar\"]}"),
ExecutionTimeout = 5,
ExecutionPollingInterval = 1,
};
var histogram = ExpectSuccess <Histogram>(azureClient.ExecuteJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
Assert.IsNotNull(histogram);
}
public (Telemetry, IServiceProvider) StartTelemetry(string workspace = "Workspace")
{
var services = Startup.CreateServiceProvider(workspace);
var telemetry = new Telemetry(new MockTelemetryLogger());
telemetry.InitServices(services, null);
return(telemetry, services);
}
public void TestJobStatus()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
// not connected
ExpectError(AzureClientError.NotConnected, azureClient.GetJobStatusAsync(new MockChannel(), "JOB_ID_1"));
// connect
var targets = ExpectSuccess <IEnumerable <TargetStatusInfo> >(ConnectToWorkspaceAsync(azureClient));
Assert.IsFalse(targets.Any());
// set up the mock workspace
var azureWorkspace = azureClient.ActiveWorkspace as MockAzureWorkspace;
Assert.IsNotNull(azureWorkspace);
MockAzureWorkspace.MockJobIds = new string[] { "JOB_ID_1", "JOB_ID_2" };
// valid job ID
var job = ExpectSuccess <CloudJob>(azureClient.GetJobStatusAsync(new MockChannel(), "JOB_ID_1"));
Assert.AreEqual("JOB_ID_1", job.Id);
// invalid job ID
ExpectError(AzureClientError.JobNotFound, azureClient.GetJobStatusAsync(new MockChannel(), "JOB_ID_3"));
// jobs list with no filter
var jobs = ExpectSuccess <IEnumerable <CloudJob> >(azureClient.GetJobListAsync(new MockChannel(), string.Empty));
Assert.AreEqual(2, jobs.Count());
// jobs list with filter
jobs = ExpectSuccess <IEnumerable <CloudJob> >(azureClient.GetJobListAsync(new MockChannel(), "JOB_ID_1"));
Assert.AreEqual(1, jobs.Count());
// jobs list with count
jobs = ExpectSuccess <IEnumerable <CloudJob> >(azureClient.GetJobListAsync(new MockChannel(), string.Empty, 1));
Assert.AreEqual(1, jobs.Count());
// jobs list with invalid filter
jobs = ExpectSuccess <IEnumerable <CloudJob> >(azureClient.GetJobListAsync(new MockChannel(), "INVALID_FILTER"));
Assert.AreEqual(0, jobs.Count());
// jobs list with partial filter
jobs = ExpectSuccess <IEnumerable <CloudJob> >(azureClient.GetJobListAsync(new MockChannel(), "JOB_ID"));
Assert.AreEqual(2, jobs.Count());
// jobs list with filter and count
jobs = ExpectSuccess <IEnumerable <CloudJob> >(azureClient.GetJobListAsync(new MockChannel(), "JOB_ID", 1));
Assert.AreEqual(1, jobs.Count());
}
private IEntryPointGenerator Init(string workspace, IEnumerable <string>?codeSnippets = null)
{
var services = Startup.CreateServiceProvider(workspace);
if (codeSnippets != null)
{
var snippets = services.GetService <ISnippets>();
snippets.Items = codeSnippets.Select(codeSnippet => new Snippet()
{
code = codeSnippet
});
}
return(services.GetService <IEntryPointGenerator>());
}
public void TestAllTargets()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
// connect to mock workspace with all providers
var targets = ExpectSuccess <IEnumerable <TargetStatus> >(ConnectToWorkspaceAsync(azureClient, MockAzureWorkspace.NameWithMockProviders));
Assert.AreEqual(Enum.GetNames(typeof(AzureProvider)).Length, targets.Count());
// set each target, which will load the corresponding package
foreach (var target in targets)
{
var returnedTarget = ExpectSuccess <TargetStatus>(azureClient.SetActiveTargetAsync(new MockChannel(), target.Id));
Assert.AreEqual(target.Id, returnedTarget.Id);
}
}
public void TestLocations()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
// Locations with whitespace should be converted correctly
_ = ExpectSuccess <IEnumerable <TargetStatusInfo> >(ConnectToWorkspaceAsync(azureClient, locationName: "Australia Central 2"));
Assert.AreEqual("australiacentral2", azureClient.ActiveWorkspace?.Location);
// No location provided should fail
ExpectError(AzureClientError.NoWorkspaceLocation, ConnectToWorkspaceAsync(azureClient, locationName: ""));
ExpectError(AzureClientError.NoWorkspaceLocation, ConnectToWorkspaceAsync(azureClient, locationName: " "));
// Invalid locations should fail
ExpectError(AzureClientError.InvalidWorkspaceLocation, ConnectToWorkspaceAsync(azureClient, locationName: "#"));
ExpectError(AzureClientError.InvalidWorkspaceLocation, ConnectToWorkspaceAsync(azureClient, locationName: "/test/"));
}
public void TestLocations()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
// Default location should be westus
_ = ExpectSuccess <IEnumerable <TargetStatus> >(ConnectToWorkspaceAsync(azureClient));
Assert.AreEqual("westus", azureClient.ActiveWorkspace?.Location);
// Locations with whitespace should be converted correctly
_ = ExpectSuccess <IEnumerable <TargetStatus> >(ConnectToWorkspaceAsync(azureClient, locationName: "Australia Central 2"));
Assert.AreEqual("australiacentral2", azureClient.ActiveWorkspace?.Location);
// Locations with invalid hostname characters should fall back to default westus
_ = ExpectSuccess <IEnumerable <TargetStatus> >(ConnectToWorkspaceAsync(azureClient, locationName: "/test/"));
Assert.AreEqual("westus", azureClient.ActiveWorkspace?.Location);
}
public void TestJobSubmission()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
var submissionContext = new AzureSubmissionContext();
// not yet connected
ExpectError(AzureClientError.NotConnected, azureClient.SubmitJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
// connect
var targets = ExpectSuccess <IEnumerable <TargetStatus> >(ConnectToWorkspaceAsync(azureClient));
Assert.IsFalse(targets.Any());
// no target yet
ExpectError(AzureClientError.NoTarget, azureClient.SubmitJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
// add a target
var azureWorkspace = azureClient.ActiveWorkspace as MockAzureWorkspace;
Assert.IsNotNull(azureWorkspace);
azureWorkspace?.AddMockTargets("ionq.simulator");
// set the active target
var target = ExpectSuccess <TargetStatus>(azureClient.SetActiveTargetAsync(new MockChannel(), "ionq.simulator"));
Assert.AreEqual("ionq.simulator", target.Id);
// no operation name specified
ExpectError(AzureClientError.NoOperationName, azureClient.SubmitJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
// specify an operation name, but have missing parameters
submissionContext.OperationName = "Tests.qss.HelloAgain";
ExpectError(AzureClientError.JobSubmissionFailed, azureClient.SubmitJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
// specify input parameters and verify that the job was submitted
submissionContext.InputParameters = new Dictionary <string, string>()
{
["count"] = "3", ["name"] = "testing"
};
var job = ExpectSuccess <CloudJob>(azureClient.SubmitJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
var retrievedJob = ExpectSuccess <CloudJob>(azureClient.GetJobStatusAsync(new MockChannel(), job.Id));
Assert.AreEqual(job.Id, retrievedJob.Id);
}
public void TestConnectedEvent()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
ConnectToWorkspaceEventArgs?lastArgs = null;
// connect
azureClient.ConnectToWorkspace += (object?sender, ConnectToWorkspaceEventArgs e) =>
{
lastArgs = e;
};
ExpectError(AzureClientError.WorkspaceNotFound, azureClient.ConnectAsync(
new MockChannel(),
"TEST_SUBSCRIPTION_ID",
"TEST_RESOURCE_GROUP_NAME",
MockAzureWorkspace.NameForInvalidWorkspace,
string.Empty,
"TEST_LOCATION",
CredentialType.Default));
Assert.IsNotNull(lastArgs);
if (lastArgs != null)
{
Assert.AreEqual(ExecuteStatus.Error, lastArgs.Status);
Assert.AreEqual(AzureClientError.WorkspaceNotFound, lastArgs.Error);
Assert.AreEqual(CredentialType.Default, lastArgs.CredentialType);
Assert.AreEqual("TEST_LOCATION", lastArgs.Location);
Assert.AreEqual(false, lastArgs.UseCustomStorage);
}
lastArgs = null;
_ = ExpectSuccess <IEnumerable <TargetStatusInfo> >(ConnectToWorkspaceAsync(azureClient, locationName: "TEST_LOCATION"));
Assert.IsNotNull(lastArgs);
if (lastArgs != null)
{
Assert.AreEqual(ExecuteStatus.Ok, lastArgs.Status);
Assert.AreEqual(null, lastArgs.Error);
Assert.AreEqual(CredentialType.Environment, lastArgs.CredentialType);
Assert.AreEqual("TEST_LOCATION", lastArgs.Location);
Assert.AreEqual(true, lastArgs.UseCustomStorage);
}
}
public void TestManualTargets()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
// SetActiveTargetAsync with recognized target ID, but not yet connected
ExpectError(AzureClientError.NotConnected, azureClient.SetActiveTargetAsync(new MockChannel(), "ionq.simulator"));
// GetActiveTargetAsync, but not yet connected
ExpectError(AzureClientError.NotConnected, azureClient.GetActiveTargetAsync(new MockChannel()));
// connect
var targets = ExpectSuccess <IEnumerable <TargetStatus> >(ConnectToWorkspaceAsync(azureClient));
Assert.IsFalse(targets.Any());
// set up the mock workspace
var azureWorkspace = azureClient.ActiveWorkspace as MockAzureWorkspace;
Assert.IsNotNull(azureWorkspace);
azureWorkspace?.AddMockTargets("ionq.simulator", "honeywell.qpu", "unrecognized.target");
// get connection status to verify list of targets
targets = ExpectSuccess <IEnumerable <TargetStatus> >(azureClient.GetConnectionStatusAsync(new MockChannel()));
Assert.AreEqual(2, targets.Count()); // only 2 valid quantum execution targets
// GetActiveTargetAsync, but no active target set yet
ExpectError(AzureClientError.NoTarget, azureClient.GetActiveTargetAsync(new MockChannel()));
// SetActiveTargetAsync with target ID not valid for quantum execution
ExpectError(AzureClientError.InvalidTarget, azureClient.SetActiveTargetAsync(new MockChannel(), "unrecognized.target"));
// SetActiveTargetAsync with valid target ID
var target = ExpectSuccess <TargetStatus>(azureClient.SetActiveTargetAsync(new MockChannel(), "ionq.simulator"));
Assert.AreEqual("ionq.simulator", target.Id);
// GetActiveTargetAsync
target = ExpectSuccess <TargetStatus>(azureClient.GetActiveTargetAsync(new MockChannel()));
Assert.AreEqual("ionq.simulator", target.Id);
}
public void TestJobExecution()
{
var services = Startup.CreateServiceProvider("Workspace");
var azureClient = (AzureClient)services.GetService <IAzureClient>();
// connect
var targets = ExpectSuccess <IEnumerable <TargetStatus> >(ConnectToWorkspaceAsync(azureClient));
Assert.IsFalse(targets.Any());
// add a target
var azureWorkspace = azureClient.ActiveWorkspace as MockAzureWorkspace;
Assert.IsNotNull(azureWorkspace);
azureWorkspace?.AddMockTargets("ionq.simulator");
// set the active target
var target = ExpectSuccess <TargetStatus>(azureClient.SetActiveTargetAsync(new MockChannel(), "ionq.simulator"));
Assert.AreEqual("ionq.simulator", target.Id);
// execute the job and verify that the results are retrieved successfully
var submissionContext = new AzureSubmissionContext()
{
OperationName = "Tests.qss.HelloAgain",
InputParameters = new Dictionary <string, string>()
{
["count"] = "3", ["name"] = "testing"
},
ExecutionTimeout = 5,
ExecutionPollingInterval = 1,
};
var histogram = ExpectSuccess <Histogram>(azureClient.ExecuteJobAsync(new MockChannel(), submissionContext, CancellationToken.None));
Assert.IsNotNull(histogram);
}
