public static Deck GetDeckPorformato(string tipoformato, int quantidadeCartas, int quantidadeSideDeck = 0)
        {
            var deckFake = new Faker <Deck>();
            var cartas   = CartaFake.GetCartasDekcGenerico(quantidadeCartas);
            var side     = CartaFake.GetCartasDekcGenerico(quantidadeSideDeck);

            deckFake.RuleFor(d => d.TipoFormato, (f, c) => TipoFormato.Factory(tipoformato));
            deckFake.RuleFor(d => d.Cartas, (f, c) => cartas);
            deckFake.RuleFor(d => d.SideDeck, (f, c) => side);

            return(deckFake.Generate());
        }
Example #2
0
        public void ValidaCarta_LimiteDeCopiasDaCartaExcedido_RetornarErroEMensagemDeErro(string formato, int limiteDeCopias)
        {
            // Arrange
            var carta       = new Carta();
            var tipoFormato = TipoFormato.Factory(formato);

            // Act
            var erros = tipoFormato.ValidaCarta(carta, limiteDeCopias + 1);

            // Assert
            Assert.False(erros.Valido);
            Assert.Contains(erros.Erros, e => e.Contains(MensagemDeErro.ACIMA_DO_LIMITE_DE_COPIAS));
        }
Example #3
0
        public void ValidaCarta_TerrenoBasicoAcimaDoLimiteDeCopias_NaoDeveDarErroPorExcederLimiteDeCopia()
        {
            // Arrange
            var carta = new Carta
            {
                Tipo = "Terreno Básico — Floresta"
            };
            var tipoFormato = TipoFormato.Factory(new Faker().FormatoJogo());
            // Act
            var erros = tipoFormato.ValidaCarta(carta, 20);

            // Assert
            Assert.DoesNotContain(erros.Erros, e => e.Contains(MensagemDeErro.ACIMA_DO_LIMITE_DE_COPIAS));
        }
Example #4
0
        public void ValidaCarta_CartaQuePermiteQuantidadeIlimitadaDeCopias_NaoRetornaErroDeLimiteDeCopias(string idCarta)
        {
            // Arrange
            var carta = new Carta
            {
                IdScryfall = idCarta
            };

            var tipoFormato = TipoFormato.Factory(new Faker().FormatoJogo());

            // Act
            var erros = tipoFormato.ValidaCarta(carta, 100);

            // Assert
            Assert.DoesNotContain(erros.Erros, e => e.Contains(MensagemDeErro.ACIMA_DO_LIMITE_DE_COPIAS));
        }
Example #5
0
        public void ValidaCarta_CartaSeteAnoes_PodeTerAteSeteCartasNoDeck()
        {
            // Arrange
            var carta = new Carta
            {
                IdScryfall = IdCartasEspeciais.SETE_ANOES
            };

            var tipoFormato = TipoFormato.Factory(new Faker().FormatoJogo());

            // Act
            var errosComSeteCartas       = tipoFormato.ValidaCarta(carta, 7);
            var errosComMaisDeSeteCartas = tipoFormato.ValidaCarta(carta, 8);

            // Assert
            Assert.DoesNotContain(errosComSeteCartas.Erros, e => e.Contains(MensagemDeErro.ACIMA_DO_LIMITE_DE_COPIAS));
            Assert.Contains(errosComMaisDeSeteCartas.Erros, e => e.Contains(MensagemDeErro.ACIMA_DO_LIMITE_DE_COPIAS));
        }
Example #6
0
        public void ValidaCarta_CartaRestritoNoFormatoComUmaCopia_NaoRetornaErroDeRestricao(string formato)
        {
            // Arrange
            var carta = new Carta
            {
                LegalidadePorFormato = new Dictionary <string, Legalidade>()
                {
                    { formato, Legalidade.RESTRITA }
                }
            };

            var tipoFormato = TipoFormato.Factory(formato);
            // Act
            var erros = tipoFormato.ValidaCarta(carta, 1);

            // Assert
            Assert.DoesNotContain(erros.Erros, e => e.Contains(MensagemDeErro.CARTA_RESTRITA_NO_FORMATO));
        }
Example #7
0
        public void ValidaCarta_CartaBanidaNoFormato_RetornaErroEMensagemDeErro(string formato)
        {
            // Arrange
            var carta = new Carta
            {
                LegalidadePorFormato = new Dictionary <string, Legalidade>()
                {
                    { formato, Legalidade.BANIDO }
                }
            };

            var tipoFormato = TipoFormato.Factory(formato);
            // Act
            var erros = tipoFormato.ValidaCarta(carta, 1);

            // Assert
            Assert.False(erros.Valido);
            Assert.Contains(erros.Erros, e => e.Contains(MensagemDeErro.CARTA_BANIDA_NO_FORMATO));
        }
Example #8
0
        public void ValidaDeck_SomaDeCopiasDeUmaMesmaCartaNoDeckENoSideExcedeLimiteDeCopias_RetornarErroEMensagemDeErro(string formato)
        {
            // Arrange
            var idCarta = new Guid();
            var deck    = new Deck();

            var cardDeck = new CartaDeck
            {
                IdCarta = idCarta,
                Carta   = new Carta
                {
                    Id = idCarta
                },
                Quantidade = 2
            };

            var cardSideDeck = new CartaDeck
            {
                IdCarta = idCarta,
                Carta   = new Carta
                {
                    Id = idCarta
                },
                Quantidade = 3
            };

            deck.Cartas.Add(cardDeck);
            deck.SideDeck.Add(cardSideDeck);

            var tipoFormato = TipoFormato.Factory(formato);

            // Act
            var erros = tipoFormato.ValidaDeck(deck);

            // Assert
            Assert.False(erros.Valido);
            Assert.Contains(erros.Erros, e => e.Contains($"{MensagemDeErro.ACIMA_DO_LIMITE_DE_COPIAS} - 5/4"));
        }