open-source-mirrors
/
Ombi
mirror of https://github.com/Ombi-app/Ombi
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

More unit tests around the login and also the core Plex Checker

Browse Source
pull/470/head
tidusjar 8 years ago
parent 4eff175424
commit 13324cac14
7 changed files with 690 additions and 468 deletions
Show Stats Download Patch File Download Diff File

6
PlexRequests.Core/CacheKeys.cs
Unescape View File

@ -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);
}
}

204
PlexRequests.Services.Tests/PlexAvailabilityCheckerTests.cs
Unescape View File

@ -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()

1
PlexRequests.Services.Tests/PlexRequests.Services.Tests.csproj
Unescape View File

@ -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'">

7
PlexRequests.Services/Jobs/PlexAvailabilityChecker.cs
Unescape View File

@ -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()
}));
}
}

937
PlexRequests.UI.Tests/UserLoginModuleTests.cs
Unescape View File

@ -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);
// }
// }
//}
#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);
}
}
}

1
PlexRequests.UI/Modules/SearchModule.cs
Unescape View File

@ -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();

2
PlexRequests.UI/Modules/UserLoginModule.cs
Unescape View File

@ -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)
{

Write Preview
Loading…
Cancel
Save