Added more tests

PlexRequests.UI.Tests/AdminModuleTests.cs

@@ -36,7 +36,6 @@ using Newtonsoft.Json;
 using NUnit.Framework;
 
 using PlexRequests.Api.Interfaces;
-using PlexRequests.Api.Models;
 using PlexRequests.Api.Models.Plex;
 using PlexRequests.Core;
 using PlexRequests.Core.SettingModels;
@@ -48,57 +47,254 @@ namespace PlexRequests.UI.Tests
     [TestFixture]
     public class AdminModuleTests
     {
+        private Mock<ISettingsService<PlexRequestSettings>> PlexRequestMock { get; set; }
+        private Mock<ISettingsService<CouchPotatoSettings>> CpMock { get; set; }
         private Mock<ISettingsService<AuthenticationSettings>> AuthMock { get; set; }
+        private Mock<ISettingsService<PlexSettings>> PlexSettingsMock { get; set; }
+        private Mock<ISettingsService<SonarrSettings>> SonarrSettingsMock { get; set; }
+        private Mock<ISettingsService<EmailNotificationSettings>> EmailMock { get; set; }
         private Mock<IPlexApi> PlexMock { get; set; }
+        private Mock<ISonarrApi> SonarrApiMock { get; set; }
+
+        private ConfigurableBootstrapper Bootstrapper { get; set; }
 
         [SetUp]
         public void Setup()
         {
             AuthMock = new Mock<ISettingsService<AuthenticationSettings>>();
-            PlexMock = new Mock<IPlexApi>();
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" };
-        }
-
-        [Test]
-        [Ignore("Need to finish")]
-        public void RequestAuthTokenTest()
-        {
-            var expectedSettings = new AuthenticationSettings {UserAuthentication = false, PlexAuthToken = "abc"};
             AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
 
-            var bootstrapper = new ConfigurableBootstrapper(with =>
+            PlexMock = new Mock<IPlexApi>();
+            PlexMock.Setup(x => x.SignIn("Username1", "Password1"))
+                    .Returns(new PlexAuthentication { user = new User { authentication_token = "abc", username = "Username1" } });
+
+            PlexRequestMock = new Mock<ISettingsService<PlexRequestSettings>>();
+            CpMock = new Mock<ISettingsService<CouchPotatoSettings>>();
+            PlexSettingsMock = new Mock<ISettingsService<PlexSettings>>();
+            SonarrApiMock = new Mock<ISonarrApi>();
+            SonarrSettingsMock = new Mock<ISettingsService<SonarrSettings>>();
+            EmailMock = new Mock<ISettingsService<EmailNotificationSettings>>();
+
+            Bootstrapper = new ConfigurableBootstrapper(with =>
             {
-                with.Module<UserLoginModule>();
+                with.Module<AdminModule>();
                 with.Dependency(AuthMock.Object);
+                with.Dependency(PlexRequestMock.Object);
+                with.Dependency(CpMock.Object);
+                with.Dependency(PlexSettingsMock.Object);
+                with.Dependency(SonarrApiMock.Object);
+                with.Dependency(SonarrSettingsMock.Object);
                 with.Dependency(PlexMock.Object);
+                with.Dependency(EmailMock.Object);
                 with.RootPathProvider<TestRootPathProvider>();
                 with.RequestStartup((container, pipelines, context) =>
                 {
-                    context.CurrentUser = new UserIdentity { UserName = "user"};
+                    context.CurrentUser = new UserIdentity { UserName = "user" };
                 });
             });
 
-            bootstrapper.WithSession(new Dictionary<string, object>());
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+        }
 
-            var browser = new Browser(bootstrapper);
+        [Test]
+        public void RequestAuthTokenTestNewSettings()
+        {
+            var browser = new Browser(Bootstrapper);
 
             var result = browser.Post("/admin/requestauth", with =>
             {
                 with.HttpRequest();
                 with.Header("Accept", "application/json");
-                with.FormValue("username", "abc");
+                with.FormValue("username", "Username1");
-                with.FormValue("password","pass");
+                with.FormValue("password", "Password1");
 
             });
 
             Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
-            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
 
             var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
             Assert.That(body.Result, Is.EqualTo(true));
+            PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Once);
             AuthMock.Verify(x => x.GetSettings(), Times.Once);
-            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Once);
-            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
         }
 
+        [Test]
+        public void RequestAuthTokenTestEmptyCredentials()
+        {
+            var browser = new Browser(Bootstrapper);
+
+            var result = browser.Post("/admin/requestauth", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("username", string.Empty);
+                with.FormValue("password", "Password1");
+
+            });
+
+            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
+
+            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
+            Assert.That(body.Result, Is.EqualTo(false));
+            Assert.That(body.Message, Is.Not.Empty);
+
+            PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Never);
+            AuthMock.Verify(x => x.GetSettings(), Times.Never);
+            AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Never);
+        }
+
+        [Test]
+        public void RequestAuthTokenTesPlexSignInFail()
+        {
+            var browser = new Browser(Bootstrapper);
+
+            var result = browser.Post("/admin/requestauth", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("username", "Badusername");
+                with.FormValue("password", "Password1");
+
+            });
+
+            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
+
+            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
+            Assert.That(body.Result, Is.EqualTo(false));
+            Assert.That(body.Message, Is.Not.Empty);
+
+            PlexMock.Verify(x => x.SignIn("Badusername", "Password1"), Times.Once);
+            AuthMock.Verify(x => x.GetSettings(), Times.Never);
+            AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Never);
+        }
+
+        [Test]
+        public void RequestAuthTokenTestExistingSettings()
+        {
+            AuthMock.Setup(x => x.GetSettings()).Returns(() => null);
+            var browser = new Browser(Bootstrapper);
+
+            var result = browser.Post("/admin/requestauth", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("username", "Username1");
+                with.FormValue("password", "Password1");
+
+            });
+
+            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
+
+            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
+            Assert.That(body.Result, Is.EqualTo(true));
+
+            PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Once);
+            AuthMock.Verify(x => x.GetSettings(), Times.Once);
+            AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Once);
+        }
+
+        [Test]
+        public void GetUsersSuccessfully()
+        {
+            var users = new PlexFriends { User = new[] { new UserFriends { Username = "abc2" }, } };
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(users);
+            var browser = new Browser(Bootstrapper);
+
+            var result = browser.Get("/admin/getusers", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("username", "Username1");
+                with.FormValue("password", "Password1");
+
+            });
+
+            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
+
+            var body = result.Body.AsString();
+            Assert.That(body, Is.Not.Null);
+            Assert.That(body, Contains.Substring("abc2"));
+
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
+            AuthMock.Verify(x => x.GetSettings(), Times.Once);
+        }
+
+        [Test]
+        public void GetUsersReturnsNoUsers()
+        {
+            var users = new PlexFriends();
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(users);
+            var browser = new Browser(Bootstrapper);
+
+            var result = browser.Get("/admin/getusers", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("username", "Username1");
+                with.FormValue("password", "Password1");
+
+            });
+
+            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
+
+            var body = JsonConvert.DeserializeObject<string>(result.Body.AsString());
+            Assert.That(body, Is.Not.Null);
+            Assert.That(string.IsNullOrWhiteSpace(body), Is.True);
+
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
+            AuthMock.Verify(x => x.GetSettings(), Times.Once);
+        }
+
+        [Test]
+        public void GetUsersReturnsNull()
+        {
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(() => null);
+            var browser = new Browser(Bootstrapper);
+
+            var result = browser.Get("/admin/getusers", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("username", "Username1");
+                with.FormValue("password", "Password1");
+
+            });
+
+            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
+
+            var body = JsonConvert.DeserializeObject<string>(result.Body.AsString());
+            Assert.That(body, Is.Not.Null);
+            Assert.That(string.IsNullOrWhiteSpace(body), Is.True);
+
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
+            AuthMock.Verify(x => x.GetSettings(), Times.Once);
+        }
+
+        [Test]
+        public void GetUsersTokenIsNull()
+        {
+            AuthMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings());
+            var browser = new Browser(Bootstrapper);
+
+            var result = browser.Get("/admin/getusers", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("username", "Username1");
+                with.FormValue("password", "Password1");
+
+            });
+
+            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
+
+            var body = JsonConvert.DeserializeObject<string>(result.Body.AsString());
+            Assert.That(body, Is.Not.Null);
+            Assert.That(string.IsNullOrWhiteSpace(body), Is.True);
+
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
+            AuthMock.Verify(x => x.GetSettings(), Times.Once);
+        }
     }
 }

PlexRequests.UI/Modules/AdminModule.cs

@@ -35,7 +35,6 @@ using Nancy.Security;
 
 using NLog;
 
-using PlexRequests.Api;
 using PlexRequests.Api.Interfaces;
 using PlexRequests.Core;
 using PlexRequests.Core.SettingModels;
@@ -46,22 +45,24 @@ namespace PlexRequests.UI.Modules
 {
     public class AdminModule : NancyModule
     {
-        private ISettingsService<PlexRequestSettings> RpService { get; set; }
+        private ISettingsService<PlexRequestSettings> RpService { get; }
-        private ISettingsService<CouchPotatoSettings> CpService { get; set; }
+        private ISettingsService<CouchPotatoSettings> CpService { get; }
-        private ISettingsService<AuthenticationSettings> AuthService { get; set; }
+        private ISettingsService<AuthenticationSettings> AuthService { get; }
-        private ISettingsService<PlexSettings> PlexService { get; set; }
+        private ISettingsService<PlexSettings> PlexService { get; }
-        private ISettingsService<SonarrSettings> SonarrService { get; set; }
+        private ISettingsService<SonarrSettings> SonarrService { get; }
-        private ISettingsService<EmailNotificationSettings> EmailService { get; set; }
+        private ISettingsService<EmailNotificationSettings> EmailService { get; }
-        private ISonarrApi SonarrApi { get; set; }
+        private IPlexApi PlexApi { get; }
+        private ISonarrApi SonarrApi { get; }
 
         private static Logger Log = LogManager.GetCurrentClassLogger();
         public AdminModule(ISettingsService<PlexRequestSettings> rpService,
             ISettingsService<CouchPotatoSettings> cpService,
-            ISettingsService<AuthenticationSettings> auth
+            ISettingsService<AuthenticationSettings> auth,
-            , ISettingsService<PlexSettings> plex,
+            ISettingsService<PlexSettings> plex,
             ISettingsService<SonarrSettings> sonarr,
             ISonarrApi sonarrApi,
-             ISettingsService<EmailNotificationSettings> email) : base("admin")
+            ISettingsService<EmailNotificationSettings> email,
+            IPlexApi plexApi) : base("admin")
         {
             RpService = rpService;
             CpService = cpService;
@@ -70,6 +71,7 @@ namespace PlexRequests.UI.Modules
             SonarrService = sonarr;
             SonarrApi = sonarrApi;
             EmailService = email;
+            PlexApi = plexApi;
 
 #if !DEBUG
             this.RequiresAuthentication();
@@ -147,10 +149,9 @@ namespace PlexRequests.UI.Modules
                 return Response.AsJson(new { Result = false, Message = "Please provide a valid username and password" });
             }
 
-            var plex = new PlexApi();
+            var model = PlexApi.SignIn(user.username, user.password);
-            var model = plex.SignIn(user.username, user.password);
 
-            if (model.user == null)
+            if (model?.user == null)
             {
                 return Response.AsJson(new { Result = false, Message = "Incorrect username or password!" });
             }
@@ -176,15 +177,23 @@ namespace PlexRequests.UI.Modules
 
         private Response GetUsers()
         {
-            var token = AuthService.GetSettings().PlexAuthToken;
+            var settings = AuthService.GetSettings();
+
+            var token = settings?.PlexAuthToken;
             if (token == null)
             {
                 return Response.AsJson(string.Empty);
             }
-            var api = new PlexApi();
+
-            var users = api.GetUsers(token);
+            var users = PlexApi.GetUsers(token);
             if (users == null)
-            { return Response.AsJson(string.Empty); }
+            {
+                return Response.AsJson(string.Empty);
+            }
+            if (users.User == null || users.User?.Length == 0)
+            {
+                return Response.AsJson(string.Empty);
+            }
 
             var usernames = users.User.Select(x => x.Username);
             return Response.AsJson(usernames);
@@ -251,7 +260,7 @@ namespace PlexRequests.UI.Modules
         private Negotiator EmailNotifications()
         {
             var settings = EmailService.GetSettings();
-            return View["EmailNotifications",settings];
+            return View["EmailNotifications", settings];
         }
 
         private Response SaveEmailNotifications()