public void DeserializeChangeSetTest(
            AggregateVersion version, TodoTaskCreated taskCreated, TodoTaskMoved taskMoved)
        {
            // arrange
            var changeSet           = new ChangeSet(version, new IDomainEvent[] { taskCreated, taskMoved });
            var serializedChangeSet = _serializer.SerializeChangeSet(changeSet);

            // act
            var restoredChangeSet = _serializer.DeserializeChangeSet(serializedChangeSet);

            // assert
            Assert.Equal(changeSet.FromVersion, restoredChangeSet.FromVersion);
            Assert.Equal(changeSet.ToVersion, restoredChangeSet.ToVersion);

            var restoredTaskCreated = restoredChangeSet.Changes[0] as TodoTaskCreated;

            Assert.NotNull(restoredTaskCreated);
            Assert.Equal(taskCreated.TaskId, restoredTaskCreated.TaskId);
            Assert.Equal(taskCreated.ProjectId, restoredTaskCreated.ProjectId);

            var restoredTaskMoved = restoredChangeSet.Changes[1] as TodoTaskMoved;

            Assert.NotNull(restoredTaskMoved);
            Assert.Equal(taskMoved.TaskId, restoredTaskMoved.TaskId);
            Assert.Equal(taskMoved.NewProjectId, restoredTaskMoved.NewProjectId);
            Assert.Equal(taskMoved.OldProjectId, restoredTaskMoved.OldProjectId);
        }
        public void SerializeChangeSetTest(
            AggregateVersion version, TodoTaskCreated taskCreated, TodoTaskMoved taskMoved)
        {
            // arrange
            var changeSet = new ChangeSet(version, new IDomainEvent[] { taskCreated, taskMoved });

            // act
            var serializedChangeSet = JObject.Parse(_serializer.SerializeChangeSet(changeSet));

            // assert
            Assert.Equal((int)changeSet.FromVersion, serializedChangeSet["fromVersion"]);

            var serializedClrTypes = (JArray)serializedChangeSet["changeClrTypes"];

            Assert.Equal(typeof(TodoTaskCreated).AssemblyQualifiedName, serializedClrTypes[0]);
            Assert.Equal(typeof(TodoTaskMoved).AssemblyQualifiedName, serializedClrTypes[1]);

            var serializedChanges     = (JArray)serializedChangeSet["changes"];
            var serializedTaskCreated = serializedChanges[0];

            Assert.Equal(taskCreated.TaskId.Id, (int)serializedTaskCreated["taskId"]);
            Assert.Equal(taskCreated.ProjectId.Id, (int)serializedTaskCreated["projectId"]);

            var serializedTaskMoved = serializedChanges[1];

            Assert.Equal(taskMoved.TaskId.Id, (int)serializedTaskMoved["taskId"]);
            Assert.Equal(taskMoved.NewProjectId.Id, (int)serializedTaskMoved["newProjectId"]);
            Assert.Equal(taskMoved.OldProjectId.Id, (int)serializedTaskMoved["oldProjectId"]);
        }
        public void WhenTodoTaskCreated_SetsCorrectProperties(TodoTaskCreated taskCreated)
        {
            // act
            _state.When(taskCreated);

            // assert
            Assert.NotNull(_state.ProjectId);
            Assert.Equal(taskCreated.ProjectId, _state.ProjectId);
            Assert.Equal(taskCreated.TaskId, _state.TaskId);
        }
Ejemplo n.º 4
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);
        }