示例#1
0
        public static ResolvedServiceStop CreateResolvedArrivalStop(
            string timetableId       = "X12345",
            StpIndicator indicator   = StpIndicator.Permanent,
            ICalendar calendar       = null,
            ScheduleLocation[] stops = null,
            int id                 = 1,
            CifService service     = null,
            string retailServiceId = null,
            DateTime on            = default(DateTime),
            bool isCancelled       = false,
            Station atLocation     = null,
            Time when              = default(Time))
        {
            on = on == default(DateTime) ? MondayAugust12 : on;
            var schedule = CreateSchedule(timetableId, indicator, calendar, stops, service, retailServiceId);
            var resolved = new ResolvedService(schedule, on, isCancelled);

            var destination = schedule.Locations.Last() as ScheduleStop;

            atLocation = atLocation ?? destination.Station;
            when       = when.Equals(default(Time)) ? destination.Arrival : when;
            var find = new StopSpecification(atLocation, when, on, TimesToUse.Arrivals);

            resolved.TryFindStop(find, out var stop);
            return(stop);
        }
示例#2
0
        private static Model.FoundSummaryItem MapResolvedStop(Timetable.CifSchedule schedule = null,
                                                              Timetable.Station at           = null, Time?time = null,
                                                              Timetable.Station from         = null, Timetable.Station to = null)
        {
            schedule = schedule ?? TestSchedules.CreateScheduleWithService();
            at       = at ?? TestStations.Surbiton;
            time     = time ?? TestSchedules.Ten;
            var find = new StopSpecification(at, time.Value, TestDate, TimesToUse.Departures);

            var resolved = new ResolvedService(schedule, TestDate, false);

            resolved.TryFindStop(find, out var stop);
            if (to != null)
            {
                stop.GoesTo(to);
            }
            if (from != null)
            {
                stop.ComesFrom(from);
            }

            var mapper = ToViewProfileConfiguration.CreateMapper();

            return(mapper.Map <Timetable.ResolvedServiceStop, Model.FoundSummaryItem>(stop, opts => opts.Items["On"] = stop.On));
        }
        public async Task DeleteAsyncShould_ReturnsTrueAnd_DeletesCorrectResolvedIssue()
        {
            //Arrange
            var activityService = new Mock <IManagerActivityService>();
            var pictureService  = IPictureServiceMock.New(DefaultPicId);
            var issueService    = new Mock <IManagerIssueService>();

            var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object);

            var(managerId, secondIssue, secondResolved, resolved) =
                await ResolvedCreator.CreateResolvedManagerAndIssue(Db);

            //Act
            var result = await service.DeleteAsync(managerId, secondResolved.Id);

            var resolvedIssuesAfter = await this.Db.ResolvedIssues.ToListAsync();

            var urbanIssueAfter = await this.Db.UrbanIssues.Where(i => i.Id == secondIssue.Id).FirstOrDefaultAsync();

            //Assert
            result.Should().BeTrue();

            Db.ResolvedIssues.Should().HaveCount(resolvedIssuesAfter.Count);

            Db.ResolvedIssues.Should().BeEquivalentTo(resolvedIssuesAfter);

            urbanIssueAfter.ResolvedIssue.Should().BeNull();

            issueService.Verify(i => i.RemoveResolvedReferenceAsync(It.IsAny <int>()), Times.Once);

            pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Once);

            activityService.Verify(a =>
                                   a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Once);
        }
        public async Task UpdateAsyncShould_ReturnsTrueAnd_ChangesResolvedPictureFileHasPassed()
        {
            //Arrange
            var issueService    = new Mock <IManagerIssueService>();
            var pictureService  = IPictureServiceMock.New(DefaultPicId);
            var activityService = new Mock <IManagerActivityService>();

            var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object);

            var(manager, resolved) = await ResolvedCreator.CreateResolvedAndManager(Db);

            var file = new Mock <IFormFile>();

            var oldImage = resolved.CloudinaryImage;

            //Act
            var result = await service.UpdateAsync(manager.Id, resolved.Id, ChangedDescription, file.Object);

            //Assert
            result.Should().BeTrue();

            resolved.CloudinaryImage.Should().NotBe(oldImage);
            resolved.CloudinaryImageId.Should().Be(DefaultPicId);

            resolved.Description.Should().NotMatch(DefaultDescription);
            resolved.Description.Should().Match(ChangedDescription);

            pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Once);

            activityService.Verify(a =>
                                   a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Once);
        }
示例#5
0
 public S Convert(ResolvedService source, S destination, ResolutionContext context)
 {
     if (source is Timetable.ResolvedServiceWithAssociations withAssociations)
     {
         return(MapServiceWithAssociations(withAssociations, context));
     }
     return(CreateService(source, context));
 }
示例#6
0
        public static ResolvedAssociation CreateAssociation(ResolvedService main, string associatedUid, bool associationIsCancelled = false, bool isNextDay = false)
        {
            var associated         = CreateScheduleWithService(associatedUid, stops: CreateWokingClaphamSchedule(NineForty));
            var associatedDate     = isNextDay ? main.On.AddDays(1) : main.On;
            var resolvedAssociated = new ResolvedService(associated, associatedDate, false);

            return(CreateAssociation(main, resolvedAssociated, associationIsCancelled));
        }
示例#7
0
        public void DoNotFindStop()
        {
            var service = new ResolvedService(TestSchedules.CreateSchedule(), DateTime.Today, false);

            var find = CreateFindSpec(TestSchedules.TenThirty);

            Assert.False(service.TryFindStop(find, out var stop));
            Assert.Null(stop);
        }
示例#8
0
        public void FindStopIsIndependentOfWhetherCancelled(bool isCancelled)
        {
            var service = new ResolvedService(TestSchedules.CreateSchedule(), DateTime.Today, isCancelled);

            var find = CreateFindSpec(TestSchedules.Ten);

            Assert.True(service.TryFindStop(find, out var stop));
            Assert.NotNull(stop);
        }
示例#9
0
        private S CreateService(ResolvedService source, ResolutionContext context)
        {
            context.Items["On"] = source.On;
            var service = context.Mapper.Map <S>(source.Details);

            service.Date        = source.On;
            service.IsCancelled = source.IsCancelled;
            return(service);
        }
示例#10
0
        public static ResolvedAssociation CreateAssociation(ResolvedService main, ResolvedService associated, bool associationIsCancelled = false)
        {
            var association = TestAssociations.CreateAssociationWithServices((CifService)main.Details.Service, (CifService)associated.Details.Service);

            return(new ResolvedAssociation(
                       association,
                       main.On,
                       associationIsCancelled,
                       associated));
        }
示例#11
0
        private static Model.ServiceSummary MapSchedule(Timetable.CifSchedule schedule = null, bool isCancelled = false)
        {
            var mapper = ToViewProfileConfiguration.CreateMapper();

            schedule = schedule ?? TestSchedules.CreateScheduleWithService();

            var resolved = new ResolvedService(schedule, TestDate, isCancelled);

            return(mapper.Map <Timetable.ResolvedService, Model.ServiceSummary>(resolved, opts => opts.Items["On"] = resolved.On));
        }
        public void RemovedCancelledAssocation()
        {
            ResolvedService service = TestSchedules.CreateServiceWithAssociation(associationIsCancelled: true);

            Assert.True(service.HasAssociations());

            var notCancelled = FilterCancelled(new [] { service });

            Assert.NotEmpty(notCancelled);
            Assert.False(notCancelled[0].HasAssociations());
        }
示例#13
0
        public static ResolvedServiceWithAssociations CreateServiceWithAssociation(
            ResolvedService resolved,
            bool associationIsCancelled = false,
            string associatedUid        = "A98765",
            bool isNextDay = false)
        {
            var association = CreateAssociation(resolved, associatedUid, associationIsCancelled, isNextDay);
            var resolvedWithAssociations = new ResolvedServiceWithAssociations(resolved, new [] { association });

            return(resolvedWithAssociations);
        }
示例#14
0
        public static ResolvedServiceStop CreateResolvedDepartureStop(
            ResolvedService service,
            Station atLocation = null,
            Time when          = default(Time))
        {
            var origin = service.Details.Locations.First() as ScheduleStop;

            atLocation = atLocation ?? origin.Station;
            when       = when.Equals(default(Time)) ? origin.Departure : when;
            var find = new StopSpecification(atLocation, when, service.On, TimesToUse.Departures);

            service.TryFindStop(find, out var stop);
            return(stop);
        }
        public async Task GetAsyncShould_ReturnsCorrectModel()
        {
            //Arrange
            var service = new ResolvedService(Db, null, null, null);

            var resolved = await ResolvedCreator.Create(Db);

            //Act
            var result = await service.GetAsync <ResolvedIssueEditModel>(resolved.Id);

            //Assert
            result.Should().BeOfType <ResolvedIssueEditModel>();

            result.Id.Should().Be(resolved.Id);
            result.CloudinaryImageId.Should().Be(resolved.CloudinaryImageId);
            result.Description.Should().Be(resolved.Description);
        }
示例#16
0
        public static ResolvedServiceStop CreateResolvedDepartureStop(
            string timetableId       = "X12345",
            StpIndicator indicator   = StpIndicator.Permanent,
            ICalendar calendar       = null,
            ScheduleLocation[] stops = null,
            CifService service       = null,
            string retailServiceId   = null,
            DateTime on        = default(DateTime),
            bool isCancelled   = false,
            Station atLocation = null,
            Time when          = default(Time))
        {
            on = on == default(DateTime) ? MondayAugust12 : on;
            var schedule = CreateSchedule(timetableId, indicator, calendar, stops, service, retailServiceId);
            var resolved = new ResolvedService(schedule, on, isCancelled);

            return(CreateResolvedDepartureStop(resolved, atLocation, when));
        }
        public async Task UpdateAsyncShould_ReturnsFalseIf_UpdaterIsNotTheSameAsUploader()
        {
            //Arrange
            var publisher = UserCreator.Create();
            var updater   = UserCreator.Create();

            await this.Db.AddRangeAsync(publisher, updater);

            var issue = UrbanIssueCreator.CreateIssue(RegionType.All);

            await this.Db.AddAsync(issue);

            var resolved = ResolvedCreator.Create(publisher.Id, issue.Id, DefaultPicId);

            await this.Db.AddAsync(resolved);

            await this.Db.SaveChangesAsync();

            var issueService    = new Mock <IManagerIssueService>();
            var pictureService  = IPictureServiceMock.New(DefaultPicId);
            var activityService = new Mock <IManagerActivityService>();

            var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object);

            //Act
            var result = await service.UpdateAsync(updater.Id, resolved.Id, ChangedDescription, null);

            var resolvedAfterAct = await this.Db.FindAsync <ResolvedIssue>(resolved.Id);

            //Assert
            result.Should().Be(false);

            resolved.Should().BeEquivalentTo(resolvedAfterAct);

            pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Never);

            activityService.Verify(a =>
                                   a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Never);
        }
        public async Task DeleteAsyncShould_ReturnsFalse_IfManagerId_IsNotEqualTo_ResolvedPublisherId()
        {
            //Arrange
            var issueService    = new Mock <IManagerIssueService>();
            var pictureService  = IPictureServiceMock.New(DefaultPicId);
            var activityService = new Mock <IManagerActivityService>();

            var service = new ResolvedService(Db, issueService.Object, pictureService.Object, activityService.Object);

            var manager   = UserCreator.Create();
            var publisher = UserCreator.Create();
            await Db.AddRangeAsync(manager, publisher);

            var issue = UrbanIssueCreator.CreateIssue(RegionType.All);
            await Db.AddAsync(issue);

            var resolved = ResolvedCreator.Create(publisher.Id, issue.Id, 0);
            await Db.AddAsync(resolved);

            await Db.SaveChangesAsync();

            //Act

            var result = await service.DeleteAsync(manager.Id, resolved.Id);

            //Assert

            result.Should().BeFalse();

            issueService.Verify(i => i.RemoveResolvedReferenceAsync(It.IsAny <int>()), Times.Never);

            pictureService.Verify(p => p.DeleteImageAsync(It.IsAny <int>()), Times.Never);

            activityService.Verify(a =>
                                   a.WriteLogAsync(It.IsAny <string>(), It.IsAny <ManagerActivityType>()), Times.Never);
        }
示例#19
0
        private A MapAssociation(ResolvedAssociation source, ResolvedService service, ResolutionContext context)
        {
            var(associatedService, associatedServiceStop) = MapOtherService();

            var association = new A()
            {
                Stop                  = MapStop(source.Stop.Stop, context),
                IsBroken              = source.Stop.IsBroken,
                IsCancelled           = source.IsCancelled,
                IsMain                = source.IsMain(service.TimetableUid),
                Date                  = source.On,
                AssociationCategory   = source.Details.Category.ToString(),
                AssociatedServiceStop = associatedServiceStop
            };

            SetAssociatedService(association, associatedService);
            return(association);

            (S, Model.ScheduledStop) MapOtherService()
            {
                // Association maybe on different day.
                var originalDate = context.Items["On"];

                try
                {
                    var otherService = CreateService(source.AssociatedService, context);
                    var otherStop    = MapStop(source.Stop.AssociatedServiceStop, context);
                    return(otherService, otherStop);
                }
                finally
                {
                    // Reset service date
                    context.Items["On"] = originalDate;
                }
            }
        }
示例#20
0
        public void ToStringReturnsTimetableUidAndDate(bool isCancelled, string expected)
        {
            var service = new ResolvedService(TestSchedules.CreateSchedule(), TestDate, isCancelled);

            Assert.Equal(expected, service.ToString());
        }