public void given_UserPermissionsRequestedCommand_handler_should_call_session_Get_and_Commit_for_unlisted_permission()
{
// Assemble
var mockAgg = new UserPermissionsRequestedCommandHandlerMockAggregate();
mockAgg.setup_session_to_ensure_addAndCommit_are_called();
var testAgg = mockAgg.SetupAdminUser();
var testPermissionAgg = mockAgg.SetupTestPermission();
var handler = mockAgg.HandlerFactory();
var input = new RequestUserPermissionsDTO
{
ForId = testAgg.Id,
ById = testAgg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{
testPermissionAgg.Id, new PermissionDetails
{
Reason = "testRequestReason"
}
}
}
};
var command = new UserPermissionsRequestedCommand(input);
// Apply
var result = handler.Handle(command);
// Assert
Assert.True(mockAgg.SessionGetWasCalled);
Assert.True(mockAgg.SessionCommitWasCalled);
}
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));
}
public void user_permission_list_should_not_contain_requested_permission_after_UserPermissionRequestedEvent_with_inactive_permission()
{
// Assemble
var agg = UserAggregateMockAggregate.SetupAdminUser();
var permissionAgg = UserAggregateMockAggregate.SetupTestPermission();
permissionAgg.DisablePermission(agg);
RequestUserPermissionsDTO requestInput = new RequestUserPermissionsDTO
{
ForId = agg.Id,
ById = agg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{ permissionAgg.Id, new PermissionDetails
{
Reason = "TestReason"
} }
},
};
// Apply
agg.UserRequestedPermissions(new List <PermissionAggregate> {
permissionAgg
}, requestInput);
// Assert
Assert.False(agg.PermissionList.Any());
}
public async Task <UserDTO> RequestPermissions([FromBody] RequestUserPermissionsDTO input)
{
var command = new UserPermissionsRequestedCommand(input);
var result = await _commandDispatcher.Execute(command);
return(result);
}
public void user_permission_list_should_not_have_revoked_permission_after_UserPermissionRevokedEvent_when_permission_was_not_previously_granted()
{
// Assemble
var agg = UserAggregateMockAggregate.SetupAdminUser();
var permissionAgg = UserAggregateMockAggregate.SetupTestPermission();
RevokeUserPermissionDTO revokeInput = new RevokeUserPermissionDTO()
{
ForId = agg.Id,
ById = agg.Id,
PermissionsToRevoke = new Dictionary <Guid, PermissionDetails>
{
{
permissionAgg.Id, new PermissionDetails
{
Reason = "test revoke reason"
}
}
}
};
RequestUserPermissionsDTO requestInput = new RequestUserPermissionsDTO
{
ForId = agg.Id,
ById = agg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{ permissionAgg.Id, new PermissionDetails
{
Reason = "TestReason"
} }
},
};
agg.UserRequestedPermissions(new List <PermissionAggregate> {
permissionAgg
}, requestInput);
// Apply
agg.RevokePermission(agg, revokeInput);
// Assert
var changes = agg.FlushUncommitedChanges();
Assert.Equal(2, changes.Length);
Assert.Collection(changes,
(e) =>
{
Assert.IsType <UserCreatedEvent>(e);
},
(e) =>
{
Assert.IsType <UserPermissionsRequestedEvent>(e);
}
);
Assert.True(agg.PermissionList.ContainsKey(permissionAgg.Id));
Assert.Equal(agg.PermissionList[permissionAgg.Id].EventType, JsonConvert.SerializeObject(typeof(UserPermissionsRequestedEvent).FullName));
}
public void user_permission_list_should_contain_requested_permission_after_UserPermissionRequestedEvent()
{
// Assemble
var agg = UserAggregateMockAggregate.SetupAdminUser();
var permissionAgg = UserAggregateMockAggregate.SetupTestPermission();
RequestUserPermissionsDTO requestInput = new RequestUserPermissionsDTO
{
ForId = agg.Id,
ById = agg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{ permissionAgg.Id, new PermissionDetails
{
Reason = "TestReason"
} }
},
};
// Apply
agg.UserRequestedPermissions(new List <PermissionAggregate> {
permissionAgg
}, requestInput);
// Assert
var changes = agg.FlushUncommitedChanges();
Assert.Equal(2, changes.Length);
Assert.Collection(changes,
(e) =>
{
Assert.IsType <UserCreatedEvent>(e);
},
(e) =>
{
Assert.IsType <UserPermissionsRequestedEvent>(e);
var @event = (UserPermissionsRequestedEvent)e;
Assert.NotEqual(Guid.Empty, @event.Id);
Assert.Equal(2, @event.Version);
Assert.NotEqual(new DateTime(), @event.TimeStamp);
Assert.True(@event.Requests.Any());
Assert.True(@event.Requests.ContainsKey(permissionAgg.Id));
Assert.Equal(@event.Requests[permissionAgg.Id].EventType, JsonConvert.SerializeObject(typeof(UserPermissionsRequestedEvent).FullName));
Assert.Equal(@event.Requests[permissionAgg.Id].Reason, requestInput.Requests[permissionAgg.Id].Reason);
Assert.True(@event.Requests[permissionAgg.Id].IsPending);
//Assert.NotEqual(@event.Requests[permissionAgg.Id].RequestDate, new DateTime());
Assert.Equal(@event.Requests[permissionAgg.Id].RequestedBy, agg.Id);
Assert.Equal(@event.Requests[permissionAgg.Id].RequestedFor, agg.Id);
});
Assert.True(agg.PermissionList.ContainsKey(permissionAgg.Id));
Assert.Equal(agg.PermissionList[permissionAgg.Id].EventType, JsonConvert.SerializeObject(typeof(UserPermissionsRequestedEvent).FullName));
}
public void given_GrantUserPermissionCommand_handler_should_call_session_Get_and_Commit_on_requested_permission()
{
// Assemble
var mockAgg = new GrantUserPermissionCommandHandlerMockAggregate();
var requestHandler = mockAgg.UserPermissionsRequestedHandlerFactory();
var granthandler = mockAgg.GrantUserPermissionHandlerFactory();
var testAgg = mockAgg.SetupAdminUser();
var testPermissionAgg = mockAgg.SetupTestPermission();
mockAgg.setup_session_to_return_correct_aggregate(testAgg, testPermissionAgg);
var grantInput = new GrantUserPermissionDTO
{
ForId = testAgg.Id,
ById = testAgg.Id,
PermissionsToGrant = new Dictionary <Guid, PermissionDetails>
{
{
testPermissionAgg.Id, new PermissionDetails
{
Reason = "testGrantReason"
}
}
}
};
var grantCommand = new GrantUserPermissionCommand(grantInput);
var requestInput = new RequestUserPermissionsDTO
{
ForId = testAgg.Id,
ById = testAgg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{
testPermissionAgg.Id, new PermissionDetails
{
Reason = "testRequestReason"
}
}
}
};
var requestCommand = new UserPermissionsRequestedCommand(requestInput);
var requestResult = requestHandler.Handle(requestCommand);
// Apply
var grantResult = granthandler.Handle(grantCommand);
// Assert
Assert.True(mockAgg.SessionGetWasCalled);
Assert.True(mockAgg.SessionCommitWasCalled);
Assert.True(mockAgg.SessionGetPermisisonWasCalled);
}
public async void given_DenyUserPermissionRequestCommand_handler_should_call_session_Get_and_Commit_when_permission_was_requested()
{
// Assemble
var mockAgg = new DenyUserPermissionRequestCommandHandlerMockAggregate();
var testAgg = mockAgg.SetupAdminUser();
var testPermissionAgg = mockAgg.SetupTestPermission();
var denyHandler = mockAgg.DenyUserPermissionRequestHandlerFactory();
var requestHandler = mockAgg.UserPermissionsRequestedHandlerFactory();
mockAgg.setup_session_to_return_correct_aggregate(testAgg, testPermissionAgg);
var denyInput = new DenyUserPermissionRequestDTO
{
ForId = testAgg.Id,
ById = testAgg.Id,
PermissionsToDeny = new Dictionary <Guid, PermissionDetails>
{
{
testPermissionAgg.Id, new PermissionDetails
{
Reason = "testDenyReason"
}
}
}
};
var requestInput = new RequestUserPermissionsDTO
{
ForId = testAgg.Id,
ById = testAgg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{
testPermissionAgg.Id, new PermissionDetails
{
Reason = "testRequestReason"
}
}
}
};
var requestCommand = new UserPermissionsRequestedCommand(requestInput);
var result = await requestHandler.Handle(requestCommand);
var denyCommand = new DenyUserPermissionRequestCommand(denyInput);
// Apply
var denyResult = await denyHandler.Handle(denyCommand);
// Assert
Assert.True(mockAgg.SessionGetWasCalled);
Assert.True(mockAgg.SessionCommitWasCalled);
Assert.True(mockAgg.SessionGetPermisisonWasCalled);
}
public async void given_requestuserpermissionscommand_command_dispatcher_should_get_same_command_created_in_controller()
{
//Assemble
var mockAgg = new UserControllerMockAggregate();
var id = new Guid();
var userId = new Guid();
var requests = new Dictionary <Guid, PermissionDetails>
{
{
new Guid(), new PermissionDetails
{
EventType = "testEvent",
IsPending = true,
Reason = "testReason",
RequestedBy = id,
RequestedFor = userId,
RequestDate = new DateTime()
}
}
};
var input = new RequestUserPermissionsDTO()
{
ById = id,
ForId = userId,
Requests = requests
};
var command = new UserPermissionsRequestedCommand(input);
mockAgg.setup_dispatcher_to_verify_userPermissionsRequestedCommands_are_the_same(command);
var controller = mockAgg.CreateUserController();
//Apply
var result = await controller.RequestPermissions(input);
//Assert
Assert.IsType <UserDTO>(result);
Assert.Equal(result.Id, input.ForId);
Assert.Equal(result.PermissionList, input.Requests);
}
public void UserRequestedPermissions(List <PermissionAggregate> permissions, RequestUserPermissionsDTO dto)
{
//business Logic here!
//check to see if permission is active
foreach (var permission in permissions)
{
if (!permission.IsActive)
{
dto.Requests.Remove(permission.Id);
}
//might need to add here some way to signal the UI to show that there was an inactive permission in their request.
//for now, let us just remove it from the list of requests.
}
if (dto.Requests.Any())
{
ApplyChange(new UserPermissionsRequestedEvent(dto));
}
}
public UserPermissionsRequestedEvent(RequestUserPermissionsDTO dto)
{
foreach (var request in dto.Requests)
{
var reason = String.IsNullOrWhiteSpace(dto.Requests[request.Key].Reason)
? "Reason Not Specified"
: dto.Requests[request.Key].Reason;
var r = new PermissionDetails
{
EventType = JsonConvert.SerializeObject(GetType().FullName),
IsPending = true,
Reason = reason,
RequestDate = DateTime.UtcNow,
RequestedBy = dto.ById,
RequestedFor = dto.ForId
};
Requests[request.Key] = r;
}
}
public async void handler_should_filter_already_requested_command_out_of_requests()
{
// Assemble
var mockAgg = new UserPermissionsRequestedCommandHandlerMockAggregate();
mockAgg.setup_session_to_ensure_addAndCommit_are_called();
var testAgg = mockAgg.SetupAdminUser();
var testPermissionAgg = mockAgg.SetupTestPermission();
var handler = mockAgg.HandlerFactory();
var input = new RequestUserPermissionsDTO
{
ForId = testAgg.Id,
ById = testAgg.Id,
Requests = new Dictionary <Guid, PermissionDetails>
{
{
testPermissionAgg.Id, new PermissionDetails
{
Reason = "testRequestReason"
}
}
}
};
var command = new UserPermissionsRequestedCommand(input);
// Apply
var result = await handler.Handle(command);
Assert.True(mockAgg.SessionCommitWasCalled);
mockAgg.setup_session_to_return_aggregate_with_requested_permission(testAgg, testPermissionAgg);
var result2 = await handler.Handle(command);
// Assert
Assert.False(mockAgg.SessionCommitWasCalled);
}
public UserPermissionsRequestedCommand(RequestUserPermissionsDTO input)
{
Input = input;
}
