Esempio n. 1
0
        public void SoftDelete_Sets_Date_Deleted()
        {
            //arrange
            var anEvent = new Event();

            //act
            anEvent.SoftDelete();

            //assert
            anEvent.DateDeleted.Should().HaveValue();
        }
Esempio n. 2
0
        public bool CreateEvent(Event anEvent)
        {
            if (string.IsNullOrEmpty(anEvent.EventReference))
                return false;

            if (string.IsNullOrEmpty(anEvent.ApplicationReference))
                return false;

            _eventContext.Events.Add(anEvent);

            return _eventContext.SaveChanges() > 0;
        }
Esempio n. 3
0
        public string CreateEvent(Event anEvent)
        {
            Check.If(anEvent).IsNotNull();

            if (string.IsNullOrEmpty(anEvent.ApplicationReference))
            {
                return null;
            }

            var result = _eventRepository.CreateEvent(anEvent.CreateReference(_referenceGenerator));

            return result ? anEvent.EventReference : null;
        }
        public void EventMapper_DoesNotMap_EventId()
        {
            //arrange
            const int eventId = 123;
            var event1 = new Event { EventId = eventId };
            var event2 = new Event { EventId = 0 };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.EventId.Should().Be(eventId);
        }
        public void EventMapper_DoesNotMap_EventReference()
        {
            //arrange
            const string reference = "ABCD1234";
            var event1 = new Event { EventReference = reference };
            var event2 = new Event { EventReference = string.Empty };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.EventReference.Should().Be(reference);
        }
        public void EventMapper_DoesNotMap_DateDeleted()
        {
            //arrange
            var dateDeleted = DateTime.Now;
            var event1 = new Event { DateDeleted = dateDeleted };
            var event2 = new Event { DateDeleted = DateTime.MinValue };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.DateDeleted.Should().Be(dateDeleted);
        }
Esempio n. 7
0
        public void CreateReference_Sets_NoteReference()
        {
            //arrange
            const string reference = "ABCDE12345";
            var mockReferenceGenerator = new Mock<IReferenceGenerator>();
            var anEvent = new Event();

            mockReferenceGenerator.Setup(x => x.CreateReference(It.IsAny<int>())).Returns(reference);

            //act
            anEvent.CreateReference(mockReferenceGenerator.Object);

            //assert
            anEvent.EventReference.Should().NotBeNullOrWhiteSpace();
            anEvent.EventReference.Should().Be(reference);

            mockReferenceGenerator.Verify(x => x.CreateReference(It.IsAny<int>()), Times.Once);
        }
Esempio n. 8
0
        public bool UpdateEvent(string eventReference, Event anEvent)
        {
            var existingEvent = _eventContext.Events.Active().FirstOrDefault(e => e.EventReference == eventReference);

            if (existingEvent == null)
                return false;

            _eventMapper.Map(anEvent, existingEvent);

            return _eventContext.SaveChanges() > 0;
        }
Esempio n. 9
0
        public bool UpdateEvent(string eventReference, Event anEvent)
        {
            Check.If(eventReference).IsNotNullOrEmpty();
            Check.If(anEvent).IsNotNull();

            return _eventRepository.UpdateEvent(eventReference, anEvent);
        }
        public void EventMapper_Maps_CorrelationId()
        {
            //arrange
            const string reference = "ABCD1234";
            var event1 = new Event { CorrelationId = string.Empty };
            var event2 = new Event { CorrelationId = reference };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.CorrelationId.Should().Be(reference);
        }
        public void EventMapper_Maps_ApplicationReference()
        {
            //arrange
            const string reference = "ABCD1234";
            var event1 = new Event { ApplicationReference = string.Empty };
            var event2 = new Event { ApplicationReference = reference };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.ApplicationReference.Should().Be(reference);
        }
        public void EventMapper_Maps_Owner()
        {
            // arrange
            const string owner = "Test.User";
            var event1 = new Event { Owner = string.Empty };
            var event2 = new Event { Owner = owner };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.Owner.Should().Be(owner);
        }
        public void EventMapper_Maps_EventType()
        {
            // arrange
            const EventType eventType = EventType.Error;
            var event1 = new Event { EventType = EventType.Unknown };
            var event2 = new Event { EventType = eventType };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.EventType.Should().Be(eventType);
        }
        public void EventMapper_Maps_EventDetail()
        {
            //arrange
            const string detail = "Test Detail";
            var event1 = new Event { EventDetail = string.Empty };
            var event2 = new Event { EventDetail = detail };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.EventDetail.Should().Be(detail);
        }
        public void EventMapper_Maps_EventDescription()
        {
            //arrange
            const string description = "Test Description";
            var event1 = new Event { EventDescription = string.Empty };
            var event2 = new Event { EventDescription = description };

            //act
            _eventMapper.Map(event2, event1);

            //assert
            event1.EventDescription.Should().Be(description);
        }