github/Ombi
1
0
Fork 0
mirror of https://github.com/Ombi-app/Ombi.git synced 2025-07-07 05:31:13 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added more tests

Browse source
This commit is contained in:
tidusjar 2016-03-15 13:00:54 +00:00
parent ba5ccfec33
commit ca8b9f20f1
2 changed files with 246 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

230
PlexRequests.UI.Tests/AdminModuleTests.cs
View file

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

45
PlexRequests.UI/Modules/AdminModule.cs
View file

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