diff --git a/.circleci/config.yml b/.circleci/config.yml index 50ef45912..85de5dbf8 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -3,7 +3,7 @@ executorType: machine jobs: test: docker: - - image: circleci/openjdk:8-jdk + - image: circleci/openjdk:11-jdk working_directory: ~/repo diff --git a/Dockerfile b/Dockerfile index 9b4f0ceb5..0947d3cb5 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,4 @@ -FROM java:8-jdk +FROM openjdk:11.0.3-jdk ARG MAVEN_VERSION=3.5.3 ARG SHA=b52956373fab1dd4277926507ab189fb797b3bc51a2a267a193c931fffad8408 diff --git a/README.md b/README.md index e006c596a..e6082c5b3 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ [![Slack](http://slack.overture.bio/badge.svg)](http://slack.overture.bio) ## Table of Contents - +- [Documentation](#documentation) - [Introduction](#introduction) - [Features](#features) - [Tech Stack](#tech-stack) @@ -27,6 +27,10 @@ - [Shoutouts](#shoutouts) - [Browserstack](#browserstack) +## Documentation + +Explore documentation with the Ego [Read the Docs](https://ego.readthedocs.io/en/latest/). + ## Introduction [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) diff --git a/pom.xml b/pom.xml index e7bf4f4bf..15e22925b 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ bio.overture ego - 2.2.1 + 2.2.2-SNAPSHOT ego OAuth 2.0 Authorization service that supports multiple OpenID Connect Providers @@ -13,15 +13,16 @@ org.springframework.boot spring-boot-starter-parent - 2.0.2.RELEASE + 2.1.4.RELEASE UTF-8 UTF-8 - 1.8 + 11 1.2.0.Final + 1.19.0 @@ -59,8 +60,10 @@ org.projectlombok lombok + 1.18.8 true + io.springfox springfox-swagger2 @@ -124,17 +127,17 @@ org.testcontainers testcontainers - 1.7.2 + 1.10.0 org.testcontainers jdbc - 1.7.2 + 1.10.0 org.testcontainers postgresql - 1.7.2 + 1.10.0 commons-io @@ -159,7 +162,7 @@ com.google.api-client google-api-client - 1.23.0 + 1.28.0 @@ -172,16 +175,10 @@ com.fasterxml.jackson.core jackson-databind - 2.9.8 + 2.9.9.1 - - org.assertj - assertj-core - 3.11.1 - test - net.javacrumbs.json-unit json-unit-fluent @@ -239,6 +236,39 @@ ${mapstruct.version} + + + io.grpc + grpc-netty-shaded + ${grpc.version} + + + io.grpc + grpc-protobuf + ${grpc.version} + + + io.grpc + grpc-stub + ${grpc.version} + + + com.google.guava + guava + 27.1-jre + + + io.grpc + grpc-services + ${grpc.version} + + + io.grpc + grpc-testing + ${grpc.version} + test + + org.springframework.boot spring-boot-devtools @@ -251,9 +281,22 @@ 1.2 + + org.glassfish.jaxb + jaxb-runtime + + + + + kr.motd.maven + os-maven-plugin + 1.5.0.Final + + + com.coveo @@ -300,6 +343,26 @@ + + + org.xolstice.maven.plugins + protobuf-maven-plugin + 0.5.1 + + com.google.protobuf:protoc:3.6.1:exe:${os.detected.classifier} + ${basedir}/src/main/proto + grpc-java + io.grpc:protoc-gen-grpc-java:1.19.0:exe:${os.detected.classifier} + + + + + compile + compile-custom + + + + diff --git a/src/main/java/bio/overture/ego/controller/PolicyController.java b/src/main/java/bio/overture/ego/controller/PolicyController.java index 9b3fa0f76..4bb69fdc0 100644 --- a/src/main/java/bio/overture/ego/controller/PolicyController.java +++ b/src/main/java/bio/overture/ego/controller/PolicyController.java @@ -89,6 +89,12 @@ public PolicyController( dataType = "string", paramType = "query", value = "Search for ids containing this text"), + @ApiImplicitParam( + name = Fields.NAME, + required = false, + dataType = "string", + paramType = "query", + value = "Search for polices whose names containing this text"), @ApiImplicitParam( name = LIMIT, required = false, diff --git a/src/main/java/bio/overture/ego/controller/UserController.java b/src/main/java/bio/overture/ego/controller/UserController.java index 28e7d5d7b..187751d55 100644 --- a/src/main/java/bio/overture/ego/controller/UserController.java +++ b/src/main/java/bio/overture/ego/controller/UserController.java @@ -386,18 +386,18 @@ public void deleteGroupsFromUser( public @ResponseBody User addApplicationsToUser( @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = true) final String accessToken, @PathVariable(value = "id", required = true) UUID id, - @RequestBody(required = true) List appIds) { - return userService.addUserToApps(id, appIds); + @RequestBody(required = true) List applicationIds) { + return userService.associateApplicationsWithUser(id, applicationIds); } @AdminScoped - @RequestMapping(method = RequestMethod.DELETE, value = "/{id}/applications/{appIds}") + @RequestMapping(method = RequestMethod.DELETE, value = "/{id}/applications/{applicationIds}") @ApiResponses(value = {@ApiResponse(code = 200, message = "Delete Applications from User")}) @ResponseStatus(value = HttpStatus.OK) public void deleteApplicationsFromUser( @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = true) final String accessToken, @PathVariable(value = "id", required = true) UUID id, - @PathVariable(value = "appIds", required = true) List appIds) { - userService.deleteUserFromApps(id, appIds); + @PathVariable(value = "applicationIds", required = true) List applicationIds) { + userService.disassociateApplicationsFromUser(id, applicationIds); } } diff --git a/src/main/java/bio/overture/ego/grpc/GrpcServer.java b/src/main/java/bio/overture/ego/grpc/GrpcServer.java new file mode 100644 index 000000000..d681202d8 --- /dev/null +++ b/src/main/java/bio/overture/ego/grpc/GrpcServer.java @@ -0,0 +1,71 @@ +package bio.overture.ego.grpc; + +import bio.overture.ego.grpc.interceptor.AuthInterceptor; +import bio.overture.ego.grpc.service.UserServiceGrpcImpl; +import io.grpc.Server; +import io.grpc.ServerBuilder; +import io.grpc.ServerInterceptors; +import java.util.Optional; +import lombok.NonNull; +import lombok.extern.slf4j.Slf4j; +import lombok.val; +import org.springframework.beans.factory.DisposableBean; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.CommandLineRunner; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +@Slf4j +@Component +@Profile("grpc") +public class GrpcServer implements CommandLineRunner, DisposableBean { + + @Value("${grpc.port}") + private int port; + + private Server server; + + private final AuthInterceptor authInterceptor; + private final UserServiceGrpcImpl userServiceImpl; + + @Autowired + public GrpcServer( + @NonNull AuthInterceptor authInterceptor, @NonNull UserServiceGrpcImpl userServiceImpl) { + + this.authInterceptor = authInterceptor; + + this.userServiceImpl = userServiceImpl; + } + + @Override + public void run(String... args) throws Exception { + + val userService = ServerInterceptors.intercept(userServiceImpl, authInterceptor); + + server = ServerBuilder.forPort(port).addService(userService).build().start(); + + log.info("gRPC Server started, listening on " + port); + startDaemonAwaitThread(); + } + + private void startDaemonAwaitThread() { + Thread awaitThread = + new Thread( + () -> { + try { + this.server.awaitTermination(); + } catch (InterruptedException e) { + log.error("gRPC server stopped.", e); + } + }); + awaitThread.start(); + } + + @Override + public final void destroy() throws Exception { + log.info("Shutting down gRPC server ..."); + Optional.ofNullable(server).ifPresent(Server::shutdown); + log.info("gRPC server stopped."); + } +} diff --git a/src/main/java/bio/overture/ego/grpc/ProtoUtils.java b/src/main/java/bio/overture/ego/grpc/ProtoUtils.java new file mode 100644 index 000000000..23a01079f --- /dev/null +++ b/src/main/java/bio/overture/ego/grpc/ProtoUtils.java @@ -0,0 +1,149 @@ +package bio.overture.ego.grpc; + +import static java.util.stream.Collectors.toList; + +import bio.overture.ego.model.enums.JavaFields; +import com.google.protobuf.StringValue; +import com.google.protobuf.UInt32Value; +import java.util.Arrays; +import java.util.Optional; +import lombok.val; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; +import org.springframework.data.domain.Sort; + +public class ProtoUtils { + + public static final StringValue DEFAULT_STRING = StringValue.of(""); + + private static final String DEFAULT_SORT_FIELD = "createdAt"; + private static final int DEFAULT_LIMIT = 100; + private static final int MAX_LIMIT = 1000; + + /* toProtoString + * Use this to convert a potentially null value into a String for a protobuf value + * + * Will return Empty String if the value is null, otherwise the toString output for the Object + */ + public static StringValue toProtoString(Object value) { + return value == null ? DEFAULT_STRING : StringValue.of(value.toString()); + } + + public static PagedResponse createPagedResponse(Page page, int currentPageNum) { + val pageBuilder = + PagedResponse.newBuilder().setMaxResults(Long.valueOf(page.getTotalElements()).intValue()); + + if (page.getTotalPages() - 1 > currentPageNum) { + val nextPage = UInt32Value.of(currentPageNum + 1); + pageBuilder.setNextPage(nextPage); + } + + return pageBuilder.build(); + } + + public static Pageable getPageable(PagedRequest pagedRequest) { + + val pageSize = pagedRequest.getPageSize(); + val sort = pagedRequest.getOrderBy(); + + val limit = pageSize == 0 ? DEFAULT_LIMIT : pageSize > MAX_LIMIT ? MAX_LIMIT : pageSize; + + val pageNumber = pagedRequest.getPageNumber(); + + return new Pageable() { + + @Override + public int getPageNumber() { + return 0; + } + + @Override + public int getPageSize() { + return limit; + } + + @Override + public long getOffset() { + return pageNumber * limit; + } + + @Override + public Sort getSort() { + return parseSort(sort); + } + + @Override + public Pageable next() { + return null; + } + + @Override + public Pageable previousOrFirst() { + return null; + } + + @Override + public Pageable first() { + return null; + } + + @Override + public boolean hasPrevious() { + return false; + } + }; + } + + public static Sort parseSort(String sort) { + if (sort.isEmpty()) { + // Sort results by creation time, ensure static order for the page_token to refer to + return new Sort(Sort.Direction.ASC, JavaFields.CREATEDAT); + } else { + val orders = + Arrays.stream(sort.split(",")) + .map(ProtoUtils::parseSortOrder) + .filter(optional -> optional.isPresent()) + .map(optional -> optional.get()) + .collect(toList()); + return Sort.by(orders); + } + } + + private static Optional parseSortOrder(String sort) { + + if (!sort.isEmpty()) { + val split = sort.trim().split(" "); + switch (split.length) { + case 1: + // Example: "id" + if (sort.equalsIgnoreCase(Sort.Direction.DESC.name())) { + // Special case, sort value is exactly "desc" + return Optional.of(new Sort.Order(Sort.Direction.DESC, DEFAULT_SORT_FIELD)); + + } else if (sort.equalsIgnoreCase(Sort.Direction.ASC.name())) { + // Special case, sort value is exactly "asc" + return Optional.of(new Sort.Order(Sort.Direction.ASC, DEFAULT_SORT_FIELD)); + + } else { + return Optional.of(new Sort.Order(Sort.Direction.ASC, split[0])); + } + + case 2: + // Example: "name desc" + if (split[1].equalsIgnoreCase(Sort.Direction.DESC.name())) { + return Optional.of(new Sort.Order(Sort.Direction.DESC, split[0])); + + } else if (split[1].equalsIgnoreCase(Sort.Direction.ASC.name())) { + return Optional.of(new Sort.Order(Sort.Direction.ASC, split[0])); + } + break; + + default: + // sort string length was 0 or longer than 2 + return Optional.empty(); + } + } + // Fall through - nothing matching expected formatting + return Optional.empty(); + } +} diff --git a/src/main/java/bio/overture/ego/grpc/interceptor/ApplicationAuthInterceptor.java b/src/main/java/bio/overture/ego/grpc/interceptor/ApplicationAuthInterceptor.java new file mode 100644 index 000000000..f6c0934ce --- /dev/null +++ b/src/main/java/bio/overture/ego/grpc/interceptor/ApplicationAuthInterceptor.java @@ -0,0 +1,121 @@ +package bio.overture.ego.grpc.interceptor; + +import static io.grpc.Metadata.ASCII_STRING_MARSHALLER; + +import bio.overture.ego.model.entity.Application; +import bio.overture.ego.model.entity.User; +import bio.overture.ego.model.enums.ApplicationType; +import bio.overture.ego.model.enums.StatusType; +import bio.overture.ego.model.enums.UserType; +import bio.overture.ego.service.ApplicationService; +import bio.overture.ego.service.TokenService; +import bio.overture.ego.service.UserService; +import io.grpc.*; +import java.util.Optional; +import java.util.UUID; +import lombok.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Primary; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +@Component +@Profile("auth") +@Primary +public class ApplicationAuthInterceptor implements AuthInterceptor { + + public static final Context.Key AUTHORIZED_JWT = Context.key("jwt"); + public static final Context.Key AUTH_INFO = Context.key("auth_info"); + + @Autowired private TokenService tokenService; + @Autowired private UserService userService; + @Autowired private ApplicationService applicationService; + + private static final Metadata.Key JWT_METADATA_KEY = + Metadata.Key.of("jwt", ASCII_STRING_MARSHALLER); + + private static final ServerCall.Listener NOOP_LISTENER = new ServerCall.Listener() {}; + + @Override + public ServerCall.Listener interceptCall( + ServerCall call, Metadata metadata, ServerCallHandler next) { + try { + // You need to implement validateIdentity + String token = metadata.get(JWT_METADATA_KEY); + + val userInfo = getUserInfo(token); + val appInfo = getAppInfo(token); + + if (!validateJwt(token) || !(userInfo.isPresent() || appInfo.isPresent())) { + call.close(Status.UNAUTHENTICATED.withDescription("Invalid JWT"), metadata); + return NOOP_LISTENER; + } + + val isApproved = + (userInfo.isPresent() && userInfo.get().getStatus() == StatusType.APPROVED) + || (appInfo.isPresent() && appInfo.get().getStatus() == StatusType.APPROVED); + + if (!isApproved) { + call.close(Status.UNAUTHENTICATED.withDescription("Status not approved."), metadata); + return NOOP_LISTENER; + } + + val isAdmin = + (userInfo.isPresent() && userInfo.get().getType() == UserType.ADMIN) + || (appInfo.isPresent() && appInfo.get().getType() == ApplicationType.ADMIN); + val id = userInfo.isPresent() ? userInfo.get().getId() : appInfo.get().getId(); + + val authInfo = new AuthInfo(userInfo.isPresent(), appInfo.isPresent(), isAdmin, id); + + Context context = + Context.current().withValue(AUTHORIZED_JWT, token).withValue(AUTH_INFO, authInfo); + return Contexts.interceptCall(context, call, metadata, next); + + } catch (IllegalArgumentException e) { + call.close(Status.UNAUTHENTICATED.withDescription("Missing JWT"), metadata); + return NOOP_LISTENER; + } + } + + private boolean validateJwt(String token) { + return tokenService.isValidToken(token); + } + + @SneakyThrows + private Optional getUserInfo(String token) { + val claims = tokenService.getTokenUserInfo(token); + + return claims == null ? Optional.empty() : userService.findById(claims.getId()); + } + + @SneakyThrows + private Optional getAppInfo(String token) { + val claims = tokenService.getTokenAppInfo(token); + return claims == null + ? Optional.empty() + : applicationService.findByClientId(claims.getClientId()); + } + + @Getter + public class AuthInfo { + + boolean user; + + boolean app; + + boolean admin; + + UUID id; + + public AuthInfo( + @NonNull final boolean isUser, + @NonNull final boolean isApp, + @NonNull final boolean isAdmin, + @NonNull final UUID id) { + this.user = isUser; + this.app = isApp; + this.admin = isAdmin; + this.id = id; + } + } +} diff --git a/src/main/java/bio/overture/ego/grpc/interceptor/AuthInterceptor.java b/src/main/java/bio/overture/ego/grpc/interceptor/AuthInterceptor.java new file mode 100644 index 000000000..484da0983 --- /dev/null +++ b/src/main/java/bio/overture/ego/grpc/interceptor/AuthInterceptor.java @@ -0,0 +1,5 @@ +package bio.overture.ego.grpc.interceptor; + +import io.grpc.ServerInterceptor; + +public interface AuthInterceptor extends ServerInterceptor {} diff --git a/src/main/java/bio/overture/ego/grpc/interceptor/NoAuthInterceptor.java b/src/main/java/bio/overture/ego/grpc/interceptor/NoAuthInterceptor.java new file mode 100644 index 000000000..749e8416c --- /dev/null +++ b/src/main/java/bio/overture/ego/grpc/interceptor/NoAuthInterceptor.java @@ -0,0 +1,20 @@ +package bio.overture.ego.grpc.interceptor; + +import io.grpc.Metadata; +import io.grpc.ServerCall; +import io.grpc.ServerCallHandler; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Component; + +/** Noop Interceptor */ +@Slf4j +@Component +public class NoAuthInterceptor implements AuthInterceptor { + + @Override + public ServerCall.Listener interceptCall( + ServerCall call, Metadata headers, ServerCallHandler next) { + log.info("No Auth Interceptor..."); + return next.startCall(call, headers); + } +} diff --git a/src/main/java/bio/overture/ego/grpc/service/UserServiceGrpcImpl.java b/src/main/java/bio/overture/ego/grpc/service/UserServiceGrpcImpl.java new file mode 100644 index 000000000..b75d45c1e --- /dev/null +++ b/src/main/java/bio/overture/ego/grpc/service/UserServiceGrpcImpl.java @@ -0,0 +1,128 @@ +package bio.overture.ego.grpc.service; + +import static bio.overture.ego.grpc.ProtoUtils.createPagedResponse; +import static bio.overture.ego.grpc.ProtoUtils.getPageable; + +import bio.overture.ego.grpc.*; +import bio.overture.ego.grpc.interceptor.ApplicationAuthInterceptor; +import bio.overture.ego.model.exceptions.NotFoundException; +import bio.overture.ego.service.UserService; +import bio.overture.ego.utils.CollectionUtils; +import io.grpc.Status; +import io.grpc.stub.StreamObserver; +import java.util.Collections; +import java.util.UUID; +import lombok.extern.slf4j.Slf4j; +import lombok.val; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.data.domain.Page; +import org.springframework.stereotype.Component; + +@Component +@Slf4j +public class UserServiceGrpcImpl extends UserServiceGrpc.UserServiceImplBase { + + private final UserService userService; + + @Autowired + public UserServiceGrpcImpl(UserService userService) { + this.userService = userService; + } + + @Override + public void getUser(GetUserRequest request, StreamObserver responseObserver) { + User output = User.getDefaultInstance(); + + try { + val id = UUID.fromString(request.getId()); + + val authInfo = ApplicationAuthInterceptor.AUTH_INFO.get(); + if (authInfo != null) { + + // Auth Checks - must be Admin, or an app, or a user requesting their own data. + val selfRequest = authInfo.isUser() && id.equals(authInfo.getId()); + if (!(authInfo.isAdmin() || authInfo.isApp() || selfRequest)) { + responseObserver.onError( + Status.UNAUTHENTICATED + .withDescription("Must be ADMIN or a user requesting themselves.") + .asRuntimeException()); + return; + } + } + + val user = userService.get(id, true, true, true); + output = user.toProto(); + + } catch (NotFoundException e) { + log.debug("gRPC Get UserService could not find user with requested ID:", e.getMessage()); + responseObserver.onError( + Status.NOT_FOUND.withDescription("No User found for provided ID.").asRuntimeException()); + return; + } catch (IllegalArgumentException e) { + log.info("gRPC Get UserService received invalid ID:", e.getMessage()); + responseObserver.onError( + Status.INVALID_ARGUMENT.withDescription("ID is not a valid UUID.").asRuntimeException()); + return; + } + + responseObserver.onNext(output); + responseObserver.onCompleted(); + } + + @Override + public void listUsers( + ListUsersRequest request, StreamObserver responseObserver) { + + val authInfo = ApplicationAuthInterceptor.AUTH_INFO.get(); + if (authInfo != null) { + // Auth Checks - must be admin or an app + if (!(authInfo.isAdmin() || authInfo.isApp())) { + responseObserver.onError( + Status.UNAUTHENTICATED + .withDescription("Must be an application or ADMIN user.") + .asRuntimeException()); + return; + } + } + + val output = ListUsersResponse.newBuilder(); + + // Find Page of users (filtered by groups if provided) + val userPage = findUsersForListRequest(request); + + if (userPage.hasContent()) { + val userIds = CollectionUtils.mapToImmutableSet(userPage.getContent(), user -> user.getId()); + + // Only run this fetch if we have at least 1 user ID, filtering by empty list throws error + val users = userService.getMany(userIds, true, true, true); + + // Add to output in order from first query + userIds.forEach( + id -> + users.stream() + .filter(user -> user.getId().equals(id)) + .findFirst() + .ifPresent(user -> output.addUsers(user.toProto()))); + } + + output.setPage(createPagedResponse(userPage, request.getPage().getPageNumber())); + + responseObserver.onNext(output.build()); + responseObserver.onCompleted(); + } + + private Page findUsersForListRequest( + ListUsersRequest request) { + val query = request.hasQuery() ? request.getQuery().getValue() : ""; + val groups = request.getGroupIdsList(); + val pageable = getPageable(request.getPage()); + + if (groups.isEmpty()) { + return userService.findUsers(query, Collections.EMPTY_LIST, pageable); + + } else { + val groupIds = CollectionUtils.mapToImmutableSet(groups, group -> UUID.fromString(group)); + return userService.findUsersForGroups(groupIds, query, Collections.EMPTY_LIST, pageable); + } + } +} diff --git a/src/main/java/bio/overture/ego/model/dto/CreateUserRequest.java b/src/main/java/bio/overture/ego/model/dto/CreateUserRequest.java index 2d35e3070..caa87785b 100644 --- a/src/main/java/bio/overture/ego/model/dto/CreateUserRequest.java +++ b/src/main/java/bio/overture/ego/model/dto/CreateUserRequest.java @@ -37,9 +37,9 @@ public class CreateUserRequest { @NotNull private StatusType status; - private String firstName; + @NotNull private String firstName; - private String lastName; + @NotNull private String lastName; private LanguageType preferredLanguage; } diff --git a/src/main/java/bio/overture/ego/model/dto/Scope.java b/src/main/java/bio/overture/ego/model/dto/Scope.java index 8d3b526f7..42de2f541 100644 --- a/src/main/java/bio/overture/ego/model/dto/Scope.java +++ b/src/main/java/bio/overture/ego/model/dto/Scope.java @@ -2,6 +2,7 @@ import static java.util.Objects.isNull; +import bio.overture.ego.model.entity.AbstractPermission; import bio.overture.ego.model.entity.Policy; import bio.overture.ego.model.enums.AccessLevel; import bio.overture.ego.model.params.ScopeName; @@ -20,6 +21,11 @@ public class Scope { private Policy policy; private AccessLevel accessLevel; + public Scope(AbstractPermission permission) { + this.policy = permission.getPolicy(); + this.accessLevel = permission.getAccessLevel(); + } + @Override public String toString() { return getPolicyName() + "." + getAccessLevelName(); diff --git a/src/main/java/bio/overture/ego/model/dto/UpdateUserRequest.java b/src/main/java/bio/overture/ego/model/dto/UpdateUserRequest.java index 89c39cf5f..c6039e578 100644 --- a/src/main/java/bio/overture/ego/model/dto/UpdateUserRequest.java +++ b/src/main/java/bio/overture/ego/model/dto/UpdateUserRequest.java @@ -19,7 +19,6 @@ import bio.overture.ego.model.enums.LanguageType; import bio.overture.ego.model.enums.StatusType; import bio.overture.ego.model.enums.UserType; -import java.util.Date; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; @@ -37,5 +36,4 @@ public class UpdateUserRequest { private String firstName; private String lastName; private LanguageType preferredLanguage; - private Date lastLogin; } diff --git a/src/main/java/bio/overture/ego/model/entity/AbstractPermission.java b/src/main/java/bio/overture/ego/model/entity/AbstractPermission.java index 1e6e189e2..e8117e195 100644 --- a/src/main/java/bio/overture/ego/model/entity/AbstractPermission.java +++ b/src/main/java/bio/overture/ego/model/entity/AbstractPermission.java @@ -4,9 +4,7 @@ import bio.overture.ego.model.enums.AccessLevel; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; -import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonPropertyOrder; import com.fasterxml.jackson.annotation.JsonSubTypes; import com.vladmihalcea.hibernate.type.basic.PostgreSQLEnumType; @@ -30,11 +28,10 @@ @Data @MappedSuperclass -@EqualsAndHashCode(of = {LombokFields.id}) -@ToString(exclude = {LombokFields.policy}) +@EqualsAndHashCode(of = {"id"}) +@ToString(exclude = {"policy"}) @TypeDef(name = EGO_ACCESS_LEVEL_ENUM, typeClass = PostgreSQLEnumType.class) @JsonPropertyOrder({JavaFields.ID, JavaFields.POLICY, JavaFields.OWNER, JavaFields.ACCESS_LEVEL}) -@JsonInclude(JsonInclude.Include.ALWAYS) @JsonSubTypes({ @JsonSubTypes.Type(value = UserPermission.class, name = JavaFields.USERPERMISSIONS), @JsonSubTypes.Type(value = GroupPermission.class, name = JavaFields.GROUPPERMISSION) diff --git a/src/main/java/bio/overture/ego/model/entity/Application.java b/src/main/java/bio/overture/ego/model/entity/Application.java index dc181a8b0..74e7fba39 100644 --- a/src/main/java/bio/overture/ego/model/entity/Application.java +++ b/src/main/java/bio/overture/ego/model/entity/Application.java @@ -21,11 +21,11 @@ import bio.overture.ego.model.enums.ApplicationType; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.StatusType; import bio.overture.ego.model.enums.Tables; import bio.overture.ego.model.join.GroupApplication; +import bio.overture.ego.model.join.UserApplication; import bio.overture.ego.view.Views; import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonInclude; @@ -42,7 +42,6 @@ import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.Id; -import javax.persistence.ManyToMany; import javax.persistence.OneToMany; import javax.persistence.Table; import javax.validation.constraints.NotNull; @@ -65,8 +64,8 @@ @AllArgsConstructor @Accessors(chain = true) @JsonView(Views.REST.class) -@ToString(exclude = {LombokFields.groupApplications, LombokFields.users}) -@EqualsAndHashCode(of = {LombokFields.id}) +@ToString(exclude = {"groupApplications", "userApplications"}) +@EqualsAndHashCode(of = {"id"}) @JsonPropertyOrder({ JavaFields.ID, JavaFields.NAME, @@ -135,9 +134,10 @@ public class Application implements Identifiable { @JsonIgnore @Builder.Default - @ManyToMany( - mappedBy = JavaFields.APPLICATIONS, + @OneToMany( + mappedBy = JavaFields.APPLICATION, + cascade = CascadeType.ALL, fetch = FetchType.LAZY, - cascade = {CascadeType.MERGE, CascadeType.PERSIST}) - private Set users = newHashSet(); + orphanRemoval = true) + private Set userApplications = newHashSet(); } diff --git a/src/main/java/bio/overture/ego/model/entity/Group.java b/src/main/java/bio/overture/ego/model/entity/Group.java index 4f10e0f2d..e81fbd6e0 100644 --- a/src/main/java/bio/overture/ego/model/entity/Group.java +++ b/src/main/java/bio/overture/ego/model/entity/Group.java @@ -20,7 +20,6 @@ import static com.google.common.collect.Sets.newHashSet; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.StatusType; import bio.overture.ego.model.enums.Tables; @@ -61,10 +60,9 @@ @AllArgsConstructor @Table(name = Tables.GROUP) @JsonView(Views.REST.class) -@EqualsAndHashCode(of = {LombokFields.id}) +@EqualsAndHashCode(of = "id") @TypeDef(name = EGO_ENUM, typeClass = PostgreSQLEnumType.class) -@ToString( - exclude = {LombokFields.userGroups, LombokFields.groupApplications, LombokFields.permissions}) +@ToString(exclude = {"userGroups", "groupApplications", "permissions"}) @JsonPropertyOrder({ JavaFields.ID, JavaFields.NAME, diff --git a/src/main/java/bio/overture/ego/model/entity/GroupPermission.java b/src/main/java/bio/overture/ego/model/entity/GroupPermission.java index 3de712e39..83bf7d919 100644 --- a/src/main/java/bio/overture/ego/model/entity/GroupPermission.java +++ b/src/main/java/bio/overture/ego/model/entity/GroupPermission.java @@ -1,7 +1,6 @@ package bio.overture.ego.model.entity; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.Tables; import bio.overture.ego.view.Views; @@ -29,10 +28,10 @@ @JsonView(Views.REST.class) @ToString( callSuper = true, - exclude = {LombokFields.owner}) + exclude = {"owner"}) @EqualsAndHashCode( callSuper = true, - of = {LombokFields.id}) + of = {"id"}) @NamedEntityGraph( name = "group-permission-entity-with-relationships", attributeNodes = { diff --git a/src/main/java/bio/overture/ego/model/entity/Policy.java b/src/main/java/bio/overture/ego/model/entity/Policy.java index b9754e5c1..aea2ef02f 100644 --- a/src/main/java/bio/overture/ego/model/entity/Policy.java +++ b/src/main/java/bio/overture/ego/model/entity/Policy.java @@ -3,7 +3,6 @@ import static com.google.common.collect.Sets.newHashSet; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.Tables; import bio.overture.ego.view.Views; @@ -40,7 +39,7 @@ @Builder @NoArgsConstructor @AllArgsConstructor -@EqualsAndHashCode(of = {LombokFields.id}) +@EqualsAndHashCode(of = {"id"}) @NamedEntityGraph( name = "policy-entity-with-relationships", attributeNodes = { diff --git a/src/main/java/bio/overture/ego/model/entity/Token.java b/src/main/java/bio/overture/ego/model/entity/Token.java index c802a8012..0d998862e 100644 --- a/src/main/java/bio/overture/ego/model/entity/Token.java +++ b/src/main/java/bio/overture/ego/model/entity/Token.java @@ -5,7 +5,6 @@ import bio.overture.ego.model.dto.Scope; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.Tables; import com.fasterxml.jackson.annotation.JsonIgnore; @@ -36,8 +35,8 @@ @Builder @NoArgsConstructor @AllArgsConstructor -@ToString(exclude = {LombokFields.owner, LombokFields.scopes}) -@EqualsAndHashCode(of = {LombokFields.id}) +@ToString(exclude = {"owner", "scopes"}) +@EqualsAndHashCode(of = {"id"}) public class Token implements Identifiable { @Id diff --git a/src/main/java/bio/overture/ego/model/entity/User.java b/src/main/java/bio/overture/ego/model/entity/User.java index 7c2cf361d..e59073e01 100644 --- a/src/main/java/bio/overture/ego/model/entity/User.java +++ b/src/main/java/bio/overture/ego/model/entity/User.java @@ -16,18 +16,21 @@ package bio.overture.ego.model.entity; +import static bio.overture.ego.grpc.ProtoUtils.toProtoString; import static bio.overture.ego.model.enums.AccessLevel.EGO_ENUM; import static bio.overture.ego.service.UserService.resolveUsersPermissions; +import static bio.overture.ego.utils.CollectionUtils.mapToImmutableSet; import static bio.overture.ego.utils.PolicyPermissionUtils.extractPermissionStrings; import static com.google.common.collect.Sets.newHashSet; +import bio.overture.ego.model.dto.Scope; import bio.overture.ego.model.enums.JavaFields; import bio.overture.ego.model.enums.LanguageType; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.StatusType; import bio.overture.ego.model.enums.Tables; import bio.overture.ego.model.enums.UserType; +import bio.overture.ego.model.join.UserApplication; import bio.overture.ego.model.join.UserGroup; import bio.overture.ego.view.Views; import com.fasterxml.jackson.annotation.JsonIgnore; @@ -35,6 +38,8 @@ import com.fasterxml.jackson.annotation.JsonPropertyOrder; import com.fasterxml.jackson.annotation.JsonView; import com.vladmihalcea.hibernate.type.basic.PostgreSQLEnumType; +import java.text.ParseException; +import java.text.SimpleDateFormat; import java.util.Date; import java.util.List; import java.util.Set; @@ -47,11 +52,11 @@ import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.JoinTable; -import javax.persistence.ManyToMany; import javax.persistence.OneToMany; +import javax.persistence.PrePersist; import javax.persistence.Table; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; import javax.validation.constraints.NotNull; import lombok.AllArgsConstructor; import lombok.Builder; @@ -60,6 +65,8 @@ import lombok.NoArgsConstructor; import lombok.ToString; import lombok.extern.slf4j.Slf4j; +import lombok.val; +import org.hibernate.LazyInitializationException; import org.hibernate.annotations.GenericGenerator; import org.hibernate.annotations.Type; import org.hibernate.annotations.TypeDef; @@ -68,21 +75,15 @@ @Entity @Table(name = Tables.EGOUSER) @Data -@ToString( - exclude = { - LombokFields.userGroups, - LombokFields.applications, - LombokFields.userPermissions, - LombokFields.tokens - }) +@ToString(exclude = {"userGroups", "userApplications", "userPermissions", "tokens"}) @JsonPropertyOrder({ JavaFields.ID, JavaFields.NAME, JavaFields.EMAIL, JavaFields.USERTYPE, JavaFields.STATUS, - JavaFields.GROUPS, - JavaFields.APPLICATIONS, + JavaFields.USERGROUPS, + JavaFields.USERAPPLICATIONS, JavaFields.USERPERMISSIONS, JavaFields.FIRSTNAME, JavaFields.LASTNAME, @@ -91,7 +92,7 @@ JavaFields.PREFERREDLANGUAGE }) @JsonInclude() -@EqualsAndHashCode(of = {LombokFields.id}) +@EqualsAndHashCode(of = {"id"}) @Builder @AllArgsConstructor @NoArgsConstructor @@ -130,10 +131,12 @@ public class User implements PolicyOwner, NameableEntity { @Column(name = SqlFields.STATUS, nullable = false) private StatusType status; + @NotNull @JsonView({Views.JWTAccessToken.class, Views.REST.class}) @Column(name = SqlFields.FIRSTNAME) private String firstName; + @NotNull @JsonView({Views.JWTAccessToken.class, Views.REST.class}) @Column(name = SqlFields.LASTNAME) private String lastName; @@ -141,10 +144,12 @@ public class User implements PolicyOwner, NameableEntity { @NotNull @JsonView({Views.JWTAccessToken.class, Views.REST.class}) @Column(name = SqlFields.CREATEDAT) + @Temporal(value = TemporalType.TIMESTAMP) private Date createdAt; @JsonView({Views.JWTAccessToken.class, Views.REST.class}) @Column(name = SqlFields.LASTLOGIN) + @Temporal(value = TemporalType.TIMESTAMP) private Date lastLogin; @Type(type = EGO_ENUM) @@ -181,21 +186,159 @@ public class User implements PolicyOwner, NameableEntity { private Set userGroups = newHashSet(); @JsonIgnore - @ManyToMany( - fetch = FetchType.LAZY, - cascade = {CascadeType.PERSIST, CascadeType.MERGE}) - @JoinTable( - name = Tables.USER_APPLICATION, - joinColumns = {@JoinColumn(name = SqlFields.USERID_JOIN)}, - inverseJoinColumns = {@JoinColumn(name = SqlFields.APPID_JOIN)}) @Builder.Default - private Set applications = newHashSet(); + @OneToMany( + mappedBy = JavaFields.USER, + cascade = CascadeType.ALL, + fetch = FetchType.LAZY, + orphanRemoval = true) + private Set userApplications = newHashSet(); - // TODO: [rtisma] move getPermissions to UserService once DTO task is complete. JsonViews creates + // TODO: [rtisma] move getPermissions to UserService once DTO task is complete. + // JsonViews creates // a dependency for this method. For now, using a UserService static method. // Creates permissions in JWTAccessToken::context::user @JsonView(Views.JWTAccessToken.class) public List getPermissions() { return extractPermissionStrings(resolveUsersPermissions(this)); } + + /* + * =========================== + * Protobuf Conversion Methods + * =========================== + */ + + public bio.overture.ego.grpc.User toProto() { + + val builder = + bio.overture.ego.grpc.User.newBuilder() + .setId(toProtoString(this.getId())) + .setEmail(toProtoString(this.getEmail())) + .setFirstName(toProtoString(this.getFirstName())) + .setLastName(toProtoString(this.getLastName())) + .setName(toProtoString(this.getName())) + .setCreatedAt(toProtoString(this.getCreatedAt())) + .setLastLogin(toProtoString(this.getLastLogin())) + .setPreferredLanguage(toProtoString(this.getPreferredLanguage())) + .setStatus(toProtoString(this.getStatus())) + .setType(toProtoString(this.getType())); + + try { + final Set applications = + mapToImmutableSet( + this.getUserApplications(), + userApplication -> userApplication.getApplication().getId().toString()); + builder.addAllApplications(applications); + + } catch (LazyInitializationException e) { + log.error( + "Could not add applications to gRPC User Object, cannot lazy load values:", + e.getMessage()); + } + + try { + final Set groups = + mapToImmutableSet(this.getUserGroups(), group -> group.getGroup().getId().toString()); + builder.addAllGroups(groups); + + } catch (LazyInitializationException e) { + log.error( + "Could not add groups to gRPC User Object, cannot lazy load values:", e.getMessage()); + } + + try { + final Set permissions = + mapToImmutableSet( + resolveUsersPermissions(this), permission -> new Scope(permission).toString()); + builder.addAllScopes(permissions); + + } catch (LazyInitializationException e) { + log.error( + "Could not add permissions to gRPC User Object, cannot lazy load values:", + e.getMessage()); + } + + return builder.build(); + } + + public static User fromProto(bio.overture.ego.grpc.User proto) { + val user = new User(); + + if (proto.hasEmail()) { + user.setEmail(proto.getEmail().getValue()); + } + + if (proto.hasFirstName()) { + user.setFirstName(proto.getFirstName().getValue()); + } + + if (proto.hasLastName()) { + user.setLastName(proto.getLastName().getValue()); + } + + if (proto.hasName()) { + user.setName(proto.getName().getValue()); + } + + try { + if (proto.hasCreatedAt()) { + final String date = proto.getCreatedAt().getValue(); + if (!date.isEmpty()) { + user.setCreatedAt(dateFormat.parse(date)); + } + } + } catch (ParseException e) { + log.debug("Could not parse created date from protobuf: ", e.getMessage()); + } + + try { + if (proto.hasLastLogin()) { + final String date = proto.getLastLogin().getValue(); + if (!date.isEmpty()) { + user.setLastLogin(dateFormat.parse(date)); + } + } + } catch (ParseException e) { + log.debug("Could not parse last login date from protobuf: ", e.getMessage()); + } + + try { + if (proto.hasPreferredLanguage()) { + final String preferredLanguage = proto.getPreferredLanguage().getValue(); + user.setPreferredLanguage(LanguageType.valueOf(preferredLanguage)); + } + } catch (IllegalArgumentException e) { + log.debug("Could not set preferred language from protobuf: ", e.getMessage()); + } + + try { + if (proto.hasStatus()) { + + final String status = proto.getStatus().getValue(); + user.setStatus(StatusType.resolveStatusType(status)); + } + } catch (IllegalArgumentException e) { + log.debug("Could not set status from protobuf: ", e.getMessage()); + } + + try { + if (proto.hasType()) { + final String userType = proto.getType().getValue(); + user.setType(UserType.resolveUserType(userType)); + } + + } catch (IllegalArgumentException e) { + log.debug("Could not set user type from protobuf: ", e.getMessage()); + } + + return user; + } + + private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); + + @PrePersist + private void onCreate() { + this.createdAt = new Date(); + } } diff --git a/src/main/java/bio/overture/ego/model/entity/UserPermission.java b/src/main/java/bio/overture/ego/model/entity/UserPermission.java index 806b3e600..2fabd4dd7 100644 --- a/src/main/java/bio/overture/ego/model/entity/UserPermission.java +++ b/src/main/java/bio/overture/ego/model/entity/UserPermission.java @@ -1,7 +1,6 @@ package bio.overture.ego.model.entity; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.Tables; import bio.overture.ego.view.Views; @@ -30,7 +29,7 @@ @ToString(callSuper = true) @EqualsAndHashCode( callSuper = true, - of = {LombokFields.id}) + of = {"id"}) @NamedEntityGraph( name = "user-permission-entity-with-relationships", attributeNodes = { diff --git a/src/main/java/bio/overture/ego/model/enums/Fields.java b/src/main/java/bio/overture/ego/model/enums/Fields.java index ba1930c7c..492b4143c 100644 --- a/src/main/java/bio/overture/ego/model/enums/Fields.java +++ b/src/main/java/bio/overture/ego/model/enums/Fields.java @@ -24,4 +24,5 @@ public class Fields { public static final String ID = "id"; + public static final String NAME = "name"; } diff --git a/src/main/java/bio/overture/ego/model/enums/JavaFields.java b/src/main/java/bio/overture/ego/model/enums/JavaFields.java index ceb8b5222..975e3adde 100644 --- a/src/main/java/bio/overture/ego/model/enums/JavaFields.java +++ b/src/main/java/bio/overture/ego/model/enums/JavaFields.java @@ -25,6 +25,7 @@ public class JavaFields { public static final String ID = "id"; public static final String NAME = "name"; + public static final String TYPE = "type"; public static final String EMAIL = "email"; public static final String STATUS = "status"; public static final String POLICY = "policy"; @@ -60,4 +61,5 @@ public class JavaFields { public static final String USERGROUPS = "userGroups"; public static final String APPLICATION_ID = "applicationId"; public static final String GROUPAPPLICATIONS = "groupApplications"; + public static final String USERAPPLICATIONS = "userApplications"; } diff --git a/src/main/java/bio/overture/ego/model/enums/LombokFields.java b/src/main/java/bio/overture/ego/model/enums/LombokFields.java index 730200030..b00968647 100644 --- a/src/main/java/bio/overture/ego/model/enums/LombokFields.java +++ b/src/main/java/bio/overture/ego/model/enums/LombokFields.java @@ -14,7 +14,7 @@ public class LombokFields { public static final String id = "doesn't matter, lombok doesnt use this string"; public static final String groups = "doesn't matter, lombok doesnt use this string"; - public static final String applications = "doesn't matter, lombok doesnt use this string"; + public static final String userApplications = "doesn't matter, lombok doesnt use this string"; public static final String policy = "doesn't matter, lombok doesnt use this string"; public static final String userPermissions = "doesn't matter, lombok doesnt use this string"; public static final String owner = "doesn't matter, lombok doesnt use this string"; diff --git a/src/main/java/bio/overture/ego/model/join/GroupApplication.java b/src/main/java/bio/overture/ego/model/join/GroupApplication.java index 978a8fd88..0b49e4e3d 100644 --- a/src/main/java/bio/overture/ego/model/join/GroupApplication.java +++ b/src/main/java/bio/overture/ego/model/join/GroupApplication.java @@ -4,7 +4,6 @@ import bio.overture.ego.model.entity.Group; import bio.overture.ego.model.entity.Identifiable; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.Tables; import javax.persistence.CascadeType; @@ -26,10 +25,10 @@ @Entity @Table(name = Tables.GROUP_APPLICATION) @Builder -@EqualsAndHashCode(of = {LombokFields.id}) +@EqualsAndHashCode(of = "id") @NoArgsConstructor @AllArgsConstructor -@ToString(exclude = {JavaFields.GROUP, JavaFields.APPLICATION}) +@ToString(exclude = {"group", "application"}) public class GroupApplication implements Identifiable { @EmbeddedId private GroupApplicationId id; diff --git a/src/main/java/bio/overture/ego/model/join/UserApplication.java b/src/main/java/bio/overture/ego/model/join/UserApplication.java new file mode 100644 index 000000000..f6b5f6b6a --- /dev/null +++ b/src/main/java/bio/overture/ego/model/join/UserApplication.java @@ -0,0 +1,49 @@ +package bio.overture.ego.model.join; + +import bio.overture.ego.model.entity.Application; +import bio.overture.ego.model.entity.Identifiable; +import bio.overture.ego.model.entity.User; +import bio.overture.ego.model.enums.JavaFields; +import bio.overture.ego.model.enums.SqlFields; +import bio.overture.ego.model.enums.Tables; +import javax.persistence.CascadeType; +import javax.persistence.EmbeddedId; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.JoinColumn; +import javax.persistence.ManyToOne; +import javax.persistence.MapsId; +import javax.persistence.Table; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.NoArgsConstructor; +import lombok.ToString; + +@Data +@Entity +@Table(name = Tables.USER_APPLICATION) +@Builder +@EqualsAndHashCode(of = "id") +@NoArgsConstructor +@AllArgsConstructor +@ToString(exclude = {"user", "application"}) +public class UserApplication implements Identifiable { + + @EmbeddedId private UserApplicationId id; + + @MapsId(value = JavaFields.USER_ID) + @JoinColumn(name = SqlFields.USERID_JOIN, nullable = false, updatable = false) + @ManyToOne( + cascade = {CascadeType.PERSIST, CascadeType.MERGE}, + fetch = FetchType.LAZY) + private User user; + + @MapsId(value = JavaFields.APPLICATION_ID) + @JoinColumn(name = SqlFields.APPID_JOIN, nullable = false, updatable = false) + @ManyToOne( + cascade = {CascadeType.PERSIST, CascadeType.MERGE}, + fetch = FetchType.LAZY) + private Application application; +} diff --git a/src/main/java/bio/overture/ego/model/join/UserApplicationId.java b/src/main/java/bio/overture/ego/model/join/UserApplicationId.java new file mode 100644 index 000000000..22b942273 --- /dev/null +++ b/src/main/java/bio/overture/ego/model/join/UserApplicationId.java @@ -0,0 +1,25 @@ +package bio.overture.ego.model.join; + +import bio.overture.ego.model.enums.SqlFields; +import java.io.Serializable; +import java.util.UUID; +import javax.persistence.Column; +import javax.persistence.Embeddable; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@Builder +@Embeddable +@NoArgsConstructor +@AllArgsConstructor +public class UserApplicationId implements Serializable { + + @Column(name = SqlFields.USERID_JOIN) + private UUID userId; + + @Column(name = SqlFields.APPID_JOIN) + private UUID applicationId; +} diff --git a/src/main/java/bio/overture/ego/model/join/UserGroup.java b/src/main/java/bio/overture/ego/model/join/UserGroup.java index 6742a71e6..21700719b 100644 --- a/src/main/java/bio/overture/ego/model/join/UserGroup.java +++ b/src/main/java/bio/overture/ego/model/join/UserGroup.java @@ -4,7 +4,6 @@ import bio.overture.ego.model.entity.Identifiable; import bio.overture.ego.model.entity.User; import bio.overture.ego.model.enums.JavaFields; -import bio.overture.ego.model.enums.LombokFields; import bio.overture.ego.model.enums.SqlFields; import bio.overture.ego.model.enums.Tables; import javax.persistence.CascadeType; @@ -26,10 +25,10 @@ @Entity @Table(name = Tables.USER_GROUP) @Builder -@EqualsAndHashCode(of = {LombokFields.id}) +@EqualsAndHashCode(of = "id") @NoArgsConstructor @AllArgsConstructor -@ToString(exclude = {JavaFields.USER, JavaFields.GROUP}) +@ToString(exclude = {"user", "group"}) public class UserGroup implements Identifiable { @EmbeddedId private UserGroupId id; diff --git a/src/main/java/bio/overture/ego/repository/queryspecification/ApplicationSpecification.java b/src/main/java/bio/overture/ego/repository/queryspecification/ApplicationSpecification.java index a93e6956a..04e1a7852 100644 --- a/src/main/java/bio/overture/ego/repository/queryspecification/ApplicationSpecification.java +++ b/src/main/java/bio/overture/ego/repository/queryspecification/ApplicationSpecification.java @@ -24,12 +24,14 @@ import static bio.overture.ego.model.enums.JavaFields.ID; import static bio.overture.ego.model.enums.JavaFields.NAME; import static bio.overture.ego.model.enums.JavaFields.STATUS; -import static bio.overture.ego.model.enums.JavaFields.USERS; +import static bio.overture.ego.model.enums.JavaFields.USER; +import static bio.overture.ego.model.enums.JavaFields.USERAPPLICATIONS; import bio.overture.ego.model.entity.Application; import bio.overture.ego.model.entity.Group; import bio.overture.ego.model.entity.User; import bio.overture.ego.model.join.GroupApplication; +import bio.overture.ego.model.join.UserApplication; import bio.overture.ego.utils.QueryUtils; import java.util.UUID; import javax.persistence.criteria.Join; @@ -60,8 +62,9 @@ public static Specification inGroup(@NonNull UUID groupId) { public static Specification usedBy(@NonNull UUID userId) { return (root, query, builder) -> { query.distinct(true); - Join applicationUserJoin = root.join(USERS); - return builder.equal(applicationUserJoin.get(ID), userId); + Join applicationJoin = root.join(USERAPPLICATIONS); + Join userJoin = applicationJoin.join(USER); + return builder.equal(userJoin.get(ID), userId); }; } } diff --git a/src/main/java/bio/overture/ego/repository/queryspecification/UserSpecification.java b/src/main/java/bio/overture/ego/repository/queryspecification/UserSpecification.java index d9be46ae7..50da31967 100644 --- a/src/main/java/bio/overture/ego/repository/queryspecification/UserSpecification.java +++ b/src/main/java/bio/overture/ego/repository/queryspecification/UserSpecification.java @@ -16,7 +16,7 @@ package bio.overture.ego.repository.queryspecification; -import static bio.overture.ego.model.enums.JavaFields.APPLICATIONS; +import static bio.overture.ego.model.enums.JavaFields.APPLICATION; import static bio.overture.ego.model.enums.JavaFields.EMAIL; import static bio.overture.ego.model.enums.JavaFields.FIRSTNAME; import static bio.overture.ego.model.enums.JavaFields.GROUP; @@ -24,14 +24,17 @@ import static bio.overture.ego.model.enums.JavaFields.LASTNAME; import static bio.overture.ego.model.enums.JavaFields.NAME; import static bio.overture.ego.model.enums.JavaFields.STATUS; +import static bio.overture.ego.model.enums.JavaFields.USERAPPLICATIONS; import static bio.overture.ego.model.enums.JavaFields.USERGROUPS; import bio.overture.ego.model.entity.Application; import bio.overture.ego.model.entity.Group; import bio.overture.ego.model.entity.User; import bio.overture.ego.model.enums.JavaFields; +import bio.overture.ego.model.join.UserApplication; import bio.overture.ego.model.join.UserGroup; import bio.overture.ego.utils.QueryUtils; +import java.util.Collection; import java.util.UUID; import javax.persistence.criteria.Join; import lombok.NonNull; @@ -58,10 +61,21 @@ public static Specification inGroup(@NonNull UUID groupId) { }; } + public static Specification inGroups(@NonNull Collection groupIds) { + return (root, query, builder) -> { + query.distinct(true); + Join userJoin = root.join(USERGROUPS); + Join groupJoin = userJoin.join(GROUP); + + return builder.isTrue(groupJoin.get(JavaFields.ID).in(groupIds)); + }; + } + public static Specification ofApplication(@NonNull UUID appId) { return (root, query, builder) -> { query.distinct(true); - Join applicationJoin = root.join(APPLICATIONS); + Join userJoin = root.join(USERAPPLICATIONS); + Join applicationJoin = userJoin.join(APPLICATION); return builder.equal(applicationJoin.get(ID), appId); }; } diff --git a/src/main/java/bio/overture/ego/repository/queryspecification/builder/AbstractSpecificationBuilder.java b/src/main/java/bio/overture/ego/repository/queryspecification/builder/AbstractSpecificationBuilder.java index b5483b396..4f9f10d3a 100644 --- a/src/main/java/bio/overture/ego/repository/queryspecification/builder/AbstractSpecificationBuilder.java +++ b/src/main/java/bio/overture/ego/repository/queryspecification/builder/AbstractSpecificationBuilder.java @@ -2,8 +2,8 @@ import static bio.overture.ego.model.enums.JavaFields.NAME; -import bio.overture.ego.model.entity.Identifiable; import bio.overture.ego.model.enums.JavaFields; +import java.util.Collection; import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.Predicate; import javax.persistence.criteria.Root; @@ -11,7 +11,7 @@ import lombok.val; import org.springframework.data.jpa.domain.Specification; -public abstract class AbstractSpecificationBuilder, ID> { +public abstract class AbstractSpecificationBuilder { protected abstract Root setupFetchStrategy(Root root); @@ -22,6 +22,13 @@ public Specification buildByNameIgnoreCase(@NonNull String name) { }; } + public Specification listAll() { + return (fromUser, query, builder) -> { + val root = setupFetchStrategy(fromUser); + return null; + }; + } + public Specification buildById(@NonNull ID id) { return (fromUser, query, builder) -> { val root = setupFetchStrategy(fromUser); @@ -29,6 +36,17 @@ public Specification buildById(@NonNull ID id) { }; } + public Specification buildByIds(@NonNull Collection ids) { + return (fromUser, query, builder) -> { + val root = setupFetchStrategy(fromUser); + return whereInIdsPredicate(root, ids); + }; + } + + private Predicate whereInIdsPredicate(Root root, Collection ids) { + return root.get(JavaFields.ID).in(ids); + } + private Predicate equalsIdPredicate(Root root, CriteriaBuilder builder, ID id) { return builder.equal(root.get(JavaFields.ID), id); } diff --git a/src/main/java/bio/overture/ego/repository/queryspecification/builder/ApplicationSpecificationBuilder.java b/src/main/java/bio/overture/ego/repository/queryspecification/builder/ApplicationSpecificationBuilder.java index d72dafa38..2d13c384a 100644 --- a/src/main/java/bio/overture/ego/repository/queryspecification/builder/ApplicationSpecificationBuilder.java +++ b/src/main/java/bio/overture/ego/repository/queryspecification/builder/ApplicationSpecificationBuilder.java @@ -3,7 +3,8 @@ import static bio.overture.ego.model.enums.JavaFields.CLIENTID; import static bio.overture.ego.model.enums.JavaFields.GROUP; import static bio.overture.ego.model.enums.JavaFields.GROUPAPPLICATIONS; -import static bio.overture.ego.model.enums.JavaFields.USERS; +import static bio.overture.ego.model.enums.JavaFields.USER; +import static bio.overture.ego.model.enums.JavaFields.USERAPPLICATIONS; import static javax.persistence.criteria.JoinType.LEFT; import bio.overture.ego.model.entity.Application; @@ -41,11 +42,10 @@ private Predicate equalsNameIgnoreCasePredicate( @Override protected Root setupFetchStrategy(Root root) { if (fetchGroups) { - val fromGroupApplications = root.fetch(GROUPAPPLICATIONS, LEFT); - fromGroupApplications.fetch(GROUP, LEFT); + root.fetch(GROUPAPPLICATIONS, LEFT).fetch(GROUP, LEFT); } if (fetchUsers) { - root.fetch(USERS, LEFT); + root.fetch(USERAPPLICATIONS, LEFT).fetch(USER, LEFT); } return root; } diff --git a/src/main/java/bio/overture/ego/repository/queryspecification/builder/TokenSpecificationBuilder.java b/src/main/java/bio/overture/ego/repository/queryspecification/builder/TokenSpecificationBuilder.java new file mode 100644 index 000000000..2cf4fbeb9 --- /dev/null +++ b/src/main/java/bio/overture/ego/repository/queryspecification/builder/TokenSpecificationBuilder.java @@ -0,0 +1,30 @@ +package bio.overture.ego.repository.queryspecification.builder; + +import static bio.overture.ego.model.enums.JavaFields.OWNER; +import static bio.overture.ego.model.enums.JavaFields.SCOPES; +import static javax.persistence.criteria.JoinType.LEFT; + +import bio.overture.ego.model.entity.Token; +import java.util.UUID; +import javax.persistence.criteria.Root; +import lombok.Setter; +import lombok.experimental.Accessors; + +@Setter +@Accessors(fluent = true, chain = true) +public class TokenSpecificationBuilder extends AbstractSpecificationBuilder { + + private boolean fetchOwner; + private boolean fetchTokenScopes; + + @Override + protected Root setupFetchStrategy(Root root) { + if (fetchOwner) { + root.fetch(OWNER); + } + if (fetchTokenScopes) { + root.fetch(SCOPES, LEFT); + } + return root; + } +} diff --git a/src/main/java/bio/overture/ego/repository/queryspecification/builder/UserSpecificationBuilder.java b/src/main/java/bio/overture/ego/repository/queryspecification/builder/UserSpecificationBuilder.java index 85b7b7c9d..04ee7a81e 100644 --- a/src/main/java/bio/overture/ego/repository/queryspecification/builder/UserSpecificationBuilder.java +++ b/src/main/java/bio/overture/ego/repository/queryspecification/builder/UserSpecificationBuilder.java @@ -1,9 +1,6 @@ package bio.overture.ego.repository.queryspecification.builder; -import static bio.overture.ego.model.enums.JavaFields.APPLICATIONS; -import static bio.overture.ego.model.enums.JavaFields.GROUP; -import static bio.overture.ego.model.enums.JavaFields.USERGROUPS; -import static bio.overture.ego.model.enums.JavaFields.USERPERMISSIONS; +import static bio.overture.ego.model.enums.JavaFields.*; import static javax.persistence.criteria.JoinType.LEFT; import bio.overture.ego.model.entity.User; @@ -11,7 +8,6 @@ import javax.persistence.criteria.Root; import lombok.Setter; import lombok.experimental.Accessors; -import lombok.val; @Setter @Accessors(fluent = true, chain = true) @@ -24,14 +20,14 @@ public class UserSpecificationBuilder extends AbstractSpecificationBuilder setupFetchStrategy(Root root) { if (fetchApplications) { - root.fetch(APPLICATIONS, LEFT); + root.fetch(USERAPPLICATIONS, LEFT).fetch(APPLICATION, LEFT); } if (fetchUserGroups) { - val fromUserGroup = root.fetch(USERGROUPS, LEFT); - fromUserGroup.fetch(GROUP, LEFT); + root.fetch(USERGROUPS, LEFT).fetch(GROUP, LEFT); } if (fetchUserPermissions) { - root.fetch(USERPERMISSIONS, LEFT); + root.fetch(USERPERMISSIONS, LEFT).fetch(POLICY, LEFT); + root.fetch(USERGROUPS, LEFT).fetch(GROUP, LEFT).fetch(PERMISSIONS, LEFT).fetch(POLICY, LEFT); } return root; } diff --git a/src/main/java/bio/overture/ego/service/AbstractBaseService.java b/src/main/java/bio/overture/ego/service/AbstractBaseService.java index 981880ff1..d77054e4c 100644 --- a/src/main/java/bio/overture/ego/service/AbstractBaseService.java +++ b/src/main/java/bio/overture/ego/service/AbstractBaseService.java @@ -1,16 +1,24 @@ package bio.overture.ego.service; +import static bio.overture.ego.model.exceptions.NotFoundException.checkNotFound; +import static bio.overture.ego.utils.CollectionUtils.difference; +import static bio.overture.ego.utils.Converters.convertToIds; import static bio.overture.ego.utils.EntityServices.checkEntityExistence; import static bio.overture.ego.utils.EntityServices.getManyEntities; +import static bio.overture.ego.utils.Joiners.COMMA; import bio.overture.ego.model.entity.Identifiable; import bio.overture.ego.repository.BaseRepository; +import bio.overture.ego.repository.queryspecification.builder.AbstractSpecificationBuilder; +import com.google.common.collect.ImmutableSet; import java.util.Collection; +import java.util.List; import java.util.Optional; import java.util.Set; import lombok.Getter; import lombok.NonNull; import lombok.RequiredArgsConstructor; +import lombok.val; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.data.jpa.domain.Specification; @@ -49,10 +57,36 @@ public void delete(@NonNull ID id) { } @Override - public Page findAll(Specification specification, Pageable pageable) { + @SuppressWarnings("unchecked") + public Page findAll(@NonNull Specification specification, @NonNull Pageable pageable) { return getRepository().findAll(specification, pageable); } + @Override + @SuppressWarnings("unchecked") + public Page findAll( + @NonNull AbstractSpecificationBuilder specificationBuilder, + @NonNull Pageable pageable) { + return getRepository().findAll(specificationBuilder.listAll(), pageable); + } + + @Override + @SuppressWarnings("unchecked") + public List getMany( + @NonNull Collection ids, + @NonNull AbstractSpecificationBuilder specificationBuilder) { + val entities = (List) getRepository().findAll(specificationBuilder.buildByIds(ids)); + val requestedIds = ImmutableSet.copyOf(ids); + val existingIds = convertToIds(entities); + val nonExistingIds = difference(requestedIds, existingIds); + checkNotFound( + nonExistingIds.isEmpty(), + "Entities of entityType '%s' were not found for the following ids: %s", + getEntityTypeName(), + COMMA.join(nonExistingIds)); + return entities; + } + @Override public Set getMany(@NonNull Collection ids) { return getManyEntities(entityType, repository, ids); diff --git a/src/main/java/bio/overture/ego/service/AbstractPermissionService.java b/src/main/java/bio/overture/ego/service/AbstractPermissionService.java index 7bba286a5..ac558724e 100644 --- a/src/main/java/bio/overture/ego/service/AbstractPermissionService.java +++ b/src/main/java/bio/overture/ego/service/AbstractPermissionService.java @@ -297,7 +297,10 @@ private static PermissionRequest convertToPermissionRequest(AbstractPermission p */ public static Set resolveFinalPermissions( Collection... collections) { - val combinedPermissionAgg = + // Java11/Java12 couldn't understand the subtyping rules anymore when using val + Map> combinedPermissionAgg; + + combinedPermissionAgg = stream(collections) .flatMap(Collection::stream) .filter(x -> !isNull(x.getPolicy())) diff --git a/src/main/java/bio/overture/ego/service/ApplicationService.java b/src/main/java/bio/overture/ego/service/ApplicationService.java index 1161d111d..75826eca7 100644 --- a/src/main/java/bio/overture/ego/service/ApplicationService.java +++ b/src/main/java/bio/overture/ego/service/ApplicationService.java @@ -37,6 +37,7 @@ import bio.overture.ego.model.entity.Group; import bio.overture.ego.model.entity.User; import bio.overture.ego.model.join.GroupApplication; +import bio.overture.ego.model.join.UserApplication; import bio.overture.ego.model.search.SearchFilter; import bio.overture.ego.repository.ApplicationRepository; import bio.overture.ego.repository.GroupRepository; @@ -316,17 +317,19 @@ public static void disassociateAllGroupsFromApplication(@NonNull Application a) } public static void disassociateAllUsersFromApplication(@NonNull Application a) { - val users = a.getUsers(); - disassociateUsersFromApplication(a, users); + val userApplications = a.getUserApplications(); + disassociateUserApplicationsFromApplication(a, userApplications); } - public static void disassociateUsersFromApplication( - @NonNull Application application, @NonNull Collection users) { - users.forEach( - u -> { - u.getApplications().remove(application); - application.getUsers().remove(u); + public static void disassociateUserApplicationsFromApplication( + @NonNull Application application, @NonNull Collection userApplications) { + userApplications.forEach( + ua -> { + ua.getUser().getUserApplications().remove(ua); + ua.setUser(null); + ua.setApplication(null); }); + application.getUserApplications().removeAll(userApplications); } public static void disassociateGroupApplicationsFromApplication( diff --git a/src/main/java/bio/overture/ego/service/BaseService.java b/src/main/java/bio/overture/ego/service/BaseService.java index 91b68acf7..f7bbfcb1d 100644 --- a/src/main/java/bio/overture/ego/service/BaseService.java +++ b/src/main/java/bio/overture/ego/service/BaseService.java @@ -3,7 +3,9 @@ import static java.lang.String.format; import bio.overture.ego.model.exceptions.NotFoundException; +import bio.overture.ego.repository.queryspecification.builder.AbstractSpecificationBuilder; import java.util.Collection; +import java.util.List; import java.util.Optional; import java.util.Set; import lombok.NonNull; @@ -34,6 +36,10 @@ default T getById(@NonNull ID id) { Page findAll(Specification specification, Pageable pageable); + Page findAll(AbstractSpecificationBuilder specificationBuilder, Pageable pageable); + + List getMany(Collection ids, AbstractSpecificationBuilder specificationBuilder); + Set getMany(Collection ids); T getWithRelationships(ID id); diff --git a/src/main/java/bio/overture/ego/service/TokenService.java b/src/main/java/bio/overture/ego/service/TokenService.java index 4159f0c8f..4f0ef01ef 100644 --- a/src/main/java/bio/overture/ego/service/TokenService.java +++ b/src/main/java/bio/overture/ego/service/TokenService.java @@ -19,23 +19,16 @@ import static bio.overture.ego.model.dto.Scope.effectiveScopes; import static bio.overture.ego.model.dto.Scope.explicitScopes; import static bio.overture.ego.model.enums.ApplicationType.ADMIN; -import static bio.overture.ego.model.enums.JavaFields.APPLICATIONS; -import static bio.overture.ego.model.enums.JavaFields.ID; -import static bio.overture.ego.model.enums.JavaFields.SCOPES; -import static bio.overture.ego.model.enums.JavaFields.USERS; -import static bio.overture.ego.model.exceptions.NotFoundException.checkNotFound; import static bio.overture.ego.service.UserService.extractScopes; import static bio.overture.ego.utils.CollectionUtils.mapToSet; import static bio.overture.ego.utils.TypeUtils.convertToAnotherType; import static java.lang.String.format; import static java.util.UUID.fromString; -import static javax.persistence.criteria.JoinType.LEFT; import static org.springframework.util.DigestUtils.md5Digest; import bio.overture.ego.model.dto.Scope; import bio.overture.ego.model.dto.TokenResponse; import bio.overture.ego.model.dto.TokenScopeResponse; -import bio.overture.ego.model.dto.UpdateUserRequest; import bio.overture.ego.model.dto.UserScopesResponse; import bio.overture.ego.model.entity.Application; import bio.overture.ego.model.entity.Token; @@ -57,11 +50,11 @@ import io.jsonwebtoken.JwtException; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; +import java.io.IOException; import java.security.InvalidKeyException; import java.util.ArrayList; import java.util.Calendar; import java.util.Collection; -import java.util.Date; import java.util.HashSet; import java.util.List; import java.util.Map; @@ -74,7 +67,6 @@ import lombok.extern.slf4j.Slf4j; import lombok.val; import org.springframework.beans.factory.annotation.Value; -import org.springframework.data.jpa.domain.Specification; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.security.oauth2.common.exceptions.InvalidRequestException; @@ -124,31 +116,17 @@ public TokenService( @Override public Token getWithRelationships(@NonNull UUID id) { - val result = - (Optional) getRepository().findOne(fetchSpecification(id, true, true, true)); - checkNotFound(result.isPresent(), "The tokenId '%s' does not exist", id); - return result.get(); + return tokenStoreService.getWithRelationships(id); } public String generateUserToken(IDToken idToken) { - val userName = idToken.getEmail(); - val user = - userService - .findByName(userName) - .orElseGet( - () -> { - log.info("User not found, creating."); - return userService.createFromIDToken(idToken); - }); - - val u = UpdateUserRequest.builder().lastLogin(new Date()).build(); - userService.partialUpdate(user.getId(), u); + val user = userService.getUserByToken(idToken); return generateUserToken(user); } @SneakyThrows public String generateUserToken(User u) { - Set permissionNames = mapToSet(extractScopes(u), p -> p.toString()); + Set permissionNames = mapToSet(extractScopes(u), Scope::toString); return generateUserToken(u, permissionNames); } @@ -285,7 +263,7 @@ public User getTokenUserInfo(String token) { val tokenClaims = convertToAnotherType(body, UserTokenClaims.class, Views.JWTAccessToken.class); return userService.getById(fromString(tokenClaims.getSub())); - } catch (JwtException | ClassCastException e) { + } catch (JwtException | ClassCastException | IOException e) { log.error("Issue handling user token (MD5sum) {}", new String(md5Digest(token.getBytes()))); return null; } @@ -297,7 +275,7 @@ public Application getTokenAppInfo(String token) { val tokenClaims = convertToAnotherType(body, AppTokenClaims.class, Views.JWTAccessToken.class); return applicationService.getById(fromString(tokenClaims.getSub())); - } catch (JwtException | ClassCastException e) { + } catch (JwtException | ClassCastException | IOException e) { log.error( "Issue handling application token (MD5sum) {}", new String(md5Digest(token.getBytes()))); return null; @@ -469,20 +447,4 @@ private void createTokenResponse(@NonNull Token token, @NonNull List fetchSpecification( - UUID id, boolean fetchUser, boolean fetchApplications, boolean fetchTokenScopes) { - return (fromToken, query, builder) -> { - if (fetchUser) { - fromToken.fetch(USERS, LEFT); - } - if (fetchApplications) { - fromToken.fetch(APPLICATIONS, LEFT); - } - if (fetchTokenScopes) { - fromToken.fetch(SCOPES, LEFT); - } - return builder.equal(fromToken.get(ID), id); - }; - } } diff --git a/src/main/java/bio/overture/ego/service/TokenStoreService.java b/src/main/java/bio/overture/ego/service/TokenStoreService.java index 8440cbe71..7c9eb6216 100644 --- a/src/main/java/bio/overture/ego/service/TokenStoreService.java +++ b/src/main/java/bio/overture/ego/service/TokenStoreService.java @@ -17,11 +17,11 @@ package bio.overture.ego.service; import static bio.overture.ego.model.exceptions.NotFoundException.checkNotFound; -import static bio.overture.ego.service.TokenService.fetchSpecification; import bio.overture.ego.model.dto.CreateTokenRequest; import bio.overture.ego.model.entity.Token; import bio.overture.ego.repository.TokenStoreRepository; +import bio.overture.ego.repository.queryspecification.builder.TokenSpecificationBuilder; import java.util.Optional; import java.util.UUID; import lombok.NonNull; @@ -48,8 +48,19 @@ public TokenStoreService(@NonNull TokenStoreRepository repository) { @Override public Token getWithRelationships(@NonNull UUID id) { + return get(id, true, true); + } + + @SuppressWarnings("unchecked") + public Token get(@NonNull UUID id, boolean fetchOwner, boolean fetchTokenScopes) { val result = - (Optional) getRepository().findOne(fetchSpecification(id, true, true, true)); + (Optional) + getRepository() + .findOne( + new TokenSpecificationBuilder() + .fetchOwner(fetchOwner) + .fetchTokenScopes(fetchTokenScopes) + .buildById(id)); checkNotFound(result.isPresent(), "The tokenId '%s' does not exist", id); return result.get(); } diff --git a/src/main/java/bio/overture/ego/service/UserService.java b/src/main/java/bio/overture/ego/service/UserService.java index b53f56603..048386f6e 100644 --- a/src/main/java/bio/overture/ego/service/UserService.java +++ b/src/main/java/bio/overture/ego/service/UserService.java @@ -17,22 +17,20 @@ package bio.overture.ego.service; import static bio.overture.ego.model.enums.UserType.ADMIN; +import static bio.overture.ego.model.exceptions.NotFoundException.buildNotFoundException; import static bio.overture.ego.model.exceptions.NotFoundException.checkNotFound; import static bio.overture.ego.model.exceptions.RequestValidationException.checkRequestValid; import static bio.overture.ego.model.exceptions.UniqueViolationException.checkUnique; import static bio.overture.ego.service.AbstractPermissionService.resolveFinalPermissions; -import static bio.overture.ego.utils.CollectionUtils.mapToSet; +import static bio.overture.ego.utils.CollectionUtils.*; import static bio.overture.ego.utils.Collectors.toImmutableSet; -import static bio.overture.ego.utils.Converters.convertToUserGroup; +import static bio.overture.ego.utils.Converters.*; import static bio.overture.ego.utils.EntityServices.checkEntityExistence; +import static bio.overture.ego.utils.EntityServices.getManyEntities; import static bio.overture.ego.utils.FieldUtils.onUpdateDetected; -import static bio.overture.ego.utils.Joiners.COMMA; -import static java.lang.String.format; -import static java.util.Collections.reverse; -import static java.util.Comparator.comparing; +import static bio.overture.ego.utils.Ids.checkDuplicates; +import static bio.overture.ego.utils.Joiners.PRETTY_COMMA; import static java.util.Objects.isNull; -import static java.util.stream.Collectors.groupingBy; -import static java.util.stream.Stream.concat; import static org.springframework.data.jpa.domain.Specification.where; import bio.overture.ego.config.UserDefaultsConfig; @@ -40,13 +38,8 @@ import bio.overture.ego.model.dto.CreateUserRequest; import bio.overture.ego.model.dto.Scope; import bio.overture.ego.model.dto.UpdateUserRequest; -import bio.overture.ego.model.entity.AbstractPermission; -import bio.overture.ego.model.entity.Application; -import bio.overture.ego.model.entity.Group; -import bio.overture.ego.model.entity.GroupPermission; -import bio.overture.ego.model.entity.User; -import bio.overture.ego.model.entity.UserPermission; -import bio.overture.ego.model.exceptions.NotFoundException; +import bio.overture.ego.model.entity.*; +import bio.overture.ego.model.join.UserApplication; import bio.overture.ego.model.join.UserGroup; import bio.overture.ego.model.search.SearchFilter; import bio.overture.ego.repository.GroupRepository; @@ -56,23 +49,12 @@ import bio.overture.ego.token.IDToken; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; -import java.util.Collection; -import java.util.Date; -import java.util.HashSet; -import java.util.List; -import java.util.Optional; -import java.util.Set; -import java.util.UUID; +import java.util.*; import javax.transaction.Transactional; import lombok.NonNull; import lombok.extern.slf4j.Slf4j; import lombok.val; -import org.mapstruct.AfterMapping; -import org.mapstruct.Mapper; -import org.mapstruct.MappingTarget; -import org.mapstruct.NullValueCheckStrategy; -import org.mapstruct.ReportingPolicy; -import org.mapstruct.TargetType; +import org.mapstruct.*; import org.mapstruct.factory.Mappers; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.domain.Page; @@ -112,15 +94,6 @@ public UserService( this.tokenEventsPublisher = tokenEventsPublisher; } - @Override - public void delete(@NonNull UUID id) { - val user = getWithRelationships(id); - disassociateAllGroupsFromUser(user); - disassociateAllApplicationsFromUser(user); - tokenEventsPublisher.requestTokenCleanupByUsers(ImmutableSet.of(user)); - super.delete(id); - } - public User create(@NonNull CreateUserRequest request) { validateCreateRequest(request); val user = USER_CONVERTER.convertToUser(request); @@ -159,6 +132,19 @@ public User get( return result.get(); } + public Collection getMany( + @NonNull Collection ids, + boolean fetchUserPermissions, + boolean fetchUserGroups, + boolean fetchApplications) { + val spec = + new UserSpecificationBuilder() + .fetchUserPermissions(fetchUserPermissions) + .fetchUserGroups(fetchUserGroups) + .fetchApplications(fetchApplications); + return getMany(ids, spec); + } + public User createFromIDToken(IDToken idToken) { return create( CreateUserRequest.builder() @@ -170,14 +156,17 @@ public User createFromIDToken(IDToken idToken) { .build()); } - public User addUserToApps(@NonNull UUID id, @NonNull List appIds) { - val user = getById(id); - val apps = applicationService.getMany(appIds); - associateUserWithApplications(user, apps); - // TODO: @rtisma test setting apps even if there were existing apps before does not delete the - // existing ones. Becuase the PERSIST and MERGE cascade applicationType is used, this should - // work correctly - return getRepository().save(user); + public User getUserByToken(@NonNull IDToken idToken) { + val userName = idToken.getEmail(); + val user = + findByName(userName) + .orElseGet( + () -> { + log.info("User not found, creating."); + return createFromIDToken(idToken); + }); + user.setLastLogin(new Date()); + return user; } @Override @@ -185,6 +174,14 @@ public User getWithRelationships(@NonNull UUID id) { return get(id, true, true, true); } + public User getWithApplications(@NonNull UUID id) { + return get(id, false, false, true); + } + + public User getWithGroups(@NonNull UUID id) { + return get(id, false, true, false); + } + /** * Partially updates a user using only non-null {@code UpdateUserRequest} {@param r} object * @@ -198,9 +195,9 @@ public User partialUpdate(@NonNull UUID id, @NonNull UpdateUserRequest r) { return getRepository().save(user); } - @SuppressWarnings("unchecked") public Page listUsers(@NonNull List filters, @NonNull Pageable pageable) { - return getRepository().findAll(UserSpecification.filterBy(filters), pageable); + val spec = UserSpecification.filterBy(filters); + return getRepository().findAll(spec, pageable); } @SuppressWarnings("unchecked") @@ -212,37 +209,148 @@ public Page findUsers( pageable); } + @SuppressWarnings("Duplicates") + public User associateApplicationsWithUser( + @NonNull UUID id, @NonNull Collection applicationIds) { + // check duplicate applicationIds + checkDuplicates(Application.class, applicationIds); + + // Get existing associated application ids with the user + val userWithUserApplications = getWithApplications(id); + val applications = + mapToImmutableSet( + userWithUserApplications.getUserApplications(), UserApplication::getApplication); + val existingAssociatedApplicationIds = convertToIds(applications); + + // Check there are no application ids that are already associated with the user + val existingAlreadyAssociatedApplicationIds = + intersection(existingAssociatedApplicationIds, applicationIds); + checkUnique( + existingAlreadyAssociatedApplicationIds.isEmpty(), + "The following %s ids are already associated with %s '%s': [%s]", + Application.class.getSimpleName(), + getEntityTypeName(), + id, + PRETTY_COMMA.join(existingAlreadyAssociatedApplicationIds)); + + // Get all unassociated application ids. If they do not exist, an error is thrown + val nonAssociatedApplicationIds = difference(applicationIds, existingAssociatedApplicationIds); + val nonAssociatedApplications = applicationService.getMany(nonAssociatedApplicationIds); + + // Associate the existing applications with the user + nonAssociatedApplications.stream() + .map(a -> convertToUserApplication(userWithUserApplications, a)) + .forEach(UserService::associateSelf); + return userWithUserApplications; + } + + @SuppressWarnings("Duplicates") + public User associateGroupsWithUser(@NonNull UUID id, @NonNull Collection groupIds) { + // check duplicate groupIds + checkDuplicates(Group.class, groupIds); + + // Get existing associated group ids with the user + val userWithUserGroups = getWithGroups(id); + val groups = mapToImmutableSet(userWithUserGroups.getUserGroups(), UserGroup::getGroup); + val existingAssociatedGroupIds = convertToIds(groups); + + // Check there are no group ids that are already associated with the user + val existingAlreadyAssociatedGroupIds = intersection(existingAssociatedGroupIds, groupIds); + checkUnique( + existingAlreadyAssociatedGroupIds.isEmpty(), + "The following %s ids are already associated with %s '%s': [%s]", + Group.class.getSimpleName(), + getEntityTypeName(), + id, + PRETTY_COMMA.join(existingAlreadyAssociatedGroupIds)); + + // Get all unassociated group ids. If they do not exist, an error is thrown + val nonAssociatedGroupIds = difference(groupIds, existingAssociatedGroupIds); + val nonAssociatedGroups = getManyEntities(Group.class, groupRepository, nonAssociatedGroupIds); + + // Associate the existing groups with the user + nonAssociatedGroups.stream() + .map(g -> convertToUserGroup(userWithUserGroups, g)) + .forEach(UserGroupService::associateSelf); + tokenEventsPublisher.requestTokenCleanupByUsers(ImmutableSet.of(userWithUserGroups)); + return userWithUserGroups; + } + + @SuppressWarnings("Duplicates") + public void disassociateApplicationsFromUser( + @NonNull UUID id, @NonNull Collection applicationIds) { + // check duplicate applicationIds + checkDuplicates(Application.class, applicationIds); + + // Get existing associated child ids with the parent + val userWithApplications = getWithApplications(id); + val applications = + mapToImmutableSet( + userWithApplications.getUserApplications(), UserApplication::getApplication); + val existingAssociatedApplicationIds = convertToIds(applications); + + // Get existing and non-existing non-associated application ids. Error out if there are existing + // and non-existing non-associated application ids + val nonAssociatedApplicationIds = difference(applicationIds, existingAssociatedApplicationIds); + if (!nonAssociatedApplicationIds.isEmpty()) { + applicationService.checkExistence(nonAssociatedApplicationIds); + throw buildNotFoundException( + "The following existing %s ids cannot be disassociated from %s '%s' " + + "because they are not associated with it", + Application.class.getSimpleName(), getEntityTypeName(), id); + } + + // Since all application ids exist and are associated with the user, disassociate them from + // each other + val applicationIdsToDisassociate = ImmutableSet.copyOf(applicationIds); + val userApplicationsToDisassociate = + userWithApplications.getUserApplications().stream() + .filter(ga -> applicationIdsToDisassociate.contains(ga.getId().getApplicationId())) + .collect(toImmutableSet()); + + disassociateUserApplicationsFromUser(userWithApplications, userApplicationsToDisassociate); + } + + @SuppressWarnings("Duplicates") public void disassociateGroupsFromUser(@NonNull UUID id, @NonNull Collection groupIds) { - val userWithRelationships = get(id, false, true, false); + // check duplicate groupIds + checkDuplicates(Group.class, groupIds); + + // Get existing associated child ids with the parent + val userWithGroups = getWithGroups(id); + val groups = mapToImmutableSet(userWithGroups.getUserGroups(), UserGroup::getGroup); + val existingAssociatedGroupIds = convertToIds(groups); + + // Get existing and non-existing non-associated group ids. Error out if there are existing + // and non-existing non-associated group ids + val nonAssociatedGroupIds = difference(groupIds, existingAssociatedGroupIds); + if (!nonAssociatedGroupIds.isEmpty()) { + checkEntityExistence(Group.class, groupRepository, nonAssociatedGroupIds); + throw buildNotFoundException( + "The following existing %s ids cannot be disassociated from %s '%s' " + + "because they are not associated with it", + Group.class.getSimpleName(), getEntityTypeName(), id); + } + + // Since all group ids exist and are associated with the user, disassociate them from + // each other + val groupIdsToDisassociate = ImmutableSet.copyOf(groupIds); val userGroupsToDisassociate = - userWithRelationships.getUserGroups().stream() - .filter(x -> groupIds.contains(x.getId().getGroupId())) + userWithGroups.getUserGroups().stream() + .filter(ga -> groupIdsToDisassociate.contains(ga.getId().getGroupId())) .collect(toImmutableSet()); - disassociateUserGroupsFromUser(userWithRelationships, userGroupsToDisassociate); - tokenEventsPublisher.requestTokenCleanupByUsers(ImmutableSet.of(userWithRelationships)); - } - public User associateGroupsWithUser(@NonNull UUID id, @NonNull Collection groupIds) { - val user = getWithRelationships(id); - val groups = groupRepository.findAllByIdIn(groupIds); - groups.stream().map(g -> convertToUserGroup(user, g)).forEach(UserGroupService::associateSelf); - tokenEventsPublisher.requestTokenCleanupByUsers(ImmutableSet.of(user)); - return user; + disassociateUserGroupsFromUser(userWithGroups, userGroupsToDisassociate); + tokenEventsPublisher.requestTokenCleanupByUsers(ImmutableSet.of(userWithGroups)); } - // TODO @rtisma: add test for all entities to ensure they implement .equals() using only the id - // field - // TODO @rtisma: add test for checking user exists - // TODO @rtisma: add test for checking application exists for a user - public void deleteUserFromApps(@NonNull UUID id, @NonNull Collection appIds) { + @Override + public void delete(@NonNull UUID id) { val user = getWithRelationships(id); - checkApplicationsExistForUser(user, appIds); - val appsToDisassociate = - user.getApplications().stream() - .filter(a -> appIds.contains(a.getId())) - .collect(toImmutableSet()); - disassociateUserFromApplications(user, appsToDisassociate); - getRepository().save(user); + disassociateAllGroupsFromUser(user); + disassociateAllApplicationsFromUser(user); + tokenEventsPublisher.requestTokenCleanupByUsers(ImmutableSet.of(user)); + super.delete(id); } @SuppressWarnings("unchecked") @@ -261,11 +369,29 @@ public Page findUsersForGroup( @NonNull List filters, @NonNull Pageable pageable) { checkEntityExistence(Group.class, groupRepository, groupId); - return userRepository.findAll( + + val spec = where(UserSpecification.inGroup(groupId)) .and(UserSpecification.containsText(query)) - .and(UserSpecification.filterBy(filters)), - pageable); + .and(UserSpecification.filterBy(filters)); + + return userRepository.findAll(where(spec), pageable); + } + + @SuppressWarnings("unchecked") + public Page findUsersForGroups( + @NonNull Collection groupIds, + @NonNull String query, + @NonNull List filters, + @NonNull Pageable pageable) { + checkEntityExistence(Group.class, groupRepository, groupIds); + + val spec = + where(UserSpecification.inGroups(groupIds)) + .and(UserSpecification.containsText(query)) + .and(UserSpecification.filterBy(filters)); + + return userRepository.findAll(spec, pageable); } @SuppressWarnings("unchecked") @@ -325,69 +451,29 @@ public static Set resolveUsersPermissions(User user) { return resolveFinalPermissions(userPermissions, groupPermissions); } - // TODO: [rtisma] this is the old implementation. Ensure there is a test for this, and if there - // isnt, - // create one, and ensure the Old and new refactored method are correct - @Deprecated - public static Set getPermissionsListOld(User user) { - // Get user's individual permission (stream) - val userPermissions = - Optional.ofNullable(user.getUserPermissions()).orElse(new HashSet<>()).stream(); - - // Get permissions from the user's groups (stream) - val userGroupsPermissions = - Optional.ofNullable(user.getUserGroups()).orElse(new HashSet<>()).stream() - .map(UserGroup::getGroup) - .map(Group::getPermissions) - .flatMap(Collection::stream); - - // Combine individual user permissions and the user's - // groups (if they have any) permissions - val combinedPermissions = - concat(userPermissions, userGroupsPermissions) - .collect(groupingBy(AbstractPermission::getPolicy)); - // If we have no permissions at all return an empty list - if (combinedPermissions.values().size() == 0) { - return new HashSet<>(); - } - - // If we do have permissions ... sort the grouped permissions (by PolicyIdStringWithMaskName) - // on PolicyMask, extracting the first value of the sorted list into the final - // permissions list - HashSet finalPermissionsList = new HashSet<>(); - - combinedPermissions.forEach( - (entity, permissions) -> { - permissions.sort(comparing(AbstractPermission::getAccessLevel)); - reverse(permissions); - finalPermissionsList.add(permissions.get(0)); - }); - return finalPermissionsList; - } - public static Set extractScopes(@NonNull User user) { return mapToSet(resolveUsersPermissions(user), AbstractPermissionService::buildScope); } - public static void disassociateUserFromApplications( - @NonNull User user, @NonNull Collection applications) { - user.getApplications().removeAll(applications); - applications.forEach(x -> x.getUsers().remove(user)); - } - - public static void associateUserWithApplications( - @NonNull User user, @NonNull Collection apps) { - apps.forEach(a -> associateUserWithApplication(user, a)); + public static void disassociateUserApplicationsFromUser( + @NonNull User g, @NonNull Collection userApplications) { + userApplications.forEach( + ua -> { + ua.getApplication().getUserApplications().remove(ua); + ua.setApplication(null); + ua.setUser(null); + }); + g.getUserApplications().removeAll(userApplications); } - public static void associateUserWithApplication(@NonNull User user, @NonNull Application app) { - user.getApplications().add(app); - app.getUsers().add(user); + public static void disassociateAllApplicationsFromUser(@NonNull User u) { + val userApplications = u.getUserApplications(); + disassociateUserApplicationsFromUser(u, userApplications); } - public static void disassociateAllApplicationsFromUser(@NonNull User user) { - user.getApplications().forEach(x -> x.getUsers().remove(user)); - user.getApplications().clear(); + private static void associateSelf(@NonNull UserApplication ua) { + ua.getUser().getUserApplications().add(ua); + ua.getApplication().getUserApplications().add(ua); } public static void disassociateAllGroupsFromUser(@NonNull User userWithRelationships) { @@ -405,20 +491,6 @@ public static void disassociateUserGroupsFromUser( user.getUserGroups().removeAll(userGroups); } - public static void checkApplicationsExistForUser( - @NonNull User user, @NonNull Collection appIds) { - val existingAppIds = - user.getApplications().stream().map(Application::getId).collect(toImmutableSet()); - val nonExistentAppIds = - appIds.stream().filter(x -> !existingAppIds.contains(x)).collect(toImmutableSet()); - if (!nonExistentAppIds.isEmpty()) { - throw new NotFoundException( - format( - "The following applications do not exist for user '%s': %s", - user.getId(), COMMA.join(nonExistentAppIds))); - } - } - @Mapper( nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS, unmappedTargetPolicy = ReportingPolicy.WARN) diff --git a/src/main/java/bio/overture/ego/token/signer/DefaultTokenSigner.java b/src/main/java/bio/overture/ego/token/signer/DefaultTokenSigner.java index 3f9dc5e89..478d5cd7c 100644 --- a/src/main/java/bio/overture/ego/token/signer/DefaultTokenSigner.java +++ b/src/main/java/bio/overture/ego/token/signer/DefaultTokenSigner.java @@ -86,7 +86,7 @@ public Optional getEncodedPublicKey() { if (publicKey != null) { val b64 = Base64.getEncoder(); String encodedKey = b64.encodeToString(publicKey.getEncoded()); - encodedKey = "-----BEGIN PUBLIC KEY-----\r\n" + encodedKey + "-----END PUBLIC KEY-----"; + encodedKey = "-----BEGIN PUBLIC KEY-----\r\n" + encodedKey + "\r\n-----END PUBLIC KEY-----"; return Optional.of(encodedKey); } else { return Optional.empty(); diff --git a/src/main/java/bio/overture/ego/token/signer/JKSTokenSigner.java b/src/main/java/bio/overture/ego/token/signer/JKSTokenSigner.java index 34cd6604f..395ba4b1a 100644 --- a/src/main/java/bio/overture/ego/token/signer/JKSTokenSigner.java +++ b/src/main/java/bio/overture/ego/token/signer/JKSTokenSigner.java @@ -101,7 +101,7 @@ public Optional getEncodedPublicKey() { if (publicKey.isPresent()) { val b64 = Base64.getEncoder(); String encodedKey = b64.encodeToString(publicKey.get().getEncoded()); - encodedKey = "-----BEGIN PUBLIC KEY-----\r\n" + encodedKey + "-----END PUBLIC KEY-----"; + encodedKey = "-----BEGIN PUBLIC KEY-----\r\n" + encodedKey + "\r\n-----END PUBLIC KEY-----"; return Optional.of(encodedKey); } else { return Optional.empty(); diff --git a/src/main/java/bio/overture/ego/token/user/UserTokenClaims.java b/src/main/java/bio/overture/ego/token/user/UserTokenClaims.java index 388aaf2dd..4ea8e8d98 100644 --- a/src/main/java/bio/overture/ego/token/user/UserTokenClaims.java +++ b/src/main/java/bio/overture/ego/token/user/UserTokenClaims.java @@ -17,6 +17,7 @@ package bio.overture.ego.token.user; import bio.overture.ego.model.entity.Application; +import bio.overture.ego.model.join.UserApplication; import bio.overture.ego.token.TokenClaims; import bio.overture.ego.view.Views; import com.fasterxml.jackson.annotation.JsonView; @@ -48,7 +49,8 @@ public Set getScope() { } public List getAud() { - return this.context.getUserInfo().getApplications().stream() + return this.context.getUserInfo().getUserApplications().stream() + .map(UserApplication::getApplication) .map(Application::getName) .collect(Collectors.toList()); } diff --git a/src/main/java/bio/overture/ego/utils/Converters.java b/src/main/java/bio/overture/ego/utils/Converters.java index 3a8e57c41..9b26b53e2 100644 --- a/src/main/java/bio/overture/ego/utils/Converters.java +++ b/src/main/java/bio/overture/ego/utils/Converters.java @@ -13,6 +13,8 @@ import bio.overture.ego.model.entity.User; import bio.overture.ego.model.join.GroupApplication; import bio.overture.ego.model.join.GroupApplicationId; +import bio.overture.ego.model.join.UserApplication; +import bio.overture.ego.model.join.UserApplicationId; import bio.overture.ego.model.join.UserGroup; import bio.overture.ego.model.join.UserGroupId; import java.util.Collection; @@ -73,6 +75,11 @@ public static void nonNullAcceptor(V nullableValue, @NonNull Consumer con } } + public static UserApplication convertToUserApplication(@NonNull User u, @NonNull Application a) { + val id = UserApplicationId.builder().applicationId(a.getId()).userId(u.getId()).build(); + return UserApplication.builder().id(id).user(u).application(a).build(); + } + public static UserGroup convertToUserGroup(@NonNull User u, @NonNull Group g) { val id = UserGroupId.builder().groupId(g.getId()).userId(u.getId()).build(); return UserGroup.builder().id(id).user(u).group(g).build(); diff --git a/src/main/java/bio/overture/ego/utils/QueryUtils.java b/src/main/java/bio/overture/ego/utils/QueryUtils.java index bec6e136d..4e800c914 100644 --- a/src/main/java/bio/overture/ego/utils/QueryUtils.java +++ b/src/main/java/bio/overture/ego/utils/QueryUtils.java @@ -25,7 +25,7 @@ public class QueryUtils { public static String prepareForQuery(String text) { String output = text; if (StringUtils.isEmpty(output)) { - return ""; + return "%"; } if (!output.contains("%")) { output = "%" + output + "%"; diff --git a/src/main/java/bio/overture/ego/utils/TypeUtils.java b/src/main/java/bio/overture/ego/utils/TypeUtils.java index 6122ae32a..1be7a6f79 100644 --- a/src/main/java/bio/overture/ego/utils/TypeUtils.java +++ b/src/main/java/bio/overture/ego/utils/TypeUtils.java @@ -19,13 +19,12 @@ import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.MapperFeature; import com.fasterxml.jackson.databind.ObjectMapper; -import lombok.SneakyThrows; +import java.io.IOException; import lombok.val; public class TypeUtils { - @SneakyThrows public static T convertToAnotherType( - Object fromObject, Class tClass, Class serializationView) { + Object fromObject, Class tClass, Class serializationView) throws IOException { val mapper = new ObjectMapper(); mapper.configure(JsonGenerator.Feature.IGNORE_UNKNOWN, true); mapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, false); diff --git a/src/main/proto/Ego.proto b/src/main/proto/Ego.proto new file mode 100644 index 000000000..1ea73eb99 --- /dev/null +++ b/src/main/proto/Ego.proto @@ -0,0 +1,59 @@ +syntax = "proto3"; +import "google/protobuf/wrappers.proto"; + +option java_multiple_files = true; +option java_package = "bio.overture.ego.grpc"; +option java_outer_classname = "EgoProto"; + +package bio.overture.ego.grpc; + +service UserService { + rpc GetUser (GetUserRequest) returns (User) {} + rpc ListUsers (ListUsersRequest) returns (ListUsersResponse) {} +} + +message PagedRequest { + uint32 page_number = 1; + uint32 page_size = 2; + string order_by = 3; +} + +message PagedResponse { + uint32 max_results = 1; + google.protobuf.UInt32Value next_page = 2; +} + +message GetUserRequest { + string id = 1; +} + +message ListUsersRequest { + PagedRequest page = 1; + + google.protobuf.StringValue query = 2; + repeated string group_ids = 3; +} + +message ListUsersResponse { + PagedResponse page = 1; + + repeated User users = 2; +} + +message User { + google.protobuf.StringValue id = 1; + google.protobuf.StringValue email = 2; + google.protobuf.StringValue first_name = 3; + google.protobuf.StringValue last_name = 4; + + google.protobuf.StringValue created_at = 5; + google.protobuf.StringValue last_login = 6; + google.protobuf.StringValue name = 7; + google.protobuf.StringValue preferred_language = 8; + google.protobuf.StringValue status = 9; + google.protobuf.StringValue type = 10; + + repeated string applications = 11; + repeated string groups = 12; + repeated string scopes = 13; +} diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml index a778e890b..af2158689 100644 --- a/src/main/resources/application.yml +++ b/src/main/resources/application.yml @@ -1,5 +1,5 @@ server: - port: 8088 + port: 8081 jwt: secret: testsecretisalsoasecret @@ -18,7 +18,7 @@ spring.main.allow-bean-definition-overriding: true # Datasource spring.datasource: driver-class-name: org.postgresql.Driver - url: jdbc:postgresql://localhost:8432/ego?stringtype=unspecified + url: jdbc:postgresql://localhost:5432/ego?stringtype=unspecified username: postgres password: password @@ -31,7 +31,7 @@ spring: enabled: false jackson: deserialization: - FAIL_ON_UNKNOWN_PROPERTIES: true + FAIL_ON_UNKNOWN_PROPERTIES: false FAIL_ON_NULL_FOR_PRIMITIVES: true FAIL_ON_NUMBERS_FOR_ENUMS: true FAIL_ON_READING_DUP_TREE_KEY: true @@ -76,6 +76,7 @@ google: clientAuthenticationScheme: form scope: - email + - profile resource: userInfoUri: https://www.googleapis.com/oauth2/v3/userinfo @@ -165,6 +166,16 @@ logging: loggers: "org.skife.jdbi.v2": TRACE +--- +############################################################################### +# Profile - "demo" +############################################################################### +spring: + profiles: grpc + +grpc: + port: 50051 + --- ############################################################################### # Profile - "demo" diff --git a/src/main/resources/dummy-data/01-insert-dummy-users.sql b/src/main/resources/dummy-data/01-insert-dummy-users.sql index b18d99832..7384f38c6 100644 --- a/src/main/resources/dummy-data/01-insert-dummy-users.sql +++ b/src/main/resources/dummy-data/01-insert-dummy-users.sql @@ -4,206 +4,206 @@ Clears the EgoUser table and insert 200 randomly generated users. */ TRUNCATE public.egouser CASCADE; ---Status Approved (160) -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Orin.Mraz@example.com', 'Orin.Mraz@example.com', 'USER', 'Orin', 'Mraz', '2017-01-15 04:35:55', '2016-12-15 23:20:51', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vella.Mayer@example.com', 'Vella.Mayer@example.com', 'USER', 'Vella', 'Mayer', '2017-04-05 05:05:50', '2017-06-16 02:44:19', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Samir.Emmerich@example.com', 'Samir.Emmerich@example.com', 'USER', 'Samir', 'Emmerich', '2017-02-03 16:28:31', '2017-05-14 11:47:11', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Humberto.Ledner@example.com', 'Humberto.Ledner@example.com', 'USER', 'Humberto', 'Ledner', '2017-01-30 12:29:31', '2017-09-16 17:53:13', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zechariah.Marvin@example.com', 'Zechariah.Marvin@example.com', 'USER', 'Zechariah', 'Marvin', '2017-08-03 17:05:50', '2017-08-23 19:32:43', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kirk.Klocko@example.com', 'Kirk.Klocko@example.com', 'USER', 'Kirk', 'Klocko', '2017-08-28 08:05:28', '2017-08-07 12:48:23', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Micheal.Swift@example.com', 'Micheal.Swift@example.com', 'USER', 'Micheal', 'Swift', '2017-09-05 20:15:22', '2017-06-04 10:58:23', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gunnar.Conroy@example.com', 'Gunnar.Conroy@example.com', 'USER', 'Gunnar', 'Conroy', '2017-03-03 18:23:20', '2017-06-08 09:18:53', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vidal.Tromp@example.com', 'Vidal.Tromp@example.com', 'USER', 'Vidal', 'Tromp', '2017-09-16 19:16:20', '2017-06-12 17:35:58', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('London.Wehner@example.com', 'London.Wehner@example.com', 'USER', 'London', 'Wehner', '2017-05-31 12:41:18', '2017-05-10 07:36:52', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Estevan.Ziemann@example.com', 'Estevan.Ziemann@example.com', 'USER', 'Estevan', 'Ziemann', '2017-02-11 17:36:28', '2017-05-16 20:09:47', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Drake.Heathcote@example.com', 'Drake.Heathcote@example.com', 'USER', 'Drake', 'Heathcote', '2017-02-20 09:53:56', '2017-10-21 16:49:42', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cecilia.Rohan@example.com', 'Cecilia.Rohan@example.com', 'USER', 'Cecilia', 'Rohan', '2017-09-26 10:45:50', '2017-02-01 21:17:46', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jeromy.Abernathy@example.com', 'Jeromy.Abernathy@example.com', 'USER', 'Jeromy', 'Abernathy', '2017-03-30 17:46:19', '2016-12-24 14:11:40', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zula.Mayer@example.com', 'Zula.Mayer@example.com', 'USER', 'Zula', 'Mayer', '2017-01-16 15:49:06', '2017-09-12 08:28:08', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dan.Jacobi@example.com', 'Dan.Jacobi@example.com', 'USER', 'Dan', 'Jacobi', '2017-09-25 01:52:57', '2017-05-06 13:49:18', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dave.Green@example.com', 'Dave.Green@example.com', 'USER', 'Dave', 'Green', '2017-09-08 08:16:35', '2017-10-10 18:14:19', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Niko.Kovacek@example.com', 'Niko.Kovacek@example.com', 'USER', 'Niko', 'Kovacek', '2017-09-07 12:08:55', '2017-08-14 05:26:38', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cyrus.Stark@example.com', 'Cyrus.Stark@example.com', 'USER', 'Cyrus', 'Stark', '2017-02-18 08:24:35', '2017-06-12 00:42:46', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dorcas.Pfeffer@example.com', 'Dorcas.Pfeffer@example.com', 'USER', 'Dorcas', 'Pfeffer', '2017-05-25 19:25:53', '2017-01-10 07:17:08', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Myra.Cormier@example.com', 'Myra.Cormier@example.com', 'USER', 'Myra', 'Cormier', '2017-05-21 04:58:38', '2017-03-20 00:40:33', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Morris.Harris@example.com', 'Morris.Harris@example.com', 'USER', 'Morris', 'Harris', '2017-08-28 09:49:03', '2017-07-07 12:15:07', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Janiya.Lakin@example.com', 'Janiya.Lakin@example.com', 'USER', 'Janiya', 'Lakin', '2017-09-16 08:03:53', '2017-07-12 10:17:36', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Rae.Kreiger@example.com', 'Rae.Kreiger@example.com', 'USER', 'Rae', 'Kreiger', '2017-06-07 20:34:25', '2017-10-30 01:14:25', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vincent.Abbott@example.com', 'Vincent.Abbott@example.com', 'USER', 'Vincent', 'Abbott', '2017-05-05 03:16:31', '2017-07-21 15:40:42', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Elisha.Weimann@example.com', 'Elisha.Weimann@example.com', 'USER', 'Elisha', 'Weimann', '2016-11-01 06:26:13', '2017-06-10 03:32:52', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Marquis.Oberbrunner@example.com', 'Marquis.Oberbrunner@example.com', 'USER', 'Marquis', 'Oberbrunner', '2017-09-11 18:38:28', '2016-12-28 04:59:25', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ludwig.Murazik@example.com', 'Ludwig.Murazik@example.com', 'USER', 'Ludwig', 'Murazik', '2016-12-02 22:00:44', '2017-06-19 11:40:03', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Orlo.Mayer@example.com', 'Orlo.Mayer@example.com', 'USER', 'Orlo', 'Mayer', '2017-02-02 19:56:55', '2017-01-07 20:04:22', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Heber.Hoppe@example.com', 'Heber.Hoppe@example.com', 'USER', 'Heber', 'Hoppe', '2016-12-05 22:22:00', '2017-09-12 22:00:48', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Furman.Volkman@example.com', 'Furman.Volkman@example.com', 'USER', 'Furman', 'Volkman', '2017-04-08 13:47:45', '2016-12-23 18:16:05', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Carlotta.Herman@example.com', 'Carlotta.Herman@example.com', 'USER', 'Carlotta', 'Herman', '2017-05-24 14:57:22', '2017-08-17 11:00:20', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Idella.Lockman@example.com', 'Idella.Lockman@example.com', 'USER', 'Idella', 'Lockman', '2017-05-05 09:35:45', '2017-06-20 03:54:33', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jarrod.Reilly@example.com', 'Jarrod.Reilly@example.com', 'USER', 'Jarrod', 'Reilly', '2017-09-30 12:12:22', '2017-05-26 03:28:20', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Claudine.McKenzie@example.com', 'Claudine.McKenzie@example.com', 'USER', 'Claudine', 'McKenzie', '2017-10-21 02:30:25', '2016-12-20 02:02:00', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Daniella.Goyette@example.com', 'Daniella.Goyette@example.com', 'USER', 'Daniella', 'Goyette', '2016-12-21 22:49:11', '2017-04-22 00:29:35', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lurline.Little@example.com', 'Lurline.Little@example.com', 'USER', 'Lurline', 'Little', '2016-11-13 22:59:43', '2017-04-02 04:18:04', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Abbey.Zemlak@example.com', 'Abbey.Zemlak@example.com', 'USER', 'Abbey', 'Zemlak', '2017-06-06 20:38:39', '2017-09-14 13:08:00', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Herminio.Kub@example.com', 'Herminio.Kub@example.com', 'USER', 'Herminio', 'Kub', '2017-03-16 21:16:01', '2016-12-02 00:09:06', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Rafaela.Harvey@example.com', 'Rafaela.Harvey@example.com', 'USER', 'Rafaela', 'Harvey', '2017-07-06 11:46:45', '2016-12-10 21:54:19', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jared.Herman@example.com', 'Jared.Herman@example.com', 'USER', 'Jared', 'Herman', '2017-06-04 09:24:07', '2017-08-09 11:54:18', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cristobal.Daugherty@example.com', 'Cristobal.Daugherty@example.com', 'USER', 'Cristobal', 'Daugherty', '2016-11-30 03:44:48', '2016-11-10 03:56:16', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chandler.Collier@example.com', 'Chandler.Collier@example.com', 'USER', 'Chandler', 'Collier', '2016-12-13 18:29:14', '2016-11-24 04:23:12', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Shayne.Lubowitz@example.com', 'Shayne.Lubowitz@example.com', 'USER', 'Shayne', 'Lubowitz', '2017-08-16 00:58:26', '2017-01-07 19:32:01', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Mara.Fisher@example.com', 'Mara.Fisher@example.com', 'USER', 'Mara', 'Fisher', '2016-11-27 21:51:17', '2017-06-25 18:37:23', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Daija.Pacocha@example.com', 'Daija.Pacocha@example.com', 'USER', 'Daija', 'Pacocha', '2017-10-11 13:53:12', '2017-01-07 05:02:15', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jimmie.Wilderman@example.com', 'Jimmie.Wilderman@example.com', 'USER', 'Jimmie', 'Wilderman', '2017-09-30 11:22:50', '2017-03-05 08:07:16', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kyla.Dare@example.com', 'Kyla.Dare@example.com', 'USER', 'Kyla', 'Dare', '2017-04-21 03:10:50', '2017-07-28 14:18:12', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jolie.Reichel@example.com', 'Jolie.Reichel@example.com', 'USER', 'Jolie', 'Reichel', '2017-08-24 12:21:22', '2017-07-10 06:37:55', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Arielle.Spinka@example.com', 'Arielle.Spinka@example.com', 'USER', 'Arielle', 'Spinka', '2017-10-23 23:11:59', '2017-02-15 00:44:32', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Talon.Ernser@example.com', 'Talon.Ernser@example.com', 'USER', 'Talon', 'Ernser', '2017-08-31 05:24:48', '2016-10-30 20:46:06', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Tanya.Barton@example.com', 'Tanya.Barton@example.com', 'USER', 'Tanya', 'Barton', '2017-09-28 14:47:12', '2017-02-12 03:04:46', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brent.Brekke@example.com', 'Brent.Brekke@example.com', 'USER', 'Brent', 'Brekke', '2016-11-12 12:37:29', '2017-10-16 10:16:16', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Noe.Breitenberg@example.com', 'Noe.Breitenberg@example.com', 'USER', 'Noe', 'Breitenberg', '2016-11-10 19:05:14', '2017-02-15 16:29:02', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chadrick.Erdman@example.com', 'Chadrick.Erdman@example.com', 'USER', 'Chadrick', 'Erdman', '2017-09-02 02:47:53', '2017-04-30 01:53:42', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Laurine.Gerlach@example.com', 'Laurine.Gerlach@example.com', 'USER', 'Laurine', 'Gerlach', '2017-06-09 02:16:07', '2017-06-24 01:54:00', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vivian.Dickens@example.com', 'Vivian.Dickens@example.com', 'USER', 'Vivian', 'Dickens', '2017-08-21 00:32:01', '2017-03-16 12:53:17', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kavon.Flatley@example.com', 'Kavon.Flatley@example.com', 'USER', 'Kavon', 'Flatley', '2016-11-08 03:20:04', '2017-02-07 02:04:16', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Anika.Stehr@example.com', 'Anika.Stehr@example.com', 'USER', 'Anika', 'Stehr', '2017-03-08 00:14:49', '2016-11-05 02:09:10', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Shayne.Hand@example.com', 'Shayne.Hand@example.com', 'USER', 'Shayne', 'Hand', '2017-09-17 22:25:28', '2017-08-31 01:36:12', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brenda.Emard@example.com', 'Brenda.Emard@example.com', 'USER', 'Brenda', 'Emard', '2017-08-14 13:31:29', '2017-04-07 21:50:49', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dillan.Gerhold@example.com', 'Dillan.Gerhold@example.com', 'USER', 'Dillan', 'Gerhold', '2017-09-03 22:52:35', '2017-04-14 15:51:34', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gordon.Ullrich@example.com', 'Gordon.Ullrich@example.com', 'USER', 'Gordon', 'Ullrich', '2017-08-21 13:27:06', '2016-12-25 07:12:16', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Mohamed.Lakin@example.com', 'Mohamed.Lakin@example.com', 'USER', 'Mohamed', 'Lakin', '2017-01-13 14:44:08', '2017-09-28 05:27:21', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Helen.Trantow@example.com', 'Helen.Trantow@example.com', 'USER', 'Helen', 'Trantow', '2017-05-31 16:15:25', '2016-12-20 18:11:31', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Thurman.Ziemann@example.com', 'Thurman.Ziemann@example.com', 'USER', 'Thurman', 'Ziemann', '2017-09-28 22:20:40', '2016-11-07 07:43:29', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Toney.Powlowski@example.com', 'Toney.Powlowski@example.com', 'USER', 'Toney', 'Powlowski', '2017-01-04 20:52:55', '2017-01-24 10:28:44', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Shaniya.OHara@example.com', 'Shaniya.OHara@example.com', 'USER', 'Shaniya', 'O''Hara', '2017-10-22 08:31:36', '2017-03-26 21:59:53', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Carmel.Corkery@example.com', 'Carmel.Corkery@example.com', 'USER', 'Carmel', 'Corkery', '2016-11-08 13:34:06', '2017-08-30 15:31:51', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Viviane.Langworth@example.com', 'Viviane.Langworth@example.com', 'USER', 'Viviane', 'Langworth', '2017-02-09 05:04:55', '2017-10-09 17:00:40', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Justice.Heller@example.com', 'Justice.Heller@example.com', 'USER', 'Justice', 'Heller', '2016-11-20 11:33:31', '2017-01-13 18:47:24', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Louvenia.Emard@example.com', 'Louvenia.Emard@example.com', 'USER', 'Louvenia', 'Emard', '2017-09-17 17:15:43', '2017-05-08 22:28:55', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ernie.Dibbert@example.com', 'Ernie.Dibbert@example.com', 'USER', 'Ernie', 'Dibbert', '2017-06-11 05:29:42', '2017-07-17 04:09:29', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Elwyn.Reinger@example.com', 'Elwyn.Reinger@example.com', 'USER', 'Elwyn', 'Reinger', '2016-11-26 04:57:15', '2017-06-08 20:42:57', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Hollie.Kunde@example.com', 'Hollie.Kunde@example.com', 'USER', 'Hollie', 'Kunde', '2017-07-20 14:00:51', '2017-01-02 03:06:22', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Willie.Schoen@example.com', 'Willie.Schoen@example.com', 'USER', 'Willie', 'Schoen', '2017-04-19 23:16:56', '2017-10-28 15:51:29', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cali.Grimes@example.com', 'Cali.Grimes@example.com', 'USER', 'Cali', 'Grimes', '2016-11-29 22:44:48', '2017-02-02 05:32:21', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chaz.Erdman@example.com', 'Chaz.Erdman@example.com', 'USER', 'Chaz', 'Erdman', '2017-04-04 16:29:34', '2017-10-09 00:09:57', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Reynold.Blanda@example.com', 'Reynold.Blanda@example.com', 'USER', 'Reynold', 'Blanda', '2017-10-08 07:11:23', '2017-09-07 22:25:00', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Haven.Kautzer@example.com', 'Haven.Kautzer@example.com', 'USER', 'Haven', 'Kautzer', '2017-06-30 17:34:39', '2017-07-09 05:51:39', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brennan.Denesik@example.com', 'Brennan.Denesik@example.com', 'USER', 'Brennan', 'Denesik', '2017-04-22 02:32:07', '2016-11-06 16:33:04', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Blanca.Zboncak@example.com', 'Blanca.Zboncak@example.com', 'USER', 'Blanca', 'Zboncak', '2017-06-11 10:09:43', '2016-11-01 23:00:24', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brionna.Mertz@example.com', 'Brionna.Mertz@example.com', 'USER', 'Brionna', 'Mertz', '2017-09-20 13:15:10', '2016-12-19 01:35:33', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Esther.Labadie@example.com', 'Esther.Labadie@example.com', 'USER', 'Esther', 'Labadie', '2017-09-19 10:27:54', '2017-03-01 06:11:31', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chadd.Friesen@example.com', 'Chadd.Friesen@example.com', 'USER', 'Chadd', 'Friesen', '2017-06-25 10:06:47', '2017-06-15 00:43:47', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Janessa.Cronin@example.com', 'Janessa.Cronin@example.com', 'USER', 'Janessa', 'Cronin', '2017-10-24 21:37:14', '2016-11-04 08:25:03', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ali.Medhurst@example.com', 'Ali.Medhurst@example.com', 'USER', 'Ali', 'Medhurst', '2016-11-29 16:11:39', '2017-07-11 16:39:58', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Briana.Hickle@example.com', 'Briana.Hickle@example.com', 'USER', 'Briana', 'Hickle', '2017-07-15 17:37:14', '2017-05-17 12:54:22', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ed.Olson@example.com', 'Ed.Olson@example.com', 'USER', 'Ed', 'Olson', '2016-12-24 13:38:43', '2016-12-31 21:49:20', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Burley.Hartmann@example.com', 'Burley.Hartmann@example.com', 'USER', 'Burley', 'Hartmann', '2017-10-29 18:46:52', '2017-04-02 20:30:58', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Keegan.Weissnat@example.com', 'Keegan.Weissnat@example.com', 'USER', 'Keegan', 'Weissnat', '2017-09-19 20:28:13', '2017-03-29 19:40:01', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Boyd.Schaden@example.com', 'Boyd.Schaden@example.com', 'USER', 'Boyd', 'Schaden', '2017-10-22 16:34:07', '2016-11-19 05:01:20', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Alize.Hansen@example.com', 'Alize.Hansen@example.com', 'USER', 'Alize', 'Hansen', '2017-06-03 06:56:05', '2017-09-29 17:22:26', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ruthe.Labadie@example.com', 'Ruthe.Labadie@example.com', 'USER', 'Ruthe', 'Labadie', '2016-11-13 22:14:04', '2017-04-18 05:42:21', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Hyman.Heathcote@example.com', 'Hyman.Heathcote@example.com', 'USER', 'Hyman', 'Heathcote', '2017-04-18 20:32:20', '2017-02-27 14:40:42', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Yesenia.Schmeler@example.com', 'Yesenia.Schmeler@example.com', 'USER', 'Yesenia', 'Schmeler', '2017-07-20 19:08:38', '2016-12-22 21:28:12', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Etha.Buckridge@example.com', 'Etha.Buckridge@example.com', 'USER', 'Etha', 'Buckridge', '2017-02-05 20:22:40', '2017-09-10 12:34:36', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Art.Klein@example.com', 'Art.Klein@example.com', 'USER', 'Art', 'Klein', '2017-02-06 23:11:24', '2017-02-07 08:48:17', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Sister.Corwin@example.com', 'Sister.Corwin@example.com', 'USER', 'Sister', 'Corwin', '2017-03-26 14:10:42', '2017-09-13 00:30:35', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Romaine.Herman@example.com', 'Romaine.Herman@example.com', 'USER', 'Romaine', 'Herman', '2016-11-28 11:04:44', '2017-10-11 20:01:56', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jadyn.Rau@example.com', 'Jadyn.Rau@example.com', 'USER', 'Jadyn', 'Rau', '2017-03-31 10:33:15', '2017-03-29 03:17:40', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ambrose.Parker@example.com', 'Ambrose.Parker@example.com', 'USER', 'Ambrose', 'Parker', '2017-05-30 07:48:22', '2017-09-24 02:39:22', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lyda.Macejkovic@example.com', 'Lyda.Macejkovic@example.com', 'USER', 'Lyda', 'Macejkovic', '2016-12-15 12:53:39', '2016-12-27 00:12:44', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Carter.Swaniawski@example.com', 'Carter.Swaniawski@example.com', 'USER', 'Carter', 'Swaniawski', '2017-08-19 08:35:34', '2017-03-23 17:25:59', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vicente.Walker@example.com', 'Vicente.Walker@example.com', 'USER', 'Vicente', 'Walker', '2017-06-01 03:36:28', '2017-03-22 07:03:29', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lois.Ward@example.com', 'Lois.Ward@example.com', 'USER', 'Lois', 'Ward', '2016-11-12 07:28:53', '2017-03-30 02:53:03', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cornelius.Crona@example.com', 'Cornelius.Crona@example.com', 'USER', 'Cornelius', 'Crona', '2017-08-05 17:49:24', '2017-02-10 21:20:03', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chandler.Bartell@example.com', 'Chandler.Bartell@example.com', 'USER', 'Chandler', 'Bartell', '2016-12-07 00:01:36', '2017-10-17 10:25:44', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Oral.Gleason@example.com', 'Oral.Gleason@example.com', 'USER', 'Oral', 'Gleason', '2017-09-02 13:14:06', '2017-01-06 02:35:41', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kenton.Jast@example.com', 'Kenton.Jast@example.com', 'USER', 'Kenton', 'Jast', '2017-10-29 07:08:27', '2017-03-05 10:21:39', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Esperanza.Ziemann@example.com', 'Esperanza.Ziemann@example.com', 'USER', 'Esperanza', 'Ziemann', '2017-07-18 21:35:49', '2017-08-12 18:16:52', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Mireille.Bergstrom@example.com', 'Mireille.Bergstrom@example.com', 'USER', 'Mireille', 'Bergstrom', '2016-12-11 16:14:29', '2017-02-13 11:21:36', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Eudora.MacGyver@example.com', 'Eudora.MacGyver@example.com', 'USER', 'Eudora', 'MacGyver', '2016-11-25 13:53:41', '2017-04-14 14:23:09', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Tito.McGlynn@example.com', 'Tito.McGlynn@example.com', 'USER', 'Tito', 'McGlynn', '2017-06-22 21:07:03', '2017-05-17 05:17:47', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ruthie.MacGyver@example.com', 'Ruthie.MacGyver@example.com', 'USER', 'Ruthie', 'MacGyver', '2017-07-17 07:07:52', '2017-03-09 19:54:28', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Serena.Rempel@example.com', 'Serena.Rempel@example.com', 'USER', 'Serena', 'Rempel', '2017-01-09 17:11:03', '2017-08-25 03:12:44', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Duane.Wiza@example.com', 'Duane.Wiza@example.com', 'USER', 'Duane', 'Wiza', '2017-07-23 05:33:47', '2017-02-27 17:51:40', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Joshua.Kilback@example.com', 'Joshua.Kilback@example.com', 'USER', 'Joshua', 'Kilback', '2017-03-18 23:57:55', '2017-06-01 06:23:58', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Pinkie.Hegmann@example.com', 'Pinkie.Hegmann@example.com', 'USER', 'Pinkie', 'Hegmann', '2017-09-24 01:35:05', '2017-05-15 19:21:10', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Justen.Jast@example.com', 'Justen.Jast@example.com', 'USER', 'Justen', 'Jast', '2017-05-24 21:32:50', '2017-03-16 14:20:39', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Yolanda.Kertzmann@example.com', 'Yolanda.Kertzmann@example.com', 'USER', 'Yolanda', 'Kertzmann', '2017-08-14 08:37:38', '2017-07-22 23:36:58', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Clint.Tillman@example.com', 'Clint.Tillman@example.com', 'USER', 'Clint', 'Tillman', '2017-09-24 15:27:22', '2017-07-25 09:56:23', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brody.Donnelly@example.com', 'Brody.Donnelly@example.com', 'USER', 'Brody', 'Donnelly', '2017-06-30 01:27:22', '2017-08-02 08:46:37', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chauncey.Schiller@example.com', 'Chauncey.Schiller@example.com', 'USER', 'Chauncey', 'Schiller', '2017-10-30 08:53:36', '2017-01-06 13:13:13', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lincoln.Runte@example.com', 'Lincoln.Runte@example.com', 'USER', 'Lincoln', 'Runte', '2017-10-25 00:00:07', '2017-06-02 21:35:40', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Carolyne.Mante@example.com', 'Carolyne.Mante@example.com', 'USER', 'Carolyne', 'Mante', '2017-10-28 12:40:32', '2017-07-02 03:14:26', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jeromy.Larkin@example.com', 'Jeromy.Larkin@example.com', 'USER', 'Jeromy', 'Larkin', '2017-04-23 13:28:23', '2016-12-28 09:09:34', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Maya.DuBuque@example.com', 'Maya.DuBuque@example.com', 'USER', 'Maya', 'DuBuque', '2017-03-04 23:14:55', '2016-12-25 01:26:34', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Merle.Jacobi@example.com', 'Merle.Jacobi@example.com', 'USER', 'Merle', 'Jacobi', '2017-02-10 05:06:13', '2017-02-26 18:00:01', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Domingo.Hoppe@example.com', 'Domingo.Hoppe@example.com', 'USER', 'Domingo', 'Hoppe', '2017-06-22 17:32:37', '2017-01-18 17:09:59', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Osvaldo.Bahringer@example.com', 'Osvaldo.Bahringer@example.com', 'USER', 'Osvaldo', 'Bahringer', '2017-08-30 00:37:34', '2017-01-07 02:00:22', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Juanita.Cummerata@example.com', 'Juanita.Cummerata@example.com', 'USER', 'Juanita', 'Cummerata', '2017-03-18 00:03:23', '2017-03-21 11:52:20', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dakota.West@example.com', 'Dakota.West@example.com', 'USER', 'Dakota', 'West', '2017-08-30 15:53:57', '2017-02-13 13:59:45', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cordie.Wolf@example.com', 'Cordie.Wolf@example.com', 'USER', 'Cordie', 'Wolf', '2017-03-21 01:14:43', '2017-07-22 13:44:08', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Olen.Baumbach@example.com', 'Olen.Baumbach@example.com', 'USER', 'Olen', 'Baumbach', '2017-09-25 16:49:11', '2017-09-13 14:59:56', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Katlynn.Mitchell@example.com', 'Katlynn.Mitchell@example.com', 'USER', 'Katlynn', 'Mitchell', '2017-03-03 15:29:37', '2017-06-30 22:31:11', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brett.Olson@example.com', 'Brett.Olson@example.com', 'USER', 'Brett', 'Olson', '2016-12-28 05:20:51', '2017-06-08 22:56:55', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Randi.Reinger@example.com', 'Randi.Reinger@example.com', 'USER', 'Randi', 'Reinger', '2016-12-11 05:43:56', '2017-04-27 19:08:15', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Wilburn.Nolan@example.com', 'Wilburn.Nolan@example.com', 'USER', 'Wilburn', 'Nolan', '2017-02-21 22:10:45', '2017-04-01 19:54:33', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kameron.Shields@example.com', 'Kameron.Shields@example.com', 'USER', 'Kameron', 'Shields', '2016-12-08 20:21:48', '2017-03-28 23:11:52', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Neoma.Keeling@example.com', 'Neoma.Keeling@example.com', 'USER', 'Neoma', 'Keeling', '2017-03-06 21:08:35', '2017-02-19 07:57:50', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Devan.Harvey@example.com', 'Devan.Harvey@example.com', 'USER', 'Devan', 'Harvey', '2016-11-23 23:35:03', '2017-02-11 10:55:55', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jocelyn.Grant@example.com', 'Jocelyn.Grant@example.com', 'USER', 'Jocelyn', 'Grant', '2016-12-15 08:50:57', '2017-01-03 04:15:33', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Bertram.Abbott@example.com', 'Bertram.Abbott@example.com', 'USER', 'Bertram', 'Abbott', '2017-09-29 17:25:46', '2017-05-09 02:00:35', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vicenta.Bogan@example.com', 'Vicenta.Bogan@example.com', 'USER', 'Vicenta', 'Bogan', '2017-05-31 05:17:51', '2017-10-07 10:52:49', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Candelario.Rowe@example.com', 'Candelario.Rowe@example.com', 'USER', 'Candelario', 'Rowe', '2017-08-24 19:17:32', '2016-11-09 06:16:47', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Halie.Heller@example.com', 'Halie.Heller@example.com', 'USER', 'Halie', 'Heller', '2016-10-31 05:30:24', '2017-01-07 01:11:17', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Erling.Bahringer@example.com', 'Erling.Bahringer@example.com', 'USER', 'Erling', 'Bahringer', '2017-04-29 15:58:59', '2016-11-03 06:40:36', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Maiya.Mante@example.com', 'Maiya.Mante@example.com', 'USER', 'Maiya', 'Mante', '2017-02-16 12:16:57', '2017-10-08 18:39:16', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Korbin.Sawayn@example.com', 'Korbin.Sawayn@example.com', 'USER', 'Korbin', 'Sawayn', '2017-07-02 21:12:03', '2016-12-19 13:10:59', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gideon.Klocko@example.com', 'Gideon.Klocko@example.com', 'USER', 'Gideon', 'Klocko', '2017-08-11 17:25:33', '2017-01-21 10:01:35', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Santina.Terry@example.com', 'Santina.Terry@example.com', 'USER', 'Santina', 'Terry', '2017-10-02 12:18:58', '2017-09-15 14:21:25', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Wilfred.Kutch@example.com', 'Wilfred.Kutch@example.com', 'USER', 'Wilfred', 'Kutch', '2017-10-25 11:39:22', '2017-04-02 04:48:07', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Earl.Rosenbaum@example.com', 'Earl.Rosenbaum@example.com', 'USER', 'Earl', 'Rosenbaum', '2017-09-06 09:33:20', '2017-09-24 18:37:22', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lera.White@example.com', 'Lera.White@example.com', 'USER', 'Lera', 'White', '2017-01-15 10:01:32', '2016-11-25 13:13:11', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Bennie.Simonis@example.com', 'Bennie.Simonis@example.com', 'USER', 'Bennie', 'Simonis', '2017-01-12 19:19:32', '2017-03-10 09:32:37', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lois.Kilback@example.com', 'Lois.Kilback@example.com', 'USER', 'Lois', 'Kilback', '2016-12-24 19:39:47', '2017-05-19 00:42:03', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zetta.Wuckert@example.com', 'Zetta.Wuckert@example.com', 'USER', 'Zetta', 'Wuckert', '2017-05-02 01:46:14', '2017-03-03 15:48:29', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lukas.Kessler@example.com', 'Lukas.Kessler@example.com', 'USER', 'Lukas', 'Kessler', '2017-05-31 10:23:15', '2017-03-10 07:06:09', 'Approved', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Tevin.Little@example.com', 'Tevin.Little@example.com', 'USER', 'Tevin', 'Little', '2017-02-14 09:12:55', '2017-04-05 23:19:42', 'Approved', null); +--Status APPROVED (160) +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Orin.Mraz@example.com', 'Orin.Mraz@example.com', 'USER', 'Orin', 'Mraz', '2017-01-15 04:35:55', '2016-12-15 23:20:51', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vella.Mayer@example.com', 'Vella.Mayer@example.com', 'USER', 'Vella', 'Mayer', '2017-04-05 05:05:50', '2017-06-16 02:44:19', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Samir.Emmerich@example.com', 'Samir.Emmerich@example.com', 'USER', 'Samir', 'Emmerich', '2017-02-03 16:28:31', '2017-05-14 11:47:11', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Humberto.Ledner@example.com', 'Humberto.Ledner@example.com', 'USER', 'Humberto', 'Ledner', '2017-01-30 12:29:31', '2017-09-16 17:53:13', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zechariah.Marvin@example.com', 'Zechariah.Marvin@example.com', 'USER', 'Zechariah', 'Marvin', '2017-08-03 17:05:50', '2017-08-23 19:32:43', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kirk.Klocko@example.com', 'Kirk.Klocko@example.com', 'USER', 'Kirk', 'Klocko', '2017-08-28 08:05:28', '2017-08-07 12:48:23', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Micheal.Swift@example.com', 'Micheal.Swift@example.com', 'USER', 'Micheal', 'Swift', '2017-09-05 20:15:22', '2017-06-04 10:58:23', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gunnar.Conroy@example.com', 'Gunnar.Conroy@example.com', 'USER', 'Gunnar', 'Conroy', '2017-03-03 18:23:20', '2017-06-08 09:18:53', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vidal.Tromp@example.com', 'Vidal.Tromp@example.com', 'USER', 'Vidal', 'Tromp', '2017-09-16 19:16:20', '2017-06-12 17:35:58', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('London.Wehner@example.com', 'London.Wehner@example.com', 'USER', 'London', 'Wehner', '2017-05-31 12:41:18', '2017-05-10 07:36:52', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Estevan.Ziemann@example.com', 'Estevan.Ziemann@example.com', 'USER', 'Estevan', 'Ziemann', '2017-02-11 17:36:28', '2017-05-16 20:09:47', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Drake.Heathcote@example.com', 'Drake.Heathcote@example.com', 'USER', 'Drake', 'Heathcote', '2017-02-20 09:53:56', '2017-10-21 16:49:42', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cecilia.Rohan@example.com', 'Cecilia.Rohan@example.com', 'USER', 'Cecilia', 'Rohan', '2017-09-26 10:45:50', '2017-02-01 21:17:46', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jeromy.Abernathy@example.com', 'Jeromy.Abernathy@example.com', 'USER', 'Jeromy', 'Abernathy', '2017-03-30 17:46:19', '2016-12-24 14:11:40', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zula.Mayer@example.com', 'Zula.Mayer@example.com', 'USER', 'Zula', 'Mayer', '2017-01-16 15:49:06', '2017-09-12 08:28:08', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dan.Jacobi@example.com', 'Dan.Jacobi@example.com', 'USER', 'Dan', 'Jacobi', '2017-09-25 01:52:57', '2017-05-06 13:49:18', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dave.Green@example.com', 'Dave.Green@example.com', 'USER', 'Dave', 'Green', '2017-09-08 08:16:35', '2017-10-10 18:14:19', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Niko.Kovacek@example.com', 'Niko.Kovacek@example.com', 'USER', 'Niko', 'Kovacek', '2017-09-07 12:08:55', '2017-08-14 05:26:38', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cyrus.Stark@example.com', 'Cyrus.Stark@example.com', 'USER', 'Cyrus', 'Stark', '2017-02-18 08:24:35', '2017-06-12 00:42:46', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dorcas.Pfeffer@example.com', 'Dorcas.Pfeffer@example.com', 'USER', 'Dorcas', 'Pfeffer', '2017-05-25 19:25:53', '2017-01-10 07:17:08', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Myra.Cormier@example.com', 'Myra.Cormier@example.com', 'USER', 'Myra', 'Cormier', '2017-05-21 04:58:38', '2017-03-20 00:40:33', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Morris.Harris@example.com', 'Morris.Harris@example.com', 'USER', 'Morris', 'Harris', '2017-08-28 09:49:03', '2017-07-07 12:15:07', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Janiya.Lakin@example.com', 'Janiya.Lakin@example.com', 'USER', 'Janiya', 'Lakin', '2017-09-16 08:03:53', '2017-07-12 10:17:36', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Rae.Kreiger@example.com', 'Rae.Kreiger@example.com', 'USER', 'Rae', 'Kreiger', '2017-06-07 20:34:25', '2017-10-30 01:14:25', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vincent.Abbott@example.com', 'Vincent.Abbott@example.com', 'USER', 'Vincent', 'Abbott', '2017-05-05 03:16:31', '2017-07-21 15:40:42', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Elisha.Weimann@example.com', 'Elisha.Weimann@example.com', 'USER', 'Elisha', 'Weimann', '2016-11-01 06:26:13', '2017-06-10 03:32:52', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Marquis.Oberbrunner@example.com', 'Marquis.Oberbrunner@example.com', 'USER', 'Marquis', 'Oberbrunner', '2017-09-11 18:38:28', '2016-12-28 04:59:25', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ludwig.Murazik@example.com', 'Ludwig.Murazik@example.com', 'USER', 'Ludwig', 'Murazik', '2016-12-02 22:00:44', '2017-06-19 11:40:03', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Orlo.Mayer@example.com', 'Orlo.Mayer@example.com', 'USER', 'Orlo', 'Mayer', '2017-02-02 19:56:55', '2017-01-07 20:04:22', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Heber.Hoppe@example.com', 'Heber.Hoppe@example.com', 'USER', 'Heber', 'Hoppe', '2016-12-05 22:22:00', '2017-09-12 22:00:48', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Furman.Volkman@example.com', 'Furman.Volkman@example.com', 'USER', 'Furman', 'Volkman', '2017-04-08 13:47:45', '2016-12-23 18:16:05', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Carlotta.Herman@example.com', 'Carlotta.Herman@example.com', 'USER', 'Carlotta', 'Herman', '2017-05-24 14:57:22', '2017-08-17 11:00:20', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Idella.Lockman@example.com', 'Idella.Lockman@example.com', 'USER', 'Idella', 'Lockman', '2017-05-05 09:35:45', '2017-06-20 03:54:33', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jarrod.Reilly@example.com', 'Jarrod.Reilly@example.com', 'USER', 'Jarrod', 'Reilly', '2017-09-30 12:12:22', '2017-05-26 03:28:20', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Claudine.McKenzie@example.com', 'Claudine.McKenzie@example.com', 'USER', 'Claudine', 'McKenzie', '2017-10-21 02:30:25', '2016-12-20 02:02:00', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Daniella.Goyette@example.com', 'Daniella.Goyette@example.com', 'USER', 'Daniella', 'Goyette', '2016-12-21 22:49:11', '2017-04-22 00:29:35', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lurline.Little@example.com', 'Lurline.Little@example.com', 'USER', 'Lurline', 'Little', '2016-11-13 22:59:43', '2017-04-02 04:18:04', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Abbey.Zemlak@example.com', 'Abbey.Zemlak@example.com', 'USER', 'Abbey', 'Zemlak', '2017-06-06 20:38:39', '2017-09-14 13:08:00', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Herminio.Kub@example.com', 'Herminio.Kub@example.com', 'USER', 'Herminio', 'Kub', '2017-03-16 21:16:01', '2016-12-02 00:09:06', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Rafaela.Harvey@example.com', 'Rafaela.Harvey@example.com', 'USER', 'Rafaela', 'Harvey', '2017-07-06 11:46:45', '2016-12-10 21:54:19', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jared.Herman@example.com', 'Jared.Herman@example.com', 'USER', 'Jared', 'Herman', '2017-06-04 09:24:07', '2017-08-09 11:54:18', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cristobal.Daugherty@example.com', 'Cristobal.Daugherty@example.com', 'USER', 'Cristobal', 'Daugherty', '2016-11-30 03:44:48', '2016-11-10 03:56:16', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chandler.Collier@example.com', 'Chandler.Collier@example.com', 'USER', 'Chandler', 'Collier', '2016-12-13 18:29:14', '2016-11-24 04:23:12', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Shayne.Lubowitz@example.com', 'Shayne.Lubowitz@example.com', 'USER', 'Shayne', 'Lubowitz', '2017-08-16 00:58:26', '2017-01-07 19:32:01', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Mara.Fisher@example.com', 'Mara.Fisher@example.com', 'USER', 'Mara', 'Fisher', '2016-11-27 21:51:17', '2017-06-25 18:37:23', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Daija.Pacocha@example.com', 'Daija.Pacocha@example.com', 'USER', 'Daija', 'Pacocha', '2017-10-11 13:53:12', '2017-01-07 05:02:15', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jimmie.Wilderman@example.com', 'Jimmie.Wilderman@example.com', 'USER', 'Jimmie', 'Wilderman', '2017-09-30 11:22:50', '2017-03-05 08:07:16', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kyla.Dare@example.com', 'Kyla.Dare@example.com', 'USER', 'Kyla', 'Dare', '2017-04-21 03:10:50', '2017-07-28 14:18:12', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jolie.Reichel@example.com', 'Jolie.Reichel@example.com', 'USER', 'Jolie', 'Reichel', '2017-08-24 12:21:22', '2017-07-10 06:37:55', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Arielle.Spinka@example.com', 'Arielle.Spinka@example.com', 'USER', 'Arielle', 'Spinka', '2017-10-23 23:11:59', '2017-02-15 00:44:32', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Talon.Ernser@example.com', 'Talon.Ernser@example.com', 'USER', 'Talon', 'Ernser', '2017-08-31 05:24:48', '2016-10-30 20:46:06', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Tanya.Barton@example.com', 'Tanya.Barton@example.com', 'USER', 'Tanya', 'Barton', '2017-09-28 14:47:12', '2017-02-12 03:04:46', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brent.Brekke@example.com', 'Brent.Brekke@example.com', 'USER', 'Brent', 'Brekke', '2016-11-12 12:37:29', '2017-10-16 10:16:16', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Noe.Breitenberg@example.com', 'Noe.Breitenberg@example.com', 'USER', 'Noe', 'Breitenberg', '2016-11-10 19:05:14', '2017-02-15 16:29:02', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chadrick.Erdman@example.com', 'Chadrick.Erdman@example.com', 'USER', 'Chadrick', 'Erdman', '2017-09-02 02:47:53', '2017-04-30 01:53:42', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Laurine.Gerlach@example.com', 'Laurine.Gerlach@example.com', 'USER', 'Laurine', 'Gerlach', '2017-06-09 02:16:07', '2017-06-24 01:54:00', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vivian.Dickens@example.com', 'Vivian.Dickens@example.com', 'USER', 'Vivian', 'Dickens', '2017-08-21 00:32:01', '2017-03-16 12:53:17', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kavon.Flatley@example.com', 'Kavon.Flatley@example.com', 'USER', 'Kavon', 'Flatley', '2016-11-08 03:20:04', '2017-02-07 02:04:16', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Anika.Stehr@example.com', 'Anika.Stehr@example.com', 'USER', 'Anika', 'Stehr', '2017-03-08 00:14:49', '2016-11-05 02:09:10', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Shayne.Hand@example.com', 'Shayne.Hand@example.com', 'USER', 'Shayne', 'Hand', '2017-09-17 22:25:28', '2017-08-31 01:36:12', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brenda.Emard@example.com', 'Brenda.Emard@example.com', 'USER', 'Brenda', 'Emard', '2017-08-14 13:31:29', '2017-04-07 21:50:49', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dillan.Gerhold@example.com', 'Dillan.Gerhold@example.com', 'USER', 'Dillan', 'Gerhold', '2017-09-03 22:52:35', '2017-04-14 15:51:34', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gordon.Ullrich@example.com', 'Gordon.Ullrich@example.com', 'USER', 'Gordon', 'Ullrich', '2017-08-21 13:27:06', '2016-12-25 07:12:16', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Mohamed.Lakin@example.com', 'Mohamed.Lakin@example.com', 'USER', 'Mohamed', 'Lakin', '2017-01-13 14:44:08', '2017-09-28 05:27:21', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Helen.Trantow@example.com', 'Helen.Trantow@example.com', 'USER', 'Helen', 'Trantow', '2017-05-31 16:15:25', '2016-12-20 18:11:31', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Thurman.Ziemann@example.com', 'Thurman.Ziemann@example.com', 'USER', 'Thurman', 'Ziemann', '2017-09-28 22:20:40', '2016-11-07 07:43:29', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Toney.Powlowski@example.com', 'Toney.Powlowski@example.com', 'USER', 'Toney', 'Powlowski', '2017-01-04 20:52:55', '2017-01-24 10:28:44', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Shaniya.OHara@example.com', 'Shaniya.OHara@example.com', 'USER', 'Shaniya', 'O''Hara', '2017-10-22 08:31:36', '2017-03-26 21:59:53', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Carmel.Corkery@example.com', 'Carmel.Corkery@example.com', 'USER', 'Carmel', 'Corkery', '2016-11-08 13:34:06', '2017-08-30 15:31:51', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Viviane.Langworth@example.com', 'Viviane.Langworth@example.com', 'USER', 'Viviane', 'Langworth', '2017-02-09 05:04:55', '2017-10-09 17:00:40', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Justice.Heller@example.com', 'Justice.Heller@example.com', 'USER', 'Justice', 'Heller', '2016-11-20 11:33:31', '2017-01-13 18:47:24', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Louvenia.Emard@example.com', 'Louvenia.Emard@example.com', 'USER', 'Louvenia', 'Emard', '2017-09-17 17:15:43', '2017-05-08 22:28:55', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ernie.Dibbert@example.com', 'Ernie.Dibbert@example.com', 'USER', 'Ernie', 'Dibbert', '2017-06-11 05:29:42', '2017-07-17 04:09:29', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Elwyn.Reinger@example.com', 'Elwyn.Reinger@example.com', 'USER', 'Elwyn', 'Reinger', '2016-11-26 04:57:15', '2017-06-08 20:42:57', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Hollie.Kunde@example.com', 'Hollie.Kunde@example.com', 'USER', 'Hollie', 'Kunde', '2017-07-20 14:00:51', '2017-01-02 03:06:22', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Willie.Schoen@example.com', 'Willie.Schoen@example.com', 'USER', 'Willie', 'Schoen', '2017-04-19 23:16:56', '2017-10-28 15:51:29', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cali.Grimes@example.com', 'Cali.Grimes@example.com', 'USER', 'Cali', 'Grimes', '2016-11-29 22:44:48', '2017-02-02 05:32:21', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chaz.Erdman@example.com', 'Chaz.Erdman@example.com', 'USER', 'Chaz', 'Erdman', '2017-04-04 16:29:34', '2017-10-09 00:09:57', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Reynold.Blanda@example.com', 'Reynold.Blanda@example.com', 'USER', 'Reynold', 'Blanda', '2017-10-08 07:11:23', '2017-09-07 22:25:00', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Haven.Kautzer@example.com', 'Haven.Kautzer@example.com', 'USER', 'Haven', 'Kautzer', '2017-06-30 17:34:39', '2017-07-09 05:51:39', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brennan.Denesik@example.com', 'Brennan.Denesik@example.com', 'USER', 'Brennan', 'Denesik', '2017-04-22 02:32:07', '2016-11-06 16:33:04', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Blanca.Zboncak@example.com', 'Blanca.Zboncak@example.com', 'USER', 'Blanca', 'Zboncak', '2017-06-11 10:09:43', '2016-11-01 23:00:24', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brionna.Mertz@example.com', 'Brionna.Mertz@example.com', 'USER', 'Brionna', 'Mertz', '2017-09-20 13:15:10', '2016-12-19 01:35:33', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Esther.Labadie@example.com', 'Esther.Labadie@example.com', 'USER', 'Esther', 'Labadie', '2017-09-19 10:27:54', '2017-03-01 06:11:31', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chadd.Friesen@example.com', 'Chadd.Friesen@example.com', 'USER', 'Chadd', 'Friesen', '2017-06-25 10:06:47', '2017-06-15 00:43:47', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Janessa.Cronin@example.com', 'Janessa.Cronin@example.com', 'USER', 'Janessa', 'Cronin', '2017-10-24 21:37:14', '2016-11-04 08:25:03', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ali.Medhurst@example.com', 'Ali.Medhurst@example.com', 'USER', 'Ali', 'Medhurst', '2016-11-29 16:11:39', '2017-07-11 16:39:58', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Briana.Hickle@example.com', 'Briana.Hickle@example.com', 'USER', 'Briana', 'Hickle', '2017-07-15 17:37:14', '2017-05-17 12:54:22', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ed.Olson@example.com', 'Ed.Olson@example.com', 'USER', 'Ed', 'Olson', '2016-12-24 13:38:43', '2016-12-31 21:49:20', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Burley.Hartmann@example.com', 'Burley.Hartmann@example.com', 'USER', 'Burley', 'Hartmann', '2017-10-29 18:46:52', '2017-04-02 20:30:58', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Keegan.Weissnat@example.com', 'Keegan.Weissnat@example.com', 'USER', 'Keegan', 'Weissnat', '2017-09-19 20:28:13', '2017-03-29 19:40:01', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Boyd.Schaden@example.com', 'Boyd.Schaden@example.com', 'USER', 'Boyd', 'Schaden', '2017-10-22 16:34:07', '2016-11-19 05:01:20', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Alize.Hansen@example.com', 'Alize.Hansen@example.com', 'USER', 'Alize', 'Hansen', '2017-06-03 06:56:05', '2017-09-29 17:22:26', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ruthe.Labadie@example.com', 'Ruthe.Labadie@example.com', 'USER', 'Ruthe', 'Labadie', '2016-11-13 22:14:04', '2017-04-18 05:42:21', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Hyman.Heathcote@example.com', 'Hyman.Heathcote@example.com', 'USER', 'Hyman', 'Heathcote', '2017-04-18 20:32:20', '2017-02-27 14:40:42', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Yesenia.Schmeler@example.com', 'Yesenia.Schmeler@example.com', 'USER', 'Yesenia', 'Schmeler', '2017-07-20 19:08:38', '2016-12-22 21:28:12', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Etha.Buckridge@example.com', 'Etha.Buckridge@example.com', 'USER', 'Etha', 'Buckridge', '2017-02-05 20:22:40', '2017-09-10 12:34:36', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Art.Klein@example.com', 'Art.Klein@example.com', 'USER', 'Art', 'Klein', '2017-02-06 23:11:24', '2017-02-07 08:48:17', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Sister.Corwin@example.com', 'Sister.Corwin@example.com', 'USER', 'Sister', 'Corwin', '2017-03-26 14:10:42', '2017-09-13 00:30:35', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Romaine.Herman@example.com', 'Romaine.Herman@example.com', 'USER', 'Romaine', 'Herman', '2016-11-28 11:04:44', '2017-10-11 20:01:56', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jadyn.Rau@example.com', 'Jadyn.Rau@example.com', 'USER', 'Jadyn', 'Rau', '2017-03-31 10:33:15', '2017-03-29 03:17:40', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ambrose.Parker@example.com', 'Ambrose.Parker@example.com', 'USER', 'Ambrose', 'Parker', '2017-05-30 07:48:22', '2017-09-24 02:39:22', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lyda.Macejkovic@example.com', 'Lyda.Macejkovic@example.com', 'USER', 'Lyda', 'Macejkovic', '2016-12-15 12:53:39', '2016-12-27 00:12:44', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Carter.Swaniawski@example.com', 'Carter.Swaniawski@example.com', 'USER', 'Carter', 'Swaniawski', '2017-08-19 08:35:34', '2017-03-23 17:25:59', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vicente.Walker@example.com', 'Vicente.Walker@example.com', 'USER', 'Vicente', 'Walker', '2017-06-01 03:36:28', '2017-03-22 07:03:29', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lois.Ward@example.com', 'Lois.Ward@example.com', 'USER', 'Lois', 'Ward', '2016-11-12 07:28:53', '2017-03-30 02:53:03', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cornelius.Crona@example.com', 'Cornelius.Crona@example.com', 'USER', 'Cornelius', 'Crona', '2017-08-05 17:49:24', '2017-02-10 21:20:03', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chandler.Bartell@example.com', 'Chandler.Bartell@example.com', 'USER', 'Chandler', 'Bartell', '2016-12-07 00:01:36', '2017-10-17 10:25:44', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Oral.Gleason@example.com', 'Oral.Gleason@example.com', 'USER', 'Oral', 'Gleason', '2017-09-02 13:14:06', '2017-01-06 02:35:41', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kenton.Jast@example.com', 'Kenton.Jast@example.com', 'USER', 'Kenton', 'Jast', '2017-10-29 07:08:27', '2017-03-05 10:21:39', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Esperanza.Ziemann@example.com', 'Esperanza.Ziemann@example.com', 'USER', 'Esperanza', 'Ziemann', '2017-07-18 21:35:49', '2017-08-12 18:16:52', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Mireille.Bergstrom@example.com', 'Mireille.Bergstrom@example.com', 'USER', 'Mireille', 'Bergstrom', '2016-12-11 16:14:29', '2017-02-13 11:21:36', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Eudora.MacGyver@example.com', 'Eudora.MacGyver@example.com', 'USER', 'Eudora', 'MacGyver', '2016-11-25 13:53:41', '2017-04-14 14:23:09', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Tito.McGlynn@example.com', 'Tito.McGlynn@example.com', 'USER', 'Tito', 'McGlynn', '2017-06-22 21:07:03', '2017-05-17 05:17:47', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ruthie.MacGyver@example.com', 'Ruthie.MacGyver@example.com', 'USER', 'Ruthie', 'MacGyver', '2017-07-17 07:07:52', '2017-03-09 19:54:28', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Serena.Rempel@example.com', 'Serena.Rempel@example.com', 'USER', 'Serena', 'Rempel', '2017-01-09 17:11:03', '2017-08-25 03:12:44', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Duane.Wiza@example.com', 'Duane.Wiza@example.com', 'USER', 'Duane', 'Wiza', '2017-07-23 05:33:47', '2017-02-27 17:51:40', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Joshua.Kilback@example.com', 'Joshua.Kilback@example.com', 'USER', 'Joshua', 'Kilback', '2017-03-18 23:57:55', '2017-06-01 06:23:58', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Pinkie.Hegmann@example.com', 'Pinkie.Hegmann@example.com', 'USER', 'Pinkie', 'Hegmann', '2017-09-24 01:35:05', '2017-05-15 19:21:10', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Justen.Jast@example.com', 'Justen.Jast@example.com', 'USER', 'Justen', 'Jast', '2017-05-24 21:32:50', '2017-03-16 14:20:39', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Yolanda.Kertzmann@example.com', 'Yolanda.Kertzmann@example.com', 'USER', 'Yolanda', 'Kertzmann', '2017-08-14 08:37:38', '2017-07-22 23:36:58', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Clint.Tillman@example.com', 'Clint.Tillman@example.com', 'USER', 'Clint', 'Tillman', '2017-09-24 15:27:22', '2017-07-25 09:56:23', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brody.Donnelly@example.com', 'Brody.Donnelly@example.com', 'USER', 'Brody', 'Donnelly', '2017-06-30 01:27:22', '2017-08-02 08:46:37', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Chauncey.Schiller@example.com', 'Chauncey.Schiller@example.com', 'USER', 'Chauncey', 'Schiller', '2017-10-30 08:53:36', '2017-01-06 13:13:13', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lincoln.Runte@example.com', 'Lincoln.Runte@example.com', 'USER', 'Lincoln', 'Runte', '2017-10-25 00:00:07', '2017-06-02 21:35:40', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Carolyne.Mante@example.com', 'Carolyne.Mante@example.com', 'USER', 'Carolyne', 'Mante', '2017-10-28 12:40:32', '2017-07-02 03:14:26', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jeromy.Larkin@example.com', 'Jeromy.Larkin@example.com', 'USER', 'Jeromy', 'Larkin', '2017-04-23 13:28:23', '2016-12-28 09:09:34', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Maya.DuBuque@example.com', 'Maya.DuBuque@example.com', 'USER', 'Maya', 'DuBuque', '2017-03-04 23:14:55', '2016-12-25 01:26:34', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Merle.Jacobi@example.com', 'Merle.Jacobi@example.com', 'USER', 'Merle', 'Jacobi', '2017-02-10 05:06:13', '2017-02-26 18:00:01', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Domingo.Hoppe@example.com', 'Domingo.Hoppe@example.com', 'USER', 'Domingo', 'Hoppe', '2017-06-22 17:32:37', '2017-01-18 17:09:59', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Osvaldo.Bahringer@example.com', 'Osvaldo.Bahringer@example.com', 'USER', 'Osvaldo', 'Bahringer', '2017-08-30 00:37:34', '2017-01-07 02:00:22', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Juanita.Cummerata@example.com', 'Juanita.Cummerata@example.com', 'USER', 'Juanita', 'Cummerata', '2017-03-18 00:03:23', '2017-03-21 11:52:20', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Dakota.West@example.com', 'Dakota.West@example.com', 'USER', 'Dakota', 'West', '2017-08-30 15:53:57', '2017-02-13 13:59:45', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Cordie.Wolf@example.com', 'Cordie.Wolf@example.com', 'USER', 'Cordie', 'Wolf', '2017-03-21 01:14:43', '2017-07-22 13:44:08', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Olen.Baumbach@example.com', 'Olen.Baumbach@example.com', 'USER', 'Olen', 'Baumbach', '2017-09-25 16:49:11', '2017-09-13 14:59:56', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Katlynn.Mitchell@example.com', 'Katlynn.Mitchell@example.com', 'USER', 'Katlynn', 'Mitchell', '2017-03-03 15:29:37', '2017-06-30 22:31:11', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Brett.Olson@example.com', 'Brett.Olson@example.com', 'USER', 'Brett', 'Olson', '2016-12-28 05:20:51', '2017-06-08 22:56:55', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Randi.Reinger@example.com', 'Randi.Reinger@example.com', 'USER', 'Randi', 'Reinger', '2016-12-11 05:43:56', '2017-04-27 19:08:15', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Wilburn.Nolan@example.com', 'Wilburn.Nolan@example.com', 'USER', 'Wilburn', 'Nolan', '2017-02-21 22:10:45', '2017-04-01 19:54:33', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kameron.Shields@example.com', 'Kameron.Shields@example.com', 'USER', 'Kameron', 'Shields', '2016-12-08 20:21:48', '2017-03-28 23:11:52', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Neoma.Keeling@example.com', 'Neoma.Keeling@example.com', 'USER', 'Neoma', 'Keeling', '2017-03-06 21:08:35', '2017-02-19 07:57:50', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Devan.Harvey@example.com', 'Devan.Harvey@example.com', 'USER', 'Devan', 'Harvey', '2016-11-23 23:35:03', '2017-02-11 10:55:55', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Jocelyn.Grant@example.com', 'Jocelyn.Grant@example.com', 'USER', 'Jocelyn', 'Grant', '2016-12-15 08:50:57', '2017-01-03 04:15:33', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Bertram.Abbott@example.com', 'Bertram.Abbott@example.com', 'USER', 'Bertram', 'Abbott', '2017-09-29 17:25:46', '2017-05-09 02:00:35', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vicenta.Bogan@example.com', 'Vicenta.Bogan@example.com', 'USER', 'Vicenta', 'Bogan', '2017-05-31 05:17:51', '2017-10-07 10:52:49', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Candelario.Rowe@example.com', 'Candelario.Rowe@example.com', 'USER', 'Candelario', 'Rowe', '2017-08-24 19:17:32', '2016-11-09 06:16:47', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Halie.Heller@example.com', 'Halie.Heller@example.com', 'USER', 'Halie', 'Heller', '2016-10-31 05:30:24', '2017-01-07 01:11:17', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Erling.Bahringer@example.com', 'Erling.Bahringer@example.com', 'USER', 'Erling', 'Bahringer', '2017-04-29 15:58:59', '2016-11-03 06:40:36', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Maiya.Mante@example.com', 'Maiya.Mante@example.com', 'USER', 'Maiya', 'Mante', '2017-02-16 12:16:57', '2017-10-08 18:39:16', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Korbin.Sawayn@example.com', 'Korbin.Sawayn@example.com', 'USER', 'Korbin', 'Sawayn', '2017-07-02 21:12:03', '2016-12-19 13:10:59', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gideon.Klocko@example.com', 'Gideon.Klocko@example.com', 'USER', 'Gideon', 'Klocko', '2017-08-11 17:25:33', '2017-01-21 10:01:35', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Santina.Terry@example.com', 'Santina.Terry@example.com', 'USER', 'Santina', 'Terry', '2017-10-02 12:18:58', '2017-09-15 14:21:25', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Wilfred.Kutch@example.com', 'Wilfred.Kutch@example.com', 'USER', 'Wilfred', 'Kutch', '2017-10-25 11:39:22', '2017-04-02 04:48:07', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Earl.Rosenbaum@example.com', 'Earl.Rosenbaum@example.com', 'USER', 'Earl', 'Rosenbaum', '2017-09-06 09:33:20', '2017-09-24 18:37:22', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lera.White@example.com', 'Lera.White@example.com', 'USER', 'Lera', 'White', '2017-01-15 10:01:32', '2016-11-25 13:13:11', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Bennie.Simonis@example.com', 'Bennie.Simonis@example.com', 'USER', 'Bennie', 'Simonis', '2017-01-12 19:19:32', '2017-03-10 09:32:37', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lois.Kilback@example.com', 'Lois.Kilback@example.com', 'USER', 'Lois', 'Kilback', '2016-12-24 19:39:47', '2017-05-19 00:42:03', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zetta.Wuckert@example.com', 'Zetta.Wuckert@example.com', 'USER', 'Zetta', 'Wuckert', '2017-05-02 01:46:14', '2017-03-03 15:48:29', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lukas.Kessler@example.com', 'Lukas.Kessler@example.com', 'USER', 'Lukas', 'Kessler', '2017-05-31 10:23:15', '2017-03-10 07:06:09', 'APPROVED', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Tevin.Little@example.com', 'Tevin.Little@example.com', 'USER', 'Tevin', 'Little', '2017-02-14 09:12:55', '2017-04-05 23:19:42', 'APPROVED', null); --- Status Pending (40) -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Beth.Johns@example.com', 'Beth.Johns@example.com', 'USER', 'Beth', 'Johns', '2017-06-19 14:52:08', '2017-05-05 15:54:19', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gretchen.Wintheiser@example.com', 'Gretchen.Wintheiser@example.com', 'USER', 'Gretchen', 'Wintheiser', '2017-06-05 04:12:26', '2017-01-07 06:58:17', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Audreanne.Miller@example.com', 'Audreanne.Miller@example.com', 'USER', 'Audreanne', 'Miller', '2017-06-04 13:11:53', '2017-06-06 23:11:45', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vergie.Daugherty@example.com', 'Vergie.Daugherty@example.com', 'USER', 'Vergie', 'Daugherty', '2017-10-20 21:45:19', '2017-09-26 16:38:34', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ethelyn.Conroy@example.com', 'Ethelyn.Conroy@example.com', 'USER', 'Ethelyn', 'Conroy', '2016-12-29 07:30:45', '2017-09-01 00:47:10', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Rusty.Hickle@example.com', 'Rusty.Hickle@example.com', 'USER', 'Rusty', 'Hickle', '2017-09-23 19:42:57', '2016-12-12 23:34:55', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Flavio.Ebert@example.com', 'Flavio.Ebert@example.com', 'USER', 'Flavio', 'Ebert', '2017-08-01 21:39:24', '2017-07-23 22:27:50', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Terry.Kuvalis@example.com', 'Terry.Kuvalis@example.com', 'USER', 'Terry', 'Kuvalis', '2017-08-04 22:08:39', '2017-02-01 06:20:39', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Aiden.Hand@example.com', 'Aiden.Hand@example.com', 'USER', 'Aiden', 'Hand', '2017-10-08 18:58:16', '2017-10-17 04:30:35', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Maya.Upton@example.com', 'Maya.Upton@example.com', 'USER', 'Maya', 'Upton', '2017-07-02 05:52:26', '2017-02-04 18:04:21', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Rodrigo.Yost@example.com', 'Rodrigo.Yost@example.com', 'USER', 'Rodrigo', 'Yost', '2017-03-31 02:55:51', '2017-05-18 01:18:53', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Betty.Padberg@example.com', 'Betty.Padberg@example.com', 'USER', 'Betty', 'Padberg', '2017-02-02 00:29:31', '2017-09-08 17:12:55', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Edd.Thompson@example.com', 'Edd.Thompson@example.com', 'USER', 'Edd', 'Thompson', '2017-09-30 09:32:18', '2016-11-19 08:42:24', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lizeth.MacGyver@example.com', 'Lizeth.MacGyver@example.com', 'USER', 'Lizeth', 'MacGyver', '2017-09-17 20:10:21', '2017-08-22 09:35:52', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gus.Satterfield@example.com', 'Gus.Satterfield@example.com', 'USER', 'Gus', 'Satterfield', '2017-01-10 06:59:53', '2017-10-17 05:18:10', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ken.Hegmann@example.com', 'Ken.Hegmann@example.com', 'USER', 'Ken', 'Hegmann', '2017-10-05 12:08:15', '2017-09-21 08:31:19', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Hilton.Kassulke@example.com', 'Hilton.Kassulke@example.com', 'USER', 'Hilton', 'Kassulke', '2017-03-27 22:42:23', '2017-03-02 03:47:27', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kelvin.Tillman@example.com', 'Kelvin.Tillman@example.com', 'USER', 'Kelvin', 'Tillman', '2017-02-18 21:45:59', '2017-06-20 14:01:55', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Antone.OKeefe@example.com', 'Antone.OKeefe@example.com', 'USER', 'Antone', 'O''Keefe', '2017-07-22 19:31:46', '2017-09-20 11:40:32', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Genesis.Lindgren@example.com', 'Genesis.Lindgren@example.com', 'USER', 'Genesis', 'Lindgren', '2017-05-15 07:25:40', '2017-02-17 04:20:10', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zane.Rath@example.com', 'Zane.Rath@example.com', 'USER', 'Zane', 'Rath', '2017-10-23 18:43:10', '2016-11-03 08:22:58', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zander.Thiel@example.com', 'Zander.Thiel@example.com', 'USER', 'Zander', 'Thiel', '2017-01-03 03:02:05', '2017-06-25 22:58:38', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Andrew.Hilpert@example.com', 'Andrew.Hilpert@example.com', 'USER', 'Andrew', 'Hilpert', '2017-07-02 21:05:23', '2017-10-08 14:39:28', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Sharon.Farrell@example.com', 'Sharon.Farrell@example.com', 'USER', 'Sharon', 'Farrell', '2017-01-29 07:02:43', '2016-11-03 16:41:53', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Deshawn.Stoltenberg@example.com', 'Deshawn.Stoltenberg@example.com', 'USER', 'Deshawn', 'Stoltenberg', '2017-01-08 23:22:23', '2017-03-13 12:23:23', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Anna.Collier@example.com', 'Anna.Collier@example.com', 'USER', 'Anna', 'Collier', '2016-12-16 07:38:12', '2017-06-26 05:40:01', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kenton.Kilback@example.com', 'Kenton.Kilback@example.com', 'USER', 'Kenton', 'Kilback', '2017-06-26 02:33:05', '2016-12-25 01:43:50', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lyda.Koss@example.com', 'Lyda.Koss@example.com', 'USER', 'Lyda', 'Koss', '2017-04-19 10:02:40', '2017-09-20 12:37:48', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Davion.Mills@example.com', 'Davion.Mills@example.com', 'USER', 'Davion', 'Mills', '2017-02-28 14:51:12', '2017-08-16 00:58:11', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Clara.Blanda@example.com', 'Clara.Blanda@example.com', 'USER', 'Clara', 'Blanda', '2017-01-08 18:39:53', '2017-06-06 16:36:25', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Micaela.Koch@example.com', 'Micaela.Koch@example.com', 'USER', 'Micaela', 'Koch', '2017-01-18 09:33:49', '2017-06-10 04:35:08', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ward.Tillman@example.com', 'Ward.Tillman@example.com', 'USER', 'Ward', 'Tillman', '2017-05-25 04:04:40', '2017-03-06 00:07:29', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Buddy.Ankunding@example.com', 'Buddy.Ankunding@example.com', 'USER', 'Buddy', 'Ankunding', '2017-09-09 07:29:30', '2017-10-06 15:30:45', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ollie.Stroman@example.com', 'Ollie.Stroman@example.com', 'USER', 'Ollie', 'Stroman', '2016-11-20 14:35:19', '2017-07-14 07:00:52', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Shad.Cassin@example.com', 'Shad.Cassin@example.com', 'USER', 'Shad', 'Cassin', '2017-07-02 05:32:44', '2017-10-15 04:57:12', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Waylon.Wiza@example.com', 'Waylon.Wiza@example.com', 'USER', 'Waylon', 'Wiza', '2017-05-09 07:08:19', '2016-12-21 12:52:29', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lupe.Hilll@example.com', 'Lupe.Hilll@example.com', 'USER', 'Lupe', 'Hilll', '2016-11-24 09:35:52', '2017-01-04 15:37:56', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Keeley.Conn@example.com', 'Keeley.Conn@example.com', 'USER', 'Keeley', 'Conn', '2016-11-08 21:15:19', '2017-04-20 05:09:51', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Adan.Hilpert@example.com', 'Adan.Hilpert@example.com', 'USER', 'Adan', 'Hilpert', '2017-10-02 11:43:57', '2017-09-23 09:01:01', 'Pending', null); -INSERT INTO public.egouser (name, email, role, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Larue.Homenick@example.com', 'Larue.Homenick@example.com', 'USER', 'Larue', 'Homenick', '2016-12-24 22:27:31', '2017-10-18 14:38:46', 'Pending', null); \ No newline at end of file +-- Status PENDING (40) +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Beth.Johns@example.com', 'Beth.Johns@example.com', 'USER', 'Beth', 'Johns', '2017-06-19 14:52:08', '2017-05-05 15:54:19', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gretchen.Wintheiser@example.com', 'Gretchen.Wintheiser@example.com', 'USER', 'Gretchen', 'Wintheiser', '2017-06-05 04:12:26', '2017-01-07 06:58:17', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Audreanne.Miller@example.com', 'Audreanne.Miller@example.com', 'USER', 'Audreanne', 'Miller', '2017-06-04 13:11:53', '2017-06-06 23:11:45', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Vergie.Daugherty@example.com', 'Vergie.Daugherty@example.com', 'USER', 'Vergie', 'Daugherty', '2017-10-20 21:45:19', '2017-09-26 16:38:34', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ethelyn.Conroy@example.com', 'Ethelyn.Conroy@example.com', 'USER', 'Ethelyn', 'Conroy', '2016-12-29 07:30:45', '2017-09-01 00:47:10', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Rusty.Hickle@example.com', 'Rusty.Hickle@example.com', 'USER', 'Rusty', 'Hickle', '2017-09-23 19:42:57', '2016-12-12 23:34:55', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Flavio.Ebert@example.com', 'Flavio.Ebert@example.com', 'USER', 'Flavio', 'Ebert', '2017-08-01 21:39:24', '2017-07-23 22:27:50', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Terry.Kuvalis@example.com', 'Terry.Kuvalis@example.com', 'USER', 'Terry', 'Kuvalis', '2017-08-04 22:08:39', '2017-02-01 06:20:39', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Aiden.Hand@example.com', 'Aiden.Hand@example.com', 'USER', 'Aiden', 'Hand', '2017-10-08 18:58:16', '2017-10-17 04:30:35', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Maya.Upton@example.com', 'Maya.Upton@example.com', 'USER', 'Maya', 'Upton', '2017-07-02 05:52:26', '2017-02-04 18:04:21', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Rodrigo.Yost@example.com', 'Rodrigo.Yost@example.com', 'USER', 'Rodrigo', 'Yost', '2017-03-31 02:55:51', '2017-05-18 01:18:53', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Betty.Padberg@example.com', 'Betty.Padberg@example.com', 'USER', 'Betty', 'Padberg', '2017-02-02 00:29:31', '2017-09-08 17:12:55', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Edd.Thompson@example.com', 'Edd.Thompson@example.com', 'USER', 'Edd', 'Thompson', '2017-09-30 09:32:18', '2016-11-19 08:42:24', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lizeth.MacGyver@example.com', 'Lizeth.MacGyver@example.com', 'USER', 'Lizeth', 'MacGyver', '2017-09-17 20:10:21', '2017-08-22 09:35:52', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Gus.Satterfield@example.com', 'Gus.Satterfield@example.com', 'USER', 'Gus', 'Satterfield', '2017-01-10 06:59:53', '2017-10-17 05:18:10', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ken.Hegmann@example.com', 'Ken.Hegmann@example.com', 'USER', 'Ken', 'Hegmann', '2017-10-05 12:08:15', '2017-09-21 08:31:19', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Hilton.Kassulke@example.com', 'Hilton.Kassulke@example.com', 'USER', 'Hilton', 'Kassulke', '2017-03-27 22:42:23', '2017-03-02 03:47:27', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kelvin.Tillman@example.com', 'Kelvin.Tillman@example.com', 'USER', 'Kelvin', 'Tillman', '2017-02-18 21:45:59', '2017-06-20 14:01:55', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Antone.OKeefe@example.com', 'Antone.OKeefe@example.com', 'USER', 'Antone', 'O''Keefe', '2017-07-22 19:31:46', '2017-09-20 11:40:32', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Genesis.Lindgren@example.com', 'Genesis.Lindgren@example.com', 'USER', 'Genesis', 'Lindgren', '2017-05-15 07:25:40', '2017-02-17 04:20:10', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zane.Rath@example.com', 'Zane.Rath@example.com', 'USER', 'Zane', 'Rath', '2017-10-23 18:43:10', '2016-11-03 08:22:58', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Zander.Thiel@example.com', 'Zander.Thiel@example.com', 'USER', 'Zander', 'Thiel', '2017-01-03 03:02:05', '2017-06-25 22:58:38', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Andrew.Hilpert@example.com', 'Andrew.Hilpert@example.com', 'USER', 'Andrew', 'Hilpert', '2017-07-02 21:05:23', '2017-10-08 14:39:28', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Sharon.Farrell@example.com', 'Sharon.Farrell@example.com', 'USER', 'Sharon', 'Farrell', '2017-01-29 07:02:43', '2016-11-03 16:41:53', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Deshawn.Stoltenberg@example.com', 'Deshawn.Stoltenberg@example.com', 'USER', 'Deshawn', 'Stoltenberg', '2017-01-08 23:22:23', '2017-03-13 12:23:23', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Anna.Collier@example.com', 'Anna.Collier@example.com', 'USER', 'Anna', 'Collier', '2016-12-16 07:38:12', '2017-06-26 05:40:01', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Kenton.Kilback@example.com', 'Kenton.Kilback@example.com', 'USER', 'Kenton', 'Kilback', '2017-06-26 02:33:05', '2016-12-25 01:43:50', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lyda.Koss@example.com', 'Lyda.Koss@example.com', 'USER', 'Lyda', 'Koss', '2017-04-19 10:02:40', '2017-09-20 12:37:48', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Davion.Mills@example.com', 'Davion.Mills@example.com', 'USER', 'Davion', 'Mills', '2017-02-28 14:51:12', '2017-08-16 00:58:11', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Clara.Blanda@example.com', 'Clara.Blanda@example.com', 'USER', 'Clara', 'Blanda', '2017-01-08 18:39:53', '2017-06-06 16:36:25', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Micaela.Koch@example.com', 'Micaela.Koch@example.com', 'USER', 'Micaela', 'Koch', '2017-01-18 09:33:49', '2017-06-10 04:35:08', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ward.Tillman@example.com', 'Ward.Tillman@example.com', 'USER', 'Ward', 'Tillman', '2017-05-25 04:04:40', '2017-03-06 00:07:29', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Buddy.Ankunding@example.com', 'Buddy.Ankunding@example.com', 'USER', 'Buddy', 'Ankunding', '2017-09-09 07:29:30', '2017-10-06 15:30:45', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Ollie.Stroman@example.com', 'Ollie.Stroman@example.com', 'USER', 'Ollie', 'Stroman', '2016-11-20 14:35:19', '2017-07-14 07:00:52', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Shad.Cassin@example.com', 'Shad.Cassin@example.com', 'USER', 'Shad', 'Cassin', '2017-07-02 05:32:44', '2017-10-15 04:57:12', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Waylon.Wiza@example.com', 'Waylon.Wiza@example.com', 'USER', 'Waylon', 'Wiza', '2017-05-09 07:08:19', '2016-12-21 12:52:29', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Lupe.Hilll@example.com', 'Lupe.Hilll@example.com', 'USER', 'Lupe', 'Hilll', '2016-11-24 09:35:52', '2017-01-04 15:37:56', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Keeley.Conn@example.com', 'Keeley.Conn@example.com', 'USER', 'Keeley', 'Conn', '2016-11-08 21:15:19', '2017-04-20 05:09:51', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Adan.Hilpert@example.com', 'Adan.Hilpert@example.com', 'USER', 'Adan', 'Hilpert', '2017-10-02 11:43:57', '2017-09-23 09:01:01', 'PENDING', null); +INSERT INTO public.egouser (name, email, type, firstname, lastname, createdat, lastlogin, status, preferredlanguage) VALUES ('Larue.Homenick@example.com', 'Larue.Homenick@example.com', 'USER', 'Larue', 'Homenick', '2016-12-24 22:27:31', '2017-10-18 14:38:46', 'PENDING', null); \ No newline at end of file diff --git a/src/main/resources/dummy-data/02-insert-dummy-groups.sql b/src/main/resources/dummy-data/02-insert-dummy-groups.sql index 5f080e0da..ad24c7596 100644 --- a/src/main/resources/dummy-data/02-insert-dummy-groups.sql +++ b/src/main/resources/dummy-data/02-insert-dummy-groups.sql @@ -1,11 +1,11 @@ /* WARNING: Clears all data in the EgoGroup Table -Clears the EgoGroup table and insert 5 sample groups (4 Approved, 1 Pending) +Clears the EgoGroup table and insert 5 sample groups (4 APPROVED, 1 PENDING) */ TRUNCATE public.egogroup CASCADE; -INSERT INTO egogroup (name, status, description) VALUES ('XYZ Cancer Research Institute', 'Approved', 'Sample group for elite cancer researchers'); -INSERT INTO egogroup (name, status, description) VALUES ('Extreme Research Consortium', 'Approved', 'Sample group for generalist researchers'); -INSERT INTO egogroup (name, status, description) VALUES ('Healthcare Providers Anonymous', 'Approved', 'Sample group for patient care specialist'); -INSERT INTO egogroup (name, status, description) VALUES ('Pediatric Patient Support Network', 'Approved', 'Sample group for patients and their supporters'); -INSERT INTO egogroup (name, status, description) VALUES ('Generic Genomics Geniuses', 'Pending', 'Sample group for super-duper smart genetic investigators'); \ No newline at end of file +INSERT INTO egogroup (name, status, description) VALUES ('XYZ Cancer Research Institute', 'APPROVED', 'Sample group for elite cancer researchers'); +INSERT INTO egogroup (name, status, description) VALUES ('Extreme Research Consortium', 'APPROVED', 'Sample group for generalist researchers'); +INSERT INTO egogroup (name, status, description) VALUES ('Healthcare Providers Anonymous', 'APPROVED', 'Sample group for patient care specialist'); +INSERT INTO egogroup (name, status, description) VALUES ('Pediatric Patient Support Network', 'APPROVED', 'Sample group for patients and their supporters'); +INSERT INTO egogroup (name, status, description) VALUES ('Generic Genomics Geniuses', 'PENDING', 'Sample group for super-duper smart genetic investigators'); \ No newline at end of file diff --git a/src/main/resources/dummy-data/04-insert-dummy-rel-user-group.sql b/src/main/resources/dummy-data/04-insert-dummy-rel-user-group.sql index 5cbfdf192..76c82738b 100644 --- a/src/main/resources/dummy-data/04-insert-dummy-rel-user-group.sql +++ b/src/main/resources/dummy-data/04-insert-dummy-rel-user-group.sql @@ -1,7 +1,7 @@ TRUNCATE public.usergroup CASCADE; -- 4 Users to XYZ Research -INSERT INTO public.usergroup (userId, grpId) +INSERT INTO public.usergroup (user_id, group_id) SELECT u.id, g.id FROM public.egouser AS u LEFT JOIN public.egogroup AS g @@ -9,7 +9,7 @@ INSERT INTO public.usergroup (userId, grpId) WHERE u.name IN ('Carmel.Corkery@example.com','Viviane.Langworth@example.com','Justice.Heller@example.com','Louvenia.Emard@example.com'); -- 19 Users into Extreme Research -INSERT INTO public.usergroup (userId, grpId) +INSERT INTO public.usergroup (user_id, group_id) SELECT u.id, g.id FROM public.egouser AS u LEFT JOIN public.egogroup AS g @@ -17,7 +17,7 @@ INSERT INTO public.usergroup (userId, grpId) WHERE u.name IN ('Elisha.Weimann@example.com','Kavon.Flatley@example.com','Carmel.Corkery@example.com','Keeley.Conn@example.com','Noe.Breitenberg@example.com','Lois.Ward@example.com','Brent.Brekke@example.com','Ruthe.Labadie@example.com','Lurline.Little@example.com','Justice.Heller@example.com','Ollie.Stroman@example.com','Devan.Harvey@example.com','Lupe.Hilll@example.com','Eudora.MacGyver@example.com','Elwyn.Reinger@example.com','Mara.Fisher@example.com','Romaine.Herman@example.com','Ali.Medhurst@example.com','Cali.Grimes@example.com'); -- 48 Users into Pediatric Patient Support Network -INSERT INTO public.usergroup (userId, grpId) +INSERT INTO public.usergroup (user_id, group_id) SELECT u.id, g.id FROM public.egouser AS u LEFT JOIN public.egogroup AS g diff --git a/src/main/resources/flyway/sql/V1_13__fname_lname_not_null_constraints.sql b/src/main/resources/flyway/sql/V1_13__fname_lname_not_null_constraints.sql new file mode 100644 index 000000000..fb085c012 --- /dev/null +++ b/src/main/resources/flyway/sql/V1_13__fname_lname_not_null_constraints.sql @@ -0,0 +1,7 @@ +UPDATE egouser SET lastname = '' WHERE lastname IS NULL; +ALTER TABLE egouser ALTER COLUMN lastname SET NOT NULL; +ALTER TABLE egouser ALTER COLUMN lastname SET DEFAULT ''; + +UPDATE egouser SET firstname = '' WHERE firstname IS NULL; +ALTER TABLE egouser ALTER COLUMN firstname SET NOT NULL; +ALTER TABLE egouser ALTER COLUMN firstname SET DEFAULT ''; diff --git a/src/test/java/bio/overture/ego/controller/AbstractControllerTest.java b/src/test/java/bio/overture/ego/controller/AbstractControllerTest.java index 120958b45..50f7cea21 100644 --- a/src/test/java/bio/overture/ego/controller/AbstractControllerTest.java +++ b/src/test/java/bio/overture/ego/controller/AbstractControllerTest.java @@ -6,9 +6,11 @@ import static org.springframework.http.MediaType.APPLICATION_JSON; import bio.overture.ego.model.dto.CreateApplicationRequest; +import bio.overture.ego.model.dto.CreateUserRequest; import bio.overture.ego.model.dto.GroupRequest; import bio.overture.ego.model.dto.MaskDTO; import bio.overture.ego.model.dto.UpdateApplicationRequest; +import bio.overture.ego.model.dto.UpdateUserRequest; import bio.overture.ego.model.entity.Application; import bio.overture.ego.model.entity.Group; import bio.overture.ego.model.entity.Policy; @@ -120,6 +122,10 @@ protected StringResponseOption deleteUsersFromGroupDeleteRequestAnd( return deleteUsersFromGroupDeleteRequestAnd(g.getId(), userIds); } + protected StringResponseOption createUserPostRequestAnd(CreateUserRequest r) { + return initStringRequest().endpoint("/users").body(r).postAnd(); + } + protected StringResponseOption createApplicationPostRequestAnd(CreateApplicationRequest r) { return initStringRequest().endpoint("/applications").body(r).postAnd(); } @@ -138,8 +144,12 @@ protected StringResponseOption addUsersToGroupPostRequestAnd(Group g, Collection return addUsersToGroupPostRequestAnd(g.getId(), userIds); } + protected StringResponseOption getApplicationsForUserGetRequestAnd(UUID userId) { + return initStringRequest().endpoint("/users/%s/applications", userId).getAnd(); + } + protected StringResponseOption getApplicationsForUserGetRequestAnd(User u) { - return initStringRequest().endpoint("/users/%s/applications", u.getId()).getAnd(); + return getApplicationsForUserGetRequestAnd(u.getId()); } protected StringWebResource getUsersForApplicationEndpoint(UUID appId) { @@ -158,6 +168,15 @@ protected StringResponseOption getApplicationsForGroupGetRequestAnd(Group g) { return initStringRequest().endpoint("/groups/%s/applications", g.getId()).getAnd(); } + protected StringResponseOption addGroupsToUserPostRequestAnd( + UUID userId, Collection groupIds) { + return initStringRequest().endpoint("/users/%s/groups", userId).body(groupIds).postAnd(); + } + + protected StringResponseOption addGroupsToUserPostRequestAnd(User u, Collection groups) { + return addGroupsToUserPostRequestAnd(u.getId(), convertToIds(groups)); + } + protected StringResponseOption addApplicationsToUserPostRequestAnd( UUID userId, Collection appIds) { return initStringRequest().endpoint("/users/%s/applications", userId).body(appIds).postAnd(); @@ -180,10 +199,23 @@ protected StringResponseOption deleteGroupDeleteRequestAnd(UUID groupId) { return initStringRequest().endpoint("/groups/%s", groupId).deleteAnd(); } + protected StringResponseOption deleteUserDeleteRequestAnd(UUID userId) { + return initStringRequest().endpoint("/users/%s", userId).deleteAnd(); + } + protected StringResponseOption deleteGroupDeleteRequestAnd(Group g) { return deleteGroupDeleteRequestAnd(g.getId()); } + protected StringResponseOption deleteUserDeleteRequestAnd(User g) { + return deleteUserDeleteRequestAnd(g.getId()); + } + + protected StringResponseOption partialUpdateUserPutRequestAnd( + UUID userId, UpdateUserRequest updateRequest) { + return initStringRequest().endpoint("/users/%s", userId).body(updateRequest).putAnd(); + } + protected StringResponseOption partialUpdateGroupPutRequestAnd( UUID groupId, GroupRequest updateRequest) { return initStringRequest().endpoint("/groups/%s", groupId).body(updateRequest).putAnd(); @@ -205,8 +237,12 @@ protected StringResponseOption createGroupPostRequestAnd(GroupRequest g) { return initStringRequest().endpoint("/groups").body(g).postAnd(); } + protected StringResponseOption getUserEntityGetRequestAnd(UUID userId) { + return initStringRequest().endpoint("/users/%s", userId).getAnd(); + } + protected StringResponseOption getUserEntityGetRequestAnd(User u) { - return initStringRequest().endpoint("/users/%s", u.getId()).getAnd(); + return getUserEntityGetRequestAnd(u.getId()); } protected StringResponseOption getApplicationEntityGetRequestAnd(UUID appId) { @@ -221,8 +257,12 @@ protected StringResponseOption getPolicyGetRequestAnd(Policy p) { return initStringRequest().endpoint("/policies/%s", p.getId()).getAnd(); } + protected StringResponseOption getGroupsForUserGetRequestAnd(UUID userId) { + return initStringRequest().endpoint("/users/%s/groups", userId).getAnd(); + } + protected StringResponseOption getGroupsForUserGetRequestAnd(User u) { - return initStringRequest().endpoint("/users/%s/groups", u.getId()).getAnd(); + return getGroupsForUserGetRequestAnd(u.getId()); } protected StringWebResource getGroupsForApplicationEndpoint(UUID appId) { @@ -258,6 +298,32 @@ protected StringResponseOption deleteApplicationsFromGroupDeleteRequestAnd( return deleteApplicationsFromGroupDeleteRequestAnd(g.getId(), appIdsToDelete); } + protected StringResponseOption deleteApplicationsFromUserDeleteRequestAnd( + User user, Collection apps) { + val appIdsToDelete = convertToIds(apps); + return deleteApplicationsFromUserDeleteRequestAnd(user.getId(), appIdsToDelete); + } + + protected StringResponseOption deleteApplicationsFromUserDeleteRequestAnd( + UUID userId, Collection appIds) { + return initStringRequest() + .endpoint("/users/%s/applications/%s", userId, COMMA.join(appIds)) + .deleteAnd(); + } + + protected StringResponseOption deleteGroupsFromUserDeleteRequestAnd( + User u, Collection groups) { + val groupIds = convertToIds(groups); + return deleteGroupsFromUserDeleteRequestAnd(u.getId(), groupIds); + } + + protected StringResponseOption deleteGroupsFromUserDeleteRequestAnd( + UUID userId, Collection groupIds) { + return initStringRequest() + .endpoint("/users/%s/groups/%s", userId, COMMA.join(groupIds)) + .deleteAnd(); + } + protected StringResponseOption deleteApplicationsFromGroupDeleteRequestAnd( UUID groupId, Collection appIds) { return initStringRequest() @@ -265,6 +331,10 @@ protected StringResponseOption deleteApplicationsFromGroupDeleteRequestAnd( .deleteAnd(); } + protected StringWebResource listUsersEndpointAnd() { + return initStringRequest().endpoint("/users"); + } + protected StringWebResource listGroupsEndpointAnd() { return initStringRequest().endpoint("/groups"); } diff --git a/src/test/java/bio/overture/ego/controller/AbstractPermissionControllerTest.java b/src/test/java/bio/overture/ego/controller/AbstractPermissionControllerTest.java index 9294226c7..f5a8c371c 100644 --- a/src/test/java/bio/overture/ego/controller/AbstractPermissionControllerTest.java +++ b/src/test/java/bio/overture/ego/controller/AbstractPermissionControllerTest.java @@ -13,8 +13,7 @@ import static java.util.Arrays.stream; import static java.util.function.Function.identity; import static java.util.stream.Collectors.toMap; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatExceptionOfType; +import static org.junit.Assert.*; import static org.springframework.http.HttpStatus.BAD_REQUEST; import static org.springframework.http.HttpStatus.CONFLICT; import static org.springframework.http.HttpStatus.NOT_FOUND; @@ -79,8 +78,8 @@ protected void beforeTest() { .build(); // Sanity check - assertThat(getOwnerService().isExist(owner1.getId())).isTrue(); - policies.forEach(p -> assertThat(getPolicyService().isExist(p.getId())).isTrue()); + assertTrue(getOwnerService().isExist(owner1.getId())); + policies.forEach(p -> assertTrue(getPolicyService().isExist(p.getId()))); } /** Add permissions to a non-existent owner */ @@ -92,8 +91,8 @@ public void addPermissionsToOwner_NonExistentOwner_NotFound() { .endpoint(getAddPermissionsEndpoint(nonExistentOwnerId)) .body(permissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); - assertThat(r1.getBody()).contains(nonExistentOwnerId.toString()); + assertEquals(r1.getStatusCode(), HttpStatus.NOT_FOUND); + assertTrue(r1.getBody().contains(nonExistentOwnerId.toString())); } /** Attempt to add an empty list of permission request to an owner */ @@ -106,7 +105,7 @@ public void addPermissionsToOwner_EmptyPermissionRequests_Conflict() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(newArrayList()) .post(); - assertThat(r1.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r1.getStatusCode(), BAD_REQUEST); } /** Add permissions to an owner that has SOME those permissions */ @@ -121,10 +120,10 @@ public void addPermissionsToOwner_SomeAlreadyExists_Conflict() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(somePermissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); - assertThat(r1.getBody()).isNotNull(); + assertEquals(r1.getStatusCode(), OK); + assertNotNull(r1.getBody()); val r1body = r1.getBody(); - assertThat(r1body.getId()).isEqualTo(owner1.getId()); + assertEquals(r1body.getId(), owner1.getId()); // Add all the permissions, including the one before val r2 = @@ -132,8 +131,8 @@ public void addPermissionsToOwner_SomeAlreadyExists_Conflict() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(permissionRequests) .post(); - assertThat(r2.getStatusCode()).isEqualTo(CONFLICT); - assertThat(r2.getBody()).isNotNull(); + assertEquals(r2.getStatusCode(), CONFLICT); + assertNotNull(r2.getBody()); } /** Add permissions to an owner that has all those permissions */ @@ -146,10 +145,10 @@ public void addPermissionsToOwner_DuplicateRequest_Conflict() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(permissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); - assertThat(r1.getBody()).isNotNull(); + assertEquals(r1.getStatusCode(), OK); + assertNotNull(r1.getBody()); val r1body = r1.getBody(); - assertThat(r1body.getId()).isEqualTo(owner1.getId()); + assertEquals(r1body.getId(), owner1.getId()); log.info("Add the same permissions to the owner. This means duplicates are being added"); val r2 = @@ -157,8 +156,8 @@ public void addPermissionsToOwner_DuplicateRequest_Conflict() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(permissionRequests) .post(); - assertThat(r2.getStatusCode()).isEqualTo(CONFLICT); - assertThat(r2.getBody()).isNotNull(); + assertEquals(r2.getStatusCode(), CONFLICT); + assertNotNull(r2.getBody()); } /** @@ -171,7 +170,7 @@ public void addPermissionsToOwner_MultipleMasks_Conflict() { stream(AccessLevel.values()) .filter(x -> !x.equals(permissionRequests.get(0).getMask())) .findAny(); - assertThat(result).isNotEmpty(); + assertFalse(result.isEmpty()); val differentMask = result.get(); val newPermRequest = @@ -191,8 +190,8 @@ public void addPermissionsToOwner_MultipleMasks_Conflict() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(newPolicyIdStringWithAccessLevel) .post(); - assertThat(r1.getStatusCode()).isEqualTo(CONFLICT); - assertThat(r1.getBody()).isNotNull(); + assertEquals(r1.getStatusCode(), CONFLICT); + assertNotNull(r1.getBody()); } /** Add permissions containing a non-existing policyId to an owner */ @@ -208,9 +207,9 @@ public void addPermissionsToOwner_NonExistentPolicy_NotFound() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(permissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); - assertThat(r1.getBody()).contains(nonExistentPolicyId.toString()); - assertThat(r1.getBody()).doesNotContain(permissionRequests.get(0).getPolicyId().toString()); + assertEquals(r1.getStatusCode(), HttpStatus.NOT_FOUND); + assertTrue(r1.getBody().contains(nonExistentPolicyId.toString())); + assertFalse(r1.getBody().contains(permissionRequests.get(0).getPolicyId().toString())); } @Test @@ -218,7 +217,7 @@ public void addPermissionsToOwner_NonExistentPolicy_NotFound() { public void addPermissions_CreateAndUpdate_Success() { val permRequest1 = permissionRequests.get(0); val permRequest2 = permissionRequests.get(1); - assertThat(permRequest1.getMask()).isNotEqualTo(permRequest2.getMask()); + assertNotEquals(permRequest1.getMask(), permRequest2.getMask()); // Add initial Permission val r1 = @@ -226,7 +225,7 @@ public void addPermissions_CreateAndUpdate_Success() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(ImmutableList.of(permRequest1)) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Update permRequest1 locally val updatePermRequest1 = @@ -241,12 +240,12 @@ public void addPermissions_CreateAndUpdate_Success() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(ImmutableList.of(updatePermRequest1, permRequest2)) .post(); - assertThat(r2.getStatusCode()).isEqualTo(OK); + assertEquals(r2.getStatusCode(), OK); // Get permissions for owner val r3 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r3.getStatusCode()).isEqualTo(OK); - assertThat(r3.getBody()).isNotNull(); + assertEquals(r3.getStatusCode(), OK); + assertNotNull(r3.getBody()); // Assert created permission is correct mask val page = MAPPER.readTree(r3.getBody()); @@ -254,19 +253,21 @@ public void addPermissions_CreateAndUpdate_Success() { Streams.stream(page.path("resultSet").iterator()) .map(x -> MAPPER.convertValue(x, getPermissionType())) .collect(toMap(x -> x.getPolicy().getId(), identity())); - assertThat(existingPermissionIndex.values()).hasSize(2); + assertEquals(existingPermissionIndex.values().size(), 2); // verify permission with permRequest1.getPolicyId() and owner, has same mask as // updatedPermRequest1.getMask() - assertThat(existingPermissionIndex).containsKey(updatePermRequest1.getPolicyId()); - assertThat(existingPermissionIndex.get(updatePermRequest1.getPolicyId()).getAccessLevel()) - .isEqualTo(updatePermRequest1.getMask()); + assertTrue(existingPermissionIndex.containsKey(updatePermRequest1.getPolicyId())); + assertEquals( + existingPermissionIndex.get(updatePermRequest1.getPolicyId()).getAccessLevel(), + updatePermRequest1.getMask()); // verify permission with permRequest2.getPolicyId() and owner, has same mask as // permRequest2.getMask(); - assertThat(existingPermissionIndex).containsKey(permRequest2.getPolicyId()); - assertThat(existingPermissionIndex.get(permRequest2.getPolicyId()).getAccessLevel()) - .isEqualTo(permRequest2.getMask()); + assertTrue(existingPermissionIndex.containsKey(permRequest2.getPolicyId())); + assertEquals( + existingPermissionIndex.get(permRequest2.getPolicyId()).getAccessLevel(), + permRequest2.getMask()); } /** Happy path Add non-existent permissions to an owner, and read it back */ @@ -279,26 +280,26 @@ public void addPermissionsToOwner_Unique_Success() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(permissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Get the policies for this owner val r3 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r3.getStatusCode()).isEqualTo(OK); + assertEquals(r3.getStatusCode(), OK); // Analyze results val page = MAPPER.readTree(r3.getBody()); - assertThat(page).isNotNull(); - assertThat(page.get("count").asInt()).isEqualTo(2); + assertNotNull(page); + assertEquals(page.get("count").asInt(), 2); val outputMap = Streams.stream(page.path("resultSet").iterator()) .collect( toMap( x -> x.path("policy").path("id").asText(), x -> x.path("accessLevel").asText())); - assertThat(outputMap) - .containsKeys(policies.get(0).getId().toString(), policies.get(1).getId().toString()); - assertThat(outputMap.get(policies.get(0).getId().toString())).isEqualTo(WRITE.toString()); - assertThat(outputMap.get(policies.get(1).getId().toString())).isEqualTo(DENY.toString()); + assertTrue(outputMap.containsKey(policies.get(0).getId().toString())); + assertTrue(outputMap.containsKey(policies.get(1).getId().toString())); + assertEquals(outputMap.get(policies.get(0).getId().toString()), WRITE.toString()); + assertEquals(outputMap.get(policies.get(1).getId().toString()), DENY.toString()); } @Test @@ -309,11 +310,11 @@ public void deletePolicyWithPermissions_AlreadyExists_Success() { val body = ImmutableList.of(permRequest); val r1 = initStringRequest().endpoint(getAddPermissionsEndpoint(owner1.getId())).body(body).post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Get the policies for this owner val r2 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r2.getStatusCode()).isEqualTo(OK); + assertEquals(r2.getStatusCode(), OK); // Assert the expected permission ids exist val page = MAPPER.readTree(r2.getBody()); @@ -322,19 +323,19 @@ public void deletePolicyWithPermissions_AlreadyExists_Success() { .map(x -> x.get("id")) .map(JsonNode::asText) .collect(toImmutableSet()); - assertThat(existingPermissionIds).hasSize(1); + assertEquals(existingPermissionIds.size(), 1); // Delete the policy val r3 = initStringRequest().endpoint("policies/%s", permRequest.getPolicyId()).delete(); - assertThat(r3.getStatusCode()).isEqualTo(OK); + assertEquals(r3.getStatusCode(), OK); // Assert that the policy deletion cascaded the delete to the permissions existingPermissionIds.stream() .map(UUID::fromString) - .forEach(x -> assertThat(getPermissionService().isExist(x)).isFalse()); + .forEach(x -> assertFalse(getPermissionService().isExist(x))); // Assert that the policy deletion DID NOT cascade past the permissions and delete the owner - assertThat(getOwnerService().isExist(owner1.getId())).isTrue(); + assertTrue(getOwnerService().isExist(owner1.getId())); } @Test @@ -346,11 +347,11 @@ public void deleteOwnerWithPermissions_AlreadyExists_Success() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(permissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Get the policies for this owner val r2 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r2.getStatusCode()).isEqualTo(OK); + assertEquals(r2.getStatusCode(), OK); // Assert the expected permission ids exist val page = MAPPER.readTree(r2.getBody()); @@ -359,22 +360,22 @@ public void deleteOwnerWithPermissions_AlreadyExists_Success() { .map(x -> x.get("id")) .map(JsonNode::asText) .collect(toImmutableSet()); - assertThat(existingPermissionIds).hasSize(permissionRequests.size()); + assertEquals(existingPermissionIds.size(), permissionRequests.size()); // Delete the owner val r3 = initStringRequest().endpoint(getDeleteOwnerEndpoint(owner1.getId())).delete(); - assertThat(r3.getStatusCode()).isEqualTo(OK); + assertEquals(r3.getStatusCode(), OK); // Assert that the owner deletion cascaded the delete to the permissions existingPermissionIds.stream() .map(UUID::fromString) - .forEach(x -> assertThat(getPermissionService().isExist(x)).isFalse()); + .forEach(x -> assertFalse(getPermissionService().isExist(x))); // Assert that the owner deletion DID NOT cascade past the permission and deleted policies permissionRequests.stream() .map(PermissionRequest::getPolicyId) .distinct() - .forEach(x -> assertThat(getPolicyService().isExist(x)).isTrue()); + .forEach(x -> assertTrue(getPolicyService().isExist(x))); } @Test @@ -386,12 +387,12 @@ public void deletePermissionsForOwner_NonExistent_NotFound() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(permissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Get permissions for owner val r2 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r2.getStatusCode()).isEqualTo(OK); - assertThat(r2.getBody()).isNotNull(); + assertEquals(r2.getStatusCode(), OK); + assertNotNull(r2.getBody()); // Assert the expected permission ids exist val page = MAPPER.readTree(r2.getBody()); @@ -401,7 +402,7 @@ public void deletePermissionsForOwner_NonExistent_NotFound() { .map(JsonNode::asText) .map(UUID::fromString) .collect(toImmutableSet()); - assertThat(existingPermissionIds).hasSize(permissionRequests.size()); + assertEquals(existingPermissionIds.size(), permissionRequests.size()); // Attempt to delete permissions for a nonExistent owner val nonExistentOwnerId = generateNonExistentId(getOwnerService()); @@ -409,19 +410,19 @@ public void deletePermissionsForOwner_NonExistent_NotFound() { initStringRequest() .endpoint(getDeletePermissionsEndpoint(nonExistentOwnerId, existingPermissionIds)) .delete(); - assertThat(r3.getStatusCode()).isEqualTo(NOT_FOUND); + assertEquals(r3.getStatusCode(), NOT_FOUND); // Attempt to delete permissions for an existing owner but a non-existent permission id val nonExistentPermissionId = generateNonExistentId(getPermissionService()); val someExistingPermissionIds = Sets.newHashSet(); someExistingPermissionIds.addAll(existingPermissionIds); someExistingPermissionIds.add(nonExistentPermissionId); - assertThat(getOwnerService().isExist(owner1.getId())).isTrue(); + assertTrue(getOwnerService().isExist(owner1.getId())); val r4 = initStringRequest() .endpoint(getDeletePermissionsEndpoint(owner1.getId(), someExistingPermissionIds)) .delete(); - assertThat(r4.getStatusCode()).isEqualTo(NOT_FOUND); + assertEquals(r4.getStatusCode(), NOT_FOUND); } @Test @@ -434,7 +435,7 @@ public void deletePermissionsForPolicy_NonExistentOwner_NotFound() { initStringRequest() .endpoint(getDeletePermissionEndpoint(policyId, nonExistingOwnerId)) .delete(); - assertThat(r3.getStatusCode()).isEqualTo(NOT_FOUND); + assertEquals(r3.getStatusCode(), NOT_FOUND); } @Test @@ -445,7 +446,7 @@ public void deletePermissionsForPolicy_NonExistentPolicy_NotFound() { initStringRequest() .endpoint(getDeletePermissionEndpoint(nonExistentPolicyId, owner1.getId())) .delete(); - assertThat(r3.getStatusCode()).isEqualTo(NOT_FOUND); + assertEquals(r3.getStatusCode(), NOT_FOUND); } @Test @@ -461,47 +462,47 @@ public void deletePermissionsForPolicy_DuplicateRequest_NotFound() { .endpoint(getAddPermissionEndpoint(policyId, owner1.getId())) .body(createMaskJson(mask.toString())) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Assert the permission exists val r2 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r2.getStatusCode()).isEqualTo(OK); - assertThat(r2.getBody()).isNotNull(); + assertEquals(r2.getStatusCode(), OK); + assertNotNull(r2.getBody()); val page = MAPPER.readTree(r2.getBody()); val existingPermissionIds = Streams.stream(page.path("resultSet").iterator()) .map(x -> x.get("id")) .map(JsonNode::asText) .collect(toImmutableSet()); - assertThat(existingPermissionIds).hasSize(1); + assertEquals(existingPermissionIds.size(), 1); // Delete an existing permission val r3 = initStringRequest() .endpoint(getDeletePermissionEndpoint(policyId, owner1.getId())) .delete(); - assertThat(r3.getStatusCode()).isEqualTo(OK); - assertThat(r3.getBody()).isNotNull(); + assertEquals(r3.getStatusCode(), OK); + assertNotNull(r3.getBody()); // Assert the permission no longer exists val r4 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r4.getStatusCode()).isEqualTo(OK); - assertThat(r4.getBody()).isNotNull(); + assertEquals(r4.getStatusCode(), OK); + assertNotNull(r4.getBody()); val page2 = MAPPER.readTree(r4.getBody()); val actualPermissionIds = Streams.stream(page2.path("resultSet").iterator()) .map(x -> x.get("id")) .map(JsonNode::asText) .collect(toImmutableSet()); - assertThat(actualPermissionIds).isEmpty(); + assertTrue(actualPermissionIds.isEmpty()); // Delete an existing permission val r5 = initStringRequest() .endpoint(getDeletePermissionEndpoint(policyId, owner1.getId())) .delete(); - assertThat(r5.getStatusCode()).isEqualTo(NOT_FOUND); - assertThat(r5.getBody()).isNotNull(); + assertEquals(r5.getStatusCode(), NOT_FOUND); + assertNotNull(r5.getBody()); } @Test @@ -517,40 +518,40 @@ public void deletePermissionsForPolicy_AlreadyExists_Success() { .endpoint(getDeletePermissionEndpoint(policyId, owner1.getId())) .body(createMaskJson(mask.toString())) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); - assertThat(r1.getBody()).isNotNull(); + assertEquals(r1.getStatusCode(), OK); + assertNotNull(r1.getBody()); // Assert the permission exists val r2 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r2.getStatusCode()).isEqualTo(OK); - assertThat(r2.getBody()).isNotNull(); + assertEquals(r2.getStatusCode(), OK); + assertNotNull(r2.getBody()); val page = MAPPER.readTree(r2.getBody()); val existingPermissionIds = Streams.stream(page.path("resultSet").iterator()) .map(x -> x.get("id")) .map(JsonNode::asText) .collect(toImmutableSet()); - assertThat(existingPermissionIds).hasSize(1); + assertEquals(existingPermissionIds.size(), 1); // Delete an existing permission val r3 = initStringRequest() .endpoint(getDeletePermissionEndpoint(policyId, owner1.getId())) .delete(); - assertThat(r3.getStatusCode()).isEqualTo(OK); - assertThat(r3.getBody()).isNotNull(); + assertEquals(r3.getStatusCode(), OK); + assertNotNull(r3.getBody()); // Assert the permission no longer exists val r4 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r4.getStatusCode()).isEqualTo(OK); - assertThat(r4.getBody()).isNotNull(); + assertEquals(r4.getStatusCode(), OK); + assertNotNull(r4.getBody()); val page2 = MAPPER.readTree(r4.getBody()); val actualPermissionIds = Streams.stream(page2.path("resultSet").iterator()) .map(x -> x.get("id")) .map(JsonNode::asText) .collect(toImmutableSet()); - assertThat(actualPermissionIds).isEmpty(); + assertTrue(actualPermissionIds.isEmpty()); } @Test @@ -562,12 +563,12 @@ public void deletePermissionsForOwner_AlreadyExists_Success() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(permissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Get permissions for the owner val r2 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r2.getStatusCode()).isEqualTo(OK); - assertThat(r2.getBody()).isNotNull(); + assertEquals(r2.getStatusCode(), OK); + assertNotNull(r2.getBody()); // Assert the expected permission ids exist val page = MAPPER.readTree(r2.getBody()); @@ -577,37 +578,37 @@ public void deletePermissionsForOwner_AlreadyExists_Success() { .map(JsonNode::asText) .map(UUID::fromString) .collect(toImmutableSet()); - assertThat(existingPermissionIds).hasSize(permissionRequests.size()); + assertEquals(existingPermissionIds.size(), permissionRequests.size()); // Delete the permissions for the owner val r3 = initStringRequest() .endpoint(getDeletePermissionsEndpoint(owner1.getId(), existingPermissionIds)) .delete(); - assertThat(r3.getStatusCode()).isEqualTo(OK); + assertEquals(r3.getStatusCode(), OK); // Assert the expected permissions were deleted val r4 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r4.getStatusCode()).isEqualTo(OK); - assertThat(r4.getBody()).isNotNull(); + assertEquals(r4.getStatusCode(), OK); + assertNotNull(r4.getBody()); val page4 = MAPPER.readTree(r4.getBody()); val existingPermissionIds4 = Streams.stream(page4.path("resultSet").iterator()) .map(x -> x.get("id")) .map(JsonNode::asText) .collect(toImmutableSet()); - assertThat(existingPermissionIds4).isEmpty(); + assertTrue(existingPermissionIds4.isEmpty()); // Assert that the policies still exists policies.forEach( p -> { val r5 = initStringRequest().endpoint("policies/%s", p.getId().toString()).get(); - assertThat(r5.getStatusCode()).isEqualTo(OK); - assertThat(r5.getBody()).isNotNull(); + assertEquals(r5.getStatusCode(), OK); + assertNotNull(r5.getBody()); }); // Assert the owner still exists - assertThat(getOwnerService().isExist(owner1.getId())).isTrue(); + assertTrue(getOwnerService().isExist(owner1.getId())); } /** Using the owners controller, attempt to read a permission belonging to a non-existent owner */ @@ -615,7 +616,7 @@ public void deletePermissionsForOwner_AlreadyExists_Success() { public void readPermissionsForOwner_NonExistent_NotFound() { val nonExistentOwnerId = generateNonExistentId(getOwnerService()); val r1 = initStringRequest().endpoint(getReadPermissionsEndpoint(nonExistentOwnerId)).get(); - assertThat(r1.getStatusCode()).isEqualTo(NOT_FOUND); + assertEquals(r1.getStatusCode(), NOT_FOUND); } /** PolicyController */ @@ -630,8 +631,8 @@ public void addPermissionToPolicy_NonExistentOwnerId_NotFound() { .endpoint(getAddPermissionEndpoint(policies.get(0).getId(), nonExistentOwnerId)) .body(createMaskJson(DENY.toString())) .post(); - assertThat(r1.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); - assertThat(r1.getBody()).contains(nonExistentOwnerId.toString()); + assertEquals(r1.getStatusCode(), HttpStatus.NOT_FOUND); + assertTrue(r1.getBody().contains(nonExistentOwnerId.toString())); } /** Using the policy controller, add a single permission for a non-existent policy */ @@ -644,8 +645,8 @@ public void addPermissionToPolicy_NonExistentPolicyId_NotFound() { .endpoint(getAddPermissionEndpoint(nonExistentPolicyId, owner1.getId())) .body(createMaskJson(DENY.toString())) .post(); - assertThat(r1.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND); - assertThat(r1.getBody()).contains(nonExistentPolicyId.toString()); + assertEquals(r1.getStatusCode(), HttpStatus.NOT_FOUND); + assertTrue(r1.getBody().contains(nonExistentPolicyId.toString())); } /** Add a single permission using the policy controller */ @@ -660,25 +661,25 @@ public void addPermissionToPolicy_Unique_Success() { .endpoint(getAddPermissionEndpoint(permRequest.getPolicyId(), owner1.getId())) .body(createMaskJson(permRequest.getMask().toString())) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); val r2 = initStringRequest() .endpoint(getAddPermissionEndpoint(permRequest.getPolicyId(), owner2.getId())) .body(createMaskJson(permRequest.getMask().toString())) .post(); - assertThat(r2.getStatusCode()).isEqualTo(OK); + assertEquals(r2.getStatusCode(), OK); // Get the owners for the policy previously used val r3 = initStringRequest() .endpoint(getReadOwnersForPolicyEndpoint(permRequest.getPolicyId())) .get(); - assertThat(r3.getStatusCode()).isEqualTo(OK); + assertEquals(r3.getStatusCode(), OK); // Assert that response contains both ownerIds, ownerNames and policyId val body = MAPPER.readTree(r3.getBody()); - assertThat(body).isNotNull(); + assertNotNull(body); val expectedMap = uniqueIndex(asList(owner1, owner2), Identifiable::getId); @@ -688,10 +689,10 @@ public void addPermissionToPolicy_Unique_Success() { val actualOwnerId = UUID.fromString(n.path("id").asText()); val actualOwnerName = n.path("name").asText(); val actualMask = AccessLevel.fromValue(n.path("mask").asText()); - assertThat(expectedMap).containsKey(actualOwnerId); + assertTrue(expectedMap.containsKey(actualOwnerId)); val expectedOwner = expectedMap.get(actualOwnerId); - assertThat(actualOwnerName).isEqualTo(expectedOwner.getName()); - assertThat(actualMask).isEqualTo(permRequest.getMask()); + assertEquals(actualOwnerName, expectedOwner.getName()); + assertEquals(actualMask, permRequest.getMask()); }); } @@ -700,8 +701,12 @@ public void addPermissionToPolicy_Unique_Success() { public void addPermissionsToOwner_IncorrectMask_BadRequest() { // Corrupt the request val incorrectMask = "anIncorrectMask"; - assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy(() -> AccessLevel.fromValue(incorrectMask)); + try { + AccessLevel.fromValue(incorrectMask); + assert (false); + } catch (IllegalArgumentException e) { + log.debug(e.getLocalizedMessage()); + } val body = MAPPER.valueToTree(permissionRequests); val firstElement = (ObjectNode) body.get(0); @@ -709,7 +714,7 @@ public void addPermissionsToOwner_IncorrectMask_BadRequest() { val r1 = initStringRequest().endpoint(getAddPermissionsEndpoint(owner1.getId())).body(body).post(); - assertThat(r1.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r1.getStatusCode(), BAD_REQUEST); } /** Using the policy controller, add a permission with an undefined mask */ @@ -717,8 +722,12 @@ public void addPermissionsToOwner_IncorrectMask_BadRequest() { public void addPermissionsToPolicy_IncorrectMask_BadRequest() { // Corrupt the request val incorrectMask = "anIncorrectMask"; - assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy(() -> AccessLevel.fromValue(incorrectMask)); + try { + AccessLevel.fromValue(incorrectMask); + assert (false); + } catch (IllegalArgumentException e) { + log.debug(e.getLocalizedMessage()); + } // Using the policy controller val policyId = permissionRequests.get(0).getPolicyId(); @@ -727,7 +736,7 @@ public void addPermissionsToPolicy_IncorrectMask_BadRequest() { .endpoint(getAddPermissionEndpoint(policyId, owner1.getId())) .body(createMaskJson(incorrectMask)) .post(); - assertThat(r2.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r2.getStatusCode(), BAD_REQUEST); } @Test @@ -737,22 +746,22 @@ public void uuidValidationForOwner_MalformedUUID_BadRequest() { .endpoint(getAddPermissionsEndpoint(INVALID_UUID)) .body(permissionRequests) .post(); - assertThat(r1.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r1.getStatusCode(), BAD_REQUEST); val r4 = initStringRequest().endpoint(getReadPermissionsEndpoint(INVALID_UUID)).get(); - assertThat(r4.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r4.getStatusCode(), BAD_REQUEST); val r5 = initStringRequest() .endpoint(getDeletePermissionEndpoint(UUID.randomUUID().toString(), INVALID_UUID)) .delete(); - assertThat(r5.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r5.getStatusCode(), BAD_REQUEST); val r6 = initStringRequest() .endpoint(getDeletePermissionEndpoint(INVALID_UUID, UUID.randomUUID().toString())) .delete(); - assertThat(r6.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r6.getStatusCode(), BAD_REQUEST); } @Test @@ -761,27 +770,27 @@ public void uuidValidationForPolicy_MalformedUUID_BadRequest() { initStringRequest() .endpoint(getDeletePermissionEndpoint(UUID.randomUUID().toString(), INVALID_UUID)) .delete(); - assertThat(r1.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r1.getStatusCode(), BAD_REQUEST); val r2 = initStringRequest() .endpoint(getAddPermissionEndpoint(UUID.randomUUID().toString(), INVALID_UUID)) .body(createMaskJson(WRITE.toString())) .post(); - assertThat(r2.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r2.getStatusCode(), BAD_REQUEST); val r3 = initStringRequest() .endpoint(getAddPermissionEndpoint(INVALID_UUID, UUID.randomUUID().toString())) .body(createMaskJson(WRITE.toString())) .post(); - assertThat(r3.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r3.getStatusCode(), BAD_REQUEST); val r4 = initStringRequest() .endpoint(getDeletePermissionEndpoint(INVALID_UUID, UUID.randomUUID().toString())) .delete(); - assertThat(r4.getStatusCode()).isEqualTo(BAD_REQUEST); + assertEquals(r4.getStatusCode(), BAD_REQUEST); } @Test @@ -794,14 +803,14 @@ public void addPermissionsToPolicy_DuplicateRequests_Conflict() { .endpoint(getAddPermissionEndpoint(permRequest.getPolicyId(), owner1.getId())) .body(createMaskJson(permRequest.getMask().toString())) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); val r2 = initStringRequest() .endpoint(getAddPermissionEndpoint(permRequest.getPolicyId(), owner1.getId())) .body(createMaskJson(permRequest.getMask().toString())) .post(); - assertThat(r2.getStatusCode()).isEqualTo(CONFLICT); + assertEquals(r2.getStatusCode(), CONFLICT); } @Test @@ -813,8 +822,8 @@ public void updatePermissionsToOwner_AlreadyExists_Success() { val updatedPermRequest1 = PermissionRequest.builder().policyId(permRequest1.getPolicyId()).mask(updatedMask).build(); - assertThat(updatedMask).isNotEqualTo(permRequest1.getMask()); - assertThat(permRequest1.getMask()).isNotEqualTo(permRequest2.getMask()); + assertNotEquals(updatedMask, permRequest1.getMask()); + assertNotEquals(permRequest1.getMask(), permRequest2.getMask()); // Create permission for owner val r1 = @@ -822,12 +831,12 @@ public void updatePermissionsToOwner_AlreadyExists_Success() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(ImmutableList.of(permRequest1)) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Get created permissions val r2 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r2.getStatusCode()).isEqualTo(OK); - assertThat(r2.getBody()).isNotNull(); + assertEquals(r2.getStatusCode(), OK); + assertNotNull(r2.getBody()); // Assert created permission is correct mask val page = MAPPER.readTree(r2.getBody()); @@ -835,9 +844,9 @@ public void updatePermissionsToOwner_AlreadyExists_Success() { Streams.stream(page.path("resultSet").iterator()) .map(x -> MAPPER.convertValue(x, getPermissionType())) .collect(toImmutableList()); - assertThat(existingPermissions).hasSize(1); + assertEquals(existingPermissions.size(), 1); val permission = existingPermissions.get(0); - assertThat(permission.getAccessLevel()).isEqualTo(permRequest1.getMask()); + assertEquals(permission.getAccessLevel(), permRequest1.getMask()); // Update the permission val r3 = @@ -845,12 +854,12 @@ public void updatePermissionsToOwner_AlreadyExists_Success() { .endpoint(getAddPermissionsEndpoint(owner1.getId())) .body(ImmutableList.of(updatedPermRequest1)) .post(); - assertThat(r3.getStatusCode()).isEqualTo(OK); + assertEquals(r3.getStatusCode(), OK); // Get updated permissions val r4 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r4.getStatusCode()).isEqualTo(OK); - assertThat(r4.getBody()).isNotNull(); + assertEquals(r4.getStatusCode(), OK); + assertNotNull(r4.getBody()); // Assert updated permission is correct mask val page2 = MAPPER.readTree(r4.getBody()); @@ -858,9 +867,9 @@ public void updatePermissionsToOwner_AlreadyExists_Success() { Streams.stream(page2.path("resultSet").iterator()) .map(x -> MAPPER.convertValue(x, getPermissionType())) .collect(toImmutableList()); - assertThat(existingPermissions2).hasSize(1); + assertEquals(existingPermissions2.size(), 1); val permission2 = existingPermissions2.get(0); - assertThat(permission2.getAccessLevel()).isEqualTo(updatedMask); + assertEquals(permission2.getAccessLevel(), updatedMask); } @Test @@ -868,7 +877,7 @@ public void updatePermissionsToOwner_AlreadyExists_Success() { public void updatePermissionsToPolicy_AlreadyExists_Success() { val permRequest1 = permissionRequests.get(0); val permRequest2 = permissionRequests.get(1); - assertThat(permRequest1.getMask()).isNotEqualTo(permRequest2.getMask()); + assertNotEquals(permRequest1.getMask(), permRequest2.getMask()); // Create permission for owner and policy val r1 = @@ -876,12 +885,12 @@ public void updatePermissionsToPolicy_AlreadyExists_Success() { .endpoint(getAddPermissionEndpoint(permRequest1.getPolicyId(), owner1.getId())) .body(createMaskJson(permRequest1.getMask().toString())) .post(); - assertThat(r1.getStatusCode()).isEqualTo(OK); + assertEquals(r1.getStatusCode(), OK); // Get created permissions val r2 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r2.getStatusCode()).isEqualTo(OK); - assertThat(r2.getBody()).isNotNull(); + assertEquals(r2.getStatusCode(), OK); + assertNotNull(r2.getBody()); // Assert created permission is correct mask val page = MAPPER.readTree(r2.getBody()); @@ -889,9 +898,9 @@ public void updatePermissionsToPolicy_AlreadyExists_Success() { Streams.stream(page.path("resultSet").iterator()) .map(x -> MAPPER.convertValue(x, getPermissionType())) .collect(toImmutableList()); - assertThat(existingPermissions).hasSize(1); + assertEquals(existingPermissions.size(), 1); val permission = existingPermissions.get(0); - assertThat(permission.getAccessLevel()).isEqualTo(permRequest1.getMask()); + assertEquals(permission.getAccessLevel(), permRequest1.getMask()); // Update the permission val r3 = @@ -899,12 +908,12 @@ public void updatePermissionsToPolicy_AlreadyExists_Success() { .endpoint(getAddPermissionEndpoint(permRequest1.getPolicyId(), owner1.getId())) .body(createMaskJson(permRequest2.getMask().toString())) .post(); - assertThat(r3.getStatusCode()).isEqualTo(OK); + assertEquals(r3.getStatusCode(), OK); // Get updated permissions val r4 = initStringRequest().endpoint(getReadPermissionsEndpoint(owner1.getId())).get(); - assertThat(r4.getStatusCode()).isEqualTo(OK); - assertThat(r4.getBody()).isNotNull(); + assertEquals(r4.getStatusCode(), OK); + assertNotNull(r4.getBody()); // Assert updated permission is correct mask val page2 = MAPPER.readTree(r4.getBody()); @@ -912,9 +921,9 @@ public void updatePermissionsToPolicy_AlreadyExists_Success() { Streams.stream(page2.path("resultSet").iterator()) .map(x -> MAPPER.convertValue(x, getPermissionType())) .collect(toImmutableList()); - assertThat(existingPermissions2).hasSize(1); + assertEquals(existingPermissions2.size(), 1); val permission2 = existingPermissions2.get(0); - assertThat(permission2.getAccessLevel()).isEqualTo(permRequest2.getMask()); + assertEquals(permission2.getAccessLevel(), permRequest2.getMask()); } /** Necessary abstract methods for a generic abstract test */ diff --git a/src/test/java/bio/overture/ego/controller/ApplicationControllerTest.java b/src/test/java/bio/overture/ego/controller/ApplicationControllerTest.java index 86e0f0c4c..8f7270e62 100644 --- a/src/test/java/bio/overture/ego/controller/ApplicationControllerTest.java +++ b/src/test/java/bio/overture/ego/controller/ApplicationControllerTest.java @@ -21,9 +21,7 @@ import static bio.overture.ego.controller.resolver.PageableResolver.OFFSET; import static bio.overture.ego.model.enums.JavaFields.GROUPAPPLICATIONS; import static bio.overture.ego.model.enums.JavaFields.ID; -import static bio.overture.ego.model.enums.JavaFields.NAME; -import static bio.overture.ego.model.enums.JavaFields.STATUS; -import static bio.overture.ego.model.enums.JavaFields.USERS; +import static bio.overture.ego.model.enums.JavaFields.USERAPPLICATIONS; import static bio.overture.ego.model.enums.StatusType.APPROVED; import static bio.overture.ego.utils.CollectionUtils.repeatedCallsOf; import static bio.overture.ego.utils.EntityGenerator.generateNonExistentClientId; @@ -37,7 +35,7 @@ import static bio.overture.ego.utils.EntityGenerator.randomStringWithSpaces; import static bio.overture.ego.utils.Streams.stream; import static com.google.common.collect.Lists.newArrayList; -import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.*; import bio.overture.ego.AuthorizationServiceMain; import bio.overture.ego.model.dto.CreateApplicationRequest; @@ -117,9 +115,9 @@ public void addApplication_Success() { val response = initStringRequest().endpoint("/applications").body(app).post(); val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + assertEquals(responseStatus, HttpStatus.OK); val responseJson = MAPPER.readTree(response.getBody()); - assertThat(responseJson.get("name").asText()).isEqualTo("addApplication_Success"); + assertEquals(responseJson.get("name").asText(), "addApplication_Success"); } @Test @@ -148,11 +146,11 @@ public void addDuplicateApplication_Conflict() { val response1 = initStringRequest().endpoint("/applications").body(app1).post(); val responseStatus1 = response1.getStatusCode(); - assertThat(responseStatus1).isEqualTo(HttpStatus.OK); + assertEquals(responseStatus1, HttpStatus.OK); val response2 = initStringRequest().endpoint("/applications").body(app2).post(); val responseStatus2 = response2.getStatusCode(); - assertThat(responseStatus2).isEqualTo(HttpStatus.CONFLICT); + assertEquals(responseStatus2, HttpStatus.CONFLICT); } @Test @@ -161,7 +159,7 @@ public void getApplication_Success() { val application = applicationService.getByClientId("111111"); getApplicationEntityGetRequestAnd(application) .assertEntityOfType(Application.class) - .isEqualToIgnoringGivenFields(application, GROUPAPPLICATIONS, USERS); + .isEqualToIgnoringGivenFields(application, GROUPAPPLICATIONS, USERAPPLICATIONS); } @Test @@ -181,8 +179,8 @@ public void findApplications_FindAllQuery_Success() { .extractPageResults(Application.class); // Assert the generated applications are included in the list - assertThat(actualApps).hasSize(totalApplications); - assertThat(actualApps).containsAll(data.getApplications()); + assertEquals(actualApps.size(), totalApplications); + assertTrue(actualApps.containsAll(data.getApplications())); } @Test @@ -229,12 +227,16 @@ public void createApplication_NonExisting_Success() { // Create the application using the request val app = createApplicationPostRequestAnd(createRequest).extractOneEntity(Application.class); - assertThat(app).isEqualToIgnoringGivenFields(createRequest, ID, GROUPAPPLICATIONS, USERS); + assertEquals(app.getClientId(), createRequest.getClientId()); + assertEquals(app.getClientSecret(), createRequest.getClientSecret()); + assertEquals(app.getName(), createRequest.getName()); + assertEquals(app.getType(), createRequest.getType()); + assertEquals(app.getDescription(), createRequest.getDescription()); // Get the application getApplicationEntityGetRequestAnd(app) .assertEntityOfType(Application.class) - .isEqualToIgnoringGivenFields(createRequest, ID, GROUPAPPLICATIONS, USERS); + .isEqualToIgnoringGivenFields(createRequest, ID, GROUPAPPLICATIONS, USERAPPLICATIONS); } @Test @@ -367,7 +369,7 @@ public void getApplication_ExistingApplication_Success() { // Assert app0 can be read getApplicationEntityGetRequestAnd(app0) .assertEntityOfType(Application.class) - .isEqualToIgnoringGivenFields(app0, GROUPAPPLICATIONS, USERS); + .isEqualToIgnoringGivenFields(app0, GROUPAPPLICATIONS, USERAPPLICATIONS); } @Test @@ -423,21 +425,28 @@ public void updateApplication_ExistingApplication_Success() { UpdateApplicationRequest.builder() .name(generateNonExistentName(applicationService)) .build(); - assertThat(app0.getName()).isNotEqualTo(updateRequest1.getName()); + assertNotEquals(app0.getName(), updateRequest1.getName()); // Update app0 with updateRequest1, and assert the name changed val app0_before0 = getApplicationEntityGetRequestAnd(app0).extractOneEntity(Application.class); partialUpdateApplicationPutRequestAnd(app0.getId(), updateRequest1).assertOk(); val app0_after0 = getApplicationEntityGetRequestAnd(app0).extractOneEntity(Application.class); - assertThat(app0_before0) - .isEqualToIgnoringGivenFields(app0_after0, ID, GROUPAPPLICATIONS, USERS, NAME); + assertEquals(app0_before0.getClientId(), app0_after0.getClientId()); + assertEquals(app0_before0.getClientSecret(), app0_after0.getClientSecret()); + assertNotEquals(app0_before0.getName(), app0_after0.getName()); + assertEquals(app0_before0.getType(), app0_after0.getType()); + assertEquals(app0_before0.getDescription(), app0_after0.getDescription()); // Update app0 with empty update request, and assert nothing changed val app0_before1 = getApplicationEntityGetRequestAnd(app0).extractOneEntity(Application.class); partialUpdateApplicationPutRequestAnd(app0.getId(), UpdateApplicationRequest.builder().build()) .assertOk(); val app0_after1 = getApplicationEntityGetRequestAnd(app0).extractOneEntity(Application.class); - assertThat(app0_before1).isEqualTo(app0_after1); + assertEquals(app0_before1.getClientId(), app0_after1.getClientId()); + assertEquals(app0_before1.getClientSecret(), app0_after1.getClientSecret()); + assertEquals(app0_before1.getName(), app0_after1.getName()); + assertEquals(app0_before1.getType(), app0_after1.getType()); + assertEquals(app0_before1.getDescription(), app0_after1.getDescription()); // Update the status field, and assert only that was updated val app0_before2 = getApplicationEntityGetRequestAnd(app0).extractOneEntity(Application.class); @@ -447,10 +456,12 @@ public void updateApplication_ExistingApplication_Success() { .build(); partialUpdateApplicationPutRequestAnd(app0.getId(), updateRequest2).assertOk(); val app0_after2 = getApplicationEntityGetRequestAnd(app0).extractOneEntity(Application.class); - assertThat(app0_before2) - .isEqualToIgnoringGivenFields(app0_after2, ID, GROUPAPPLICATIONS, USERS, STATUS); - assertThat(app0_before2.getStatus()).isNotEqualTo(app0_after2.getStatus()); - assertThat(app0_after2.getStatus()).isEqualTo(updateRequest2.getStatus()); + assertEquals(app0_before2.getClientId(), app0_after2.getClientId()); + assertEquals(app0_before2.getClientSecret(), app0_after2.getClientSecret()); + assertEquals(app0_before2.getName(), app0_after2.getName()); + assertEquals(app0_before2.getType(), app0_after2.getType()); + assertEquals(app0_before2.getDescription(), app0_after2.getDescription()); + assertNotEquals(app0_before2.getStatus(), app0_after2.getStatus()); } @Test @@ -496,7 +507,7 @@ public void statusValidation_MalformedStatus_BadRequest() { // Assert the invalid status is actually invalid val invalidStatus = "something123"; val match = stream(StatusType.values()).anyMatch(x -> x.toString().equals(invalidStatus)); - assertThat(match).isFalse(); + assertFalse(match); // Generate data val data = generateUniqueTestApplicationData(); @@ -535,7 +546,7 @@ public void applicationTypeValidation_MalformedApplicationType_BadRequest() { val invalidApplicationType = "something123"; val match = stream(ApplicationType.values()).anyMatch(x -> x.toString().equals(invalidApplicationType)); - assertThat(match).isFalse(); + assertFalse(match); // Generate data val data = generateUniqueTestApplicationData(); diff --git a/src/test/java/bio/overture/ego/controller/GroupControllerTest.java b/src/test/java/bio/overture/ego/controller/GroupControllerTest.java index c9881acda..4d3bc5e4a 100644 --- a/src/test/java/bio/overture/ego/controller/GroupControllerTest.java +++ b/src/test/java/bio/overture/ego/controller/GroupControllerTest.java @@ -3,12 +3,6 @@ import static bio.overture.ego.model.enums.AccessLevel.DENY; import static bio.overture.ego.model.enums.AccessLevel.READ; import static bio.overture.ego.model.enums.AccessLevel.WRITE; -import static bio.overture.ego.model.enums.JavaFields.DESCRIPTION; -import static bio.overture.ego.model.enums.JavaFields.GROUPAPPLICATIONS; -import static bio.overture.ego.model.enums.JavaFields.NAME; -import static bio.overture.ego.model.enums.JavaFields.PERMISSIONS; -import static bio.overture.ego.model.enums.JavaFields.STATUS; -import static bio.overture.ego.model.enums.JavaFields.USERGROUPS; import static bio.overture.ego.model.enums.StatusType.APPROVED; import static bio.overture.ego.model.enums.StatusType.DISABLED; import static bio.overture.ego.model.enums.StatusType.PENDING; @@ -37,7 +31,7 @@ import static net.javacrumbs.jsonunit.core.Option.IGNORING_ARRAY_ORDER; import static net.javacrumbs.jsonunit.core.Option.IGNORING_EXTRA_ARRAY_ITEMS; import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson; -import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.*; import bio.overture.ego.AuthorizationServiceMain; import bio.overture.ego.model.dto.GroupRequest; @@ -58,6 +52,7 @@ import bio.overture.ego.service.UserService; import bio.overture.ego.utils.EntityGenerator; import java.util.List; +import java.util.Set; import java.util.UUID; import lombok.Builder; import lombok.NonNull; @@ -146,7 +141,7 @@ public void getGroup() { "{\"id\":\"%s\",\"name\":\"Group One\",\"description\":\"\",\"status\":\"PENDING\"}", groupId); - assertThat(actualBody).isEqualTo(expectedBody); + assertEquals(actualBody, expectedBody); } @Test @@ -205,20 +200,20 @@ public void deleteOne() { // Check user-group relationship is there val userWithGroup = userService.getByName("TempGroupUser@domain.com"); val expectedGroups = mapToSet(userWithGroup.getUserGroups(), UserGroup::getGroup); - assertThat(extractGroupIds(expectedGroups)).contains(groupId); + assertTrue(extractGroupIds(expectedGroups).contains(groupId)); // Check app-group relationship is there val applicationWithGroup = applicationService.getByClientId("TempGroupApp"); val groups = mapToImmutableSet(applicationWithGroup.getGroupApplications(), GroupApplication::getGroup); - assertThat(extractGroupIds(groups)).contains(groupId); + assertTrue(extractGroupIds(groups).contains(groupId)); deleteGroupDeleteRequestAnd(group).assertOk(); // Check user-group relationship is also deleted val usersWithoutGroupBody = getGroupsForUserGetRequestAnd(userOne).assertOk().assertHasBody().getResponse().getBody(); - assertThat(usersWithoutGroupBody).doesNotContain(groupId.toString()); + assertFalse(usersWithoutGroupBody.contains(groupId.toString())); // Check user-application relationship is also deleted val applicationWithoutGroupBody = @@ -227,7 +222,7 @@ public void deleteOne() { .assertHasBody() .getResponse() .getBody(); - assertThat(applicationWithoutGroupBody).doesNotContain(groupId.toString()); + assertFalse(applicationWithoutGroupBody.contains(groupId.toString())); // Check group is deleted getGroupEntityGetRequestAnd(group).assertNotFound(); @@ -246,15 +241,16 @@ public void addUsersToGroup() { // Check that Group is associated with Users val groupWithUsers = groupService.getByName("GroupWithUsers"); - assertThat(extractIDs(mapToSet(groupWithUsers.getUserGroups(), UserGroup::getUser))) - .contains(userOne.getId(), userTwo.getId()); + assertTrue( + extractIDs(mapToSet(groupWithUsers.getUserGroups(), UserGroup::getUser)) + .containsAll(Set.of(userOne.getId(), userTwo.getId()))); // Check that each user is associated with the group val userOneWithGroups = userService.getByName("FirstUser@domain.com"); val userTwoWithGroups = userService.getByName("SecondUser@domain.com"); - assertThat(mapToSet(userOneWithGroups.getUserGroups(), UserGroup::getGroup)).contains(group); - assertThat(mapToSet(userTwoWithGroups.getUserGroups(), UserGroup::getGroup)).contains(group); + assertTrue(mapToSet(userOneWithGroups.getUserGroups(), UserGroup::getGroup).contains(group)); + assertTrue(mapToSet(userTwoWithGroups.getUserGroups(), UserGroup::getGroup).contains(group)); } @Test @@ -273,8 +269,8 @@ public void deleteUserFromGroup() { deleteUsersFromGroupDeleteRequestAnd(group, asList(deleteUser)).assertOk(); val actualUsersForGroup = getUsersForGroupGetRequestAnd(group).extractPageResults(User.class); - assertThat(actualUsersForGroup).hasSize(1); - assertThat(actualUsersForGroup.stream().findAny().get().getId()).isEqualTo(remainUser.getId()); + assertEquals(actualUsersForGroup.size(), 1); + assertEquals(actualUsersForGroup.stream().findAny().get().getId(), remainUser.getId()); } @Test @@ -292,18 +288,18 @@ public void addAppsToGroup() { val groupWithApps = groupService.getByName("GroupWithApps"); val applications = mapToImmutableSet(groupWithApps.getGroupApplications(), GroupApplication::getApplication); - assertThat(extractAppIds(applications)).contains(appOne.getId(), appTwo.getId()); + assertTrue(extractAppIds(applications).containsAll(Set.of(appOne.getId(), appTwo.getId()))); // Check that each user is associated with the group val appOneWithGroups = applicationService.getByClientId("111111"); val appTwoWithGroups = applicationService.getByClientId("222222"); - assertThat( - mapToImmutableSet(appOneWithGroups.getGroupApplications(), GroupApplication::getGroup)) - .contains(group); - assertThat( - mapToImmutableSet(appTwoWithGroups.getGroupApplications(), GroupApplication::getGroup)) - .contains(group); + assertTrue( + mapToImmutableSet(appOneWithGroups.getGroupApplications(), GroupApplication::getGroup) + .contains(group)); + assertTrue( + mapToImmutableSet(appTwoWithGroups.getGroupApplications(), GroupApplication::getGroup) + .contains(group)); } @Test @@ -325,8 +321,8 @@ public void deleteAppFromGroup() { val actualApps = getApplicationsForGroupGetRequestAnd(group).extractPageResults(Application.class); - assertThat(actualApps).hasSize(1); - assertThat(actualApps.stream().findAny().get().getId()).isEqualTo(remainApp.getId()); + assertEquals(actualApps.size(), 1); + assertEquals(actualApps.stream().findAny().get().getId(), remainApp.getId()); } @Test @@ -338,7 +334,9 @@ public void createGroup_NonExisting_Success() { getGroupEntityGetRequestAnd(group1).assertOk().assertHasBody(); - assertThat(r).isEqualToComparingFieldByField(group1); + assertEquals(r.getName(), group1.getName()); + assertEquals(r.getDescription(), group1.getDescription()); + assertEquals(r.getStatus(), group1.getStatus()); } @Test @@ -403,7 +401,7 @@ public void deleteGroupAndRelationshipsOnly_AlreadyExisting_Success() { // Assert no group permissions for the group val results = groupPermissionRepository.findAllByOwner_Id(group0.getId()); - assertThat(results).hasSize(0); + assertEquals(results.size(), 0); // Assert getGroupUsers returns NOT_FOUND getUsersForGroupGetRequestAnd(group0).assertNotFound(); @@ -490,7 +488,7 @@ public void getGroups_FindSomeQuery_Success() { .extractPageResults(Group.class); val rejectedGroups = r3.stream().filter(x -> x.getStatus() == REJECTED).collect(toImmutableSet()); - assertThat(rejectedGroups.size()).isGreaterThanOrEqualTo(1); + assertTrue(rejectedGroups.size() >= 1); listGroupsEndpointAnd() .queryParam("query", "blueberry") @@ -651,7 +649,7 @@ public void getUsersFromGroup_FindAllQuery_Success() { // Assert without using a controller, there are no users for the group val beforeGroup = groupService.getWithRelationships(group0.getId()); - assertThat(beforeGroup.getUserGroups()).isEmpty(); + assertTrue(beforeGroup.getUserGroups().isEmpty()); // Add users to group addUsersToGroupPostRequestAnd(group0, data.getUsers()).assertOk(); @@ -659,7 +657,8 @@ public void getUsersFromGroup_FindAllQuery_Success() { // Assert without using a controller, there are users for the group val afterGroup = groupService.getWithRelationships(group0.getId()); val expectedUsers = mapToSet(afterGroup.getUserGroups(), UserGroup::getUser); - assertThat(expectedUsers).containsExactlyInAnyOrderElementsOf(data.getUsers()); + assertTrue(data.getUsers().containsAll(expectedUsers)); + assertTrue(expectedUsers.containsAll(data.getUsers())); // Get user for a group using a controller getUsersForGroupGetRequestAnd(group0) @@ -744,14 +743,14 @@ public void getUsersFromGroup_FindSomeQuery_Success() { @Test public void getGroup_ExistingGroup_Success() { val group = entityGenerator.generateRandomGroup(); - assertThat(groupService.isExist(group.getId())).isTrue(); + assertTrue(groupService.isExist(group.getId())); getGroupEntityGetRequestAnd(group).assertOk(); } @Test public void getGroup_NonExistentGroup_Success() { val nonExistentId = generateNonExistentId(groupService); - val r1 = initStringRequest().endpoint("groups/%s", nonExistentId).getAnd().assertNotFound(); + initStringRequest().endpoint("groups/%s", nonExistentId).getAnd().assertNotFound(); } @Test @@ -812,7 +811,7 @@ public void UUIDValidation_MalformedUUID_BadRequest() { val actualPermissions = getGroupPermissionsForGroupGetRequestAnd(group0).extractPageResults(GroupPermission.class); - assertThat(actualPermissions).hasSize(1); + assertEquals(actualPermissions.size(), 1); val existingPermissionId = actualPermissions.get(0).getId(); initStringRequest() @@ -863,9 +862,10 @@ public void updateGroup_ExistingGroup_Success() { val updatedGroup1 = partialUpdateGroupPutRequestAnd(g.getId(), updateRequest1).extractOneEntity(Group.class); - assertThat(updatedGroup1) - .isEqualToIgnoringGivenFields(g, NAME, PERMISSIONS, GROUPAPPLICATIONS, USERGROUPS); - assertThat(updatedGroup1.getName()).isEqualTo(updateRequest1.getName()); + assertEquals(updatedGroup1.getId(), g.getId()); + assertEquals(updatedGroup1.getDescription(), g.getDescription()); + + assertEquals(updatedGroup1.getName(), updateRequest1.getName()); val updateRequest2 = GroupRequest.builder() @@ -875,20 +875,20 @@ public void updateGroup_ExistingGroup_Success() { .build(); val updatedGroup2 = partialUpdateGroupPutRequestAnd(g.getId(), updateRequest2).extractOneEntity(Group.class); - assertThat(updatedGroup2) - .isEqualToIgnoringGivenFields( - updatedGroup1, STATUS, PERMISSIONS, GROUPAPPLICATIONS, USERGROUPS); - assertThat(updatedGroup2.getStatus()).isEqualTo(updateRequest2.getStatus()); + assertEquals(updatedGroup2.getName(), updatedGroup1.getName()); + assertEquals(updatedGroup2.getId(), updatedGroup1.getId()); + assertEquals(updatedGroup2.getDescription(), updatedGroup1.getDescription()); + assertEquals(updatedGroup2.getStatus(), updateRequest2.getStatus()); val description = "my description"; val updateRequest3 = GroupRequest.builder().name(null).status(null).description(description).build(); val updatedGroup3 = partialUpdateGroupPutRequestAnd(g.getId(), updateRequest3).extractOneEntity(Group.class); - assertThat(updatedGroup3) - .isEqualToIgnoringGivenFields( - updatedGroup2, DESCRIPTION, PERMISSIONS, GROUPAPPLICATIONS, USERGROUPS); - assertThat(updatedGroup3.getDescription()).isEqualTo(updateRequest3.getDescription()); + assertEquals(updatedGroup3.getName(), updatedGroup2.getName()); + assertEquals(updatedGroup3.getId(), updatedGroup2.getId()); + + assertEquals(updatedGroup3.getDescription(), updateRequest3.getDescription()); } @Test @@ -911,7 +911,7 @@ public void updateGroup_NameAlreadyExists_Conflict() { public void statusValidation_MalformedStatus_BadRequest() { val invalidStatus = "something123"; val match = stream(StatusType.values()).anyMatch(x -> x.toString().equals(invalidStatus)); - assertThat(match).isFalse(); + assertFalse(match); val data = generateUniqueTestGroupData(); val group = data.getGroups().get(0); @@ -941,7 +941,7 @@ public void getScopes_FindAllQuery_Success() { // Assert without using a controller, there are no users for the group val beforeGroup = groupService.getWithRelationships(group0.getId()); - assertThat(beforeGroup.getPermissions()).isEmpty(); + assertTrue(beforeGroup.getPermissions().isEmpty()); // Add policies to group data.getPolicies() @@ -953,7 +953,7 @@ public void getScopes_FindAllQuery_Success() { // Assert without using a controller, there are users for the group val afterGroup = groupService.getWithRelationships(group0.getId()); - assertThat(afterGroup.getPermissions()).hasSize(2); + assertEquals(afterGroup.getPermissions().size(), 2); // Get permissions for a group using a controller getGroupPermissionsForGroupGetRequestAnd(group0) @@ -989,7 +989,7 @@ public void addAppsToGroup_AllExistingUnassociatedApps_Success() { // Assert without using the controller, that the group is not associated with any apps val beforeGroup = groupService.getWithRelationships(group0.getId()); - assertThat(beforeGroup.getGroupApplications()).isEmpty(); + assertTrue(beforeGroup.getGroupApplications().isEmpty()); // Add applications to the group addApplicationsToGroupPostRequestAnd(group0, data.getApplications()).assertOk(); @@ -998,7 +998,8 @@ public void addAppsToGroup_AllExistingUnassociatedApps_Success() { val afterGroup = groupService.getWithRelationships(group0.getId()); val expectedApplications = mapToImmutableSet(afterGroup.getGroupApplications(), GroupApplication::getApplication); - assertThat(expectedApplications).containsExactlyInAnyOrderElementsOf(data.getApplications()); + + assertTrue(expectedApplications.containsAll(data.getApplications())); } @Test diff --git a/src/test/java/bio/overture/ego/controller/PolicyControllerTest.java b/src/test/java/bio/overture/ego/controller/PolicyControllerTest.java index fd22a3e9e..348f5d24e 100644 --- a/src/test/java/bio/overture/ego/controller/PolicyControllerTest.java +++ b/src/test/java/bio/overture/ego/controller/PolicyControllerTest.java @@ -20,7 +20,7 @@ import static bio.overture.ego.controller.AbstractPermissionControllerTest.createMaskJson; import static bio.overture.ego.model.enums.AccessLevel.READ; import static bio.overture.ego.model.enums.AccessLevel.WRITE; -import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; import bio.overture.ego.AuthorizationServiceMain; import bio.overture.ego.model.dto.PolicyRequest; @@ -81,12 +81,12 @@ public void addpolicy_Success() { val response = initStringRequest().endpoint("/policies").body(policy).post(); val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + assertEquals(responseStatus, HttpStatus.OK); val responseJson = MAPPER.readTree(response.getBody()); log.info(response.getBody()); - assertThat(responseJson.get("name").asText()).isEqualTo("AddPolicy"); + assertEquals(responseJson.get("name").asText(), "AddPolicy"); } @Test @@ -98,12 +98,12 @@ public void addDuplicatePolicy_Conflict() { val response1 = initStringRequest().endpoint("/policies").body(policy1).post(); val responseStatus1 = response1.getStatusCode(); - assertThat(responseStatus1).isEqualTo(HttpStatus.OK); + assertEquals(responseStatus1, HttpStatus.OK); val response2 = initStringRequest().endpoint("/policies").body(policy2).post(); val responseStatus2 = response2.getStatusCode(); - assertThat(responseStatus2).isEqualTo(HttpStatus.CONFLICT); + assertEquals(responseStatus2, HttpStatus.CONFLICT); } @Test @@ -115,8 +115,8 @@ public void getPolicy_Success() { val responseStatus = response.getStatusCode(); val responseJson = MAPPER.readTree(response.getBody()); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); - assertThat(responseJson.get("name").asText()).isEqualTo("Study001"); + assertEquals(responseStatus, HttpStatus.OK); + assertEquals(responseJson.get("name").asText(), "Study001"); } @Test @@ -132,7 +132,7 @@ public void associatePermissionsWithGroup_ExistingEntitiesButNonExistingRelation .post(); val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + assertEquals(responseStatus, HttpStatus.OK); val getResponse = initStringRequest().endpoint("/policies/%s/groups", policyId).get(); @@ -140,9 +140,9 @@ public void associatePermissionsWithGroup_ExistingEntitiesButNonExistingRelation val getResponseJson = MAPPER.readTree(getResponse.getBody()); val groupPermissionJson = getResponseJson.get(0); - assertThat(getResponseStatus).isEqualTo(HttpStatus.OK); - assertThat(groupPermissionJson.get("id").asText()).isEqualTo(groupId); - assertThat(groupPermissionJson.get("mask").asText()).isEqualTo("WRITE"); + assertEquals(getResponseStatus, HttpStatus.OK); + assertEquals(groupPermissionJson.get("id").asText(), groupId); + assertEquals(groupPermissionJson.get("mask").asText(), "WRITE"); } @Test @@ -158,7 +158,7 @@ public void disassociatePermissionsFromGroup_EntitiesAndRelationshipsExisting_Su .post(); val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + assertEquals(responseStatus, HttpStatus.OK); val deleteResponse = initStringRequest() @@ -166,15 +166,15 @@ public void disassociatePermissionsFromGroup_EntitiesAndRelationshipsExisting_Su .delete(); val deleteResponseStatus = deleteResponse.getStatusCode(); - assertThat(deleteResponseStatus).isEqualTo(HttpStatus.OK); + assertEquals(deleteResponseStatus, HttpStatus.OK); val getResponse = initStringRequest().endpoint("/policies/%s/groups", policyId).get(); val getResponseStatus = getResponse.getStatusCode(); val getResponseJson = (ArrayNode) MAPPER.readTree(getResponse.getBody()); - assertThat(getResponseStatus).isEqualTo(HttpStatus.OK); - assertThat(getResponseJson.size()).isEqualTo(0); + assertEquals(getResponseStatus, HttpStatus.OK); + assertEquals(getResponseJson.size(), 0); } @Test @@ -190,7 +190,7 @@ public void associatePermissionsWithUser_ExistingEntitiesButNoRelationship_Succe .post(); val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + assertEquals(responseStatus, HttpStatus.OK); // TODO: Fix it so that POST returns JSON, not just random string message val getResponse = initStringRequest().endpoint("/policies/%s/users", policyId).get(); @@ -199,9 +199,9 @@ public void associatePermissionsWithUser_ExistingEntitiesButNoRelationship_Succe val getResponseJson = MAPPER.readTree(getResponse.getBody()); val groupPermissionJson = getResponseJson.get(0); - assertThat(getResponseStatus).isEqualTo(HttpStatus.OK); - assertThat(groupPermissionJson.get("id").asText()).isEqualTo(userId); - assertThat(groupPermissionJson.get("mask").asText()).isEqualTo("READ"); + assertEquals(getResponseStatus, HttpStatus.OK); + assertEquals(groupPermissionJson.get("id").asText(), userId); + assertEquals(groupPermissionJson.get("mask").asText(), "READ"); } @Test @@ -217,21 +217,21 @@ public void disassociatePermissionsFromUser_ExistingEntitiesAndRelationships_Suc .post(); val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + assertEquals(responseStatus, HttpStatus.OK); // TODO: Fix it so that POST returns JSON, not just random string message val deleteResponse = initStringRequest().endpoint("/policies/%s/permission/user/%s", policyId, userId).delete(); val deleteResponseStatus = deleteResponse.getStatusCode(); - assertThat(deleteResponseStatus).isEqualTo(HttpStatus.OK); + assertEquals(deleteResponseStatus, HttpStatus.OK); val getResponse = initStringRequest().endpoint("/policies/%s/users", policyId).get(); val getResponseStatus = getResponse.getStatusCode(); val getResponseJson = (ArrayNode) MAPPER.readTree(getResponse.getBody()); - assertThat(getResponseStatus).isEqualTo(HttpStatus.OK); - assertThat(getResponseJson.size()).isEqualTo(0); + assertEquals(getResponseStatus, HttpStatus.OK); + assertEquals(getResponseJson.size(), 0); } } diff --git a/src/test/java/bio/overture/ego/controller/RevokeTokenControllerTest.java b/src/test/java/bio/overture/ego/controller/RevokeTokenControllerTest.java index 71fc051af..33d5dc7e7 100644 --- a/src/test/java/bio/overture/ego/controller/RevokeTokenControllerTest.java +++ b/src/test/java/bio/overture/ego/controller/RevokeTokenControllerTest.java @@ -3,7 +3,8 @@ import static bio.overture.ego.model.enums.ApplicationType.CLIENT; import static bio.overture.ego.model.enums.UserType.USER; import static java.util.UUID.randomUUID; -import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; import static org.springframework.http.HttpHeaders.AUTHORIZATION; import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity; import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print; @@ -81,7 +82,7 @@ public void revokeAnyTokenAsAdminUser() { test.regularUser, randomTokenName, false, 1000, "random token", randomScopes); entityGenerator.setupToken(test.adminUser, adminTokenName, false, 1000, "test token", scopes); - assertThat(randomToken.isRevoked()).isFalse(); + assertFalse(randomToken.isRevoked()); mockMvc .perform( @@ -94,7 +95,7 @@ public void revokeAnyTokenAsAdminUser() { tokenService .findByTokenString(randomTokenName) .orElseThrow(() -> new InvalidTokenException("Token Not Found!")); - assertThat(revokedToken.isRevoked()).isTrue(); + assertTrue(revokedToken.isRevoked()); } @WithMockCustomUser @@ -108,7 +109,7 @@ public void revokeOwnTokenAsAdminUser() { val token = entityGenerator.setupToken(test.adminUser, tokenName, false, 1000, "test token", scopes); - assertThat(token.isRevoked()).isFalse(); + assertFalse(token.isRevoked()); mockMvc .perform( @@ -121,7 +122,7 @@ public void revokeOwnTokenAsAdminUser() { tokenService .findByTokenString(tokenName) .orElseThrow(() -> new InvalidTokenException("Token Not Found!")); - assertThat(revokedToken.isRevoked()).isTrue(); + assertTrue(revokedToken.isRevoked()); } @WithMockCustomUser(firstName = "Regular", lastName = "User", type = USER) @@ -135,7 +136,7 @@ public void revokeAnyTokenAsRegularUser() { val token = entityGenerator.setupToken(test.user1, tokenName, false, 1000, "test token", scopes); - assertThat(token.isRevoked()).isFalse(); + assertFalse(token.isRevoked()); mockMvc .perform( @@ -147,7 +148,7 @@ public void revokeAnyTokenAsRegularUser() { tokenService .findByTokenString(tokenName) .orElseThrow(() -> new InvalidTokenException("Token Not Found!")); - assertThat(revokedToken.isRevoked()).isFalse(); + assertFalse(revokedToken.isRevoked()); } @WithMockCustomUser(firstName = "Regular", lastName = "User", type = USER) @@ -161,7 +162,7 @@ public void revokeOwnTokenAsRegularUser() { val token = entityGenerator.setupToken(test.regularUser, tokenName, false, 1000, "test token", scopes); - assertThat(token.isRevoked()).isFalse(); + assertFalse(token.isRevoked()); mockMvc .perform( @@ -174,7 +175,7 @@ public void revokeOwnTokenAsRegularUser() { tokenService .findByTokenString(tokenName) .orElseThrow(() -> new InvalidTokenException("Token Not Found!")); - assertThat(revokedToken.isRevoked()).isTrue(); + assertTrue(revokedToken.isRevoked()); } @WithMockCustomApplication @@ -186,7 +187,7 @@ public void revokeAnyTokenAsAdminApp() { val token = entityGenerator.setupToken(test.regularUser, tokenName, false, 1000, "test token", scopes); - assertThat(token.isRevoked()).isFalse(); + assertFalse(token.isRevoked()); mockMvc .perform( @@ -199,7 +200,7 @@ public void revokeAnyTokenAsAdminApp() { tokenService .findByTokenString(tokenName) .orElseThrow(() -> new InvalidTokenException("Token Not Found!")); - assertThat(revokedToken.isRevoked()).isTrue(); + assertTrue(revokedToken.isRevoked()); } @WithMockCustomApplication( @@ -215,7 +216,7 @@ public void revokeTokenAsClientApp() { val token = entityGenerator.setupToken(test.regularUser, tokenName, false, 1000, "test token", scopes); - assertThat(token.isRevoked()).isFalse(); + assertFalse(token.isRevoked()); mockMvc .perform( @@ -228,6 +229,6 @@ public void revokeTokenAsClientApp() { tokenService .findByTokenString(tokenName) .orElseThrow(() -> new InvalidTokenException("Token Not Found!")); - assertThat(revokedToken.isRevoked()).isFalse(); + assertFalse(revokedToken.isRevoked()); } } diff --git a/src/test/java/bio/overture/ego/controller/TokensOnPermissionsChangeTest.java b/src/test/java/bio/overture/ego/controller/TokensOnPermissionsChangeTest.java index b70b113c1..6f0b64357 100644 --- a/src/test/java/bio/overture/ego/controller/TokensOnPermissionsChangeTest.java +++ b/src/test/java/bio/overture/ego/controller/TokensOnPermissionsChangeTest.java @@ -17,7 +17,8 @@ package bio.overture.ego.controller; -import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import static org.springframework.http.HttpHeaders.AUTHORIZATION; import static org.springframework.http.MediaType.APPLICATION_JSON; @@ -95,13 +96,13 @@ public void deletePermissionFromUser_ExistingToken_RevokeSuccess() { .endpoint("/users/%s/permissions/%s", user.getId(), permissionId) .delete(); val deleteStatusCode = deletePermissionResponse.getStatusCode(); - assertThat(deleteStatusCode).isEqualTo(HttpStatus.OK); + assertEquals(deleteStatusCode, HttpStatus.OK); val checkTokenAfterDeleteResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be revoked - assertThat(checkTokenAfterDeleteResponse.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(checkTokenAfterDeleteResponse.getStatusCode(), HttpStatus.UNAUTHORIZED); } /** @@ -125,14 +126,14 @@ public void upgradePermissionFromUser_ExistingToken_KeepTokenSuccess() { .post(); val upgradeStatusCode = upgradeResponse.getStatusCode(); - assertThat(upgradeStatusCode).isEqualTo(HttpStatus.OK); + assertEquals(upgradeStatusCode, HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); val statusCode = checkTokenAfterUpgradeResponse.getStatusCode(); // Should be valid - assertThat(statusCode).isEqualTo(HttpStatus.MULTI_STATUS); + assertEquals(statusCode, HttpStatus.MULTI_STATUS); } /** @@ -156,14 +157,14 @@ public void downgradePermissionFromUser_ExistingToken_RevokeTokenSuccess() { .post(); val downgradeStatusCode = upgradeResponse.getStatusCode(); - assertThat(downgradeStatusCode).isEqualTo(HttpStatus.OK); + assertEquals(downgradeStatusCode, HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); val statusCode = checkTokenAfterUpgradeResponse.getStatusCode(); // Should be revoked - assertThat(statusCode).isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(statusCode, HttpStatus.UNAUTHORIZED); } /** @@ -187,14 +188,14 @@ public void denyPermissionFromUser_ExistingToken_RevokeTokenSuccess() { .post(); val denyStatusCode = upgradeResponse.getStatusCode(); - assertThat(denyStatusCode).isEqualTo(HttpStatus.OK); + assertEquals(denyStatusCode, HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); val statusCode = checkTokenAfterUpgradeResponse.getStatusCode(); // Should be revoked - assertThat(statusCode).isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(statusCode, HttpStatus.UNAUTHORIZED); } /** @@ -220,13 +221,13 @@ public void deleteGroupPermission_ExistingToken_RevokeTokenSuccess() { initStringRequest() .endpoint("/groups/%s/permissions/%s", group.getId(), permissionId) .delete(); - assertThat(deletePermissionResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(deletePermissionResponse.getStatusCode(), HttpStatus.OK); val checkTokenAfterDeleteResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be revoked - assertThat(checkTokenAfterDeleteResponse.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(checkTokenAfterDeleteResponse.getStatusCode(), HttpStatus.UNAUTHORIZED); } /** @@ -251,13 +252,13 @@ public void upgradeGroupPermission_ExistingToken_KeepTokenSuccess() { .endpoint("/groups/%s/permissions", group.getId().toString()) .body(permissionUpgradeRequest) .post(); - assertThat(upgradeResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(upgradeResponse.getStatusCode(), HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be valid - assertThat(checkTokenAfterUpgradeResponse.getStatusCode()).isEqualTo(HttpStatus.MULTI_STATUS); + assertEquals(checkTokenAfterUpgradeResponse.getStatusCode(), HttpStatus.MULTI_STATUS); } /** @@ -281,13 +282,13 @@ public void downgradeGroupPermission_ExistingToken_RevokeTokenSuccess() { .endpoint("/groups/%s/permissions", group.getId().toString()) .body(permissionDowngradeRequest) .post(); - assertThat(downgradeResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(downgradeResponse.getStatusCode(), HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be revoked - assertThat(checkTokenAfterUpgradeResponse.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(checkTokenAfterUpgradeResponse.getStatusCode(), HttpStatus.UNAUTHORIZED); } /** @@ -311,13 +312,13 @@ public void denyGroupPermission_ExistingToken_RevokeTokenSuccess() { .endpoint("/groups/%s/permissions", group.getId().toString()) .body(permissionDenyRequest) .post(); - assertThat(denyResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(denyResponse.getStatusCode(), HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be revoked - assertThat(checkTokenAfterUpgradeResponse.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(checkTokenAfterUpgradeResponse.getStatusCode(), HttpStatus.UNAUTHORIZED); } /** @@ -337,13 +338,13 @@ public void removeUserFromGroupPermission_ExistingToken_RevokeTokenSuccess() { initStringRequest() .endpoint("/users/%s/groups/%s", user.getId().toString(), group.getId().toString()) .delete(); - assertThat(removeUserFromGroupResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(removeUserFromGroupResponse.getStatusCode(), HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be revoked - assertThat(checkTokenAfterUpgradeResponse.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(checkTokenAfterUpgradeResponse.getStatusCode(), HttpStatus.UNAUTHORIZED); } /** @@ -376,13 +377,13 @@ public void addUserToDenyGroupPermission_ExistingToken_RevokeTokenSuccess() { .endpoint("/users/%s/groups", user.getId().toString()) .body(groupRequest) .post(); - assertThat(groupResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(groupResponse.getStatusCode(), HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be revoked - assertThat(checkTokenAfterUpgradeResponse.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(checkTokenAfterUpgradeResponse.getStatusCode(), HttpStatus.UNAUTHORIZED); } /** @@ -415,13 +416,13 @@ public void addUserToWriteGroupPermission_ExistingToken_KeepTokenSuccess() { .endpoint("/users/%s/groups", user.getId().toString()) .body(groupRequest) .post(); - assertThat(groupResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(groupResponse.getStatusCode(), HttpStatus.OK); val checkTokenAfterUpgradeResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be valid - assertThat(checkTokenAfterUpgradeResponse.getStatusCode()).isEqualTo(HttpStatus.MULTI_STATUS); + assertEquals(checkTokenAfterUpgradeResponse.getStatusCode(), HttpStatus.MULTI_STATUS); } /** @@ -441,14 +442,13 @@ public void deleteGroupWithUserAndPermission_ExistingToken_RevokeTokenSuccess() initStringRequest() .endpoint("/users/%s/groups/%s", user.getId().toString(), group.getId().toString()) .delete(); - assertThat(deleteGroupResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(deleteGroupResponse.getStatusCode(), HttpStatus.OK); val checkTokenAfterGroupDeleteResponse = initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); // Should be revoked - assertThat(checkTokenAfterGroupDeleteResponse.getStatusCode()) - .isEqualTo(HttpStatus.UNAUTHORIZED); + assertEquals(checkTokenAfterGroupDeleteResponse.getStatusCode(), HttpStatus.UNAUTHORIZED); } /** @@ -486,8 +486,8 @@ private String userPermissionTestSetup( initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); val checkStatusCode = checkTokenResponse.getStatusCode(); - assertThat(checkStatusCode).isEqualTo(HttpStatus.MULTI_STATUS); - assertThat(checkTokenResponse.getBody()).contains(policy.getName() + "." + tokenScopeSuffix); + assertEquals(checkStatusCode, HttpStatus.MULTI_STATUS); + assertTrue(checkTokenResponse.getBody().contains(policy.getName() + "." + tokenScopeSuffix)); return accessToken; } @@ -514,7 +514,7 @@ private String groupPermissionTestSetup( .endpoint("/users/%s/groups", user.getId().toString()) .body(groupRequest) .post(); - assertThat(groupResponse.getStatusCode()).isEqualTo(HttpStatus.OK); + assertEquals(groupResponse.getStatusCode(), HttpStatus.OK); // Create Group Permission val permissionRequest = @@ -539,8 +539,8 @@ private String groupPermissionTestSetup( initStringRequest(tokenHeaders).endpoint("/o/check_token?token=%s", accessToken).post(); val checkStatusCode = checkTokenResponse.getStatusCode(); - assertThat(checkStatusCode).isEqualTo(HttpStatus.MULTI_STATUS); - assertThat(checkTokenResponse.getBody()).contains(policy.getName() + "." + tokenScopeSuffix); + assertEquals(checkStatusCode, HttpStatus.MULTI_STATUS); + assertTrue(checkTokenResponse.getBody().contains(policy.getName() + "." + tokenScopeSuffix)); return accessToken; } diff --git a/src/test/java/bio/overture/ego/controller/UserControllerTest.java b/src/test/java/bio/overture/ego/controller/UserControllerTest.java index 667a63f54..b50ef56c7 100644 --- a/src/test/java/bio/overture/ego/controller/UserControllerTest.java +++ b/src/test/java/bio/overture/ego/controller/UserControllerTest.java @@ -17,32 +17,66 @@ package bio.overture.ego.controller; +import static bio.overture.ego.controller.resolver.PageableResolver.LIMIT; +import static bio.overture.ego.controller.resolver.PageableResolver.OFFSET; +import static bio.overture.ego.model.enums.JavaFields.PREFERREDLANGUAGE; +import static bio.overture.ego.model.enums.JavaFields.STATUS; +import static bio.overture.ego.model.enums.JavaFields.TOKENS; +import static bio.overture.ego.model.enums.JavaFields.TYPE; +import static bio.overture.ego.model.enums.JavaFields.USERAPPLICATIONS; +import static bio.overture.ego.model.enums.JavaFields.USERGROUPS; +import static bio.overture.ego.model.enums.JavaFields.USERPERMISSIONS; import static bio.overture.ego.model.enums.LanguageType.ENGLISH; import static bio.overture.ego.model.enums.StatusType.APPROVED; -import static bio.overture.ego.model.enums.StatusType.REJECTED; +import static bio.overture.ego.model.enums.StatusType.DISABLED; import static bio.overture.ego.model.enums.UserType.USER; +import static bio.overture.ego.utils.CollectionUtils.mapToImmutableSet; import static bio.overture.ego.utils.CollectionUtils.mapToSet; +import static bio.overture.ego.utils.CollectionUtils.repeatedCallsOf; import static bio.overture.ego.utils.Collectors.toImmutableList; -import static bio.overture.ego.utils.EntityTools.extractUserIds; -import static java.util.Arrays.asList; -import static java.util.Collections.singletonList; -import static net.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson; -import static org.assertj.core.api.Assertions.assertThat; +import static bio.overture.ego.utils.Collectors.toImmutableSet; +import static bio.overture.ego.utils.Converters.convertToIds; +import static bio.overture.ego.utils.EntityGenerator.generateNonExistentId; +import static bio.overture.ego.utils.EntityGenerator.generateNonExistentName; +import static bio.overture.ego.utils.EntityGenerator.randomEnum; +import static bio.overture.ego.utils.EntityGenerator.randomEnumExcluding; +import static bio.overture.ego.utils.EntityGenerator.randomStringNoSpaces; +import static bio.overture.ego.utils.Joiners.COMMA; +import static bio.overture.ego.utils.Streams.stream; +import static com.google.common.collect.Lists.newArrayList; +import static com.google.common.collect.Sets.newHashSet; +import static org.junit.Assert.*; import bio.overture.ego.AuthorizationServiceMain; import bio.overture.ego.model.dto.CreateUserRequest; import bio.overture.ego.model.dto.UpdateUserRequest; -import bio.overture.ego.model.join.UserGroup; +import bio.overture.ego.model.entity.Application; +import bio.overture.ego.model.entity.Group; +import bio.overture.ego.model.entity.Identifiable; +import bio.overture.ego.model.entity.Policy; +import bio.overture.ego.model.entity.User; +import bio.overture.ego.model.enums.LanguageType; +import bio.overture.ego.model.enums.StatusType; +import bio.overture.ego.model.enums.UserType; import bio.overture.ego.service.ApplicationService; import bio.overture.ego.service.GroupService; import bio.overture.ego.service.UserService; import bio.overture.ego.utils.EntityGenerator; -import bio.overture.ego.utils.Streams; import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.google.common.collect.Sets; +import java.util.List; +import java.util.Set; import java.util.UUID; +import lombok.Builder; +import lombok.NonNull; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import lombok.val; +import org.apache.commons.lang.NotImplementedException; +import org.hibernate.LazyInitializationException; +import org.junit.Assert; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; @@ -89,308 +123,913 @@ protected void beforeTest() { } @Test - public void addUser() { + @SneakyThrows + public void listUsersNoFilter() { + val numUsers = userService.getRepository().count(); - val user = - CreateUserRequest.builder() - .firstName("foo") - .lastName("bar") - .email("foobar@foo.bar") - .preferredLanguage(ENGLISH) - .type(USER) - .status(APPROVED) - .build(); + // Since previous test may introduce new users. If there are more users than the + // default page + // size, only a subset will be returned and could cause a test failure. + val response = initStringRequest().endpoint("/users?offset=0&limit=%s", numUsers).get(); - val response = initStringRequest().endpoint("/users").body(user).post(); + val responseStatus = response.getStatusCode(); + val responseJson = MAPPER.readTree(response.getBody()); + + assertEquals(responseStatus, HttpStatus.OK); + assertTrue(responseJson.get("count").asInt() >= 3); + assertTrue(responseJson.get("resultSet").isArray()); + + // Verify that the returned Users are the ones from the setup. + Iterable resultSetIterable = () -> responseJson.get("resultSet").iterator(); + val actualUserNames = + stream(resultSetIterable).map(j -> j.get("name").asText()).collect(toImmutableList()); + assertTrue( + actualUserNames.containsAll( + Set.of("FirstUser@domain.com", "SecondUser@domain.com", "ThirdUser@domain.com"))); + } + + @Test + @SneakyThrows + public void listUsersWithQuery() { + val response = initStringRequest().endpoint("/users?query=FirstUser").get(); val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + val responseJson = MAPPER.readTree(response.getBody()); + + assertEquals(responseStatus, HttpStatus.OK); + assertEquals(responseJson.get("count").asInt(), 1); + assertTrue(responseJson.get("resultSet").isArray()); + assertEquals( + responseJson.get("resultSet").elements().next().get("name").asText(), + "FirstUser@domain.com"); + } + + @Test + public void findUsers_FindAllQuery_Success() { + // Generate data + val data = generateUniqueTestUserData(); + + val numUsers = userService.getRepository().count(); + + // Assert that you can page users that were created + listUsersEndpointAnd() + .queryParam(LIMIT, numUsers) + .queryParam(OFFSET, 0) + .getAnd() + .assertPageResultsOfType(User.class) + .containsAll(data.getUsers()); + } + + @Test + @Ignore("low prority, but should be implemented") + public void findUsers_FindSomeQuery_Success() { + throw new NotImplementedException( + "need to implement the test 'findUsers_FindSomeQuery_Success'"); } @Test - public void addUniqueUser() { - val user1 = + public void createUser_NonExisting_Success() { + // Create unique name + val name = generateNonExistentName(userService); + + // Create request + val r = CreateUserRequest.builder() - .firstName("unique") - .lastName("unique") - .email("unique@unique.com") - .preferredLanguage(ENGLISH) - .type(USER) - .status(APPROVED) + .email(name + "@gmail.com") + .status(randomEnum(StatusType.class)) + .type(randomEnum(UserType.class)) + .preferredLanguage(randomEnum(LanguageType.class)) + .firstName(randomStringNoSpaces(10)) + .lastName(randomStringNoSpaces(10)) .build(); - val user2 = + + // Create the user + val user = createUserPostRequestAnd(r).extractOneEntity(User.class); + assertEquals(user.getEmail(), r.getEmail()); + assertEquals(user.getFirstName(), r.getFirstName()); + assertEquals(user.getLastName(), r.getLastName()); + assertEquals(user.getPreferredLanguage(), r.getPreferredLanguage()); + assertEquals(user.getType(), r.getType()); + assertEquals(user.getStatus(), r.getStatus()); + + // Assert the user can be read and matches the request data + val r1 = getUserEntityGetRequestAnd(user).extractOneEntity(User.class); + assertEquals(r1.getEmail(), r.getEmail()); + assertEquals(r1.getFirstName(), r.getFirstName()); + assertEquals(r1.getLastName(), r.getLastName()); + assertEquals(r1.getPreferredLanguage(), r.getPreferredLanguage()); + assertEquals(r1.getType(), r.getType()); + assertEquals(r1.getStatus(), r.getStatus()); + + assertEquals(r1.getEmail(), user.getEmail()); + assertEquals(r1.getFirstName(), user.getFirstName()); + assertEquals(r1.getLastName(), user.getLastName()); + assertEquals(r1.getPreferredLanguage(), user.getPreferredLanguage()); + assertEquals(r1.getType(), user.getType()); + assertEquals(r1.getStatus(), user.getStatus()); + } + + @Test + public void createUser_EmailAlreadyExists_Conflict() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Get an existing name + val existingName = getUserEntityGetRequestAnd(user0).extractOneEntity(User.class).getName(); + + // Create a request with an existing name + val r = CreateUserRequest.builder() - .firstName("unique") - .lastName("unique") - .email("unique@unique.com") - .preferredLanguage(ENGLISH) - .type(USER) - .status(APPROVED) + .email(existingName) + .status(randomEnum(StatusType.class)) + .type(randomEnum(UserType.class)) + .preferredLanguage(randomEnum(LanguageType.class)) + .firstName(randomStringNoSpaces(10)) + .lastName(randomStringNoSpaces(10)) .build(); - val response1 = initStringRequest().endpoint("/users").body(user1).post(); - val responseStatus1 = response1.getStatusCode(); + // Create the user and assert a conflict + createUserPostRequestAnd(r).assertConflict(); + } - assertThat(responseStatus1).isEqualTo(HttpStatus.OK); + @Test + public void deleteUser_NonExisting_NotFound() { + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); - // Return a 409 conflict because email already exists for a registered user. - val response2 = initStringRequest().endpoint("/users").body(user2).post(); - val responseStatus2 = response2.getStatusCode(); - assertThat(responseStatus2).isEqualTo(HttpStatus.CONFLICT); + // Assert that you cannot delete a non-existent id + deleteGroupDeleteRequestAnd(nonExistentId).assertNotFound(); } @Test - @SneakyThrows - public void getUser() { + public void deleteUserAndRelationshipsOnly_AlreadyExisting_Success() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Add applications to user + addApplicationsToUserPostRequestAnd(user0, data.getApplications()).assertOk(); + + // Add groups to user + addGroupsToUserPostRequestAnd(user0, data.getGroups()).assertOk(); + + // Check applications were added + getApplicationsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Application.class) + .containsExactlyInAnyOrderElementsOf(data.getApplications()); + + // Check groups were added + getGroupsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Group.class) + .containsExactlyInAnyOrderElementsOf(data.getGroups()); + + // Delete user + deleteUserDeleteRequestAnd(user0).assertOk(); + + // Check user was deleted + getUserEntityGetRequestAnd(user0).assertNotFound(); + + // Check applications exist + data.getApplications() + .forEach(application -> getApplicationEntityGetRequestAnd(application).assertOk()); + + // Check groups exist + data.getGroups().forEach(group -> getGroupEntityGetRequestAnd(group).assertOk()); + + // Check no users associated with applications + data.getApplications() + .forEach( + a -> + getUsersForApplicationGetRequestAnd(a) + .assertPageResultsOfType(User.class) + .isEmpty()); + + // Check no users associated with groups + data.getGroups() + .forEach( + g -> getUsersForGroupGetRequestAnd(g).assertPageResultsOfType(User.class).isEmpty()); + } + + @Test + public void getUser_ExistingUser_Success() { + // Generate user + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); - // Users created in setup - val userId = userService.getByName("FirstUser@domain.com").getId(); - val response = initStringRequest().endpoint("/users/%s", userId).get(); + // Assert actual and expected user are the same + getUserEntityGetRequestAnd(user0.getId()).assertEntityOfType(User.class).isEqualTo(user0); + } - val responseStatus = response.getStatusCode(); - val responseJson = MAPPER.readTree(response.getBody()); + @Test + public void getUser_NonExistentUser_NotFound() { + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); - assertThat(responseJson.get("firstName").asText()).isEqualTo("First"); - assertThat(responseJson.get("lastName").asText()).isEqualTo("User"); - assertThat(responseJson.get("name").asText()).isEqualTo("FirstUser@domain.com"); - assertThat(responseJson.get("preferredLanguage").asText()).isEqualTo(ENGLISH.toString()); - assertThat(responseJson.get("status").asText()).isEqualTo(APPROVED.toString()); - assertThat(responseJson.get("id").asText()).isEqualTo(userId.toString()); + // Assert that you cannot get a non-existent id + getUserEntityGetRequestAnd(nonExistentId).assertNotFound(); } @Test - public void getUser404() { - val response = initStringRequest().endpoint("/users/%s", UUID.randomUUID().toString()).get(); + public void UUIDValidation_MalformedUUID_BadRequest() { + val data = generateUniqueTestUserData(); + val badUUID = "123sksk"; + val applicationIds = convertToIds(data.getApplications()); + val groupIds = convertToIds(data.getGroups()); + val randomPermIds = repeatedCallsOf(UUID::randomUUID, 3); + + initStringRequest().endpoint("/users/%s", badUUID).deleteAnd().assertBadRequest(); + initStringRequest().endpoint("/users/%s", badUUID).getAnd().assertBadRequest(); + initStringRequest().endpoint("/users/%s", badUUID).putAnd().assertBadRequest(); + + initStringRequest().endpoint("/users/%s/applications", badUUID).getAnd().assertBadRequest(); + initStringRequest().endpoint("/users/%s/applications", badUUID).postAnd().assertBadRequest(); + initStringRequest() + .endpoint("/users/%s/applications/%s", badUUID, COMMA.join(applicationIds)) + .deleteAnd() + .assertBadRequest(); - val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.NOT_FOUND); + initStringRequest().endpoint("/users/%s/groups", badUUID).getAnd().assertBadRequest(); + initStringRequest().endpoint("/users/%s/groups", badUUID).postAnd().assertBadRequest(); + initStringRequest() + .endpoint("/users/%s/groups/%s", badUUID, COMMA.join(groupIds)) + .deleteAnd() + .assertBadRequest(); + + initStringRequest().endpoint("/users/%s/permissions", badUUID).getAnd().assertBadRequest(); + initStringRequest().endpoint("/users/%s/permissions", badUUID).postAnd().assertBadRequest(); + initStringRequest() + .endpoint("/users/%s/permissions/%s", badUUID, COMMA.join(randomPermIds)) + .deleteAnd() + .assertBadRequest(); } @Test @SneakyThrows - public void listUsersNoFilter() { - val numUsers = userService.getRepository().count(); + public void getManyUsers_noRelations() { - // Since previous test may introduce new users. If there are more users than the default page - // size, only a subset will be returned and could cause a test failure. - val response = initStringRequest().endpoint("/users?offset=0&limit=%s", numUsers).get(); + final int testUserCount = 3; - val responseStatus = response.getStatusCode(); - val responseJson = MAPPER.readTree(response.getBody()); + // Creating new users cause we need their Ids as inputs in this test + val users = repeatedCallsOf(() -> entityGenerator.generateRandomUser(), testUserCount); + val userIds = mapToImmutableSet(users, User::getId); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); - assertThat(responseJson.get("count").asInt()).isGreaterThanOrEqualTo(3); - assertThat(responseJson.get("resultSet").isArray()).isTrue(); + val results = userService.getMany(userIds, false, false, false); - // Verify that the returned Users are the ones from the setup. - Iterable resultSetIterable = () -> responseJson.get("resultSet").iterator(); - val actualUserNames = - Streams.stream(resultSetIterable) - .map(j -> j.get("name").asText()) - .collect(toImmutableList()); - assertThat(actualUserNames) - .contains("FirstUser@domain.com", "SecondUser@domain.com", "ThirdUser@domain.com"); + assertEquals(results.size(), testUserCount); + + val testUser = results.iterator().next(); + + try { + testUser.getUserGroups().iterator().next().getId(); + Assert.fail("No exception thrown accessing groups that were not fetched for user."); + } catch (Exception e) { + assertTrue(e instanceof LazyInitializationException); + } + + try { + testUser.getUserApplications().iterator().next().getId(); + Assert.fail("No exception thrown accessing applications that were not fetched for user."); + } catch (Exception e) { + assertTrue(e instanceof LazyInitializationException); + } + + try { + testUser.getUserPermissions().iterator().next().getId(); + Assert.fail("No exception thrown accessing permissions that were not fetched for user."); + } catch (Exception e) { + assertTrue(e instanceof LazyInitializationException); + } } @Test @SneakyThrows - public void listUsersWithQuery() { - val response = initStringRequest().endpoint("/users?query=FirstUser").get(); + public void getManyUsers_withRelations() { + + final int testUserCount = 3; + + // Creating new users cause we need their Ids as inputs in this test + val users = repeatedCallsOf(() -> entityGenerator.generateRandomUser(), testUserCount); + val userIds = mapToImmutableSet(users, User::getId); + + val results = userService.getMany(userIds, true, true, true); + + assertEquals(results.size(), testUserCount); + + results + .iterator() + .forEachRemaining( + user -> { + try { + assertNotNull(user.getUserGroups()); + assertTrue(user.getUserGroups().isEmpty()); + assertNotNull(user.getUserPermissions()); + assertTrue(user.getUserPermissions().isEmpty()); + assertNotNull(user.getUserApplications()); + assertTrue(user.getUserApplications().isEmpty()); + } catch (Exception e) { + e.printStackTrace(); + } + }); + } - val responseStatus = response.getStatusCode(); - val responseJson = MAPPER.readTree(response.getBody()); + @Test + @SneakyThrows + public void updateUser_ExistingUser_Success() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // create update request 1 + val uniqueName = generateNonExistentName(userService); + val email = uniqueName + "@xyz.com"; + val r1 = UpdateUserRequest.builder().firstName("aNewFirstName").email(email).build(); + + // Update user + partialUpdateUserPutRequestAnd(user0.getId(), r1).assertOk(); + + // Assert update was correct + val actualUser1 = getUserEntityGetRequestAnd(user0).extractOneEntity(User.class); + assertEquals(actualUser1.getFirstName(), r1.getFirstName()); + assertEquals(actualUser1.getEmail(), r1.getEmail()); + assertEquals(actualUser1.getName(), r1.getEmail()); + + // create update request 2 + val r2 = + UpdateUserRequest.builder() + .status(randomEnumExcluding(StatusType.class, user0.getStatus())) + .type(randomEnumExcluding(UserType.class, user0.getType())) + .preferredLanguage( + randomEnumExcluding(LanguageType.class, user0.getPreferredLanguage())) + .build(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); - assertThat(responseJson.get("count").asInt()).isEqualTo(1); - assertThat(responseJson.get("resultSet").isArray()).isTrue(); - assertThat(responseJson.get("resultSet").elements().next().get("name").asText()) - .isEqualTo("FirstUser@domain.com"); + // Update user + partialUpdateUserPutRequestAnd(user0.getId(), r2).assertOk(); + + // Assert update was correct + val actualUser2 = getUserEntityGetRequestAnd(user0).extractOneEntity(User.class); + assertEquals(actualUser2.getStatus(), r2.getStatus()); + assertEquals(actualUser2.getType(), r2.getType()); + assertEquals(actualUser2.getPreferredLanguage(), r2.getPreferredLanguage()); } @Test - public void updateUser() { - val user = entityGenerator.setupUser("update test"); - val update = UpdateUserRequest.builder().status(REJECTED).build(); + public void updateUser_NonExistentUser_NotFound() { + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); + + val dummyUpdateUserRequest = UpdateUserRequest.builder().build(); - val response = initStringRequest().endpoint("/users/%s", user.getId()).body(update).put(); + // Assert that you cannot get a non-existent id + partialUpdateUserPutRequestAnd(nonExistentId, dummyUpdateUserRequest).assertNotFound(); + } - val responseBody = response.getBody(); + @Test + public void updateUser_EmailAlreadyExists_Conflict() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + val user1 = data.getUsers().get(1); + + // Assumptions + assertEquals(user0.getName(), user0.getEmail()); + assertEquals(user1.getName(), user1.getEmail()); + + // Create update request with same email + val r1 = + UpdateUserRequest.builder() + .email(user1.getName()) + .status(randomEnumExcluding(StatusType.class, user0.getStatus())) + .build(); - HttpStatus responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); - assertThatJson(responseBody).node("id").isEqualTo(user.getId()); - assertThatJson(responseBody).node("status").isEqualTo(REJECTED.toString()); + // Assert that a CONFLICT error occurs when trying to update a user with a name + // that already + // exists + partialUpdateUserPutRequestAnd(user0.getId(), r1).assertConflict(); } @Test - @SneakyThrows - public void addGroupToUser() { - val userId = entityGenerator.setupUser("Group1 User").getId(); - val groupId = entityGenerator.setupGroup("Addone Group").getId().toString(); + public void statusValidation_MalformedStatus_BadRequest() { + val invalidStatus = "something123"; + val match = stream(StatusType.values()).anyMatch(x -> x.toString().equals(invalidStatus)); + assertFalse(match); - val response = - initStringRequest() - .endpoint("/users/%s/groups", userId) - .body(singletonList(groupId)) - .post(); + val data = generateUniqueTestUserData(); + val user = data.getUsers().get(0); - val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + // Assert createUsers + val templateR1 = + CreateUserRequest.builder() + .email(generateNonExistentName(userService) + "@xyz.com") + .type(USER) + .lastName("") + .lastName("") + .preferredLanguage(ENGLISH) + .build(); + val r1 = ((ObjectNode) MAPPER.valueToTree(templateR1)).put(STATUS, invalidStatus); + initStringRequest().endpoint("/users").body(r1).postAnd().assertBadRequest(); - val groupResponse = initStringRequest().endpoint("/users/%s/groups", userId).get(); + // Assert updateUser + val templateR2 = + UpdateUserRequest.builder() + .email(generateNonExistentName(userService) + "@xyz.com") + .type(USER) + .preferredLanguage(ENGLISH) + .build(); + val r2 = ((ObjectNode) MAPPER.valueToTree(templateR2)).put(STATUS, invalidStatus); + initStringRequest().endpoint("/users/%s", user.getId()).body(r2).putAnd().assertBadRequest(); + } + + @Test + public void typeValidation_MalformedType_BadRequest() { + val invalidType = "something123"; + val match = stream(UserType.values()).anyMatch(x -> x.toString().equals(invalidType)); + assertFalse(match); - val groupResponseStatus = groupResponse.getStatusCode(); - assertThat(groupResponseStatus).isEqualTo(HttpStatus.OK); + val data = generateUniqueTestUserData(); + val user = data.getUsers().get(0); - val groupResponseJson = MAPPER.readTree(groupResponse.getBody()); - assertThat(groupResponseJson.get("count").asInt()).isEqualTo(1); - assertThat(groupResponseJson.get("resultSet").elements().next().get("id").asText()) - .isEqualTo(groupId); + // Assert createUsers + val templateR1 = + CreateUserRequest.builder() + .email(generateNonExistentName(userService) + "@xyz.com") + .status(APPROVED) + .preferredLanguage(ENGLISH) + .firstName("") + .lastName("") + .build(); + val r1 = ((ObjectNode) MAPPER.valueToTree(templateR1)).put(TYPE, invalidType); + initStringRequest().endpoint("/users").body(r1).postAnd().assertBadRequest(); + + // Assert updateUser + val templateR2 = + UpdateUserRequest.builder() + .email(generateNonExistentName(userService) + "@xyz.com") + .status(DISABLED) + .preferredLanguage(ENGLISH) + .build(); + val r2 = ((ObjectNode) MAPPER.valueToTree(templateR2)).put(TYPE, invalidType); + initStringRequest().endpoint("/users/%s", user.getId()).body(r2).putAnd().assertBadRequest(); } @Test - @SneakyThrows - public void deleteGroupFromUser() { - val userId = entityGenerator.setupUser("DeleteGroup User").getId(); - val deleteGroup = entityGenerator.setupGroup("Delete One Group").getId().toString(); - val remainGroup = entityGenerator.setupGroup("Don't Delete This One").getId().toString(); + public void preferredLanguageValidation_MalformedPreferredLanguage_BadRequest() { + val invalidLanguage = "something123"; + val match = stream(LanguageType.values()).anyMatch(x -> x.toString().equals(invalidLanguage)); + assertFalse(match); - initStringRequest() - .endpoint("/users/%s/groups", userId) - .body(asList(deleteGroup, remainGroup)) - .post(); + val data = generateUniqueTestUserData(); + val user = data.getUsers().get(0); - val groupResponse = initStringRequest().endpoint("/users/%s/groups", userId).get(); + // Assert createUsers + val templateR1 = + CreateUserRequest.builder() + .email(generateNonExistentName(userService) + "@xyz.com") + .status(APPROVED) + .type(USER) + .firstName("") + .lastName("") + .build(); + val r1 = ((ObjectNode) MAPPER.valueToTree(templateR1)).put(PREFERREDLANGUAGE, invalidLanguage); + initStringRequest().endpoint("/users").body(r1).postAnd().assertBadRequest(); + + // Assert updateUser + val templateR2 = + UpdateUserRequest.builder() + .email(generateNonExistentName(userService) + "@xyz.com") + .status(DISABLED) + .type(USER) + .build(); + val r2 = ((ObjectNode) MAPPER.valueToTree(templateR2)).put(PREFERREDLANGUAGE, invalidLanguage); + initStringRequest().endpoint("/users/%s", user.getId()).body(r2).putAnd().assertBadRequest(); + } - val groupResponseStatus = groupResponse.getStatusCode(); - assertThat(groupResponseStatus).isEqualTo(HttpStatus.OK); - val groupResponseJson = MAPPER.readTree(groupResponse.getBody()); - assertThat(groupResponseJson.get("count").asInt()).isEqualTo(2); + @Test + public void getApplicationsFromUser_FindAllQuery_Success() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Associate applications with user + addApplicationsToUserPostRequestAnd(user0, data.getApplications()).assertOk(); + + // get Applications for user, and assert it has the expected applications + getApplicationsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Application.class) + .containsExactlyInAnyOrderElementsOf(data.getApplications()); + } - val deleteResponse = - initStringRequest().endpoint("/users/%s/groups/%s", userId, deleteGroup).delete(); + @Test + public void getApplicationsFromUser_NonExistentUser_NotFound() { + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); - val deleteResponseStatus = deleteResponse.getStatusCode(); - assertThat(deleteResponseStatus).isEqualTo(HttpStatus.OK); + // Assert that getting the applications for a non-existent user id results in a + // NOT_FOUND error + getApplicationsForUserGetRequestAnd(nonExistentId).assertNotFound(); + } - val secondGetResponse = initStringRequest().endpoint("/users/%s/groups", userId).get(); - val secondGetResponseStatus = deleteResponse.getStatusCode(); - assertThat(secondGetResponseStatus).isEqualTo(HttpStatus.OK); - val secondGetResponseJson = MAPPER.readTree(secondGetResponse.getBody()); - assertThat(secondGetResponseJson.get("count").asInt()).isEqualTo(1); - assertThat(secondGetResponseJson.get("resultSet").elements().next().get("id").asText()) - .isEqualTo(remainGroup); + @Test + @Ignore("low priority, but should be implemented") + public void getApplicationsFromUser_FindSomeQuery_Success() { + throw new NotImplementedException("need to implement"); } @Test - @SneakyThrows - public void addApplicationToUser() { - val userId = entityGenerator.setupUser("AddApp1 User").getId(); - val appId = entityGenerator.setupApplication("app1").getId().toString(); + public void addApplicationsToUser_NonExistentUser_NotFound() { + // Generate data + val data = generateUniqueTestUserData(); + val existingApplicationIds = convertToIds(data.getApplications()); - val response = - initStringRequest() - .endpoint("/users/%s/applications", userId) - .body(singletonList(appId)) - .post(); + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); - val responseStatus = response.getStatusCode(); - assertThat(responseStatus).isEqualTo(HttpStatus.OK); + // Assert NOT_FOUND thrown when adding existing applications to a non-existing + // user + addApplicationsToUserPostRequestAnd(nonExistentId, existingApplicationIds).assertNotFound(); + } - val appResponse = initStringRequest().endpoint("/users/%s/applications", userId).get(); + @Test + public void addApplicationsToUser_AllExistingUnassociatedApplications_Success() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Assert the user has no applications + getApplicationsForUserGetRequestAnd(user0).assertPageResultsOfType(Application.class).isEmpty(); + + // Add applications to user and assert the response is equal to the user + addApplicationsToUserPostRequestAnd(user0, data.getApplications()) + .assertEntityOfType(User.class) + .isEqualToIgnoringGivenFields(user0, USERPERMISSIONS, TOKENS, USERGROUPS, USERAPPLICATIONS); + + // Assert the user has all the applications + getApplicationsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Application.class) + .containsExactlyInAnyOrderElementsOf(data.getApplications()); + } - val appResponseStatus = appResponse.getStatusCode(); - assertThat(appResponseStatus).isEqualTo(HttpStatus.OK); + @Test + public void addApplicationsToUser_SomeExistingApplicationsButAllUnassociated_NotFound() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Assert NOT_FOUND thrown when adding non-existing applications to an existing + // user + val someExistingApplicationIds = mapToSet(data.getApplications(), Identifiable::getId); + val nonExistingApplicationIds = + repeatedCallsOf(() -> generateNonExistentId(applicationService), 10).stream() + .collect(toImmutableSet()); + someExistingApplicationIds.addAll(nonExistingApplicationIds); + + addApplicationsToUserPostRequestAnd(user0.getId(), someExistingApplicationIds).assertNotFound(); + } - val groupResponseJson = MAPPER.readTree(appResponse.getBody()); - assertThat(groupResponseJson.get("count").asInt()).isEqualTo(1); - assertThat(groupResponseJson.get("resultSet").elements().next().get("id").asText()) - .isEqualTo(appId); + @Test + public void addApplicationsToUser_AllExistingApplicationsButSomeAlreadyAssociated_Conflict() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + val app0 = data.getApplications().get(0); + val app1 = data.getApplications().get(1); + + // Assert the user has no applications + getApplicationsForUserGetRequestAnd(user0).assertPageResultsOfType(Application.class).isEmpty(); + + // Add app00 to user and assert the response is equal to the user + addApplicationsToUserPostRequestAnd(user0, newArrayList(app0)) + .assertEntityOfType(User.class) + .isEqualToIgnoringGivenFields(user0, USERPERMISSIONS, TOKENS, USERGROUPS, USERAPPLICATIONS); + + // Assert the user has app0 + getApplicationsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Application.class) + .containsExactlyInAnyOrder(app0); + + // Add app0 and app1 to user and assert a CONFLICT error is returned since app0 + // was already + // associated + addApplicationsToUserPostRequestAnd(user0, newArrayList(app0, app1)).assertConflict(); } @Test - @SneakyThrows - public void deleteApplicationFromUser() { - val userId = entityGenerator.setupUser("App2 User").getId(); - val deleteApp = entityGenerator.setupApplication("deleteApp").getId().toString(); - val remainApp = entityGenerator.setupApplication("remainApp").getId().toString(); + public void removeApplicationsFromUser_AllExistingAssociatedApplications_Success() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Assert the user has no applications + getApplicationsForUserGetRequestAnd(user0).assertPageResultsOfType(Application.class).isEmpty(); + + // Add apps to user and assert user is returned + addApplicationsToUserPostRequestAnd(user0, data.getApplications()) + .assertEntityOfType(User.class) + .isEqualToIgnoringGivenFields(user0, USERPERMISSIONS, TOKENS, USERGROUPS, USERAPPLICATIONS); + + // Assert the user has all the applications + getApplicationsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Application.class) + .containsExactlyInAnyOrderElementsOf(data.getApplications()); + + // Delete applications from user + deleteApplicationsFromUserDeleteRequestAnd(user0, data.getApplications()).assertOk(); - val appResponse = - initStringRequest() - .endpoint("/users/%s/applications", userId) - .body(asList(deleteApp, remainApp)) - .post(); + // Assert the user has no applications + getApplicationsForUserGetRequestAnd(user0).assertPageResultsOfType(Application.class).isEmpty(); + } + + @Test + public void removeApplicationsFromUser_AllExistingApplicationsButSomeNotAssociated_NotFound() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + val app0 = data.getApplications().get(0); + val app1 = data.getApplications().get(1); + + // Assert the user has no applications + getApplicationsForUserGetRequestAnd(user0).assertPageResultsOfType(Application.class).isEmpty(); + + // Add apps to user and assert user is returned + addApplicationsToUserPostRequestAnd(user0, newArrayList(app0)) + .assertEntityOfType(User.class) + .isEqualToIgnoringGivenFields(user0, USERPERMISSIONS, TOKENS, USERGROUPS, USERAPPLICATIONS); + + // Assert the user is associated with app0 + getApplicationsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Application.class) + .containsExactlyInAnyOrder(app0); + + // Delete applications from user + deleteApplicationsFromUserDeleteRequestAnd(user0, newArrayList(app0, app1)).assertNotFound(); + } + + @Test + public void removeApplicationsFromUser_SomeNonExistingApplicationsButAllAssociated_NotFound() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Assert the user has no applications + getApplicationsForUserGetRequestAnd(user0).assertPageResultsOfType(Application.class).isEmpty(); + + // Add all apps to user + addApplicationsToUserPostRequestAnd(user0, data.getApplications()) + .assertEntityOfType(User.class) + .isEqualToIgnoringGivenFields(user0, USERPERMISSIONS, TOKENS, USERGROUPS, USERAPPLICATIONS); + + // Assert the apps were added + getApplicationsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Application.class) + .containsExactlyInAnyOrderElementsOf(data.getApplications()); + + // Create non existing application id + val nonExistingApplicationId = generateNonExistentId(applicationService); + getApplicationEntityGetRequestAnd(nonExistingApplicationId).assertNotFound(); + + // Create a list of application ids with some not existing + val someExistingApplicationsIds = Sets.newHashSet(); + someExistingApplicationsIds.addAll(convertToIds(data.getApplications())); + someExistingApplicationsIds.add(nonExistingApplicationId); + + // Delete applications from user and assert a NOT_FOUND error was returned due + // to the + // non-existing application id + deleteApplicationsFromUserDeleteRequestAnd(user0.getId(), someExistingApplicationsIds) + .assertNotFound(); + } + + @Test + public void removeApplicationsFromUser_NonExistentUser_NotFound() { + // Generate data + val data = generateUniqueTestUserData(); + val existingApplicationIds = convertToIds(data.getApplications()); - log.info(appResponse.getBody()); + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); - val appResponseStatus = appResponse.getStatusCode(); - assertThat(appResponseStatus).isEqualTo(HttpStatus.OK); + // Assert NOT_FOUND thrown when deleting applications to a non-existing user + deleteApplicationsFromUserDeleteRequestAnd(nonExistentId, existingApplicationIds) + .assertNotFound(); + } + + @Test + public void getGroupsFromUser_FindAllQuery_Success() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); - val deleteResponse = - initStringRequest().endpoint("/users/%s/applications/%s", userId, deleteApp).delete(); + // Assert no groups are associated with the user + getGroupsForUserGetRequestAnd(user0).assertPageResultsOfType(Group.class).isEmpty(); - val deleteResponseStatus = deleteResponse.getStatusCode(); - assertThat(deleteResponseStatus).isEqualTo(HttpStatus.OK); + // Add groups to the user + addGroupsToUserPostRequestAnd(user0, data.getGroups()).assertOk(); + + // Assert all the groups are associated with the user + getGroupsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Group.class) + .containsExactlyInAnyOrderElementsOf(data.getGroups()); + } + + @Test + public void getGroupsFromUser_NonExistentUser_NotFound() { + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); + + // Assert that a NOT_FOUND error is thrown when attempting to all groups for a + // non-existent user + getGroupsForUserGetRequestAnd(nonExistentId).assertNotFound(); + } + + @Test + @Ignore("low priority, but should be implemented") + public void getGroupsFromUser_FindSomeQuery_Success() { + throw new NotImplementedException( + "need to implement the test 'getGroupsFromUser_FindSomeQuery_Success'"); + } + + @Test + public void addGroupsToUser_NonExistentUser_NotFound() { + val data = generateUniqueTestUserData(); + val existingGroupIds = convertToIds(data.getGroups()); - val secondGetResponse = initStringRequest().endpoint("/users/%s/applications", userId).get(); + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); - val secondGetResponseStatus = deleteResponse.getStatusCode(); - assertThat(secondGetResponseStatus).isEqualTo(HttpStatus.OK); - val secondGetResponseJson = MAPPER.readTree(secondGetResponse.getBody()); - assertThat(secondGetResponseJson.get("count").asInt()).isEqualTo(1); - assertThat(secondGetResponseJson.get("resultSet").elements().next().get("id").asText()) - .isEqualTo(remainApp); + // Assert that a NOT_FOUND error is thrown when attempting to add existing + // groups to a + // non-existing user + addGroupsToUserPostRequestAnd(nonExistentId, existingGroupIds).assertNotFound(); } @Test + public void addGroupsToUser_AllExistingUnassociatedGroups_Success() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Assert user has no groups + getGroupsForUserGetRequestAnd(user0).assertPageResultsOfType(Group.class).isEmpty(); + + // Add groups to user and asser response is a user + addGroupsToUserPostRequestAnd(user0, data.getGroups()) + .assertEntityOfType(User.class) + .isEqualToIgnoringGivenFields(user0, USERPERMISSIONS, TOKENS, USERGROUPS, USERAPPLICATIONS); + + // Get groups for user and assert they are associated + getGroupsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Group.class) + .containsExactlyInAnyOrderElementsOf(data.getGroups()); + } + + @Test + public void addGroupsToUser_SomeExistingGroupsButAllUnassociated_NotFound() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Assert NOT_FOUND thrown when adding a mix of existing and non-existing + // applications to an + // existing user + val someExistingGroupIds = mapToSet(data.getGroups(), Identifiable::getId); + val nonExistingGroupIds = + repeatedCallsOf(() -> generateNonExistentId(groupService), 10).stream() + .collect(toImmutableSet()); + someExistingGroupIds.addAll(nonExistingGroupIds); + + addGroupsToUserPostRequestAnd(user0.getId(), someExistingGroupIds).assertNotFound(); + } + + @Test + public void addGroupsToUser_AllExistingGroupsButSomeAlreadyAssociated_Conflict() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + val group0 = data.getGroups().get(0); + val group1 = data.getGroups().get(1); + + // Assert user has no groups + getGroupsForUserGetRequestAnd(user0).assertPageResultsOfType(Group.class).isEmpty(); + + // Add group0 to user and assert response is a user + addGroupsToUserPostRequestAnd(user0, newArrayList(group0)) + .assertEntityOfType(User.class) + .isEqualToIgnoringGivenFields(user0, USERPERMISSIONS, TOKENS, USERGROUPS, USERAPPLICATIONS); + + // Get groups for user and assert they are associated only to group0 + getGroupsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Group.class) + .containsExactlyInAnyOrderElementsOf(newArrayList(group0)); + + // Add group0 and group1 to user and assert CONFLICT + addGroupsToUserPostRequestAnd(user0, newArrayList(group0, group1)).assertConflict(); + } + + @Test + public void removeGroupsFromUser_AllExistingAssociatedGroups_Success() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Add groups to user and assert response is a user + addGroupsToUserPostRequestAnd(user0, data.getGroups()) + .assertEntityOfType(User.class) + .isEqualToIgnoringGivenFields(user0, USERPERMISSIONS, TOKENS, USERGROUPS, USERAPPLICATIONS); + + // Assert groups were added + getGroupsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Group.class) + .containsExactlyInAnyOrderElementsOf(data.getGroups()); + + // Delete groups from user + deleteGroupsFromUserDeleteRequestAnd(user0, data.getGroups()).assertOk(); + + // Assert user does not have any groups associated + getGroupsForUserGetRequestAnd(user0).assertPageResultsOfType(Group.class).isEmpty(); + } + + @Test + public void removeGroupsFromUser_AllExistingGroupsButSomeNotAssociated_NotFound() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + val group0 = data.getGroups().get(0); + val group1 = data.getGroups().get(1); + + // Assert user has no groups + getGroupsForUserGetRequestAnd(user0).assertPageResultsOfType(Group.class).isEmpty(); + + // Add group0 only to user + addGroupsToUserPostRequestAnd(user0, newArrayList(group0)).assertOk(); + + // Assert group0 was added to user + getGroupsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Group.class) + .containsExactlyInAnyOrder(group0); + + // Attempt to delete group0 and group1 from user, and assert NOT_FOUND error + deleteGroupsFromUserDeleteRequestAnd(user0, newArrayList(group0, group1)).assertNotFound(); + } + + @Test + public void removeGroupsFromUser_SomeNonExistingGroupsButAllAssociated_NotFound() { + // Generate data + val data = generateUniqueTestUserData(); + val user0 = data.getUsers().get(0); + + // Assert no groups for user + getGroupsForUserGetRequestAnd(user0).assertPageResultsOfType(Group.class).isEmpty(); + + // Add all groups to user + addGroupsToUserPostRequestAnd(user0, data.getGroups()).assertOk(); + + // Assert groups were added to user + getGroupsForUserGetRequestAnd(user0) + .assertPageResultsOfType(Group.class) + .containsExactlyInAnyOrderElementsOf(data.getGroups()); + + // delete all groups plus some that dont exist and assert NOT_FOUND error + val groupIdsToDelete = newHashSet(convertToIds(data.getGroups())); + groupIdsToDelete.add(generateNonExistentId(groupService)); + deleteGroupsFromUserDeleteRequestAnd(user0.getId(), groupIdsToDelete).assertNotFound(); + } + + @Test + public void removeGroupsFromUser_NonExistentUser_NotFound() { + // Setup data + val data = generateUniqueTestUserData(); + val groupIds = convertToIds(data.getGroups()); + + // Create non existent user id + val nonExistentId = generateNonExistentId(userService); + + // Assert that a NOT_FOUND error is returned when trying to delete groups from a + // non-existent + // user + deleteGroupsFromUserDeleteRequestAnd(nonExistentId, groupIds).assertNotFound(); + } + @SneakyThrows - public void deleteUser() { - val userId = entityGenerator.setupUser("User ToDelete").getId(); - - // Add application to user - val appOne = entityGenerator.setupApplication("TempGroupApp"); - val appBody = singletonList(appOne.getId().toString()); - val addAppToUserResponse = - initStringRequest().endpoint("/users/%s/applications", userId).body(appBody).post(); - val addAppToUserResponseStatus = addAppToUserResponse.getStatusCode(); - assertThat(addAppToUserResponseStatus).isEqualTo(HttpStatus.OK); - - // Make sure user-application relationship is there - val appWithUser = applicationService.getByClientId("TempGroupApp"); - assertThat(extractUserIds(appWithUser.getUsers())).contains(userId); - - // Add group to user - val groupOne = entityGenerator.setupGroup("GroupOne"); - val groupBody = singletonList(groupOne.getId().toString()); - val addGroupToUserResponse = - initStringRequest().endpoint("/users/%s/groups", userId).body(groupBody).post(); - val addGroupToUserResponseStatus = addGroupToUserResponse.getStatusCode(); - assertThat(addGroupToUserResponseStatus).isEqualTo(HttpStatus.OK); - // Make sure user-group relationship is there - val expectedUserGroups = groupService.getByName("GroupOne").getUserGroups(); - val expectedUsers = mapToSet(expectedUserGroups, UserGroup::getUser); - assertThat(extractUserIds(expectedUsers)).contains(userId); - - // delete user - val deleteResponse = initStringRequest().endpoint("/users/%s", userId).delete(); - val deleteResponseStatus = deleteResponse.getStatusCode(); - assertThat(deleteResponseStatus).isEqualTo(HttpStatus.OK); - - // verify if user is deleted - val getUserResponse = initStringRequest().endpoint("/users/%s", userId).get(); - val getUserResponseStatus = getUserResponse.getStatusCode(); - assertThat(getUserResponseStatus).isEqualTo(HttpStatus.NOT_FOUND); - val jsonResponse = MAPPER.readTree(getUserResponse.getBody()); - assertThat(jsonResponse.get("error").asText()) - .isEqualTo(HttpStatus.NOT_FOUND.getReasonPhrase()); - - // check if user - group is deleted - val groupWithoutUser = groupService.getByName("GroupOne"); - assertThat(groupWithoutUser.getUserGroups()).isEmpty(); - - // make sure user - application is deleted - val appWithoutUser = applicationService.getByClientId("TempGroupApp"); - assertThat(appWithoutUser.getUsers()).isEmpty(); + private TestUserData generateUniqueTestUserData() { + val groups = repeatedCallsOf(() -> entityGenerator.generateRandomGroup(), 2); + val applications = repeatedCallsOf(() -> entityGenerator.generateRandomApplication(), 2); + val policies = repeatedCallsOf(() -> entityGenerator.generateRandomPolicy(), 2); + val users = repeatedCallsOf(() -> entityGenerator.generateRandomUser(), 2); + + return TestUserData.builder() + .users(users) + .groups(groups) + .applications(applications) + .policies(policies) + .build(); + } + + @lombok.Value + @Builder + public static class TestUserData { + @NonNull private final List users; + @NonNull private final List groups; + @NonNull private final List applications; + @NonNull private final List policies; } } diff --git a/src/test/java/bio/overture/ego/grpc/ProtoUtilsTest.java b/src/test/java/bio/overture/ego/grpc/ProtoUtilsTest.java new file mode 100644 index 000000000..3e729e066 --- /dev/null +++ b/src/test/java/bio/overture/ego/grpc/ProtoUtilsTest.java @@ -0,0 +1,201 @@ +package bio.overture.ego.grpc; + +import static bio.overture.ego.grpc.ProtoUtils.*; +import static java.util.stream.Collectors.toList; +import static org.junit.Assert.*; + +import bio.overture.ego.model.enums.JavaFields; +import java.util.Arrays; +import lombok.extern.slf4j.Slf4j; +import lombok.val; +import org.apache.commons.lang.StringUtils; +import org.junit.Test; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageImpl; +import org.springframework.data.domain.Sort; + +@Slf4j +public class ProtoUtilsTest { + + /** Proto String conversion convenience method */ + @Test + public void toProtoStringNullValue() { + val result = toProtoString(null); + assertNotNull(result); + assertEquals(result.getValue(), StringUtils.EMPTY); + } + + @Test + public void toProtoStringWithValue() { + // using Sort for test object since we already have this in the test class for use in other + // tests + val testObject = Sort.by(new Sort.Order(Sort.Direction.ASC, "createdAt")); + val result = toProtoString(testObject); + assertNotNull(result); + assertEquals(result.getValue(), testObject.toString()); + } + + /** Create Paged Response from Page */ + @Test + public void createPagedResponseForEmptyPage() { + val result = createPagedResponse(Page.empty(), 0); + assertFalse(result.hasNextPage()); + assertEquals(result.getMaxResults(), 0); + } + + @Test + public void createPagedResponseForCompleteSet() { + val dataList = Arrays.asList("1", "2", "3"); + val page = new PageImpl(dataList); + val result = createPagedResponse(page, 0); + assertFalse(result.hasNextPage()); + assertEquals(result.getMaxResults(), dataList.size()); + } + + @Test + public void createPagedResponseForPartialSet() { + val dataList = Arrays.asList("1", "2", "3"); + val pageable = + getPageable( + PagedRequest.newBuilder() + .setPageNumber(0) + .setPageSize(2) + .setOrderBy(StringUtils.EMPTY) + .build()); + + val pageData = dataList.stream().limit(2).collect(toList()); + val page = + new PageImpl(pageData, pageable, Integer.valueOf(dataList.size()).longValue()); + + val result = createPagedResponse(page, 0); + + assertTrue(result.hasNextPage()); + assertEquals(result.getNextPage().getValue(), 1); + assertEquals(result.getMaxResults(), dataList.size()); + } + + @Test + public void createPagedResponseForPartialSetWithDifferentPageNumber() { + val dataList = Arrays.asList("1", "2", "3", "4", "5"); + val pageable = + getPageable( + PagedRequest.newBuilder() + .setPageNumber(1) + .setPageSize(2) + .setOrderBy(StringUtils.EMPTY) + .build()); + + val pageData = dataList.stream().limit(2).collect(toList()); + val page = + new PageImpl(pageData, pageable, Integer.valueOf(dataList.size()).longValue()); + + val result = createPagedResponse(page, 1); + + assertTrue(result.hasNextPage()); + assertEquals(result.getNextPage().getValue(), 2); + } + + /** Pageable Resolution */ + @Test + public void getPageableForEmptyInput() { + val input = + PagedRequest.newBuilder() + .setPageNumber(0) + .setPageSize(0) + .setOrderBy(StringUtils.EMPTY) + .build(); + val result = getPageable(input); + + assertEquals( + result.getSort(), Sort.by(new Sort.Order(Sort.Direction.ASC, JavaFields.CREATEDAT))); + assertEquals(result.getOffset(), 0); + assertEquals( + result.getPageSize(), 100); // default page size value (set in ProtoUtils.getPageable) + } + + @Test + public void getPageableForSpecificInput() { + int page = 10; + int size = 30; + + val input = + PagedRequest.newBuilder() + .setPageNumber(page) + .setPageSize(size) + .setOrderBy("id desc, lastLogin, name asc") + .build(); + val result = getPageable(input); + + val expectedSort = + Sort.by( + new Sort.Order(Sort.Direction.DESC, "id"), + new Sort.Order(Sort.Direction.ASC, "lastLogin"), + new Sort.Order(Sort.Direction.ASC, "name")); + + assertEquals(result.getSort(), expectedSort); + assertEquals(result.getOffset(), page * size); + assertEquals(result.getPageSize(), 30); + } + + @Test + public void getPageableWithSizeOverLimit() { + int size = 9001; + + val input = + PagedRequest.newBuilder() + .setPageNumber(0) + .setPageSize(size) + .setOrderBy(StringUtils.EMPTY) + .build(); + val result = getPageable(input); + + assertEquals( + result.getPageSize(), 1000); // default max page size value (set in ProtoUtils.getPageable) + } + + /** Parse Sort Tests */ + @Test + public void parseSortWithEmptyInput() { + val sort = StringUtils.EMPTY; + val result = parseSort(sort); + + val expected = Sort.by(new Sort.Order(Sort.Direction.ASC, "createdAt")); + assertEquals(result, expected); + } + + @Test + public void parseSortWithDirectionOnly() { + // Test asc + val sortUp = "asc"; + val sortUpResult = parseSort(sortUp); + + val sortUpExpected = Sort.by(new Sort.Order(Sort.Direction.ASC, "createdAt")); + assertEquals(sortUpResult, sortUpExpected); + + // Test desc + val sortDown = "desc"; + val sortDownResult = parseSort(sortDown); + + val sortDownExpected = Sort.by(new Sort.Order(Sort.Direction.DESC, "createdAt")); + assertEquals(sortDownResult, sortDownExpected); + } + + @Test + public void parseSortWithMultipleInputs() { + val expected = + Sort.by( + new Sort.Order(Sort.Direction.DESC, "id"), + new Sort.Order(Sort.Direction.ASC, "lastLogin"), + new Sort.Order(Sort.Direction.ASC, "name")); + + // comma separated list with all direction indicators (asc, desc, no direction indicated) + val sort = "id desc, lastLogin, name asc"; + val result = parseSort(sort); + assertEquals(result, expected); + + // double check spacing variation, trailing commas, empty clauses + val sortCompact = "id desc,lastLogin,,name asc,"; + val resultCompact = parseSort(sortCompact); + assertEquals(resultCompact, expected); + } +} diff --git a/src/test/java/bio/overture/ego/grpc/service/UserServiceGrpcAuthTest.java b/src/test/java/bio/overture/ego/grpc/service/UserServiceGrpcAuthTest.java new file mode 100644 index 000000000..87067f1db --- /dev/null +++ b/src/test/java/bio/overture/ego/grpc/service/UserServiceGrpcAuthTest.java @@ -0,0 +1,232 @@ +package bio.overture.ego.grpc.service; + +import static bio.overture.ego.utils.EntityGenerator.generateNonExistentId; +import static io.grpc.Metadata.ASCII_STRING_MARSHALLER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; + +import bio.overture.ego.grpc.GetUserRequest; +import bio.overture.ego.grpc.ListUsersRequest; +import bio.overture.ego.grpc.UserServiceGrpc; +import bio.overture.ego.grpc.interceptor.AuthInterceptor; +import bio.overture.ego.model.dto.CreateApplicationRequest; +import bio.overture.ego.model.dto.CreateUserRequest; +import bio.overture.ego.model.entity.Application; +import bio.overture.ego.model.entity.User; +import bio.overture.ego.model.enums.ApplicationType; +import bio.overture.ego.model.enums.StatusType; +import bio.overture.ego.model.enums.UserType; +import bio.overture.ego.service.ApplicationService; +import bio.overture.ego.service.TokenService; +import bio.overture.ego.service.UserService; +import io.grpc.Channel; +import io.grpc.Metadata; +import io.grpc.ServerInterceptors; +import io.grpc.StatusRuntimeException; +import io.grpc.inprocess.InProcessChannelBuilder; +import io.grpc.inprocess.InProcessServerBuilder; +import io.grpc.stub.MetadataUtils; +import io.grpc.testing.GrpcCleanupRule; +import java.io.IOException; +import java.util.UUID; +import lombok.extern.slf4j.Slf4j; +import lombok.val; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; + +@Slf4j +@ActiveProfiles({"test", "auth"}) +@SpringBootTest +@RunWith(SpringRunner.class) +public class UserServiceGrpcAuthTest { + + private static String serverName; + private static Channel channel; + private static UserServiceGrpc.UserServiceBlockingStub stub; + private static boolean hasRunSetup = false; + + private static Metadata userAuthMeta = new Metadata(); + private static Metadata userAdminAuthMeta = new Metadata(); + private static Metadata appAuthMeta = new Metadata(); + private static Metadata emptyAuthMeta = new Metadata(); + private static Metadata.Key JWT_KEY = Metadata.Key.of("jwt", ASCII_STRING_MARSHALLER); + private static User testUser; + private static User testAdmin; + private static Application testApp; + + @Autowired private AuthInterceptor authInterceptor; + @Autowired private UserServiceGrpcImpl userServiceGrpc; + @Autowired private UserService userService; + @Autowired private ApplicationService appService; + @Autowired private TokenService tokenService; + + @Rule public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule(); + + @Before + public void init() throws IOException { + grpcSetup(); + testDataSetup(); + } + + public void grpcSetup() throws IOException { + + serverName = InProcessServerBuilder.generateName(); + // Create a client channel and register for automatic graceful shutdown. + channel = + grpcCleanup.register(InProcessChannelBuilder.forName(serverName).directExecutor().build()); + + // Create a server, add service with auth interceptor, start, and register for automatic + // graceful shutdown. + grpcCleanup.register( + InProcessServerBuilder.forName(serverName) + .directExecutor() + .addService(ServerInterceptors.intercept(userServiceGrpc, authInterceptor)) + .build() + .start()); + + stub = UserServiceGrpc.newBlockingStub(channel); + } + + public void testDataSetup() { + if (!hasRunSetup) { + hasRunSetup = true; + // Setup test data and meta data for auth + testUser = + userService.create( + CreateUserRequest.builder() + .status(StatusType.APPROVED) + .email("approvedUserGrpc@example.com") + .lastName("") + .firstName("") + .type(UserType.USER) + .build()); + userAuthMeta.put(JWT_KEY, tokenService.generateUserToken(testUser)); + + testAdmin = + userService.create( + CreateUserRequest.builder() + .status(StatusType.APPROVED) + .firstName("") + .lastName("") + .email("approvedAdminGrpc@example.com") + .type(UserType.ADMIN) + .build()); + userAdminAuthMeta.put(JWT_KEY, tokenService.generateUserToken(testAdmin)); + + testApp = + appService.create( + CreateApplicationRequest.builder() + .status(StatusType.APPROVED) + .type(ApplicationType.CLIENT) + .clientId("grpctest") + .clientSecret("grpctestsecret") + .redirectUri("http://test.example.com") + .name("grpctest") + .build()); + appAuthMeta.put(JWT_KEY, tokenService.generateAppToken(testApp)); + } + } + + @Test + public void getUser_noAuth_rejected() { + + val noAuthStub = MetadataUtils.attachHeaders(stub, emptyAuthMeta); + + // Test that the interceptor rejects this request + assertThatExceptionOfType(StatusRuntimeException.class) + .as("Request should be rejected due to missing JWT") + .isThrownBy( + () -> + noAuthStub.getUser( + GetUserRequest.newBuilder().setId(UUID.randomUUID().toString()).build())); + } + + @Test + public void getUser_userAuth_success() { + + val authStub = MetadataUtils.attachHeaders(stub, userAuthMeta); + + // Test that the interceptor rejects this request + val reply = + authStub.getUser(GetUserRequest.newBuilder().setId(testUser.getId().toString()).build()); + assertThat(reply.getId().getValue()).isEqualTo(testUser.getId().toString()); + } + + @Test + public void getUser_userAuth_rejectedForWrongUser() { + + val authStub = MetadataUtils.attachHeaders(stub, userAuthMeta); + UUID randomId = generateNonExistentId(userService); + + // Test that the interceptor rejects this request + assertThatExceptionOfType(StatusRuntimeException.class) + .as("User should not be allowed to access data of a different user.") + .isThrownBy( + () -> authStub.getUser(GetUserRequest.newBuilder().setId(randomId.toString()).build())); + } + + @Test + public void getUser_adminAuth_success() { + val authStub = MetadataUtils.attachHeaders(stub, userAdminAuthMeta); + + // Test that the interceptor rejects this request + val reply = + authStub.getUser(GetUserRequest.newBuilder().setId(testUser.getId().toString()).build()); + assertThat(reply.getId().getValue()).isEqualTo(testUser.getId().toString()); + } + + @Test + public void getUser_appAuth_success() { + val authStub = MetadataUtils.attachHeaders(stub, appAuthMeta); + + // Test that the interceptor rejects this request + val reply = + authStub.getUser(GetUserRequest.newBuilder().setId(testUser.getId().toString()).build()); + assertThat(reply.getId().getValue()).isEqualTo(testUser.getId().toString()); + } + + @Test + public void listUsers_noAuth_rejected() { + val authStub = MetadataUtils.attachHeaders(stub, emptyAuthMeta); + + // Test that the interceptor rejects this request + assertThatExceptionOfType(StatusRuntimeException.class) + .as("Request should be rejected due to missing JWT") + .isThrownBy(() -> authStub.listUsers(ListUsersRequest.newBuilder().build())); + } + + @Test + public void listUsers_userAuth_rejected() { + + val authStub = MetadataUtils.attachHeaders(stub, userAuthMeta); + + // Test that the interceptor rejects this request + assertThatExceptionOfType(StatusRuntimeException.class) + .as("Request should be rejected due to missing JWT") + .isThrownBy(() -> authStub.listUsers(ListUsersRequest.newBuilder().build())); + } + + @Test + public void listUsers_adminAuth_success() { + val authStub = MetadataUtils.attachHeaders(stub, userAdminAuthMeta); + + // Test that the interceptor rejects this request + val reply = authStub.listUsers(ListUsersRequest.newBuilder().build()); + assertThat(reply.getUsersCount()).isGreaterThanOrEqualTo(2); + } + + @Test + public void listUsers_appAuth_success() { + val authStub = MetadataUtils.attachHeaders(stub, appAuthMeta); + + // Test that the interceptor rejects this request + val reply = authStub.listUsers(ListUsersRequest.newBuilder().build()); + assertThat(reply.getUsersCount()).isGreaterThanOrEqualTo(2); + } +} diff --git a/src/test/java/bio/overture/ego/grpc/service/UserServiceGrpcTest.java b/src/test/java/bio/overture/ego/grpc/service/UserServiceGrpcTest.java new file mode 100644 index 000000000..d73b56a7b --- /dev/null +++ b/src/test/java/bio/overture/ego/grpc/service/UserServiceGrpcTest.java @@ -0,0 +1,220 @@ +package bio.overture.ego.grpc.service; + +import static bio.overture.ego.utils.CollectionUtils.repeatedCallsOf; +import static java.util.stream.Collectors.toList; +import static org.assertj.core.api.Assertions.assertThat; + +import bio.overture.ego.grpc.GetUserRequest; +import bio.overture.ego.grpc.ListUsersRequest; +import bio.overture.ego.grpc.PagedRequest; +import bio.overture.ego.grpc.UserServiceGrpc; +import bio.overture.ego.model.entity.Application; +import bio.overture.ego.model.entity.Group; +import bio.overture.ego.model.entity.User; +import bio.overture.ego.model.enums.AccessLevel; +import bio.overture.ego.service.UserService; +import bio.overture.ego.utils.EntityGenerator; +import io.grpc.Channel; +import io.grpc.inprocess.InProcessChannelBuilder; +import io.grpc.inprocess.InProcessServerBuilder; +import io.grpc.testing.GrpcCleanupRule; +import java.io.IOException; +import java.util.Collection; +import lombok.extern.slf4j.Slf4j; +import lombok.val; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; + +@Slf4j +@ActiveProfiles("test") +@SpringBootTest +@RunWith(SpringRunner.class) +public class UserServiceGrpcTest { + + private String serverName; + + private Channel channel; + + private UserServiceGrpc.UserServiceBlockingStub stub; + + // Test Data + private static boolean hasRunEntitySetup = false; + private static Collection testUsers; + private static Group groupWithUsers; + private static Application appWithUsers; + private static Collection usersWithGroup; + + @Autowired private EntityGenerator entityGenerator; + @Autowired UserServiceGrpcImpl userServiceGrpc; + @Autowired UserService userService; + + @Rule public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule(); + + @Before + public void before() throws IOException { + + // setUpInProcessGrpc + // Generate a unique in-process server name. + serverName = InProcessServerBuilder.generateName(); + // Create a client channel and register for automatic graceful shutdown. + channel = + grpcCleanup.register(InProcessChannelBuilder.forName(serverName).directExecutor().build()); + + // Create a server, add service, start, and register for automatic graceful shutdown. + grpcCleanup.register( + InProcessServerBuilder.forName(serverName) + .directExecutor() + .addService(userServiceGrpc) + .build() + .start()); + + stub = UserServiceGrpc.newBlockingStub(channel); + } + + @Before + public void setUpTestData() { + if (!hasRunEntitySetup) { + hasRunEntitySetup = true; + + // Lets add several users to test list functionality + val users = repeatedCallsOf(() -> entityGenerator.generateRandomUser(), 7); + + // Create a group and add it to first few users + val group = entityGenerator.setupGroup("GrpcUserTestGroup"); + usersWithGroup = users.stream().limit(4).collect(toList()); + groupWithUsers = entityGenerator.addUsersToGroup(usersWithGroup, group); + + // Create application and add it to last few users + val application = entityGenerator.setupApplication("GrpcUserTestApplicaiton"); + appWithUsers = + entityGenerator.addUsersToApplication( + users.stream().skip(3).collect(toList()), application); + + // Create policy and add permission to users + val groupPolicy = entityGenerator.setupSinglePolicy("GrpcUserTestPolicyForGroup"); + entityGenerator.setupGroupPermission(groupWithUsers, groupPolicy, AccessLevel.WRITE); + + val userPolicy = entityGenerator.setupSinglePolicy("GrpcUserTestPolicyForUser"); + entityGenerator.addPermissionToUsers(users, userPolicy, AccessLevel.READ); + + // Update testUsers now that they have relations + testUsers = + userService.getMany( + users.stream().map(user -> user.getId()).collect(toList()), true, true, true); + } + } + + @Test + public void getUser_success() { + + // Test with the user that has a group and application + val testUser = + testUsers.stream() + .filter( + user -> user.getUserGroups().size() > 0 && user.getUserApplications().size() > 0) + .findFirst() + .get(); + + val reply = + stub.getUser(GetUserRequest.newBuilder().setId(testUser.getId().toString()).build()); + + // Ensure all fields populated and value matches expected + assertThat(reply.getId().getValue()).isEqualTo(testUser.getId().toString()); + assertThat(reply.getFirstName().getValue()).isEqualTo(testUser.getFirstName()); + assertThat(reply.getLastName().getValue()).isEqualTo(testUser.getLastName()); + assertThat(reply.getEmail().getValue()).isEqualTo(testUser.getEmail()); + assertThat(reply.getStatus().getValue()).isEqualTo(testUser.getStatus().toString()); + assertThat(reply.getPreferredLanguage().getValue()) + .isEqualTo(testUser.getPreferredLanguage().toString()); + assertThat(reply.getType().getValue()).isEqualTo(testUser.getType().toString()); + + assertThat(reply.hasCreatedAt()).isTrue(); + assertThat(reply.hasLastLogin()).isTrue(); + + assertThat(reply.getApplicationsList().size()).isEqualTo(1); + assertThat(reply.getGroupsList().size()).isEqualTo(1); + assertThat(reply.getScopesList().size()).isEqualTo(2); + } + + @Test + public void listUser_emptyRequest() { + val request = ListUsersRequest.newBuilder().build(); + + val reply = stub.listUsers(request); + + // Ensure response includes pagination data + assertThat(reply.hasPage()).isTrue(); + assertThat(reply.getPage().getMaxResults()).isGreaterThanOrEqualTo(7); + + // Make sure we got users in the response (quick sanity check, not in depth) + assertThat(reply.getUsersCount()).isGreaterThanOrEqualTo(7); + val user = reply.getUsers(0); + assertThat(user.hasId()).isTrue(); + } + + @Test + public void listUser_pagedRequests() { + val pagedRequest1 = PagedRequest.newBuilder().setPageNumber(0).setPageSize(2); + val request1 = ListUsersRequest.newBuilder().setPage(pagedRequest1).build(); + + val reply1 = stub.listUsers(request1); + + // Correct number of users + assertThat(reply1.getUsersCount()).isEqualTo(2); + + // Correct pagination info + assertThat(reply1.hasPage()).isTrue(); + assertThat(reply1.getPage().getMaxResults()).isGreaterThanOrEqualTo(7); + assertThat(reply1.getPage().hasNextPage()).isTrue(); + assertThat(reply1.getPage().getNextPage().getValue()).isEqualTo(1); + + val user1 = reply1.getUsers(0); + + val pagedRequest2 = + PagedRequest.newBuilder() + .setPageNumber(reply1.getPage().getNextPage().getValue()) + .setPageSize(2); + val request2 = ListUsersRequest.newBuilder().setPage(pagedRequest2).build(); + + val reply2 = stub.listUsers(request2); + + // Correct pagination info + assertThat(reply2.hasPage()).isTrue(); + assertThat(reply2.getPage().getMaxResults()).isGreaterThanOrEqualTo(7); + assertThat(reply2.getPage().getNextPage().getValue()).isEqualTo(2); + + // different user (ensure we're not repeating user blocks) + val user2 = reply2.getUsers(0); + assertThat(user1.getId()).isNotEqualTo(user2.getId()); + } + + @Test + public void listUser_largePageRequest() { + val pagedRequest = PagedRequest.newBuilder().setPageNumber(0).setPageSize(1000000); + val request = ListUsersRequest.newBuilder().setPage(pagedRequest).build(); + + val reply = stub.listUsers(request); + + // Correct number of users + assertThat(reply.getUsersCount()).isGreaterThanOrEqualTo(7); + assertThat(reply.getUsersCount()).isLessThanOrEqualTo(1000); + } + + @Test + public void listUser_nonExistentPageNumberRequest() { + val pagedRequest = PagedRequest.newBuilder().setPageNumber(100000).setPageSize(1000000); + val request = ListUsersRequest.newBuilder().setPage(pagedRequest).build(); + + val reply = stub.listUsers(request); + + // Correct number of users + assertThat(reply.getUsersCount()).isEqualTo(0); + assertThat(reply.getPage().hasNextPage()).isFalse(); + } +} diff --git a/src/test/java/bio/overture/ego/service/ApplicationServiceTest.java b/src/test/java/bio/overture/ego/service/ApplicationServiceTest.java deleted file mode 100644 index 8ef45882f..000000000 --- a/src/test/java/bio/overture/ego/service/ApplicationServiceTest.java +++ /dev/null @@ -1,581 +0,0 @@ -package bio.overture.ego.service; - -import static bio.overture.ego.model.enums.StatusType.APPROVED; -import static bio.overture.ego.model.enums.StatusType.DISABLED; -import static bio.overture.ego.model.enums.StatusType.PENDING; -import static bio.overture.ego.model.enums.StatusType.REJECTED; -import static bio.overture.ego.service.ApplicationService.APPLICATION_CONVERTER; -import static bio.overture.ego.utils.CollectionUtils.setOf; -import static bio.overture.ego.utils.EntityGenerator.generateNonExistentId; -import static com.google.common.collect.Lists.newArrayList; -import static java.util.Collections.singletonList; -import static java.util.UUID.randomUUID; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatExceptionOfType; - -import bio.overture.ego.controller.resolver.PageableResolver; -import bio.overture.ego.model.dto.CreateApplicationRequest; -import bio.overture.ego.model.dto.UpdateApplicationRequest; -import bio.overture.ego.model.entity.Application; -import bio.overture.ego.model.exceptions.NotFoundException; -import bio.overture.ego.model.exceptions.UniqueViolationException; -import bio.overture.ego.model.search.SearchFilter; -import bio.overture.ego.repository.ApplicationRepository; -import bio.overture.ego.token.app.AppTokenClaims; -import bio.overture.ego.utils.EntityGenerator; -import java.util.Arrays; -import java.util.Collections; -import java.util.UUID; -import lombok.extern.slf4j.Slf4j; -import lombok.val; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.security.core.authority.SimpleGrantedAuthority; -import org.springframework.security.oauth2.provider.ClientRegistrationException; -import org.springframework.test.context.ActiveProfiles; -import org.springframework.test.context.junit4.SpringRunner; -import org.springframework.transaction.annotation.Transactional; - -@Slf4j -@SpringBootTest -@RunWith(SpringRunner.class) -@ActiveProfiles("test") -@Transactional -@Ignore("replace with controller tests.") -public class ApplicationServiceTest { - - @Autowired private ApplicationService applicationService; - @Autowired private ApplicationRepository applicationRepository; - - @Autowired private UserService userService; - - @Autowired private GroupService groupService; - - @Autowired private EntityGenerator entityGenerator; - - @Test - public void applicationConversion_UpdateApplicationRequest_Application() { - val id = randomUUID(); - val clientId = randomUUID().toString(); - val clientSecret = randomUUID().toString(); - val name = randomUUID().toString(); - val status = PENDING; - - val app = - Application.builder() - .id(id) - .clientId(clientId) - .clientSecret(clientSecret) - .name(name) - .status(status) - .redirectUri(null) - .users(null) - .build(); - - val newName = randomUUID().toString(); - assertThat(newName).isNotEqualTo(name); - val partialAppUpdateRequest = - UpdateApplicationRequest.builder() - .name(newName) - .status(APPROVED) - .redirectUri(randomUUID().toString()) - .build(); - APPLICATION_CONVERTER.updateApplication(partialAppUpdateRequest, app); - - assertThat(app.getDescription()).isNull(); - assertThat(app.getGroupApplications()).isEmpty(); - assertThat(app.getClientSecret()).isEqualTo(clientSecret); - assertThat(app.getClientId()).isEqualTo(clientId); - assertThat(app.getRedirectUri()).isNotNull(); - assertThat(app.getStatus()).isEqualTo(APPROVED); - assertThat(app.getId()).isEqualTo(id); - assertThat(app.getName()).isEqualTo(newName); - assertThat(app.getUsers()).isNull(); - } - - @Test - public void applicationConversion_CreateApplicationRequest_Application() { - val req = - CreateApplicationRequest.builder() - .status(PENDING) - .clientSecret(randomUUID().toString()) - .clientId(randomUUID().toString()) - .name(randomUUID().toString()) - .redirectUri("") - .build(); - val app = APPLICATION_CONVERTER.convertToApplication(req); - assertThat(app.getId()).isNull(); - assertThat(app.getGroupApplications()).isEmpty(); - assertThat(app.getClientId()).isEqualTo(req.getClientId()); - assertThat(app.getName()).isEqualTo(req.getName()); - assertThat(app.getUsers()).isEmpty(); - assertThat(app.getClientSecret()).isEqualTo(req.getClientSecret()); - assertThat(app.getStatus()).isEqualTo(req.getStatus()); - assertThat(app.getDescription()).isNull(); - assertThat(app.getRedirectUri()).isEqualTo(""); - } - - // Create - @Test - public void testCreate() { - val application = entityGenerator.setupApplication("123456"); - assertThat(application.getClientId()).isEqualTo("123456"); - } - - // Get - @Test - public void testGet() { - val application = entityGenerator.setupApplication("123456"); - val savedApplication = applicationService.getById(application.getId()); - assertThat(savedApplication.getClientId()).isEqualTo("123456"); - } - - @Test - public void testGetEntityNotFoundException() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> applicationService.getById(randomUUID())); - } - - @Test - public void testGetByName() { - entityGenerator.setupApplication("123456"); - val savedApplication = applicationService.getByName("Application 123456"); - assertThat(savedApplication.getClientId()).isEqualTo("123456"); - } - - @Test - public void testGetByNameAllCaps() { - entityGenerator.setupApplication("123456"); - val savedApplication = applicationService.getByName("APPLICATION 123456"); - assertThat(savedApplication.getClientId()).isEqualTo("123456"); - } - - @Test - @Ignore - public void testGetByNameNotFound() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> applicationService.getByName("Application 123456")); - } - - @Test - public void testGetByClientId() { - entityGenerator.setupApplication("123456"); - val savedApplication = applicationService.getByClientId("123456"); - assertThat(savedApplication.getClientId()).isEqualTo("123456"); - } - - @Test - @Ignore - public void testGetByClientIdNotFound() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> applicationService.getByClientId("123456")); - } - - // List - @Test - public void testListAppsNoFilters() { - val expectedApplications = newArrayList(applicationRepository.findAll()); - val actualApplicationsPage = - applicationService.listApps(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(actualApplicationsPage.getTotalElements()).isEqualTo(expectedApplications.size()); - assertThat(actualApplicationsPage.getContent()) - .containsExactlyInAnyOrderElementsOf(expectedApplications); - } - - @Test - public void testListAppsFiltered() { - entityGenerator.setupTestApplications(); - val clientIdFilter = new SearchFilter("clientId", "333333"); - val applications = - applicationService.listApps( - singletonList(clientIdFilter), new PageableResolver().getPageable()); - assertThat(applications.getTotalElements()).isEqualTo(1L); - assertThat(applications.getContent().get(0).getClientId()).isEqualTo("333333"); - } - - @Test - public void testListAppsFilteredEmptyResult() { - entityGenerator.setupTestApplications(); - val clientIdFilter = new SearchFilter("clientId", "666666"); - val applications = - applicationService.listApps( - singletonList(clientIdFilter), new PageableResolver().getPageable()); - assertThat(applications.getTotalElements()).isEqualTo(0L); - } - - // Find - @Test - public void testFindAppsNoFilters() { - entityGenerator.setupTestApplications(); - val applications = - applicationService.findApps( - "222222", Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(applications.getTotalElements()).isEqualTo(1L); - assertThat(applications.getContent().get(0).getClientId()).isEqualTo("222222"); - } - - @Test - public void testFindAppsFiltered() { - entityGenerator.setupTestApplications(); - val clientIdFilter = new SearchFilter("clientId", "333333"); - val applications = - applicationService.findApps( - "222222", singletonList(clientIdFilter), new PageableResolver().getPageable()); - // Expect empty list - assertThat(applications.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindUsersAppsNoQueryNoFilters() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestUsers(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = userService.getByName("SecondUser@domain.com"); - - val application = applicationService.getByClientId("444444"); - - userService.addUserToApps(user.getId(), newArrayList(application.getId())); - userService.addUserToApps(userTwo.getId(), newArrayList(application.getId())); - - val applications = - applicationService.findApplicationsForUser( - user.getId(), Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(1L); - assertThat(applications.getContent().get(0).getClientId()).isEqualTo("444444"); - } - - @Test - public void testFindUsersAppsNoQueryNoFiltersNoUser() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestUsers(); - - val user = userService.getByName("FirstUser@domain.com"); - val applications = - applicationService.findApplicationsForUser( - user.getId(), Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindUsersAppsNoQueryFilters() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestUsers(); - - val user = userService.getByName("FirstUser@domain.com"); - val applicationOne = applicationService.getByClientId("111111"); - val applicationTwo = applicationService.getByClientId("555555"); - - userService.addUserToApps( - user.getId(), newArrayList(applicationOne.getId(), applicationTwo.getId())); - - val clientIdFilter = new SearchFilter("clientId", "111111"); - - val applications = - applicationService.findApplicationsForUser( - user.getId(), singletonList(clientIdFilter), new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(1L); - assertThat(applications.getContent().get(0).getClientId()).isEqualTo("111111"); - } - - @Test - public void testFindUsersAppsQueryAndFilters() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestUsers(); - - val user = userService.getByName("FirstUser@domain.com"); - val applicationOne = applicationService.getByClientId("333333"); - val applicationTwo = applicationService.getByClientId("444444"); - - userService.addUserToApps( - user.getId(), newArrayList(applicationOne.getId(), applicationTwo.getId())); - - val clientIdFilter = new SearchFilter("clientId", "333333"); - - val applications = - applicationService.findApplicationsForUser( - user.getId(), - "444444", - singletonList(clientIdFilter), - new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindUsersAppsQueryNoFilters() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestUsers(); - - val user = userService.getByName("FirstUser@domain.com"); - val applicationOne = applicationService.getByClientId("222222"); - val applicationTwo = applicationService.getByClientId("444444"); - - userService.addUserToApps( - user.getId(), newArrayList(applicationOne.getId(), applicationTwo.getId())); - - val applications = - applicationService.findApplicationsForUser( - user.getId(), "222222", Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(1L); - assertThat(applications.getContent().get(0).getClientId()).isEqualTo("222222"); - } - - @Test - public void testFindGroupsAppsNoQueryNoFilters() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - val groupTwo = groupService.getByName("Group Two"); - - val application = applicationService.getByClientId("111111"); - - groupService.associateApplicationsWithGroup(group.getId(), newArrayList(application.getId())); - groupService.associateApplicationsWithGroup( - groupTwo.getId(), newArrayList(application.getId())); - - val applications = - applicationService.findApplicationsForGroup( - group.getId(), Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(1L); - assertThat(applications.getContent().get(0).getClientId()).isEqualTo("111111"); - } - - @Test - public void testFindGroupsAppsNoQueryNoFiltersNoGroup() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - val applications = - applicationService.findApplicationsForGroup( - group.getId(), Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindGroupsAppsNoQueryFilters() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - val applicationOne = applicationService.getByClientId("222222"); - val applicationTwo = applicationService.getByClientId("333333"); - - groupService.associateApplicationsWithGroup( - group.getId(), newArrayList(applicationOne.getId(), applicationTwo.getId())); - - val clientIdFilter = new SearchFilter("clientId", "333333"); - - val applications = - applicationService.findApplicationsForGroup( - group.getId(), singletonList(clientIdFilter), new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(1L); - assertThat(applications.getContent().get(0).getClientId()).isEqualTo("333333"); - } - - @Test - public void testFindGroupsAppsQueryAndFilters() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group Three"); - val applicationOne = applicationService.getByClientId("333333"); - val applicationTwo = applicationService.getByClientId("444444"); - - groupService.associateApplicationsWithGroup( - group.getId(), newArrayList(applicationOne.getId(), applicationTwo.getId())); - - val clientIdFilter = new SearchFilter("clientId", "333333"); - - val applications = - applicationService.findApplicationsForGroup( - group.getId(), - "444444", - singletonList(clientIdFilter), - new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindGroupsAppsQueryNoFilters() { - entityGenerator.setupTestApplications(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - val applicationOne = applicationService.getByClientId("444444"); - val applicationTwo = applicationService.getByClientId("555555"); - - groupService.associateApplicationsWithGroup( - group.getId(), newArrayList(applicationOne.getId(), applicationTwo.getId())); - - val applications = - applicationService.findApplicationsForGroup( - group.getId(), "555555", Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(applications.getTotalElements()).isEqualTo(1L); - assertThat(applications.getContent().get(0).getClientId()).isEqualTo("555555"); - } - - // Update - @Test - public void testUpdate() { - val application = entityGenerator.setupApplication("123456"); - val updateRequest = UpdateApplicationRequest.builder().name("New Name").build(); - val updated = applicationService.partialUpdate(application.getId(), updateRequest); - assertThat(updated.getName()).isEqualTo("New Name"); - } - - @Test - public void testUpdateNonexistentEntity() { - val nonExistentId = generateNonExistentId(applicationService); - val updateRequest = - UpdateApplicationRequest.builder() - .clientId("123456") - .name("DoesNotExist") - .clientSecret("654321") - .build(); - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> applicationService.partialUpdate(nonExistentId, updateRequest)); - } - - @Test - public void uniqueClientIdCheck_CreateApplication_ThrowsUniqueConstraintException() { - val r1 = - CreateApplicationRequest.builder() - .clientId(UUID.randomUUID().toString()) - .clientSecret(UUID.randomUUID().toString()) - .name(UUID.randomUUID().toString()) - .status(PENDING) - .build(); - - val a1 = applicationService.create(r1); - assertThat(applicationService.isExist(a1.getId())).isTrue(); - - assertThat(a1.getClientId()).isEqualTo(r1.getClientId()); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> applicationService.create(r1)); - } - - @Test - public void uniqueClientIdCheck_UpdateApplication_ThrowsUniqueConstraintException() { - val clientId1 = UUID.randomUUID().toString(); - val clientId2 = UUID.randomUUID().toString(); - val cr1 = - CreateApplicationRequest.builder() - .clientId(clientId1) - .clientSecret(UUID.randomUUID().toString()) - .name(UUID.randomUUID().toString()) - .status(PENDING) - .build(); - - val cr2 = - CreateApplicationRequest.builder() - .clientId(clientId2) - .clientSecret(UUID.randomUUID().toString()) - .name(UUID.randomUUID().toString()) - .status(APPROVED) - .build(); - - val a1 = applicationService.create(cr1); - assertThat(applicationService.isExist(a1.getId())).isTrue(); - val a2 = applicationService.create(cr2); - assertThat(applicationService.isExist(a2.getId())).isTrue(); - - val ur3 = UpdateApplicationRequest.builder().clientId(clientId1).build(); - - assertThat(a1.getClientId()).isEqualTo(ur3.getClientId()); - assertThat(a2.getClientId()).isNotEqualTo(ur3.getClientId()); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> applicationService.partialUpdate(a2.getId(), ur3)); - } - - // Delete - @Test - public void testDelete() { - entityGenerator.setupTestApplications(); - - val application = applicationService.getByClientId("222222"); - applicationService.delete(application.getId()); - - val applications = - applicationService.listApps(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(applications.getTotalElements()).isEqualTo(4L); - assertThat(applications.getContent()).doesNotContain(application); - } - - @Test - public void testDeleteNonExisting() { - entityGenerator.setupTestApplications(); - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> applicationService.delete(randomUUID())); - } - - // Special (LoadClient) - @Test - public void testLoadClientByClientId() { - val application = entityGenerator.setupApplication("123456"); - val updateRequest = UpdateApplicationRequest.builder().status(APPROVED).build(); - applicationService.partialUpdate(application.getId(), updateRequest); - - val client = applicationService.loadClientByClientId("123456"); - - assertThat(client.getClientId()).isEqualToIgnoringCase("123456"); - assertThat( - client - .getAuthorizedGrantTypes() - .containsAll(Arrays.asList(AppTokenClaims.AUTHORIZED_GRANTS))); - assertThat(client.getScope().containsAll(Arrays.asList(AppTokenClaims.SCOPES))); - assertThat(client.getRegisteredRedirectUri()).isEqualTo(setOf(application.getRedirectUri())); - assertThat(client.getAuthorities()) - .containsExactly(new SimpleGrantedAuthority(AppTokenClaims.ROLE)); - } - - @Test - public void testLoadClientByClientIdNotFound() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> applicationService.loadClientByClientId("123456")) - .withMessage("The 'Application' entity with clientId '123456' was not found"); - } - - @Test - public void testLoadClientByClientIdEmptyString() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> applicationService.loadClientByClientId("")) - .withMessage("The 'Application' entity with clientId '' was not found"); - } - - @Test - public void testLoadClientByClientIdNotApproved() { - val application = entityGenerator.setupApplication("123456"); - val updateRequest = UpdateApplicationRequest.builder().status(PENDING).build(); - applicationService.partialUpdate(application.getId(), updateRequest); - assertThatExceptionOfType(ClientRegistrationException.class) - .isThrownBy(() -> applicationService.loadClientByClientId("123456")) - .withMessage("Client Access is not approved."); - - updateRequest.setStatus(REJECTED); - applicationService.partialUpdate(application.getId(), updateRequest); - assertThatExceptionOfType(ClientRegistrationException.class) - .isThrownBy(() -> applicationService.loadClientByClientId("123456")) - .withMessage("Client Access is not approved."); - - updateRequest.setStatus(DISABLED); - applicationService.partialUpdate(application.getId(), updateRequest); - assertThatExceptionOfType(ClientRegistrationException.class) - .isThrownBy(() -> applicationService.loadClientByClientId("123456")) - .withMessage("Client Access is not approved."); - } -} diff --git a/src/test/java/bio/overture/ego/service/GroupsServiceTest.java b/src/test/java/bio/overture/ego/service/GroupsServiceTest.java deleted file mode 100644 index 14c5628de..000000000 --- a/src/test/java/bio/overture/ego/service/GroupsServiceTest.java +++ /dev/null @@ -1,693 +0,0 @@ -package bio.overture.ego.service; - -import static bio.overture.ego.model.enums.AccessLevel.DENY; -import static bio.overture.ego.model.enums.AccessLevel.READ; -import static bio.overture.ego.model.enums.AccessLevel.WRITE; -import static bio.overture.ego.model.enums.StatusType.APPROVED; -import static bio.overture.ego.model.enums.StatusType.PENDING; -import static bio.overture.ego.utils.CollectionUtils.mapToImmutableSet; -import static bio.overture.ego.utils.EntityGenerator.generateNonExistentId; -import static bio.overture.ego.utils.EntityTools.extractGroupNames; -import static com.google.common.collect.Lists.newArrayList; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatExceptionOfType; - -import bio.overture.ego.controller.resolver.PageableResolver; -import bio.overture.ego.model.dto.GroupRequest; -import bio.overture.ego.model.dto.PermissionRequest; -import bio.overture.ego.model.entity.AbstractPermission; -import bio.overture.ego.model.exceptions.NotFoundException; -import bio.overture.ego.model.exceptions.UniqueViolationException; -import bio.overture.ego.model.join.GroupApplication; -import bio.overture.ego.model.search.SearchFilter; -import bio.overture.ego.repository.join.UserGroupRepository; -import bio.overture.ego.utils.EntityGenerator; -import bio.overture.ego.utils.PolicyPermissionUtils; -import com.google.common.collect.ImmutableList; -import java.util.Arrays; -import java.util.Collections; -import java.util.UUID; -import java.util.stream.Collectors; -import lombok.extern.slf4j.Slf4j; -import lombok.val; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.ActiveProfiles; -import org.springframework.test.context.junit4.SpringRunner; -import org.springframework.transaction.annotation.Transactional; - -@Slf4j -@SpringBootTest -@RunWith(SpringRunner.class) -@ActiveProfiles("test") -@Transactional -@Ignore("replace with controller tests.") -public class GroupsServiceTest { - @Autowired private ApplicationService applicationService; - - @Autowired private UserService userService; - - @Autowired private GroupService groupService; - @Autowired private GroupPermissionService groupPermissionService; - - @Autowired private PolicyService policyService; - - @Autowired private EntityGenerator entityGenerator; - @Autowired private UserGroupRepository userGroupRepository; - - // Create - @Test - public void testCreate() { - val group = entityGenerator.setupGroup("Group One"); - assertThat(group.getName()).isEqualTo("Group One"); - } - - @Test - public void uniqueNameCheck_CreateGroup_ThrowsUniqueConstraintException() { - val r1 = GroupRequest.builder().name(UUID.randomUUID().toString()).status(PENDING).build(); - - val g1 = groupService.create(r1); - assertThat(groupService.isExist(g1.getId())).isTrue(); - - assertThat(g1.getName()).isEqualTo(r1.getName()); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> groupService.create(r1)); - } - - @Test - public void uniqueClientIdCheck_UpdateGroup_ThrowsUniqueConstraintException() { - val name1 = UUID.randomUUID().toString(); - val name2 = UUID.randomUUID().toString(); - val cr1 = GroupRequest.builder().name(name1).status(PENDING).build(); - - val cr2 = GroupRequest.builder().name(name2).status(APPROVED).build(); - - val g1 = groupService.create(cr1); - assertThat(groupService.isExist(g1.getId())).isTrue(); - val g2 = groupService.create(cr2); - assertThat(groupService.isExist(g2.getId())).isTrue(); - - val ur3 = GroupRequest.builder().name(name1).build(); - - assertThat(g1.getName()).isEqualTo(ur3.getName()); - assertThat(g2.getName()).isNotEqualTo(ur3.getName()); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> groupService.partialUpdate(g2.getId(), ur3)); - } - - // Get - @Test - public void testGet() { - val group = entityGenerator.setupGroup("Group One"); - val saveGroup = groupService.getById(group.getId()); - assertThat(saveGroup.getName()).isEqualTo("Group One"); - } - - @Test - public void testGetNotFoundException() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> groupService.getById(UUID.randomUUID())); - } - - @Test - public void testGetByName() { - entityGenerator.setupGroup("Group One"); - val saveGroup = groupService.getByName("Group One"); - assertThat(saveGroup.getName()).isEqualTo("Group One"); - } - - @Test - public void testGetByNameAllCaps() { - entityGenerator.setupGroup("Group One"); - val saveGroup = groupService.getByName("GROUP ONE"); - assertThat(saveGroup.getName()).isEqualTo("Group One"); - } - - @Test - @Ignore - public void testGetByNameNotFound() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> groupService.getByName("Group One")); - } - - // List Groups - @Test - public void testListGroupsNoFilters() { - entityGenerator.setupTestGroups(); - val groups = - groupService.listGroups(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(groups.getTotalElements()).isEqualTo(3L); - } - - @Test - public void testListGroupsNoFiltersEmptyResult() { - val groups = - groupService.listGroups(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(groups.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testListGroupsFiltered() { - entityGenerator.setupTestGroups(); - val groupNameFilter = new SearchFilter("name", "Group One"); - val groups = - groupService.listGroups( - Arrays.asList(groupNameFilter), new PageableResolver().getPageable()); - assertThat(groups.getTotalElements()).isEqualTo(1L); - assertThat(groups.getContent().get(0).getName()).isEqualTo("Group One"); - } - - @Test - public void testListGroupsFilteredEmptyResult() { - entityGenerator.setupTestGroups(); - val groupNameFilter = new SearchFilter("name", "Group Four"); - val groups = - groupService.listGroups( - Arrays.asList(groupNameFilter), new PageableResolver().getPageable()); - assertThat(groups.getTotalElements()).isEqualTo(0L); - } - - // Find Groups - @Test - public void testFindGroupsNoFilters() { - entityGenerator.setupTestGroups(); - val groups = - groupService.findGroups( - "One", Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(groups.getTotalElements()).isEqualTo(1L); - assertThat(groups.getContent().get(0).getName()).isEqualTo("Group One"); - } - - @Test - public void testFindGroupsFiltered() { - entityGenerator.setupTestGroups(); - val groupNameFilter = new SearchFilter("name", "Group One"); - val groups = - groupService.findGroups( - "Two", Arrays.asList(groupNameFilter), new PageableResolver().getPageable()); - // Expect empty list - assertThat(groups.getTotalElements()).isEqualTo(0L); - } - - // Find User's Groups - @Test - public void testFindUsersGroupsNoQueryNoFilters() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestUsers(); - - val userId = userService.getByName("FirstUser@domain.com").getId(); - val userTwoId = userService.getByName("SecondUser@domain.com").getId(); - val groupId = groupService.getByName("Group One").getId(); - - userService.associateGroupsWithUser(userId, Arrays.asList(groupId)); - userService.associateGroupsWithUser(userTwoId, Arrays.asList(groupId)); - - val groups = - groupService.findGroupsForUser( - userId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(groups.getTotalElements()).isEqualTo(1L); - assertThat(groups.getContent().get(0).getName()).isEqualTo("Group One"); - } - - @Test - public void testFindUsersGroupsNoQueryNoFiltersNoGroupsFound() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestUsers(); - - val userId = userService.getByName("FirstUser@domain.com").getId(); - - val groups = - groupService.findGroupsForUser( - userId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(groups.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindUsersGroupsNoQueryFilters() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestUsers(); - - val userId = userService.getByName("FirstUser@domain.com").getId(); - val groupId = groupService.getByName("Group One").getId(); - val groupTwoId = groupService.getByName("Group Two").getId(); - - userService.associateGroupsWithUser(userId, Arrays.asList(groupId, groupTwoId)); - - val groupsFilters = new SearchFilter("name", "Group One"); - - val groups = - groupService.findGroupsForUser( - userId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(groups.getTotalElements()).isEqualTo(1L); - assertThat(groups.getContent().get(0).getName()).isEqualTo("Group One"); - } - - @Test - public void testFindUsersGroupsQueryAndFilters() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestUsers(); - - val userId = userService.getByName("FirstUser@domain.com").getId(); - val groupId = groupService.getByName("Group One").getId(); - val groupTwoId = groupService.getByName("Group Two").getId(); - - userService.associateGroupsWithUser(userId, Arrays.asList(groupId, groupTwoId)); - - val groupsFilters = new SearchFilter("name", "Group One"); - - val groups = - groupService.findGroupsForUser( - userId, "Two", ImmutableList.of(groupsFilters), new PageableResolver().getPageable()); - - assertThat(groups.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindUsersGroupsQueryNoFilters() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestUsers(); - - val userId = userService.getByName("FirstUser@domain.com").getId(); - val groupId = groupService.getByName("Group One").getId(); - val groupTwoId = groupService.getByName("Group Two").getId(); - - userService.associateGroupsWithUser(userId, Arrays.asList(groupId, groupTwoId)); - - val groups = - groupService.findGroupsForUser( - userId, "Two", ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(groups.getTotalElements()).isEqualTo(1L); - assertThat(groups.getContent().get(0).getName()).isEqualTo("Group Two"); - } - - // Find Application's Groups - @Test - public void testFindApplicationsGroupsNoQueryNoFilters() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val groupId = groupService.getByName("Group One").getId(); - val groupTwoId = groupService.getByName("Group Two").getId(); - val applicationId = applicationService.getByClientId("111111").getId(); - val applicationTwoId = applicationService.getByClientId("222222").getId(); - - groupService.associateApplicationsWithGroup(groupId, Arrays.asList(applicationId)); - groupService.associateApplicationsWithGroup(groupTwoId, Arrays.asList(applicationTwoId)); - - val groups = - groupService.findGroupsForApplication( - applicationId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(extractGroupNames(groups.getContent())).contains("Group One"); - assertThat(extractGroupNames(groups.getContent())).doesNotContain("Group Two"); - } - - @Test - public void testFindApplicationsGroupsNoQueryNoFiltersNoGroup() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val applicationId = applicationService.getByClientId("111111").getId(); - - val groups = - groupService.findGroupsForApplication( - applicationId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(groups.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindApplicationsGroupsNoQueryFilters() { - entityGenerator.setupTestGroups("testFindApplicationsGroupsNoQueryFilters"); - entityGenerator.setupTestApplications("testFindApplicationsGroupsNoQueryFilters"); - - val groupId = - groupService.getByName("Group One_testFindApplicationsGroupsNoQueryFilters").getId(); - val groupTwoId = - groupService.getByName("Group Two_testFindApplicationsGroupsNoQueryFilters").getId(); - val applicationId = - applicationService.getByClientId("111111_testFindApplicationsGroupsNoQueryFilters").getId(); - - groupService.associateApplicationsWithGroup(groupId, Arrays.asList(applicationId)); - groupService.associateApplicationsWithGroup(groupTwoId, Arrays.asList(applicationId)); - - val groupsFilters = - new SearchFilter("name", "Group One_testFindApplicationsGroupsNoQueryFilters"); - - val groups = - groupService.findGroupsForApplication( - applicationId, ImmutableList.of(groupsFilters), new PageableResolver().getPageable()); - - assertThat(groups.getTotalElements()).isEqualTo(1L); - assertThat(groups.getContent().get(0).getName()) - .isEqualTo("Group One_testFindApplicationsGroupsNoQueryFilters"); - } - - @Test - public void testFindApplicationsGroupsQueryAndFilters() { - entityGenerator.setupTestGroups("testFindApplicationsGroupsQueryAndFilters"); - entityGenerator.setupTestApplications("testFindApplicationsGroupsQueryAndFilters"); - - val groupId = - groupService.getByName("Group One_testFindApplicationsGroupsQueryAndFilters").getId(); - val groupTwoId = - groupService.getByName("Group Two_testFindApplicationsGroupsQueryAndFilters").getId(); - val applicationId = - applicationService - .getByClientId("111111_testFindApplicationsGroupsQueryAndFilters") - .getId(); - - groupService.associateApplicationsWithGroup(groupId, Arrays.asList(applicationId)); - groupService.associateApplicationsWithGroup(groupTwoId, Arrays.asList(applicationId)); - - val groupsFilters = - new SearchFilter("name", "Group One_testFindApplicationsGroupsQueryAndFilters"); - - val groups = - groupService.findGroupsForApplication( - applicationId, - "Two", - ImmutableList.of(groupsFilters), - new PageableResolver().getPageable()); - - assertThat(groups.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindApplicationsGroupsQueryNoFilters() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val groupId = groupService.getByName("Group One").getId(); - val groupTwoId = groupService.getByName("Group Two").getId(); - val applicationId = applicationService.getByClientId("111111").getId(); - - groupService.associateApplicationsWithGroup(groupId, Arrays.asList(applicationId)); - groupService.associateApplicationsWithGroup(groupTwoId, Arrays.asList(applicationId)); - - val groups = - groupService.findGroupsForApplication( - applicationId, "Group One", ImmutableList.of(), new PageableResolver().getPageable()); - assertThat(groups.getTotalElements()).isEqualTo(1L); - assertThat(groups.getContent().get(0).getName()).isEqualTo("Group One"); - } - - // Update - @Test - public void testUpdate() { - val group = entityGenerator.setupGroup("Group One"); - val updateRequest = GroupRequest.builder().description("New Description").build(); - val updated = groupService.partialUpdate(group.getId(), updateRequest); - assertThat(updated.getDescription()).isEqualTo("New Description"); - } - - @Test - public void testUpdateNonexistentEntity() { - val nonExistentId = generateNonExistentId(groupService); - val nonExistentEntity = - GroupRequest.builder().name("NonExistent").status(PENDING).description("").build(); - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> groupService.partialUpdate(nonExistentId, nonExistentEntity)); - } - - // Add Apps to Group - @Test - public void addAppsToGroup() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val groupId = groupService.getByName("Group One").getId(); - val application = applicationService.getByClientId("111111"); - val applicationId = application.getId(); - - groupService.associateApplicationsWithGroup(groupId, Arrays.asList(applicationId)); - - val group = groupService.getWithApplications(groupId); - - assertThat(mapToImmutableSet(group.getGroupApplications(), GroupApplication::getApplication)) - .contains(applicationService.getByClientId("111111")); - } - - @Test - public void addAppsToGroupNoGroup() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - val applicationId = applicationService.getByClientId("111111").getId(); - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy( - () -> - groupService.associateApplicationsWithGroup( - UUID.randomUUID(), Arrays.asList(applicationId))); - } - - @Test - public void addAppsToGroupNoApp() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val groupId = groupService.getByName("Group One").getId(); - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy( - () -> - groupService.associateApplicationsWithGroup( - groupId, Arrays.asList(UUID.randomUUID()))); - } - - @Test - public void addAppsToGroupEmptyAppList() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val group = groupService.getByName("Group One"); - val groupId = group.getId(); - - groupService.associateApplicationsWithGroup(groupId, Collections.emptyList()); - - val nonUpdated = groupService.getByName("Group One"); - assertThat(nonUpdated).isEqualTo(group); - } - - // Delete - @Test - public void testDelete() { - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - - groupService.delete(group.getId()); - - val groups = - groupService.listGroups(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(groups.getTotalElements()).isEqualTo(2L); - assertThat(groups.getContent()).doesNotContain(group); - } - - @Test - public void testDeleteNonExisting() { - entityGenerator.setupTestGroups(); - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> groupService.delete(UUID.randomUUID())); - } - - // Delete Apps from Group - @Test - public void testDeleteAppFromGroup() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val groupId = groupService.getByName("Group One").getId(); - val application = applicationService.getByClientId("111111"); - val applicationId = application.getId(); - - groupService.associateApplicationsWithGroup(groupId, Arrays.asList(applicationId)); - - val group = groupService.getWithApplications(groupId); - assertThat(group.getGroupApplications().size()).isEqualTo(1); - - groupService.disassociateApplicationsFromGroup(groupId, Arrays.asList(applicationId)); - - val groupWithDeleteApp = groupService.getWithApplications(groupId); - assertThat(groupWithDeleteApp.getGroupApplications().size()).isEqualTo(0); - } - - @Test - public void testDeleteAppsFromGroupNoGroup() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val groupId = groupService.getByName("Group One").getId(); - val application = applicationService.getByClientId("111111"); - val applicationId = application.getId(); - - groupService.associateApplicationsWithGroup(groupId, Arrays.asList(applicationId)); - - val group = groupService.getWithApplications(groupId); - assertThat(group.getGroupApplications().size()).isEqualTo(1); - - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy( - () -> - groupService.disassociateApplicationsFromGroup( - UUID.randomUUID(), Arrays.asList(applicationId))); - } - - @Test - public void testDeleteAppsFromGroupEmptyAppsList() { - entityGenerator.setupTestGroups(); - entityGenerator.setupTestApplications(); - - val groupId = groupService.getByName("Group One").getId(); - val application = applicationService.getByClientId("111111"); - val applicationId = application.getId(); - - groupService.associateApplicationsWithGroup(groupId, Arrays.asList(applicationId)); - - val group = groupService.getWithApplications(groupId); - assertThat(group.getGroupApplications().size()).isEqualTo(1); - - assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy(() -> groupService.disassociateApplicationsFromGroup(groupId, Arrays.asList())); - } - - /** This test guards against bad cascades against users */ - @Test - public void testDeleteGroupWithUserRelations() { - val user = entityGenerator.setupUser("foo bar"); - val group = entityGenerator.setupGroup("testGroup"); - - val updatedGroup = - userService.associateGroupsWithUser(group.getId(), newArrayList(user.getId())); - - groupService.delete(updatedGroup.getId()); - assertThat(userService.getById(user.getId())).isNotNull(); - } - - /** This test guards against bad cascades against applications */ - @Test - public void testDeleteGroupWithApplicationRelations() { - val app = entityGenerator.setupApplication("foobar"); - val group = entityGenerator.setupGroup("testGroup"); - - val updatedGroup = - groupService.associateApplicationsWithGroup(group.getId(), newArrayList(app.getId())); - - groupService.delete(updatedGroup.getId()); - assertThat(applicationService.getById(app.getId())).isNotNull(); - } - - @Test - public void testAddGroupPermissions() { - entityGenerator.setupTestGroups(); - val groups = - groupService - .listGroups(Collections.emptyList(), new PageableResolver().getPageable()) - .getContent(); - entityGenerator.setupTestPolicies(); - - val study001 = policyService.getByName("Study001"); - val study001id = study001.getId(); - - val study002 = policyService.getByName("Study002"); - val study002id = study002.getId(); - - val study003 = policyService.getByName("Study003"); - val study003id = study003.getId(); - - val permissions = - Arrays.asList( - new PermissionRequest(study001id, READ), - new PermissionRequest(study002id, WRITE), - new PermissionRequest(study003id, DENY)); - - val firstGroup = groups.get(0); - - groupPermissionService.addPermissions(firstGroup.getId(), permissions); - - assertThat(PolicyPermissionUtils.extractPermissionStrings(firstGroup.getPermissions())) - .containsExactlyInAnyOrder("Study001.READ", "Study002.WRITE", "Study003.DENY"); - } - - @Test - public void testDeleteGroupPermissions() { - entityGenerator.setupTestGroups(); - val groups = - groupService - .listGroups(Collections.emptyList(), new PageableResolver().getPageable()) - .getContent(); - entityGenerator.setupTestPolicies(); - - val firstGroup = groups.get(0); - - val study001 = policyService.getByName("Study001"); - val study001id = study001.getId(); - - val study002 = policyService.getByName("Study002"); - val study002id = study002.getId(); - - val study003 = policyService.getByName("Study003"); - val study003id = study003.getId(); - - val permissions = - Arrays.asList( - new PermissionRequest(study001id, READ), - new PermissionRequest(study002id, WRITE), - new PermissionRequest(study003id, DENY)); - - groupPermissionService.addPermissions(firstGroup.getId(), permissions); - - val groupPermissionsToRemove = - firstGroup.getPermissions().stream() - .filter(p -> !p.getPolicy().getName().equals("Study001")) - .map(AbstractPermission::getId) - .collect(Collectors.toList()); - - groupPermissionService.deletePermissions(firstGroup.getId(), groupPermissionsToRemove); - - assertThat(PolicyPermissionUtils.extractPermissionStrings(firstGroup.getPermissions())) - .containsExactlyInAnyOrder("Study001.READ"); - } - - @Test - public void testGetGroupPermissions() { - entityGenerator.setupPolicies( - "testGetGroupPermissions_Study001, testGetGroupPermissions_Group", - "testGetGroupPermissions_Study002, testGetGroupPermissions_Group", - "testGetGroupPermissions_Study003, testGetGroupPermissions_Group"); - - val testGroup = entityGenerator.setupGroup("testGetGroupPermissions_Group"); - - val study001 = policyService.getByName("testGetGroupPermissions_Study001"); - val study001id = study001.getId(); - - val study002 = policyService.getByName("testGetGroupPermissions_Study002"); - val study002id = study002.getId(); - - val study003 = policyService.getByName("testGetGroupPermissions_Study003"); - val study003id = study003.getId(); - - val permissions = - Arrays.asList( - new PermissionRequest(study001id, READ), - new PermissionRequest(study002id, WRITE), - new PermissionRequest(study003id, DENY)); - - groupPermissionService.addPermissions(testGroup.getId(), permissions); - - val pagedGroupPermissions = - groupPermissionService.getPermissions( - testGroup.getId(), new PageableResolver().getPageable()); - - assertThat(pagedGroupPermissions.getTotalElements()).isEqualTo(1L); - assertThat(pagedGroupPermissions.getContent().get(0).getAccessLevel().toString()) - .isEqualToIgnoringCase("READ"); - assertThat(pagedGroupPermissions.getContent().get(0).getPolicy().getName()) - .isEqualToIgnoringCase("testGetGroupPermissions_Study001"); - } -} diff --git a/src/test/java/bio/overture/ego/service/PermissionServiceTest.java b/src/test/java/bio/overture/ego/service/PermissionServiceTest.java deleted file mode 100644 index bcace9a07..000000000 --- a/src/test/java/bio/overture/ego/service/PermissionServiceTest.java +++ /dev/null @@ -1,93 +0,0 @@ -package bio.overture.ego.service; - -import static bio.overture.ego.model.enums.AccessLevel.READ; -import static java.util.Arrays.asList; -import static org.assertj.core.api.Assertions.assertThat; - -import bio.overture.ego.model.dto.PermissionRequest; -import bio.overture.ego.model.dto.PolicyResponse; -import bio.overture.ego.utils.EntityGenerator; -import lombok.extern.slf4j.Slf4j; -import lombok.val; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.ActiveProfiles; -import org.springframework.test.context.junit4.SpringRunner; -import org.springframework.transaction.annotation.Transactional; - -@Slf4j -@SpringBootTest -@RunWith(SpringRunner.class) -@ActiveProfiles("test") -@Transactional -@Ignore("replace with controller tests.") -public class PermissionServiceTest { - @Autowired private UserService userService; - - @Autowired private GroupService groupService; - - @Autowired private PolicyService policyService; - - @Autowired private UserPermissionService userPermissionService; - - @Autowired private GroupPermissionService groupPermissionService; - - @Autowired private EntityGenerator entityGenerator; - - @Test - public void testFindGroupIdsByPolicy() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - entityGenerator.setupTestPolicies(); - - val policy = policyService.getByName("Study001"); - - val name1 = "Group One"; - val name2 = "Group Three"; - - val group1 = groupService.getByName(name1); - val group2 = groupService.getByName(name2); - - val permissions = asList(new PermissionRequest(policy.getId(), READ)); - groupPermissionService.addPermissions(group1.getId(), permissions); - groupPermissionService.addPermissions(group2.getId(), permissions); - - val expected = - asList( - new PolicyResponse(group1.getId().toString(), name1, READ), - new PolicyResponse(group2.getId().toString(), name2, READ)); - - val actual = groupPermissionService.findByPolicy(policy.getId()); - - assertThat(actual).containsExactlyInAnyOrderElementsOf(expected); - } - - @Test - public void testFindUserIdsByPolicy() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - entityGenerator.setupTestPolicies(); - - val policy = policyService.getByName("Study001"); - val name1 = "FirstUser@domain.com"; - val name2 = "SecondUser@domain.com"; - val user1 = userService.getByName(name1); - val user2 = userService.getByName(name2); - - val permissions = asList(new PermissionRequest(policy.getId(), READ)); - userPermissionService.addPermissions(user1.getId(), permissions); - userPermissionService.addPermissions(user2.getId(), permissions); - - val expected = - asList( - new PolicyResponse(user1.getId().toString(), name1, READ), - new PolicyResponse(user2.getId().toString(), name2, READ)); - - val actual = userPermissionService.findByPolicy(policy.getId()); - System.out.printf("%s", actual.get(0).toString()); - assertThat(actual).containsExactlyInAnyOrderElementsOf(expected); - } -} diff --git a/src/test/java/bio/overture/ego/service/PolicyServiceTest.java b/src/test/java/bio/overture/ego/service/PolicyServiceTest.java deleted file mode 100644 index 7adc23751..000000000 --- a/src/test/java/bio/overture/ego/service/PolicyServiceTest.java +++ /dev/null @@ -1,177 +0,0 @@ -package bio.overture.ego.service; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatExceptionOfType; - -import bio.overture.ego.controller.resolver.PageableResolver; -import bio.overture.ego.model.dto.PolicyRequest; -import bio.overture.ego.model.entity.Group; -import bio.overture.ego.model.exceptions.NotFoundException; -import bio.overture.ego.model.exceptions.UniqueViolationException; -import bio.overture.ego.model.search.SearchFilter; -import bio.overture.ego.utils.EntityGenerator; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.UUID; -import lombok.extern.slf4j.Slf4j; -import lombok.val; -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.ActiveProfiles; -import org.springframework.test.context.junit4.SpringRunner; -import org.springframework.transaction.annotation.Transactional; - -@Slf4j -@SpringBootTest -@RunWith(SpringRunner.class) -@ActiveProfiles("test") -@Transactional -@Ignore("To be replaced with controller tests") -public class PolicyServiceTest { - - @Autowired private PolicyService policyService; - - @Autowired private EntityGenerator entityGenerator; - - private List groups; - - @Before - public void setUp() { - groups = entityGenerator.setupGroups("Group One", "GroupTwo", "Group Three"); - } - - // Create - @Test - public void testCreate() { - val policy = entityGenerator.setupPolicy("Study001,Group One"); - assertThat(policy.getName()).isEqualTo("Study001"); - } - - // Read - @Test - public void testGet() { - val policy = entityGenerator.setupPolicy("Study001", groups.get(0).getName()); - val savedPolicy = policyService.getById(policy.getId()); - assertThat(savedPolicy.getName()).isEqualTo("Study001"); - } - - @Test - public void testGetNotFoundException() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> policyService.getById(UUID.randomUUID())); - } - - @Test - public void testGetByName() { - entityGenerator.setupPolicy("Study001", groups.get(0).getName()); - val savedUser = policyService.getByName("Study001"); - assertThat(savedUser.getName()).isEqualTo("Study001"); - } - - @Test - public void testGetByNameAllCaps() { - entityGenerator.setupPolicy("Study001", groups.get(0).getName()); - val savedUser = policyService.getByName("STUDY001"); - assertThat(savedUser.getName()).isEqualTo("Study001"); - } - - @Test - @Ignore - public void testGetByNameNotFound() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> policyService.getByName("Study000")); - } - - @Test - public void testListUsersNoFilters() { - entityGenerator.setupTestPolicies(); - val aclEntities = - policyService.listPolicies(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(aclEntities.getTotalElements()).isEqualTo(3L); - } - - @Test - public void testListUsersNoFiltersEmptyResult() { - val aclEntities = - policyService.listPolicies(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(aclEntities.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testListUsersFiltered() { - entityGenerator.setupTestPolicies(); - val userFilter = new SearchFilter("name", "Study001"); - val aclEntities = - policyService.listPolicies(Arrays.asList(userFilter), new PageableResolver().getPageable()); - assertThat(aclEntities.getTotalElements()).isEqualTo(1L); - } - - @Test - public void uniqueNameCheck_CreatePolicy_ThrowsUniqueConstraintException() { - val r1 = PolicyRequest.builder().name(UUID.randomUUID().toString()).build(); - - val p1 = policyService.create(r1); - assertThat(policyService.isExist(p1.getId())).isTrue(); - - assertThat(p1.getName()).isEqualTo(r1.getName()); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> policyService.create(r1)); - } - - @Test - public void uniqueNameCheck_UpdatePolicy_ThrowsUniqueConstraintException() { - val name1 = UUID.randomUUID().toString(); - val name2 = UUID.randomUUID().toString(); - val cr1 = PolicyRequest.builder().name(name1).build(); - - val cr2 = PolicyRequest.builder().name(name2).build(); - - val p1 = policyService.create(cr1); - assertThat(policyService.isExist(p1.getId())).isTrue(); - val p2 = policyService.create(cr2); - assertThat(policyService.isExist(p2.getId())).isTrue(); - - val ur3 = PolicyRequest.builder().name(name1).build(); - - assertThat(p1.getName()).isEqualTo(ur3.getName()); - assertThat(p2.getName()).isNotEqualTo(ur3.getName()); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> policyService.partialUpdate(p2.getId(), ur3)); - } - - @Test - public void testListUsersFilteredEmptyResult() { - entityGenerator.setupTestPolicies(); - val userFilter = new SearchFilter("name", "Study004"); - val aclEntities = - policyService.listPolicies(Arrays.asList(userFilter), new PageableResolver().getPageable()); - assertThat(aclEntities.getTotalElements()).isEqualTo(0L); - } - - // Update - @Test - public void testUpdate() { - val policy = entityGenerator.setupPolicy("Study001", groups.get(0).getName()); - val updateRequest = PolicyRequest.builder().name("StudyOne").build(); - val updated = policyService.partialUpdate(policy.getId(), updateRequest); - assertThat(updated.getName()).isEqualTo("StudyOne"); - } - - // Delete - @Test - public void testDelete() { - entityGenerator.setupTestPolicies(); - val policy = policyService.getByName("Study001"); - policyService.delete(policy.getId()); - - val remainingAclEntities = - policyService.listPolicies(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(remainingAclEntities.getTotalElements()).isEqualTo(2L); - assertThat(remainingAclEntities.getContent()).doesNotContain(policy); - } -} diff --git a/src/test/java/bio/overture/ego/service/UserServiceTest.java b/src/test/java/bio/overture/ego/service/UserServiceTest.java index 0b8aeaf30..0777654b9 100644 --- a/src/test/java/bio/overture/ego/service/UserServiceTest.java +++ b/src/test/java/bio/overture/ego/service/UserServiceTest.java @@ -1,46 +1,13 @@ package bio.overture.ego.service; -import static bio.overture.ego.model.enums.AccessLevel.DENY; -import static bio.overture.ego.model.enums.AccessLevel.READ; import static bio.overture.ego.model.enums.AccessLevel.WRITE; -import static bio.overture.ego.model.enums.LanguageType.ENGLISH; -import static bio.overture.ego.model.enums.StatusType.APPROVED; -import static bio.overture.ego.model.enums.StatusType.DISABLED; -import static bio.overture.ego.model.enums.StatusType.PENDING; -import static bio.overture.ego.model.enums.UserType.ADMIN; -import static bio.overture.ego.model.enums.UserType.USER; -import static bio.overture.ego.service.UserService.USER_CONVERTER; -import static bio.overture.ego.utils.Collectors.toImmutableSet; -import static bio.overture.ego.utils.EntityGenerator.generateNonExistentId; -import static com.google.common.collect.Lists.newArrayList; -import static java.util.Arrays.asList; -import static java.util.Collections.singletonList; -import static java.util.UUID.randomUUID; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatExceptionOfType; +import static bio.overture.ego.utils.CollectionUtils.repeatedCallsOf; +import static java.util.stream.Collectors.toList; -import bio.overture.ego.controller.resolver.PageableResolver; -import bio.overture.ego.model.dto.CreateUserRequest; -import bio.overture.ego.model.dto.PermissionRequest; -import bio.overture.ego.model.dto.UpdateUserRequest; -import bio.overture.ego.model.entity.AbstractPermission; -import bio.overture.ego.model.entity.Application; -import bio.overture.ego.model.entity.User; -import bio.overture.ego.model.exceptions.NotFoundException; -import bio.overture.ego.model.exceptions.UniqueViolationException; -import bio.overture.ego.model.search.SearchFilter; -import bio.overture.ego.token.IDToken; import bio.overture.ego.utils.EntityGenerator; -import bio.overture.ego.utils.PolicyPermissionUtils; -import com.google.common.collect.ImmutableList; -import java.util.Collections; -import java.util.Date; -import java.util.UUID; -import java.util.stream.Collectors; -import java.util.stream.IntStream; import lombok.extern.slf4j.Slf4j; import lombok.val; -import org.junit.Ignore; +import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; @@ -54,874 +21,50 @@ @RunWith(SpringRunner.class) @ActiveProfiles("test") @Transactional -@Ignore("replace with controller tests.") public class UserServiceTest { - private static final UUID NON_EXISTENT_USER = - UUID.fromString("827fae28-7fb8-11e8-adc0-fa7ae01bbebc"); - - @Autowired private ApplicationService applicationService; @Autowired private UserService userService; - @Autowired private GroupService groupService; - @Autowired private PolicyService policyService; @Autowired private EntityGenerator entityGenerator; - @Autowired private UserPermissionService userPermissionService; - - @Test - public void userConverter_UpdateUserRequest_User() { - val email = System.currentTimeMillis() + "@gmail.com"; - val firstName = "John"; - val lastName = "Doe"; - val userType = ADMIN; - val status = APPROVED; - val preferredLanguage = ENGLISH; - val id = randomUUID(); - val createdAt = new Date(); - - val applications = - IntStream.range(0, 3) - .boxed() - .map(x -> Application.builder().id(randomUUID()).build()) - .collect(toImmutableSet()); - - val user = - User.builder() - .email(email) - .firstName(firstName) - .lastName(lastName) - .type(userType) - .status(status) - .preferredLanguage(preferredLanguage) - .id(id) - .createdAt(createdAt) - .applications(applications) - .userPermissions(null) - .build(); - - val partialUserUpdateRequest = - UpdateUserRequest.builder().firstName("Rob").status(DISABLED).build(); - USER_CONVERTER.updateUser(partialUserUpdateRequest, user); - - assertThat(user.getPreferredLanguage()).isEqualTo(preferredLanguage); - assertThat(user.getCreatedAt()).isEqualTo(createdAt); - assertThat(user.getStatus()).isEqualTo(DISABLED); - assertThat(user.getLastName()).isEqualTo(lastName); - assertThat(user.getName()).isEqualTo(email); - assertThat(user.getEmail()).isEqualTo(email); - assertThat(user.getFirstName()).isEqualTo("Rob"); - assertThat(user.getType()).isEqualTo(userType); - assertThat(user.getId()).isEqualTo(id); - assertThat(user.getApplications()).containsExactlyInAnyOrderElementsOf(applications); - assertThat(user.getUserPermissions()).isNull(); - assertThat(user.getUserGroups()).isEmpty(); - } - - @Test - public void userConversion_CreateUserRequest_User() { - val t = System.currentTimeMillis(); - val request = - CreateUserRequest.builder() - .email(t + "@gmail.com") - .firstName("John") - .type(ADMIN) - .status(APPROVED) - .preferredLanguage(ENGLISH) - .build(); - val user = USER_CONVERTER.convertToUser(request); - assertThat(user.getEmail()).isEqualTo(request.getEmail()); - assertThat(user.getName()).isEqualTo(user.getEmail()); - assertThat(user.getCreatedAt()).isNotNull(); - assertThat(user.getId()).isNull(); - assertThat(user.getLastName()).isNull(); - assertThat(user.getFirstName()).isEqualTo(request.getFirstName()); - assertThat(user.getType()).isEqualTo(request.getType()); - assertThat(user.getStatus()).isEqualTo(request.getStatus()); - assertThat(user.getPreferredLanguage()).isEqualTo(request.getPreferredLanguage()); - assertThat(user.getUserGroups()).isEmpty(); - assertThat(user.getUserPermissions()).isEmpty(); - assertThat(user.getApplications()).isEmpty(); - } - - // Create - @Test - public void testCreate() { - val user = entityGenerator.setupUser("Demo User"); - // UserName == UserEmail - assertThat(user.getName()).isEqualTo("DemoUser@domain.com"); - } - - @Test - public void testCreateFromIDToken() { - val idToken = - IDToken.builder() - .email("UserOne@domain.com") - .given_name("User") - .family_name("User") - .build(); - - val idTokenUser = userService.createFromIDToken(idToken); - - assertThat(idTokenUser.getName()).isEqualTo("UserOne@domain.com"); - assertThat(idTokenUser.getEmail()).isEqualTo("UserOne@domain.com"); - assertThat(idTokenUser.getFirstName()).isEqualTo("User"); - assertThat(idTokenUser.getLastName()).isEqualTo("User"); - assertThat(idTokenUser.getStatus()).isEqualTo("Approved"); - assertThat(idTokenUser.getType()).isEqualTo("USER"); - } - - @Test - public void testCreateFromIDTokenUniqueNameAndEmail() { - // Note: This test has one strike due to Hibernate Cache. - entityGenerator.setupUser("User One"); - val idToken = - IDToken.builder().email("UserOne@domain.com").given_name("User").family_name("One").build(); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> userService.createFromIDToken(idToken)); - } - - // Get - @Test - public void testGet() { - val user = entityGenerator.setupUser("User One"); - val savedUser = userService.getById(user.getId()); - assertThat(savedUser.getName()).isEqualTo("UserOne@domain.com"); - } - - @Test - public void testGetNotFoundException() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> userService.getById(NON_EXISTENT_USER)); - } - - @Test - public void testGetByName() { - entityGenerator.setupUser("User One"); - val savedUser = userService.getByName("UserOne@domain.com"); - assertThat(savedUser.getName()).isEqualTo("UserOne@domain.com"); - } - - @Test - public void testGetByNameAllCaps() { - entityGenerator.setupUser("User One"); - val savedUser = userService.getByName("USERONE@DOMAIN.COM"); - assertThat(savedUser.getName()).isEqualTo("UserOne@domain.com"); - } - - @Test - @Ignore - public void testGetByNameNotFound() { - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> userService.getByName("UserOne@domain.com")); - } - - // List Users - @Test - public void testListUsersNoFilters() { - entityGenerator.setupTestUsers(); - val users = - userService.listUsers(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(users.getTotalElements()).isEqualTo(3L); - } - - @Test - public void testListUsersNoFiltersEmptyResult() { - val users = - userService.listUsers(Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(users.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testListUsersFiltered() { - entityGenerator.setupTestUsers(); - val userFilter = new SearchFilter("email", "FirstUser@domain.com"); - val users = - userService.listUsers(singletonList(userFilter), new PageableResolver().getPageable()); - assertThat(users.getTotalElements()).isEqualTo(1L); - } - - @Test - public void testListUsersFilteredEmptyResult() { - entityGenerator.setupTestUsers(); - val userFilter = new SearchFilter("email", "FourthUser@domain.com"); - val users = - userService.listUsers(singletonList(userFilter), new PageableResolver().getPageable()); - assertThat(users.getTotalElements()).isEqualTo(0L); - } - - // Find Users - @Test - public void testFindUsersNoFilters() { - entityGenerator.setupTestUsers(); - val users = - userService.findUsers( - "First", Collections.emptyList(), new PageableResolver().getPageable()); - assertThat(users.getTotalElements()).isEqualTo(1L); - assertThat(users.getContent().get(0).getName()).isEqualTo("FirstUser@domain.com"); - } - - @Test - public void testFindUsersFiltered() { - entityGenerator.setupTestUsers(); - val userFilter = new SearchFilter("email", "FirstUser@domain.com"); - val users = - userService.findUsers( - "Second", singletonList(userFilter), new PageableResolver().getPageable()); - // Expect empty list - assertThat(users.getTotalElements()).isEqualTo(0L); - } - // Find Group Users - @Test - public void testFindGroupUsersNoQueryNoFilters() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = (userService.getByName("SecondUser@domain.com")); - val groupId = groupService.getByName("Group One").getId(); - - userService.associateGroupsWithUser(user.getId(), singletonList(groupId)); - userService.associateGroupsWithUser(userTwo.getId(), singletonList(groupId)); - - val users = - userService.findUsersForGroup( - groupId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(2L); - assertThat(users.getContent()).contains(user, userTwo); - } - - @Test - public void testFindGroupUsersNoQueryNoFiltersNoUsersFound() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val groupId = groupService.getByName("Group One").getId(); - - val users = - userService.findUsersForGroup( - groupId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindGroupUsersNoQueryFilters() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = userService.getByName("SecondUser@domain.com"); - val groupId = groupService.getByName("Group One").getId(); - - userService.associateGroupsWithUser(user.getId(), newArrayList(groupId)); - userService.associateGroupsWithUser(userTwo.getId(), newArrayList(groupId)); - - val userFilters = new SearchFilter("name", "First"); - - val users = - userService.findUsersForGroup( - groupId, ImmutableList.of(userFilters), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(1L); - assertThat(users.getContent()).contains(user); - } - - @Test - public void testFindGroupUsersQueryAndFilters() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = (userService.getByName("SecondUser@domain.com")); - val groupId = groupService.getByName("Group One").getId(); - - userService.associateGroupsWithUser(user.getId(), singletonList(groupId)); - userService.associateGroupsWithUser(userTwo.getId(), singletonList(groupId)); - - val userFilters = new SearchFilter("name", "First"); - - val users = - userService.findUsersForGroup( - groupId, "Second", ImmutableList.of(userFilters), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindGroupUsersQueryNoFilters() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = (userService.getByName("SecondUser@domain.com")); - val groupId = groupService.getByName("Group One").getId(); - - userService.associateGroupsWithUser(user.getId(), singletonList(groupId)); - userService.associateGroupsWithUser(userTwo.getId(), singletonList(groupId)); - val users = - userService.findUsersForGroup( - groupId, "Second", ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(1L); - assertThat(users.getContent()).contains(userTwo); - } - - // Find App Users - - @Test - public void testFindAppUsersNoQueryNoFilters() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = (userService.getByName("SecondUser@domain.com")); - val appId = applicationService.getByClientId("111111").getId(); - - userService.addUserToApps(user.getId(), singletonList(appId)); - userService.addUserToApps(userTwo.getId(), singletonList(appId)); - - val users = - userService.findUsersForApplication( - appId, Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(2L); - assertThat(users.getContent()).contains(user, userTwo); - } - - @Test - public void testFindAppUsersNoQueryNoFiltersNoUser() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val appId = applicationService.getByClientId("111111").getId(); - - val users = - userService.findUsersForApplication( - appId, Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindAppUsersNoQueryFilters() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = (userService.getByName("SecondUser@domain.com")); - val appId = applicationService.getByClientId("111111").getId(); - - userService.addUserToApps(user.getId(), singletonList(appId)); - userService.addUserToApps(userTwo.getId(), singletonList(appId)); - - val userFilters = new SearchFilter("name", "First"); - - val users = - userService.findUsersForApplication( - appId, singletonList(userFilters), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(1L); - assertThat(users.getContent()).contains(user); - } - - @Test - public void testFindAppUsersQueryAndFilters() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = (userService.getByName("SecondUser@domain.com")); - val appId = applicationService.getByClientId("111111").getId(); - - userService.addUserToApps(user.getId(), singletonList(appId)); - userService.addUserToApps(userTwo.getId(), singletonList(appId)); - - val userFilters = new SearchFilter("name", "First"); - - val users = - userService.findUsersForApplication( - appId, "Second", singletonList(userFilters), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(0L); - } - - @Test - public void testFindAppUsersQueryNoFilters() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val user = userService.getByName("FirstUser@domain.com"); - val userTwo = (userService.getByName("SecondUser@domain.com")); - val appId = applicationService.getByClientId("111111").getId(); - - userService.addUserToApps(user.getId(), singletonList(appId)); - userService.addUserToApps(userTwo.getId(), singletonList(appId)); - - val users = - userService.findUsersForApplication( - appId, "First", Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(users.getTotalElements()).isEqualTo(1L); - assertThat(users.getContent()).contains(user); - } - - // Update - @Test - public void testUpdate() { - val user = entityGenerator.setupUser("First User"); - val updated = - userService.partialUpdate( - user.getId(), UpdateUserRequest.builder().firstName("NotFirst").build()); - assertThat(updated.getFirstName()).isEqualTo("NotFirst"); - } - - @Test - public void testUpdateTypeUser() { - val user = entityGenerator.setupUser("First User"); - val updated = - userService.partialUpdate(user.getId(), UpdateUserRequest.builder().type(USER).build()); - assertThat(updated.getType()).isEqualTo("USER"); - } - - @Test - public void testUpdateUserTypeAdmin() { - val user = entityGenerator.setupUser("First User"); - val updated = - userService.partialUpdate(user.getId(), UpdateUserRequest.builder().type(ADMIN).build()); - assertThat(updated.getType()).isEqualTo("ADMIN"); - } - - @Test - public void uniqueEmailCheck_CreateUser_ThrowsUniqueConstraintException() { - val r1 = - CreateUserRequest.builder() - .preferredLanguage(ENGLISH) - .type(ADMIN) - .status(APPROVED) - .email(UUID.randomUUID() + "@gmail.com") - .build(); - - val u1 = userService.create(r1); - assertThat(userService.isExist(u1.getId())).isTrue(); - r1.setType(USER); - r1.setStatus(PENDING); - - assertThat(u1.getEmail()).isEqualTo(r1.getEmail()); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> userService.create(r1)); - } - - @Test - public void uniqueEmailCheck_UpdateUser_ThrowsUniqueConstraintException() { - val e1 = UUID.randomUUID().toString() + "@something.com"; - val e2 = UUID.randomUUID().toString() + "@something.com"; - val cr1 = - CreateUserRequest.builder() - .preferredLanguage(ENGLISH) - .type(ADMIN) - .status(APPROVED) - .email(e1) - .build(); - - val cr2 = - CreateUserRequest.builder() - .preferredLanguage(ENGLISH) - .type(USER) - .status(PENDING) - .email(e2) - .build(); - - val u1 = userService.create(cr1); - assertThat(userService.isExist(u1.getId())).isTrue(); - val u2 = userService.create(cr2); - assertThat(userService.isExist(u2.getId())).isTrue(); - - val ur3 = UpdateUserRequest.builder().email(e1).build(); - - assertThat(u1.getEmail()).isEqualTo(ur3.getEmail()); - assertThat(u2.getEmail()).isNotEqualTo(ur3.getEmail()); - assertThatExceptionOfType(UniqueViolationException.class) - .isThrownBy(() -> userService.partialUpdate(u2.getId(), ur3)); - } - - @Test - public void testUpdateNonexistentEntity() { - val nonExistentId = generateNonExistentId(userService); - val updateRequest = - UpdateUserRequest.builder() - .firstName("Doesnot") - .lastName("Exist") - .status(APPROVED) - .preferredLanguage(ENGLISH) - .lastLogin(null) - .type(ADMIN) - .build(); - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> userService.partialUpdate(nonExistentId, updateRequest)); - } - - // Add User to Groups - @Test - public void addUserToGroups() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - val groupId = group.getId(); - val groupTwo = groupService.getByName("Group Two"); - val groupTwoId = groupTwo.getId(); - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.associateGroupsWithUser(userId, asList(groupId, groupTwoId)); - - val groups = - groupService.findGroupsForUser( - userId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(groups.getContent()).contains(group, groupTwo); - } - - @Test - public void addUserToGroupsNoUser() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - val groupId = group.getId(); - - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy( - () -> userService.associateGroupsWithUser(NON_EXISTENT_USER, singletonList(groupId))); - } - - @Test - public void addUserToGroupsWithGroupsListOneEmptyString() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy(() -> userService.associateGroupsWithUser(userId, ImmutableList.of())); - } - - @Test - public void addUserToGroupsEmptyGroupsList() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.associateGroupsWithUser(userId, Collections.emptyList()); - - val nonUpdated = userService.getByName("FirstUser@domain.com"); - assertThat(nonUpdated).isEqualTo(user); - } - - // Add User to Apps - @Test - public void addUserToApps() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val app = applicationService.getByClientId("111111"); - val appId = app.getId(); - val appTwo = applicationService.getByClientId("222222"); - val appTwoId = appTwo.getId(); - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.addUserToApps(userId, asList(appId, appTwoId)); - - val apps = - applicationService.findApplicationsForUser( - userId, Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(apps.getContent()).contains(app, appTwo); - } - - @Test - public void addUserToAppsNoUser() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val app = applicationService.getByClientId("111111"); - val appId = app.getId(); - - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> userService.addUserToApps(NON_EXISTENT_USER, singletonList(appId))); - } - - @Test - public void addUserToAppsWithAppsListOneEmptyString() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy(() -> userService.addUserToApps(userId, ImmutableList.of())); - } - - @Test - public void addUserToAppsEmptyAppsList() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.addUserToApps(userId, Collections.emptyList()); - - val nonUpdated = userService.getByName("FirstUser@domain.com"); - assertThat(nonUpdated).isEqualTo(user); - } - - // Delete - @Test - public void testDelete() { - entityGenerator.setupTestUsers(); - - val usersBefore = - userService.listUsers(Collections.emptyList(), new PageableResolver().getPageable()); - - val user = userService.getByName("FirstUser@domain.com"); - - userService.delete(user.getId()); - - val usersAfter = - userService.listUsers(Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(usersBefore.getTotalElements() - usersAfter.getTotalElements()).isEqualTo(1L); - assertThat(usersAfter.getContent()).doesNotContain(user); - } - - @Test - public void testDeleteNonExisting() { - entityGenerator.setupTestUsers(); - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> userService.delete(NON_EXISTENT_USER)); - } - - // Delete User from Group - @Test - public void testDeleteUserFromGroup() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - val groupId = group.getId(); - val groupTwo = groupService.getByName("Group Two"); - val groupTwoId = groupTwo.getId(); - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.associateGroupsWithUser(userId, asList(groupId, groupTwoId)); - - userService.disassociateGroupsFromUser(userId, singletonList(groupId)); - - val groupWithoutUser = - groupService.findGroupsForUser( - userId, ImmutableList.of(), new PageableResolver().getPageable()); - - assertThat(groupWithoutUser.getContent()).containsOnly(groupTwo); - } - - @Test - public void testDeleteUserFromGroupNoUser() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val group = groupService.getByName("Group One"); - val groupId = group.getId(); - val groupTwo = groupService.getByName("Group Two"); - val groupTwoId = groupTwo.getId(); - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.associateGroupsWithUser(userId, asList(groupId, groupTwoId)); - - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy( - () -> - userService.disassociateGroupsFromUser(NON_EXISTENT_USER, singletonList(groupId))); - } - - @Test - public void testDeleteUserFromGroupEmptyGroupsList() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - val group = groupService.getByName("Group One"); - val groupId = group.getId(); - - userService.associateGroupsWithUser(userId, singletonList(groupId)); - assertThat(user.getUserGroups().size()).isEqualTo(1); - - assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy(() -> userService.disassociateGroupsFromUser(userId, ImmutableList.of())); - } - - // Delete User from App - @Test - public void testDeleteUserFromApp() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val app = applicationService.getByClientId("111111"); - val appId = app.getId(); - val appTwo = applicationService.getByClientId("222222"); - val appTwoId = appTwo.getId(); - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.addUserToApps(userId, asList(appId, appTwoId)); - - userService.deleteUserFromApps(userId, singletonList(appId)); - - val groupWithoutUser = - applicationService.findApplicationsForUser( - userId, Collections.emptyList(), new PageableResolver().getPageable()); - - assertThat(groupWithoutUser.getContent()).containsOnly(appTwo); - } @Test - public void testDeleteUserFromAppNoUser() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); + public void testGetManyUsersWithRelations() { + int numUsers = 3; - val app = applicationService.getByClientId("111111"); - val appId = app.getId(); - val appTwo = applicationService.getByClientId("222222"); - val appTwoId = appTwo.getId(); - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.addUserToApps(userId, asList(appId, appTwoId)); - - assertThatExceptionOfType(NotFoundException.class) - .isThrownBy(() -> userService.deleteUserFromApps(NON_EXISTENT_USER, singletonList(appId))); - } - - @Test - public void testDeleteUserFromAppEmptyAppsList() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestApplications(); - - val app = applicationService.getByClientId("111111"); - val appId = app.getId(); - val appTwo = applicationService.getByClientId("222222"); - val appTwoId = appTwo.getId(); - val user = userService.getByName("FirstUser@domain.com"); - val userId = user.getId(); - - userService.addUserToApps(userId, asList(appId, appTwoId)); - - assertThatExceptionOfType(IllegalArgumentException.class) - .isThrownBy(() -> userService.deleteUserFromApps(userId, ImmutableList.of())); - } - - @Test - public void testAddUserPermissions() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - entityGenerator.setupTestPolicies(); - - val user = userService.getByName("FirstUser@domain.com"); - - val study001 = policyService.getByName("Study001"); - val study001id = study001.getId(); - - val study002 = policyService.getByName("Study002"); - val study002id = study002.getId(); - - val study003 = policyService.getByName("Study003"); - val study003id = study003.getId(); - - val permissions = - asList( - new PermissionRequest(study001id, READ), - new PermissionRequest(study002id, WRITE), - new PermissionRequest(study003id, DENY)); - - userPermissionService.addPermissions(user.getId(), permissions); - - assertThat(PolicyPermissionUtils.extractPermissionStrings(user.getUserPermissions())) - .containsExactlyInAnyOrder("Study001.READ", "Study002.WRITE", "Study003.DENY"); - } - - @Test - public void testRemoveUserPermissions() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - entityGenerator.setupTestPolicies(); - - val user = userService.getByName("FirstUser@domain.com"); - - val study001 = policyService.getByName("Study001"); - val study001id = study001.getId(); - - val study002 = policyService.getByName("Study002"); - val study002id = study002.getId(); - - val study003 = policyService.getByName("Study003"); - val study003id = study003.getId(); - - val permissions = - asList( - new PermissionRequest(study001id, READ), - new PermissionRequest(study002id, WRITE), - new PermissionRequest(study003id, DENY)); - - userPermissionService.addPermissions(user.getId(), permissions); - - val userPermissionsToRemove = - user.getUserPermissions().stream() - .filter(p -> !p.getPolicy().getName().equals("Study001")) - .map(AbstractPermission::getId) - .collect(Collectors.toList()); - - userPermissionService.deletePermissions(user.getId(), userPermissionsToRemove); - - assertThat(PolicyPermissionUtils.extractPermissionStrings(user.getUserPermissions())) - .containsExactlyInAnyOrder("Study001.READ"); - } - - @Test - public void testGetUserPermissions() { - entityGenerator.setupTestUsers(); - entityGenerator.setupTestGroups(); - entityGenerator.setupTestPolicies(); + val users = repeatedCallsOf(() -> entityGenerator.generateRandomUser(), numUsers); - val user = userService.getByName("FirstUser@domain.com"); + // Create a group and add it to first few users + val group = entityGenerator.setupGroup("UserServiceTestGroup"); + val groupWithUsers = entityGenerator.addUsersToGroup(users.stream().collect(toList()), group); - val study001 = policyService.getByName("Study001"); - val study001id = study001.getId(); + // Create application and add it to last few users + val application = entityGenerator.setupApplication("UserServiceTestApplicaiton"); + entityGenerator.addUsersToApplication(users.stream().collect(toList()), application); - val study002 = policyService.getByName("Study002"); - val study002id = study002.getId(); + // Create policy and add permission to users + val policy = entityGenerator.setupSinglePolicy("UserServiceTestPolicy"); + entityGenerator.setupGroupPermission(groupWithUsers, policy, WRITE); - val study003 = policyService.getByName("Study003"); - val study003id = study003.getId(); + // Update testUsers now that they have relations + val reply = + userService.getMany( + users.stream().map(user -> user.getId()).collect(toList()), true, true, true); - val permissions = - asList( - new PermissionRequest(study001id, READ), - new PermissionRequest(study002id, WRITE), - new PermissionRequest(study003id, DENY)); + Assert.assertEquals(reply.size(), numUsers); - userPermissionService.addPermissions(user.getId(), permissions); + reply.forEach( + user -> { + Assert.assertEquals(user.getUserGroups().size(), 1); + Assert.assertEquals( + user.getUserGroups().iterator().next().getGroup().getName(), group.getName()); - val pagedUserPermissions = - userPermissionService.getPermissions(user.getId(), new PageableResolver().getPageable()); + Assert.assertEquals(user.getUserApplications().size(), 1); + Assert.assertEquals( + user.getUserApplications().iterator().next().getApplication().getName(), + application.getName()); - assertThat(pagedUserPermissions.getTotalElements()).isEqualTo(3L); + Assert.assertEquals(user.getPermissions().size(), 1); + Assert.assertEquals( + user.getPermissions().iterator().next(), "UserServiceTestPolicy.WRITE"); + }); } } diff --git a/src/test/java/bio/overture/ego/token/ListTokenTest.java b/src/test/java/bio/overture/ego/token/ListTokenTest.java index b6fe98063..156327d23 100644 --- a/src/test/java/bio/overture/ego/token/ListTokenTest.java +++ b/src/test/java/bio/overture/ego/token/ListTokenTest.java @@ -86,7 +86,7 @@ public void testListToken() { .description("Test token 2.") .build()); - assertTrue((responseList.stream().allMatch(expected::contains))); + assertTrue(responseList.stream().allMatch(expected::contains)); } @Test diff --git a/src/test/java/bio/overture/ego/utils/EntityGenerator.java b/src/test/java/bio/overture/ego/utils/EntityGenerator.java index 62b0ea68c..35ca5db9e 100644 --- a/src/test/java/bio/overture/ego/utils/EntityGenerator.java +++ b/src/test/java/bio/overture/ego/utils/EntityGenerator.java @@ -15,11 +15,7 @@ import static java.util.stream.Collectors.toSet; import static org.assertj.core.api.Assertions.assertThat; -import bio.overture.ego.model.dto.CreateApplicationRequest; -import bio.overture.ego.model.dto.CreateUserRequest; -import bio.overture.ego.model.dto.GroupRequest; -import bio.overture.ego.model.dto.PolicyRequest; -import bio.overture.ego.model.dto.Scope; +import bio.overture.ego.model.dto.*; import bio.overture.ego.model.entity.Application; import bio.overture.ego.model.entity.Group; import bio.overture.ego.model.entity.Policy; @@ -32,24 +28,11 @@ import bio.overture.ego.model.enums.StatusType; import bio.overture.ego.model.enums.UserType; import bio.overture.ego.model.params.ScopeName; -import bio.overture.ego.service.ApplicationService; -import bio.overture.ego.service.BaseService; -import bio.overture.ego.service.GroupService; -import bio.overture.ego.service.NamedService; -import bio.overture.ego.service.PolicyService; -import bio.overture.ego.service.TokenService; -import bio.overture.ego.service.TokenStoreService; -import bio.overture.ego.service.UserPermissionService; -import bio.overture.ego.service.UserService; +import bio.overture.ego.service.*; import com.google.common.collect.ImmutableSet; import java.time.Instant; import java.time.temporal.ChronoUnit; -import java.util.Date; -import java.util.List; -import java.util.Optional; -import java.util.Random; -import java.util.Set; -import java.util.UUID; +import java.util.*; import java.util.function.Supplier; import lombok.NonNull; import lombok.val; @@ -75,6 +58,7 @@ public class EntityGenerator { @Autowired private UserService userService; @Autowired private GroupService groupService; + @Autowired private GroupPermissionService groupPermissionService; @Autowired private PolicyService policyService; @@ -127,6 +111,15 @@ public Application setupApplication( }); } + public Application addUsersToApplication(Collection users, Application app) { + val appIdList = Arrays.asList(app.getId()); + + users.stream() + .forEach(user -> userService.associateApplicationsWithUser(user.getId(), appIdList)); + + return applicationService.getById(app.getId()); + } + public User setupUser(String name) { val names = name.split(" ", 2); val userName = String.format("%s%s@domain.com", names[0], names[1]); @@ -157,6 +150,11 @@ public Group setupGroup(String name) { }); } + public Group addUsersToGroup(Collection users, Group group) { + val userIds = users.stream().map(user -> user.getId()).collect(toList()); + return groupService.associateUsersWithGroup(group.getId(), userIds); + } + private CreateUserRequest createUser(String firstName, String lastName) { return CreateUserRequest.builder() .email(String.format("%s%s@domain.com", firstName, lastName)) @@ -299,30 +297,29 @@ public Policy setupSinglePolicy(String name) { }); } - public Policy setupPolicy(String name, String groupName) { - return policyService - .findByName(name) - .orElseGet( - () -> { - val createRequest = createPolicyRequest(name); - return policyService.create(createRequest); - }); + public Policy setupGroupPermission(Group group, Policy policy, AccessLevel level) { + + val permission = PermissionRequest.builder().mask(level).policyId(policy.getId()).build(); + + groupPermissionService.addPermissions(group.getId(), Arrays.asList(permission)); + + return policy; } public Policy setupPolicy(@NonNull String csv) { val args = newArrayList(COMMA_SPLITTER.split(csv)); assertThat(args).hasSize(2); val name = args.get(0); - val groupName = args.get(1); - return setupPolicy(name, groupName); + + return setupSinglePolicy(name); } public List setupPolicies(String... names) { - return mapToList(listOf(names), this::setupPolicy); + return mapToList(listOf(names), this::setupSinglePolicy); } public void setupTestPolicies() { - setupPolicies("Study001,Group One", "Study002,Group Two", "Study003,Group Three"); + setupPolicies("Study001", "Study002", "Study003"); } public Token setupToken( @@ -364,6 +361,13 @@ public void addPermissions(User user, Set scopes) { userService.getRepository().save(user); } + public void addPermissionToUsers(Collection users, Policy policy, AccessLevel level) { + val permission = PermissionRequest.builder().mask(level).policyId(policy.getId()).build(); + users.stream() + .forEach( + user -> userPermissionService.addPermissions(user.getId(), Arrays.asList(permission))); + } + public String generateNonExistentUserName() { val r = new Random(); String name; diff --git a/src/test/java/bio/overture/ego/utils/TestData.java b/src/test/java/bio/overture/ego/utils/TestData.java index 25594708a..c794e21c7 100644 --- a/src/test/java/bio/overture/ego/utils/TestData.java +++ b/src/test/java/bio/overture/ego/utils/TestData.java @@ -55,7 +55,7 @@ public TestData(EntityGenerator entityGenerator) { policyMap = new HashMap<>(); for (val p : allPolicies) { - val policy = entityGenerator.setupPolicy(p, "admin"); + val policy = entityGenerator.setupSinglePolicy(p); policyMap.put(p, policy); } diff --git a/src/test/java/bio/overture/ego/utils/web/ResponseOption.java b/src/test/java/bio/overture/ego/utils/web/ResponseOption.java index f51e56055..e03b064ed 100644 --- a/src/test/java/bio/overture/ego/utils/web/ResponseOption.java +++ b/src/test/java/bio/overture/ego/utils/web/ResponseOption.java @@ -1,6 +1,5 @@ package bio.overture.ego.utils.web; -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; import static org.springframework.http.HttpStatus.BAD_REQUEST; import static org.springframework.http.HttpStatus.CONFLICT; import static org.springframework.http.HttpStatus.NOT_FOUND; @@ -10,6 +9,7 @@ import lombok.Getter; import lombok.NonNull; import lombok.RequiredArgsConstructor; +import org.junit.Assert; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; @@ -19,7 +19,7 @@ public class ResponseOption> { @Getter @NonNull private final ResponseEntity response; public O assertStatusCode(HttpStatus code) { - assertThat(response.getStatusCode()).isEqualTo(code); + Assert.assertEquals(response.getStatusCode(), code); return thisInstance(); } @@ -40,8 +40,8 @@ public O assertBadRequest() { } public O assertHasBody() { - assertThat(response.hasBody()).isTrue(); - assertThat(response.getBody()).isNotNull(); + Assert.assertTrue(response.hasBody()); + Assert.assertNotNull(response.getBody()); return thisInstance(); } diff --git a/src/test/java/bio/overture/ego/selenium/AbstractSeleniumTest.java b/src/test/java/selenium/AbstractSeleniumTest.java similarity index 91% rename from src/test/java/bio/overture/ego/selenium/AbstractSeleniumTest.java rename to src/test/java/selenium/AbstractSeleniumTest.java index b54c98c6d..215c356f1 100644 --- a/src/test/java/bio/overture/ego/selenium/AbstractSeleniumTest.java +++ b/src/test/java/selenium/AbstractSeleniumTest.java @@ -15,12 +15,9 @@ * */ -package bio.overture.ego.selenium; +package selenium; import bio.overture.ego.AuthorizationServiceMain; -import bio.overture.ego.selenium.driver.WebDriverFactory; -import bio.overture.ego.selenium.rule.AssumingSeleniumEnvironment; -import bio.overture.ego.selenium.rule.SeleniumEnvironmentChecker; import java.util.HashMap; import java.util.Map; import lombok.SneakyThrows; @@ -33,6 +30,9 @@ import org.springframework.test.context.ActiveProfiles; import org.springframework.test.context.junit4.SpringRunner; import org.testcontainers.containers.GenericContainer; +import selenium.driver.WebDriverFactory; +import selenium.rule.AssumingSeleniumEnvironment; +import selenium.rule.SeleniumEnvironmentChecker; @Slf4j @ActiveProfiles({"test", "secure", "auth"}) diff --git a/src/test/java/bio/overture/ego/selenium/LoadAdminUITest.java b/src/test/java/selenium/LoadAdminUITest.java similarity index 91% rename from src/test/java/bio/overture/ego/selenium/LoadAdminUITest.java rename to src/test/java/selenium/LoadAdminUITest.java index 4c5ee5849..be3e4a159 100644 --- a/src/test/java/bio/overture/ego/selenium/LoadAdminUITest.java +++ b/src/test/java/selenium/LoadAdminUITest.java @@ -15,16 +15,16 @@ * */ -package bio.overture.ego.selenium; +package selenium; import static bio.overture.ego.model.enums.ApplicationType.ADMIN; import static bio.overture.ego.model.enums.StatusType.APPROVED; -import static org.assertj.core.api.Assertions.assertThat; import bio.overture.ego.model.dto.CreateApplicationRequest; import bio.overture.ego.service.ApplicationService; import lombok.SneakyThrows; import lombok.val; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.openqa.selenium.By; import org.springframework.beans.factory.annotation.Autowired; @@ -56,7 +56,7 @@ public void loadAdmin_Success() { driver.get("http://localhost:" + uiPort); val titleText = driver.findElement(By.className("Login")).findElement(By.tagName("h1")).getText(); - assertThat(titleText).isEqualTo("Admin Portal"); + Assertions.assertThat(titleText).isEqualTo("Admin Portal"); driver.findElement(By.className("fa-facebook")).click(); @@ -76,7 +76,8 @@ public void loadAdmin_Success() { .findElement(By.tagName("div")) .findElement(By.tagName("div")) .getText(); - assertThat(messageDiv).contains("Your account does not have an administrator userType."); + Assertions.assertThat(messageDiv) + .contains("Your account does not have an administrator userType."); Thread.sleep(1000); } diff --git a/src/test/java/bio/overture/ego/selenium/driver/BrowserStackDriverProxy.java b/src/test/java/selenium/driver/BrowserStackDriverProxy.java similarity index 96% rename from src/test/java/bio/overture/ego/selenium/driver/BrowserStackDriverProxy.java rename to src/test/java/selenium/driver/BrowserStackDriverProxy.java index 0a3a3f099..34e697917 100644 --- a/src/test/java/bio/overture/ego/selenium/driver/BrowserStackDriverProxy.java +++ b/src/test/java/selenium/driver/BrowserStackDriverProxy.java @@ -15,7 +15,7 @@ * */ -package bio.overture.ego.selenium.driver; +package selenium.driver; import com.browserstack.local.Local; import java.net.URL; diff --git a/src/test/java/bio/overture/ego/selenium/driver/WebDriverFactory.java b/src/test/java/selenium/driver/WebDriverFactory.java similarity index 98% rename from src/test/java/bio/overture/ego/selenium/driver/WebDriverFactory.java rename to src/test/java/selenium/driver/WebDriverFactory.java index ba6f56521..27f683398 100644 --- a/src/test/java/bio/overture/ego/selenium/driver/WebDriverFactory.java +++ b/src/test/java/selenium/driver/WebDriverFactory.java @@ -15,7 +15,7 @@ * */ -package bio.overture.ego.selenium.driver; +package selenium.driver; import com.browserstack.local.Local; import java.io.FileReader; diff --git a/src/test/java/bio/overture/ego/selenium/rule/AssumingSeleniumEnvironment.java b/src/test/java/selenium/rule/AssumingSeleniumEnvironment.java similarity index 93% rename from src/test/java/bio/overture/ego/selenium/rule/AssumingSeleniumEnvironment.java rename to src/test/java/selenium/rule/AssumingSeleniumEnvironment.java index 1f4f8c818..6784dd9e2 100644 --- a/src/test/java/bio/overture/ego/selenium/rule/AssumingSeleniumEnvironment.java +++ b/src/test/java/selenium/rule/AssumingSeleniumEnvironment.java @@ -15,13 +15,13 @@ * */ -package bio.overture.ego.selenium.rule; +package selenium.rule; -import bio.overture.ego.selenium.driver.WebDriverFactory.DriverType; import org.junit.AssumptionViolatedException; import org.junit.rules.TestRule; import org.junit.runner.Description; import org.junit.runners.model.Statement; +import selenium.driver.WebDriverFactory.DriverType; public class AssumingSeleniumEnvironment implements TestRule { diff --git a/src/test/java/bio/overture/ego/selenium/rule/SeleniumEnvironmentChecker.java b/src/test/java/selenium/rule/SeleniumEnvironmentChecker.java similarity index 91% rename from src/test/java/bio/overture/ego/selenium/rule/SeleniumEnvironmentChecker.java rename to src/test/java/selenium/rule/SeleniumEnvironmentChecker.java index 988487d71..acb257789 100644 --- a/src/test/java/bio/overture/ego/selenium/rule/SeleniumEnvironmentChecker.java +++ b/src/test/java/selenium/rule/SeleniumEnvironmentChecker.java @@ -15,10 +15,10 @@ * */ -package bio.overture.ego.selenium.rule; +package selenium.rule; -import bio.overture.ego.selenium.driver.WebDriverFactory.DriverType; import lombok.Getter; +import selenium.driver.WebDriverFactory.DriverType; public class SeleniumEnvironmentChecker {