Exemplo n.º 1
0
        public void InsertParqueTest()
        {
            using (Context ctx = new Context(connectionString))
            {
                Parque c = new Parque();
                c.Nome     = "brasil";
                c.Email    = "*****@*****.**";
                c.Morada   = "Rio de Janeiro, Rua Junqueiro 367";
                c.Estrelas = 5;

                ParqueMapper map = new ParqueMapper(ctx);
                c = map.Create(c);
                Parque c1 = map.Read(c.Nome);


                Assert.AreEqual(c1.Nome, c.Nome);
                Assert.AreEqual(c1.Estrelas, c.Estrelas);
                Assert.AreEqual(c1.Email, c.Email);
                Assert.AreEqual(c1.Morada, c.Morada);

                foreach (var hospede in map.ReadAll())
                {
                    map.Delete(hospede);
                }
            }
        }
Exemplo n.º 2
0
        public void UpdateTendaTest()
        {
            using (Context ctx = new Context(connectionString))
            {
                Parque parque = new Parque();
                parque.Nome     = "Marechal Carmona";
                parque.Morada   = "Rua de Cascais";
                parque.Estrelas = 4;
                parque.Email    = "*****@*****.**";

                ParqueMapper pm = new ParqueMapper(ctx);
                parque = pm.Create(parque);

                Alojamento alojamento = new Alojamento();
                alojamento.Nome        = "Primeiro Alojamento";
                alojamento.Localizaçao = "Quinta da Marinha";
                alojamento.Descrição   = "T0 com duche";
                alojamento.MaxPessoas  = 5;
                alojamento.PreçoBase   = 85;
                alojamento.Parque      = parque;

                AlojamentoMapper am = new AlojamentoMapper(ctx);
                alojamento = am.Create(alojamento);

                Tenda tenda = new Tenda();
                tenda.Area       = 1234;
                tenda.Alojamento = alojamento;
                tenda.Tipo       = "yurt";

                TendaMapper tendaMapper = new TendaMapper(ctx);
                tenda = tendaMapper.Create(tenda);

                tenda.Area = 5678;
                tenda.Tipo = "safari";
                tendaMapper.Update(tenda);

                Tenda tenda1 = tendaMapper.Read(tenda.Alojamento.Nome);

                Assert.AreEqual(tenda.Alojamento.Nome, tenda1.Alojamento.Nome);
                Assert.AreEqual(tenda.Tipo, tenda1.Tipo);

                foreach (var t in tendaMapper.ReadAll())
                {
                    tendaMapper.Delete(t);
                }
                foreach (var a in am.ReadAll())
                {
                    am.Delete(a);
                }
                foreach (var p in pm.ReadAll())
                {
                    pm.Delete(p);
                }
            }
        }
Exemplo n.º 3
0
        public void UpdateTendaTest()
        {
            using (Context ctx = new Context(connectionString))
            {
                Parque parque = new Parque();
                parque.Nome     = "Marechal Carmona";
                parque.Morada   = "Rua de Cascais";
                parque.Estrelas = 4;
                parque.Email    = "*****@*****.**";

                ParqueMapper pm = new ParqueMapper(ctx);
                parque = pm.Create(parque);

                Alojamento alojamento = new Alojamento();
                alojamento.Nome        = "Primeiro Alojamento";
                alojamento.Localizaçao = "Quinta da Marinha";
                alojamento.Descrição   = "T0 com duche";
                alojamento.MaxPessoas  = 5;
                alojamento.PreçoBase   = 85;
                alojamento.Parque      = parque;

                AlojamentoMapper am = new AlojamentoMapper(ctx);
                alojamento = am.Create(alojamento);

                Bungalow bungalow = new Bungalow();
                bungalow.Tipologia  = "T0";
                bungalow.Alojamento = alojamento;

                BungalowMapper bungalowMapper = new BungalowMapper(ctx);
                bungalow = bungalowMapper.Create(bungalow);

                bungalow.Tipologia = "T1";
                bungalowMapper.Update(bungalow);

                Bungalow bungalow1 = bungalowMapper.Read(bungalow.Alojamento.Nome);

                Assert.AreEqual(bungalow.Alojamento.Nome, bungalow1.Alojamento.Nome);
                Assert.AreEqual(bungalow.Tipologia, bungalow1.Tipologia);

                foreach (var b in bungalowMapper.ReadAll())
                {
                    bungalowMapper.Delete(b);
                }
                foreach (var a in am.ReadAll())
                {
                    am.Delete(a);
                }
                foreach (var p in pm.ReadAll())
                {
                    pm.Delete(p);
                }
            }
        }
Exemplo n.º 4
0
        public void InsertHóspedeTest()
        {
            using (Context ctx = new Context(_connectionString))
            {
                var estada = new Estada
                {
                    DataInicio = new DateTime(2007, 3, 1),
                    DataFim    = new DateTime(2017, 3, 1),
                    Id         = 25,
                    NifHospede = 0
                };

                EstadaMapper estadaMapper = new EstadaMapper(ctx);
                estada = estadaMapper.Create(estada);


                Hóspede hóspede = new Hóspede();
                hóspede.Bi     = 1234567890;
                hóspede.Nif    = 0;
                hóspede.Nome   = "Jaquim";
                hóspede.Email  = "*****@*****.**";
                hóspede.Morada = "Rua da Calçada";

                HóspedeMapper hóspedeMapper = new HóspedeMapper(ctx);
                hóspede = hóspedeMapper.Create(hóspede);

                EstadaHóspede estadaHóspede = new EstadaHóspede()
                {
                    Estada  = estada,
                    Hóspede = hóspede
                };

                var estadaHospedeMapper = new EstadaHóspedeMapper(ctx);

                estadaHóspede = estadaHospedeMapper.Create(estadaHóspede);

                /*
                 * CREATE PARQUE
                 */
                Parque p = new Parque();
                p.Nome     = "brasil";
                p.Email    = "*****@*****.**";
                p.Morada   = "Rio de Janeiro, Rua Junqueiro 367";
                p.Estrelas = 5;

                ParqueMapper parqueMap = new ParqueMapper(ctx);
                p = parqueMap.Create(p);


                var atividade = new Atividade
                {
                    Parque        = p,
                    DataAtividade = new DateTime(2009, 10, 1),
                    Descrição     = "FORA",
                    Preço         = 90,
                    Lotaçao       = 12,
                    NomeAtividade = "HAMBURGER"
                };
                var atividadeMapper = new AtividadeMapper(ctx);
                atividade = atividadeMapper.Create(atividade);


                Fatura fatura = new Fatura();
                fatura.Hóspede    = hóspede;
                fatura.Estada     = estada;
                fatura.Id         = 1;
                fatura.ValorFinal = 0;


                var faturaMapper = new FaturaMapper(ctx);
                fatura = faturaMapper.Create(fatura);


                var inscr = new InscreverHóspedeEmAtividade(ctx);

                inscr.Execute(hóspede.Nif, atividade.NomeAtividade, p.Nome);


                var hospedeAtividadeMapper = new HóspedeAtividadeMapper(ctx);
                var componenteFaturaMapper = new ComponenteFaturaMapper(ctx);

                var hospedeAtividade = hospedeAtividadeMapper.Read(atividade.NomeAtividade);
                Assert.IsNotNull(hospedeAtividade);
                var count = componenteFaturaMapper.ReadAll().Count;
                Assert.AreNotEqual(count, 0);

                /*
                 * REMOVE THE PARQUE
                 */


                foreach (var cp in hospedeAtividadeMapper.ReadAll())
                {
                    hospedeAtividadeMapper.Delete(cp);
                }
                foreach (var s in atividadeMapper.ReadAll())
                {
                    atividadeMapper.Delete(s);
                }
                foreach (var e in estadaHospedeMapper.ReadAll())
                {
                    estadaHospedeMapper.Delete(e);
                }

                foreach (var cp in componenteFaturaMapper.ReadAll())
                {
                    componenteFaturaMapper.Delete(cp);
                }

                foreach (var e in faturaMapper.ReadAll())
                {
                    faturaMapper.Delete(e);
                }

                foreach (var hospede in hóspedeMapper.ReadAll())
                {
                    hóspedeMapper.Delete(hospede);
                }

                foreach (var parque in parqueMap.ReadAll())
                {
                    parqueMap.Delete(parque);
                }


                foreach (var e in estadaMapper.ReadAll())
                {
                    estadaMapper.Delete(estada);
                }
            }
        }
Exemplo n.º 5
0
        public void ListAvailableActivitiesTest()
        {
            using (Context ctx = new Context(_connectionString))
            {
                var estada = new Estada
                {
                    DataInicio = new DateTime(2017, 1, 1),
                    DataFim    = new DateTime(2017, 5, 2),
                    Id         = 123456,
                    NifHospede = 111
                };

                EstadaMapper estadaMapper = new EstadaMapper(ctx);
                estada = estadaMapper.Create(estada);

                Hóspede hóspede = new Hóspede();
                hóspede.Bi     = 456;
                hóspede.Nif    = 111;
                hóspede.Nome   = "Jaquim";
                hóspede.Email  = "*****@*****.**";
                hóspede.Morada = "Rua da Calçada";

                HóspedeMapper hóspedeMapper = new HóspedeMapper(ctx);
                hóspede = hóspedeMapper.Create(hóspede);

                EstadaHóspede estadaHóspede = new EstadaHóspede()
                {
                    Estada  = estada,
                    Hóspede = hóspede
                };

                var estadaHospedeMapper = new EstadaHóspedeMapper(ctx);
                estadaHóspede = estadaHospedeMapper.Create(estadaHóspede);

                Parque p = new Parque();
                p.Nome     = "brasil";
                p.Email    = "*****@*****.**";
                p.Morada   = "Rio de Janeiro, Rua Junqueiro 367";
                p.Estrelas = 5;

                ParqueMapper parqueMap = new ParqueMapper(ctx);
                p = parqueMap.Create(p);

                Atividade atividade = new Atividade
                {
                    Parque        = p,
                    DataAtividade = new DateTime(2017, 1, 1),
                    Descrição     = "Canoagem",
                    Preço         = 90,
                    Lotaçao       = 12,
                    NomeAtividade = "Canoagem"
                };

                var atividadeMapper = new AtividadeMapper(ctx);
                atividade = atividadeMapper.Create(atividade);

                Atividade atividade2 = new Atividade
                {
                    Parque        = p,
                    DataAtividade = new DateTime(2016, 1, 2),
                    Descrição     = "Pesca",
                    Preço         = 45,
                    Lotaçao       = 20,
                    NomeAtividade = "Pesca"
                };

                atividade2 = atividadeMapper.Create(atividade2);

                HóspedeAtividade hóspedeAtividade = new HóspedeAtividade()
                {
                    Hóspede        = hóspede,
                    Nome_Atividade = atividade.NomeAtividade,
                    Nome_Parque    = p.Nome
                };

                var hóspedeAtividadeMapper = new HóspedeAtividadeMapper(ctx);
                hóspedeAtividade = hóspedeAtividadeMapper.Create(hóspedeAtividade);

                HóspedeAtividade hóspedeAtividade2 = new HóspedeAtividade()
                {
                    Hóspede        = hóspede,
                    Nome_Atividade = atividade2.NomeAtividade,
                    Nome_Parque    = p.Nome
                };

                hóspedeAtividade2 = hóspedeAtividadeMapper.Create(hóspedeAtividade2);

                var listagem = new ListarAtividadeComLugares(ctx);

                listagem.Execute(new DateTime(2016, 1, 1), new DateTime(2018, 1, 1));

                foreach (var h in hóspedeAtividadeMapper.ReadAll())
                {
                    hóspedeAtividadeMapper.Delete(h);
                }
                foreach (var s in atividadeMapper.ReadAll())
                {
                    atividadeMapper.Delete(s);
                }
                foreach (var e in estadaHospedeMapper.ReadAll())
                {
                    estadaHospedeMapper.Delete(e);
                }

                foreach (var hospede in hóspedeMapper.ReadAll())
                {
                    hóspedeMapper.Delete(hospede);
                }

                foreach (var parque in parqueMap.ReadAll())
                {
                    parqueMap.Delete(parque);
                }

                foreach (var e in estadaMapper.ReadAll())
                {
                    estadaMapper.Delete(estada);
                }
            }
        }
Exemplo n.º 6
0
        public void PagamentoEstadaComFaturaTest()
        {
            using (Context ctx = new Context(_connectionString))
            {
                var estada = new Estada
                {
                    DataInicio = new DateTime(2000, 1, 1),
                    DataFim    = new DateTime(2000, 5, 2),
                    Id         = 123456,
                    NifHospede = 111
                };

                EstadaMapper estadaMapper = new EstadaMapper(ctx);
                estada = estadaMapper.Create(estada);

                Hóspede hóspede = new Hóspede();
                hóspede.Bi     = 456;
                hóspede.Nif    = 111;
                hóspede.Nome   = "Jaquim";
                hóspede.Email  = "*****@*****.**";
                hóspede.Morada = "Rua da Calçada";

                HóspedeMapper hóspedeMapper = new HóspedeMapper(ctx);
                hóspede = hóspedeMapper.Create(hóspede);

                EstadaHóspede estadaHóspede = new EstadaHóspede()
                {
                    Estada  = estada,
                    Hóspede = hóspede
                };

                var estadaHospedeMapper = new EstadaHóspedeMapper(ctx);
                estadaHóspede = estadaHospedeMapper.Create(estadaHóspede);

                Fatura fatura = new Fatura()
                {
                    Id         = 9999,
                    Estada     = estada,
                    Hóspede    = hóspede,
                    ValorFinal = 0
                };

                FaturaMapper faturaMapper = new FaturaMapper(ctx);
                fatura = faturaMapper.Create(fatura);

                Parque p = new Parque();
                p.Nome     = "brasil";
                p.Email    = "*****@*****.**";
                p.Morada   = "Rio de Janeiro, Rua Junqueiro 367";
                p.Estrelas = 5;

                ParqueMapper parqueMap = new ParqueMapper(ctx);
                p = parqueMap.Create(p);

                Alojamento alojamento = new Alojamento
                {
                    Nome        = "Primeiro Alojamento",
                    Localizaçao = "Quinta da Marinha",
                    Descrição   = "T0 com duche",
                    MaxPessoas  = 5,
                    PreçoBase   = 85,
                    Parque      = p
                };

                AlojamentoMapper alojamentoMapper = new AlojamentoMapper(ctx);
                alojamento = alojamentoMapper.Create(alojamento);

                Bungalow bungalow = new Bungalow()
                {
                    Tipologia  = "T2",
                    Alojamento = alojamento
                };

                BungalowMapper bungalowMapper = new BungalowMapper(ctx);
                bungalow = bungalowMapper.Create(bungalow);

                ComponenteFatura componenteFatura = new ComponenteFatura
                {
                    Preço     = 85,
                    Fatura    = fatura,
                    Tipo      = "Alojamento",
                    Descrição = "muito bom"
                };

                var componenteMapper = new ComponenteFaturaMapper(ctx);
                componenteFatura = componenteMapper.Create(componenteFatura);

                Atividade atividade = new Atividade
                {
                    Parque        = p,
                    DataAtividade = new DateTime(2017, 1, 1),
                    Descrição     = "Canoagem",
                    Preço         = 90,
                    Lotaçao       = 12,
                    NomeAtividade = "Canoagem"
                };

                AtividadeMapper atividadeMapper = new AtividadeMapper(ctx);
                atividade = atividadeMapper.Create(atividade);

                var inscr = new InscreverHóspedeEmAtividade(ctx);
                inscr.Execute(hóspede.Nif, atividade.NomeAtividade, p.Nome);

                var pagamento = new PagamentoEstadaComFatura(ctx);
                pagamento.Execute(estada.Id, out int total);

                // atualizar valor final da fatura
                fatura.ValorFinal = total;
                fatura            = faturaMapper.Update(fatura);

                Assert.AreEqual(175, fatura.ValorFinal);

                var hospedeAtividadeMapper = new HóspedeAtividadeMapper(ctx);

                foreach (var ha in hospedeAtividadeMapper.ReadAll())
                {
                    hospedeAtividadeMapper.Delete(ha);
                }

                foreach (var b in bungalowMapper.ReadAll())
                {
                    bungalowMapper.Delete(b);
                }

                foreach (var c in componenteMapper.ReadAll())
                {
                    componenteMapper.Delete(c);
                }

                foreach (var f in faturaMapper.ReadAll())
                {
                    faturaMapper.Delete(f);
                }

                foreach (var s in atividadeMapper.ReadAll())
                {
                    atividadeMapper.Delete(s);
                }

                foreach (var e in estadaHospedeMapper.ReadAll())
                {
                    estadaHospedeMapper.Delete(e);
                }

                foreach (var hospede in hóspedeMapper.ReadAll())
                {
                    hóspedeMapper.Delete(hospede);
                }

                foreach (var e in estadaMapper.ReadAll())
                {
                    estadaMapper.Delete(estada);
                }

                foreach (var a in alojamentoMapper.ReadAll())
                {
                    alojamentoMapper.Delete(a);
                }

                foreach (var parque in parqueMap.ReadAll())
                {
                    parqueMap.Delete(parque);
                }
            }
        }
Exemplo n.º 7
0
        public void ApagarParqueEAssociaçoesTest()
        {
            using (var ctx = new Context(_connectionString))
            {
                EstadaMapper     estadaMapper     = new EstadaMapper(ctx);
                ParqueMapper     parqueMap        = new ParqueMapper(ctx);
                AlojamentoMapper alojamentoMapper = new AlojamentoMapper(ctx);
                var estadaAlojamentoMapper        = new EstadaAlojamentoMapper(ctx);
                try
                {
                    var estada = new Estada
                    {
                        DataInicio = new DateTime(2007, 3, 1),
                        DataFim    = new DateTime(2017, 3, 1),
                        Id         = 25,
                        NifHospede = 0
                    };


                    estada = estadaMapper.Create(estada);


                    /*
                     * CREATE PARQUE
                     */
                    Parque p = new Parque();
                    p.Nome     = "brasil";
                    p.Email    = "*****@*****.**";
                    p.Morada   = "Rio de Janeiro, Rua Junqueiro 367";
                    p.Estrelas = 5;


                    p = parqueMap.Create(p);

                    /*
                     * Alojamento
                     */


                    Alojamento c = new Alojamento
                    {
                        PreçoBase   = 50,
                        Nome        = "OI",
                        Descrição   = "sem descricao",
                        Localizaçao = "Brasil",
                        MaxPessoas  = 20,
                        Parque      = p
                    };


                    c = alojamentoMapper.Create(c);


                    EstadaAlojamento estadaAlojamento = new EstadaAlojamento()
                    {
                        Estada     = estada,
                        Alojamento = c,
                        Descrição  = "OLA",
                        PreçoBase  = 1234
                    };



                    estadaAlojamento = estadaAlojamentoMapper.Create(estadaAlojamento);


                    var apagrParque = new ApagarParqueEAssociaçoes(ctx);
                    apagrParque.Execute(p);

                    var parqueExists = parqueMap.ReadAll().Any(parque => parque.Nome.Equals(p.Nome));
                    Assert.AreEqual(false, parqueExists);

                    var alojamentoExists = alojamentoMapper.ReadAll().Any(a => a.Nome.Equals(c.Nome));
                    Assert.AreEqual(false, alojamentoExists);

                    var estadaExists = estadaMapper.ReadAll().Any(e => e.Id == estada.Id);
                    Assert.AreEqual(false, estadaExists);
                }
                catch (Exception exception)
                {
                    Console.WriteLine(exception);


                    foreach (var e in estadaAlojamentoMapper.ReadAll())
                    {
                        estadaAlojamentoMapper.Delete(e);
                    }

                    foreach (var e in estadaMapper.ReadAll())
                    {
                        estadaMapper.Delete(e);
                    }


                    foreach (var alojamento in alojamentoMapper.ReadAll())
                    {
                        alojamentoMapper.Delete(alojamento);
                    }


                    foreach (var parque in parqueMap.ReadAll())
                    {
                        parqueMap.Delete(parque);
                    }

                    throw;
                }
            }
        }
Exemplo n.º 8
0
        public void InsertTest()
        {
            using (Context ctx = new Context(_connectionString))
            {
                var estada = new Estada
                {
                    DataInicio = new DateTime(2007, 3, 1),
                    DataFim    = new DateTime(2017, 3, 1),
                    Id         = 25,
                    NifHospede = 0
                };

                EstadaMapper estadaMapper = new EstadaMapper(ctx);
                estada = estadaMapper.Create(estada);


                /*
                 * CREATE PARQUE
                 */
                Parque p = new Parque();
                p.Nome     = "brasil";
                p.Email    = "*****@*****.**";
                p.Morada   = "Rio de Janeiro, Rua Junqueiro 367";
                p.Estrelas = 5;

                ParqueMapper parqueMap = new ParqueMapper(ctx);
                p = parqueMap.Create(p);

                /*
                 * Alojamento
                 */


                Alojamento c = new Alojamento();
                c.PreçoBase   = 50;
                c.Nome        = "OI";
                c.Descrição   = "sem descricao";
                c.Localizaçao = "Brasil";
                c.MaxPessoas  = 20;
                c.Parque      = p;

                AlojamentoMapper alojamentoMapper = new AlojamentoMapper(ctx);
                c = alojamentoMapper.Create(c);



                EstadaAlojamento estadaAlojamento = new EstadaAlojamento()
                {
                    Estada     = estada,
                    Alojamento = c,
                    Descrição  = "OLA",
                    PreçoBase  = 1234
                };

                var estadaAlojamentoMapper = new EstadaAlojamentoMapper(ctx);

                estadaAlojamento = estadaAlojamentoMapper.Create(estadaAlojamento);

                var ee = estadaAlojamentoMapper.Read(new KeyValuePair <string, int>(estadaAlojamento.Alojamento.Nome, estadaAlojamento.Estada.Id));

                Assert.IsNotNull(ee);

                Assert.AreEqual(ee.Alojamento.Nome, estadaAlojamento.Alojamento.Nome);
                Assert.AreEqual(ee.Estada.Id, estadaAlojamento.Estada.Id);



                foreach (var e in estadaAlojamentoMapper.ReadAll())
                {
                    estadaAlojamentoMapper.Delete(e);
                }

                foreach (var e in estadaMapper.ReadAll())
                {
                    estadaMapper.Delete(estada);
                }


                foreach (var alojamento in alojamentoMapper.ReadAll())
                {
                    alojamentoMapper.Delete(alojamento);
                }


                foreach (var parque in parqueMap.ReadAll())
                {
                    parqueMap.Delete(parque);
                }
            }
        }
Exemplo n.º 9
0
        public void TestUpdate()
        {
            Console.WriteLine(" TESTAR UPDATE");

            using (Context ctx = new Context(_connectionString))
            {
                /*
                 * CREATE PARQUE
                 */
                Parque p = new Parque();
                p.Nome     = "brasil";
                p.Email    = "*****@*****.**";
                p.Morada   = "Rio de Janeiro, Rua Junqueiro 367";
                p.Estrelas = 5;

                ParqueMapper parqueMap = new ParqueMapper(ctx);
                p = parqueMap.Create(p);


                var atividade = new Atividade
                {
                    Parque        = p,
                    DataAtividade = new DateTime(2009, 10, 1),
                    Descrição     = "FORA",
                    Preço         = 90,
                    Lotaçao       = 12,
                    NomeAtividade = "HAMBURGER"
                };
                var atividadeMapper = new AtividadeMapper(ctx);
                atividade = atividadeMapper.Create(atividade);

                Assert.IsNotNull(atividade);
                Assert.AreNotEqual(atividade.Número, 0);

                var atividade2 = atividadeMapper.Read(atividade.Número);

                Assert.AreEqual(atividade2.Parque.Nome, atividade.Parque.Nome);
                Assert.AreEqual(atividade2.Número, atividade.Número);
                Assert.AreEqual(atividade2.DataAtividade, atividade.DataAtividade);
                Assert.AreEqual(atividade2.Descrição, atividade.Descrição);


                Assert.AreEqual(atividade2.Lotaçao, atividade.Lotaçao);
                Assert.AreEqual(atividade2.Preço, atividade.Preço);

                var dataAtividade = new DateTime(2010, 10, 1);
                var descrição     = "DENTRO";
                var preço         = 1000;
                var lotaçao       = 112;

                atividade.DataAtividade = dataAtividade;
                atividade.Descrição     = descrição;
                atividade.Preço         = preço;
                atividade.Lotaçao       = lotaçao;

                atividade2 = atividadeMapper.Update(atividade);

                Assert.AreEqual(atividade2.Parque.Nome, atividade.Parque.Nome);
                Assert.AreEqual(atividade2.Número, atividade.Número);

                Assert.AreEqual(atividade2.DataAtividade, atividade.DataAtividade);
                Assert.AreEqual(atividade2.Descrição, atividade.Descrição);
                Assert.AreEqual(atividade2.Lotaçao, atividade.Lotaçao);
                Assert.AreEqual(atividade2.Preço, atividade.Preço);

                Assert.AreEqual(atividade2.DataAtividade, dataAtividade);
                Assert.AreEqual(atividade2.Descrição, descrição);
                Assert.AreEqual(atividade2.Lotaçao, lotaçao);
                Assert.AreEqual(atividade2.Preço, preço);



                /*
                 * REMOVE THE PARQUE
                 */
                foreach (var s in atividadeMapper.ReadAll())
                {
                    atividadeMapper.Delete(s);
                }
                foreach (var parque in parqueMap.ReadAll())
                {
                    parqueMap.Delete(parque);
                }

                Console.WriteLine("REMOVED");
            }
        }