public async Task UserDepositItemsSuccess()
{
_offerMinmalInfo.OfferSend.SteamOffer.ItemsToGive.Clear();
var offerTransInsertWithId = new DatabaseModel.OfferTransaction(1, 14, new decimal(196.91), true, "12345", DateTime.Today, 75);
var userInsertRes = new DatabaseModel.User("userSteamId", "name", "img", "tradeLink", DateTime.Today, DateTime.Today, false, null, 1);
A.CallTo(() => _fakedUserRepoService.FindAsync("userSteamId")).Returns(userInsertRes);
var botLookRes = Task.FromResult(new DatabaseModel.Bot("botSteamId", "botName", 14));
A.CallTo(() => _fakedBotRepoService.FindAsync("botSteamId")).Returns(botLookRes);
A.CallTo(() => _fakedOfferTranascrionRepoService.InsertAsync(A <DatabaseModel.OfferTransaction> .That.Matches(o =>
o.IsDeposit && o.Accepted > DateTime.Today && o.BotId == 14 && o.UserId == 1 && o.Id == 0 && o.TotalValue == new decimal(196.91)
), A <ITransactionWrapper> ._)).Returns(offerTransInsertWithId);
await _offerService.DepositSteamOfferAsync(_offerMinmalInfo);
A.CallTo(() => _fakedOfferTranascrionRepoService.InsertAsync(A <DatabaseModel.OfferTransaction> .That.Matches(o =>
o.IsDeposit && o.Accepted > DateTime.Today && o.BotId == 14 && o.UserId == 1 && o.Id == 0 && o.TotalValue == new decimal(196.91)
), A <ITransactionWrapper> ._)).MustHaveHappened();
A.CallTo(() => _fakedItemInOfferTransactionRepoService.InsertAsync(A <List <DatabaseModel.ItemInOfferTransaction> > .That.Matches(i =>
i.Where(o => o.OfferTransactionId == 75 && o.ItemDescriptionId == 1 && o.Value == new decimal(11.22)).ToList().Count == 2 &&
i.Where(o => o.OfferTransactionId == 75 && o.ItemDescriptionId == 3 && o.Value == new decimal(78.00)).ToList().Count == 1 &&
i.Where(o => o.OfferTransactionId == 75 && o.ItemDescriptionId == 4 && o.Value == new decimal(5.47)).ToList().Count == 1 &&
i.Where(o => o.OfferTransactionId == 75 && o.ItemDescriptionId == 2 && o.Value == new decimal(45.5)).ToList().Count == 2
), A <ITransactionWrapper> ._)).MustHaveHappened();
A.CallTo(() => _fakedTransactionWrapper.Commit()).MustHaveHappened();
}
public async Task CreateMatchFailDueToNoItemsPlaced()
{
var percentage = 12.4587;
var percentageAsString = percentage.ToString(CultureInfo.InvariantCulture);
var salt = "randomSalt";
var hash = "ranomdHash";
var creatorUser = new DatabaseModel.User("steamId", "name", "imageURl", null, DateTime.Today, DateTime.Today, false, null, 10);
var gameMode = new DatabaseModel.GameMode
{
CurrentSettingId = 1,
IsEnabled = true,
Type = GameModeHelper.GetStringFromType(GameModeType.CoinFlip),
Id = 2
};
A.CallTo(() => _fakedRandomService.GeneratePercentage()).Returns(percentageAsString);
A.CallTo(() => _fakedRandomService.GenerateSalt()).Returns(salt);
A.CallTo(() => _fakedHashService.CreateBase64Sha512Hash(percentageAsString, salt)).Returns(hash);
A.CallTo(() => _fakedUserRepoService.FindAsync(creatorUser.SteamId)).Returns(creatorUser);
A.CallTo(() => _fakedGameModeRepoSerivce.Find(GameModeHelper.GetStringFromType(GameModeType.CoinFlip))).Returns(gameMode);
var itemList = new List <AssetAndDescriptionId>();
await Assert.ThrowsAsync <InvalidBetException>(async() =>
await _coinFlipService.CreateMatch(creatorUser.SteamId, true, itemList, _defaultSetting));
A.CallTo(() => _fakedCoinFlipMatchRepoService.InsertAsync(A <DatabaseModel.CoinFlip> ._, A <ITransactionWrapper> ._)).MustNotHaveHappened();
A.CallTo(() => _fakedUserRepoService.FindAsync(creatorUser.SteamId)).MustHaveHappened();
}
public SteamServiceTest()
{
var host = "testHost";
var port = 8080;
_realUser = new DatabaseModel.User("realUserSteamud", "realUser", "realImg", "myTradelink", DateTime.Now, DateTime.Now, false, null, 10);
_scammerUser = new DatabaseModel.User("scammerUserSteamud", "scamerUser", "fakeImg", "myTradelink1", DateTime.Now, DateTime.Now, false,
null, 20);
_realUsersItems = new List <DatabaseModel.Item>();
_scammerUsersItems = new List <DatabaseModel.Item>();
_fakedGrpcServiceFactory = A.Fake <IGrpcServiceFactory>();
_fakedBotService = A.Fake <IBotService>();
_fakeRepoServiceFacotry = A.Fake <IRepoServiceFactory>();
_fakedSteamServiceClient = A.Fake <ISteamServiceClientWrapper>();
_fakedUserRepoService = A.Fake <IUserRepoService>();
_fakedItemRepoService = A.Fake <IItemRepoService>();
_fakedItemDescRepoService = A.Fake <IItemDescriptionRepoService>();
_fakedSettingsRepoService = A.Fake <ISettingRepoService>();
_fakedOfferTransactionRepoService = A.Fake <IOfferTranascrionRepoService>();
_fakedOfferService = A.Fake <IOfferService>();
A.CallTo(() => _fakeRepoServiceFacotry.UserRepoService).Returns(_fakedUserRepoService);
A.CallTo(() => _fakeRepoServiceFacotry.ItemRepoService).Returns(_fakedItemRepoService);
A.CallTo(() => _fakeRepoServiceFacotry.SettingRepoService).Returns(_fakedSettingsRepoService);
A.CallTo(() => _fakeRepoServiceFacotry.ItemDescriptionRepoService).Returns(_fakedItemDescRepoService);
A.CallTo(() => _fakeRepoServiceFacotry.OfferTranascrionRepoService).Returns(_fakedOfferTransactionRepoService);
A.CallTo(() => _fakedUserRepoService.FindAsync("scammerUserSteamud")).Returns(_scammerUser);
A.CallTo(() => _fakedUserRepoService.FindAsync("realUserSteamud")).Returns(_realUser);
A.CallTo(() => _fakedItemRepoService.FindAsync(A <DatabaseModel.User> .That.Matches(user => user.Id == _realUser.Id)))
.Returns(_realUsersItems);
A.CallTo(() => _fakedItemRepoService.FindAsync(A <DatabaseModel.User> .That.Matches(user => user.Id == _scammerUser.Id)))
.Returns(_scammerUsersItems);
A.CallTo(() => _fakedGrpcServiceFactory.GetSteamServiceClient(A <ISteamInventoryCacheManager> ._)).Returns(_fakedSteamServiceClient);
_steamService = new SteamService(
_fakedGrpcServiceFactory,
_fakeRepoServiceFacotry,
_fakedBotService,
A.Dummy <ILogServiceFactory>(),
_fakedOfferService,
A.Dummy <ISteamInventoryCacheManager>()
);
}
public async void TransferItemsSuccess()
{
var fromUser = new DatabaseModel.User
{
Id = 1
};
var toSteamId = "toSteamId";
var itemsToTransfer = new List <AssetAndDescriptionId>
{
new AssetAndDescriptionId {
AssetId = "assetId1", DescriptionId = 1
},
new AssetAndDescriptionId {
AssetId = "assetId3", DescriptionId = 1
},
new AssetAndDescriptionId {
AssetId = "assetId4", DescriptionId = 5
},
new AssetAndDescriptionId {
AssetId = "assetId8", DescriptionId = 5
},
};
A.CallTo(() => _fakedItemService.GetAvalibleItemsForUser(A <DatabaseModel.User> ._)).Returns(new List <Item>
{
new Item {
AssetId = "assetId1", DescriptionId = 1, Id = 1
},
new Item {
AssetId = "assetId2", DescriptionId = 1, Id = 2
},
new Item {
AssetId = "assetId3", DescriptionId = 1, Id = 3
},
new Item {
AssetId = "assetId4", DescriptionId = 5, Id = 4
},
new Item {
AssetId = "assetId8", DescriptionId = 5, Id = 5
},
});
A.CallTo(() => _fakedUserRepoService.FindAsync(A <string> ._)).Returns(new DatabaseModel.User {
Id = 1
});
var itemTransferService = new ItemTransferService(_fakedRepoService, _fakedItemService);
var res = await itemTransferService.TransferItemsAsync(fromUser, toSteamId, itemsToTransfer);
Assert.True(res);
A.CallTo(() => _fakedRepoService.ItemRepoService.ChangeOwner(
A <List <int> > .That.Matches(i => i.Contains(1) && i.Contains(3) && i.Contains(4) && i.Contains(5)),
A <DatabaseModel.User> .That.Matches(u => u.Id == 1))
).MustHaveHappened();
}
private async Task <OfferData> CreateOfferData(OfferStatusRequest request, bool isDeposit)
{
var bot = await _botRepoService.FindAsync(request.Bot.SteamId);
var owner = await _userRepoService.FindAsync(request.SteamId);
var itemsInOfferRequest = isDeposit ? request.OfferSend.SteamOffer.ItemsToReceive : request.OfferSend.SteamOffer.ItemsToGive;
return(await CreateTransactionOfferAsync(itemsInOfferRequest.ToList(), bot, owner, isDeposit));
}
public async Task TimmerRanOutForMatchDraftsWinnerSuccess()
{
var manager = new CoinFlipManager
(
_fakedRepoServiceFactory,
_fakedCoinFlipService,
_fakedDraftingService,
_coinFlipSocketSender,
_dummyBetOrWithdrawQueueManager,
_dummyBetHubConnection,
_dummyLogServiceFactory,
_dummyBetService,
_dummyMongoJackpotRepoService,
_dummyHotStatusManager,
_dummyDiscordService
);
var bets = new List <DatabaseModel.Bet>
{
new DatabaseModel.Bet(10, 1, 2, DateTime.Today),
new DatabaseModel.Bet(9, 1, 2, DateTime.Today),
};
var winningUser = new DatabaseModel.User("", "", "", "", DateTime.Now, DateTime.Now, false, null, 10);
A.CallTo(() => _fakedBetRepoService.FindAsync(1, 2)).Returns(Task.FromResult(bets));
A.CallTo(() => _fakedCoinFlipMatchRepoService.FindAllNotClosedMatches()).Returns(new List <DatabaseModel.CoinFlip>
{
new DatabaseModel.CoinFlip
{
Created = DateTime.Now,
CreatorIsHead = true,
CreatorUserId = 10,
GameModeId = 2,
Hash = "hash",
Id = 1,
Percentage = "5",
RoundId = "",
Salt = "",
SettingId = 5,
Status = (int)MatchStatus.TimerCountdown,
TimerStarted = DateTime.Today,
WinnerId = null
}
});
A.CallTo(() => _fakedDraftingService.GetWinningBet(5, bets, A <List <DatabaseModel.ItemBetted> > ._)).Returns(new WinningBet
{
Bet = bets[0],
WinningTicket = 5
});
A.CallTo(() => _fakedJackpotSettingRepo.Find(5)).Returns(new DatabaseModel.JackpotSetting
{
Rake = 10
});
A.CallTo(() => _fakedUserRepoService.FindAsync(10)).Returns(winningUser);
await ExecuteStartStopManager(manager);
A.CallTo(() => _fakedCoinFlipMatchRepoService.FindAllNotClosedMatches()).MustHaveHappened();
A.CallTo(() => _fakedBetRepoService.FindAsync(1, 2)).MustHaveHappened();
A.CallTo(() => _fakedJackpotSettingRepo.Find(5)).MustHaveHappened();
A.CallTo(() => _fakedCoinFlipMatchRepoService.UpdateAsync(A <DatabaseModel.CoinFlip> .That.Matches(
m =>
m.Created > DateTime.Today &&
m.CreatorIsHead == true &&
m.CreatorUserId == 10 &&
m.GameModeId == 2 &&
m.Hash == "hash" &&
m.Id == 1 &&
m.Percentage == "5" &&
m.RoundId == "" &&
m.Salt == "" &&
m.SettingId == 5 &&
m.Status == (int)MatchStatus.TimerCountdown &&
m.TimerStarted >= DateTime.Today &&
m.WinnerId == null
)
)).MustNotHaveHappened();
A.CallTo(() => _fakedCoinFlipMatchRepoService.UpdateAsync(A <DatabaseModel.CoinFlip> .That.Matches(
m =>
m.Created > DateTime.Today &&
m.CreatorIsHead == true &&
m.CreatorUserId == 10 &&
m.GameModeId == 2 &&
m.Hash == "hash" &&
m.Id == 1 &&
m.Percentage == "5" &&
m.RoundId == "" &&
m.Salt == "" &&
m.SettingId == 5 &&
m.Status == (int)MatchStatus.Drafting &&
m.TimerStarted >= DateTime.Today &&
m.WinnerId == 10
)
)).MustHaveHappened();
A.CallTo(() => _fakedDraftingService.GetWinningBet(5, bets, A <List <DatabaseModel.ItemBetted> > ._)).MustHaveHappened();
A.CallTo(() => _fakedUserRepoService.FindAsync(10)).MustHaveHappened();
A.CallTo(() => _fakedDraftingService.ChangeOwnerOfItems(bets, A <List <DatabaseModel.ItemBetted> > ._, winningUser, 1, 10, 2))
.MustHaveHappened();
}