github/Ombi
1
0
Fork 0
mirror of https://github.com/Ombi-app/Ombi.git synced 2025-08-19 12:59:39 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

test(request-limits): ✅ Added tests for the new RequestLimitRules

Browse source
This commit is contained in:
tidusjar 2021-09-22 22:36:23 +01:00
commit 1ba054e439
1 changed files with 258 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

258
src/Ombi.Core.Tests/Rule/Request/RequestLimitRuleTests.cs Normal file
View file

@ -0,0 +1,258 @@
using Moq;
using Moq.AutoMock;
using NUnit.Framework;
using Ombi.Core.Rule;
using Ombi.Core.Rule.Rules.Request;
using Ombi.Core.Services;
using Ombi.Store.Entities;
using Ombi.Store.Entities.Requests;
using Ombi.Store.Repository.Requests;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Ombi.Core.Tests.Rule.Request
{
[TestFixture]
public class RequestLimitRuleTests
{
private AutoMocker _mocker;
private RequestLimitRule _subject;
[SetUp]
public void SetUp()
{
_mocker = new AutoMocker();
_subject = _mocker.CreateInstance<RequestLimitRule>();
}
[Test]
public async Task MovieRule_No_Limit()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingMovieRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = false
});
var result = await _subject.Execute(new Store.Entities.Requests.BaseRequest
{
RequestType = RequestType.Movie
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(true));
}
[Test]
public async Task MovieRule_Limit_NotReached()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingMovieRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = true,
Limit = 2,
Remaining = 1
});
var result = await _subject.Execute(new Store.Entities.Requests.BaseRequest
{
RequestType = RequestType.Movie
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(true));
}
[Test]
public async Task MovieRule_Limit_Reached()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingMovieRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = true,
Limit = 1,
Remaining = 0
});
var result = await _subject.Execute(new Store.Entities.Requests.BaseRequest
{
RequestType = RequestType.Movie
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(false));
}
[Test]
public async Task MusicRule_No_Limit()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingMusicRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = false
});
var result = await _subject.Execute(new Store.Entities.Requests.BaseRequest
{
RequestType = RequestType.Album
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(true));
}
[Test]
public async Task MusicRule_Limit_NotReached()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingMusicRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = true,
Limit = 2,
Remaining = 1
});
var result = await _subject.Execute(new Store.Entities.Requests.BaseRequest
{
RequestType = RequestType.Album
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(true));
}
[Test]
public async Task MusicRule_Limit_Reached()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingMusicRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = true,
Limit = 1,
Remaining = 0
});
var result = await _subject.Execute(new Store.Entities.Requests.BaseRequest
{
RequestType = RequestType.Album
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(false));
}
[Test]
public async Task TvRule_No_Limit()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingTvRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = false
});
var result = await _subject.Execute(new Store.Entities.Requests.BaseRequest
{
RequestType = RequestType.TvShow
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(true));
}
[Test]
public async Task TvRule_Limit_NotReached()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingTvRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = true,
Limit = 2,
Remaining = 1
});
var result = await _subject.Execute(new ChildRequests
{
RequestType = RequestType.TvShow,
SeasonRequests = new List<SeasonRequests>
{
new SeasonRequests
{
Episodes = new List<EpisodeRequests>
{
new EpisodeRequests()
}
}
}
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(true));
}
[Test]
public async Task TvRule_Limit_Reached()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingTvRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = true,
Limit = 1,
Remaining = 0
});
var result = await _subject.Execute(new ChildRequests
{
RequestType = RequestType.TvShow,
SeasonRequests = new List<SeasonRequests>
{
new SeasonRequests
{
Episodes = new List<EpisodeRequests>
{
new EpisodeRequests()
}
}
}
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(false));
}
[Test]
public async Task TvRule_Limit_Reached_ManyEpisodes()
{
var limitService = _mocker.GetMock<IRequestLimitService>();
limitService.Setup(x => x.GetRemainingTvRequests(It.IsAny<OmbiUser>())).ReturnsAsync(new Models.RequestQuotaCountModel
{
HasLimit = true,
Limit = 1,
Remaining = 5
});
var result = await _subject.Execute(new ChildRequests
{
RequestType = RequestType.TvShow,
SeasonRequests = new List<SeasonRequests>
{
new SeasonRequests
{
Episodes = new List<EpisodeRequests>
{
new EpisodeRequests(),
new EpisodeRequests(),
new EpisodeRequests(),
}
},
new SeasonRequests
{
Episodes = new List<EpisodeRequests>
{
new EpisodeRequests(),
new EpisodeRequests(),
new EpisodeRequests(),
}
}
}
});
Assert.That(result, Is.InstanceOf<RuleResult>().With.Property(nameof(RuleResult.Success)).EqualTo(false));
}
}
}