Exemple #1
0
        public void f()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            _repository.Save(workTime);
            workTime.MarkPendingEventsAsHandled();

            for (int i = 0; i < 2; i++)
            {
                _uow.RegisterNew(workTime);

                workTime.StartManually();

                _uow.Save();

                var found = _repository.Find(workTime.User, DateTime.UtcNow);

                found.Started.Should().BeTrue();

                _uow.Rollback();

                found = _repository.Find(workTime.User, DateTime.UtcNow);

                found.Started.Should().BeFalse();
                _repository.CountForUser(workTime.User).Should().Be(1);
            }
        }
Exemple #2
0
        public void Find_all_finds_all_full_aggregates()
        {
            var user      = UserTestUtils.CreateTestUser();
            var workTime1 = WorkTimeTestUtils.CreateManual(user);

            workTime1.StartManually();
            _repository.Save(workTime1);

            InternalTimeService.GetCurrentDateTime = () => DateTime.UtcNow.AddHours(1);

            var workTime2 = WorkTimeTestUtils.CreateManual(user);

            workTime2.StartManually();
            _repository.Save(workTime2);

            InternalTimeService.GetCurrentDateTime = () => DateTime.UtcNow.AddHours(2);

            var workTime3 = WorkTimeTestUtils.CreateManual(user);

            workTime3.StartManually();
            _repository.Save(workTime3);


            var found = _repository.FindAll(user, null, null);

            found.Count.Should().Be(3);
        }
Exemple #3
0
        public void FindLatestFromSnapshot_returns_latest_aggregate_from_snapshot()
        {
            var user     = UserTestUtils.CreateTestUser();
            var workTime = WorkTimeTestUtils.CreateManual(user);

            workTime.StartManually();
            var snap = workTime.TakeSnapshot();

            workTime.AddMouseAction(new MouseKeyboardEvent());
            _repository.Save(workTime);

            InternalTimeService.GetCurrentDateTime = () => DateTime.UtcNow.AddDays(1);

            var workTime2 = WorkTimeTestUtils.CreateManual(user);

            workTime2.StartManually();
            var snap2 = workTime2.TakeSnapshot();

            workTime2.AddMouseAction(new MouseKeyboardEvent());
            _repository.Save(workTime2);

            var found = _repository.FindLatestFromSnapshot(user);

            CompareWorkTimes(found, workTime2);
        }
Exemple #4
0
        public void FromEvents_recreates_valid_object()
        {
            var now      = DateTime.UtcNow;
            var workTime = WorkTimeTestUtils.CreateManual();

            workTime.StartManually();
            workTime.AddMouseAction(_testMkEvent);
            workTime.AddKeyboardAction(_testMkEvent);
            InternalTimeService.GetCurrentDateTime = () => DateTime.UtcNow.AddMinutes(1);
            workTime.AddRecognitionFailure(DateTime.UtcNow, true, false);


            var recreated = WorkTimeAggregate.WorkTime.FromEvents(workTime.PendingEvents);

            workTime.MarkPendingEventsAsHandled();

            recreated.Should().BeEquivalentTo(workTime, options =>
            {
                return(options.Excluding(time => time.StartDate)
                       .Excluding(t => t.KeyboardActionEvents)
                       .Excluding(t => t.MouseActionEvents)
                       .Excluding(t => t.FaceRecognitionFailures)
                       .Excluding(time => time.EndDate)
                       .Excluding(time => time.DateCreated));
            });
            recreated.StartDate.Value.SafeCompare(workTime.StartDate.Value);
            recreated.EndDate.SafeCompare(workTime.EndDate);
            recreated.DateCreated.SafeCompare(now);

            recreated.KeyboardActionEvents.Count.Should().Be(1);
            recreated.MouseActionEvents.Count.Should().Be(1);
            recreated.FaceRecognitionFailures.Count.Should().Be(1);
        }
Exemple #5
0
        public void Save_adds_new()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            _repository.Save(workTime);

            _repository.CountForUser(workTime.User).Should().Be(1);
        }
Exemple #6
0
        public void Save_called_twice_with_same_param_throws()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            _repository.Save(workTime);
            _repository.CountForUser(workTime.User).Should().Be(1);

            Assert.ThrowsAny <Exception>(() => _repository.Save(workTime));

            _repository.CountForUser(workTime.User).Should().Be(1);
        }
Exemple #7
0
        public void Stop_if_called_stops_workTIme()
        {
            var workTime = WorkTimeTestUtils.CreateManual(_user);

            workTime.MarkPendingEventsAsHandled();
            workTime.StartManually();

            workTime.Stop();

            workTime.Started.Should().BeTrue();
            workTime.Stopped.Should().BeTrue();
            workTime.StoppedByUser.Should().BeTrue();
            workTime.Paused.Should().BeFalse();
        }
Exemple #8
0
        public void When_past_end_time_workTime_is_stopped()
        {
            var workTime = WorkTimeTestUtils.CreateManual(_user);

            workTime.MarkPendingEventsAsHandled();
            workTime.StartManually();

            InternalTimeService.GetCurrentDateTime = () => DateTime.UtcNow.AddMinutes(11);

            workTime.Started.Should().BeTrue();
            workTime.Stopped.Should().BeTrue();
            workTime.StoppedByUser.Should().BeFalse();
            workTime.Paused.Should().BeFalse();
        }
Exemple #9
0
        public void SetResored_when_not_interrupted_generates_event()
        {
            var workTime = WorkTimeTestUtils.CreateManual(_user);

            workTime.StartManually();
            workTime.MarkPendingEventsAsHandled();
            workTime.SetRestored();

            workTime.PendingEvents.Last().Should().BeOfType <WorkTimeRestored>();

            var restoredEv = workTime.PendingEvents.Last() as WorkTimeRestored;

            restoredEv.TotalTimeMs.Should().Be(0);
        }
Exemple #10
0
        public void set_interrupted_stopped_or_paused__does_not_gen_event()
        {
            var workTime = WorkTimeTestUtils.CreateManual(_user);

            workTime.StartManually();
            workTime.MarkPendingEventsAsHandled();

            workTime.Pause();
            workTime.SetInterrupted();
            workTime.Resume();

            InternalTimeService.GetCurrentDateTime = () => DateTime.UtcNow.AddMinutes(11);

            workTime.SetInterrupted();
            workTime.PendingEvents.Count.Should().Be(0);
        }
Exemple #11
0
        public void AddMouseAction_when_started_adds_valid_events()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            workTime.MarkPendingEventsAsHandled();

            workTime.StartManually();
            workTime.MarkPendingEventsAsHandled();
            workTime.AddMouseAction(_testMkEvent);
            workTime.MouseActionEvents.Count.Should().Be(1);


            workTime.PendingEvents.Count.Should().Be(1);
            workTime.PendingEvents.First().Should().BeOfType <MouseAction>();
            workTime.AggregateVersion.Should().Be(3);
        }
Exemple #12
0
        public void Find_when_valid_start_date_finds_full_aggregate()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            workTime.StartManually();
            workTime.AddMouseAction(new MouseKeyboardEvent());
            workTime.AddKeyboardAction(new MouseKeyboardEvent());

            _repository.Save(workTime);
            workTime.PendingEvents.Count.Should().Be(4);
            workTime.MarkPendingEventsAsHandled();

            var found = _repository.Find(workTime.User, workTime.DateCreated);

            found.PendingEvents.Count.Should().Be(0);
            found.Should().BeEquivalentTo(workTime, options =>
            {
                return(options.Excluding(time => time.StartDate).Excluding(time => time.EndDate)
                       .Excluding(t => t.MouseActionEvents)
                       .Excluding(t => t.KeyboardActionEvents));
            });
            found.StartDate.Value.SafeCompare(workTime.StartDate.Value);
            found.EndDate.SafeCompare(workTime.EndDate);
            //todo
            found.MouseActionEvents.Count.Should().Be(workTime.MouseActionEvents.Count);

            for (int i = 0; i < found.MouseActionEvents.Count; i++)
            {
                found.MouseActionEvents[i].Should().BeEquivalentTo(workTime.MouseActionEvents[i],
                                                                   opt => opt
                                                                   .Excluding(e => e.Date).Excluding(e => e.Id));
                found.MouseActionEvents[i].Id.Should().NotBeNull();
                found.MouseActionEvents[i].Date.SafeCompare(workTime.MouseActionEvents[i].Date);
            }


            found.KeyboardActionEvents.Count.Should().Be(workTime.KeyboardActionEvents.Count);

            for (int i = 0; i < found.KeyboardActionEvents.Count; i++)
            {
                found.KeyboardActionEvents[i].Should().BeEquivalentTo(workTime.KeyboardActionEvents[i],
                                                                      opt => opt
                                                                      .Excluding(e => e.Date).Excluding(e => e.Id));
                found.KeyboardActionEvents[i].Id.Should().NotBeNull();
                found.KeyboardActionEvents[i].Date.SafeCompare(workTime.KeyboardActionEvents[i].Date);
            }
        }
Exemple #13
0
        public void Rollback_restores_state_to_given_snapshot()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            workTime.StartManually();
            var snap = workTime.TakeSnapshot();

            workTime.AddMouseAction(new MouseKeyboardEvent());
            _repository.Save(workTime);
            workTime.MarkPendingEventsAsHandled();

            _repository.Rollback(snap);
            workTime.RollbackToSnapshot(snap);

            var found = _repository.Find(workTime.User, workTime.DateCreated);

            found.Should().BeEquivalentTo(workTime, opt => opt.Excluding(t => t.FromSnapshot));
        }
Exemple #14
0
        public void Combine_ads_new_events()
        {
            var workTime = WorkTimeTestUtils.CreateManual(_user);

            workTime.StartManually();
            var snap = workTime.TakeSnapshot();

            var totalEvs = workTime.PendingEvents.Count;

            var fromSnap = WorkTime.CreateFromSnapshot(snap);

            fromSnap.AddRecognitionFailure(DateTime.UtcNow, false, false);

            WorkTime joined = WorkTime.Combine(workTime, fromSnap);

            joined.PendingEvents.Count.Should().Be(totalEvs + 1);
            joined.PendingEvents.Last().Should().BeOfType <FaceRecognitionFailure>();
        }
Exemple #15
0
        public void Take_snapshot_generates_valid_events_and_clears_actionEvents_list()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            workTime.StartManually();
            workTime.AddMouseAction(_testMkEvent);
            workTime.AddKeyboardAction(_testMkEvent);
            InternalTimeService.GetCurrentDateTime = () => DateTime.UtcNow.AddMinutes(1);
            workTime.AddRecognitionFailure(DateTime.UtcNow, true, false);

            workTime.TakeSnapshot();

            workTime.KeyboardActionEvents.Count.Should().Be(0);
            workTime.MouseActionEvents.Count.Should().Be(0);
            workTime.FaceRecognitionFailures.Count.Should().Be(0);
            workTime.PendingEvents.Count.Should().Be(6);
            workTime.PendingEvents.Last().Should().BeOfType <WorkTimeSnapshotCreated>();
            workTime.AggregateVersion.Should().Be(6);
        }
        public void Event_DbEvent()
        {
            var worktime = WorkTimeTestUtils.CreateManual();

            var ev = worktime.PendingEvents.First() as WorkTimeCreated;

            var dbEvent = _mapper.Map <DbEvent>(ev);

            dbEvent.Id.Should().BeNull();
            dbEvent.AggregateId.Should().Be(ev.AggregateId);
            dbEvent.AggregateVersion.Should().Be(ev.AggregateVersion);
            dbEvent.Data.Should().NotBeNullOrWhiteSpace();
            dbEvent.Data.Should().NotContain("AggregateVersion");
            dbEvent.Data.Should().NotContain("AggregateId");
            dbEvent.Date.Should().Be(ev.Date);

            var ev1 = _mapper.Map <Event>(dbEvent) as WorkTimeCreated;

            ev1.Should().BeEquivalentTo(ev);
        }
Exemple #17
0
        public void Start_starts_working_time_and_sets_startDate()
        {
            var workTime = WorkTimeTestUtils.CreateManual(_user);

            workTime.MarkPendingEventsAsHandled();

            workTime.StartDate.Should().BeNull();
            workTime.StartManually();
            workTime.StartDate.Value.SafeCompare(DateTime.UtcNow);
            workTime.StartDate.Value.Kind.Should().Be(DateTimeKind.Utc);
            workTime.User.Should().BeEquivalentTo(_user);
            workTime.PendingEvents.Count.Should().Be(1);
            workTime.PendingEvents.First().Should().BeOfType <WorkTimeStarted>();
            workTime.AggregateVersion.Should().Be(2);

            workTime.Started.Should().BeTrue();
            workTime.Stopped.Should().BeFalse();
            workTime.Paused.Should().BeFalse();
            workTime.StoppedByUser.Should().BeFalse();
        }
Exemple #18
0
        public void FindFromSnapshot_returns_aggregate_from_snapshot()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            workTime.StartManually();
            var snap = workTime.TakeSnapshot();

            _repository.Save(workTime);
            workTime.MarkPendingEventsAsHandled();

            workTime.AddMouseAction(new MouseKeyboardEvent());

            var fromSnap = _repository.FindFromSnapshot(snap);

            CompareWorkTimes(fromSnap, workTime);
            fromSnap.FromSnapshot.Should().BeTrue();
            fromSnap.MouseActionEvents.Should().BeEmpty();
            fromSnap.KeyboardActionEvents.Should().BeEmpty();
            fromSnap.PendingEvents.Should().BeEmpty();
            fromSnap.AggregateVersion.Should().Be(workTime.AggregateVersion - 1);
        }
Exemple #19
0
        public void SetResored_when_interrupted_generates_event()
        {
            var workTime = WorkTimeTestUtils.CreateManual(_user);

            workTime.StartManually();
            workTime.MarkPendingEventsAsHandled();

            workTime.SetInterrupted();

            workTime.PendingEvents.Last().Should().BeOfType <WorkTimeInterrupted>();

            InternalTimeService.GetCurrentDateTime = () => DateTime.UtcNow.AddMilliseconds(2000);

            workTime.SetRestored();

            workTime.PendingEvents.Last().Should().BeOfType <WorkTimeRestored>();

            var restoredEv = workTime.PendingEvents.Last() as WorkTimeRestored;

            restoredEv.TotalTimeMs.Should().BeInRange(2000, 2100);

            //not throwing
            workTime.AddRecognitionFailure(InternalTimeService.GetCurrentDateTime(), true, false);
        }
Exemple #20
0
        public void RollbackToSnapshot_discards_changes()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            workTime.StartManually();
            workTime.AddMouseAction(_testMkEvent);
            workTime.AddKeyboardAction(_testMkEvent);

            var snap = workTime.TakeSnapshot();

            workTime.MarkPendingEventsAsHandled();

            workTime.AddMouseAction(_testMkEvent);

            workTime.AggregateVersion.Should().Be(6);
            workTime.RollbackToSnapshot(snap);
            workTime.PendingEvents.Count.Should().Be(0);
            workTime.MouseActionEvents.Count.Should().Be(0);
            workTime.KeyboardActionEvents.Count.Should().Be(0);
            workTime.UserWatchingScreen.Count.Should().Be(0);
            workTime.FaceRecognitionFailures.Count.Should().Be(0);
            workTime.AggregateVersion.Should().Be(5);
            workTime.FromSnapshot.Should().BeTrue();
        }
Exemple #21
0
        public void AddKeyboardAction_when_not_started_throws()
        {
            var workTime = WorkTimeTestUtils.CreateManual();

            Assert.ThrowsAny <Exception>(() => workTime.AddKeyboardAction(_testMkEvent));
        }