public void given_new_permission_should_be_enabled_after_permission_created_event()
{
//assemble
CreateNewPermissionDTO input = new CreateNewPermissionDTO
{
Name = "test",
Description = "test",
IsActive = true
};
//apply
var agg = PermissionAggregate.CreateNewPermission(input);
//assert
var changes = agg.GetUncommittedChanges();
Assert.Single(changes);
Assert.Collection(changes,
(e) =>
{
Assert.IsType <PermissionCreatedEvent>(e);
var @event = (PermissionCreatedEvent)e;
Assert.True(@event.IsActive);
});
Assert.True(agg.IsActive);
}
public void setup_session_to_return_correct_aggregate(UserAggregate agg, PermissionAggregate permAgg)
{
// Get UserAggregate
SessionMock.Setup(a => a.Get <UserAggregate>(It.IsAny <Guid>(), It.IsAny <int?>(), It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionGetWasCalled = true;
})
.Returns(Task.FromResult(agg));
// Get PermissionAggregate
SessionMock.Setup(a => a.Get <PermissionAggregate>(It.IsAny <Guid>(), It.IsAny <int?>(), It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionGetPermisisonWasCalled = true;
})
.Returns(Task.FromResult(permAgg));
// Commit
SessionMock.Setup(a => a.Commit(It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionCommitWasCalled = true;
})
.Returns(Task.FromResult(0));
}
public void given_new_permission_should_be_disabled_after_permission_disabled_event()
{
//assemble
CreateNewPermissionDTO input = new CreateNewPermissionDTO
{
Name = "test",
Description = "test",
IsActive = true
};
var agg = PermissionAggregate.CreateNewPermission(input);
var adminUser = PermissionAggregateMockAggregate.SetupAdminUser();
//apply
agg.DisablePermission(adminUser);
//assert
var changes = agg.GetUncommittedChanges();
Assert.Equal(2, changes.Length);
Assert.Collection(changes,
(e) =>
{
Assert.IsType <PermissionCreatedEvent>(e);
},
(e) =>
{
Assert.IsType <PermissionDisabledEvent>(e);
var @event = (PermissionDisabledEvent)e;
Assert.False(@event.IsActive);
});
Assert.False(agg.IsActive);
}
public void given_new_permission_should_have_permission_created_event_with_non_empty_id()
{
//assemble
CreateNewPermissionDTO input = new CreateNewPermissionDTO
{
Name = "test",
Description = "test",
IsActive = true
};
//apply
var agg = PermissionAggregate.CreateNewPermission(input);
//assert
var changes = agg.GetUncommittedChanges();
Assert.Single(changes);
Assert.Collection(changes, (e) =>
{
Assert.IsType <PermissionCreatedEvent>(e);
var @event = (PermissionCreatedEvent)e;
Assert.Equal("test", @event.Name);
Assert.Equal("test", @event.Description);
});
Assert.NotEqual(Guid.Empty, agg.Id);
Assert.Equal("test", agg.Name);
Assert.Equal("test", agg.Description);
}
public async void setup_context_to_return_one_item(PermissionAggregate agg)
{
var list = new List <PermissionTemplateProjection>
{
new PermissionTemplateProjection
{
Id = Guid.Empty,
Name = "testTemplateName",
TemplatePermissions = JsonConvert.SerializeObject(
new Dictionary <Guid, string>
{
{ agg.Id, agg.Name }
})
}
};
ContextMock.Setup(a => a.PermissionTemplateProjection)
.Returns(MockDbSetFactory.MockDbSet(list).Object);
ContextMock.Setup(a => a.PermissionTemplateProjection.AddAsync(It.IsAny <PermissionTemplateProjection>(), It.IsAny <CancellationToken>()))
.Callback <PermissionTemplateProjection, CancellationToken>((a, b) =>
{
list.Add(a);
ContextAddWasCalled = true;
})
.Returns(Task.FromResult((EntityEntry <PermissionTemplateProjection>)null));
ContextMock.Setup(a => a.SaveChangesAsync(It.IsAny <CancellationToken>()))
.Callback(() =>
{
ContextSaveWasCalled = true;
})
.ReturnsAsync(await Task.FromResult(0));
}
public async Task <PermissionDTO> Handle(CreatePermissionCommand command)
{
var permAgg = PermissionAggregate.CreateNewPermission(command.Input);
await _session.Add(permAgg);
await _session.Commit();
return(_mapper.Map <PermissionDTO>(permAgg));
}
public static PermissionAggregate SetupTestPermission()
{
CreateNewPermissionDTO input = new CreateNewPermissionDTO
{
Name = "test",
Description = "test",
IsActive = true
};
return(PermissionAggregate.CreateNewPermission(input));
}
public PermissionAggregate SetupTestDisabledPermission()
{
var createPermisisonDTO = new CreateNewPermissionDTO
{
Name = "testPermisison",
Description = "testDescription",
IsActive = false,
Image = "testUrl"
};
var permAgg = PermissionAggregate.CreateNewPermission(createPermisisonDTO);
return(permAgg);
}
public async void setup_session_to_ensure_addAndCommit_are_called(PermissionAggregate permAagg)
{
SessionMock.Setup(a => a.Get <PermissionAggregate>(permAagg.Id, It.IsAny <int?>(), It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionGetWasCalled = true;
})
.ReturnsAsync(await Task.FromResult(permAagg));
SessionMock.Setup(a => a.Commit(It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionCommitWasCalled = true;
})
.Returns(Task.FromResult(0));
}
public void given_new_permission_should_have_correct_values_after_update_permission_event()
{
//assemble
CreateNewPermissionDTO input = new CreateNewPermissionDTO
{
Name = "test",
Description = "test",
IsActive = true
};
var agg = PermissionAggregate.CreateNewPermission(input);
var userAgg = PermissionAggregateMockAggregate.SetupAdminUser();
var updateInfo = new UpdatePermissionInfoDTO
{
Id = agg.Id,
UpdatedById = userAgg.Id,
Name = "New Name",
Description = "New Description",
};
//apply
agg.UpdatePermissionInfo(updateInfo);
//assert
var changes = agg.GetUncommittedChanges();
Assert.Equal(2, changes.Length);
Assert.Collection(changes,
(e) =>
{
Assert.IsType <PermissionCreatedEvent>(e);
},
(e) =>
{
Assert.IsType <PermissionInfoUpdatedEvent>(e);
var @event = (PermissionInfoUpdatedEvent)e;
Assert.Equal(@event.Name, updateInfo.Name);
Assert.Equal(@event.Description, updateInfo.Description);
});
Assert.Equal(agg.Name, updateInfo.Name);
Assert.Equal(agg.Description, updateInfo.Description);
}
public PermissionTemplateProjection SetupTestPermissionTemplate()
{
var createPermisisonDTO = new CreateNewPermissionDTO
{
Name = "testPermisison",
Description = "testDescription",
IsActive = true,
Image = "testUrl"
};
var permAgg = PermissionAggregate.CreateNewPermission(createPermisisonDTO);
var permissionTemplate = new PermissionTemplateProjection
{
Id = new Guid(),
Name = "testName",
TemplatePermissions = JsonConvert.SerializeObject(new Dictionary <Guid, string>
{
{ permAgg.Id, permAgg.Name }
})
};
return(permissionTemplate);
}
public void setup_session_to_return_aggregate_with_requested_permission(UserAggregate agg, PermissionAggregate permAgg)
{
SessionCommitWasCalled = false;
var input = new RequestUserPermissionsDTO
{
ForId = agg.Id,
ById = agg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{
permAgg.Id, new PermissionDetails
{
Reason = "testReason"
}
}
}
};
agg.UserRequestedPermissions(new List <PermissionAggregate> {
permAgg
}, input);
SessionMock.Setup(a => a.Get <UserAggregate>(It.IsAny <Guid>(), It.IsAny <int?>(), It.IsAny <CancellationToken>()))
.Callback(() =>
{
SessionGetWasCalled = true;
})
.Returns(Task.FromResult(agg));
}
