ArchiSteamFarm.Tests/Bot.cs

   1 // ----------------------------------------------------------------------------------------------
   2 //     _                _      _  ____   _                           _____
   3 //    / \    _ __  ___ | |__  (_)/ ___| | |_  ___   __ _  _ __ ___  |  ___|__ _  _ __  _ __ ___
   4 //   / _ \  | '__|/ __|| '_ \ | |\___ \ | __|/ _ \ / _` || '_ ` _ \ | |_  / _` || '__|| '_ ` _ \
   5 //  / ___ \ | |  | (__ | | | || | ___) || |_|  __/| (_| || | | | | ||  _|| (_| || |   | | | | | |
   6 // /_/   \_\|_|   \___||_| |_||_||____/  \__|\___| \__,_||_| |_| |_||_|   \__,_||_|   |_| |_| |_|
   7 // ----------------------------------------------------------------------------------------------
   8 // |
   9 // Copyright 2015-2024 Łukasz "JustArchi" Domeradzki
  10 // Contact: JustArchi@JustArchi.net
  11 // |
  12 // Licensed under the Apache License, Version 2.0 (the "License");
  13 // you may not use this file except in compliance with the License.
  14 // You may obtain a copy of the License at
  15 // |
  16 // http://www.apache.org/licenses/LICENSE-2.0
  17 // |
  18 // Unless required by applicable law or agreed to in writing, software
  19 // distributed under the License is distributed on an "AS IS" BASIS,
  20 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21 // See the License for the specific language governing permissions and
  22 // limitations under the License.
  23
  24 using System;
  25 using System.Collections.Generic;
  26 using System.Linq;
  27 using ArchiSteamFarm.Steam.Data;
  28 using Microsoft.VisualStudio.TestTools.UnitTesting;
  29 using static ArchiSteamFarm.Steam.Bot;
  30
  31 namespace ArchiSteamFarm.Tests;
  32
  33 [TestClass]
  34 public sealed class Bot {
  35         [TestMethod]
  36         public void MaxItemsBarelyEnoughForOneSet() {
  37                 const uint relevantAppID = 42;
  38
  39                 Dictionary<uint, byte> itemsPerSet = new() {
  40                         { relevantAppID, MinCardsPerBadge },
  41                         { 43, MinCardsPerBadge + 1 }
  42                 };
  43
  44                 HashSet<Asset> items = [];
  45
  46                 foreach ((uint appID, byte cards) in itemsPerSet) {
  47                         for (byte i = 1; i <= cards; i++) {
  48                                 items.Add(CreateCard(i, realAppID: appID));
  49                         }
  50                 }
  51
  52                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, itemsPerSet, MinCardsPerBadge);
  53
  54                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = items.Where(static item => item.RealAppID == relevantAppID).GroupBy(static item => (item.RealAppID, item.ContextID, item.ClassID)).ToDictionary(static group => group.Key, static group => (uint) group.Sum(static item => item.Amount));
  55
  56                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
  57         }
  58
  59         [TestMethod]
  60         public void MaxItemsTooSmall() {
  61                 const uint appID = 42;
  62
  63                 HashSet<Asset> items = [
  64                         CreateCard(1, realAppID: appID),
  65                         CreateCard(2, realAppID: appID)
  66                 ];
  67
  68                 Assert.ThrowsException<ArgumentOutOfRangeException>(() => GetItemsForFullBadge(items, 2, appID, MinCardsPerBadge - 1));
  69         }
  70
  71         [TestMethod]
  72         public void MoreCardsThanNeeded() {
  73                 const uint appID = 42;
  74
  75                 HashSet<Asset> items = [
  76                         CreateCard(1, realAppID: appID),
  77                         CreateCard(1, realAppID: appID),
  78                         CreateCard(2, realAppID: appID),
  79                         CreateCard(3, realAppID: appID)
  80                 ];
  81
  82                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 3, appID);
  83
  84                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
  85                         { (appID, Asset.SteamCommunityContextID, 1), 1 },
  86                         { (appID, Asset.SteamCommunityContextID, 2), 1 },
  87                         { (appID, Asset.SteamCommunityContextID, 3), 1 }
  88                 };
  89
  90                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
  91         }
  92
  93         [TestMethod]
  94         public void MultipleSets() {
  95                 const uint appID = 42;
  96
  97                 HashSet<Asset> items = [
  98                         CreateCard(1, realAppID: appID),
  99                         CreateCard(1, realAppID: appID),
 100                         CreateCard(2, realAppID: appID),
 101                         CreateCard(2, realAppID: appID)
 102                 ];
 103
 104                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 2, appID);
 105
 106                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 107                         { (appID, Asset.SteamCommunityContextID, 1), 2 },
 108                         { (appID, Asset.SteamCommunityContextID, 2), 2 }
 109                 };
 110
 111                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 112         }
 113
 114         [TestMethod]
 115         public void MultipleSetsDifferentAmount() {
 116                 const uint appID = 42;
 117
 118                 HashSet<Asset> items = [
 119                         CreateCard(1, amount: 2, realAppID: appID),
 120                         CreateCard(2, realAppID: appID),
 121                         CreateCard(2, realAppID: appID)
 122                 ];
 123
 124                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 2, appID);
 125
 126                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 127                         { (appID, Asset.SteamCommunityContextID, 1), 2 },
 128                         { (appID, Asset.SteamCommunityContextID, 2), 2 }
 129                 };
 130
 131                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 132         }
 133
 134         [TestMethod]
 135         public void MutliRarityAndType() {
 136                 const uint appID = 42;
 137
 138                 HashSet<Asset> items = [
 139                         CreateCard(1, realAppID: appID, type: EAssetType.TradingCard, rarity: EAssetRarity.Common),
 140                         CreateCard(2, realAppID: appID, type: EAssetType.TradingCard, rarity: EAssetRarity.Common),
 141
 142                         CreateCard(1, realAppID: appID, type: EAssetType.FoilTradingCard, rarity: EAssetRarity.Uncommon),
 143                         CreateCard(2, realAppID: appID, type: EAssetType.FoilTradingCard, rarity: EAssetRarity.Uncommon),
 144
 145                         CreateCard(1, realAppID: appID, type: EAssetType.FoilTradingCard, rarity: EAssetRarity.Rare),
 146                         CreateCard(2, realAppID: appID, type: EAssetType.FoilTradingCard, rarity: EAssetRarity.Rare),
 147
 148                         // for better readability and easier verification when thinking about this test the items that shall be selected for sending are the ones below this comment
 149                         CreateCard(1, realAppID: appID, type: EAssetType.TradingCard, rarity: EAssetRarity.Uncommon),
 150                         CreateCard(2, realAppID: appID, type: EAssetType.TradingCard, rarity: EAssetRarity.Uncommon),
 151                         CreateCard(3, realAppID: appID, type: EAssetType.TradingCard, rarity: EAssetRarity.Uncommon),
 152
 153                         CreateCard(1, realAppID: appID, type: EAssetType.FoilTradingCard, rarity: EAssetRarity.Common),
 154                         CreateCard(3, realAppID: appID, type: EAssetType.FoilTradingCard, rarity: EAssetRarity.Common),
 155                         CreateCard(7, realAppID: appID, type: EAssetType.FoilTradingCard, rarity: EAssetRarity.Common),
 156
 157                         CreateCard(2, realAppID: appID, type: EAssetType.Unknown, rarity: EAssetRarity.Rare),
 158                         CreateCard(3, realAppID: appID, type: EAssetType.Unknown, rarity: EAssetRarity.Rare),
 159                         CreateCard(4, realAppID: appID, type: EAssetType.Unknown, rarity: EAssetRarity.Rare)
 160                 ];
 161
 162                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 3, appID);
 163
 164                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 165                         { (appID, Asset.SteamCommunityContextID, 1), 2 },
 166                         { (appID, Asset.SteamCommunityContextID, 2), 2 },
 167                         { (appID, Asset.SteamCommunityContextID, 3), 3 },
 168                         { (appID, Asset.SteamCommunityContextID, 4), 1 },
 169                         { (appID, Asset.SteamCommunityContextID, 7), 1 }
 170                 };
 171
 172                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 173         }
 174
 175         [TestMethod]
 176         public void NotAllCardsPresent() {
 177                 const uint appID = 42;
 178
 179                 HashSet<Asset> items = [
 180                         CreateCard(1, realAppID: appID),
 181                         CreateCard(2, realAppID: appID)
 182                 ];
 183
 184                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 3, appID);
 185
 186                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new(0);
 187                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 188         }
 189
 190         [TestMethod]
 191         public void OneSet() {
 192                 const uint appID = 42;
 193
 194                 HashSet<Asset> items = [
 195                         CreateCard(1, realAppID: appID),
 196                         CreateCard(2, realAppID: appID)
 197                 ];
 198
 199                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 2, appID);
 200
 201                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 202                         { (appID, Asset.SteamCommunityContextID, 1), 1 },
 203                         { (appID, Asset.SteamCommunityContextID, 2), 1 }
 204                 };
 205
 206                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 207         }
 208
 209         [TestMethod]
 210         public void OtherAppIDFullSets() {
 211                 const uint appID0 = 42;
 212                 const uint appID1 = 43;
 213
 214                 HashSet<Asset> items = [
 215                         CreateCard(1, realAppID: appID0),
 216                         CreateCard(1, realAppID: appID1)
 217                 ];
 218
 219                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(
 220                         items, new Dictionary<uint, byte> {
 221                                 { appID0, 1 },
 222                                 { appID1, 1 }
 223                         }
 224                 );
 225
 226                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 227                         { (appID0, Asset.SteamCommunityContextID, 1), 1 },
 228                         { (appID1, Asset.SteamCommunityContextID, 1), 1 }
 229                 };
 230
 231                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 232         }
 233
 234         [TestMethod]
 235         public void OtherAppIDNoSets() {
 236                 const uint appID0 = 42;
 237                 const uint appID1 = 43;
 238
 239                 HashSet<Asset> items = [
 240                         CreateCard(1, realAppID: appID0),
 241                         CreateCard(1, realAppID: appID1)
 242                 ];
 243
 244                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(
 245                         items, new Dictionary<uint, byte> {
 246                                 { appID0, 2 },
 247                                 { appID1, 2 }
 248                         }
 249                 );
 250
 251                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new(0);
 252
 253                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 254         }
 255
 256         [TestMethod]
 257         public void OtherAppIDOneSet() {
 258                 const uint appID0 = 42;
 259                 const uint appID1 = 43;
 260                 const uint appID2 = 44;
 261
 262                 HashSet<Asset> items = [
 263                         CreateCard(1, realAppID: appID0),
 264                         CreateCard(2, realAppID: appID0),
 265
 266                         CreateCard(1, realAppID: appID1),
 267                         CreateCard(2, realAppID: appID1),
 268                         CreateCard(3, realAppID: appID1)
 269                 ];
 270
 271                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(
 272                         items, new Dictionary<uint, byte> {
 273                                 { appID0, 3 },
 274                                 { appID1, 3 },
 275                                 { appID2, 3 }
 276                         }
 277                 );
 278
 279                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 280                         { (appID1, Asset.SteamCommunityContextID, 1), 1 },
 281                         { (appID1, Asset.SteamCommunityContextID, 2), 1 },
 282                         { (appID1, Asset.SteamCommunityContextID, 3), 1 }
 283                 };
 284
 285                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 286         }
 287
 288         [TestMethod]
 289         public void OtherRarityFullSets() {
 290                 const uint appID = 42;
 291
 292                 HashSet<Asset> items = [
 293                         CreateCard(1, realAppID: appID, rarity: EAssetRarity.Common),
 294                         CreateCard(1, realAppID: appID, rarity: EAssetRarity.Rare)
 295                 ];
 296
 297                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 1, appID);
 298
 299                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 300                         { (appID, Asset.SteamCommunityContextID, 1), 2 }
 301                 };
 302
 303                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 304         }
 305
 306         [TestMethod]
 307         public void OtherRarityNoSets() {
 308                 const uint appID = 42;
 309
 310                 HashSet<Asset> items = [
 311                         CreateCard(1, realAppID: appID, rarity: EAssetRarity.Common),
 312                         CreateCard(1, realAppID: appID, rarity: EAssetRarity.Rare)
 313                 ];
 314
 315                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 2, appID);
 316
 317                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new(0);
 318
 319                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 320         }
 321
 322         [TestMethod]
 323         public void OtherRarityOneSet() {
 324                 const uint appID = 42;
 325
 326                 HashSet<Asset> items = [
 327                         CreateCard(1, realAppID: appID, rarity: EAssetRarity.Common),
 328                         CreateCard(2, realAppID: appID, rarity: EAssetRarity.Common),
 329                         CreateCard(1, realAppID: appID, rarity: EAssetRarity.Uncommon),
 330                         CreateCard(2, realAppID: appID, rarity: EAssetRarity.Uncommon),
 331                         CreateCard(3, realAppID: appID, rarity: EAssetRarity.Uncommon)
 332                 ];
 333
 334                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 3, appID);
 335
 336                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 337                         { (appID, Asset.SteamCommunityContextID, 1), 1 },
 338                         { (appID, Asset.SteamCommunityContextID, 2), 1 },
 339                         { (appID, Asset.SteamCommunityContextID, 3), 1 }
 340                 };
 341
 342                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 343         }
 344
 345         [TestMethod]
 346         public void OtherTypeFullSets() {
 347                 const uint appID = 42;
 348
 349                 HashSet<Asset> items = [
 350                         CreateCard(1, realAppID: appID, type: EAssetType.TradingCard),
 351                         CreateCard(1, realAppID: appID, type: EAssetType.FoilTradingCard)
 352                 ];
 353
 354                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 1, appID);
 355
 356                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 357                         { (appID, Asset.SteamCommunityContextID, 1), 2 }
 358                 };
 359
 360                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 361         }
 362
 363         [TestMethod]
 364         public void OtherTypeNoSets() {
 365                 const uint appID = 42;
 366
 367                 HashSet<Asset> items = [
 368                         CreateCard(1, realAppID: appID, type: EAssetType.TradingCard),
 369                         CreateCard(1, realAppID: appID, type: EAssetType.FoilTradingCard)
 370                 ];
 371
 372                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 2, appID);
 373
 374                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new(0);
 375
 376                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 377         }
 378
 379         [TestMethod]
 380         public void OtherTypeOneSet() {
 381                 const uint appID = 42;
 382
 383                 HashSet<Asset> items = [
 384                         CreateCard(1, realAppID: appID, type: EAssetType.TradingCard),
 385                         CreateCard(2, realAppID: appID, type: EAssetType.TradingCard),
 386                         CreateCard(1, realAppID: appID, type: EAssetType.FoilTradingCard),
 387                         CreateCard(2, realAppID: appID, type: EAssetType.FoilTradingCard),
 388                         CreateCard(3, realAppID: appID, type: EAssetType.FoilTradingCard)
 389                 ];
 390
 391                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 3, appID);
 392
 393                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 394                         { (appID, Asset.SteamCommunityContextID, 1), 1 },
 395                         { (appID, Asset.SteamCommunityContextID, 2), 1 },
 396                         { (appID, Asset.SteamCommunityContextID, 3), 1 }
 397                 };
 398
 399                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 400         }
 401
 402         [TestMethod]
 403         public void TooHighAmount() {
 404                 const uint appID0 = 42;
 405
 406                 HashSet<Asset> items = [
 407                         CreateCard(1, amount: 2, realAppID: appID0),
 408                         CreateCard(2, realAppID: appID0)
 409                 ];
 410
 411                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 2, appID0);
 412
 413                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult = new() {
 414                         { (appID0, Asset.SteamCommunityContextID, 1), 1 },
 415                         { (appID0, Asset.SteamCommunityContextID, 2), 1 }
 416                 };
 417
 418                 AssertResultMatchesExpectation(expectedResult, itemsToSend);
 419         }
 420
 421         [TestMethod]
 422         public void TooManyCardsForSingleTrade() {
 423                 const uint appID = 42;
 424
 425                 HashSet<Asset> items = [];
 426
 427                 for (byte i = 0; i < Steam.Exchange.Trading.MaxItemsPerTrade; i++) {
 428                         items.Add(CreateCard(1, realAppID: appID));
 429                         items.Add(CreateCard(2, realAppID: appID));
 430                 }
 431
 432                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, 2, appID);
 433
 434                 Assert.IsTrue(itemsToSend.Count <= Steam.Exchange.Trading.MaxItemsPerTrade);
 435         }
 436
 437         [TestMethod]
 438         public void TooManyCardsForSingleTradeMultipleAppIDs() {
 439                 const uint appID0 = 42;
 440                 const uint appID1 = 43;
 441
 442                 HashSet<Asset> items = [];
 443
 444                 for (byte i = 0; i < 100; i++) {
 445                         items.Add(CreateCard(1, realAppID: appID0));
 446                         items.Add(CreateCard(2, realAppID: appID0));
 447                         items.Add(CreateCard(1, realAppID: appID1));
 448                         items.Add(CreateCard(2, realAppID: appID1));
 449                 }
 450
 451                 Dictionary<uint, byte> itemsPerSet = new() {
 452                         { appID0, 2 },
 453                         { appID1, 2 }
 454                 };
 455
 456                 HashSet<Asset> itemsToSend = GetItemsForFullBadge(items, itemsPerSet);
 457
 458                 Assert.IsTrue(itemsToSend.Count <= Steam.Exchange.Trading.MaxItemsPerTrade);
 459         }
 460
 461         [TestMethod]
 462         public void TooManyCardsPerSet() {
 463                 const uint appID0 = 42;
 464                 const uint appID1 = 43;
 465                 const uint appID2 = 44;
 466
 467                 HashSet<Asset> items = [
 468                         CreateCard(1, realAppID: appID0),
 469                         CreateCard(2, realAppID: appID0),
 470                         CreateCard(3, realAppID: appID0),
 471                         CreateCard(4, realAppID: appID0)
 472                 ];
 473
 474                 Assert.ThrowsException<InvalidOperationException>(
 475                         () => GetItemsForFullBadge(
 476                                 items, new Dictionary<uint, byte> {
 477                                         { appID0, 3 },
 478                                         { appID1, 3 },
 479                                         { appID2, 3 }
 480                                 }
 481                         )
 482                 );
 483         }
 484
 485         private static void AssertResultMatchesExpectation(IReadOnlyDictionary<(uint RealAppID, ulong ContextID, ulong ClassID), uint> expectedResult, IReadOnlyCollection<Asset> itemsToSend) {
 486                 ArgumentNullException.ThrowIfNull(expectedResult);
 487                 ArgumentNullException.ThrowIfNull(itemsToSend);
 488
 489                 Dictionary<(uint RealAppID, ulong ContextID, ulong ClassID), long> realResult = itemsToSend.GroupBy(static asset => (asset.RealAppID, asset.ContextID, asset.ClassID)).ToDictionary(static group => group.Key, static group => group.Sum(static asset => asset.Amount));
 490                 Assert.AreEqual(expectedResult.Count, realResult.Count);
 491                 Assert.IsTrue(expectedResult.All(expectation => realResult.TryGetValue(expectation.Key, out long reality) && (expectation.Value == reality)));
 492         }
 493
 494         private static Asset CreateCard(ulong classID, ulong instanceID = 0, uint amount = 1, bool marketable = false, bool tradable = false, uint realAppID = Asset.SteamAppID, EAssetType type = EAssetType.TradingCard, EAssetRarity rarity = EAssetRarity.Common) => new(Asset.SteamAppID, Asset.SteamCommunityContextID, classID, amount, new InventoryDescription(Asset.SteamAppID, classID, instanceID, marketable, tradable, realAppID, type, rarity));
 495
 496         private static HashSet<Asset> GetItemsForFullBadge(IReadOnlyCollection<Asset> inventory, byte cardsPerSet, uint appID, ushort maxItems = Steam.Exchange.Trading.MaxItemsPerTrade) => GetItemsForFullBadge(inventory, new Dictionary<uint, byte> { { appID, cardsPerSet } }, maxItems);
 497
 498         private static HashSet<Asset> GetItemsForFullBadge(IReadOnlyCollection<Asset> inventory, IDictionary<uint, byte> cardsPerSet, ushort maxItems = Steam.Exchange.Trading.MaxItemsPerTrade) {
 499                 Dictionary<(uint RealAppID, EAssetType Type, EAssetRarity Rarity), List<uint>> inventorySets = Steam.Exchange.Trading.GetInventorySets(inventory);
 500
 501                 return GetItemsForFullSets(inventory, inventorySets.ToDictionary(static kv => kv.Key, kv => (SetsToExtract: inventorySets[kv.Key][0], cardsPerSet[kv.Key.RealAppID])), maxItems).ToHashSet();
 502         }
 503 }