コード例 #1
0
        public void IncidentSummaryQueryService_FindIncidentOfficerInvolvedShooting()
        {
            // Create ReportId
            var systemQuery = GetDependency <ISystemQueryService>();

            Assert.IsInstanceOfType(systemQuery, typeof(ISystemQueryService));
            var fICommandService = GetDependency <IIncidentSummaryCommandService>();

            Assert.IsInstanceOfType(fICommandService, typeof(IIncidentSummaryCommandService));

            var incidentDetails = MockObjects.NewIncidentSummary;

            Guid summaryId = fICommandService.CreateIncidentSummary(systemQuery.GetAgencies()[0].AgencyId, "Random Case #" + new Random().Next(int.MaxValue), incidentDetails);

            Assert.IsInstanceOfType(summaryId, typeof(Guid));
            Assert.AreNotEqual(summaryId, Guid.Empty);

            // Create OfficerInvolvedShooting
            Guid officerInvolvedShootingId = fICommandService.CreateIncidentOfficerInvolvedShooting(summaryId, MockObjects.NewIncidentOfficerInvolvedShooting);

            Assert.IsInstanceOfType(officerInvolvedShootingId, typeof(Guid));
            Assert.AreNotEqual(officerInvolvedShootingId, Guid.Empty);

            // Find
            var iSummaryQueryService = GetDependency <IIncidentSummaryQueryService>();

            Assert.IsInstanceOfType(iSummaryQueryService, typeof(IIncidentSummaryQueryService));
            IncidentOfficerInvolvedShooting incidentOfficerInvolvedShooting = iSummaryQueryService.FindIncidentOfficerInvolvedShooting(officerInvolvedShootingId);

            Assert.IsNotNull(incidentOfficerInvolvedShooting);
        }
コード例 #2
0
        public void IncidentReportQueryService_FindIncidentOfficerInvolvedShooting()
        {
            var iCommandService = GetDependency <IIncidentReportCommandService>();

            Assert.IsInstanceOfType(iCommandService, typeof(IIncidentReportCommandService));
            Guid reportId = GetReportId();

            Assert.IsInstanceOfType(reportId, typeof(Guid));
            Assert.AreNotEqual(reportId, Guid.Empty);

            // Create incident Gun section
            var  shootingDetails = MockObjects.NewIncidentOfficerInvolvedShooting;
            Guid incidentOfficerInvolvedShootingId = iCommandService.CreateIncidentOfficerInvolvedShooting(reportId, shootingDetails);

            Assert.IsInstanceOfType(incidentOfficerInvolvedShootingId, typeof(Guid));
            Assert.AreNotEqual(incidentOfficerInvolvedShootingId, Guid.Empty);

            // Find incident Gun section
            var incidentReportQueryService = GetDependency <IIncidentReportQueryService>();

            Assert.IsInstanceOfType(incidentReportQueryService, typeof(IIncidentReportQueryService));
            IncidentOfficerInvolvedShooting reportDetails = incidentReportQueryService.FindIncidentOfficerInvolvedShooting(incidentOfficerInvolvedShootingId);

            Assert.IsNotNull(reportDetails);
            Assert.AreEqual(incidentOfficerInvolvedShootingId, reportDetails.Id);
            Assert.AreEqual(shootingDetails.WeaponType, reportDetails.WeaponType);
        }
コード例 #3
0
        private void SetUpIncidentShooting()
        {
            var incidentShooting = new IncidentOfficerInvolvedShooting(DataEntryUnitTestFixture.IdentityId, DataEntryUnitTestFixture.AgencyDetails.Id, Guid.NewGuid());

            _summariesUnitOfWork.Setup(mock => mock.Find <IncidentOfficerInvolvedShooting>(It.IsAny <Guid>(), It.IsAny <TrackingMode>(), It.IsAny <ThrowIf>()))
            .Returns(incidentShooting);
            _incidentSummary.OfficerInvolvedShootings.Add(incidentShooting);
            _incidentShootingId = incidentShooting.Id;
        }
コード例 #4
0
        public void FindIncidentOfficerInvolvedShooting()
        {
            var incidentOfficerInvolvedShooting = new IncidentOfficerInvolvedShooting(DataEntryUnitTestFixture.IdentityId, DataEntryUnitTestFixture.AgencyDetails.Id, Guid.NewGuid());

            _reportsUnitOfWork.Setup(mock => mock.Find <IncidentOfficerInvolvedShooting>(It.IsAny <Guid>(), It.IsAny <TrackingMode>(), It.IsAny <ThrowIf>())).Returns(incidentOfficerInvolvedShooting);
            var incidentOfficerInvolvedShootingReport = _incidentReportQueryService.FindIncidentOfficerInvolvedShooting(It.IsAny <Guid>());

            incidentOfficerInvolvedShootingReport.Should().NotBeNull();
        }
コード例 #5
0
        public void FindIncidentOfficerInvolvedShootingReportId()
        {
            var incidentReportList = new List <IncidentReport>();

            incidentReportList.Add(_incidentReport);
            _reportsUnitOfWork.Setup(mock => mock.GetEntityQuery <IncidentReport>(It.IsAny <TrackingMode>())).Returns(incidentReportList.AsQueryable());
            var incidentOfficerInvolvedShooting = new IncidentOfficerInvolvedShooting(DataEntryUnitTestFixture.IdentityId, DataEntryUnitTestFixture.AgencyDetails.Id, Guid.NewGuid());

            _incidentReport.OfficerInvolvedShootings.Add(incidentOfficerInvolvedShooting);
            var incidentOfficerInvolvedShootingReportId = _incidentReportQueryService.FindIncidentOfficerInvolvedShootingReportId(incidentOfficerInvolvedShooting.Id);

            incidentOfficerInvolvedShootingReportId.Should().NotBeEmpty();
            Assert.AreEqual(_incidentReport.Id, incidentOfficerInvolvedShootingReportId);
        }