public TemplateValidator(IBonusRepository repository, BonusQueries queries)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
_infoGetter = template => repository.Templates.Single(t => t.Id == template.Id && t.Version == template.Version).Info;
_brandGetter = template => template.Info == null?_infoGetter(template).Brand : repository.Brands.SingleOrDefault(b => b.Id == template.Info.BrandId);
When(template => template.Id != Guid.Empty, () =>
{
Func <CreateUpdateTemplate, Template> templateGetter =
vm => queries.GetCurrentVersionTemplates().SingleOrDefault(t => t.Id == vm.Id);
RuleFor(template => template)
.Must(template => templateGetter(template) != null)
.WithMessage(ValidatorMessages.TemplateDoesNotExist)
.Must(template => templateGetter(template).Version == template.Version)
.WithMessage(ValidatorMessages.TemplateVersionIsNotCurrent)
.Must(template => queries.GetBonusesUsingTemplate(templateGetter(template)).Any(bonus => bonus.IsActive) == false)
.WithMessage(ValidatorMessages.AllBonusesShouldBeInactive)
.When(template => templateGetter(template).Status == TemplateStatus.Complete, ApplyConditionTo.CurrentValidator)
.WithName("Template")
.DependentRules(rules =>
{
When(template => template.Availability != null, () => ValidateAvailability(repository));
When(template => template.Rules != null, ValidateRules);
When(template => template.Wagering != null, () => ValidateWagering(repository));
});
});
When(template => template.Info != null, () => ValidateInfo(repository));
}
public void Unknown_gameId_in_wagering_contribution_isnt_valid()
{
var gameId = Guid.NewGuid();
BonusRepository.Games.Add(new Game());
BonusRepository.Games.Add(new Game {
Id = gameId
});
_model.Wagering = new CreateUpdateTemplateWagering
{
GameContributions = new List <CreateUpdateGameContribution>
{
new CreateUpdateGameContribution
{
GameId = gameId,
Contribution = 0
},
new CreateUpdateGameContribution
{
GameId = new Guid(),
Contribution = 1
}
}
};
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.TemplateOneOfGameContributionsPointsToInvalidGame, message);
}
public IssueBonusController(
BonusCommands bonusCommands,
BonusQueries bonusQueries)
{
_bonusCommands = bonusCommands;
_bonusQueries = bonusQueries;
}
public BonusController(
BonusManagementCommands bonusCommands,
BonusQueries bonusQueries)
{
_bonusCommands = bonusCommands;
_bonusQueries = bonusQueries;
}
public bool Status_of_bonus_redemption_is_validated_during_cancellation(RolloverStatus status)
{
var bonus = CreateFirstDepositBonus();
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.Multiplier = 3m;
MakeDeposit(PlayerId);
var bonusRedemption = BonusRedemptions.First();
bonusRedemption.RolloverState = status;
var validationResult = BonusQueries.GetValidationResult(new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
if (validationResult.IsValid == false)
{
validationResult.Errors.Single().ErrorMessage.Should().Be(ValidatorMessages.BonusRedemptionStatusIsIncorrectForCancellation);
}
return(validationResult.IsValid);
}
public override void BeforeEach()
{
base.BeforeEach();
_bonusQueries = Container.Resolve <BonusQueries>();
_bonusManagementCommands = Container.Resolve <BonusManagementCommands>();
}
public void Can_not_update_non_existing_bonus()
{
_model.Id = Guid.NewGuid();
var validationResult = BonusQueries.GetValidationResult(_model);
Assert.AreEqual(ValidatorMessages.BonusDoesNotExist, validationResult.Errors.Single().ErrorMessage);
}
public void Can_not_change_status_of_non_existent_bonus()
{
var result = BonusQueries.GetValidationResult(new ToggleBonusStatus {
Id = Guid.Empty, IsActive = true
});
result.Errors.Single().ErrorMessage.Should().Be(ValidatorMessages.BonusDoesNotExist);
}
public void Player_does_not_exist_validation()
{
var validationResult = BonusQueries.GetValidationResult(new CancelBonusRedemption {
PlayerId = Guid.NewGuid(), RedemptionId = Guid.NewGuid()
});
validationResult.Errors.Single().ErrorMessage.Should().Be(ValidatorMessages.PlayerDoesNotExist);
}
public void All_bonuses_are_qualified_if_no_exclude_bonuses_are_selected()
{
BonusQueries
.GetDepositQualifiedBonuses(PlayerId)
.Count()
.Should()
.Be(3);
}
public void Can_not_update_non_existing_template()
{
_model.Id = Guid.NewGuid();
var validationResult = BonusQueries.GetValidationResult(_model);
Assert.AreEqual(1, validationResult.Errors.Count(e => e.ErrorMessage == ValidatorMessages.TemplateDoesNotExist));
}
public void Can_not_cancel_a_non_existent_bonus()
{
var validationResult = BonusQueries.GetValidationResult(new CancelBonusRedemption {
PlayerId = PlayerId, RedemptionId = Guid.NewGuid()
});
validationResult.Errors.Single().ErrorMessage.Should().Be(ValidatorMessages.BonusRedemptionDoesNotExist);
}
public void Bonus_does_not_exist()
{
var result = BonusQueries.GetValidationResult(new IssueBonusByCs {
PlayerId = PlayerId
});
result.Errors.Single().ErrorMessage.Should().Be(ValidatorMessages.BonusDoesNotExist);
}
public void Player_does_not_exist()
{
var result = BonusQueries.GetValidationResult(new FundInBonusApplication
{
PlayerId = Guid.NewGuid()
});
result.Errors.Single().ErrorMessage.Should().Be(ValidatorMessages.PlayerDoesNotExist);
}
public void Can_not_update_not_current_version_template()
{
_model.Info = _info;
_template.Version = 1000;
var validationResult = BonusQueries.GetValidationResult(_model);
Assert.AreEqual(1, validationResult.Errors.Count(e => e.ErrorMessage == ValidatorMessages.TemplateVersionIsNotCurrent));
}
public void Days_to_claim_cant_be_negative()
{
_model.DaysToClaim = -1;
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.BonusDaysToClaimIsNegative, message);
}
public void Activity_dates_should_form_range()
{
_model.ActiveFrom = DateTimeOffset.Now.ToBrandOffset(_brandTimezoneId).AddDays(2).Date;
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.BonusActivityRangeIsInvalid, message);
}
public BonusHistoryController(
BonusCommands bonusCommands,
BonusQueries bonusQueries,
IEventRepository eventRepository)
{
_bonusCommands = bonusCommands;
_bonusQueries = bonusQueries;
_eventRepository = eventRepository;
}
public void Name_is_required_validation_works()
{
_model.Name = null;
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.NameIsNotSpecified, message);
}
public void Qualified_bonuses_list_does_not_contain_inactive_bonuses()
{
CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode, isActive: false);
BonusQueries.GetDepositQualifiedBonuses(PlayerId)
.ToList()
.Should()
.BeEmpty();
}
public void Bonus_is_not_qualified_if_ANY_of_excluded_bonuses_were_redeemed()
{
MakeDeposit(PlayerId, bonusCode: _excludedBonus1.Code);
BonusQueries.GetDepositQualifiedBonuses(PlayerId)
.ToList()
.Should()
.NotContain(qualifiedBonus => qualifiedBonus.Name == _bonus.Name);
}
public void Template_does_not_exist_validation_works()
{
_model.TemplateId = Guid.NewGuid();
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.BonusTemplateIsNotAssigned, message);
}
public void Code_cant_contain_special_characters()
{
_model.Code = "Foo Bar$";
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.BonusCodeIsInvalid, message);
}
public void Zero_length_duration_validation_works()
{
_model.DurationType = DurationType.StartDateBased;
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.BonusDurationIsZeroLength, message);
}
public void Transaction_does_not_exist()
{
var bonus = CreateFirstDepositBonus();
var result = BonusQueries.GetValidationResult(new IssueBonusByCs {
BonusId = bonus.Id, PlayerId = PlayerId
});
result.Errors.Single().ErrorMessage.Should().Be(ValidatorMessages.TransactionDoesNotExist);
}
public void Name_cant_be_empty()
{
_info.Name = string.Empty;
_model.Info = _info;
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.NameIsNotSpecified, message);
}
public void Fund_in_no_wallets_validation_works()
{
_template.Info.TemplateType = BonusType.FundIn;
_model.Rules = _rules;
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.TemplateNoFundInWallets, message);
}
public void Template_should_have_receiving_wallet()
{
_info.WalletTemplateId = Guid.Empty;
_model.Info = _info;
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.TemplateReceivingWalletIsNotSpecified, message);
}
public void Template_should_have_receiving_wallet_that_is_brand_related()
{
_info.WalletTemplateId = Guid.NewGuid();
_model.Info = _info;
var validationResult = BonusQueries.GetValidationResult(_model);
var message = validationResult.Errors.Single().ErrorMessage;
Assert.AreEqual(ValidatorMessages.TemplateReceivingWalletIsInvalid, message);
}
public void ManualByCs_bonus_is_qualified_during_manual_issuance()
{
MakeDeposit(PlayerId);
CreateFirstDepositBonus(mode: IssuanceMode.ManualByCs);
BonusQueries.GetManualByCsQualifiedBonuses(PlayerId)
.ToList()
.Should()
.NotBeEmpty();
}
