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

Request Grid test

Browse source
This commit is contained in:
Jamie.Rees 2017-06-02 15:09:57 +01:00
parent e0018f63fa
commit d5ec429893
24 changed files with 583 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

131
src/Ombi.Core.Tests/Engine/MovieRequestEngineTests.cs Normal file
View file

@ -0,0 +1,131 @@
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.Movie;
using Ombi.Core.Requests.Models;
using Xunit;
namespace Ombi.Core.Tests.Engine
{
public class MovieRequestEngineTests
{
public MovieRequestEngineTests()
{
RequestService = new Mock<IRequestService<MovieRequestModel>>();
var requestService = new RequestService(null, RequestService.Object);
Engine = new MovieRequestEngine(null, requestService, null, null, null);
}
private MovieRequestEngine Engine { get; }
private Mock<IRequestService<MovieRequestModel>> RequestService { get; }
[Fact]
public async Task GetNewRequests_Should_ReturnEmpty_WhenThereAreNoNewRequests()
{
var requests = new List<MovieRequestModel>
{
new MovieRequestModel { Available = true },
new MovieRequestModel { Approved = true },
};
RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
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);
var result = await Engine.GetNewRequests();
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);
var result = await Engine.GetApprovedRequests();
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);
var result = await Engine.GetApprovedRequests();
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);
var result = await Engine.GetAvailableRequests();
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);
var result = await Engine.GetAvailableRequests();
Assert.Equal(result.Count(), 1);
Assert.All(result, x =>
{
Assert.Equal(x.Available, true);
Assert.Equal(x.Approved, false);
});
}
}
}

130
src/Ombi.Core.Tests/Engine/TvRequestEngineTests.cs Normal file
View file

@ -0,0 +1,130 @@
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.Requests.Models;
using Xunit;
namespace Ombi.Core.Tests.Engine
{
public class TvRequestEngineTests
{
public TvRequestEngineTests()
{
RequestService = new Mock<IRequestService<TvRequestModel>>();
var requestService = new RequestService(RequestService.Object, null);
Engine = new TvRequestEngine(null, requestService, null, null, null, null);
}
private TvRequestEngine Engine { get; }
private Mock<IRequestService<TvRequestModel>> 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);
var result = await Engine.GetNewRequests();
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);
var result = await Engine.GetNewRequests();
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<TvRequestModel>
{
new TvRequestModel { Available = true },
};
RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
var result = await Engine.GetApprovedRequests();
Assert.False(result.Any());
}
[Fact]
public async Task GetApprovedRequests_Should_ReturnOnlyApprovedRequests_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.GetApprovedRequests();
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<TvRequestModel>
{
new TvRequestModel { Approved = true },
};
RequestService.Setup(x => x.GetAllAsync()).ReturnsAsync(requests);
var result = await Engine.GetAvailableRequests();
Assert.False(result.Any());
}
[Fact]
public async Task GetAvailableRequests_Should_ReturnOnlyAvailableRequests_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.GetAvailableRequests();
Assert.Equal(result.Count(), 1);
Assert.All(result, x =>
{
Assert.Equal(x.Available, true);
Assert.Equal(x.Approved, false);
});
}
}
}

8
src/Ombi.Core.Tests/Rule/AutoApproveRuleTests.cs
View file

@ -1,11 +1,11 @@
using Ombi.Core.Rule.Rules;
using Xunit;
using System.Security.Principal;
using Moq;
using Ombi.Core.Models.Requests;
using Ombi.Core.Claims;
using Ombi.Core.Models.Requests;
using Ombi.Core.Rule.Rules;
using Xunit;
namespace Ombi.Core.Tests
namespace Ombi.Core.Tests.Rule
{
public class AutoApproveRuleTests
{

8
src/Ombi.Core.Tests/Rule/CanRequestRuleTests.cs
View file

@ -1,11 +1,11 @@
using Ombi.Core.Rule.Rules;
using Xunit;
using System.Security.Principal;
using Moq;
using Ombi.Core.Models.Requests;
using Ombi.Core.Claims;
using Ombi.Core.Models.Requests;
using Ombi.Core.Rule.Rules;
using Xunit;
namespace Ombi.Core.Tests
namespace Ombi.Core.Tests.Rule
{
public class CanRequestRuleTests
{