Example #1
0
        public async Task FindAsync_shouldReturnOk_WhenExistingUser()
        {
            //Arrange
            var viewModel = new AuthViewModel()
            {
                Username  = "******",
                AccessKey = "userAccessKey"
            };

            User userReturn = new User()
            {
                UserID = viewModel.Username, AccessKey = viewModel.AccessKey
            };

            authenticationService.FindAsync(viewModel.Username).Returns(userReturn);
            var tokenResponse = new BearerTokenResponse()
            {
                Token = "tokenexemplo", Expiration = "01/02/2019 18:34:22"
            };

            tokenHelper.CreateTokenReponse().Returns(tokenResponse);

            var sut = new AuthController(tokenHelper, authenticationService);

            //Act
            var result = (ObjectResult)await sut.GetTokenAsync(viewModel);

            //Assert
            Assert.Equal((int)HttpStatusCode.OK, result.StatusCode);
        }
Example #2
0
        public BearerTokenResponse CreateTokenReponse()
        {
            var handler = new JwtSecurityTokenHandler();

            var token = CreateToken();

            var tokenResponse = new BearerTokenResponse {
                Token = handler.WriteToken(token), Expiration = token.ValidTo.ToString()
            };

            return(tokenResponse);
        }
Example #3
0
        public async Task RetrieveToken_Success()
        {
            // ARRANGE
            var appCache    = (IAppCache)_context.Properties["appCache"];
            var bearerToken = new BearerTokenResponse
            {
                access_token = "token"
            };
            var json = System.Text.Json.JsonSerializer.Serialize(bearerToken);
            var clientHandlerStub = new DelegatingHandlerStub((request, cancellationToken) =>
            {
                var response = new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = new StringContent(json, Encoding.UTF8)
                };
                return(Task.FromResult(response));
            }
                                                              );
            var client = new HttpClient(clientHandlerStub);
            var httpClientFactoryMock = new Mock <IHttpClientFactory>();

            httpClientFactoryMock.Setup(mock => mock.CreateClient(It.IsAny <string>()))
            .Returns(client)
            .Verifiable();

            var configurationMock = new Mock <IConfiguration>();

            configurationMock.Setup(mock => mock[It.IsAny <string>()])
            .Returns("http://test.url")
            .Verifiable();

            var keyVaultMock = new Mock <IAzureKeyVaultService>();

            var unitUnderTest =
                new BearerTokenProvider(appCache,
                                        httpClientFactoryMock.Object,
                                        configurationMock.Object,
                                        keyVaultMock.Object);

            // ACT
            var result = await unitUnderTest.RetrieveToken();

            // ASSERT
            configurationMock.Verify();
            httpClientFactoryMock.Verify();
            Assert.IsNotNull(result);
            Assert.AreEqual(bearerToken.access_token, result);
        }