Beispiel #1
0
        public async Task <Deck> Add(YgoProDeck ygoProDeck)
        {
            var newDeck = new Deck
            {
                UserId      = ygoProDeck.UserId,
                Name        = ygoProDeck.Name,
                Description = ygoProDeck.Description,
                Created     = DateTime.UtcNow,
                Updated     = DateTime.UtcNow
            };

            var deckTypes = (await _deckTypeRepository.AllDeckTypes()).ToDictionary(dt => dt.Name, dt => dt);

            var mainDeckUniqueCards  = ygoProDeck.Main.Select(c => c).Distinct().ToList();
            var extraDeckUniqueCards = ygoProDeck.Extra.Select(c => c).Distinct().ToList();
            var sideDeckUniqueCards  = ygoProDeck.Side.Select(c => c).Distinct().ToList();

            var mainDeckCardCopies  = ygoProDeck.Main.GroupBy(c => c).ToDictionary(g => g.Key, g => g.Count());
            var extraDeckCardCopies = ygoProDeck.Extra.GroupBy(c => c).ToDictionary(g => g.Key, g => g.Count());
            var sideDeckCardCopies  = ygoProDeck.Side.GroupBy(c => c).ToDictionary(g => g.Key, g => g.Count());

            newDeck = await AddCardsToDeckByCardNumber(mainDeckUniqueCards, newDeck, deckTypes[DeckTypeConstants.Main], mainDeckCardCopies);

            newDeck = await AddCardsToDeckByCardNumber(extraDeckUniqueCards, newDeck, deckTypes[DeckTypeConstants.Extra], extraDeckCardCopies);

            newDeck = await AddCardsToDeckByCardNumber(sideDeckUniqueCards, newDeck, deckTypes[DeckTypeConstants.Side], sideDeckCardCopies);

            await _deckRepository.Add(newDeck);

            return(newDeck);
        }
        public async Task Given_A_Valid_YgoProDeck_If_Cards_Are_Found_Not_Found_Should_Return_Newly_Created_Deck()
        {
            // Arrange
            var ygoProDeck = new YgoProDeck
            {
                UserId      = Guid.NewGuid().ToString(),
                Name        = "Jinzo Deck",
                Description = "Machines are coming.",
                Main        = new List <long> {
                    34230233, 34230233, 34230233, 99458769, 99458769, 99458769
                },
                Extra = new List <long> {
                    31386180, 6832966, 16195942, 84013237, 94380860
                },
                Side = new List <long>()
            };

            _deckTypeRepository.AllDeckTypes().Returns(new List <DeckType>
            {
                new DeckType
                {
                    Id   = 23424,
                    Name = "Main",
                },
                new DeckType
                {
                    Id   = 23424,
                    Name = "Extra",
                },
                new DeckType
                {
                    Id   = 23424,
                    Name = "Side",
                }
            });

            // Act
            var result = await _sut.Add(ygoProDeck);

            // Assert
            result.Should().NotBeNull();
        }
Beispiel #3
0
        public async Task Should_Invoke_AllDeckTypes_Once()
        {
            // Arrange
            _deckTypeRepository.AllDeckTypes().Returns(new List<DeckType>());

            // Act
            await _sut.AllDeckTypes();

            // Assert
            await _deckTypeRepository.Received(1).AllDeckTypes();

        }
Beispiel #4
0
        public async Task Given_A_Valid_Deck_If_Cards_Are_Found_Not_Found_Should_Return_Updated_Deck()
        {
            // Arrange
            var updatedDeck = new DeckModel
            {
                UserId      = Guid.NewGuid().ToString(),
                Name        = "Jinzo Deck",
                Description = "Machines are coming.",
                MainDeck    = new List <CardModel>
                {
                    new CardModel {
                        Id = 34230233
                    },
                    new CardModel {
                        Id = 34230233
                    },
                    new CardModel {
                        Id = 34230233
                    },
                    new CardModel {
                        Id = 99458769
                    },
                    new CardModel {
                        Id = 99458769
                    },
                    new CardModel {
                        Id = 99458769
                    }
                },
                ExtraDeck = new List <CardModel>
                {
                    new CardModel {
                        Id = 31386180
                    },
                    new CardModel {
                        Id = 6832966
                    },
                    new CardModel {
                        Id = 16195942
                    },
                    new CardModel {
                        Id = 84013237
                    },
                    new CardModel {
                        Id = 94380860
                    },
                },
                SideDeck = new List <CardModel>()
            };

            _deckTypeRepository.AllDeckTypes().Returns(new List <DeckType>
            {
                new DeckType
                {
                    Id   = 23424,
                    Name = "Main",
                },
                new DeckType
                {
                    Id   = 23424,
                    Name = "Extra",
                },
                new DeckType
                {
                    Id   = 23424,
                    Name = "Side",
                }
            });

            _deckRepository.GetDeckById(Arg.Any <long>()).Returns(new DeckDetail
            {
                Id      = 2342342,
                UserId  = Guid.NewGuid().ToString(),
                Created = DateTime.Now
            });


            _deckRepository.Update(Arg.Any <Deck>()).Returns(new Deck());

            // Act
            var result = await _sut.Update(updatedDeck);

            // Assert
            result.Should().NotBeNull();
        }
Beispiel #5
0
 public Task <IEnumerable <DeckType> > AllDeckTypes()
 {
     return(_deckTypeRepository.AllDeckTypes());
 }