Mock AzureEnvironment and end-to-end C# and Python tests

build/test.ps1

@@ -41,7 +41,7 @@ function Test-Python {
     Write-Host "##[info]Testing Python inside $testFolder"    
     Push-Location (Join-Path $PSScriptRoot $testFolder)
         python --version
-        pytest --log-level=DEBUG
+        pytest -v --log-level=DEBUG
     Pop-Location
 
     if ($LastExitCode -ne 0) {

src/AzureClient/AzureClient.csproj

@@ -13,7 +13,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Azure.Quantum.Client" Version="0.11.2006.207" />
+    <PackageReference Include="Microsoft.Azure.Quantum.Client" Version="0.11.2006.403" />
     <PackageReference Include="Microsoft.Rest.ClientRuntime" Version="2.3.21" />
     <PackageReference Include="Microsoft.Rest.ClientRuntime.Azure" Version="3.3.19" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />

src/AzureClient/AzureClientError.cs

@@ -0,0 +1,93 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#nullable enable
+
+using System.ComponentModel;
+
+namespace Microsoft.Quantum.IQSharp.AzureClient
+{
+    /// <summary>
+    /// Describes possible error results from <see cref="IAzureClient"/> methods.
+    /// </summary>
+    public enum AzureClientError
+    {
+        /// <summary>
+        /// Method completed with an unknown error.
+        /// </summary>
+        [Description(Resources.AzureClientErrorUnknownError)]
+        UnknownError = 1000,
+
+        /// <summary>
+        /// No connection has been made to any Azure Quantum workspace.
+        /// </summary>
+        [Description(Resources.AzureClientErrorNotConnected)]
+        NotConnected,
+
+        /// <summary>
+        /// A target has not yet been configured for job submission.
+        /// </summary>
+        [Description(Resources.AzureClientErrorNoTarget)]
+        NoTarget,
+
+        /// <summary>
+        /// The specified target is not valid for job submission.
+        /// </summary>
+        [Description(Resources.AzureClientErrorInvalidTarget)]
+        InvalidTarget,
+
+        /// <summary>
+        /// A job meeting the specified criteria was not found.
+        /// </summary>
+        [Description(Resources.AzureClientErrorJobNotFound)]
+        JobNotFound,
+
+        /// <summary>
+        /// The result of a job was requested, but the job has not yet completed.
+        /// </summary>
+        [Description(Resources.AzureClientErrorJobNotCompleted)]
+        JobNotCompleted,
+
+        /// <summary>
+        /// The job output failed to be downloaded from the Azure storage location.
+        /// </summary>
+        [Description(Resources.AzureClientErrorJobOutputDownloadFailed)]
+        JobOutputDownloadFailed,
+
+        /// <summary>
+        /// No Q# operation name was provided where one was required.
+        /// </summary>
+        [Description(Resources.AzureClientErrorNoOperationName)]
+        NoOperationName,
+
+        /// <summary>
+        /// The specified Q# operation name is not recognized.
+        /// </summary>
+        [Description(Resources.AzureClientErrorUnrecognizedOperationName)]
+        UnrecognizedOperationName,
+
+        /// <summary>
+        /// The specified Q# operation cannot be used as an entry point.
+        /// </summary>
+        [Description(Resources.AzureClientErrorInvalidEntryPoint)]
+        InvalidEntryPoint,
+
+        /// <summary>
+        /// The Azure Quantum job submission failed.
+        /// </summary>
+        [Description(Resources.AzureClientErrorJobSubmissionFailed)]
+        JobSubmissionFailed,
+
+        /// <summary>
+        /// Authentication with the Azure service failed.
+        /// </summary>
+        [Description(Resources.AzureClientErrorAuthenticationFailed)]
+        AuthenticationFailed,
+
+        /// <summary>
+        /// A workspace meeting the specified criteria was not found.
+        /// </summary>
+        [Description(Resources.AzureClientErrorWorkspaceNotFound)]
+        WorkspaceNotFound,
+    }
+}

src/AzureClient/AzureEnvironment.cs

@@ -1,74 +1,170 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 #nullable enable
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Net;
-using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Azure.Quantum.Client;
+using Microsoft.Identity.Client;
+using Microsoft.Identity.Client.Extensions.Msal;
+using Microsoft.Jupyter.Core;
 
 namespace Microsoft.Quantum.IQSharp.AzureClient
 {
-    internal enum AzureEnvironmentType { Production, Canary, Dogfood };
+    internal enum AzureEnvironmentType { Production, Canary, Dogfood, Mock };
 
     internal class AzureEnvironment
     {
-        public string ClientId { get; private set; } = string.Empty;
-        public string Authority { get; private set; } = string.Empty;
-        public List<string> Scopes { get; private set; } = new List<string>();
-        public Uri? BaseUri { get; private set; }
+        public static string EnvironmentVariableName => "AZURE_QUANTUM_ENV";
+        public AzureEnvironmentType Type { get; private set; }
+
+        private string SubscriptionId { get; set; } = string.Empty;
+        private string ClientId { get; set; } = string.Empty;
+        private string Authority { get; set; } = string.Empty;
+        private List<string> Scopes { get; set; } = new List<string>();
+        private Uri? BaseUri { get; set; }
 
         private AzureEnvironment()
         {
         }
 
-        public static AzureEnvironment Create(string environment, string subscriptionId)
+        public static AzureEnvironment Create(string subscriptionId)
         {
-            if (Enum.TryParse(environment, true, out AzureEnvironmentType environmentType))
+            var azureEnvironmentName = System.Environment.GetEnvironmentVariable(EnvironmentVariableName);
+
+            if (Enum.TryParse(azureEnvironmentName, true, out AzureEnvironmentType environmentType))
             {
                 switch (environmentType)
                 {
                     case AzureEnvironmentType.Production:
-                        return Production();
+                        return Production(subscriptionId);
                     case AzureEnvironmentType.Canary:
-                        return Canary();
+                        return Canary(subscriptionId);
                     case AzureEnvironmentType.Dogfood:
                         return Dogfood(subscriptionId);
+                    case AzureEnvironmentType.Mock:
+                        return Mock();
                     default:
                         throw new InvalidOperationException("Unexpected EnvironmentType value.");
                 }
             }
 
-            return Production();
+            return Production(subscriptionId);
         }
 
-        private static AzureEnvironment Production() =>
+        public async Task<IAzureWorkspace?> GetAuthenticatedWorkspaceAsync(IChannel channel, string resourceGroupName, string workspaceName, bool refreshCredentials)
+        {
+            if (Type == AzureEnvironmentType.Mock)
+            {
+                channel.Stdout("AZURE_QUANTUM_ENV set to Mock. Using mock Azure workspace rather than connecting to the real service.");
+                return new MockAzureWorkspace(workspaceName);
+            }
+
+            // Find the token cache folder
+            var cacheDirectoryEnvVarName = "AZURE_QUANTUM_TOKEN_CACHE";
+            var cacheDirectory = System.Environment.GetEnvironmentVariable(cacheDirectoryEnvVarName);
+            if (string.IsNullOrEmpty(cacheDirectory))
+            {
+                cacheDirectory = Path.Join(System.Environment.GetFolderPath(System.Environment.SpecialFolder.UserProfile), ".azure-quantum");
+            }
+
+            // Register the token cache for serialization
+            var cacheFileName = "aad.bin";
+            var storageCreationProperties = new StorageCreationPropertiesBuilder(cacheFileName, cacheDirectory, ClientId).Build();
+            var cacheHelper = await MsalCacheHelper.CreateAsync(storageCreationProperties);
+            var msalApp = PublicClientApplicationBuilder.Create(ClientId).WithAuthority(Authority).Build();
+            cacheHelper.RegisterCache(msalApp.UserTokenCache);
+
+            // Perform the authentication
+            bool shouldShowLoginPrompt = refreshCredentials;
+            AuthenticationResult? authenticationResult = null;
+            if (!shouldShowLoginPrompt)
+            {
+                try
+                {
+                    var accounts = await msalApp.GetAccountsAsync();
+                    authenticationResult = await msalApp.AcquireTokenSilent(
+                        Scopes, accounts.FirstOrDefault()).WithAuthority(msalApp.Authority).ExecuteAsync();
+                }
+                catch (MsalUiRequiredException)
+                {
+                    shouldShowLoginPrompt = true;
+                }
+            }
+
+            if (shouldShowLoginPrompt)
+            {
+                authenticationResult = await msalApp.AcquireTokenWithDeviceCode(
+                    Scopes,
+                    deviceCodeResult =>
+                    {
+                        channel.Stdout(deviceCodeResult.Message);
+                        return Task.FromResult(0);
+                    }).WithAuthority(msalApp.Authority).ExecuteAsync();
+            }
+
+            if (authenticationResult == null)
+            {
+                return null;
+            }
+
+            // Construct and return the AzureWorkspace object
+            var credentials = new Rest.TokenCredentials(authenticationResult.AccessToken);
+            var azureQuantumClient = new QuantumClient(credentials)
+            {
+                SubscriptionId = SubscriptionId,
+                ResourceGroupName = resourceGroupName,
+                WorkspaceName = workspaceName,
+                BaseUri = BaseUri,
+            };
+            var azureQuantumWorkspace = new Azure.Quantum.Workspace(
+                azureQuantumClient.SubscriptionId,
+                azureQuantumClient.ResourceGroupName,
+                azureQuantumClient.WorkspaceName,
+                authenticationResult?.AccessToken,
+                BaseUri);
+
+            return new AzureWorkspace(azureQuantumClient, azureQuantumWorkspace);
+        }
+
+        private static AzureEnvironment Production(string subscriptionId) =>
             new AzureEnvironment()
             {
+                Type = AzureEnvironmentType.Production,
                 ClientId = "84ba0947-6c53-4dd2-9ca9-b3694761521b",      // QDK client ID
                 Authority = "https://login.microsoftonline.com/common",
                 Scopes = new List<string>() { "https://quantum.microsoft.com/Jobs.ReadWrite" },
                 BaseUri = new Uri("https://app-jobscheduler-prod.azurewebsites.net/"),
+                SubscriptionId = subscriptionId,
             };
 
         private static AzureEnvironment Dogfood(string subscriptionId) =>
             new AzureEnvironment()
             {
+                Type = AzureEnvironmentType.Dogfood,
                 ClientId = "46a998aa-43d0-4281-9cbb-5709a507ac36",      // QDK dogfood client ID
                 Authority = GetDogfoodAuthority(subscriptionId),
                 Scopes = new List<string>() { "api://dogfood.azure-quantum/Jobs.ReadWrite" },
                 BaseUri = new Uri("https://app-jobscheduler-test.azurewebsites.net/"),
+                SubscriptionId = subscriptionId,
             };
 
-        private static AzureEnvironment Canary()
+        private static AzureEnvironment Canary(string subscriptionId)
         {
-            var canary = Production();
+            var canary = Production(subscriptionId);
+            canary.Type = AzureEnvironmentType.Canary;
             canary.BaseUri = new Uri("https://app-jobs-canarysouthcentralus.azurewebsites.net/");
             return canary;
         }
 
+        private static AzureEnvironment Mock() =>
+            new AzureEnvironment() { Type = AzureEnvironmentType.Mock };
+
         private static string GetDogfoodAuthority(string subscriptionId)
         {
             try

src/AzureClient/AzureExecutionTarget.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 #nullable enable
@@ -11,28 +11,28 @@ internal enum AzureProvider { IonQ, Honeywell, QCI }
 
     internal class AzureExecutionTarget
     {
-        public string TargetName { get; private set; }
-        public string PackageName => $"Microsoft.Quantum.Providers.{GetProvider(TargetName)}";
+        public string TargetId { get; private set; } = string.Empty;
+        public string PackageName => $"Microsoft.Quantum.Providers.{GetProvider(TargetId)}";
 
-        public static bool IsValid(string targetName) => GetProvider(targetName) != null;
+        public static bool IsValid(string targetId) => GetProvider(targetId) != null;
 
-        public static AzureExecutionTarget? Create(string targetName) =>
-            IsValid(targetName)
-            ? new AzureExecutionTarget() { TargetName = targetName }
+        public static AzureExecutionTarget? Create(string targetId) =>
+            IsValid(targetId)
+            ? new AzureExecutionTarget() { TargetId = targetId }
             : null;
 
         /// <summary>
         ///     Gets the Azure Quantum provider corresponding to the given execution target.
         /// </summary>
-        /// <param name="targetName">The Azure Quantum execution target name.</param>
+        /// <param name="targetId">The Azure Quantum execution target ID.</param>
         /// <returns>The <see cref="AzureProvider"/> enum value representing the provider.</returns>
         /// <remarks>
-        ///     Valid target names are structured as "provider.target".
+        ///     Valid target IDs are structured as "provider.target".
         ///     For example, "ionq.simulator" or "honeywell.qpu".
         /// </remarks>
-        private static AzureProvider? GetProvider(string targetName)
+        private static AzureProvider? GetProvider(string targetId)
         {
-            var parts = targetName.Split('.', 2);
+            var parts = targetId.Split('.', 2);
             if (Enum.TryParse(parts[0], true, out AzureProvider provider))
             {
                 return provider;