public void Bet_lost_increases_wagering_completed()
{
MakeDeposit(PlayerId);
PlaceAndLoseBet(27, PlayerId);
BonusRedemptions.First().Contributions.SingleOrDefault(c => c.Contribution == 27).Should().NotBeNull();
}
public void All_contribution_are_calculated_as_100_percents_when_no_game_to_rollover_contributions_defined()
{
MakeDeposit(PlayerId);
PlaceAndLoseBet(27, PlayerId);
BonusRedemptions.First().Contributions.SingleOrDefault(c => c.Contribution == 27).Should().NotBeNull();
}
public void Qualification_runs_before_rollover_is_issued_for_AfterWager_bonus()
{
MakeDeposit(PlayerId);
var excludedReloadedDeposit = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
excludedReloadedDeposit.Template.Info.TemplateType = BonusType.ReloadDeposit;
var reloadDepositWithExclude = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
reloadDepositWithExclude.Template.Info.TemplateType = BonusType.ReloadDeposit;
reloadDepositWithExclude.Template.Wagering.HasWagering = true;
reloadDepositWithExclude.Template.Wagering.IsAfterWager = true;
reloadDepositWithExclude.Template.Wagering.Multiplier = 1;
reloadDepositWithExclude.Template.Availability.ExcludeBonuses.Add(new BonusExclude {
ExcludedBonusId = excludedReloadedDeposit.Id
});
reloadDepositWithExclude.Template.Availability.ExcludeOperation = Operation.Any;
var depositId = Guid.NewGuid();
BonusCommands.ApplyForBonus(new DepositBonusApplication
{
PlayerId = PlayerId,
Amount = 200,
DepositId = depositId,
BonusCode = reloadDepositWithExclude.Code
});
MakeDeposit(PlayerId, 200, excludedReloadedDeposit.Code);
ApproveDeposit(depositId, PlayerId, 200);
BonusRedemptions.First().ActivationState.Should().Be(ActivationStatus.Negated);
}
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 void Fundin_ManualByPlayer_bonus_rollover_is_calculated()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
var brandWalletId = bonus.Template.Info.Brand.WalletTemplates.First().Id;
bonus.Template.Info.TemplateType = BonusType.FundIn;
bonus.Template.Rules.FundInWallets = new List <BonusFundInWallet>
{
new BonusFundInWallet {
WalletId = brandWalletId
}
};
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.Method = WageringMethod.TransferAmount;
bonus.Template.Wagering.Multiplier = 2;
//depositing funds to use them for fund in
MakeDeposit(PlayerId);
MakeFundIn(PlayerId, brandWalletId, 100, bonusId: bonus.Id);
var bonusRedemption = BonusRedemptions.First();
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption.Rollover.Should().Be(200);
}
public void Placing_a_bet_does_not_change_wagering_completed()
{
MakeDeposit(PlayerId);
PlaceBet(27, PlayerId, Guid.NewGuid(), Guid.NewGuid());
BonusRedemptions.First().Contributions.Should().BeEmpty();
}
public void Qualification_runs_after_rollover_fulfillment_for_AfterWager_bonus()
{
var reloadBonus = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
reloadBonus.Template.Info.TemplateType = BonusType.ReloadDeposit;
var firstDeposit = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
firstDeposit.Template.Info.TemplateType = BonusType.FirstDeposit;
firstDeposit.Template.Wagering.HasWagering = true;
firstDeposit.Template.Wagering.IsAfterWager = true;
firstDeposit.Template.Wagering.Multiplier = 1;
firstDeposit.Template.Availability.ExcludeBonuses.Add(new BonusExclude {
ExcludedBonusId = reloadBonus.Id
});
firstDeposit.Template.Availability.ExcludeOperation = Operation.Any;
MakeDeposit(PlayerId, 200, firstDeposit.Code);
MakeDeposit(PlayerId, 200, reloadBonus.Code);
var walletQueriesMock = new Mock <IBrandOperations>();
walletQueriesMock.Setup(queries => queries.GetPlayerBalance(It.IsAny <Guid>(), It.IsAny <string>())).Returns(10m);
Container.RegisterInstance(walletQueriesMock.Object);
PlaceAndWinBet(50, 100, PlayerId);
BonusRedemptions.First().ActivationState.Should().Be(ActivationStatus.Negated);
}
public void Bonus_redemption_without_rollover_has_None_rollover_status_after_activation()
{
_bonus.Template.Wagering.HasWagering = false;
MakeDeposit(PlayerId);
Assert.AreEqual(RolloverStatus.None, BonusRedemptions.First().RolloverState);
}
public void System_activates_Automatic_mode_bonus_redemption()
{
CreateFirstDepositBonus();
MakeDeposit(PlayerId);
BonusRedemptions.First().ActivationState.Should().Be(ActivationStatus.Activated);
}
public void System_activates_AutomaticWithBonusCode_mode_bonus_redemption()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
MakeDeposit(PlayerId, bonusCode: bonus.Code);
BonusRedemptions.First().ActivationState.Should().Be(ActivationStatus.Activated);
}
public void Player_redeems_ManualByPlayer_deposit_bonus()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
MakeDeposit(PlayerId, bonusId: bonus.Id);
BonusRedemptions.Count.Should().Be(1);
BonusRedemptions.First().Bonus.Id.Should().Be(bonus.Id);
}
public void Player_redeems_AutomaticWithBonusCode_deposit_bonus()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
MakeDeposit(PlayerId, bonusCode: bonus.Code);
BonusRedemptions.Count.Should().Be(1);
BonusRedemptions.First().Bonus.Id.Should().Be(bonus.Id);
}
public void Cancel_of_deposit_negates_related_bonus_redemption()
{
CreateFirstDepositBonus();
var depositId = SubmitDeposit(PlayerId, 100);
UnverifyDeposit(depositId, PlayerId);
BonusRedemptions.First().ActivationState.Should().Be(ActivationStatus.Negated);
}
public void Can_receive_flat_amount_fund_in_bonus()
{
//depositing funds to use them for fund in
MakeDeposit(PlayerId);
MakeFundIn(PlayerId, _brandWalletId, 100);
var bonusRedemption = BonusRedemptions.First();
Assert.AreEqual(ActivationStatus.Activated, bonusRedemption.ActivationState);
Assert.AreEqual(_bonus.Template.Rules.RewardTiers.Single().BonusTiers.Single().Reward, bonusRedemption.Amount);
}
public decimal Deposit_bonus_lock_amount_is_correct(bool isAfterWager)
{
var bonus = CreateFirstDepositBonus();
bonus.Template.Info.TemplateType = BonusType.FirstDeposit;
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.IsAfterWager = isAfterWager;
MakeDeposit(PlayerId);
return(BonusRedemptions.First().LockedAmount);
}
public void Contribution_is_calculated_as_100_percents_for_game_that_is_not_on_GameContributions_list()
{
_bonus.Template.Wagering.GameContributions.Add(new GameContribution
{
Contribution = 0.5m,
GameId = Guid.NewGuid()
});
MakeDeposit(PlayerId);
PlaceAndLoseBet(27, PlayerId);
BonusRedemptions.First().Contributions.SingleOrDefault(c => c.Contribution == 27).Should().NotBeNull();
}
public void Pending_deposit_bonus_redemption_is_negated_if_deposit_amount_became_unqualified()
{
var bonus = CreateFirstDepositBonus();
bonus.Template.Rules.RewardTiers.Single().BonusTiers.Single().From = 150;
var depositId = SubmitDeposit(PlayerId, 200);
ApproveDeposit(depositId, PlayerId, 100);
BonusRedemptions.First().ActivationState.Should().Be(ActivationStatus.Negated);
}
public void Percentage_bonus_reward_is_limited_by_transaction_limit()
{
const decimal limit = 50m;
var bonus = CreateFirstDepositBonus();
bonus.Template.Rules.RewardType = BonusRewardType.Percentage;
bonus.Template.Rules.RewardTiers.Single().Tiers.Single().Reward = 0.5m;
bonus.Template.Rules.RewardTiers.Single().Tiers.Single().MaxAmount = limit;
MakeDeposit(PlayerId, 1000);
Assert.AreEqual(limit, BonusRedemptions.First().Amount);
}
public decimal Bonus_rollover_is_calculated_correctly(WageringMethod method)
{
var bonus = CreateFirstDepositBonus();
bonus.Template.Info.IsWithdrawable = true;
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.Method = method;
bonus.Template.Wagering.Multiplier = 2;
MakeDeposit(PlayerId);
return(BonusRedemptions.First().Rollover);
}
public void Bonus_cancellation_sets_rollover_status_to_None()
{
MakeDeposit(PlayerId);
var bonusRedemption = BonusRedemptions.First();
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
};
BonusCommands.CancelBonusRedemption(model);
Assert.AreEqual(RolloverStatus.None, bonusRedemption.RolloverState);
}
public void Meeting_wagering_threshold_completes_wagering()
{
_bonus.Template.Wagering.Threshold = 200;
MakeDeposit(PlayerId);
PlaceAndLoseBet(100, PlayerId);
var bonusRedemption = BonusRedemptions.First();
bonusRedemption.RolloverState.Should().Be(RolloverStatus.ZeroedOut);
var thresholdContribution = bonusRedemption.Contributions.ElementAt(1);
thresholdContribution.Type.Should().Be(ContributionType.Threshold);
thresholdContribution.Contribution.Should().Be(200);
}
public void Can_redeem_deposit_bonus_with_matched_fixed_amount_specific_rules(int depositAmount,
int expectedRedemptionAmount)
{
var bonus = CreateBonusWithBonusTiers(BonusRewardType.TieredAmount);
MakeDeposit(PlayerId, depositAmount);
var bonusRedemption = BonusRedemptions.First();
Assert.AreEqual(PlayerId, bonusRedemption.Player.Id);
Assert.AreEqual(bonus.Id, bonusRedemption.Bonus.Id);
Assert.AreEqual(ActivationStatus.Activated, bonusRedemption.ActivationState);
Assert.AreEqual(expectedRedemptionAmount, bonusRedemption.Amount);
}
public void Bonus_cancellation_sets_activation_status_to_Cancelled()
{
MakeDeposit(PlayerId);
var bonusRedemption = BonusRedemptions.First();
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
};
BonusCommands.CancelBonusRedemption(model);
Assert.AreEqual(ActivationStatus.Canceled, bonusRedemption.ActivationState);
}
public void Bonus_redemtion_amount_is_recalculated_if_deposit_amount_changes()
{
var bonus = CreateFirstDepositBonus();
bonus.Template.Rules.RewardType = BonusRewardType.Percentage;
bonus.Template.Rules.RewardTiers.Single().BonusTiers.Single().Reward = 0.5m;
var depositId = SubmitDeposit(PlayerId);
ApproveDeposit(depositId, PlayerId, 100);
BonusRedemptions.First().Amount.Should().Be(50);
bonus.Statistic.TotalRedeemedAmount.Should().Be(50);
}
public void System_redeems_Automatic_mode_deposit_bonus()
{
var bonus1 = CreateFirstDepositBonus();
//bonus #2
CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
//bonus #3
CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
MakeDeposit(PlayerId);
BonusRedemptions.Count.Should().Be(1);
BonusRedemptions.First().Bonus.Id.Should().Be(bonus1.Id);
}
public void Wagering_completed_sets_rollover_status_to_Completed()
{
_bonus.IsActive = false;
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.AutomaticWithCode);
bonus.Template.Info.IsWithdrawable = true;
bonus.Template.Wagering.HasWagering = true;
bonus.Template.Wagering.Method = WageringMethod.Bonus;
bonus.Template.Wagering.Multiplier = 1;
MakeDeposit(PlayerId, bonusCode: bonus.Code);
PlaceAndLoseBet(27, PlayerId);
Assert.AreEqual(RolloverStatus.Completed, BonusRedemptions.First(br => br.Rollover == 27).RolloverState);
}
public void Bonus_cancellation_releases_bonus_lock()
{
MakeDeposit(PlayerId, 300);
var model = new CancelBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = BonusRedemptions.First().Id
};
BonusCommands.CancelBonusRedemption(model);
_wallet.Locks.Count(tr => tr.UnlockedOn.HasValue)
.Should()
.Be(2, "Unlock of deposit, bonus amount");
}
public void Per_player_bonus_issuance_limit_qualification_is_processed_during_activation()
{
MakeDeposit(PlayerId);
var bonus = CreateFirstDepositBonus();
bonus.Template.Availability.PlayerRedemptionsLimit = 1;
bonus.Template.Info.TemplateType = BonusType.ReloadDeposit;
var depositId = SubmitDeposit(PlayerId);
MakeDeposit(PlayerId);
ApproveDeposit(depositId, PlayerId, 200);
BonusRedemptions.First().ActivationState.Should().Be(ActivationStatus.Negated);
}
public void Player_should_activate_ManualByPlayer_mode_bonus_redemption()
{
var bonus = CreateFirstDepositBonus(mode: IssuanceMode.ManualByPlayer);
MakeDeposit(PlayerId, bonusId: bonus.Id);
var bonusRedemption = BonusRedemptions.First();
BonusCommands.ClaimBonusRedemption(new ClaimBonusRedemption
{
PlayerId = PlayerId,
RedemptionId = bonusRedemption.Id
});
bonusRedemption.ActivationState.Should().Be(ActivationStatus.Activated);
}
public void FreeBet_increases_wagering_completed()
{
MakeDeposit(PlayerId);
var gameId = Guid.NewGuid();
var roundId = Guid.NewGuid();
ServiceBus.PublishMessage(new BetPlacedFree
{
PlayerId = PlayerId,
Amount = 27,
GameId = gameId,
RoundId = roundId,
Turnover = 27
});
BonusRedemptions.First().Contributions.SingleOrDefault(c => c.Contribution == 27).Should().NotBeNull();
}
