public async Task ShouldUseUserDefinedCloudWhenEnvironmentIsSetToAUserDefinedCloud()
        {
            GraphSession.Initialize(() => new GraphSession());

            // Arrange
            GraphEnvironment userDefinedEnvironment = new GraphEnvironment
            {
                Name            = "Canary",
                AzureADEndpoint = "https://login.microsoftonline.com",
                GraphEndpoint   = "https://canary.graph.microsoft.com"
            };

            GraphSession.Instance.Environment = userDefinedEnvironment;
            Uri requestUrl         = new Uri($"https://graph.microsoft.com/v1.0/users?{topParam}&{selectParam}");
            var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, requestUrl);

            // Act
            var response = await this._invoker.SendAsync(httpRequestMessage, new CancellationToken());

            var sentRequestQuery = response.RequestMessage.RequestUri.Query;

            // Assert
            Assert.Equal(requestUrl.Scheme, response.RequestMessage.RequestUri.Scheme);
            Assert.Equal("canary.graph.microsoft.com", response.RequestMessage.RequestUri.Host);
            Assert.Contains(topParam, sentRequestQuery);
            Assert.Contains($"${selectParam}", sentRequestQuery);
            Assert.Equal(2, sentRequestQuery.Split('&').Length);

            GraphSession.Reset();
        }
        public void ShouldSerializeAndDeserializeSettings()
        {
            GraphSession.Initialize(() => new GraphSession());

            // Arrange
            GraphSession.Instance.DataStore = new MockDataStore();
            GraphSettings settings = new GraphSettings(ProtectedFileProvider.CreateFileProvider(Constants.SettingFilePath, FileProtection.SharedRead));

            GraphEnvironment userDefinedEnv = new GraphEnvironment
            {
                Name            = "TestCloud",
                Type            = GraphEnvironmentConstants.EnvironmentType.UserDefined,
                AzureADEndpoint = "https://tester.com",
                GraphEndpoint   = "https://tester.com"
            };

            settings.EnvironmentTable[userDefinedEnv.Name] = userDefinedEnv;

            // Act
            string serializedSettings = settings.ToString();

            settings.TryDeserializeObject(serializedSettings, out GraphSettings deserializedSettings, new GraphSettingsConverter());
            deserializedSettings.TryGetEnvironment(userDefinedEnv.Name, out IGraphEnvironment deserializedEnv);

            // Assert
            Assert.NotNull(deserializedSettings);
            Assert.NotNull(deserializedEnv);
            Assert.Equal(serializedSettings, deserializedSettings.ToString());
            Assert.Equal(userDefinedEnv.GraphEndpoint, deserializedEnv.GraphEndpoint);

            GraphSession.Reset();
        }
        public async Task ShouldUseGermanyCloudWhenEnvironmentIsSetToGermany()
        {
            GraphSession.Initialize(() => new GraphSession());

            // Arrange
            GraphEnvironment germanyEnvironment = GraphEnvironment.BuiltInEnvironments[GraphEnvironmentConstants.EnvironmentName.Germany];

            GraphSession.Instance.Environment = germanyEnvironment;
            Uri requestUrl         = new Uri($"https://graph.microsoft.com/beta/users?{topParam}&{selectParam}");
            var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, requestUrl);

            // Act
            var response = await this._invoker.SendAsync(httpRequestMessage, new CancellationToken());

            var sentRequestQuery = response.RequestMessage.RequestUri.Query;

            // Assert
            Assert.Equal(requestUrl.Scheme, response.RequestMessage.RequestUri.Scheme);
            Assert.Equal("graph.microsoft.de", response.RequestMessage.RequestUri.Host);
            Assert.Contains(topParam, sentRequestQuery);
            Assert.Contains(selectParam, sentRequestQuery);
            Assert.Equal(2, sentRequestQuery.Split('&').Length);

            GraphSession.Reset();
        }
        public void ShouldUseCertThumbPrintInsteadOfPassedInCertificateWhenBothAreSpecified()
        {
            // Arrange
            var         dummyCertName          = "CN=dummycert";
            var         inMemoryCertName       = "CN=inmemorycert";
            var         storedDummyCertificate = CreateAndStoreSelfSignedCert(dummyCertName);
            var         inMemoryCertificate    = CreateSelfSignedCert(inMemoryCertName);
            AuthContext appOnlyAuthContext     = new AuthContext
            {
                AuthType = AuthenticationType.AppOnly,
                ClientId = Guid.NewGuid().ToString(),
                CertificateThumbprint = storedDummyCertificate.Thumbprint,
                Certificate           = inMemoryCertificate,
                ContextScope          = ContextScope.Process
            };
            // Act
            IAuthenticationProvider authProvider = AuthenticationHelpers.GetAuthProvider(appOnlyAuthContext);

            // Assert
            Assert.IsType <ClientCredentialProvider>(authProvider);
            var clientCredentialProvider = (ClientCredentialProvider)authProvider;

            // Assert: That the certificate used is dummycert (Thumbprint), that is in the store
            Assert.NotEqual(inMemoryCertName, clientCredentialProvider.ClientApplication.AppConfig.ClientCredentialCertificate.SubjectName.Name);
            Assert.Equal(appOnlyAuthContext.CertificateThumbprint, clientCredentialProvider.ClientApplication.AppConfig.ClientCredentialCertificate.Thumbprint);

            //CleanUp
            DeleteSelfSignedCertByThumbprint(appOnlyAuthContext.CertificateThumbprint);
            GraphSession.Reset();
        }
        public async Task ShouldUseDelegateAuthProviderWhenUserAccessTokenIsProvidedAsync()
        {
            // Arrange
            string accessToken = "ACCESS_TOKEN_VIA_DELEGATE_PROVIDER";

            GraphSession.Instance.UserProvidedToken = new NetworkCredential(string.Empty, accessToken).SecurePassword;
            AuthContext userProvidedAuthContext = new AuthContext
            {
                AuthType     = AuthenticationType.UserProvidedAccessToken,
                ContextScope = ContextScope.Process
            };

            IAuthenticationProvider authProvider   = AuthenticationHelpers.GetAuthProvider(userProvidedAuthContext);
            HttpRequestMessage      requestMessage = new HttpRequestMessage();

            // Act
            await authProvider.AuthenticateRequestAsync(requestMessage);

            // Assert
            Assert.IsType <DelegateAuthenticationProvider>(authProvider);
            Assert.Equal("Bearer", requestMessage.Headers.Authorization.Scheme);
            Assert.Equal(accessToken, requestMessage.Headers.Authorization.Parameter);

            // reset static instance.
            GraphSession.Reset();
        }
        public void ShouldThrowExceptionWhenSessionIsNotInitialized()
        {
            InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => GraphSession.Instance);

            Assert.Equal(ErrorConstants.Codes.SessionNotInitialized, exception.Message);

            // reset static instance.
            GraphSession.Reset();
        }
        public void GraphSessionShouldBeInitilizedAfterInitializerIsCalled()
        {
            GraphSession.Initialize(() => new GraphSession());

            Assert.NotNull(GraphSession.Instance);
            Assert.Null(GraphSession.Instance.AuthContext);

            // reset static instance.
            GraphSession.Reset();
        }
Exemplo n.º 8
0
        public void ShouldThrowExceptionWhenOutputIsNotInitialized()
        {
            GraphSession.Initialize(() => new GraphSession());
            InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => GraphSession.Instance.OutputWriter.WriteObject("Output"));

            Assert.NotNull(GraphSession.Instance);
            Assert.Null(GraphSession.Instance.AuthContext);

            // reset static instance.
            GraphSession.Reset();
        }
        public void ShouldNotOverwriteExistingGraphSession()
        {
            GraphSession.Initialize(() => new GraphSession());
            Guid originalSessionId = GraphSession.Instance._graphSessionId;

            GraphSession.Initialize(() => new GraphSession());

            Assert.NotNull(GraphSession.Instance);
            Assert.Equal(originalSessionId, GraphSession.Instance._graphSessionId);

            // reset static instance.
            GraphSession.Reset();
        }
Exemplo n.º 10
0
        public void ShouldNotOverwriteExistingGraphSession()
        {
            GraphSession.Initialize(() => new GraphSession());
            Guid originalSessionId = GraphSession.Instance._graphSessionId;

            InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => GraphSession.Initialize(() => new GraphSession()));

            Assert.Equal("An instance of GraphSession already exists. Call Initialize(Func<GraphSession>, bool) to overwrite it.", exception.Message);
            Assert.NotNull(GraphSession.Instance);
            Assert.Equal(originalSessionId, GraphSession.Instance._graphSessionId);

            // reset static instance.
            GraphSession.Reset();
        }
Exemplo n.º 11
0
        public void GetGraphHttpClientWithDefaultParametersShouldReturnHttpClientWithDefaultTimeout()
        {
            GraphSession.Initialize(() => new GraphSession());
            GraphSession.Instance.AuthContext = new AuthContext
            {
                AuthType     = AuthenticationType.UserProvidedAccessToken,
                ContextScope = ContextScope.Process
            };

            HttpClient httpClient = HttpHelpers.GetGraphHttpClient();

            Assert.Equal(GraphSession.Instance.AuthContext.ClientTimeout, TimeSpan.FromSeconds(Constants.ClientTimeout));
            Assert.Equal(httpClient.Timeout, GraphSession.Instance.AuthContext.ClientTimeout);

            // reset static instance.
            GraphSession.Reset();
        }
Exemplo n.º 12
0
        public void GetGraphHttpClientWithClientTimeoutParameterShouldReturnHttpClientWithSpecifiedTimeout()
        {
            GraphSession.Initialize(() => new GraphSession());
            TimeSpan timeSpan    = TimeSpan.FromSeconds(10);
            var      authContext = new AuthContext
            {
                AuthType     = AuthenticationType.UserProvidedAccessToken,
                ContextScope = ContextScope.Process
            };
            IAuthenticationProvider authProvider = AuthenticationHelpers.GetAuthProvider(authContext);

            HttpClient httpClient = HttpHelpers.GetGraphHttpClient(authProvider, timeSpan);

            Assert.Equal(authContext.ClientTimeout, TimeSpan.FromSeconds(Constants.ClientTimeout));
            Assert.Equal(httpClient.Timeout, timeSpan);

            // reset static instance.
            GraphSession.Reset();
        }
Exemplo n.º 13
0
        public void ShouldInitializeOutputWriter()
        {
            GraphSessionInitializer.InitializeSession();
            GraphSessionInitializer.InitializeOutput(new PsGraphOutputWriter
            {
                WriteError       = (exception1, s, arg3, arg4) => _helper.WriteLine(exception1.Message),
                WriteObject      = _helper.WriteLine,
                WriteDebug       = _helper.WriteLine,
                WriteInformation = (o, s) => _helper.WriteLine(s),
                WriteVerbose     = _helper.WriteLine
            });
            GraphSession.Instance.OutputWriter.WriteObject("Output");

            Assert.NotNull(GraphSession.Instance.OutputWriter);
            Assert.NotNull(GraphSession.Instance.OutputWriter.WriteObject);

            // reset static instance.
            GraphSession.Reset();
        }
        public void ShouldUseInteractiveProviderWhenDelegated()
        {
            // Arrange
            AuthContext delegatedAuthContext = new AuthContext
            {
                AuthType     = AuthenticationType.Delegated,
                Scopes       = new[] { "User.Read" },
                ContextScope = ContextScope.Process
            };

            // Act
            IAuthenticationProvider authProvider = AuthenticationHelpers.GetAuthProvider(delegatedAuthContext);

            // Assert
            Assert.IsType <InteractiveAuthenticationProvider>(authProvider);

            // reset static instance.
            GraphSession.Reset();
        }
        public void ShouldUseDeviceCodeWhenFallback()
        {
            // Arrange
            AuthContext delegatedAuthContext = new AuthContext
            {
                AuthType         = AuthenticationType.Delegated,
                Scopes           = new[] { "User.Read" },
                ContextScope     = ContextScope.Process,
                AuthProviderType = AuthProviderType.DeviceCodeProviderFallBack
            };

            // Act
            IAuthenticationProvider authProvider = AuthenticationHelpers.GetAuthProvider(delegatedAuthContext);

            // Assert
            Assert.IsType <DeviceCodeProvider>(authProvider);

            // reset static instance.
            GraphSession.Reset();
        }
Exemplo n.º 16
0
        public void GetGraphHttpClientShouldReturnHttpClientWithCustomerProvidedTimeout()
        {
            GraphSession.Initialize(() => new GraphSession());
            TimeSpan timeSpan = TimeSpan.FromSeconds(10);

            GraphSession.Instance.AuthContext = new AuthContext
            {
                AuthType      = AuthenticationType.UserProvidedAccessToken,
                ContextScope  = ContextScope.Process,
                ClientTimeout = timeSpan
            };

            HttpClient httpClient = HttpHelpers.GetGraphHttpClient();

            Assert.Equal(GraphSession.Instance.AuthContext.ClientTimeout, timeSpan);
            Assert.Equal(httpClient.Timeout, timeSpan);

            // reset static instance.
            GraphSession.Reset();
        }
        public void ShouldLoadSettingsFromConfiguredDataStore()
        {
            GraphSession.Initialize(() => new GraphSession());

            // Arrange
            GraphSession.Instance.DataStore = new MockDataStore();
            string settingsContent = @"{
  ""EnvironmentTable"": {
    ""MyNewCloud"": {
      ""Name"": ""MyNewCloud"",
      ""AzureADEndpoint"": ""https://login.MyNewCloud.com"",
      ""GraphEndpoint"": ""https://graph.MyNewCloud.com"",
      ""Type"": ""User-defined""
    },
    ""TrialCloud"": {
      ""Name"": ""MyNewCloud"",
      ""AzureADEndpoint"": ""https://login.TrialCloud.com"",
      ""GraphEndpoint"": ""https://graph.TrialCloud.com"",
      ""Type"": ""User-defined""
    }
  }
}";

            GraphSession.Instance.DataStore.WriteFile(Constants.SettingFilePath, settingsContent);

            // Act
            // Loads settings from disk store.
            GraphSettings settings = new GraphSettings(ProtectedFileProvider.CreateFileProvider(Constants.SettingFilePath, FileProtection.SharedRead));

            settings.TryGetEnvironment("MyNewCloud", out IGraphEnvironment loadedEnvironment);

            // Assert
            Assert.NotNull(loadedEnvironment);
            // 5 built-in + 2 user-defined
            Assert.Equal(7, settings.Environments.Count());
            Assert.Equal("https://login.MyNewCloud.com", loadedEnvironment.AzureADEndpoint);
            Assert.Equal("https://graph.MyNewCloud.com", loadedEnvironment.GraphEndpoint);
            Assert.Equal(GraphEnvironmentConstants.EnvironmentType.UserDefined, loadedEnvironment.Type);

            GraphSession.Reset();
        }
        public void ShouldUseInMemoryCertificateWhenProvided()
        {
            // Arrange
            var         certificate        = CreateSelfSignedCert("cn=inmemorycert");
            AuthContext appOnlyAuthContext = new AuthContext
            {
                AuthType     = AuthenticationType.AppOnly,
                ClientId     = Guid.NewGuid().ToString(),
                Certificate  = certificate,
                ContextScope = ContextScope.Process
            };
            // Act
            IAuthenticationProvider authProvider = AuthenticationHelpers.GetAuthProvider(appOnlyAuthContext);

            // Assert
            Assert.IsType <ClientCredentialProvider>(authProvider);
            var clientCredentialProvider = (ClientCredentialProvider)authProvider;

            // Assert: That the certificate created and set above is the same as used here.
            Assert.Equal(clientCredentialProvider.ClientApplication.AppConfig.ClientCredentialCertificate, certificate);
            GraphSession.Reset();
        }
        public void ShouldUseClientCredentialProviderWhenAppOnlyContextIsProvided()
        {
            // Arrange
            AuthContext appOnlyAuthContext = new AuthContext
            {
                AuthType        = AuthenticationType.AppOnly,
                ClientId        = Guid.NewGuid().ToString(),
                CertificateName = "cn=dummyCert",
                ContextScope    = ContextScope.Process
            };

            CreateAndStoreSelfSignedCert(appOnlyAuthContext.CertificateName);

            // Act
            IAuthenticationProvider authProvider = AuthenticationHelpers.GetAuthProvider(appOnlyAuthContext);

            // Assert
            Assert.IsType <ClientCredentialProvider>(authProvider);

            // reset
            DeleteSelfSignedCertByName(appOnlyAuthContext.CertificateName);
            GraphSession.Reset();
        }
        public void ShouldSaveSettingsToConfiguredDataStore()
        {
            GraphSession.Initialize(() => new GraphSession());

            // Arrange
            GraphSession.Instance.DataStore = new MockDataStore();
            GraphSettings settings = new GraphSettings(ProtectedFileProvider.CreateFileProvider(Constants.SettingFilePath, FileProtection.SharedRead));

            GraphEnvironment userDefinedEnv = new GraphEnvironment
            {
                Name            = "TestCloud",
                Type            = GraphEnvironmentConstants.EnvironmentType.UserDefined,
                AzureADEndpoint = "https://tester.com",
                GraphEndpoint   = "https://tester.com"
            };
            string expectedSettingsContent = @"{
  ""EnvironmentTable"": {
    ""TestCloud"": {
      ""Name"": ""TestCloud"",
      ""AzureADEndpoint"": ""https://tester.com"",
      ""GraphEndpoint"": ""https://tester.com"",
      ""Type"": ""User-defined""
    }
  }
}";

            // Act
            // Saves settings to disk store.
            settings.TrySetEnvironment(userDefinedEnv, out IGraphEnvironment savedEnvironment);
            string settingsContent = GraphSession.Instance.DataStore.ReadFileAsText(Constants.SettingFilePath).Substring(1).TrimEnd(new[] { '\0' });

            // Assert
            Assert.NotEmpty(settingsContent);
            Assert.Equal(expectedSettingsContent, settingsContent);

            GraphSession.Reset();
        }
        public void ShouldRemoveSettingsFromConfiguredDataStore()
        {
            GraphSession.Initialize(() => new GraphSession());

            // Arrange
            GraphSession.Instance.DataStore = new MockDataStore();
            GraphSettings    settings      = new GraphSettings(ProtectedFileProvider.CreateFileProvider(Constants.SettingFilePath, FileProtection.SharedRead));
            GraphEnvironment myNewCloudEnv = new GraphEnvironment
            {
                Name            = "MyNewCloud",
                Type            = GraphEnvironmentConstants.EnvironmentType.UserDefined,
                AzureADEndpoint = "https://login.MyNewCloud.com",
                GraphEndpoint   = "https://graph.MyNewCloud.com"
            };
            GraphEnvironment trialCloudEnv = new GraphEnvironment
            {
                Name            = "TrialCloud",
                Type            = GraphEnvironmentConstants.EnvironmentType.UserDefined,
                AzureADEndpoint = "https://login.TrialCloud.com",
                GraphEndpoint   = "https://graph.TrialCloud.com"
            };

            settings.TrySetEnvironment(myNewCloudEnv, out IGraphEnvironment mergedMyNewCloudEnv);
            settings.TrySetEnvironment(trialCloudEnv, out IGraphEnvironment mergedTrialCloudEnv);

            // Act
            settings.RemoveEnvironment(trialCloudEnv.Name);
            string settingsContent = GraphSession.Instance.DataStore.ReadFileAsText(Constants.SettingFilePath);

            // Assert
            Assert.NotEmpty(settingsContent);
            // 5 built-in + 1 user-defined
            Assert.Equal(6, settings.Environments.Count());

            GraphSession.Reset();
        }
        public async Task ShouldUseGlobalCloudWhenEnvironmentIsNotSet()
        {
            GraphSession.Initialize(() => new GraphSession());

            // Arrange
            GraphSession.Instance.Environment = null;
            string initialRequestUrl  = $"https://graph.microsoft.com/v1.0/users?{topParam}&{selectParam}";
            Uri    requestUrl         = new Uri(initialRequestUrl);
            var    httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, requestUrl);

            // Act
            var response = await this._invoker.SendAsync(httpRequestMessage, new CancellationToken());

            var sentRequestQuery = response.RequestMessage.RequestUri.Query;

            // Assert
            Assert.Equal(requestUrl.Scheme, response.RequestMessage.RequestUri.Scheme);
            Assert.Equal(requestUrl.Host, response.RequestMessage.RequestUri.Host);
            Assert.Contains(topParam, sentRequestQuery);
            Assert.Contains($"${selectParam}", sentRequestQuery);
            Assert.Equal(2, sentRequestQuery.Split('&').Length);

            GraphSession.Reset();
        }
 /// <summary>
 /// Resets <see cref="GraphSession"/> instance when a user removes the module from the session via Remove-Module.
 /// </summary>
 /// <param name="psModuleInfo">A <see cref="PSModuleInfo"/> object.</param>
 public void OnRemove(PSModuleInfo psModuleInfo)
 {
     GraphSession.Reset();
     DependencyAssemblyResolver.Reset();
 }
 /// <summary>
 /// Resets <see cref="GraphSession"/> instance when a user removes the module from the session via Remove-Module.
 /// </summary>
 /// <param name="psModuleInfo">A <see cref="PSModuleInfo"/> object.</param>
 public void OnRemove(PSModuleInfo psModuleInfo)
 {
     GraphSession.Reset();
 }
Exemplo n.º 25
0
 private void CleanTokenCache(IAuthContext authContext)
 {
     TokenCacheStorage.DeleteToken(authContext);
     GraphSession.Reset();
 }