From 13324cac14059043ad12d5850012947572d612cf Mon Sep 17 00:00:00 2001
From: tidusjar <jamierees@outlook.com>
Date: Fri, 12 Aug 2016 14:41:34 +0100
Subject: [PATCH] More unit tests around the login and also the core Plex
 Checker

---
 PlexRequests.Core/CacheKeys.cs                |   6 -
 .../PlexAvailabilityCheckerTests.cs           | 204 +++-
 .../PlexRequests.Services.Tests.csproj        |   1 +
 .../Jobs/PlexAvailabilityChecker.cs           |   7 +-
 PlexRequests.UI.Tests/UserLoginModuleTests.cs | 937 +++++++++---------
 PlexRequests.UI/Modules/SearchModule.cs       |   1 +
 PlexRequests.UI/Modules/UserLoginModule.cs    |   2 +-
 7 files changed, 690 insertions(+), 468 deletions(-)

diff --git a/PlexRequests.Core/CacheKeys.cs b/PlexRequests.Core/CacheKeys.cs
index 230da7971..0f718f1f1 100644
--- a/PlexRequests.Core/CacheKeys.cs
+++ b/PlexRequests.Core/CacheKeys.cs
@@ -35,20 +35,14 @@ namespace PlexRequests.Core
 
         public const string PlexLibaries = nameof(PlexLibaries);
         public const string PlexEpisodes = nameof(PlexEpisodes);
-
         public const string TvDbToken = nameof(TvDbToken);
-
         public const string SonarrQualityProfiles = nameof(SonarrQualityProfiles);
         public const string SonarrQueued = nameof(SonarrQueued);
-
         public const string SickRageQualityProfiles = nameof(SickRageQualityProfiles);
         public const string SickRageQueued = nameof(SickRageQueued);
-
         public const string CouchPotatoQualityProfiles = nameof(CouchPotatoQualityProfiles);
         public const string CouchPotatoQueued = nameof(CouchPotatoQueued);
-
         public const string GetPlexRequestSettings = nameof(GetPlexRequestSettings);
-
         public const string LastestProductVersion = nameof(LastestProductVersion);
     }
 }
\ No newline at end of file
diff --git a/PlexRequests.Services.Tests/PlexAvailabilityCheckerTests.cs b/PlexRequests.Services.Tests/PlexAvailabilityCheckerTests.cs
index abe90364c..e9c86a6c6 100644
--- a/PlexRequests.Services.Tests/PlexAvailabilityCheckerTests.cs
+++ b/PlexRequests.Services.Tests/PlexAvailabilityCheckerTests.cs
@@ -25,26 +25,35 @@
 //  ************************************************************************/
 #endregion
 using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
 
 using Moq;
 
 using NUnit.Framework;
 
 using PlexRequests.Api.Interfaces;
+using PlexRequests.Api.Models.Plex;
 using PlexRequests.Core;
 using PlexRequests.Core.SettingModels;
 using PlexRequests.Services.Interfaces;
 using PlexRequests.Helpers;
 using PlexRequests.Services.Jobs;
+using PlexRequests.Services.Models;
 using PlexRequests.Store.Models;
 using PlexRequests.Store.Repository;
 
+using Ploeh.AutoFixture;
+
 namespace PlexRequests.Services.Tests
 {
     [TestFixture]
     public class PlexAvailabilityCheckerTests
     {
         public IAvailabilityChecker Checker { get; set; }
+        private Fixture F { get; set; } = new Fixture();
         private Mock<ISettingsService<PlexSettings>> SettingsMock { get; set; }
         private Mock<ISettingsService<AuthenticationSettings>> AuthMock { get; set; }
         private Mock<IRequestService> RequestMock { get; set; }
@@ -82,27 +91,190 @@ namespace PlexRequests.Services.Tests
             PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
         }
 
-        //[Test]
-        //public void IsAvailableTest()
-        //{
-        //    var settingsMock = new Mock<ISettingsService<PlexSettings>>();
-        //    var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
-        //    var requestMock = new Mock<IRequestService>();
-        //    var plexMock = new Mock<IPlexApi>();
-        //    var cacheMock = new Mock<ICacheProvider>();
+        [TestCaseSource(nameof(IsMovieAvailableTestData))]
+        public bool IsMovieAvailableTest(string title, string year)
+        {
+            var movies = new List<PlexMovie>
+            {
+                new PlexMovie {Title = title, ProviderId = null, ReleaseYear = year}
+            };
+            var result = Checker.IsMovieAvailable(movies.ToArray(), "title", "2011");
 
-        //    var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title", Year = "2011" } } };
+            return result;
+        }
 
-        //    settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
-        //    authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
-        //    plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
+        private static IEnumerable<TestCaseData> IsMovieAvailableTestData
+        {
+            get
+            {
+                yield return new TestCaseData("title", "2011").Returns(true).SetName("IsMovieAvailable True");
+                yield return new TestCaseData("title2", "2011").Returns(false).SetName("IsMovieAvailable False different title");
+                yield return new TestCaseData("title", "2001").Returns(false).SetName("IsMovieAvailable False different year");
+            }
+        }
 
-        //    Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
 
-        //    var result = Checker.IsAvailable("title", "2011", null, PlexType.Movie);
+        [TestCaseSource(nameof(IsMovieAvailableAdvancedTestData))]
+        public bool IsMovieAvailableAdvancedTest(string title, string year, string providerId)
+        {
+            var movies = new List<PlexMovie>
+            {
+                new PlexMovie {Title = title, ProviderId = providerId, ReleaseYear = year }
+            };
+            var result = Checker.IsMovieAvailable(movies.ToArray(), "title", "2011", 9999.ToString());
+
+            return result;
+        }
+
+        private static IEnumerable<TestCaseData> IsMovieAvailableAdvancedTestData
+        {
+            get
+            {
+                yield return new TestCaseData("title", "2011", "9999").Returns(true).SetName("Advanced IsMovieAvailable True");
+                yield return new TestCaseData("title2", "2011", "99929").Returns(false).SetName("Advanced IsMovieAvailable False different title");
+                yield return new TestCaseData("title", "2001", "99939").Returns(false).SetName("Advanced IsMovieAvailable False different year");
+                yield return new TestCaseData("title", "2001", "44445").Returns(false).SetName("Advanced IsMovieAvailable False different providerID");
+            }
+        }
+
+        [TestCaseSource(nameof(IsTvAvailableTestData))]
+        public bool IsTvAvailableTest(string title, string year)
+        {
+            var tv = new List<PlexTvShow>
+            {
+                new PlexTvShow {Title = title, ProviderId = null, ReleaseYear = year}
+            };
+            var result = Checker.IsTvShowAvailable(tv.ToArray(), "title", "2011");
+
+            return result;
+        }
+
+        private static IEnumerable<TestCaseData> IsTvAvailableTestData
+        {
+            get
+            {
+                yield return new TestCaseData("title", "2011").Returns(true).SetName("IsTvAvailable True");
+                yield return new TestCaseData("title2", "2011").Returns(false).SetName("IsTvAvailable False different title");
+                yield return new TestCaseData("title", "2001").Returns(false).SetName("IsTvAvailable False different year");
+            }
+        }
+
+        [TestCaseSource(nameof(IsTvAvailableAdvancedTestData))]
+        public bool IsTvAvailableAdvancedTest(string title, string year, string providerId)
+        {
+            var movies = new List<PlexTvShow>
+            {
+                new PlexTvShow {Title = title, ProviderId = providerId, ReleaseYear = year }
+            };
+            var result = Checker.IsTvShowAvailable(movies.ToArray(), "title", "2011", 9999.ToString());
+
+            return result;
+        }
+
+        private static IEnumerable<TestCaseData> IsTvAvailableAdvancedTestData
+        {
+            get
+            {
+                yield return new TestCaseData("title", "2011", "9999").Returns(true).SetName("Advanced IsTvAvailable True");
+                yield return new TestCaseData("title2", "2011", "99929").Returns(false).SetName("Advanced IsTvAvailable False different title");
+                yield return new TestCaseData("title", "2001", "99939").Returns(false).SetName("Advanced IsTvAvailable False different year");
+                yield return new TestCaseData("title", "2001", "44445").Returns(false).SetName("Advanced IsTvAvailable False different providerID");
+            }
+        }
+
+        [TestCaseSource(nameof(IsTvAvailableAdvancedSeasonsTestData))]
+        public bool IsTvAvailableAdvancedSeasonsTest(string title, string year, string providerId, int[] seasons)
+        {
+            var movies = new List<PlexTvShow>
+            {
+                new PlexTvShow {Title = title, ProviderId = providerId, ReleaseYear = year , Seasons = seasons}
+            };
+            var result = Checker.IsTvShowAvailable(movies.ToArray(), "title", "2011", 9999.ToString(), new[] { 1, 2, 3 });
+
+            return result;
+        }
+
+        private static IEnumerable<TestCaseData> IsTvAvailableAdvancedSeasonsTestData
+        {
+            get
+            {
+                yield return new TestCaseData("title", "2011", "9999", new[] { 1, 2, 3 }).Returns(true).SetName("Advanced IsTvSeasonsAvailable True");
+                yield return new TestCaseData("title2", "2011", "99929", new[] { 5, 6 }).Returns(false).SetName("Advanced IsTvSeasonsAvailable False no seasons");
+                yield return new TestCaseData("title2", "2011", "99929", new[] { 1, 6 }).Returns(true).SetName("Advanced IsTvSeasonsAvailable true one season");
+            }
+        }
+
+        [TestCaseSource(nameof(IsEpisodeAvailableTestData))]
+        public bool IsEpisodeAvailableTest(string providerId, int season, int episode)
+        {
+            var expected = new List<PlexEpisodes>
+            {
+                new PlexEpisodes {EpisodeNumber = 1, ShowTitle = "The Flash",ProviderId = 23.ToString(), SeasonNumber = 1, EpisodeTitle = "Pilot"}
+            };
+            PlexEpisodes.Setup(x => x.Custom(It.IsAny<Func<IDbConnection, IEnumerable<PlexEpisodes>>>())).Returns(expected);
+            Checker = new PlexAvailabilityChecker(SettingsMock.Object, RequestMock.Object, PlexMock.Object, CacheMock.Object, NotificationMock.Object, JobRec.Object, NotifyUsers.Object, PlexEpisodes.Object);
+
+            var result = Checker.IsEpisodeAvailable(providerId, season, episode);
+
+            return result;
+        }
+
+        private static IEnumerable<TestCaseData> IsEpisodeAvailableTestData
+        {
+            get
+            {
+                yield return new TestCaseData("23", 1, 1).Returns(true).SetName("IsEpisodeAvailable True S01E01");
+                yield return new TestCaseData("23", 1, 2).Returns(false).SetName("IsEpisodeAvailable False S01E02");
+                yield return new TestCaseData("23", 99, 99).Returns(false).SetName("IsEpisodeAvailable False S99E99");
+                yield return new TestCaseData("230", 99, 99).Returns(false).SetName("IsEpisodeAvailable False Incorrect ProviderId");
+            }
+        }
+
+        [Test]
+        public void GetPlexMoviesTests()
+        {
+            var cachedMovies = F.Build<PlexSearch>().Without(x => x.Directory).CreateMany().ToList();
+            cachedMovies.Add(new PlexSearch
+            {
+                Video = new List<Video>
+                {
+                    new Video {Type = "movie", Title = "title1", Year = "2016", ProviderId = "1212"}
+                }
+            });
+            CacheMock.Setup(x => x.Get<List<PlexSearch>>(CacheKeys.PlexLibaries)).Returns(cachedMovies);
+            var movies = Checker.GetPlexMovies();
+
+            Assert.That(movies.Any(x => x.ProviderId == "1212"));
+        }
+
+        [Test]
+        public void GetPlexTvShowsTests()
+        {
+            var cachedTv = F.Build<PlexSearch>().Without(x => x.Directory).CreateMany().ToList();
+            cachedTv.Add(new PlexSearch
+            {
+                Directory = new List<Directory1>
+                {
+                    new Directory1 {Type = "show", Title = "title1", Year = "2016", ProviderId = "1212", Seasons = new List<Directory1>()}
+                }
+            });
+            CacheMock.Setup(x => x.Get<List<PlexSearch>>(CacheKeys.PlexLibaries)).Returns(cachedTv);
+            var movies = Checker.GetPlexTvShows();
+
+            Assert.That(movies.Any(x => x.ProviderId == "1212"));
+        }
+
+        [Test]
+        public async Task GetAllPlexEpisodes()
+        {
+            PlexEpisodes.Setup(x => x.GetAllAsync()).ReturnsAsync(F.CreateMany<PlexEpisodes>().ToList());
+            Checker = new PlexAvailabilityChecker(SettingsMock.Object, RequestMock.Object, PlexMock.Object, CacheMock.Object, NotificationMock.Object, JobRec.Object, NotifyUsers.Object, PlexEpisodes.Object);
+
+            var episodes = await Checker.GetEpisodes();
+
+            Assert.That(episodes.Count(), Is.GreaterThan(0));
+        }
 
-        //    Assert.That(result, Is.True);
-        //}
 
         //[Test]
         //public void IsAvailableMusicDirectoryTitleTest()
diff --git a/PlexRequests.Services.Tests/PlexRequests.Services.Tests.csproj b/PlexRequests.Services.Tests/PlexRequests.Services.Tests.csproj
index 9400701dd..40794ab7d 100644
--- a/PlexRequests.Services.Tests/PlexRequests.Services.Tests.csproj
+++ b/PlexRequests.Services.Tests/PlexRequests.Services.Tests.csproj
@@ -61,6 +61,7 @@
       <Private>True</Private>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.Data" />
   </ItemGroup>
   <Choose>
     <When Condition="('$(VisualStudioVersion)' == '10.0' or '$(VisualStudioVersion)' == '') and '$(TargetFrameworkVersion)' == 'v3.5'">
diff --git a/PlexRequests.Services/Jobs/PlexAvailabilityChecker.cs b/PlexRequests.Services/Jobs/PlexAvailabilityChecker.cs
index 88aea4091..1f20a6e28 100644
--- a/PlexRequests.Services/Jobs/PlexAvailabilityChecker.cs
+++ b/PlexRequests.Services/Jobs/PlexAvailabilityChecker.cs
@@ -48,8 +48,6 @@ using PlexRequests.Store.Repository;
 
 using Quartz;
 
-using Action = PlexRequests.Helpers.Analytics.Action;
-
 namespace PlexRequests.Services.Jobs
 {
     public class PlexAvailabilityChecker : IJob, IAvailabilityChecker
@@ -202,7 +200,8 @@ namespace PlexRequests.Services.Jobs
             var libs = Cache.Get<List<PlexSearch>>(CacheKeys.PlexLibaries);
             if (libs != null)
             {
-                var tvLibs = libs.Where(x =>
+                var withDir = libs.Where(x => x.Directory != null);
+                var tvLibs = withDir.Where(x =>
                         x.Directory.Any(y =>
                             y.Type.Equals(PlexMediaType.Show.ToString(), StringComparison.CurrentCultureIgnoreCase)
                         )
@@ -215,7 +214,7 @@ namespace PlexRequests.Services.Jobs
                         Title = x.Title,
                         ReleaseYear = x.Year,
                         ProviderId = x.ProviderId,
-                        Seasons = x.Seasons.Select(d => PlexHelper.GetSeasonNumberFromTitle(d.Title)).ToArray()
+                        Seasons = x.Seasons?.Select(d => PlexHelper.GetSeasonNumberFromTitle(d.Title)).ToArray()
                     }));
                 }
             }
diff --git a/PlexRequests.UI.Tests/UserLoginModuleTests.cs b/PlexRequests.UI.Tests/UserLoginModuleTests.cs
index b49ebbd35..16b138eea 100644
--- a/PlexRequests.UI.Tests/UserLoginModuleTests.cs
+++ b/PlexRequests.UI.Tests/UserLoginModuleTests.cs
@@ -1,441 +1,496 @@
-//#region Copyright
-//// /************************************************************************
-////    Copyright (c) 2016 Jamie Rees
-////    File: UserLoginModuleTests.cs
-////    Created By: Jamie Rees
-////   
-////    Permission is hereby granted, free of charge, to any person obtaining
-////    a copy of this software and associated documentation files (the
-////    "Software"), to deal in the Software without restriction, including
-////    without limitation the rights to use, copy, modify, merge, publish,
-////    distribute, sublicense, and/or sell copies of the Software, and to
-////    permit persons to whom the Software is furnished to do so, subject to
-////    the following conditions:
-////   
-////    The above copyright notice and this permission notice shall be
-////    included in all copies or substantial portions of the Software.
-////   
-////    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-////    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-////    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-////    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-////    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-////    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-////    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-////  ************************************************************************/
-//#endregion
-//using System.Collections.Generic;
-//using System.Threading.Tasks;
-
-//using Moq;
-
-//using Nancy;
-//using Nancy.Testing;
-
-//using Newtonsoft.Json;
-
-//using NUnit.Framework;
-
-//using PlexRequests.Api.Interfaces;
-//using PlexRequests.Api.Models.Plex;
-//using PlexRequests.Core;
-//using PlexRequests.Core.SettingModels;
-//using PlexRequests.Helpers.Analytics;
-//using PlexRequests.UI.Models;
-//using PlexRequests.UI.Modules;
-
-//namespace PlexRequests.UI.Tests
-//{
-//    [TestFixture]
-//    public class UserLoginModuleTests
-//    {
-//        private Mock<ISettingsService<AuthenticationSettings>> AuthMock { get; set; }
-//        private Mock<ISettingsService<PlexRequestSettings>> PlexRequestMock { get; set; }
-//        private Mock<ISettingsService<LandingPageSettings>> LandingPageMock { get; set; }
-//        private ConfigurableBootstrapper Bootstrapper { get; set; }
-//        private Mock<IPlexApi> PlexMock { get; set; }
-//        private Mock<IAnalytics> IAnalytics { get; set; }
-
-//        [SetUp]
-//        public void Setup()
-//        {
-//            AuthMock = new Mock<ISettingsService<AuthenticationSettings>>();
-//            PlexMock = new Mock<IPlexApi>();
-//            LandingPageMock = new Mock<ISettingsService<LandingPageSettings>>();
-//            PlexRequestMock = new Mock<ISettingsService<PlexRequestSettings>>();
-//            PlexRequestMock.Setup(x => x.GetSettings()).Returns(new PlexRequestSettings());
-//            PlexRequestMock.Setup(x => x.GetSettingsAsync()).Returns(Task.FromResult(new PlexRequestSettings()));
-//            LandingPageMock.Setup(x => x.GetSettings()).Returns(new LandingPageSettings());
-//            IAnalytics = new Mock<IAnalytics>();
-//            Bootstrapper = new ConfigurableBootstrapper(with =>
-//            {
-//                with.Module<UserLoginModule>();
-//                with.Dependency(PlexRequestMock.Object);
-//                with.Dependency(AuthMock.Object);
-//                with.Dependency(PlexMock.Object);
-//                with.Dependency(LandingPageMock.Object);
-//                with.Dependency(IAnalytics.Object);
-//                with.RootPathProvider<TestRootPathProvider>();
-//            });
-//        }
-
-//        [Test]
-//        public void LoginWithoutAuthentication()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" };
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-
-//            Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", "abc");
-//            });
-
-//            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));
-//            AuthMock.Verify(x => x.GetSettings(), Times.Once);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
-//        }
-
-//        [Test]
-//        public void LoginWithoutAuthenticationWithEmptyUsername()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" };
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-
-
-//            Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", string.Empty);
-//            });
-
-//            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
-
-//            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
-//            Assert.That(body.Result, Is.EqualTo(false));
-//            AuthMock.Verify(x => x.GetSettings(), Times.Never);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
-//        }
-
-//        [Test]
-//        public void LoginWithUsernameSuccessfully()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" };
-//            var plexFriends = new PlexFriends
-//            {
-//                User = new[]
-//                {
-//                    new UserFriends
-//                    {
-//                        Title = "abc",
-//                    },
-//                }
-//            };
-
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-//            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
-//            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
-
-//            Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", "abc");
-//            });
-
-//            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));
-//            AuthMock.Verify(x => x.GetSettings(), Times.Once);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
-//        }
-
-//        [Test]
-//        public void LoginWithUsernameUnSuccessfully()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" };
-//            var plexFriends = new PlexFriends
-//            {
-//                User = new[]
-//                {
-//                    new UserFriends
-//                    {
-//                        Username = "aaaa",
-//                    },
-//                }
-//            };
-
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-//            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
-//            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
-
-//            Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", "abc");
-//            });
-
-
-//            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
-//            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
-
-//            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
-//            Assert.That(body.Result, Is.EqualTo(false));
-//            Assert.That(body.Message, Is.Not.Empty);
-//            AuthMock.Verify(x => x.GetSettings(), Times.Once);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
-//        }
-
-//        [Test]
-//        public void LoginWithUsernameAndPasswordSuccessfully()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" };
-//            var plexFriends = new PlexFriends
-//            {
-//                User = new[]
-//                {
-//                    new UserFriends
-//                    {
-//                        Title = "abc",
-//                    }
-//                }
-//            };
-//            var plexAuth = new PlexAuthentication
-//            {
-//                user = new User
-//                {
-//                    authentication_token = "abc"
-//                }
-//            };
-
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-//            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
-//            PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
-//            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
-
-//            Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", "abc");
-//                with.FormValue("Password", "abc");
-//            });
-
-
-//            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));
-//            AuthMock.Verify(x => x.GetSettings(), Times.Once);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
-//        }
-
-//        [Test]
-//        public void LoginWithUsernameAndPasswordUnSuccessfully()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" };
-//            var plexFriends = new PlexFriends
-//            {
-//                User = new[]
-//                {
-//                    new UserFriends
-//                    {
-//                        Username = "abc",
-//                    },
-//                }
-//            };
-//            var plexAuth = new PlexAuthentication
-//            {
-//                user = null
-//            };
-
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-//            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
-//            PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
-
-  
-//            Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", "abc");
-//                with.FormValue("Password", "abc");
-//            });
-
-
-//            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
-//            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
-
-//            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
-//            Assert.That(body.Result, Is.EqualTo(false));
-//            Assert.That(body.Message, Is.Not.Empty);
-//            AuthMock.Verify(x => x.GetSettings(), Times.Once);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
-//        }
-
-//        [Test]
-//        public void AttemptToLoginAsDeniedUser()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = false, DeniedUsers = "abc", PlexAuthToken = "abc" };
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-
-//   Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", "abc");
-//            });
-
-//            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
-//            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
-
-//            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
-//            Assert.That(body.Result, Is.EqualTo(false));
-//            Assert.That(body.Message, Is.Not.Empty);
-//            AuthMock.Verify(x => x.GetSettings(), Times.Once);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
-//        }
-
-//        [Test]
-//        public void Logout()
-//        {
-//            Bootstrapper.WithSession(new Dictionary<string, object> { { SessionKeys.UsernameKey, "abc" } });
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Get("/userlogin/logout", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//            });
-
-//            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
-//            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
-//        }
-
-//        [Test]
-//        public void LoginWithOwnerUsernameSuccessfully()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" };
-//            var plexFriends = new PlexFriends
-//            {
-//                User = new[]
-//                {
-//                    new UserFriends()
-//                }
-//            };
-
-//            var account = new PlexAccount { Username = "Jamie" };
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-//            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
-//            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(account);
-//            PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(new PlexAuthentication { user = new User { username = "Jamie" } });
-
-//            Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", "Jamie");
-//            });
-
-//            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
-//            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("Jamie"));
-
-//            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
-//            Assert.That(body.Result, Is.EqualTo(true));
-//            AuthMock.Verify(x => x.GetSettings(), Times.Once);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
-//        }
-
-//        [Test]
-//        public void LoginWithOwnerUsernameAndPasswordSuccessfully()
-//        {
-//            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" };
-//            var plexFriends = new PlexFriends
-//            {
-//                User = new[]
-//                {
-//                    new UserFriends()
-//                }
-//            };
-//            var plexAuth = new PlexAuthentication
-//            {
-//                user = new User
-//                {
-//                    authentication_token = "abc",
-//                    username = "Jamie"
-//                }
-//            };
-
-//            var account = new PlexAccount { Username = "Jamie" };
-
-//            AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
-//            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
-//            PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
-//            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(account);
-
-//            Bootstrapper.WithSession(new Dictionary<string, object>());
-
-//            var browser = new Browser(Bootstrapper);
-//            var result = browser.Post("/userlogin", with =>
-//            {
-//                with.HttpRequest();
-//                with.Header("Accept", "application/json");
-//                with.FormValue("Username", "jamie");
-//                with.FormValue("Password", "abc");
-//            });
-
-
-//            Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
-//            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("jamie"));
-
-//            var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
-//            Assert.That(body.Result, Is.EqualTo(true));
-//            AuthMock.Verify(x => x.GetSettings(), Times.Once);
-//            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
-//            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
-//        }
-//    }
-//}
\ No newline at end of file
+#region Copyright
+// /************************************************************************
+//    Copyright (c) 2016 Jamie Rees
+//    File: UserLoginModuleTests.cs
+//    Created By: Jamie Rees
+//   
+//    Permission is hereby granted, free of charge, to any person obtaining
+//    a copy of this software and associated documentation files (the
+//    "Software"), to deal in the Software without restriction, including
+//    without limitation the rights to use, copy, modify, merge, publish,
+//    distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so, subject to
+//    the following conditions:
+//   
+//    The above copyright notice and this permission notice shall be
+//    included in all copies or substantial portions of the Software.
+//   
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//  ************************************************************************/
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+using Moq;
+
+using Nancy;
+using Nancy.Linker;
+using Nancy.Testing;
+
+using Newtonsoft.Json;
+
+using NUnit.Framework;
+
+using PlexRequests.Api.Interfaces;
+using PlexRequests.Api.Models.Plex;
+using PlexRequests.Core;
+using PlexRequests.Core.SettingModels;
+using PlexRequests.Helpers.Analytics;
+using PlexRequests.UI.Models;
+using PlexRequests.UI.Modules;
+
+namespace PlexRequests.UI.Tests
+{
+    [TestFixture]
+    public class UserLoginModuleTests
+    {
+        private Mock<ISettingsService<AuthenticationSettings>> AuthMock { get; set; }
+        private Mock<ISettingsService<PlexRequestSettings>> PlexRequestMock { get; set; }
+        private Mock<ISettingsService<LandingPageSettings>> LandingPageMock { get; set; }
+        private Mock<ISettingsService<PlexSettings>> PlexSettingsMock { get; set; }
+        private ConfigurableBootstrapper Bootstrapper { get; set; }
+        private Mock<IPlexApi> PlexMock { get; set; }
+        private Mock<IAnalytics> IAnalytics { get; set; }
+        private Mock<IResourceLinker> Linker { get; set; }
+
+        [SetUp]
+        public void Setup()
+        {
+            AuthMock = new Mock<ISettingsService<AuthenticationSettings>>();
+            PlexMock = new Mock<IPlexApi>();
+            LandingPageMock = new Mock<ISettingsService<LandingPageSettings>>();
+            PlexRequestMock = new Mock<ISettingsService<PlexRequestSettings>>();
+            PlexRequestMock.Setup(x => x.GetSettings()).Returns(new PlexRequestSettings());
+            PlexRequestMock.Setup(x => x.GetSettingsAsync()).Returns(Task.FromResult(new PlexRequestSettings()));
+            LandingPageMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new LandingPageSettings());
+            IAnalytics = new Mock<IAnalytics>();
+            Linker = new Mock<IResourceLinker>();
+            Linker.Setup(x => x.BuildAbsoluteUri(It.IsAny<NancyContext>(), "SearchIndex", null)).Returns(new Uri("http://www.searchindex.com"));
+            Linker.Setup(x => x.BuildAbsoluteUri(It.IsAny<NancyContext>(), "LandingPageIndex", null)).Returns(new Uri("http://www.landingpage.com"));
+            Linker.Setup(x => x.BuildAbsoluteUri(It.IsAny<NancyContext>(), "UserLoginIndex", null)).Returns(new Uri("http://www.userloginindex.com"));
+            PlexSettingsMock = new Mock<ISettingsService<PlexSettings>>();
+            PlexSettingsMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new PlexSettings() {PlexAuthToken = "abc"});
+            Bootstrapper = new ConfigurableBootstrapper(with =>
+            {
+                with.Module<UserLoginModule>();
+                with.Dependency(PlexRequestMock.Object);
+                with.Dependency(AuthMock.Object);
+                with.Dependency(PlexMock.Object);
+                with.Dependency(LandingPageMock.Object);
+                with.Dependency(IAnalytics.Object);
+                with.Dependency(Linker.Object);
+                with.Dependency(PlexSettingsMock.Object);
+                with.RootPathProvider<TestRootPathProvider>();
+            });
+        }
+
+        [Test]
+        public void LoginWithoutAuthentication()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = false };
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "abc");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
+
+
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.searchindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void LoginWithoutAuthenticationWithEmptyUsername()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = false };
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", string.Empty);
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+
+
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.userloginindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Never);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void LoginWithUsernameSuccessfully()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = true };
+            var plexFriends = new PlexFriends
+            {
+                User = new[]
+                {
+                    new UserFriends
+                    {
+                        Title = "abc",
+                    },
+                }
+            };
+
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
+            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "abc");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
+
+
+
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.searchindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void LoginWithUsernameUnSuccessfully()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = true };
+            var plexFriends = new PlexFriends
+            {
+                User = new[]
+                {
+                    new UserFriends
+                    {
+                        Username = "aaaa",
+                    },
+                }
+            };
+
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
+            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "abc");
+            });
+
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
+
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.userloginindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void LoginWithUsernameAndPasswordSuccessfully()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true };
+            var plexFriends = new PlexFriends
+            {
+                User = new[]
+                {
+                    new UserFriends
+                    {
+                        Title = "abc",
+                    }
+                }
+            };
+            var plexAuth = new PlexAuthentication
+            {
+                user = new User
+                {
+                    authentication_token = "abc"
+                }
+            };
+
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
+            PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
+            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "abc");
+                with.FormValue("Password", "abc");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
+            
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.searchindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void LoginWithUsernameAndPasswordUnSuccessfully()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true };
+            var plexFriends = new PlexFriends
+            {
+                User = new[]
+                {
+                    new UserFriends
+                    {
+                        Username = "abc",
+                    },
+                }
+            };
+            var plexAuth = new PlexAuthentication
+            {
+                user = null
+            };
+
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
+            PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
+
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "abc");
+                with.FormValue("Password", "abc");
+            });
+
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
+            
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.userloginindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void AttemptToLoginAsDeniedUser()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = false, DeniedUsers = "abc" };
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "abc");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
+
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.userloginindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void Logout()
+        {
+            Bootstrapper.WithSession(new Dictionary<string, object> { { SessionKeys.UsernameKey, "abc" } });
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Get("/userlogin/logout", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
+        }
+
+        [Test]
+        public void LoginWithOwnerUsernameSuccessfully()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = true };
+            var plexFriends = new PlexFriends
+            {
+                User = new[]
+                {
+                    new UserFriends()
+                }
+            };
+
+            var account = new PlexAccount { Username = "Jamie" };
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
+            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(account);
+            PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(new PlexAuthentication { user = new User { username = "Jamie" } });
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "Jamie");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("Jamie"));
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.searchindex.com/"))); // Redirect header
+
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void LoginWithOwnerUsernameAndPasswordSuccessfully()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true };
+            var plexFriends = new PlexFriends
+            {
+                User = new[]
+                {
+                    new UserFriends()
+                }
+            };
+            var plexAuth = new PlexAuthentication
+            {
+                user = new User
+                {
+                    authentication_token = "abc",
+                    username = "Jamie"
+                }
+            };
+
+            var account = new PlexAccount { Username = "Jamie" };
+
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+            PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
+            PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
+            PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(account);
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "jamie");
+                with.FormValue("Password", "abc");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.searchindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        [Description("We should go to the landing page as it is enabled after we log in")]
+        public void LoginWithLandingPageAfterLogin()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = false };
+            LandingPageMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new LandingPageSettings { BeforeLogin = false, Enabled = true });
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "abc");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
+
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.landingpage.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        [Description("We shouldn't go to the landing page as we have already been there!")]
+        public void LoginWithLandingPageBefore()
+        {
+            var expectedSettings = new AuthenticationSettings { UserAuthentication = false };
+            LandingPageMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new LandingPageSettings { BeforeLogin = true, Enabled = true });
+            AuthMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(expectedSettings);
+
+            Bootstrapper.WithSession(new Dictionary<string, object>());
+
+            var browser = new Browser(Bootstrapper);
+            var result = browser.Post("/userlogin", with =>
+            {
+                with.HttpRequest();
+                with.Header("Accept", "application/json");
+                with.FormValue("Username", "abc");
+            });
+
+            Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
+            Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
+
+            Assert.That(result.Headers.Contains(new KeyValuePair<string, string>("Location", "http://www.searchindex.com/"))); // Redirect header
+            AuthMock.Verify(x => x.GetSettingsAsync(), Times.Once);
+            PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
+            PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/PlexRequests.UI/Modules/SearchModule.cs b/PlexRequests.UI/Modules/SearchModule.cs
index dd85e9737..7e2f9ebb5 100644
--- a/PlexRequests.UI/Modules/SearchModule.cs
+++ b/PlexRequests.UI/Modules/SearchModule.cs
@@ -673,6 +673,7 @@ namespace PlexRequests.UI.Modules
                         }
                     }
 
+                    //TODO this is not working correctly.
                     var episodes = await GetEpisodes(showId);
                     var availableEpisodes = episodes.Where(x => x.Requested).ToList();
                     var availble = availableEpisodes.Select(a => new EpisodesModel { EpisodeNumber = a.EpisodeNumber, SeasonNumber = a.SeasonNumber }).ToList();
diff --git a/PlexRequests.UI/Modules/UserLoginModule.cs b/PlexRequests.UI/Modules/UserLoginModule.cs
index c4680052b..61481faef 100644
--- a/PlexRequests.UI/Modules/UserLoginModule.cs
+++ b/PlexRequests.UI/Modules/UserLoginModule.cs
@@ -166,7 +166,7 @@ namespace PlexRequests.UI.Modules
                 return Response.AsRedirect(uri.ToString()); // TODO Check this
             }
 
-            var landingSettings = LandingPageSettings.GetSettings();
+            var landingSettings = await LandingPageSettings.GetSettingsAsync();
 
             if (landingSettings.Enabled)
             {