Esempio n. 1
0
            public async Task ThrowsArgumentExceptionIfMissingEvent()
            {
                var entity = new EditStatusEventManualChangeEntity("path", ComponentStatus.Degraded, new DateTime(2018, 8, 20), false)
                {
                    Timestamp = new DateTimeOffset(2018, 8, 21, 0, 0, 0, TimeSpan.Zero)
                };

                var time        = entity.Timestamp.UtcDateTime;
                var eventRowKey = EventEntity.GetRowKey(entity.EventAffectedComponentPath, entity.EventStartTime);

                _table
                .Setup(x => x.RetrieveAsync <EventEntity>(eventRowKey))
                .Returns(Task.FromResult <EventEntity>(null));

                await Assert.ThrowsAsync <ArgumentException>(() => _handler.Handle(entity));
            }
Esempio n. 2
0
            public async Task EditsEvent(bool eventIsActive, bool shouldEventBeActive)
            {
                var entity = new EditStatusEventManualChangeEntity("path", ComponentStatus.Degraded, new DateTime(2018, 8, 20), shouldEventBeActive)
                {
                    Timestamp = new DateTimeOffset(2018, 8, 21, 0, 0, 0, TimeSpan.Zero)
                };

                var time        = entity.Timestamp.UtcDateTime;
                var eventRowKey = EventEntity.GetRowKey(entity.EventAffectedComponentPath, entity.EventStartTime);

                var existingEntity =
                    new EventEntity(
                        entity.EventAffectedComponentPath,
                        entity.EventStartTime,
                        ComponentStatus.Up,
                        eventIsActive ? (DateTime?)null : new DateTime(2018, 8, 19));

                _table
                .Setup(x => x.RetrieveAsync <EventEntity>(eventRowKey))
                .Returns(Task.FromResult(existingEntity));

                var shouldUpdateEndTime = ManualStatusChangeUtility.ShouldEventBeActive(existingEntity, shouldEventBeActive, time);

                _table
                .Setup(x => x.ReplaceAsync(
                           It.Is <EventEntity>(eventEntity =>
                                               eventEntity.PartitionKey == EventEntity.DefaultPartitionKey &&
                                               eventEntity.RowKey == eventRowKey &&
                                               eventEntity.AffectedComponentPath == existingEntity.AffectedComponentPath &&
                                               eventEntity.AffectedComponentStatus == entity.EventAffectedComponentStatus &&
                                               eventEntity.StartTime == existingEntity.StartTime &&
                                               eventEntity.EndTime == (shouldUpdateEndTime ? time : existingEntity.EndTime)
                                               )))
                .Returns(Task.CompletedTask)
                .Verifiable();

                await _handler.Handle(entity);

                _table.Verify();
            }
Esempio n. 3
0
        public Task <ActionResult> EditEvent(EditStatusEvent model)
        {
            var startTime = ParseModelDateTime(model.StartTime);

            ManualStatusChangeEntity entity;

            if (model.Delete)
            {
                entity = new DeleteStatusEventManualChangeEntity(
                    model.AffectedComponentPath,
                    startTime);
            }
            else
            {
                entity = new EditStatusEventManualChangeEntity(
                    model.AffectedComponentPath,
                    model.AffectedComponentStatus,
                    startTime,
                    model.IsActive);
            }

            return(RunUpdateStatusTask(entity));
        }