コード例 #1
0
 public void Equals_ForTheSameTaskReturnsTrue(TodoTaskId taskId)
 {
     Assert.Equal(taskId, taskId);
     Assert.True(taskId == new TodoTaskId(taskId.Id));
     Assert.False(taskId != new TodoTaskId(taskId.Id));
     Assert.True(taskId.Equals(new TodoTaskId(taskId.Id)));
 }
コード例 #2
0
 public void Equals_ForDifferentTasksReturnsFalse(TodoTaskId task1, TodoTaskId task2)
 {
     Assert.NotEqual(task1, task2);
     Assert.False(task1 == task2);
     Assert.True(task1 != task2);
     Assert.False(task1.Equals(task2));
 }
コード例 #3
0
        public async Task LoadAsync_WhenTheStateDoesNotExists_ReturnsEmptyVersion(TodoTaskId id)
        {
            // act
            var(version, _) = await _stateStorage.LoadAsync <TodoTask.AggregateState>(id, CancellationToken.None);

            // assert
            Assert.True(AggregateVersion.IsEmpty(version));
        }
コード例 #4
0
        public void Equals_ForDifferentEntityIdentityTypesReturnsFalse(TodoTaskId task, ProjectId project)
        {
            var taskIdentity    = task as IEntityIdentity;
            var projectIdentity = project as IEntityIdentity;

            Assert.NotEqual(taskIdentity, projectIdentity);
            Assert.False(taskIdentity.Equals(projectIdentity));
        }
コード例 #5
0
        public void Constructor_FromTheValue(int id)
        {
            // arrange
            var taskId = new TodoTaskId(id);

            // act && assert
            Assert.Equal(id, taskId.Id);
            Assert.Equal(id.ToString(), taskId.Value);
        }
コード例 #6
0
 public async Task FindByIdAsync_WhenStateDoesNotExist_ReturnsNull(
     [Frozen] Mock <IAggregateStateStorage> stateStorageMock,
     TodoTaskId todoTaskId,
     TodoTaskRepository repository)
 {
     // arrange
     stateStorageMock
     .Setup(self => self.LoadAsync <TodoTask.AggregateState>(todoTaskId, It.IsAny <CancellationToken>()))
     .ReturnsAsync((AggregateVersion.Emtpy, default));
コード例 #7
0
        public void Create_TaskIdPropertyReturnsTheCorrectValue(
            [Frozen] TodoTaskId taskId, ProjectId projectId)
        {
            // act
            _task.Create(taskId, projectId);

            // assert
            Assert.IsType <TodoTaskId>(_task.Id);
            Assert.Equal(taskId, _task.Id);
        }
コード例 #8
0
        public void Equals_ForDifferentAbstractEntityIdentitySubTypesReturnsFalse(TodoTaskId task, ProjectId project)
        {
            var taskIdentity    = task as AbstractEntityIdentity <int>;
            var projectIdentity = project as AbstractEntityIdentity <int>;

            Assert.NotEqual(taskIdentity, projectIdentity);
            Assert.False(taskIdentity == projectIdentity);
            Assert.True(taskIdentity != projectIdentity);
            Assert.False(taskIdentity.Equals(projectIdentity));
        }
コード例 #9
0
 public void RestoreFromState_UpdatesStateAndVersionOfTheAggregate(
     [Frozen] AggregateVersion version,
     [Frozen] TodoTask.AggregateState state,
     [Frozen] TodoTaskId id,
     TestableAbstractAggregateRoot entity)
 {
     // assert
     Assert.Equal(id, entity.Id);
     Assert.Equal(version, entity.Version);
     Assert.Same(state, entity.State);
 }
コード例 #10
0
        public void Complete_ForCompletedTask_DoesNotTriggerTaskCompletedEvent(TodoTaskId taskId, ProjectId projectId)
        {
            // arrange
            _task.Create(taskId, projectId);
            _task.Complete();

            // act
            _task.Complete();

            // assert
            Assert.Equal(1, _task.State.GetChanges().Count(evt => evt is TodoTaskCompleted));
        }
コード例 #11
0
        public void MoveProject_WhenTheSameProjectIsPassed_DoesNotChangeProject(TodoTaskId taskId, ProjectId projectId)
        {
            // arrange
            _task.Create(taskId, projectId);

            // act
            _task.MoveToProject(projectId);

            // assert
            Assert.DoesNotContain(
                _task.State.GetChanges(),
                domainEvent => domainEvent is TodoTaskMoved);
        }
コード例 #12
0
        public void Create_TriggersTodoTaskCreated(TodoTaskId taskId, ProjectId projectId)
        {
            // act
            _task.Create(taskId, projectId);

            // assert
            Assert.Contains(
                _task.State.GetChanges(),
                domainEvent =>
                domainEvent is TodoTaskCreated todoTaskCreated &&
                todoTaskCreated.ProjectId == projectId &&
                todoTaskCreated.TaskId == _task.Id);
        }
コード例 #13
0
        public async Task LoadAsync_WhenStageWasUpdatedConcurrently_Throws(
            TodoTaskId id,
            TodoTask.AggregateState state)
        {
            // arrange
            await _stateStorage.PersistAsync(id, state, AggregateVersion.Emtpy, new Dictionary <string, object>(),
                                             CancellationToken.None);

            // act && assert
            await Assert.ThrowsAsync <StateWasConcurrentlyUpdatedException>(
                () => _stateStorage.PersistAsync(id, state, AggregateVersion.Emtpy.Increment(),
                                                 new Dictionary <string, object>(), CancellationToken.None));
        }
コード例 #14
0
        public async Task LoadAsync_CanReadPersistedState(TodoTaskId id, TodoTask.AggregateState state)
        {
            // arrange
            state.Mutate(new TodoTaskCompleted(id));
            await _stateStorage.PersistAsync(id, state, AggregateVersion.Emtpy, new Dictionary <string, object>(),
                                             CancellationToken.None);

            // act
            var(restoredVersion, restoredState) =
                await _stateStorage.LoadAsync <TodoTask.AggregateState>(id, CancellationToken.None);

            // assert
            Assert.Equal(state.ProjectId, restoredState.ProjectId);
            Assert.Equal(AggregateVersion.Emtpy.Increment(), restoredVersion);
        }
コード例 #15
0
        private async Task <(DateTimeOffset, DateTimeOffset)> GetAuditDatesAsync(TodoTaskId taskId)
        {
            var getConfig = new GetItemOperationConfig {
                ConsistentRead = true
            };
            var          primaryKey       = taskId.Tag + "_" + taskId.Value;
            const string headSortKeyValue = "HEAD";

            var document = await _storageTable.GetItemAsync(primaryKey, headSortKeyValue, getConfig,
                                                            CancellationToken.None);

            var createdAt1  = DateTimeOffset.FromUnixTimeMilliseconds((long)document["CreatedAt"]);
            var modifiedAt1 = DateTimeOffset.FromUnixTimeMilliseconds((long)document["UpdatedAt"]);

            return(createdAt1, modifiedAt1);
        }
コード例 #16
0
        public void MoveProject_WhenDifferentProjectIsPassed_ChangesProject(
            TodoTaskId taskId, ProjectId projectId, ProjectId newProjectId)
        {
            // arrange
            _task.Create(taskId, projectId);

            // act
            _task.MoveToProject(newProjectId);

            // assert
            Assert.Contains(
                _task.State.GetChanges(),
                domainEvent =>
                domainEvent is TodoTaskMoved todoTaskMoved &&
                todoTaskMoved.OldProjectId == projectId &&
                todoTaskMoved.NewProjectId == newProjectId &&
                todoTaskMoved.TaskId == _task.Id);
        }
コード例 #17
0
        public void Constructor_FromIdentity(Mock <IEntityIdentity> identity, int id)
        {
            // arrange
            identity
            .SetupGet(self => self.Tag)
            .Returns("todo_task");

            identity
            .SetupGet(self => self.Value)
            .Returns(id.ToString);

            // act
            var taskId = new TodoTaskId(identity.Object);

            // assert
            Assert.Equal(id, taskId.Id);
            Assert.Equal(id.ToString(), taskId.Value);
        }
コード例 #18
0
        public async Task LoadAsync_WhenStateHasChanges_IncrementsVersion(
            TodoTaskId id,
            TodoTaskCreated todoTaskCreated,
            AggregateVersion originalVersion,
            TodoTask.AggregateState state)
        {
            // arrange
            state.Mutate(todoTaskCreated);

            await _stateStorage.PersistAsync(id, state, AggregateVersion.Emtpy, new Dictionary <string, object>(),
                                             CancellationToken.None);

            // act
            var(restoredVersion, restoredState) =
                await _stateStorage.LoadAsync <TodoTask.AggregateState>(id, CancellationToken.None);

            // assert
            Assert.Equal(state.ProjectId, restoredState.ProjectId);
            Assert.Equal(AggregateVersion.Emtpy.Increment(), restoredVersion);
        }
コード例 #19
0
        public async Task PersistedAsync_ShouldStoreCreatedAtAndUpdatedAt(TodoTaskId taskId, ProjectId projectId)
        {
            // arrange & act
            TodoTask.AggregateState state = new TodoTask.AggregateState();
            state.Mutate(new TodoTaskCreated(projectId, taskId));
            await _stateStorage.PersistAsync(taskId, state, AggregateVersion.Emtpy, new Dictionary <string, object>(), CancellationToken.None);

            var(createdAt1, updatedAt1) = await GetAuditDatesAsync(taskId);

            var(newVersion, newState) = await _stateStorage.LoadAsync <TodoTask.AggregateState>(taskId, CancellationToken.None);

            newState.Mutate(new TodoTaskCompleted(taskId));
            await _stateStorage.PersistAsync(taskId, newState, newVersion, new Dictionary <string, object>(), CancellationToken.None);

            var(createdAt2, updatedAt2) = await GetAuditDatesAsync(taskId);

            // assert
            Assert.Equal(createdAt1, createdAt2);
            Assert.True(updatedAt2 > updatedAt1);
            createdAt1.Should().BeCloseTo(DateTimeOffset.UtcNow, 1000);
            updatedAt2.Should().BeCloseTo(DateTimeOffset.UtcNow, 500);
        }
コード例 #20
0
 public void Equals_WhenTheValueIsComparedWithNull_ReturnsFalse(TodoTaskId task)
 {
     Assert.False(task.Equals(null));
 }
コード例 #21
0
 public void Equals_ForTheSameInstanceReturnsTrue(TodoTaskId task)
 {
     Assert.Equal(task, task);
     Assert.True(task.Equals(task));
 }
コード例 #22
0
 public Task <TodoTask> GetByIdAsync(TodoTaskId id, CancellationToken cancellationToken)
 {
     return(null);
 }