Develop user token interface.

3 files changed, 141 insertions, 33 deletions

diff --git a/Timeline.Tests/AuthorizationUnitTest.cs b/Timeline.Tests/AuthorizationUnitTest.cs
index e9e86c8e..1566f2ac 100644
--- a/Timeline.Tests/AuthorizationUnitTest.cs
+++ b/Timeline.Tests/AuthorizationUnitTest.cs
@@ -1,12 +1,12 @@
 using Microsoft.AspNetCore.Mvc.Testing;
 using Newtonsoft.Json;
 using System;
-using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
 using Timeline.Controllers;
 using Timeline.Tests.Helpers;
+using Timeline.Tests.Helpers.Authentication;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -14,6 +14,10 @@ namespace Timeline.Tests
 {
     public class AuthorizationUnitTest : IClassFixture<WebApplicationFactory<Startup>>
     {
+        private const string NeedAuthorizeUrl = "api/test/User/NeedAuthorize";
+        private const string BothUserAndAdminUrl = "api/test/User/BothUserAndAdmin";
+        private const string OnlyAdminUrl = "api/test/User/OnlyAdmin";
+
         private readonly WebApplicationFactory<Startup> _factory;
 
         public AuthorizationUnitTest(WebApplicationFactory<Startup> factory, ITestOutputHelper outputHelper)
@@ -26,41 +30,18 @@ namespace Timeline.Tests
         {
             using (var client = _factory.CreateDefaultClient())
             {
-                var response = await client.GetAsync("/api/Test/Action1");                
+                var response = await client.GetAsync(NeedAuthorizeUrl);                
                 Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
             }
         }
 
-        private static async Task<string> Login(HttpClient client, string username, string password)
-        {
-            var response = await client.PostAsJsonAsync("/api/User/LogIn", new UserController.UserCredentials { Username = username, Password = password });
-
-            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
-
-            var loginInfo = JsonConvert.DeserializeObject<UserController.LoginInfo>(await response.Content.ReadAsStringAsync());
-
-            return loginInfo.Token;
-        }
-
-        private static async Task<HttpResponseMessage> GetWithAuthentication(HttpClient client, string path, string token)
-        {
-            var request = new HttpRequestMessage
-            {
-                RequestUri = new Uri(client.BaseAddress, path),
-                Method = HttpMethod.Get
-            };
-            request.Headers.Add("Authorization", "Bearer " + token);
-
-            return await client.SendAsync(request);
-        }
-
         [Fact]
         public async Task AuthenticationTest()
         {
             using (var client = _factory.CreateDefaultClient())
             {
-                var token = await Login(client, "user", "user");
-                var response = await GetWithAuthentication(client, "/api/Test/Action1", token);
+                var token = (await client.CreateUserTokenAsync("user", "user")).Token;
+                var response = await client.SendWithAuthenticationAsync(token, NeedAuthorizeUrl);
                 Assert.Equal(HttpStatusCode.OK, response.StatusCode);
             }
         }
@@ -70,10 +51,10 @@ namespace Timeline.Tests
         {
             using (var client = _factory.CreateDefaultClient())
             {
-                var token = await Login(client, "user", "user");
-                var response1 = await GetWithAuthentication(client, "/api/Test/Action2", token);
+                var token = (await client.CreateUserTokenAsync("user", "user")).Token;
+                var response1 = await client.SendWithAuthenticationAsync(token, BothUserAndAdminUrl);
                 Assert.Equal(HttpStatusCode.OK, response1.StatusCode);
-                var response2 = await GetWithAuthentication(client, "/api/Test/Action3", token);
+                var response2 = await client.SendWithAuthenticationAsync(token, OnlyAdminUrl);
                 Assert.Equal(HttpStatusCode.Forbidden, response2.StatusCode);
             }
         }
@@ -83,10 +64,10 @@ namespace Timeline.Tests
         {
             using (var client = _factory.CreateDefaultClient())
             {
-                var token = await Login(client, "admin", "admin");
-                var response1 = await GetWithAuthentication(client, "/api/Test/Action2", token);
+                var token = (await client.CreateUserTokenAsync("admin", "admin")).Token;
+                var response1 = await client.SendWithAuthenticationAsync(token, BothUserAndAdminUrl);
                 Assert.Equal(HttpStatusCode.OK, response1.StatusCode);
-                var response2 = await GetWithAuthentication(client, "/api/Test/Action3", token);
+                var response2 = await client.SendWithAuthenticationAsync(token, OnlyAdminUrl);
                 Assert.Equal(HttpStatusCode.OK, response2.StatusCode);
             }
         }
diff --git a/Timeline.Tests/Helpers/Authentication/AuthenticationHttpClientExtensions.cs b/Timeline.Tests/Helpers/Authentication/AuthenticationHttpClientExtensions.cs
new file mode 100644
index 00000000..a4cb8c65
--- /dev/null
+++ b/Timeline.Tests/Helpers/Authentication/AuthenticationHttpClientExtensions.cs
@@ -0,0 +1,41 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Timeline.Controllers;
+using Xunit;
+
+namespace Timeline.Tests.Helpers.Authentication
+{
+    public static class AuthenticationHttpClientExtensions
+    {
+        private const string CreateTokenUrl = "/api/User/CreateToken";
+
+        public static async Task<UserController.CreateTokenResult> CreateUserTokenAsync(this HttpClient client, string username, string password)
+        {
+            var response = await client.PostAsJsonAsync(CreateTokenUrl, new UserController.UserCredentials { Username = username, Password = password });
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+            var result = JsonConvert.DeserializeObject<UserController.CreateTokenResult>(await response.Content.ReadAsStringAsync());
+
+            return result;
+        }
+
+        public static async Task<HttpResponseMessage> SendWithAuthenticationAsync(this HttpClient client, string token, string path, Action<HttpRequestMessage> requestBuilder = null)
+        {
+            var request = new HttpRequestMessage
+            {
+                RequestUri = new Uri(client.BaseAddress, path),
+            };
+            request.Headers.Add("Authorization", "Bearer " + token);
+
+            requestBuilder?.Invoke(request);
+
+            return await client.SendAsync(request);
+        }
+    }
+}
diff --git a/Timeline.Tests/JwtTokenUnitTest.cs b/Timeline.Tests/JwtTokenUnitTest.cs
new file mode 100644
index 00000000..e55bc82c
--- /dev/null
+++ b/Timeline.Tests/JwtTokenUnitTest.cs
@@ -0,0 +1,86 @@
+using Microsoft.AspNetCore.Mvc.Testing;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Timeline.Controllers;
+using Timeline.Services;
+using Timeline.Tests.Helpers;
+using Timeline.Tests.Helpers.Authentication;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Timeline.Tests
+{
+    public class JwtTokenUnitTest : IClassFixture<WebApplicationFactory<Startup>>
+    {
+        private const string ValidateTokenUrl = "/api/User/ValidateToken";
+
+        private readonly WebApplicationFactory<Startup> _factory;
+
+        public JwtTokenUnitTest(WebApplicationFactory<Startup> factory, ITestOutputHelper outputHelper)
+        {
+            _factory = factory.WithTestConfig(outputHelper);
+        }
+
+        [Fact]
+        public async void ValidateToken_BadTokenTest()
+        {
+            using (var client = _factory.CreateDefaultClient())
+            {
+                var response = await client.PostAsync(ValidateTokenUrl, new StringContent("bad token hahaha", Encoding.UTF8, "text/plain"));
+
+                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+                var validationInfo = JsonConvert.DeserializeObject<TokenValidationResult>(await response.Content.ReadAsStringAsync());
+
+                Assert.False(validationInfo.IsValid);
+                Assert.Null(validationInfo.UserInfo);
+            }
+        }
+
+        [Fact]
+        public async void ValidateToken_PlainTextGoodTokenTest()
+        {
+            using (var client = _factory.CreateDefaultClient())
+            {
+                var createTokenResult = await client.CreateUserTokenAsync("admin", "admin");
+
+                var response = await client.PostAsync(ValidateTokenUrl, new StringContent(createTokenResult.Token, Encoding.UTF8, "text/plain"));
+
+                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+                var result = JsonConvert.DeserializeObject<TokenValidationResult>(await response.Content.ReadAsStringAsync());
+
+                Assert.True(result.IsValid);
+                Assert.NotNull(result.UserInfo);
+                Assert.Equal(createTokenResult.UserInfo.Username, result.UserInfo.Username);
+                Assert.Equal(createTokenResult.UserInfo.Roles, result.UserInfo.Roles);
+            }
+        }
+
+        [Fact]
+        public async void ValidateToken_JsonGoodTokenTest()
+        {
+            using (var client = _factory.CreateDefaultClient())
+            {
+                var createTokenResult = await client.CreateUserTokenAsync("admin", "admin");
+
+                var response = await client.PostAsJsonAsync(ValidateTokenUrl, new UserController.TokenValidationRequest { Token = createTokenResult.Token });
+
+                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+                var result = JsonConvert.DeserializeObject<TokenValidationResult>(await response.Content.ReadAsStringAsync());
+
+                Assert.True(result.IsValid);
+                Assert.NotNull(result.UserInfo);
+                Assert.Equal(createTokenResult.UserInfo.Username, result.UserInfo.Username);
+                Assert.Equal(createTokenResult.UserInfo.Roles, result.UserInfo.Roles);
+            }
+        }
+    }
+}