Beispiel #1
0
        public void t_PointCountLess50_Select_ByEventId()
        {
            Guid pointSurveyId = TestHelper.TestGuid2;

            DbTestHelper.LoadSinglePointSurvey(pointSurveyId, TestHelper.TestGuid2, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));
            Observation_ado setupObject = null;

            // backdoor data setup
            DbTestHelper.LoadAdoObjects(delegate(IbaUnitTestEntities iba)
            {
                setupObject = new Observation_ado()
                {
                    Comments          = "asdfasdf asdf adsfa dsfads fasdf adsfasd fadsf awefr34fr34r34 ",
                    SpeciesId         = new Guid(TestHelper.SPECIES_1_ID),
                    EventId           = pointSurveyId,
                    ObservationTypeId = _PointCountLess50TypeId
                };
                iba.AddToObservation_ado(setupObject);
            });
            DbTestHelper.LoadExtraneousObservations(TestHelper.TestGuid3);

            // Exercise the test
            List <PointCountWithin50> selectList = ObservationMapper.SelectAllForEvent <PointCountWithin50>(setupObject.EventId);

            Assert.AreEqual(1, selectList.Count(), "Does not contain just one object");
            PointCountWithin50 result = selectList[0];

            using (IbaUnitTestEntities iba = new IbaUnitTestEntities())
            {
                validateObjectEquality(result, setupObject, iba);
            }
        }
 private static void addABunchOfObservations(List <Observation_ado> obsList, int entries, Guid speciesId, Guid eventId)
 {
     for (int i = 0; i < entries; i++)
     {
         obsList.Add(Observation_ado.CreateObservation_ado(0, eventId, speciesId, LookupConstants.ObservationTypePointLess50m));
     }
 }
Beispiel #3
0
        public void t_PointCountLess50_Delete()
        {
            Observation_ado setupObject = null;

            // backdoor data setup
            DbTestHelper.LoadAdoObjects(delegate(IbaUnitTestEntities iba)
            {
                setupObject = new Observation_ado()
                {
                    Comments          = "asdfasdf asdf adsfa dsfads fasdf adsfasd fadsf awefr34fr34r34 ",
                    SpeciesId         = new Guid(TestHelper.SPECIES_1_ID),
                    EventId           = TestHelper.TestGuid1,
                    ObservationTypeId = _PointCountLess50TypeId
                };
                iba.AddToObservation_ado(setupObject);
            });
            List <Observation_ado> Observationlist = DbTestHelper.LoadExtraneousObservations(TestHelper.TestGuid3);

            ObservationMapper.Delete(new PointCountWithin50()
            {
                Id = setupObject.ObservationId
            });

            // Validate results
            using (IbaUnitTestEntities iba = new IbaUnitTestEntities())
            {
                var PointCountLess50Query = from PointCountLess50s in iba.Observation_ado
                                            select PointCountLess50s;
                Assert.IsNotNull(PointCountLess50Query, "Query result is null");
                Assert.AreEqual(Observationlist.Count(), PointCountLess50Query.Count(), "Wrong number of results in query");
                validateExtraObservations(Observationlist, PointCountLess50Query);
            }
        }
Beispiel #4
0
        public void t_PointCountLess50_Select_ByGuid()
        {
            Observation_ado setupObject = null;
            // backdoor data setup
            Guid pointSurveyId = TestHelper.TestGuid3;

            DbTestHelper.LoadSinglePointSurvey(pointSurveyId, TestHelper.TestGuid2, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));
            DbTestHelper.LoadAdoObjects(delegate(IbaUnitTestEntities iba)
            {
                setupObject = new Observation_ado()
                {
                    Comments          = "asdfasdf asdf adsfa dsfads fasdf adsfasd fadsf awefr34fr34r34 ",
                    SpeciesId         = new Guid(TestHelper.SPECIES_1_ID),
                    EventId           = pointSurveyId,
                    ObservationTypeId = _PointCountLess50TypeId
                };
                iba.AddToObservation_ado(setupObject);
            });
            DbTestHelper.LoadExtraneousObservations(TestHelper.TestGuid3);

            // Exercise the test
            PointCountWithin50 PointCountLess50 = ObservationMapper.Select <PointCountWithin50>(setupObject.ObservationId);

            using (IbaUnitTestEntities iba = new IbaUnitTestEntities())
            {
                validateObjectEquality(PointCountLess50, setupObject, iba);
            }
        }
        /// <summary>
        /// Loads extra observations to improve testing
        /// </summary>
        /// <returns>List of <see cref="Observation_ado"></see> objects</returns>
        /// <param name="pointSurveyId"></param>
        public static List <Observation_ado> LoadExtraneousObservations(Guid pointSurveyId)
        {
            List <Observation_ado> conditionList = new List <Observation_ado>();

            Guid observationTypeId = SupplementalObservation.ObservationTypeGuid;

            Observation_ado extra1 = Observation_ado.CreateObservation_ado(0, pointSurveyId, new Guid(TestHelper.SPECIES_2_ID), observationTypeId);

            LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                iba.AddToObservation_ado(extra1);
            });
            conditionList.Add(extra1);

            observationTypeId = PointCountBeyond50.ObservationTypeGuid;
            Observation_ado extra2 = Observation_ado.CreateObservation_ado(0, pointSurveyId, new Guid(TestHelper.SPECIES_2_ID), observationTypeId);

            LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                iba.AddToObservation_ado(extra2);
            });
            conditionList.Add(extra2);

            observationTypeId = PointCountWithin50.ObservationTypeGuid;
            Observation_ado extra3 = Observation_ado.CreateObservation_ado(0, pointSurveyId, new Guid(TestHelper.SPECIES_2_ID), observationTypeId);

            LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                iba.AddToObservation_ado(extra3);
            });
            conditionList.Add(extra3);

            return(conditionList);
        }
        public void t_PointCountBeyond50_DeleteTopX()
        {
            Guid   eventId            = TestHelper.TestGuid1;
            Guid   speciesId          = new Guid(TestHelper.SPECIES_2_ID);
            string speciesCode        = TestHelper.SPECIES_2_CODE;
            Guid   observationTypeId1 = LookupConstants.ObservationTypePointLess50m;
            Guid   observationTypeId2 = LookupConstants.ObservationTypeSupplemental;

            DbTestHelper.LoadAdoObjects(delegate(IbaUnitTestEntities iba)
            {
                Observation_ado obs1 = Observation_ado.CreateObservation_ado(0, eventId, speciesId, observationTypeId1);
                iba.AddToObservation_ado(obs1);
                Observation_ado ob2 = Observation_ado.CreateObservation_ado(0, eventId, speciesId, observationTypeId1);
                iba.AddToObservation_ado(ob2);
                Observation_ado obs3 = Observation_ado.CreateObservation_ado(0, eventId, speciesId, observationTypeId1);
                iba.AddToObservation_ado(obs3);
                Observation_ado obs4 = Observation_ado.CreateObservation_ado(0, eventId, speciesId, observationTypeId2);
                iba.AddToObservation_ado(obs4);
            });

            ObservationMapper.DeleteTopX(eventId, observationTypeId1, speciesCode, 2);

            using (IbaUnitTestEntities iba = new IbaUnitTestEntities())
            {
                var observationQuery = from observations in iba.Observation_ado select observations;
                Assert.IsNotNull(observationQuery, "observationQuery is null");
                Assert.AreEqual(2, observationQuery.Count(), "observationQuery has wrong count");
                Assert.AreEqual(1, observationQuery.Count(x => x.ObservationTypeId.Equals(observationTypeId1)), "wrong count for type 1");
                Assert.AreEqual(1, observationQuery.Count(x => x.ObservationTypeId.Equals(observationTypeId2)), "wrong count for type 2");
            }
        }
Beispiel #7
0
        //private static void loadSiteVisit(Guid visitGuid)
        //{
        //    DbTestHelper.LoadAdoObjects((IbaUnitTestEntities iba) =>
        //        {
        //            SiteVisit_ado visit = SiteVisit_ado.CreateSiteVisit_ado(visitGuid, false, TestHelper.TestGuid2, DateTime.Now, DateTime.Now);
        //            iba.AddToSiteVisit_ado(visit);
        //        });
        //}

        private void validateExtraObservations(List <Observation_ado> extraList, IQueryable <Observation_ado> PointCountLess50Query)
        {
            foreach (Observation_ado extra in extraPointCountLess50s(extraList))
            {
                Observation_ado result = PointCountLess50Query.First(x => x.ObservationId == extra.ObservationId);
                Assert.IsNotNull(result, "There is no longer an object with id " + extra.ObservationId.ToString());
                Assert.AreEqual(extra.Comments, result.Comments, "Comments for id " + extra.ObservationId.ToString());
                Assert.AreEqual(extra.EventId, result.EventId, "EventId for id " + extra.ObservationId.ToString());
                Assert.AreEqual(extra.ObservationTypeId, result.ObservationTypeId, "ObservationTypeId  for id " + extra.ObservationId.ToString());
                Assert.AreEqual(extra.SpeciesId, result.SpeciesId, "SpeciesId for id " + extra.ObservationId.ToString());
            }
        }
Beispiel #8
0
        private static void validateObjectEquality(PointCountWithin50 supplemental, Observation_ado adoPointCountLess50, IbaUnitTestEntities iba)
        {
            Assert.IsNotNull(adoPointCountLess50, "There is no PointCountLess50 with the ID to test for");
            Assert.IsNotNull(adoPointCountLess50.Comments, "ADO Comments are null");
            Assert.AreEqual(supplemental.Comments, adoPointCountLess50.Comments, "Comments");
            Assert.AreEqual(supplemental.EventId, adoPointCountLess50.EventId, "EventId");
            // ID is now an identity field
            //Assert.AreEqual(supplemental.Id, adoPointCountLess50.ObservationId, "ObservationId");
            Assert.AreEqual(supplemental.ObservationTypeId, adoPointCountLess50.ObservationTypeId, "ObservationTypeId");
            var speciesQuery = from specieses in iba.Species_ado where specieses.AlphaCode == supplemental.SpeciesCode select specieses.SpeciesId;

            Assert.AreEqual(speciesQuery.First().ToString(), adoPointCountLess50.SpeciesId.ToString(), "SpeciesId");
        }
Beispiel #9
0
        public void t_PointCountLess50_Save_Update()
        {
            //loadSiteVisit(TestHelper.TestGuid1);
            Observation_ado setupObject = null;

            // backdoor data setup
            DbTestHelper.LoadAdoObjects(delegate(IbaUnitTestEntities iba)
            {
                setupObject = new Observation_ado()
                {
                    Comments          = "asdfasdf asdf adsfa dsfads fasdf adsfasd fadsf awefr34fr34r34 ",
                    SpeciesId         = new Guid(TestHelper.SPECIES_1_ID),
                    EventId           = TestHelper.TestGuid1,
                    ObservationTypeId = _PointCountLess50TypeId
                };
                iba.AddToObservation_ado(setupObject);
            });
            List <Observation_ado> extraList = DbTestHelper.LoadExtraneousObservations(TestHelper.TestGuid3);

            // Setup object to be saved. Change everything except the Id.
            PointCountWithin50 testObject = new PointCountWithin50()
            {
                Comments    = "hurdy gurdy",
                SpeciesCode = TestHelper.SPECIES_2_CODE,
                EventId     = setupObject.EventId,
                Id          = setupObject.ObservationId
            };

            // Execute the test
            ObservationMapper.Update(testObject);

            // Validate results
            using (IbaUnitTestEntities iba = new IbaUnitTestEntities())
            {
                var PointCountLess50Query = from PointCountLess50s in iba.Observation_ado select PointCountLess50s;
                Assert.IsNotNull(PointCountLess50Query, "Query result is null");
                Assert.AreEqual(extraList.Count() + 1, PointCountLess50Query.Count(), "Wrong number of results in query");

                Observation_ado adoPointCountLess50 = PointCountLess50Query.First(x => x.ObservationId == setupObject.ObservationId);
                validateObjectEquality(testObject, adoPointCountLess50, iba);

                validateExtraObservations(extraList, PointCountLess50Query);
            }
        }
Beispiel #10
0
        private static void multiBackdoorSetup(Guid eventId, Guid speciesId1, Guid speciesId2, string comments1, string comments2)
        {
            DbTestHelper.LoadAdoObjects(delegate(IbaUnitTestEntities iba)
            {
                Observation_ado obsSpecies1 = Observation_ado.CreateObservation_ado(0, eventId, speciesId1, PointCountWithin50.ObservationTypeGuid);
                obsSpecies1.Comments = comments1;
                iba.AddToObservation_ado(obsSpecies1);

                Observation_ado obsSpecies2 = Observation_ado.CreateObservation_ado(0, eventId, speciesId2, PointCountWithin50.ObservationTypeGuid);
                obsSpecies2.Comments = comments2;
                iba.AddToObservation_ado(obsSpecies2);

                Observation_ado obsSpecies3 = Observation_ado.CreateObservation_ado(0, eventId, speciesId2, PointCountBeyond50.ObservationTypeGuid);
                obsSpecies3.Comments = comments2;
                iba.AddToObservation_ado(obsSpecies3);

                Observation_ado obsSpecies4 = Observation_ado.CreateObservation_ado(0, eventId, speciesId2, PointCountBeyond50.ObservationTypeGuid);
                obsSpecies4.Comments = comments2;
                iba.AddToObservation_ado(obsSpecies4);
            });
        }
Beispiel #11
0
        public void t_SupplementalObservation_Save_Insert()
        {
            //loadSiteVisit(TestHelper.TestGuid1);
            SupplementalObservation supplemental = new SupplementalObservation()
            {
                Comments    = "asdfasdf asdf adsfa dsfads fasdf adsfasd fadsf awefr34fr34r34 ",
                SpeciesCode = TestHelper.SPECIES_1_CODE,
                EventId     = TestHelper.TestGuid1
            };

            ObservationMapper.Insert(supplemental);

            using (IbaUnitTestEntities iba = new IbaUnitTestEntities())
            {
                var SupplementalObservationQuery = from SupplementalObservations in iba.Observation_ado select SupplementalObservations;
                Assert.IsNotNull(SupplementalObservationQuery, "Query result is null");
                Assert.AreEqual(1, SupplementalObservationQuery.Count(), "Wrong number of results in query");
                Observation_ado adoSupplementalObservation = SupplementalObservationQuery.First();
                validateObjectEquality(supplemental, adoSupplementalObservation, iba);
            }
        }
Beispiel #12
0
        public void t_PointCountLess50_Save_Insert()
        {
            //loadSiteVisit(TestHelper.TestGuid1);
            PointCountWithin50 supplemental = new PointCountWithin50()
            {
                Comments    = "asdfasdf asdf adsfa dsfads fasdf adsfasd fadsf awefr34fr34r34 ",
                SpeciesCode = TestHelper.SPECIES_1_CODE,
                EventId     = TestHelper.TestGuid1
            };

            ObservationMapper.Insert(supplemental);

            using (IbaUnitTestEntities iba = new IbaUnitTestEntities())
            {
                var PointCountLess50Query = from PointCountLess50s in iba.Observation_ado select PointCountLess50s;
                Assert.IsNotNull(PointCountLess50Query, "Query result is null");
                Assert.AreEqual(1, PointCountLess50Query.Count(), "Wrong number of results in query");
                Observation_ado adoPointCountLess50 = PointCountLess50Query.First();
                validateObjectEquality(supplemental, adoPointCountLess50, iba);
            }
        }
Beispiel #13
0
        public void tGetSiteBySpecies_Supplemental()
        {
            Guid siteVisitId1 = TestHelper.TestGuid1;
            Guid surveyId1    = TestHelper.TestGuid4;

            DbTestHelper.LoadSingleSiteVisit(siteVisitId1, _siteList[0].LocationId, DateTime.Parse("2010-01-01"));
            DbTestHelper.LoadSamplingPoint(surveyId1, _siteList[0].LocationId);
            DbTestHelper.LoadSinglePointSurvey(surveyId1, siteVisitId1, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));

            DbTestHelper.LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                // Just 1 in week 1 site 1
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, siteVisitId1,
                                                                               new Guid(TestHelper.SPECIES_1_ID), SupplementalObservation.ObservationTypeGuid));
            });

            // Finally, can exercise the system under test
            using (IDataReader reader = iba.Data.Mappers.ResultsMapper.GetSiteBySpecies(new Guid(TestHelper.SPECIES_1_ID), 2010))
            {
                Assert.IsFalse(reader.Read());
            }
        }
Beispiel #14
0
        public void t_Insert()
        {
            FiftyMeterDataEntry entry = new FiftyMeterDataEntry()
            {
                Comments = "comments",
                CountBeyond50 = 1,
                CountWithin50 = 2,
                PointSurveyId = DbTestHelper.TestGuid4,
                SpeciesCode = DbTestHelper.SPECIES_2_CODE
            };

            // Todo: fix this
            FiftyMeterDataEntryFacade.Insert(entry);

            using (IbaUnitTestEntities iba = new IbaUnitTestEntities())
            {
                var observationQuery = from observations in iba.Observation_ado select observations;
                Assert.IsNotNull(observationQuery, "observationQuery is null");
                Assert.AreEqual(3, observationQuery.Count(), "observationQuery has wrong count");

                Observation_ado beyond50 = observationQuery.First(x => x.ObservationTypeId.Equals(PointCountBeyond50.ObservationTypeGuid));
                Assert.IsNotNull(beyond50, "no object added for Beyond 50 count");
                Assert.AreEqual(entry.Comments, beyond50.Comments, "comments beyond");
                Assert.AreEqual(entry.PointSurveyId, beyond50.EventId, "event id beyond");
                Assert.AreEqual(new Guid(DbTestHelper.SPECIES_2_ID), beyond50.SpeciesId, "species ID beyond");

                List<Observation_ado> withinList = observationQuery.Where(x => x.ObservationTypeId.Equals(PointCountWithin50.ObservationTypeGuid)).ToList();
                Assert.IsNotNull(withinList, "withinList is null");

                Assert.AreEqual(entry.Comments, withinList[0].Comments, "within 1 comments");
                Assert.AreEqual(entry.PointSurveyId, withinList[0].EventId, "within 1 event id");
                Assert.AreEqual(new Guid(DbTestHelper.SPECIES_2_ID), withinList[0].SpeciesId, "within 1 species id");

                Assert.AreEqual(entry.Comments, withinList[1].Comments, "within 2 comments");
                Assert.AreEqual(entry.PointSurveyId, withinList[1].EventId, "within 2 event id");
                Assert.AreEqual(new Guid(DbTestHelper.SPECIES_2_ID), withinList[1].SpeciesId, "within 2 species id");
            }
        }
        public void tGetSpeciesCount_Supplemental()
        {
            Guid siteVisitId1 = TestHelper.TestGuid1;
            Guid surveyId1    = TestHelper.TestGuid4;

            DbTestHelper.LoadSingleSiteVisit(siteVisitId1, _siteList[0].LocationId, DateTime.Now);
            DbTestHelper.LoadSamplingPoint(surveyId1, _siteList[0].LocationId);
            DbTestHelper.LoadSinglePointSurvey(surveyId1, siteVisitId1, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));

            DbTestHelper.LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                // Load species 1 into the database
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, siteVisitId1,
                                                                               new Guid(TestHelper.SPECIES_1_ID), SupplementalObservation.ObservationTypeGuid));
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_1_ID), PointCountBeyond50.ObservationTypeGuid));
            });

            // Finally, can exercise the system under test
            DataSet set = ResultsMapper.GetSpeciesCount(DateTime.Now.Year);

            Assert.IsNotNull(set, "DataSet is null");
            Assert.AreEqual(1, set.Tables.Count, "There is not 1 table in the DataSet");

            DataTable table = set.Tables[0];


            Assert.AreEqual(1, table.Rows.Count, "There are not three rows in the results");

            // Results are supposed to be sorted by common name. That means order of Species1, Species3, Species2.
            DataRow species1 = table.Rows[0];

            Assert.AreEqual(TestHelper.SPECIES_1_COMMON, species1["CommonName"], "CommonName wrong row 1");
            Assert.AreEqual(TestHelper.SPECIES_1_SCIENTIFIC, species1["ScientificName"], "ScientificName wrong row 1");
            Assert.AreEqual("1", species1["SpeciesCount"].ToString(), "SpeciesCount wrong row 1");
            Assert.AreEqual(TestHelper.SPECIES_1_ID, species1["SpeciesId"].ToString(), "SpeciesId wrong row 1");
        }
        public void tGetSpeciesCount_Full()
        {
            Guid siteVisitId1 = TestHelper.TestGuid1;
            Guid siteVisitId2 = TestHelper.TestGuid2;
            Guid siteVisitId3 = TestHelper.TestGuid3;
            Guid surveyId1    = TestHelper.TestGuid4;
            Guid surveyId2    = TestHelper.TestGuid5;
            Guid surveyId3    = TestHelper.TestGuid6;

            DbTestHelper.LoadSingleSiteVisit(siteVisitId1, _siteList[0].LocationId, DateTime.Now);
            DbTestHelper.LoadSingleSiteVisit(siteVisitId2, _siteList[1].LocationId, DateTime.Now);
            DbTestHelper.LoadSingleSiteVisit(siteVisitId3, _siteList[2].LocationId, DateTime.Now);
            DbTestHelper.LoadSingleSiteVisit(surveyId1, _siteList[2].LocationId, DateTime.Now.AddYears(-1)); // extra
            DbTestHelper.LoadSamplingPoint(surveyId1, _siteList[0].LocationId);
            DbTestHelper.LoadSamplingPoint(surveyId2, _siteList[1].LocationId);
            DbTestHelper.LoadSamplingPoint(surveyId3, _siteList[2].LocationId);
            DbTestHelper.LoadSinglePointSurvey(surveyId1, siteVisitId1, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));
            DbTestHelper.LoadSinglePointSurvey(surveyId2, siteVisitId2, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));
            DbTestHelper.LoadSinglePointSurvey(surveyId3, siteVisitId3, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));
            DbTestHelper.LoadSinglePointSurvey(siteVisitId1, surveyId1, TestHelper.TestGuid1, DateTime.Now.AddYears(-1), DateTime.Now.AddYears(-1).AddHours(1)); // extra

            DbTestHelper.LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                // Load species 1 into the database
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_1_ID), PointCountWithin50.ObservationTypeGuid));
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_1_ID), PointCountBeyond50.ObservationTypeGuid));

                // species 2
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_2_ID), PointCountBeyond50.ObservationTypeGuid));
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_2_ID), PointCountBeyond50.ObservationTypeGuid));
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_2_ID), PointCountBeyond50.ObservationTypeGuid));
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_2_ID), PointCountWithin50.ObservationTypeGuid));

                // species 3
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_3_ID), PointCountWithin50.ObservationTypeGuid));
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId2,
                                                                               new Guid(TestHelper.SPECIES_3_ID), PointCountWithin50.ObservationTypeGuid));
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId3,
                                                                               new Guid(TestHelper.SPECIES_3_ID), PointCountWithin50.ObservationTypeGuid));

                // extra
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, siteVisitId1,
                                                                               new Guid(TestHelper.SPECIES_1_ID), PointCountBeyond50.ObservationTypeGuid));
            });

            // Finally, can exercise the system under test
            DataSet set = ResultsMapper.GetSpeciesCount(DateTime.Now.Year);

            Assert.IsNotNull(set, "DataSet is null");
            Assert.AreEqual(1, set.Tables.Count, "There is not 1 table in the DataSet");

            DataTable table = set.Tables[0];

            Assert.IsTrue(table.Columns.Contains("CommonName"), "Does not contain CommonName column");
            Assert.IsTrue(table.Columns.Contains("ScientificName"), "Does not contain ScientificName column");
            Assert.IsTrue(table.Columns.Contains("SpeciesCount"), "Does not contain SpeciesCount column");
            Assert.IsTrue(table.Columns.Contains("SpeciesId"), "Does not contain SpeciesId column");

            Assert.AreEqual(3, table.Rows.Count, "There are not three rows in the results");

            // Results are supposed to be sorted by common name. That means order of Species1, Species3, Species2.
            DataRow species1 = table.Rows[0];

            Assert.AreEqual(TestHelper.SPECIES_1_COMMON, species1["CommonName"], "CommonName wrong row 1");
            Assert.AreEqual(TestHelper.SPECIES_1_SCIENTIFIC, species1["ScientificName"], "ScientificName wrong row 1");
            Assert.AreEqual("2", species1["SpeciesCount"].ToString(), "SpeciesCount wrong row 1");
            Assert.AreEqual(TestHelper.SPECIES_1_ID, species1["SpeciesId"].ToString(), "SpeciesId wrong row 1");

            species1 = table.Rows[1];
            Assert.AreEqual(TestHelper.SPECIES_3_COMMON, species1["CommonName"], "CommonName wrong row 2");
            Assert.AreEqual(TestHelper.SPECIES_3_SCIENTIFIC, species1["ScientificName"], "ScientificName wrong row 2");
            Assert.AreEqual("3", species1["SpeciesCount"].ToString(), "SpeciesCount wrong row 2");
            Assert.AreEqual(TestHelper.SPECIES_3_ID, species1["SpeciesId"].ToString(), "SpeciesId wrong row 2");

            species1 = table.Rows[2];
            Assert.AreEqual(TestHelper.SPECIES_2_COMMON, species1["CommonName"], "CommonName wrong row 3");
            Assert.AreEqual(TestHelper.SPECIES_2_SCIENTIFIC, species1["ScientificName"], "ScientificName wrong row 3");
            Assert.AreEqual("4", species1["SpeciesCount"].ToString(), "SpeciesCount wrong row 3");
            Assert.AreEqual(TestHelper.SPECIES_2_ID, species1["SpeciesId"].ToString(), "SpeciesId wrong row 3");
        }
Beispiel #17
0
        [Ignore] // this is getting an XML error and it is not worth trying to fix it right now. 2014-12-26.
        public void t_BMDE_CompleteSurvey_TwoObservations()
        {
            DbTestHelper.LoadSinglePerson(PersonFirstName, PersonLastName, PersonGuid);
            List <Location_ado> locations = DbTestHelper.LoadExtraneousLocations();

            DateTime startDate   = DateTime.Now.AddHours(-2);
            DateTime endDate     = DateTime.Now;
            DateTime surveyDate  = endDate.AddMinutes(-5);
            DateTime surveyDate2 = surveyDate.AddMinutes(-5);

            DbTestHelper.LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                DateTime startDateTimeme = DateTime.Now;
                SiteVisit_ado ado        = SiteVisit_ado.CreateSiteVisit_ado(SiteVisitGuid, true, locations[0].LocationId, startDate,
                                                                             endDate, TestHelper.TestGuid1);
                ado.IsDataEntryComplete = true;
                ado.RecorderId          = PersonGuid;
                ado.ObserverId          = PersonGuid;
                iba.SiteVisit_ado1.AddObject(ado);
            });

            Location_ado point  = locations.First(x => x.ParentLocationId != null);
            Location_ado point2 = locations.Last();

            DbTestHelper.LoadSinglePointSurvey(PointSurveyGuid, SiteVisitGuid, point.LocationId, surveyDate, endDate);
            DbTestHelper.LoadSinglePointSurvey(PointSurveyGuid2, SiteVisitGuid, point2.LocationId, surveyDate2, surveyDate);

            DbTestHelper.LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                Observation_ado observation  = Observation_ado.CreateObservation_ado(0, PointSurveyGuid, new Guid(TestHelper.SPECIES_1_ID), PointCountBeyond50.ObservationTypeGuid);
                Observation_ado observation2 = Observation_ado.CreateObservation_ado(0, PointSurveyGuid, new Guid(TestHelper.SPECIES_1_ID), PointCountBeyond50.ObservationTypeGuid);
                Observation_ado observation3 = Observation_ado.CreateObservation_ado(0, PointSurveyGuid2, new Guid(TestHelper.SPECIES_2_ID), PointCountWithin50.ObservationTypeGuid);
                iba.Observation_ado.AddObject(observation);
                iba.Observation_ado.AddObject(observation2);
                iba.Observation_ado.AddObject(observation3);
            });

            string        bmde     = ResultsMapper.GetBMDE();
            ASCIIEncoding encoding = new ASCIIEncoding();

            using (MemoryStream stream = new MemoryStream(encoding.GetBytes(bmde)))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(ObservationList));
                serializer.UnknownAttribute   += new XmlAttributeEventHandler(serializer_UnknownAttribute);
                serializer.UnknownElement     += new XmlElementEventHandler(serializer_UnknownElement);
                serializer.UnknownNode        += new XmlNodeEventHandler(serializer_UnknownNode);
                serializer.UnreferencedObject += new UnreferencedObjectEventHandler(serializer_UnreferencedObject);
                ObservationList obslist = (ObservationList)serializer.Deserialize(stream);

                Assert.AreEqual(2, obslist.Observation.Count(), "wrong Observation count");
                ObservationListObservation actual = obslist.Observation[0];
                Assert.AreEqual("Yes", actual.AllIndividualsReported, "AllIndividualsReported");
                Assert.AreEqual("observation", actual.BasisOfRecord, "BasisOfRecord");
                Assert.IsTrue(!string.IsNullOrEmpty(actual.CatalogNumber), "CatalogNumber");
                Assert.AreEqual(PersonFirstName + " " + PersonLastName, actual.Collector, "Collector");
                Assert.AreEqual(TestHelper.SPECIES_1_COMMON, actual.CommonName, "CommonName");
                Assert.AreEqual("North America", actual.Continent, "Continent");
                Assert.AreEqual("null", actual.CoordinateUncertainty, "CoordinateUncertainty");
                Assert.AreEqual("United States of America", actual.Country, "Country");
                Assert.AreEqual(startDate.Day, actual.DayCollected, "DayCollected");
                Assert.AreEqual(point.Latitude.Value, actual.DecimalLatitude, "DecimalLatitude");
                Assert.AreEqual(point.Longitude, actual.DecimalLongitude, "DecimalLongitude");
                Assert.AreEqual("Unlimited", actual.DistanceFromObserverMax, "DistanceFromObserverMax");
                Assert.AreEqual("50 m", actual.DistanceFromObserverMin, "DistanceFromObserverMin");
                Assert.AreEqual((endDate - surveyDate).TotalHours.ToString("00.00"), actual.DurationInHours.ToString("00.00"), "DurationInHours");
                string genus   = TestHelper.SPECIES_1_SCIENTIFIC.Split(' ')[0];
                string species = TestHelper.SPECIES_1_SCIENTIFIC.Split(' ')[1];
                Assert.AreEqual(genus, actual.Genus, "Genus");
                Assert.AreEqual(startDate.DayOfYear, actual.JulianDay, "JulianDay");
                Assert.AreEqual(point.LocationName, actual.Locality, "Locality");
                Assert.AreEqual(startDate.Month, actual.MonthCollected, "MonthCollected");
                Assert.AreEqual(1, actual.NumberOfObservers, "NumberOfObservers");
                Assert.AreEqual(2, actual.ObservationCount, "ObservationCount");
                Assert.AreEqual(startDate.ToString("MM/dd/yyyy"), actual.ObservationDate, "ObservationDate");
                Assert.AreEqual("decimal degrees", actual.OriginalCoordinateSystem, "OriginalCoordinateSystem");
                Assert.AreEqual("Homayoun, T. Z. and R. B. Blair. 2009. Citizen-Science Monitoring of Landbirds in the Mississippi River Twin Cities Important Bird Area. Pages 607-616 in T.D., Rich, C. Arizmendi, D. Demarest and C. Thompson, editors. Tundra to Tropics: Connecting Birds, Habitats and People. Proceedings of the 4th International Partners in Flight Conference, 13-16 February 2008, McAllen, TX. Partners in Flight.", actual.ProtocolReference, "ProtocolReference");
                Assert.AreEqual("Point Count", actual.ProtocolType, "ProtocolType");
                Assert.AreEqual("http://www.partnersinflight.org/pubs/McAllenProc/articles/PIF09_Monitoring/Homayoun_PIF09.pdf", actual.ProtocolURL, "ProtocolURL");
                Assert.AreEqual("Restricted", actual.RecordPermissions, "RecordPermissions");
                Assert.AreEqual(locations[0].LocationId.ToString().ToUpper(), actual.RouteIdentifier, "RouteIdentifier");
                Assert.AreEqual(PointSurveyGuid.ToString().ToUpper(), actual.SamplingEventIdentifier, "SamplingEventIdentifier");
                Assert.AreEqual(TestHelper.SPECIES_1_SCIENTIFIC, actual.ScientificName, "ScientificName");
                Assert.AreEqual(TestHelper.SPECIES_1_CODE, actual.SpeciesCode, "SpeciesCode");
                Assert.AreEqual(species, actual.SpecificEpithet, "SpecificEpithet");
                Assert.AreEqual("Minnesota", actual.StateProvince, "StateProvince");
                Assert.AreEqual(point.LocationId.ToString().ToUpper(), actual.SurveyAreaIdentifier, "SurveyAreaIdentifier");
                Assert.AreEqual((surveyDate.TimeOfDay.Hours + surveyDate.TimeOfDay.Minutes / 60.0).ToString("00.00"), actual.TimeCollected.ToString("00.00"), "TimeCollected");
                Assert.AreEqual((endDate.TimeOfDay.Hours + endDate.TimeOfDay.Minutes / 60.0).ToString("00.00"), actual.TimeObservationsEnded.ToString("00.00"), "TimeObservationsEnded");
                Assert.AreEqual(surveyDate.TimeOfDay.TotalHours.ToString("00.00"), actual.TimeObservationsStarted.ToString("00.00"), "TimeObservationsStarted");
                Assert.AreEqual(startDate.Year.ToString(), actual.YearCollected.ToString(), "YearCollected");

                actual = obslist.Observation[1];
                Assert.AreEqual("Yes", actual.AllIndividualsReported, "AllIndividualsReported");
                Assert.AreEqual("observation", actual.BasisOfRecord, "BasisOfRecord");
                Assert.IsTrue(!string.IsNullOrEmpty(actual.CatalogNumber), "CatalogNumber");
                Assert.AreEqual(PersonFirstName + " " + PersonLastName, actual.Collector, "Collector");
                Assert.AreEqual(TestHelper.SPECIES_2_COMMON, actual.CommonName, "CommonName");
                Assert.AreEqual("North America", actual.Continent, "Continent");
                Assert.AreEqual("null", actual.CoordinateUncertainty, "CoordinateUncertainty");
                Assert.AreEqual("United States of America", actual.Country, "Country");
                Assert.AreEqual(startDate.Day, actual.DayCollected, "DayCollected");
                Assert.AreEqual(point2.Latitude.Value, actual.DecimalLatitude, "DecimalLatitude");
                Assert.AreEqual(point2.Longitude, actual.DecimalLongitude, "DecimalLongitude");
                Assert.AreEqual("50 m", actual.DistanceFromObserverMax, "DistanceFromObserverMax");
                Assert.AreEqual("0 m", actual.DistanceFromObserverMin, "DistanceFromObserverMin");
                Assert.AreEqual((surveyDate - surveyDate2).TotalHours.ToString("00.00"), actual.DurationInHours.ToString("00.00"), "DurationInHours");
                genus   = TestHelper.SPECIES_2_SCIENTIFIC.Split(' ')[0];
                species = TestHelper.SPECIES_2_SCIENTIFIC.Split(' ')[1];
                Assert.AreEqual(genus, actual.Genus, "Genus");
                Assert.AreEqual(startDate.DayOfYear, actual.JulianDay, "JulianDay");
                Assert.AreEqual(point.LocationName, actual.Locality, "Locality");
                Assert.AreEqual(startDate.Month, actual.MonthCollected, "MonthCollected");
                Assert.AreEqual(1, actual.NumberOfObservers, "NumberOfObservers");
                Assert.AreEqual(1, actual.ObservationCount, "ObservationCount");
                Assert.AreEqual(startDate.ToString("MM/dd/yyyy"), actual.ObservationDate, "ObservationDate");
                Assert.AreEqual("decimal degrees", actual.OriginalCoordinateSystem, "OriginalCoordinateSystem");
                Assert.AreEqual("Homayoun, T. Z. and R. B. Blair. 2009. Citizen-Science Monitoring of Landbirds in the Mississippi River Twin Cities Important Bird Area. Pages 607-616 in T.D., Rich, C. Arizmendi, D. Demarest and C. Thompson, editors. Tundra to Tropics: Connecting Birds, Habitats and People. Proceedings of the 4th International Partners in Flight Conference, 13-16 February 2008, McAllen, TX. Partners in Flight.", actual.ProtocolReference, "ProtocolReference");
                Assert.AreEqual("Point Count", actual.ProtocolType, "ProtocolType");
                Assert.AreEqual("http://www.partnersinflight.org/pubs/McAllenProc/articles/PIF09_Monitoring/Homayoun_PIF09.pdf", actual.ProtocolURL, "ProtocolURL");
                Assert.AreEqual("Restricted", actual.RecordPermissions, "RecordPermissions");
                Assert.AreEqual(locations[0].LocationId.ToString().ToUpper(), actual.RouteIdentifier, "RouteIdentifier");
                Assert.AreEqual(PointSurveyGuid2.ToString().ToUpper(), actual.SamplingEventIdentifier, "SamplingEventIdentifier");
                Assert.AreEqual(TestHelper.SPECIES_2_SCIENTIFIC, actual.ScientificName, "ScientificName");
                Assert.AreEqual(TestHelper.SPECIES_2_CODE, actual.SpeciesCode, "SpeciesCode");
                Assert.AreEqual(species, actual.SpecificEpithet, "SpecificEpithet");
                Assert.AreEqual("Minnesota", actual.StateProvince, "StateProvince");
                Assert.AreEqual(point.LocationId.ToString().ToUpper(), actual.SurveyAreaIdentifier, "SurveyAreaIdentifier");
                Assert.AreEqual((surveyDate2.TimeOfDay.Hours + surveyDate2.TimeOfDay.Minutes / 60.0).ToString("00.00"), actual.TimeCollected.ToString("00.00"), "TimeCollected");
                Assert.AreEqual((surveyDate.TimeOfDay.Hours + surveyDate.TimeOfDay.Minutes / 60.0).ToString("00.00"), actual.TimeObservationsEnded.ToString("00.00"), "TimeObservationsEnded");
                Assert.AreEqual(surveyDate2.TimeOfDay.TotalHours.ToString("00.00"), actual.TimeObservationsStarted.ToString("00.00"), "TimeObservationsStarted");
                Assert.AreEqual(startDate.Year.ToString(), actual.YearCollected.ToString(), "YearCollected");
            }
        }
        public void t_GetCommunityBreeding()
        {
            DateTime breedingdate1 = new DateTime(2010, 07, 01);
            DateTime breedingdate2 = new DateTime(2010, 06, 11);
            DateTime breedingdate3 = new DateTime(2009, 06, 11, 9, 32, 0);

            List <Location_ado> siteList    = DbTestHelper.LoadSites();
            SiteVisit_ado       visit1      = DbTestHelper.LoadSingleSiteVisit(TestHelper.TestGuid1, siteList[0].LocationId, breedingdate1);
            SiteVisit_ado       visit2      = DbTestHelper.LoadSingleSiteVisit(TestHelper.TestGuid2, siteList[1].LocationId, breedingdate2);
            SiteVisit_ado       extra       = DbTestHelper.LoadSingleSiteVisit(TestHelper.TestGuid3, siteList[0].LocationId, breedingdate3);
            PointSurvey_ado     surveyExtra = DbTestHelper.LoadSinglePointSurvey(TestHelper.TestGuid5, extra.EventId, TestHelper.TestGuid1, breedingdate3, breedingdate3.AddMinutes(5));
            PointSurvey_ado     survey1     = DbTestHelper.LoadSinglePointSurvey(TestHelper.TestGuid3, visit1.EventId, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));
            PointSurvey_ado     survey2     = DbTestHelper.LoadSinglePointSurvey(TestHelper.TestGuid4, visit2.EventId, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));

            // To make this test interesting, there must be several factors:
            // A supplemental to ignore
            // At least one observation inside of 50m
            // At least one outside of 50m for each species
            // A site that has count of zero therefore shouldn't show up
            // And relative abundance cannot calculate as zero
            Observation_ado supplementalSite1   = Observation_ado.CreateObservation_ado(0, visit1.EventId, new Guid(TestHelper.SPECIES_1_ID), LookupConstants.ObservationTypeSupplemental);
            Observation_ado site1Species1Beyond = Observation_ado.CreateObservation_ado(0, survey1.EventId, new Guid(TestHelper.SPECIES_1_ID), LookupConstants.ObservationTypePointBeyond50m);
            Observation_ado site1Species1Less   = Observation_ado.CreateObservation_ado(0, survey1.EventId, new Guid(TestHelper.SPECIES_1_ID), LookupConstants.ObservationTypePointLess50m);
            Observation_ado site1Species1Less2  = Observation_ado.CreateObservation_ado(0, survey1.EventId, new Guid(TestHelper.SPECIES_1_ID), LookupConstants.ObservationTypePointLess50m);
            Observation_ado site1Species2Beyond = Observation_ado.CreateObservation_ado(0, survey1.EventId, new Guid(TestHelper.SPECIES_2_ID), LookupConstants.ObservationTypePointBeyond50m);
            Observation_ado site1Species3Less   = Observation_ado.CreateObservation_ado(0, survey1.EventId, new Guid(TestHelper.SPECIES_3_ID), LookupConstants.ObservationTypePointLess50m);
            Observation_ado site1Species3Beyond = Observation_ado.CreateObservation_ado(0, survey1.EventId, new Guid(TestHelper.SPECIES_3_ID), LookupConstants.ObservationTypePointBeyond50m);
            Observation_ado site2Species3Beyond = Observation_ado.CreateObservation_ado(0, survey2.EventId, new Guid(TestHelper.SPECIES_3_ID), LookupConstants.ObservationTypePointBeyond50m);
            Observation_ado site2Species3Less   = Observation_ado.CreateObservation_ado(0, survey2.EventId, new Guid(TestHelper.SPECIES_3_ID), LookupConstants.ObservationTypePointLess50m);
            Observation_ado site2Species2Beyond = Observation_ado.CreateObservation_ado(0, survey2.EventId, new Guid(TestHelper.SPECIES_2_ID), LookupConstants.ObservationTypePointBeyond50m);
            Observation_ado site2Species2Less   = Observation_ado.CreateObservation_ado(0, survey2.EventId, new Guid(TestHelper.SPECIES_2_ID), LookupConstants.ObservationTypePointLess50m);
            Observation_ado extraObservation    = Observation_ado.CreateObservation_ado(0, surveyExtra.EventId, new Guid(TestHelper.SPECIES_1_ID), LookupConstants.ObservationTypePointBeyond50m);

            DbTestHelper.LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                iba.AddToObservation_ado(supplementalSite1);
                iba.AddToObservation_ado(site1Species1Beyond);
                iba.AddToObservation_ado(site1Species2Beyond);
                iba.AddToObservation_ado(site2Species3Beyond);
                iba.AddToObservation_ado(site1Species1Less);
                iba.AddToObservation_ado(site1Species1Less2);
                iba.AddToObservation_ado(site2Species3Less);
                iba.AddToObservation_ado(site1Species3Less);
                iba.AddToObservation_ado(site2Species2Beyond);
                iba.AddToObservation_ado(site2Species2Less);
                iba.AddToObservation_ado(extraObservation);
                iba.SaveChanges();
            });

            DataSet resultSet = mappers.ResultsMapper.GetCommunityBreeding(2010);

            Assert.IsNotNull(resultSet, "Resultset is null");
            Assert.AreEqual(1, resultSet.Tables.Count, "Wrong table count");


            DataTable table = resultSet.Tables[0];


            Assert.IsTrue(table.Columns.Contains("LocationName"), "Missing LocationName column");
            Assert.IsTrue(table.Columns.Contains("Richness"), "Missing Richness column");
            Assert.IsTrue(table.Columns.Contains("DiversityIndex"), "Missing DiversityIndex column");
            Assert.IsTrue(table.Columns.Contains("Evenness"), "Missing Evenness column");
            Assert.AreEqual(2, table.Rows.Count, "Wrong row count");

            var locationQuery = from locs
                                in table.AsEnumerable()
                                //where locs.Field<Guid>("LocationId").Equals(siteList[0].LocationId)
                                select new
            {
                LocationId   = locs.Field <Guid>("LocationId"),
                LocationName = locs.Field <string>("LocationName"),
                Richness     = locs.Field <int>("Richness"),
                Diversity    = locs.Field <decimal>("DiversityIndex"),
                Evenness     = locs.Field <decimal>("Evenness")
            };
            var result = from l1 in locationQuery where l1.LocationName.Equals(siteList[0].LocationName) select l1;

            Assert.AreEqual(1, result.Count(), "does not contain row for location 1");
            Assert.AreEqual(siteList[0].LocationId, result.First().LocationId, "wrong location ID for location 1");
            Assert.AreEqual(3, result.First().Richness, "Wrong Richness for location 1");
            Assert.AreEqual(0.8044m, result.First().Diversity, "Wrong DiversityIndex for location 1");
            Assert.AreEqual(0.7322m, result.First().Evenness, "Wrong Evenness for location 1");

            result = from l1 in locationQuery where l1.LocationName.Equals(siteList[1].LocationName) select l1;
            Assert.AreEqual(1, result.Count(), "does not contain row for location 2");
            Assert.AreEqual(siteList[1].LocationId, result.First().LocationId, "wrong location ID for location 2");
            Assert.AreEqual(2, result.First().Richness, "Wrong Richness for location 2");
            Assert.AreEqual(0.5828m, result.First().Diversity, "Wrong DiversityIndex for location 2");
            Assert.AreEqual(0.8409m, result.First().Evenness, "Wrong Evenness for location 2");
        }
Beispiel #19
0
        public void tGetSiteBySpecies_Full()
        {
            Guid siteVisitId1 = TestHelper.TestGuid1;
            Guid siteVisitId2 = TestHelper.TestGuid2;
            Guid siteVisitId3 = TestHelper.TestGuid3;
            Guid surveyId1    = TestHelper.TestGuid4;
            Guid surveyId2    = TestHelper.TestGuid5;
            Guid surveyId3    = TestHelper.TestGuid6;

            // Week 1 site 1, visit 1
            DbTestHelper.LoadSingleSiteVisit(siteVisitId1, _siteList[0].LocationId, DateTime.Parse("2010-01-01"));
            // Week 2 site 1, visit 2
            DbTestHelper.LoadSingleSiteVisit(siteVisitId2, _siteList[0].LocationId, DateTime.Parse("2010-01-09"));
            // Week 2 site 2, visit 1
            DbTestHelper.LoadSingleSiteVisit(siteVisitId3, _siteList[1].LocationId, DateTime.Parse("2010-01-08"));
            DbTestHelper.LoadSamplingPoint(surveyId1, _siteList[0].LocationId);
            DbTestHelper.LoadSamplingPoint(surveyId2, _siteList[0].LocationId);
            DbTestHelper.LoadSamplingPoint(surveyId3, _siteList[1].LocationId);
            DbTestHelper.LoadSinglePointSurvey(surveyId1, siteVisitId1, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));
            DbTestHelper.LoadSinglePointSurvey(surveyId2, siteVisitId2, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));
            DbTestHelper.LoadSinglePointSurvey(surveyId3, siteVisitId3, TestHelper.TestGuid1, DateTime.Now, DateTime.Now.AddHours(1));

            // Different year
            DbTestHelper.LoadSingleSiteVisit(surveyId1, _siteList[0].LocationId, DateTime.Parse("2009-06-06"));
            DbTestHelper.LoadSinglePointSurvey(siteVisitId1, surveyId1, TestHelper.TestGuid4, DateTime.Parse("2009-06-06 11:00 AM"), DateTime.Parse("2009-06-06 11:05 AM"));


            DbTestHelper.LoadAdoObjects((IbaUnitTestEntities iba) =>
            {
                // Just 1 in week 1 site 1
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId1,
                                                                               new Guid(TestHelper.SPECIES_1_ID), PointCountWithin50.ObservationTypeGuid));
                // Two in week 2 site 1
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId2,
                                                                               new Guid(TestHelper.SPECIES_1_ID), PointCountBeyond50.ObservationTypeGuid));
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId2,
                                                                               new Guid(TestHelper.SPECIES_1_ID), PointCountWithin50.ObservationTypeGuid));
                // One beyond 50 in week 2 site 2
                iba.AddToObservation_ado(Observation_ado.CreateObservation_ado(0, surveyId3,
                                                                               new Guid(TestHelper.SPECIES_1_ID), PointCountBeyond50.ObservationTypeGuid));
            });

            // Finally, can exercise the system under test
            using (IDataReader reader = iba.Data.Mappers.ResultsMapper.GetSiteBySpecies(new Guid(TestHelper.SPECIES_1_ID), 2010))
            {
                // Results are supposed to be sorted by location name.
                Assert.IsTrue(reader.Read(), "missing row 1");
                Assert.AreEqual("Location 1", reader.GetString(reader.GetOrdinal("LocationName")), "LocationName wrong row 1");
                Assert.AreEqual("1", reader.GetValue(reader.GetOrdinal("Week")).ToString(), "Week wrong row 1");
                Assert.AreEqual("1", reader.GetValue(reader.GetOrdinal("SpeciesCount")).ToString(), "SpeciesCount wrong row 1");

                Assert.IsTrue(reader.Read(), "missing row 2");
                Assert.AreEqual("Location 1", reader.GetString(reader.GetOrdinal("LocationName")), "LocationName wrong row 2");
                Assert.AreEqual("2", reader.GetValue(reader.GetOrdinal("Week")).ToString(), "Week wrong row 2");
                Assert.AreEqual("2", reader.GetValue(reader.GetOrdinal("SpeciesCount")).ToString(), "SpeciesCount wrong row 2");

                Assert.IsTrue(reader.Read(), "missing row 3");
                Assert.AreEqual("Location 2", reader.GetString(reader.GetOrdinal("LocationName")), "LocationName wrong row 3");
                Assert.AreEqual("2", reader.GetValue(reader.GetOrdinal("Week")).ToString(), "Week wrong row 3");
                Assert.AreEqual("1", reader.GetValue(reader.GetOrdinal("SpeciesCount")).ToString(), "SpeciesCount wrong row 3");
            }
        }
Beispiel #20
0
        private static void validateObjectEquality(SupplementalObservation supplemental, Observation_ado adoSupplementalObservation, IbaUnitTestEntities iba)
        {
            Assert.IsNotNull(adoSupplementalObservation, "There is no SupplementalObservation with the ID to test for");
            Assert.IsNotNull(adoSupplementalObservation.Comments, "ADO Comments are null");
            Assert.AreEqual(supplemental.Comments, adoSupplementalObservation.Comments, "Comments");
            Assert.AreEqual(supplemental.EventId, adoSupplementalObservation.EventId, "EventId");
            // ID is now an identity field, so these should not match
            //Assert.AreEqual(supplemental.Id, adoSupplementalObservation.ObservationId, "ObservationId");
            Assert.AreEqual(supplemental.ObservationTypeId, adoSupplementalObservation.ObservationTypeId, "ObservationTypeId");
            var speciesQuery = from specieses in iba.Species_ado where specieses.AlphaCode == supplemental.SpeciesCode select specieses.SpeciesId;

            Assert.AreEqual(speciesQuery.First().ToString(), adoSupplementalObservation.SpeciesId.ToString(), "SpeciesId");
        }