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

Lot's of refactoring

Browse source
This commit is contained in:
Jamie.Rees 2017-07-06 16:24:51 +01:00
commit 263240c648
36 changed files with 732 additions and 660 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/Ombi.Core.Tests/DbHelper.cs
View file

@ -1,4 +1,8 @@
using System.Linq;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Moq;
@ -18,5 +22,15 @@ namespace Ombi.Core.Tests
return dbSet.Object;
}
public static IQueryable<T> GetQueryable<T>(params T[] sourceList) where T : class
{
var mock = new Mock<IQueryable<T>>();
mock.As<IQueryable<T>>().Setup(x => x.ToListAsync(It.IsAny<CancellationToken>())).ReturnsAsync(sourceList.ToList());
return mock.Object;
}
}
}

172
src/Ombi.Core.Tests/Engine/MovieRequestEngineTests.cs
View file

@ -4,8 +4,8 @@
//using Moq;
//using Ombi.Core.Engine;
//using Ombi.Core.Models.Requests;
//using Ombi.Core.Models.Requests.Movie;
//using Ombi.Core.Requests.Models;
//using Ombi.Store.Entities.Requests;
//using Ombi.Store.Repository;
//using Xunit;
//namespace Ombi.Core.Tests.Engine
@ -14,118 +14,120 @@
// {
// public MovieRequestEngineTests()
// {
// RequestService = new Mock<IRequestService<MovieRequestModel>>();
// RequestService = new Mock<IMovieRequestRepository>();
// var requestService = new RequestService(null, RequestService.Object);
// Engine = new MovieRequestEngine(null, requestService, null, null, null, null, null);
// Engine = new MovieRequestEngine(null, requestService, null, null, null, null, null, null);
// }
// private MovieRequestEngine Engine { get; }
// private Mock<IRequestService<MovieRequestModel>> RequestService { get; }
// private Mock<IMovieRequestRepository> RequestService { get; }
// [Fact]
// public async Task GetNewRequests_Should_ReturnEmpty_WhenThereAreNoNewRequests()
// {
// var requests = new List<MovieRequestModel>
// var requests = new List<MovieRequests>
// {
// new MovieRequestModel { Available = true },
// new MovieRequestModel { Approved = true },
// new MovieRequests { Available = true },
// new MovieRequests { Approved = true },
// };
// RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// var r = DbHelper.GetQueryable(requests[0], requests[1]);
// RequestService.Setup(x => x.Get()).Returns(r);
// var result = await Engine.GetNewRequests();
// Assert.False(result.Any());
// }
// [Fact]
// public async Task GetNewRequests_Should_ReturnOnlyNewRequests_WhenThereAreMultipleRequests()
// {
// var requests = new List<MovieRequestModel>
// {
// new MovieRequestModel { Available = true },
// new MovieRequestModel { Approved = true },
// new MovieRequestModel(),
// };
// RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// //[Fact]
// //public async Task GetNewRequests_Should_ReturnOnlyNewRequests_WhenThereAreMultipleRequests()
// //{
// // var requests = new List<MovieRequestModel>
// // {
// // new MovieRequestModel { Available = true },
// // new MovieRequestModel { Approved = true },
// // new MovieRequestModel(),
// // };
// // RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// var result = await Engine.GetNewRequests();
// // var result = await Engine.GetNewRequests();
// Assert.Equal(result.Count(), 1);
// Assert.All(result, x =>
// {
// Assert.Equal(x.Available, false);
// Assert.Equal(x.Approved, false);
// });
// }
// // Assert.Equal(result.Count(), 1);
// // Assert.All(result, x =>
// // {
// // Assert.Equal(x.Available, false);
// // Assert.Equal(x.Approved, false);
// // });
// //}
// [Fact]
// public async Task GetApprovedRequests_Should_ReturnEmpty_WhenThereAreNoApprovedRequests()
// {
// var requests = new List<MovieRequestModel>
// {
// new MovieRequestModel { Available = true },
// };
// RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// //[Fact]
// //public async Task GetApprovedRequests_Should_ReturnEmpty_WhenThereAreNoApprovedRequests()
// //{
// // var requests = new List<MovieRequestModel>
// // {
// // new MovieRequestModel { Available = true },
// // };
// // RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// var result = await Engine.GetApprovedRequests();
// // var result = await Engine.GetApprovedRequests();
// Assert.False(result.Any());
// }
// // Assert.False(result.Any());
// //}
// [Fact]
// public async Task GetApprovedRequests_Should_ReturnOnlyApprovedRequests_WhenThereAreMultipleRequests()
// {
// var requests = new List<MovieRequestModel>
// {
// new MovieRequestModel { Available = true },
// new MovieRequestModel { Approved = true },
// new MovieRequestModel(),
// };
// RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// //[Fact]
// //public async Task GetApprovedRequests_Should_ReturnOnlyApprovedRequests_WhenThereAreMultipleRequests()
// //{
// // var requests = new List<MovieRequestModel>
// // {
// // new MovieRequestModel { Available = true },
// // new MovieRequestModel { Approved = true },
// // new MovieRequestModel(),
// // };
// // RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// var result = await Engine.GetApprovedRequests();
// // var result = await Engine.GetApprovedRequests();
// Assert.Equal(result.Count(), 1);
// Assert.All(result, x =>
// {
// Assert.Equal(x.Available, false);
// Assert.Equal(x.Approved, true);
// });
// }
// // Assert.Equal(result.Count(), 1);
// // Assert.All(result, x =>
// // {
// // Assert.Equal(x.Available, false);
// // Assert.Equal(x.Approved, true);
// // });
// //}
// [Fact]
// public async Task GetAvailableRequests_Should_ReturnEmpty_WhenThereAreNoAvailableRequests()
// {
// var requests = new List<MovieRequestModel>
// {
// new MovieRequestModel { Approved = true },
// };
// RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// //[Fact]
// //public async Task GetAvailableRequests_Should_ReturnEmpty_WhenThereAreNoAvailableRequests()
// //{
// // var requests = new List<MovieRequestModel>
// // {
// // new MovieRequestModel { Approved = true },
// // };
// // RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// var result = await Engine.GetAvailableRequests();
// // var result = await Engine.GetAvailableRequests();
// Assert.False(result.Any());
// }
// // Assert.False(result.Any());
// //}
// [Fact]
// public async Task GetAvailableRequests_Should_ReturnOnlyAvailableRequests_WhenThereAreMultipleRequests()
// {
// var requests = new List<MovieRequestModel>
// {
// new MovieRequestModel { Available = true },
// new MovieRequestModel { Approved = true },
// new MovieRequestModel(),
// };
// RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// //[Fact]
// //public async Task GetAvailableRequests_Should_ReturnOnlyAvailableRequests_WhenThereAreMultipleRequests()
// //{
// // var requests = new List<MovieRequestModel>
// // {
// // new MovieRequestModel { Available = true },
// // new MovieRequestModel { Approved = true },
// // new MovieRequestModel(),
// // };
// // RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// var result = await Engine.GetAvailableRequests();
// // var result = await Engine.GetAvailableRequests();
// Assert.Equal(result.Count(), 1);
// Assert.All(result, x =>
// {
// Assert.Equal(x.Available, true);
// Assert.Equal(x.Approved, false);
// });
// }
// // Assert.Equal(result.Count(), 1);
// // Assert.All(result, x =>
// // {
// // Assert.Equal(x.Available, true);
// // Assert.Equal(x.Approved, false);
// // });
// //}
// }
//}

71
src/Ombi.Core.Tests/Engine/TvRequestEngineTests.cs
View file

@ -1,11 +1,10 @@
//using System.Collections.Generic;
//using System.Linq;
//using System.Threading.Tasks;
//using Moq;
//using Ombi.Core.Engine;
//using Ombi.Core.Models.Requests;
//using Ombi.Core.Models.Requests.Tv;
//using Ombi.Core.Requests.Models;
//using Ombi.Store.Entities.Requests;
//using Ombi.Store.Repository.Requests;
//using Xunit;
//namespace Ombi.Core.Tests.Engine
@ -14,49 +13,49 @@
// {
// public TvRequestEngineTests()
// {
// RequestService = new Mock<IRequestService<TvRequestModel>>();
// RequestService = new Mock<ITvRequestRepository>();
// var requestService = new RequestService(RequestService.Object, null);
// Engine = new TvRequestEngine(null, requestService, null, null, null, null);
// Engine = new TvRequestEngine(null, requestService, null, null, null, null, null, null);
// }
// private TvRequestEngine Engine { get; }
// private Mock<IRequestService<TvRequestModel>> RequestService { get; }
// private Mock<ITvRequestRepository> RequestService { get; }
// [Fact]
// public async Task GetNewRequests_Should_ReturnEmpty_WhenThereAreNoNewRequests()
// {
// var requests = new List<TvRequestModel>
// {
// new TvRequestModel { Available = true },
// new TvRequestModel { Approved = true },
// };
// RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// //[Fact]
// //public async Task GetNewRequests_Should_ReturnEmpty_WhenThereAreNoNewRequests()
// //{
// // var requests = new List<TvRequests>
// // {
// // new TvRequests { Available = true },
// // new TvRequests { Approved = true },
// // };
// // RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// var result = await Engine.GetNewRequests();
// // var result = await Engine.GetNewRequests();
// Assert.False(result.Any());
// }
// // Assert.False(result.Any());
// //}
// [Fact]
// public async Task GetNewRequests_Should_ReturnOnlyNewRequests_WhenThereAreMultipleRequests()
// {
// var requests = new List<TvRequestModel>
// {
// new TvRequestModel { Available = true },
// new TvRequestModel { Approved = true },
// new TvRequestModel(),
// };
// RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// //[Fact]
// //public async Task GetNewRequests_Should_ReturnOnlyNewRequests_WhenThereAreMultipleRequests()
// //{
// // var requests = new List<TvRequestModel>
// // {
// // new TvRequestModel { Available = true },
// // new TvRequestModel { Approved = true },
// // new TvRequestModel(),
// // };
// // RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
// var result = await Engine.GetNewRequests();
// // var result = await Engine.GetNewRequests();
// Assert.Equal(result.Count(), 1);
// Assert.All(result, x =>
// {
// Assert.Equal(x.Available, false);
// Assert.Equal(x.Approved, false);
// });
// }
// // Assert.Equal(result.Count(), 1);
// // Assert.All(result, x =>
// // {
// // Assert.Equal(x.Available, false);
// // Assert.Equal(x.Approved, false);
// // });
// //}
// [Fact]
// public async Task GetApprovedRequests_Should_ReturnEmpty_WhenThereAreNoApprovedRequests()

147
src/Ombi.Core.Tests/Rule/Request/AutoApproveRuleTests.cs
View file

@ -1,89 +1,86 @@
//using System.Security.Principal;
//using System.Threading.Tasks;
//using Moq;
//using Ombi.Core.Claims;
//using Ombi.Core.Models.Requests;
//using Ombi.Core.Rule.Rules;
//using Ombi.Core.Rule.Rules.Request;
//using Xunit;
using System.Security.Principal;
using System.Threading.Tasks;
using Moq;
using Ombi.Core.Claims;
using Ombi.Core.Rule.Rules.Request;
using Ombi.Store.Entities.Requests;
using Xunit;
//namespace Ombi.Core.Tests.Rule
//{
// public class AutoApproveRuleTests
// {
// public AutoApproveRuleTests()
// {
// PrincipalMock = new Mock<IPrincipal>();
// Rule = new AutoApproveRule(PrincipalMock.Object);
// }
namespace Ombi.Core.Tests.Rule.Request
{
public class AutoApproveRuleTests
{
public AutoApproveRuleTests()
{
PrincipalMock = new Mock<IPrincipal>();
Rule = new AutoApproveRule(PrincipalMock.Object);
}
// private AutoApproveRule Rule { get; }
// private Mock<IPrincipal> PrincipalMock { get; }
private AutoApproveRule Rule { get; }
private Mock<IPrincipal> PrincipalMock { get; }
// [Fact]
// public async Task Should_ReturnSuccess_WhenAdminAndRequestMovie()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.Admin)).Returns(true);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.Movie };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnSuccess_WhenAdminAndRequestMovie()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.Admin)).Returns(true);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.Movie };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// Assert.Equal(request.Approved, true);
// }
Assert.Equal(result.Success, true);
Assert.Equal(request.Approved, true);
}
// [Fact]
// public async Task Should_ReturnSuccess_WhenAdminAndRequestTV()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.Admin)).Returns(true);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.TvShow };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnSuccess_WhenAdminAndRequestTV()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.Admin)).Returns(true);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.TvShow };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// Assert.Equal(request.Approved, true);
// }
Assert.Equal(result.Success, true);
Assert.Equal(request.Approved, true);
}
// [Fact]
// public async Task Should_ReturnSuccess_WhenAutoApproveMovieAndRequestMovie()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.AutoApproveMovie)).Returns(true);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.Movie };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnSuccess_WhenAutoApproveMovieAndRequestMovie()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.AutoApproveMovie)).Returns(true);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.Movie };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// Assert.Equal(request.Approved, true);
// }
Assert.Equal(result.Success, true);
Assert.Equal(request.Approved, true);
}
// [Fact]
// public async Task Should_ReturnSuccess_WhenAutoApproveTVAndRequestTV()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.AutoApproveTv)).Returns(true);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.TvShow };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnSuccess_WhenAutoApproveTVAndRequestTV()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.AutoApproveTv)).Returns(true);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.TvShow };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// Assert.Equal(request.Approved, true);
// }
Assert.Equal(result.Success, true);
Assert.Equal(request.Approved, true);
}
// [Fact]
// public async Task Should_ReturnFail_WhenNoClaimsAndRequestMovie()
// {
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.Movie };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnFail_WhenNoClaimsAndRequestMovie()
{
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.Movie };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// Assert.Equal(request.Approved, false);
// }
Assert.Equal(result.Success, true);
Assert.Equal(request.Approved, false);
}
// [Fact]
// public async Task Should_ReturnFail_WhenNoClaimsAndRequestTV()
// {
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.TvShow };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnFail_WhenNoClaimsAndRequestTV()
{
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.TvShow };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// Assert.Equal(request.Approved, false);
// }
// }
//}
Assert.Equal(result.Success, true);
Assert.Equal(request.Approved, false);
}
}
}

141
src/Ombi.Core.Tests/Rule/Request/CanRequestRuleTests.cs
View file

@ -1,84 +1,85 @@
//using System.Security.Principal;
//using System.Threading.Tasks;
//using Moq;
//using Ombi.Core.Claims;
//using Ombi.Core.Models.Requests;
//using Ombi.Core.Rule.Rules;
//using Xunit;
using System.Security.Principal;
using System.Threading.Tasks;
using Moq;
using Ombi.Core.Claims;
using Ombi.Core.Models.Requests;
using Ombi.Core.Rule.Rules;
using Ombi.Store.Entities.Requests;
using Xunit;
//namespace Ombi.Core.Tests.Rule
//{
// public class CanRequestRuleTests
// {
// public CanRequestRuleTests()
// {
// PrincipalMock = new Mock<IPrincipal>();
// Rule = new CanRequestRule(PrincipalMock.Object);
// }
namespace Ombi.Core.Tests.Rule
{
public class CanRequestRuleTests
{
public CanRequestRuleTests()
{
PrincipalMock = new Mock<IPrincipal>();
Rule = new CanRequestRule(PrincipalMock.Object);
}
// private CanRequestRule Rule { get; }
// private Mock<IPrincipal> PrincipalMock { get; }
private CanRequestRule Rule { get; }
private Mock<IPrincipal> PrincipalMock { get; }
// [Fact]
// public async Task Should_ReturnSuccess_WhenRequestingMovieWithMovieRole()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.RequestMovie)).Returns(true);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.Movie };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnSuccess_WhenRequestingMovieWithMovieRole()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.RequestMovie)).Returns(true);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.Movie };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// }
Assert.Equal(result.Success, true);
}
// [Fact]
// public async Task Should_ReturnFail_WhenRequestingMovieWithoutMovieRole()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.RequestMovie)).Returns(false);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.Movie };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnFail_WhenRequestingMovieWithoutMovieRole()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.RequestMovie)).Returns(false);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.Movie };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, false);
// Assert.Equal(string.IsNullOrEmpty(result.Message), false);
// }
Assert.Equal(result.Success, false);
Assert.Equal(string.IsNullOrEmpty(result.Message), false);
}
// [Fact]
// public async Task Should_ReturnSuccess_WhenRequestingMovieWithAdminRole()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.Admin)).Returns(true);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.Movie };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnSuccess_WhenRequestingMovieWithAdminRole()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.Admin)).Returns(true);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.Movie };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// }
Assert.Equal(result.Success, true);
}
// [Fact]
// public async Task Should_ReturnSuccess_WhenRequestingTVWithAdminRole()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.Admin)).Returns(true);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.TvShow };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnSuccess_WhenRequestingTVWithAdminRole()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.Admin)).Returns(true);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.TvShow };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// }
Assert.Equal(result.Success, true);
}
// [Fact]
// public async Task Should_ReturnSuccess_WhenRequestingTVWithTVRole()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.RequestTv)).Returns(true);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.TvShow };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnSuccess_WhenRequestingTVWithTVRole()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.RequestTv)).Returns(true);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.TvShow };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, true);
// }
Assert.Equal(result.Success, true);
}
// [Fact]
// public async Task Should_ReturnFail_WhenRequestingTVWithoutTVRole()
// {
// PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.RequestTv)).Returns(false);
// var request = new BaseRequestModel() { Type = Store.Entities.RequestType.TvShow };
// var result = await Rule.Execute(request);
[Fact]
public async Task Should_ReturnFail_WhenRequestingTVWithoutTVRole()
{
PrincipalMock.Setup(x => x.IsInRole(OmbiClaims.RequestTv)).Returns(false);
var request = new BaseRequest() { RequestType = Store.Entities.RequestType.TvShow };
var result = await Rule.Execute(request);
// Assert.Equal(result.Success, false);
// Assert.Equal(string.IsNullOrEmpty(result.Message), false);
// }
// }
//}
Assert.Equal(result.Success, false);
Assert.Equal(string.IsNullOrEmpty(result.Message), false);
}
}
}

204
src/Ombi.Core.Tests/Rule/Search/ExistingRequestRuleTests.cs
View file

@ -1,110 +1,128 @@
//using System.Collections.Generic;
//using System.Threading.Tasks;
//using Moq;
//using Ombi.Core.Models.Requests;
//using Ombi.Core.Models.Requests.Movie;
//using Ombi.Core.Models.Requests.Tv;
//using Ombi.Core.Models.Search;
//using Ombi.Core.Requests.Models;
//using Ombi.Core.Rule.Rules.Search;
//using Xunit;
using System.Collections.Generic;
using System.Threading.Tasks;
using Moq;
using Ombi.Core.Models.Search;
using Ombi.Core.Rule.Rules.Search;
using Ombi.Store.Entities.Requests;
using Ombi.Store.Repository;
using Ombi.Store.Repository.Requests;
using Xunit;
//namespace Ombi.Core.Tests.Rule.Search
//{
// public class ExistignRequestRuleTests
// {
// public ExistignRequestRuleTests()
// {
// MovieMock = new Mock<IRequestService<MovieRequestModel>>();
// TvMock = new Mock<IRequestService<TvRequestModel>>();
// Rule = new ExistingRequestRule(MovieMock.Object, TvMock.Object);
// }
namespace Ombi.Core.Tests.Rule.Search
{
public class ExistignRequestRuleTests
{
public ExistignRequestRuleTests()
{
MovieMock = new Mock<IMovieRequestRepository>();
TvMock = new Mock<ITvRequestRepository>();
Rule = new ExistingRule(MovieMock.Object, TvMock.Object);
}
// private ExistingRequestRule Rule { get; }
// private Mock<IRequestService<MovieRequestModel>> MovieMock { get; }
// private Mock<IRequestService<TvRequestModel>> TvMock { get; }
private ExistingRule Rule { get; }
private Mock<IMovieRequestRepository> MovieMock { get; }
private Mock<ITvRequestRepository> TvMock { get; }
// [Fact]
// public async Task ShouldBe_Requested_WhenExisitngMovie()
// {
// var list = new List<MovieRequestModel>{new MovieRequestModel
// {
// ProviderId = 123,
// Approved = true
// }};
// MovieMock.Setup(x => x.GetAllAsync()).ReturnsAsync(list);
// var search = new SearchMovieViewModel
// {
// Id = 123,
[Fact]
public async Task ShouldBe_Requested_WhenExisitngMovie()
{
var list = new MovieRequests
{
TheMovieDbId = 123,
Approved = true
};
// };
// var result = await Rule.Execute(search);
MovieMock.Setup(x => x.GetRequest(123)).ReturnsAsync(list);
var search = new SearchMovieViewModel
{
Id = 123,
// Assert.True(result.Success);
// Assert.Equal(search.Approved, true);
// }
};
var result = await Rule.Execute(search);
// [Fact]
// public async Task ShouldBe_NotRequested_WhenNewMovie()
// {
// var list = new List<MovieRequestModel>{new MovieRequestModel
// {
// ProviderId = 123,
// Approved = true
// }};
// MovieMock.Setup(x => x.GetAllAsync()).ReturnsAsync(list);
// var search = new SearchMovieViewModel
// {
// Id = 999,
Assert.True(result.Success);
Assert.Equal(search.Approved, true);
}
// };
// var result = await Rule.Execute(search);
[Fact]
public async Task ShouldBe_NotRequested_WhenNewMovie()
{
var list = new MovieRequests
{
TheMovieDbId = 123,
Approved = true
};
// Assert.True(result.Success);
// Assert.Equal(search.Approved, false);
// }
MovieMock.Setup(x => x.GetRequest(123)).ReturnsAsync(list);
var search = new SearchMovieViewModel
{
Id = 999,
// [Fact]
// public async Task ShouldBe_Requested_WhenExisitngTv()
// {
// var list = new List<TvRequestModel>{new TvRequestModel
// {
// ProviderId = 123,
// Approved = true
// }};
// TvMock.Setup(x => x.GetAllAsync()).ReturnsAsync(list);
// var search = new SearchTvShowViewModel
// {
// Id = 123,
};
var result = await Rule.Execute(search);
// };
// var result = await Rule.Execute(search);
Assert.True(result.Success);
Assert.Equal(search.Approved, false);
}
// Assert.True(result.Success);
// Assert.Equal(search.Approved, true);
// }
[Fact]
public async Task ShouldBe_Requested_WhenExisitngTv()
{
var list = new TvRequests
{
TvDbId = 123,
ChildRequests = new List<ChildRequests>
{
new ChildRequests()
{
Approved = true
// [Fact]
// public async Task ShouldBe_NotRequested_WhenNewTv()
// {
// var list = new List<TvRequestModel>{new TvRequestModel
// {
// ProviderId = 123,
// Approved = true
// }};
// TvMock.Setup(x => x.GetAllAsync()).ReturnsAsync(list);
// var search = new SearchTvShowViewModel()
// {
// Id = 999,
}
}
};
// };
// var result = await Rule.Execute(search);
TvMock.Setup(x => x.GetRequest(123)).ReturnsAsync(list);
var search = new SearchTvShowViewModel
{
Id = 123,
// Assert.True(result.Success);
// Assert.Equal(search.Approved, false);
// }
};
var result = await Rule.Execute(search);
Assert.True(result.Success);
Assert.Equal(search.Approved, true);
}
[Fact]
public async Task ShouldBe_NotRequested_WhenNewTv()
{
var list = new TvRequests
{
TvDbId = 123,
ChildRequests = new List<ChildRequests>
{
new ChildRequests()
{
Approved = true
}
}
};
// }
//}
TvMock.Setup(x => x.GetRequest(123)).ReturnsAsync(list);
var search = new SearchTvShowViewModel()
{
Id = 999,
};
var result = await Rule.Execute(search);
Assert.True(result.Success);
Assert.Equal(search.Approved, false);
}
}
}