hostsharing/hs.hsadmin.ng
6
0
Fork 0
Code Pull Requests 1 Activity

fix some tests

Browse Source
This commit is contained in:
Michael Hoennig 2024-04-17 16:27:46 +02:00
parent 71a8843c01
commit dbfd55adfb
24 changed files with 287 additions and 584 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/main/java/net/hostsharing/hsadminng/hs/hosting/managedserver/HsManagedServerRepository.java
View File

@ -1,26 +0,0 @@
package net.hostsharing.hsadminng.hs.hosting.managedserver;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
public interface HsManagedServerRepository extends Repository<HsManagedServerEntity, UUID> {
List<HsManagedServerEntity> findAll();
Optional<HsManagedServerEntity> findByUuid(final UUID managedServerUuid);
@Query("""
SELECT s FROM HsManagedServerEntity s
WHERE s.bookingItem.debitor.uuid = :debitorUuid
""")
List<HsManagedServerEntity> findAllByDebitorUuid(final UUID debitorUuid);
HsManagedServerEntity save(HsManagedServerEntity current);
int deleteByUuid(final UUID uuid);
long count();
}

66
src/main/java/net/hostsharing/hsadminng/hs/hosting/managedserver/HsManagedServerController.java → src/main/java/net/hostsharing/hsadminng/hs/hosting/server/HsHostingServerController.java
View File

@ -1,11 +1,11 @@
package net.hostsharing.hsadminng.hs.hosting.managedserver;
package net.hostsharing.hsadminng.hs.hosting.server;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.api.HsHostingManagedserversApi;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.api.HsHostingServersApi;
import net.hostsharing.hsadminng.context.Context;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsManagedServerInsertResource;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsManagedServerPatchResource;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsManagedServerResource;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsServerInsertResource;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsServerPatchResource;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsServerResource;
import net.hostsharing.hsadminng.mapper.KeyValueMap;
import net.hostsharing.hsadminng.mapper.Mapper;
import org.springframework.beans.factory.annotation.Autowired;
@ -21,7 +21,7 @@ import java.util.function.BiConsumer;
import static net.hostsharing.hsadminng.mapper.PostgresDateRange.toPostgresDateRange;
@RestController
public class HsManagedServerController implements HsHostingManagedserversApi {
public class HsHostingServerController implements HsHostingServersApi {
@Autowired
private Context context;
@ -30,70 +30,70 @@ public class HsManagedServerController implements HsHostingManagedserversApi {
private Mapper mapper;
@Autowired
private HsManagedServerRepository managedServerRepo;
private HsHostingServerRepository serverRepo;
@Override
@Transactional(readOnly = true)
public ResponseEntity<List<HsManagedServerResource>> listManagedServersByDebitorUuid(
public ResponseEntity<List<HsServerResource>> listServersByDebitorUuid(
final String currentUser,
final String assumedRoles,
final UUID debitorUuid) {
context.define(currentUser, assumedRoles);
final var entities = managedServerRepo.findAllByDebitorUuid(debitorUuid);
final var entities = serverRepo.findAllByDebitorUuid(debitorUuid);
final var resources = mapper.mapList(entities, HsManagedServerResource.class, ENTITY_TO_RESOURCE_POSTMAPPER);
final var resources = mapper.mapList(entities, HsServerResource.class, ENTITY_TO_RESOURCE_POSTMAPPER);
return ResponseEntity.ok(resources);
}
@Override
@Transactional
public ResponseEntity<HsManagedServerResource> addManagedServer(
public ResponseEntity<HsServerResource> addServer(
final String currentUser,
final String assumedRoles,
final HsManagedServerInsertResource body) {
final HsServerInsertResource body) {
context.define(currentUser, assumedRoles);
final var entityToSave = mapper.map(body, HsManagedServerEntity.class, RESOURCE_TO_ENTITY_POSTMAPPER);
final var entityToSave = mapper.map(body, HsHostingServerEntity.class, RESOURCE_TO_ENTITY_POSTMAPPER);
final var saved = managedServerRepo.save(entityToSave);
final var saved = serverRepo.save(entityToSave);
final var uri =
MvcUriComponentsBuilder.fromController(getClass())
.path("/api/hs/hosting/managedservers/{id}")
.path("/api/hs/hosting/servers/{id}")
.buildAndExpand(saved.getUuid())
.toUri();
final var mapped = mapper.map(saved, HsManagedServerResource.class, ENTITY_TO_RESOURCE_POSTMAPPER);
final var mapped = mapper.map(saved, HsServerResource.class, ENTITY_TO_RESOURCE_POSTMAPPER);
return ResponseEntity.created(uri).body(mapped);
}
@Override
@Transactional(readOnly = true)
public ResponseEntity<HsManagedServerResource> getManagedServerByUuid(
public ResponseEntity<HsServerResource> getServerByUuid(
final String currentUser,
final String assumedRoles,
final UUID managedServerUuid) {
final UUID serverUuid) {
context.define(currentUser, assumedRoles);
final var result = managedServerRepo.findByUuid(managedServerUuid);
final var result = serverRepo.findByUuid(serverUuid);
return result
.map(managedServerEntity -> ResponseEntity.ok(
mapper.map(managedServerEntity, HsManagedServerResource.class, ENTITY_TO_RESOURCE_POSTMAPPER)))
.map(serverEntity -> ResponseEntity.ok(
mapper.map(serverEntity, HsServerResource.class, ENTITY_TO_RESOURCE_POSTMAPPER)))
.orElseGet(() -> ResponseEntity.notFound().build());
}
@Override
@Transactional
public ResponseEntity<Void> deleteManagedServerUuid(
public ResponseEntity<Void> deleteServerUuid(
final String currentUser,
final String assumedRoles,
final UUID managedServerUuid) {
final UUID serverUuid) {
context.define(currentUser, assumedRoles);
final var result = managedServerRepo.deleteByUuid(managedServerUuid);
final var result = serverRepo.deleteByUuid(serverUuid);
return result == 0
? ResponseEntity.notFound().build()
: ResponseEntity.noContent().build();
@ -101,24 +101,24 @@ public class HsManagedServerController implements HsHostingManagedserversApi {
@Override
@Transactional
public ResponseEntity<HsManagedServerResource> patchManagedServer(
public ResponseEntity<HsServerResource> patchServer(
final String currentUser,
final String assumedRoles,
final UUID managedServerUuid,
final HsManagedServerPatchResource body) {
final UUID serverUuid,
final HsServerPatchResource body) {
context.define(currentUser, assumedRoles);
final var current = managedServerRepo.findByUuid(managedServerUuid).orElseThrow();
final var current = serverRepo.findByUuid(serverUuid).orElseThrow();
new HsManagedServerEntityPatcher(current).apply(body);
new HsHostingServerEntityPatcher(current).apply(body);
final var saved = managedServerRepo.save(current);
final var mapped = mapper.map(saved, HsManagedServerResource.class, ENTITY_TO_RESOURCE_POSTMAPPER);
final var saved = serverRepo.save(current);
final var mapped = mapper.map(saved, HsServerResource.class, ENTITY_TO_RESOURCE_POSTMAPPER);
return ResponseEntity.ok(mapped);
}
final BiConsumer<HsManagedServerEntity, HsManagedServerResource> ENTITY_TO_RESOURCE_POSTMAPPER = (entity, resource) -> {
final BiConsumer<HsHostingServerEntity, HsServerResource> ENTITY_TO_RESOURCE_POSTMAPPER = (entity, resource) -> {
resource.setValidFrom(entity.getValidity().lower());
if (entity.getValidity().hasUpperBound()) {
resource.setValidTo(entity.getValidity().upper().minusDays(1));
@ -126,7 +126,7 @@ public class HsManagedServerController implements HsHostingManagedserversApi {
};
@SuppressWarnings("unchecked")
final BiConsumer<HsManagedServerInsertResource, HsManagedServerEntity> RESOURCE_TO_ENTITY_POSTMAPPER = (resource, entity) -> {
final BiConsumer<HsServerInsertResource, HsHostingServerEntity> RESOURCE_TO_ENTITY_POSTMAPPER = (resource, entity) -> {
entity.setValidity(toPostgresDateRange(resource.getValidFrom(), resource.getValidTo()));
entity.putConfig(KeyValueMap.from(resource.getConfig()));
};

18
src/main/java/net/hostsharing/hsadminng/hs/hosting/managedserver/HsManagedServerEntity.java → src/main/java/net/hostsharing/hsadminng/hs/hosting/server/HsHostingServerEntity.java
View File

@ -1,4 +1,4 @@
package net.hostsharing.hsadminng.hs.hosting.managedserver;
package net.hostsharing.hsadminng.hs.hosting.server;
import io.hypersistence.utils.hibernate.type.json.JsonType;
import io.hypersistence.utils.hibernate.type.range.PostgreSQLRangeType;
@ -52,18 +52,18 @@ import static net.hostsharing.hsadminng.stringify.Stringify.stringify;
@Builder
@Entity
@Table(name = "hs_hosting_managedserver_rv")
@Table(name = "hs_hosting_server_rv")
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class HsManagedServerEntity implements Stringifyable, RbacObject {
public class HsHostingServerEntity implements Stringifyable, RbacObject {
private static Stringify<HsManagedServerEntity> stringify = stringify(HsManagedServerEntity.class)
private static Stringify<HsHostingServerEntity> stringify = stringify(HsHostingServerEntity.class)
.withProp(e -> e.getBookingItem().toShortString())
.withProp(e -> e.getValidity().asString())
.withProp(HsManagedServerEntity::getCaption)
.withProp(HsManagedServerEntity::getConfig)
.withProp(HsHostingServerEntity::getCaption)
.withProp(HsHostingServerEntity::getConfig)
.quotedValues(false);
@Id
@ -136,10 +136,10 @@ public class HsManagedServerEntity implements Stringifyable, RbacObject {
}
public static RbacView rbac() {
return rbacViewFor("managedServer", HsManagedServerEntity.class)
return rbacViewFor("server", HsHostingServerEntity.class)
.withIdentityView(SQL.query("""
SELECT server.uuid as uuid, bookingItemIV.idName || ':' || cleanIdentifier(server.caption) as idName
FROM hs_hosting_managedserver server
FROM hs_hosting_server server
JOIN hs_booking_item_iv bookingItemIV ON bookingItemIV.uuid = server.bookingItemUuid
"""))
.withRestrictedViewOrderBy(SQL.expression("validity"))
@ -164,6 +164,6 @@ public class HsManagedServerEntity implements Stringifyable, RbacObject {
}
public static void main(String[] args) throws IOException {
rbac().generateWithBaseFileName("7-hs-hosting/701-hosting-managedserver/7013-hs-hosting-managedserver-rbac");
rbac().generateWithBaseFileName("7-hs-hosting/701-hosting-server/7013-hs-hosting-server-rbac");
}
}

12
src/main/java/net/hostsharing/hsadminng/hs/hosting/managedserver/HsManagedServerEntityPatcher.java → src/main/java/net/hostsharing/hsadminng/hs/hosting/server/HsHostingServerEntityPatcher.java
View File

@ -1,6 +1,6 @@
package net.hostsharing.hsadminng.hs.hosting.managedserver;
package net.hostsharing.hsadminng.hs.hosting.server;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsManagedServerPatchResource;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsServerPatchResource;
import net.hostsharing.hsadminng.mapper.EntityPatcher;
import net.hostsharing.hsadminng.mapper.KeyValueMap;
import net.hostsharing.hsadminng.mapper.OptionalFromJson;
@ -8,16 +8,16 @@ import net.hostsharing.hsadminng.mapper.OptionalFromJson;
import java.util.Optional;
public class HsManagedServerEntityPatcher implements EntityPatcher<HsManagedServerPatchResource> {
public class HsHostingServerEntityPatcher implements EntityPatcher<HsServerPatchResource> {
private final HsManagedServerEntity entity;
private final HsHostingServerEntity entity;
public HsManagedServerEntityPatcher(final HsManagedServerEntity entity) {
public HsHostingServerEntityPatcher(final HsHostingServerEntity entity) {
this.entity = entity;
}
@Override
public void apply(final HsManagedServerPatchResource resource) {
public void apply(final HsServerPatchResource resource) {
OptionalFromJson.of(resource.getCaption())
.ifPresent(entity::setCaption);
Optional.ofNullable(resource.getConfig())

26
src/main/java/net/hostsharing/hsadminng/hs/hosting/server/HsHostingServerRepository.java Normal file
View File

@ -0,0 +1,26 @@
package net.hostsharing.hsadminng.hs.hosting.server;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
public interface HsHostingServerRepository extends Repository<HsHostingServerEntity, UUID> {
List<HsHostingServerEntity> findAll();
Optional<HsHostingServerEntity> findByUuid(final UUID serverUuid);
@Query("""
SELECT s FROM HsHostingServerEntity s
WHERE s.bookingItem.debitor.uuid = :debitorUuid
""")
List<HsHostingServerEntity> findAllByDebitorUuid(final UUID debitorUuid);
HsHostingServerEntity save(HsHostingServerEntity current);
int deleteByUuid(final UUID uuid);
long count();
}

4
src/main/resources/api-definition/hs-booking/hs-booking-item-schemas.yaml
View File

@ -69,10 +69,10 @@ components:
BookingResources:
anyOf:
- $ref: '#/components/schemas/ManagedServerBookingResources'
- $ref: '#/components/schemas/ServerBookingResources'
- $ref: '#/components/schemas/ManagedWebspaceBookingResources'
ManagedServerBookingResources:
ServerBookingResources:
type: object
properties:
caption:

2
src/main/resources/api-definition/hs-hosting/api-mappings.yaml
View File

@ -13,5 +13,5 @@ map:
- type: string:uuid => java.util.UUID
paths:
/api/hs/hosting/managedservers/{managedServerUuid}:
/api/hs/hosting/servers/{serverUuid}:
null: org.openapitools.jackson.nullable.JsonNullable

16
src/main/resources/api-definition/hs-hosting/hs-hosting-managedserver-schemas.yaml → src/main/resources/api-definition/hs-hosting/hs-hosting-server-schemas.yaml
View File

@ -3,7 +3,7 @@ components:
schemas:
HsManagedServer:
HsServer:
type: object
properties:
uuid:
@ -18,14 +18,14 @@ components:
type: string
format: date
config:
$ref: '#/components/schemas/ManagedServerConfiguration'
$ref: '#/components/schemas/ServerConfiguration'
required:
- uuid
- validFrom
- validTo
- config
HsManagedServerPatch:
HsServerPatch:
type: object
properties:
caption:
@ -36,9 +36,9 @@ components:
format: date
nullable: true
config:
$ref: '#/components/schemas/ManagedServerConfiguration'
$ref: '#/components/schemas/ServerConfiguration'
HsManagedServerInsert:
HsServerInsert:
type: object
properties:
bookingItemUuid:
@ -59,7 +59,7 @@ components:
format: date
nullable: true
config:
$ref: '#/components/schemas/ManagedServerConfiguration'
$ref: '#/components/schemas/ServerConfiguration'
required:
- caption
- debitorUuid
@ -67,8 +67,8 @@ components:
- config
additionalProperties: false
ManagedServerConfiguration:
# forces generating a java.lang.Object containing a Map, instead of class ManagedServerConfiguration
ServerConfiguration:
# forces generating a java.lang.Object containing a Map, instead of class ServerConfiguration
anyOf:
- type: object
properties:

24
src/main/resources/api-definition/hs-hosting/hs-hosting-managedservers-with-uuid.yaml → src/main/resources/api-definition/hs-hosting/hs-hosting-servers-with-uuid.yaml
View File

@ -1,12 +1,12 @@
get:
tags:
- hs-hosting-managedservers
- hs-hosting-servers
description: 'Fetch a single managed server by its uuid, if visible for the current subject.'
operationId: getManagedServerByUuid
operationId: getServerByUuid
parameters:
- $ref: 'auth.yaml#/components/parameters/currentUser'
- $ref: 'auth.yaml#/components/parameters/assumedRoles'
- name: managedServerUuid
- name: serverUuid
in: path
required: true
schema:
@ -19,7 +19,7 @@ get:
content:
'application/json':
schema:
$ref: 'hs-hosting-managedserver-schemas.yaml#/components/schemas/HsManagedServer'
$ref: 'hs-hosting-server-schemas.yaml#/components/schemas/HsServer'
"401":
$ref: 'error-responses.yaml#/components/responses/Unauthorized'
@ -28,13 +28,13 @@ get:
patch:
tags:
- hs-hosting-managedservers
- hs-hosting-servers
description: 'Updates a single managed server identified by its uuid, if permitted for the current subject.'
operationId: patchManagedServer
operationId: patchServer
parameters:
- $ref: 'auth.yaml#/components/parameters/currentUser'
- $ref: 'auth.yaml#/components/parameters/assumedRoles'
- name: managedServerUuid
- name: serverUuid
in: path
required: true
schema:
@ -44,14 +44,14 @@ patch:
content:
'application/json':
schema:
$ref: 'hs-hosting-managedserver-schemas.yaml#/components/schemas/HsManagedServerPatch'
$ref: 'hs-hosting-server-schemas.yaml#/components/schemas/HsServerPatch'
responses:
"200":
description: OK
content:
'application/json':
schema:
$ref: 'hs-hosting-managedserver-schemas.yaml#/components/schemas/HsManagedServer'
$ref: 'hs-hosting-server-schemas.yaml#/components/schemas/HsServer'
"401":
$ref: 'error-responses.yaml#/components/responses/Unauthorized'
"403":
@ -59,13 +59,13 @@ patch:
delete:
tags:
- hs-hosting-managedservers
- hs-hosting-servers
description: 'Delete a single managed server identified by its uuid, if permitted for the current subject.'
operationId: deleteManagedServerUuid
operationId: deleteServerUuid
parameters:
- $ref: 'auth.yaml#/components/parameters/currentUser'
- $ref: 'auth.yaml#/components/parameters/assumedRoles'
- name: managedServerUuid
- name: serverUuid
in: path
required: true
schema:

14
src/main/resources/api-definition/hs-hosting/hs-hosting-managedservers.yaml → src/main/resources/api-definition/hs-hosting/hs-hosting-servers.yaml
View File

@ -2,8 +2,8 @@ get:
summary: Returns a list of all managed servers for a specified debitor.
description: Returns the list of all managed servers for a debitor which are visible to the current user or any of it's assumed roles.
tags:
- hs-hosting-managedservers
operationId: listManagedServersByDebitorUuid
- hs-hosting-servers
operationId: listServersByDebitorUuid
parameters:
- $ref: 'auth.yaml#/components/parameters/currentUser'
- $ref: 'auth.yaml#/components/parameters/assumedRoles'
@ -22,7 +22,7 @@ get:
schema:
type: array
items:
$ref: 'hs-hosting-managedserver-schemas.yaml#/components/schemas/HsManagedServer'
$ref: 'hs-hosting-server-schemas.yaml#/components/schemas/HsServer'
"401":
$ref: 'error-responses.yaml#/components/responses/Unauthorized'
"403":
@ -31,8 +31,8 @@ get:
post:
summary: Adds a new managed server.
tags:
- hs-hosting-managedservers
operationId: addManagedServer
- hs-hosting-servers
operationId: addServer
parameters:
- $ref: 'auth.yaml#/components/parameters/currentUser'
- $ref: 'auth.yaml#/components/parameters/assumedRoles'
@ -42,14 +42,14 @@ post:
content:
application/json:
schema:
$ref: 'hs-hosting-managedserver-schemas.yaml#/components/schemas/HsManagedServerInsert'
$ref: 'hs-hosting-server-schemas.yaml#/components/schemas/HsServerInsert'
responses:
"201":
description: Created
content:
'application/json':
schema:
$ref: 'hs-hosting-managedserver-schemas.yaml#/components/schemas/HsManagedServer'
$ref: 'hs-hosting-server-schemas.yaml#/components/schemas/HsServer'
"401":
$ref: 'error-responses.yaml#/components/responses/Unauthorized'
"403":

8
src/main/resources/api-definition/hs-hosting/hs-hosting.yaml
View File

@ -10,8 +10,8 @@ paths:
# Items
/api/hs/hosting/managedservers:
$ref: "hs-hosting-managedservers.yaml"
/api/hs/hosting/servers:
$ref: "hs-hosting-servers.yaml"
/api/hs/hosting/managedservers/{managedServerUuid}:
$ref: "hs-hosting-managedservers-with-uuid.yaml"
/api/hs/hosting/servers/{serverUuid}:
$ref: "hs-hosting-servers-with-uuid.yaml"

302
src/main/resources/db/changelog/7-hs-hosting/701-hosting-managedserver/7013-hs-hosting-managedserver-rbac.md
View File

@ -1,302 +0,0 @@
### rbac managedServer
This code generated was by RbacViewMermaidFlowchartGenerator, do not amend manually.
```mermaid
%%{init:{'flowchart':{'htmlLabels':false}}}%%
flowchart TB
subgraph managedServer["`**managedServer**`"]
direction TB
style managedServer fill:#dd4901,stroke:#274d6e,stroke-width:8px
subgraph managedServer:roles[ ]
style managedServer:roles fill:#dd4901,stroke:white
role:managedServer:OWNER[[managedServer:OWNER]]
role:managedServer:ADMIN[[managedServer:ADMIN]]
role:managedServer:TENANT[[managedServer:TENANT]]
end
subgraph managedServer:permissions[ ]
style managedServer:permissions fill:#dd4901,stroke:white
perm:managedServer:INSERT{{managedServer:INSERT}}
perm:managedServer:DELETE{{managedServer:DELETE}}
perm:managedServer:UPDATE{{managedServer:UPDATE}}
perm:managedServer:SELECT{{managedServer:SELECT}}
end
end
subgraph bookingItem.debitor.debitorRel.anchorPerson["`**bookingItem.debitor.debitorRel.anchorPerson**`"]
direction TB
style bookingItem.debitor.debitorRel.anchorPerson fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.debitorRel.anchorPerson:roles[ ]
style bookingItem.debitor.debitorRel.anchorPerson:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.debitorRel.anchorPerson:OWNER[[bookingItem.debitor.debitorRel.anchorPerson:OWNER]]
role:bookingItem.debitor.debitorRel.anchorPerson:ADMIN[[bookingItem.debitor.debitorRel.anchorPerson:ADMIN]]
role:bookingItem.debitor.debitorRel.anchorPerson:REFERRER[[bookingItem.debitor.debitorRel.anchorPerson:REFERRER]]
end
end
subgraph bookingItem.debitor.partnerRel.contact["`**bookingItem.debitor.partnerRel.contact**`"]
direction TB
style bookingItem.debitor.partnerRel.contact fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.partnerRel.contact:roles[ ]
style bookingItem.debitor.partnerRel.contact:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.partnerRel.contact:OWNER[[bookingItem.debitor.partnerRel.contact:OWNER]]
role:bookingItem.debitor.partnerRel.contact:ADMIN[[bookingItem.debitor.partnerRel.contact:ADMIN]]
role:bookingItem.debitor.partnerRel.contact:REFERRER[[bookingItem.debitor.partnerRel.contact:REFERRER]]
end
end
subgraph bookingItem["`**bookingItem**`"]
direction TB
style bookingItem fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem:roles[ ]
style bookingItem:roles fill:#99bcdb,stroke:white
role:bookingItem:OWNER[[bookingItem:OWNER]]
role:bookingItem:ADMIN[[bookingItem:ADMIN]]
role:bookingItem:TENANT[[bookingItem:TENANT]]
end
end
subgraph bookingItem.debitor.partnerRel["`**bookingItem.debitor.partnerRel**`"]
direction TB
style bookingItem.debitor.partnerRel fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.partnerRel:roles[ ]
style bookingItem.debitor.partnerRel:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.partnerRel:OWNER[[bookingItem.debitor.partnerRel:OWNER]]
role:bookingItem.debitor.partnerRel:ADMIN[[bookingItem.debitor.partnerRel:ADMIN]]
role:bookingItem.debitor.partnerRel:AGENT[[bookingItem.debitor.partnerRel:AGENT]]
role:bookingItem.debitor.partnerRel:TENANT[[bookingItem.debitor.partnerRel:TENANT]]
end
end
subgraph bookingItem.debitor.partnerRel.anchorPerson["`**bookingItem.debitor.partnerRel.anchorPerson**`"]
direction TB
style bookingItem.debitor.partnerRel.anchorPerson fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.partnerRel.anchorPerson:roles[ ]
style bookingItem.debitor.partnerRel.anchorPerson:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.partnerRel.anchorPerson:OWNER[[bookingItem.debitor.partnerRel.anchorPerson:OWNER]]
role:bookingItem.debitor.partnerRel.anchorPerson:ADMIN[[bookingItem.debitor.partnerRel.anchorPerson:ADMIN]]
role:bookingItem.debitor.partnerRel.anchorPerson:REFERRER[[bookingItem.debitor.partnerRel.anchorPerson:REFERRER]]
end
end
subgraph bookingItem.debitorRel["`**bookingItem.debitorRel**`"]
direction TB
style bookingItem.debitorRel fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitorRel:roles[ ]
style bookingItem.debitorRel:roles fill:#99bcdb,stroke:white
role:bookingItem.debitorRel:OWNER[[bookingItem.debitorRel:OWNER]]
role:bookingItem.debitorRel:ADMIN[[bookingItem.debitorRel:ADMIN]]
role:bookingItem.debitorRel:AGENT[[bookingItem.debitorRel:AGENT]]
role:bookingItem.debitorRel:TENANT[[bookingItem.debitorRel:TENANT]]
end
end
subgraph bookingItem.debitorRel.anchorPerson["`**bookingItem.debitorRel.anchorPerson**`"]
direction TB
style bookingItem.debitorRel.anchorPerson fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitorRel.anchorPerson:roles[ ]
style bookingItem.debitorRel.anchorPerson:roles fill:#99bcdb,stroke:white
role:bookingItem.debitorRel.anchorPerson:OWNER[[bookingItem.debitorRel.anchorPerson:OWNER]]
role:bookingItem.debitorRel.anchorPerson:ADMIN[[bookingItem.debitorRel.anchorPerson:ADMIN]]
role:bookingItem.debitorRel.anchorPerson:REFERRER[[bookingItem.debitorRel.anchorPerson:REFERRER]]
end
end
subgraph bookingItem.debitor.partnerRel.holderPerson["`**bookingItem.debitor.partnerRel.holderPerson**`"]
direction TB
style bookingItem.debitor.partnerRel.holderPerson fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.partnerRel.holderPerson:roles[ ]
style bookingItem.debitor.partnerRel.holderPerson:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.partnerRel.holderPerson:OWNER[[bookingItem.debitor.partnerRel.holderPerson:OWNER]]
role:bookingItem.debitor.partnerRel.holderPerson:ADMIN[[bookingItem.debitor.partnerRel.holderPerson:ADMIN]]
role:bookingItem.debitor.partnerRel.holderPerson:REFERRER[[bookingItem.debitor.partnerRel.holderPerson:REFERRER]]
end
end
subgraph bookingItem.debitorRel.contact["`**bookingItem.debitorRel.contact**`"]
direction TB
style bookingItem.debitorRel.contact fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitorRel.contact:roles[ ]
style bookingItem.debitorRel.contact:roles fill:#99bcdb,stroke:white
role:bookingItem.debitorRel.contact:OWNER[[bookingItem.debitorRel.contact:OWNER]]
role:bookingItem.debitorRel.contact:ADMIN[[bookingItem.debitorRel.contact:ADMIN]]
role:bookingItem.debitorRel.contact:REFERRER[[bookingItem.debitorRel.contact:REFERRER]]
end
end
subgraph bookingItem.debitorRel.holderPerson["`**bookingItem.debitorRel.holderPerson**`"]
direction TB
style bookingItem.debitorRel.holderPerson fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitorRel.holderPerson:roles[ ]
style bookingItem.debitorRel.holderPerson:roles fill:#99bcdb,stroke:white
role:bookingItem.debitorRel.holderPerson:OWNER[[bookingItem.debitorRel.holderPerson:OWNER]]
role:bookingItem.debitorRel.holderPerson:ADMIN[[bookingItem.debitorRel.holderPerson:ADMIN]]
role:bookingItem.debitorRel.holderPerson:REFERRER[[bookingItem.debitorRel.holderPerson:REFERRER]]
end
end
subgraph bookingItem.debitor.refundBankAccount["`**bookingItem.debitor.refundBankAccount**`"]
direction TB
style bookingItem.debitor.refundBankAccount fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.refundBankAccount:roles[ ]
style bookingItem.debitor.refundBankAccount:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.refundBankAccount:OWNER[[bookingItem.debitor.refundBankAccount:OWNER]]
role:bookingItem.debitor.refundBankAccount:ADMIN[[bookingItem.debitor.refundBankAccount:ADMIN]]
role:bookingItem.debitor.refundBankAccount:REFERRER[[bookingItem.debitor.refundBankAccount:REFERRER]]
end
end
subgraph bookingItem.debitor.debitorRel.contact["`**bookingItem.debitor.debitorRel.contact**`"]
direction TB
style bookingItem.debitor.debitorRel.contact fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.debitorRel.contact:roles[ ]
style bookingItem.debitor.debitorRel.contact:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.debitorRel.contact:OWNER[[bookingItem.debitor.debitorRel.contact:OWNER]]
role:bookingItem.debitor.debitorRel.contact:ADMIN[[bookingItem.debitor.debitorRel.contact:ADMIN]]
role:bookingItem.debitor.debitorRel.contact:REFERRER[[bookingItem.debitor.debitorRel.contact:REFERRER]]
end
end
subgraph bookingItem.debitor["`**bookingItem.debitor**`"]
direction TB
style bookingItem.debitor fill:#99bcdb,stroke:#274d6e,stroke-width:8px
end
subgraph bookingItem.debitor.debitorRel.holderPerson["`**bookingItem.debitor.debitorRel.holderPerson**`"]
direction TB
style bookingItem.debitor.debitorRel.holderPerson fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.debitorRel.holderPerson:roles[ ]
style bookingItem.debitor.debitorRel.holderPerson:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.debitorRel.holderPerson:OWNER[[bookingItem.debitor.debitorRel.holderPerson:OWNER]]
role:bookingItem.debitor.debitorRel.holderPerson:ADMIN[[bookingItem.debitor.debitorRel.holderPerson:ADMIN]]
role:bookingItem.debitor.debitorRel.holderPerson:REFERRER[[bookingItem.debitor.debitorRel.holderPerson:REFERRER]]
end
end
subgraph bookingItem.debitor.debitorRel["`**bookingItem.debitor.debitorRel**`"]
direction TB
style bookingItem.debitor.debitorRel fill:#99bcdb,stroke:#274d6e,stroke-width:8px
subgraph bookingItem.debitor.debitorRel:roles[ ]
style bookingItem.debitor.debitorRel:roles fill:#99bcdb,stroke:white
role:bookingItem.debitor.debitorRel:OWNER[[bookingItem.debitor.debitorRel:OWNER]]
role:bookingItem.debitor.debitorRel:ADMIN[[bookingItem.debitor.debitorRel:ADMIN]]
role:bookingItem.debitor.debitorRel:AGENT[[bookingItem.debitor.debitorRel:AGENT]]
role:bookingItem.debitor.debitorRel:TENANT[[bookingItem.debitor.debitorRel:TENANT]]
end
end
%% granting roles to roles
role:global:ADMIN -.-> role:bookingItem.debitor.debitorRel.anchorPerson:OWNER
role:bookingItem.debitor.debitorRel.anchorPerson:OWNER -.-> role:bookingItem.debitor.debitorRel.anchorPerson:ADMIN
role:bookingItem.debitor.debitorRel.anchorPerson:ADMIN -.-> role:bookingItem.debitor.debitorRel.anchorPerson:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitor.debitorRel.holderPerson:OWNER
role:bookingItem.debitor.debitorRel.holderPerson:OWNER -.-> role:bookingItem.debitor.debitorRel.holderPerson:ADMIN
role:bookingItem.debitor.debitorRel.holderPerson:ADMIN -.-> role:bookingItem.debitor.debitorRel.holderPerson:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitor.debitorRel.contact:OWNER
role:bookingItem.debitor.debitorRel.contact:OWNER -.-> role:bookingItem.debitor.debitorRel.contact:ADMIN
role:bookingItem.debitor.debitorRel.contact:ADMIN -.-> role:bookingItem.debitor.debitorRel.contact:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitor.debitorRel:OWNER
role:bookingItem.debitor.debitorRel:OWNER -.-> role:bookingItem.debitor.debitorRel:ADMIN
role:bookingItem.debitor.debitorRel:ADMIN -.-> role:bookingItem.debitor.debitorRel:AGENT
role:bookingItem.debitor.debitorRel:AGENT -.-> role:bookingItem.debitor.debitorRel:TENANT
role:bookingItem.debitor.debitorRel.contact:ADMIN -.-> role:bookingItem.debitor.debitorRel:TENANT
role:bookingItem.debitor.debitorRel:TENANT -.-> role:bookingItem.debitor.debitorRel.anchorPerson:REFERRER
role:bookingItem.debitor.debitorRel:TENANT -.-> role:bookingItem.debitor.debitorRel.holderPerson:REFERRER
role:bookingItem.debitor.debitorRel:TENANT -.-> role:bookingItem.debitor.debitorRel.contact:REFERRER
role:bookingItem.debitor.debitorRel.anchorPerson:ADMIN -.-> role:bookingItem.debitor.debitorRel:OWNER
role:bookingItem.debitor.debitorRel.holderPerson:ADMIN -.-> role:bookingItem.debitor.debitorRel:AGENT
role:global:ADMIN -.-> role:bookingItem.debitor.refundBankAccount:OWNER
role:bookingItem.debitor.refundBankAccount:OWNER -.-> role:bookingItem.debitor.refundBankAccount:ADMIN
role:bookingItem.debitor.refundBankAccount:ADMIN -.-> role:bookingItem.debitor.refundBankAccount:REFERRER
role:bookingItem.debitor.refundBankAccount:ADMIN -.-> role:bookingItem.debitor.debitorRel:AGENT
role:bookingItem.debitor.debitorRel:AGENT -.-> role:bookingItem.debitor.refundBankAccount:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitor.partnerRel.anchorPerson:OWNER
role:bookingItem.debitor.partnerRel.anchorPerson:OWNER -.-> role:bookingItem.debitor.partnerRel.anchorPerson:ADMIN
role:bookingItem.debitor.partnerRel.anchorPerson:ADMIN -.-> role:bookingItem.debitor.partnerRel.anchorPerson:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitor.partnerRel.holderPerson:OWNER
role:bookingItem.debitor.partnerRel.holderPerson:OWNER -.-> role:bookingItem.debitor.partnerRel.holderPerson:ADMIN
role:bookingItem.debitor.partnerRel.holderPerson:ADMIN -.-> role:bookingItem.debitor.partnerRel.holderPerson:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitor.partnerRel.contact:OWNER
role:bookingItem.debitor.partnerRel.contact:OWNER -.-> role:bookingItem.debitor.partnerRel.contact:ADMIN
role:bookingItem.debitor.partnerRel.contact:ADMIN -.-> role:bookingItem.debitor.partnerRel.contact:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitor.partnerRel:OWNER
role:bookingItem.debitor.partnerRel:OWNER -.-> role:bookingItem.debitor.partnerRel:ADMIN
role:bookingItem.debitor.partnerRel:ADMIN -.-> role:bookingItem.debitor.partnerRel:AGENT
role:bookingItem.debitor.partnerRel:AGENT -.-> role:bookingItem.debitor.partnerRel:TENANT
role:bookingItem.debitor.partnerRel.contact:ADMIN -.-> role:bookingItem.debitor.partnerRel:TENANT
role:bookingItem.debitor.partnerRel:TENANT -.-> role:bookingItem.debitor.partnerRel.anchorPerson:REFERRER
role:bookingItem.debitor.partnerRel:TENANT -.-> role:bookingItem.debitor.partnerRel.holderPerson:REFERRER
role:bookingItem.debitor.partnerRel:TENANT -.-> role:bookingItem.debitor.partnerRel.contact:REFERRER
role:bookingItem.debitor.partnerRel.anchorPerson:ADMIN -.-> role:bookingItem.debitor.partnerRel:OWNER
role:bookingItem.debitor.partnerRel.holderPerson:ADMIN -.-> role:bookingItem.debitor.partnerRel:AGENT
role:bookingItem.debitor.partnerRel:ADMIN -.-> role:bookingItem.debitor.debitorRel:ADMIN
role:bookingItem.debitor.partnerRel:AGENT -.-> role:bookingItem.debitor.debitorRel:AGENT
role:bookingItem.debitor.debitorRel:AGENT -.-> role:bookingItem.debitor.partnerRel:TENANT
role:global:ADMIN -.-> role:bookingItem.debitorRel.anchorPerson:OWNER
role:bookingItem.debitorRel.anchorPerson:OWNER -.-> role:bookingItem.debitorRel.anchorPerson:ADMIN
role:bookingItem.debitorRel.anchorPerson:ADMIN -.-> role:bookingItem.debitorRel.anchorPerson:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitorRel.holderPerson:OWNER
role:bookingItem.debitorRel.holderPerson:OWNER -.-> role:bookingItem.debitorRel.holderPerson:ADMIN
role:bookingItem.debitorRel.holderPerson:ADMIN -.-> role:bookingItem.debitorRel.holderPerson:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitorRel.contact:OWNER
role:bookingItem.debitorRel.contact:OWNER -.-> role:bookingItem.debitorRel.contact:ADMIN
role:bookingItem.debitorRel.contact:ADMIN -.-> role:bookingItem.debitorRel.contact:REFERRER
role:global:ADMIN -.-> role:bookingItem.debitorRel:OWNER
role:bookingItem.debitorRel:OWNER -.-> role:bookingItem.debitorRel:ADMIN
role:bookingItem.debitorRel:ADMIN -.-> role:bookingItem.debitorRel:AGENT
role:bookingItem.debitorRel:AGENT -.-> role:bookingItem.debitorRel:TENANT
role:bookingItem.debitorRel.contact:ADMIN -.-> role:bookingItem.debitorRel:TENANT
role:bookingItem.debitorRel:TENANT -.-> role:bookingItem.debitorRel.anchorPerson:REFERRER
role:bookingItem.debitorRel:TENANT -.-> role:bookingItem.debitorRel.holderPerson:REFERRER
role:bookingItem.debitorRel:TENANT -.-> role:bookingItem.debitorRel.contact:REFERRER
role:bookingItem.debitorRel.anchorPerson:ADMIN -.-> role:bookingItem.debitorRel:OWNER
role:bookingItem.debitorRel.holderPerson:ADMIN -.-> role:bookingItem.debitorRel:AGENT
role:bookingItem.debitorRel:AGENT -.-> role:bookingItem:OWNER
role:bookingItem:OWNER -.-> role:bookingItem:ADMIN
role:bookingItem:ADMIN -.-> role:bookingItem:TENANT
role:bookingItem:TENANT -.-> role:bookingItem.debitorRel:TENANT
role:bookingItem:ADMIN ==> role:managedServer:OWNER
role:managedServer:OWNER ==> role:managedServer:ADMIN
role:managedServer:ADMIN ==> role:managedServer:TENANT
role:managedServer:TENANT ==> role:bookingItem:TENANT
%% granting permissions to roles
role:bookingItem:ADMIN ==> perm:managedServer:INSERT
role:global:ADMIN ==> perm:managedServer:DELETE
role:managedServer:OWNER ==> perm:managedServer:UPDATE
role:managedServer:TENANT ==> perm:managedServer:SELECT
```

8
src/main/resources/db/changelog/7-hs-hosting/701-hosting-managedserver/7010-hs-hosting-managedserver.sql → src/main/resources/db/changelog/7-hs-hosting/701-hosting-server/7010-hs-hosting-server.sql
View File

@ -1,10 +1,10 @@
--liquibase formatted sql
-- ============================================================================
--changeset hosting-managedserver-MAIN-TABLE:1 endDelimiter:--//
--changeset hosting-server-MAIN-TABLE:1 endDelimiter:--//
-- ----------------------------------------------------------------------------
create table if not exists hs_hosting_managedserver
create table if not exists hs_hosting_server
(
uuid uuid unique references RbacObject (uuid),
version int not null default 0,
@ -17,8 +17,8 @@ create table if not exists hs_hosting_managedserver
-- ============================================================================
--changeset hs-hosting-managedserver-MAIN-TABLE-JOURNAL:1 endDelimiter:--//
--changeset hs-hosting-server-MAIN-TABLE-JOURNAL:1 endDelimiter:--//
-- ----------------------------------------------------------------------------
call create_journal('hs_hosting_managedserver');
call create_journal('hs_hosting_server');
--//

20
src/main/resources/db/changelog/7-hs-hosting/701-hosting-managedserver/7018-hs-hosting-managedserver-test-data.sql → src/main/resources/db/changelog/7-hs-hosting/701-hosting-server/7018-hs-hosting-server-test-data.sql
View File

@ -2,13 +2,13 @@
-- ============================================================================
--changeset hs-hosting-managedserver-TEST-DATA-GENERATOR:1 endDelimiter:--//
--changeset hs-hosting-server-TEST-DATA-GENERATOR:1 endDelimiter:--//
-- ----------------------------------------------------------------------------
/*
Creates a single hs_hosting_managedserver test record.
Creates a single hs_hosting_server test record.
*/
create or replace procedure createHsHostingManagedServerTestData(
create or replace procedure createHsHostingServerTestData(
givenPartnerNumber numeric,
givenDebitorSuffix char(2)
)
@ -18,7 +18,7 @@ declare
relatedDebitor hs_office_debitor;
relatedBookingItem hs_booking_item;
begin
currentTask := 'creating hosting-managedserver test-data ' || givenPartnerNumber::text || givenDebitorSuffix;
currentTask := 'creating hosting-server test-data ' || givenPartnerNumber::text || givenDebitorSuffix;
call defineContext(currentTask, null, 'superuser-alex@hostsharing.net', 'global#global:ADMIN');
execute format('set local hsadminng.currentTask to %L', currentTask);
@ -33,10 +33,10 @@ begin
where item.debitoruuid = relatedDebitor.uuid
and item.caption = 'some PrivateCloud';
raise notice 'creating test hosting-managedserver: %', givenPartnerNumber::text || givenDebitorSuffix::text;
raise notice 'creating test hosting-server: %', givenPartnerNumber::text || givenDebitorSuffix::text;
raise notice '- using debitor (%): %', relatedDebitor.uuid, relatedDebitor;
insert
into hs_hosting_managedserver (uuid, bookingitemuuid, caption, validity, config)
into hs_hosting_server (uuid, bookingitemuuid, caption, validity, config)
values (uuid_generate_v4(), relatedBookingItem.uuid, 'some ManagedServer', daterange('20221001', null, '[]'), '{ "CPU": 2, "SDD": 512, "extra": 42 }'::jsonb),
(uuid_generate_v4(), relatedBookingItem.uuid, 'another CloudServer', daterange('20230115', '20240415', '[)'), '{ "CPU": 2, "HDD": 1024, "extra": 42 }'::jsonb),
(uuid_generate_v4(), relatedBookingItem.uuid, 'some Whatever', daterange('20240401', null, '[]'), '{ "CPU": 1, "SDD": 512, "HDD": 2048, "extra": 42 }'::jsonb);
@ -45,13 +45,13 @@ end; $$;
-- ============================================================================
--changeset hs-hosting-managedserver-TEST-DATA-GENERATION:1 –context=dev,tc endDelimiter:--//
--changeset hs-hosting-server-TEST-DATA-GENERATION:1 –context=dev,tc endDelimiter:--//
-- ----------------------------------------------------------------------------
do language plpgsql $$
begin
call createHsHostingManagedServerTestData(10001, '11');
call createHsHostingManagedServerTestData(10002, '12');
call createHsHostingManagedServerTestData(10003, '13');
call createHsHostingServerTestData(10001, '11');
call createHsHostingServerTestData(10002, '12');
call createHsHostingServerTestData(10003, '13');
end;
$$;

6
src/main/resources/db/changelog/db.changelog-master.yaml
View File

@ -134,8 +134,8 @@ databaseChangeLog:
- include:
file: db/changelog/6-hs-booking/601-booking-item/6018-hs-booking-item-test-data.sql
- include:
file: db/changelog/7-hs-hosting/701-hosting-managedserver/7010-hs-hosting-managedserver.sql
file: db/changelog/7-hs-hosting/701-hosting-server/7010-hs-hosting-server.sql
- include:
file: db/changelog/7-hs-hosting/701-hosting-managedserver/7013-hs-hosting-managedserver-rbac.sql
file: db/changelog/7-hs-hosting/701-hosting-server/7013-hs-hosting-server-rbac.sql
- include:
file: db/changelog/7-hs-hosting/701-hosting-managedserver/7018-hs-hosting-managedserver-test-data.sql
file: db/changelog/7-hs-hosting/701-hosting-server/7018-hs-hosting-server-test-data.sql

3
src/test/java/net/hostsharing/hsadminng/arch/ArchitectureTest.java
View File

@ -51,7 +51,7 @@ public class ArchitectureTest {
"..hs.office.relation",
"..hs.office.sepamandate",
"..hs.booking.item",
"..hs.hosting.managedserver",
"..hs.hosting.server",
"..errors",
"..mapper",
"..ping",
@ -131,6 +131,7 @@ public class ArchitectureTest {
.resideInAnyPackage(
"..hs.office.(*)..",
"..hs.booking.(*)..",
"..hs.hosting.(*)..",
"..rbac.rbacgrant" // TODO.test: just because of RbacGrantsDiagramServiceIntegrationTest
);

2
src/test/java/net/hostsharing/hsadminng/hs/booking/item/HsBookingItemRepositoryIntegrationTest.java
View File

@ -119,7 +119,7 @@ class HsBookingItemRepositoryIntegrationTest extends ContextBasedTestWithCleanup
// insert+delete
"{ grant perm:hs_booking_item#D-1000111:somenewbookingitem:DELETE to role:global#global:ADMIN by system and assume }",
"{ grant perm:hs_booking_item#D-1000111:somenewbookingitem:INSERT>hs_hosting_managedserver to role:hs_booking_item#D-1000111:somenewbookingitem:ADMIN by system and assume }",
"{ grant perm:hs_booking_item#D-1000111:somenewbookingitem:INSERT>hs_hosting_server to role:hs_booking_item#D-1000111:somenewbookingitem:ADMIN by system and assume }",
// owner
"{ grant perm:hs_booking_item#D-1000111:somenewbookingitem:UPDATE to role:hs_booking_item#D-1000111:somenewbookingitem:OWNER by system and assume }",

38
src/test/java/net/hostsharing/hsadminng/hs/hosting/managedserver/HsManagedServerEntityPatcherUnitTest.java → src/test/java/net/hostsharing/hsadminng/hs/hosting/server/HsHostingServerEntityPatcherUnitTest.java
View File

@ -1,7 +1,7 @@
package net.hostsharing.hsadminng.hs.hosting.managedserver;
package net.hostsharing.hsadminng.hs.hosting.server;
import io.hypersistence.utils.hibernate.type.range.Range;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsManagedServerPatchResource;
import net.hostsharing.hsadminng.hs.hosting.generated.api.v1.model.HsServerPatchResource;
import net.hostsharing.hsadminng.hs.office.debitor.HsOfficeDebitorEntity;
import net.hostsharing.hsadminng.mapper.KeyValueMap;
import net.hostsharing.hsadminng.rbac.test.PatchUnitTestBase;
@ -27,9 +27,9 @@ import static org.mockito.Mockito.lenient;
@TestInstance(PER_CLASS)
@ExtendWith(MockitoExtension.class)
class HsManagedServerEntityPatcherUnitTest extends PatchUnitTestBase<
HsManagedServerPatchResource,
HsManagedServerEntity
class HsHostingServerEntityPatcherUnitTest extends PatchUnitTestBase<
HsServerPatchResource,
HsHostingServerEntity
> {
private static final UUID INITIAL_BOOKING_ITEM_UUID = UUID.randomUUID();
@ -62,13 +62,13 @@ class HsManagedServerEntityPatcherUnitTest extends PatchUnitTestBase<
void initMocks() {
lenient().when(em.getReference(eq(HsOfficeDebitorEntity.class), any())).thenAnswer(invocation ->
HsOfficeDebitorEntity.builder().uuid(invocation.getArgument(1)).build());
lenient().when(em.getReference(eq(HsManagedServerEntity.class), any())).thenAnswer(invocation ->
HsManagedServerEntity.builder().uuid(invocation.getArgument(1)).build());
lenient().when(em.getReference(eq(HsHostingServerEntity.class), any())).thenAnswer(invocation ->
HsHostingServerEntity.builder().uuid(invocation.getArgument(1)).build());
}
@Override
protected HsManagedServerEntity newInitialEntity() {
final var entity = new HsManagedServerEntity();
protected HsHostingServerEntity newInitialEntity() {
final var entity = new HsHostingServerEntity();
entity.setUuid(INITIAL_BOOKING_ITEM_UUID);
entity.setBookingItem(TEST_BOOKING_ITEM);
entity.getConfig().putAll(KeyValueMap.from(INITIAL_CONFIG));
@ -78,13 +78,13 @@ class HsManagedServerEntityPatcherUnitTest extends PatchUnitTestBase<
}
@Override
protected HsManagedServerPatchResource newPatchResource() {
return new HsManagedServerPatchResource();
protected HsServerPatchResource newPatchResource() {
return new HsServerPatchResource();
}
@Override
protected HsManagedServerEntityPatcher createPatcher(final HsManagedServerEntity managedServer) {
return new HsManagedServerEntityPatcher(managedServer);
protected HsHostingServerEntityPatcher createPatcher(final HsHostingServerEntity server) {
return new HsHostingServerEntityPatcher(server);
}
@Override
@ -92,21 +92,21 @@ class HsManagedServerEntityPatcherUnitTest extends PatchUnitTestBase<
return Stream.of(
new JsonNullableProperty<>(
"caption",
HsManagedServerPatchResource::setCaption,
HsServerPatchResource::setCaption,
PATCHED_CAPTION,
HsManagedServerEntity::setCaption),
HsHostingServerEntity::setCaption),
new SimpleProperty<>(
"config",
HsManagedServerPatchResource::setConfig,
HsServerPatchResource::setConfig,
PATCH_CONFIG,
HsManagedServerEntity::putConfig,
HsHostingServerEntity::putConfig,
PATCHED_CONFIG)
.notNullable(),
new JsonNullableProperty<>(
"validto",
HsManagedServerPatchResource::setValidTo,
HsServerPatchResource::setValidTo,
PATCHED_VALID_TO,
HsManagedServerEntity::setValidTo)
HsHostingServerEntity::setValidTo)
);
}
}

24
src/test/java/net/hostsharing/hsadminng/hs/hosting/managedserver/HsManagedServerEntityUnitTest.java → src/test/java/net/hostsharing/hsadminng/hs/hosting/server/HsHostingServerEntityUnitTest.java
View File

@ -1,4 +1,4 @@
package net.hostsharing.hsadminng.hs.hosting.managedserver;
package net.hostsharing.hsadminng.hs.hosting.server;
import org.junit.jupiter.api.Test;
@ -10,11 +10,11 @@ import static net.hostsharing.hsadminng.hs.booking.item.TestHsBookingItem.TEST_B
import static net.hostsharing.hsadminng.mapper.PostgresDateRange.toPostgresDateRange;
import static org.assertj.core.api.Assertions.assertThat;
class HsManagedServerEntityUnitTest {
class HsHostingServerEntityUnitTest {
public static final LocalDate GIVEN_VALID_FROM = LocalDate.parse("2020-01-01");
public static final LocalDate GIVEN_VALID_TO = LocalDate.parse("2030-12-31");
final HsManagedServerEntity givenManagedServer = HsManagedServerEntity.builder()
final HsHostingServerEntity givenServer = HsHostingServerEntity.builder()
.bookingItem(TEST_BOOKING_ITEM)
.caption("some caption")
.config(Map.ofEntries(
@ -26,32 +26,32 @@ class HsManagedServerEntityUnitTest {
@Test
void toStringContainsAllPropertiesAndResourcesSortedByKey() {
final var result = givenManagedServer.toString();
final var result = givenServer.toString();
assertThat(result).isEqualTo(
"HsManagedServerEntity(D-1000100:test booking item, [2020-01-01,2031-01-01), some caption, { CPUs: 2, HDD-storage: 2048, SSD-storage: 512 })");
"HsServerEntity(D-1000100:test booking item, [2020-01-01,2031-01-01), some caption, { CPUs: 2, HDD-storage: 2048, SSD-storage: 512 })");
}
@Test
void toShortStringContainsOnlyMemberNumberAndCaption() {
final var result = givenManagedServer.toShortString();
final var result = givenServer.toShortString();
assertThat(result).isEqualTo("D-1000100:test booking item:some caption");
}
@Test
void settingValidFromKeepsValidTo() {
givenManagedServer.setValidFrom(LocalDate.parse("2023-12-31"));
assertThat(givenManagedServer.getValidFrom()).isEqualTo(LocalDate.parse("2023-12-31"));
assertThat(givenManagedServer.getValidTo()).isEqualTo(GIVEN_VALID_TO);
givenServer.setValidFrom(LocalDate.parse("2023-12-31"));
assertThat(givenServer.getValidFrom()).isEqualTo(LocalDate.parse("2023-12-31"));
assertThat(givenServer.getValidTo()).isEqualTo(GIVEN_VALID_TO);
}
@Test
void settingValidToKeepsValidFrom() {
givenManagedServer.setValidTo(LocalDate.parse("2024-12-31"));
assertThat(givenManagedServer.getValidFrom()).isEqualTo(GIVEN_VALID_FROM);
assertThat(givenManagedServer.getValidTo()).isEqualTo(LocalDate.parse("2024-12-31"));
givenServer.setValidTo(LocalDate.parse("2024-12-31"));
assertThat(givenServer.getValidFrom()).isEqualTo(GIVEN_VALID_FROM);
assertThat(givenServer.getValidTo()).isEqualTo(LocalDate.parse("2024-12-31"));
}
}

162
src/test/java/net/hostsharing/hsadminng/hs/hosting/managedserver/HsManagedServerRepositoryIntegrationTest.java → src/test/java/net/hostsharing/hsadminng/hs/hosting/server/HsHostingServerRepositoryIntegrationTest.java
View File

@ -1,4 +1,4 @@
package net.hostsharing.hsadminng.hs.hosting.managedserver;
package net.hostsharing.hsadminng.hs.hosting.server;
import io.hypersistence.utils.hibernate.type.range.Range;
import net.hostsharing.hsadminng.context.Context;
@ -35,10 +35,10 @@ import static org.assertj.core.api.Assertions.assertThat;
@DataJpaTest
@Import({ Context.class, JpaAttempt.class })
class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithCleanup {
class HsHostingServerRepositoryIntegrationTest extends ContextBasedTestWithCleanup {
@Autowired
HsManagedServerRepository managedServerRepo;
HsHostingServerRepository serverRepo;
@Autowired
HsBookingItemRepository bookingItemRepo;
@ -62,32 +62,32 @@ class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithClean
HttpServletRequest request;
@Nested
class CreateManagedServer {
class CreateServer {
@Test
public void testHostsharingAdmin_withoutAssumedRole_canCreateNewManagedServer() {
public void testHostsharingAdmin_withoutAssumedRole_canCreateNewServer() {
// given
context("superuser-alex@hostsharing.net");
final var count = managedServerRepo.count();
final var count = serverRepo.count();
final var givenBookingItem = givenBookingItem("First", "some CloudServer");
// when
final var result = attempt(em, () -> {
final var newManagedServer = HsManagedServerEntity.builder()
final var newServer = HsHostingServerEntity.builder()
.bookingItem(givenBookingItem)
.caption("some new booking managedserver")
.caption("some new booking server")
.validity(Range.closedOpen(
LocalDate.parse("2020-01-01"), LocalDate.parse("2023-01-01")))
.build();
return toCleanup(managedServerRepo.save(newManagedServer));
return toCleanup(serverRepo.save(newServer));
});
// then
result.assertSuccessful();
assertThat(result.returnedValue()).isNotNull().extracting(HsManagedServerEntity::getUuid).isNotNull();
assertThatManagedServerIsPersisted(result.returnedValue());
assertThat(managedServerRepo.count()).isEqualTo(count + 1);
assertThat(result.returnedValue()).isNotNull().extracting(HsHostingServerEntity::getUuid).isNotNull();
assertThatServerIsPersisted(result.returnedValue());
assertThat(serverRepo.count()).isEqualTo(count + 1);
}
@Test
@ -102,47 +102,47 @@ class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithClean
// when
attempt(em, () -> {
final var newManagedServer = HsManagedServerEntity.builder()
final var newServer = HsHostingServerEntity.builder()
.bookingItem(givenBookingItem)
.caption("some new booking managedserver")
.caption("some new booking server")
.validity(Range.closedOpen(
LocalDate.parse("2020-01-01"), LocalDate.parse("2023-01-01")))
.build();
return toCleanup(managedServerRepo.save(newManagedServer));
return toCleanup(serverRepo.save(newServer));
});
// then
final var all = rawRoleRepo.findAll();
assertThat(distinctRoleNamesOf(all)).containsExactlyInAnyOrder(Array.from(
initialRoleNames,
"hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:ADMIN",
"hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:OWNER",
"hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:TENANT"));
"hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:ADMIN",
"hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:OWNER",
"hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:TENANT"));
assertThat(distinctGrantDisplaysOf(rawGrantRepo.findAll()))
.map(s -> s.replace("hs_office_", ""))
.containsExactlyInAnyOrder(fromFormatted(
initialGrantNames,
// global-admin
"{ grant perm:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:DELETE to role:global#global:ADMIN by system and assume }",
"{ grant perm:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:DELETE to role:global#global:ADMIN by system and assume }",
// owner
"{ grant perm:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:UPDATE to role:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:OWNER by system and assume }",
"{ grant role:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:OWNER to role:hs_booking_item#D-1000111:someCloudServer:ADMIN by system and assume }",
"{ grant perm:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:UPDATE to role:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:OWNER by system and assume }",
"{ grant role:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:OWNER to role:hs_booking_item#D-1000111:someCloudServer:ADMIN by system and assume }",
// admin
"{ grant role:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:ADMIN to role:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:OWNER by system and assume }",
"{ grant role:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:ADMIN to role:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:OWNER by system and assume }",
// tenant
"{ grant role:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:TENANT to role:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:ADMIN by system and assume }",
"{ grant perm:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:SELECT to role:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:TENANT by system and assume }",
"{ grant role:hs_booking_item#D-1000111:someCloudServer:TENANT to role:hs_hosting_managedserver#D-1000111:someCloudServer:somenewbookingmanagedserver:TENANT by system and assume }",
"{ grant role:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:TENANT to role:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:ADMIN by system and assume }",
"{ grant perm:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:SELECT to role:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:TENANT by system and assume }",
"{ grant role:hs_booking_item#D-1000111:someCloudServer:TENANT to role:hs_hosting_server#D-1000111:someCloudServer:somenewbookingserver:TENANT by system and assume }",
null));
}
private void assertThatManagedServerIsPersisted(final HsManagedServerEntity saved) {
final var found = managedServerRepo.findByUuid(saved.getUuid());
assertThat(found).isNotEmpty().map(HsManagedServerEntity::toString).get().isEqualTo(saved.toString());
private void assertThatServerIsPersisted(final HsHostingServerEntity saved) {
final var found = serverRepo.findByUuid(saved.getUuid());
assertThat(found).isNotEmpty().map(HsHostingServerEntity::toString).get().isEqualTo(saved.toString());
}
}
@ -150,71 +150,71 @@ class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithClean
class FindByDebitorUuid {
@Test
public void globalAdmin_withoutAssumedRole_canViewAllManagedServersOfArbitraryDebitor() {
public void globalAdmin_withoutAssumedRole_canViewAllServersOfArbitraryDebitor() {
// given
context("superuser-alex@hostsharing.net");
final var debitorUuid = debitorRepo.findDebitorByDebitorNumber(1000212).stream()
.findAny().orElseThrow().getUuid();
// when
final var result = managedServerRepo.findAllByDebitorUuid(debitorUuid);
final var result = serverRepo.findAllByDebitorUuid(debitorUuid);
// then
allTheseManagedServersAreReturned(
allTheseServersAreReturned(
result,
"HsManagedServerEntity(D-1000212:some PrivateCloud, [2022-10-01,), some ManagedServer, { CPU: 2, SDD: 512, extra: 42 })",
"HsManagedServerEntity(D-1000212:some PrivateCloud, [2023-01-15,2024-04-15), another CloudServer, { CPU: 2, HDD: 1024, extra: 42 })",
"HsManagedServerEntity(D-1000212:some PrivateCloud, [2024-04-01,), some Whatever, { CPU: 1, HDD: 2048, SDD: 512, extra: 42 })");
"HsServerEntity(D-1000212:some PrivateCloud, [2022-10-01,), some ManagedServer, { CPU: 2, SDD: 512, extra: 42 })",
"HsServerEntity(D-1000212:some PrivateCloud, [2023-01-15,2024-04-15), another CloudServer, { CPU: 2, HDD: 1024, extra: 42 })",
"HsServerEntity(D-1000212:some PrivateCloud, [2024-04-01,), some Whatever, { CPU: 1, HDD: 2048, SDD: 512, extra: 42 })");
}
@Test
public void normalUser_canViewOnlyRelatedManagedServers() {
public void normalUser_canViewOnlyRelatedServers() {
// given:
context("person-FirbySusan@example.com");
final var debitorUuid = debitorRepo.findDebitorByDebitorNumber(1000111).stream().findAny().orElseThrow().getUuid();
// when:
final var result = managedServerRepo.findAllByDebitorUuid(debitorUuid);
final var result = serverRepo.findAllByDebitorUuid(debitorUuid);
// then:
exactlyTheseManagedServersAreReturned(
exactlyTheseServersAreReturned(
result,
"HsManagedServerEntity(D-1000111:some PrivateCloud, [2022-10-01,), some ManagedServer, { CPU: 2, SDD: 512, extra: 42 })",
"HsManagedServerEntity(D-1000111:some PrivateCloud, [2023-01-15,2024-04-15), another CloudServer, { CPU: 2, HDD: 1024, extra: 42 })",
"HsManagedServerEntity(D-1000111:some PrivateCloud, [2024-04-01,), some Whatever, { CPU: 1, HDD: 2048, SDD: 512, extra: 42 })");
"HsServerEntity(D-1000111:some PrivateCloud, [2022-10-01,), some ManagedServer, { CPU: 2, SDD: 512, extra: 42 })",
"HsServerEntity(D-1000111:some PrivateCloud, [2023-01-15,2024-04-15), another CloudServer, { CPU: 2, HDD: 1024, extra: 42 })",
"HsServerEntity(D-1000111:some PrivateCloud, [2024-04-01,), some Whatever, { CPU: 1, HDD: 2048, SDD: 512, extra: 42 })");
}
}
@Nested
class UpdateManagedServer {
class UpdateServer {
@Test
public void hostsharingAdmin_canUpdateArbitraryManagedServer() {
public void hostsharingAdmin_canUpdateArbitraryServer() {
// given
final var givenManagedServerUuid = givenSomeTemporaryManagedServer(1000111).getUuid();
final var givenServerUuid = givenSomeTemporaryServer(1000111).getUuid();
// when
final var result = jpaAttempt.transacted(() -> {
context("superuser-alex@hostsharing.net");
final var foundManagedServer = em.find(HsManagedServerEntity.class, givenManagedServerUuid);
foundManagedServer.getConfig().put("CPUs", 2);
foundManagedServer.getConfig().remove("SSD-storage");
foundManagedServer.getConfig().put("HSD-storage", 2048);
foundManagedServer.setValidity(Range.closedOpen(
final var foundServer = em.find(HsHostingServerEntity.class, givenServerUuid);
foundServer.getConfig().put("CPUs", 2);
foundServer.getConfig().remove("SSD-storage");
foundServer.getConfig().put("HSD-storage", 2048);
foundServer.setValidity(Range.closedOpen(
LocalDate.parse("2019-05-17"), LocalDate.parse("2023-01-01")));
return toCleanup(managedServerRepo.save(foundManagedServer));
return toCleanup(serverRepo.save(foundServer));
});
// then
result.assertSuccessful();
jpaAttempt.transacted(() -> {
context("superuser-alex@hostsharing.net");
assertThatManagedServerActuallyInDatabase(result.returnedValue());
assertThatServerActuallyInDatabase(result.returnedValue());
}).assertSuccessful();
}
private void assertThatManagedServerActuallyInDatabase(final HsManagedServerEntity saved) {
final var found = managedServerRepo.findByUuid(saved.getUuid());
private void assertThatServerActuallyInDatabase(final HsHostingServerEntity saved) {
final var found = serverRepo.findByUuid(saved.getUuid());
assertThat(found).isNotEmpty().get().isNotSameAs(saved)
.extracting(Object::toString).isEqualTo(saved.toString());
}
@ -224,61 +224,61 @@ class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithClean
class DeleteByUuid {
@Test
public void globalAdmin_withoutAssumedRole_canDeleteAnyManagedServer() {
public void globalAdmin_withoutAssumedRole_canDeleteAnyServer() {
// given
context("superuser-alex@hostsharing.net", null);
final var givenManagedServer = givenSomeTemporaryManagedServer(1000111);
final var givenServer = givenSomeTemporaryServer(1000111);
// when
final var result = jpaAttempt.transacted(() -> {
context("superuser-alex@hostsharing.net");
managedServerRepo.deleteByUuid(givenManagedServer.getUuid());
serverRepo.deleteByUuid(givenServer.getUuid());
});
// then
result.assertSuccessful();
assertThat(jpaAttempt.transacted(() -> {
context("superuser-fran@hostsharing.net", null);
return managedServerRepo.findByUuid(givenManagedServer.getUuid());
return serverRepo.findByUuid(givenServer.getUuid());
}).assertSuccessful().returnedValue()).isEmpty();
}
@Test
public void nonGlobalAdmin_canNotDeleteTheirRelatedManagedServer() {
public void nonGlobalAdmin_canNotDeleteTheirRelatedServer() {
// given
context("superuser-alex@hostsharing.net", null);
final var givenManagedServer = givenSomeTemporaryManagedServer(1000111);
final var givenServer = givenSomeTemporaryServer(1000111);
// when
final var result = jpaAttempt.transacted(() -> {
context("person-FirbySusan@example.com");
assertThat(managedServerRepo.findByUuid(givenManagedServer.getUuid())).isPresent();
assertThat(serverRepo.findByUuid(givenServer.getUuid())).isPresent();
managedServerRepo.deleteByUuid(givenManagedServer.getUuid());
serverRepo.deleteByUuid(givenServer.getUuid());
});
// then
result.assertExceptionWithRootCauseMessage(
JpaSystemException.class,
"[403] Subject ", " is not allowed to delete hs_hosting_managedserver");
"[403] Subject ", " is not allowed to delete hs_hosting_server");
assertThat(jpaAttempt.transacted(() -> {
context("superuser-alex@hostsharing.net");
return managedServerRepo.findByUuid(givenManagedServer.getUuid());
return serverRepo.findByUuid(givenServer.getUuid());
}).assertSuccessful().returnedValue()).isPresent(); // still there
}
@Test
public void deletingAManagedServerAlsoDeletesRelatedRolesAndGrants() {
public void deletingAServerAlsoDeletesRelatedRolesAndGrants() {
// given
context("superuser-alex@hostsharing.net");
final var initialRoleNames = Array.from(distinctRoleNamesOf(rawRoleRepo.findAll()));
final var initialGrantNames = Array.from(distinctGrantDisplaysOf(rawGrantRepo.findAll()));
final var givenManagedServer = givenSomeTemporaryManagedServer(1000111);
final var givenServer = givenSomeTemporaryServer(1000111);
// when
final var result = jpaAttempt.transacted(() -> {
context("superuser-alex@hostsharing.net");
return managedServerRepo.deleteByUuid(givenManagedServer.getUuid());
return serverRepo.deleteByUuid(givenServer.getUuid());
});
// then
@ -295,7 +295,7 @@ class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithClean
final var query = em.createNativeQuery("""
select currentTask, targetTable, targetOp
from tx_journal_v
where targettable = 'hs_hosting_managedserver';
where targettable = 'hs_hosting_server';
""");
// when
@ -303,18 +303,18 @@ class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithClean
// then
assertThat(customerLogEntries).map(Arrays::toString).contains(
"[creating hosting-managedserver test-data 1000111, hs_hosting_managedserver, INSERT]",
"[creating hosting-managedserver test-data 1000212, hs_hosting_managedserver, INSERT]",
"[creating hosting-managedserver test-data 1000313, hs_hosting_managedserver, INSERT]");
"[creating hosting-server test-data 1000111, hs_hosting_server, INSERT]",
"[creating hosting-server test-data 1000212, hs_hosting_server, INSERT]",
"[creating hosting-server test-data 1000313, hs_hosting_server, INSERT]");
}
private HsManagedServerEntity givenSomeTemporaryManagedServer(final int debitorNumber) {
private HsHostingServerEntity givenSomeTemporaryServer(final int debitorNumber) {
return jpaAttempt.transacted(() -> {
context("superuser-alex@hostsharing.net");
final var givenBookingItem = givenBookingItem("First", "some CloudServer");
final var newManagedServer = HsManagedServerEntity.builder()
final var newServer = HsHostingServerEntity.builder()
.bookingItem(givenBookingItem)
.caption("some temp booking managedserver")
.caption("some temp booking server")
.validity(Range.closedOpen(
LocalDate.parse("2020-01-01"), LocalDate.parse("2023-01-01")))
.config(Map.ofEntries(
@ -322,7 +322,7 @@ class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithClean
entry("SSD-storage", 256)))
.build();
return toCleanup(managedServerRepo.save(newManagedServer));
return toCleanup(serverRepo.save(newServer));
}).assertSuccessful().returnedValue();
}
@ -333,17 +333,17 @@ class HsManagedServerRepositoryIntegrationTest extends ContextBasedTestWithClean
.findAny().orElseThrow();
}
void exactlyTheseManagedServersAreReturned(
final List<HsManagedServerEntity> actualResult,
final String... managedServerNames) {
void exactlyTheseServersAreReturned(
final List<HsHostingServerEntity> actualResult,
final String... serverNames) {
assertThat(actualResult)
.extracting(managedServerEntity -> managedServerEntity.toString())
.containsExactlyInAnyOrder(managedServerNames);
.extracting(serverEntity -> serverEntity.toString())
.containsExactlyInAnyOrder(serverNames);
}
void allTheseManagedServersAreReturned(final List<HsManagedServerEntity> actualResult, final String... managedServerNames) {
void allTheseServersAreReturned(final List<HsHostingServerEntity> actualResult, final String... serverNames) {
assertThat(actualResult)
.extracting(managedServerEntity -> managedServerEntity.toString())
.contains(managedServerNames);
.extracting(serverEntity -> serverEntity.toString())
.contains(serverNames);
}
}

84
src/test/java/net/hostsharing/hsadminng/hs/hosting/managedserver/HsManagedServerControllerAcceptanceTest.java → src/test/java/net/hostsharing/hsadminng/hs/hosting/server/HsServerControllerAcceptanceTest.java
View File

@ -1,4 +1,4 @@
package net.hostsharing.hsadminng.hs.hosting.managedserver;
package net.hostsharing.hsadminng.hs.hosting.server;
import io.hypersistence.utils.hibernate.type.range.Range;
import io.restassured.RestAssured;
@ -30,13 +30,13 @@ import static org.hamcrest.Matchers.matchesRegex;
classes = { HsadminNgApplication.class, JpaAttempt.class }
)
@Transactional
class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanup {
class HsServerControllerAcceptanceTest extends ContextBasedTestWithCleanup {
@LocalServerPort
private Integer port;
@Autowired
HsManagedServerRepository managedServerRepo;
HsHostingServerRepository serverRepo;
@Autowired
HsBookingItemRepository bookingItemRepo;
@ -48,10 +48,10 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
JpaAttempt jpaAttempt;
@Nested
class ListManagedServers {
class ListServers {
@Test
void globalAdmin_canViewAllManagedServersOfArbitraryDebitor() {
void globalAdmin_canViewAllServersOfArbitraryDebitor() {
// given
context("superuser-alex@hostsharing.net");
@ -62,7 +62,7 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
.header("current-user", "superuser-alex@hostsharing.net")
.port(port)
.when()
.get("http://localhost/api/hs/hosting/managedservers?debitorUuid=" + givenDebitor.getUuid())
.get("http://localhost/api/hs/hosting/servers?debitorUuid=" + givenDebitor.getUuid())
.then().log().all().assertThat()
.statusCode(200)
.contentType("application/json")
@ -106,10 +106,10 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
}
@Nested
class AddManagedServer {
class AddServer {
@Test
void globalAdmin_canAddManagedServer() {
void globalAdmin_canAddServer() {
context.define("superuser-alex@hostsharing.net");
final var givenBookingItem = givenBookingItem("First", "some PrivateCloud");
@ -128,7 +128,7 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
""".formatted(givenBookingItem.getUuid()))
.port(port)
.when()
.post("http://localhost/api/hs/hosting/managedservers")
.post("http://localhost/api/hs/hosting/servers")
.then().log().all().assertThat()
.statusCode(201)
.contentType(ContentType.JSON)
@ -139,10 +139,10 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
"validFrom": "2024-04-17"
}
"""))
.header("Location", matchesRegex("http://localhost:[1-9][0-9]*/api/hs/hosting/managedservers/[^/]*"))
.header("Location", matchesRegex("http://localhost:[1-9][0-9]*/api/hs/hosting/servers/[^/]*"))
.extract().header("Location"); // @formatter:on
// finally, the new managedServer can be accessed under the generated UUID
// finally, the new server can be accessed under the generated UUID
final var newUserUuid = UUID.fromString(
location.substring(location.lastIndexOf('/') + 1));
assertThat(newUserUuid).isNotNull();
@ -150,12 +150,12 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
}
@Nested
class GetManagedServer {
class GetServer {
@Test
void globalAdmin_canGetArbitraryManagedServer() {
void globalAdmin_canGetArbitraryServer() {
context.define("superuser-alex@hostsharing.net");
final var givenManagedServerUuid = managedServerRepo.findAll().stream()
final var givenServerUuid = serverRepo.findAll().stream()
.filter(bi -> bi.getBookingItem().getDebitor().getDebitorNumber() == 1000111)
.filter(item -> item.getCaption().equals("some ManagedServer"))
.findAny().orElseThrow().getUuid();
@ -165,7 +165,7 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
.header("current-user", "superuser-alex@hostsharing.net")
.port(port)
.when()
.get("http://localhost/api/hs/hosting/managedservers/" + givenManagedServerUuid)
.get("http://localhost/api/hs/hosting/servers/" + givenServerUuid)
.then().log().all().assertThat()
.statusCode(200)
.contentType("application/json")
@ -184,11 +184,11 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
}
@Test
void normalUser_canNotGetUnrelatedManagedServer() {
void normalUser_canNotGetUnrelatedServer() {
context.define("superuser-alex@hostsharing.net");
final var givenManagedServerUuid = managedServerRepo.findAll().stream()
final var givenServerUuid = serverRepo.findAll().stream()
.filter(bi -> bi.getBookingItem().getDebitor().getDebitorNumber() == 1000212)
.map(HsManagedServerEntity::getUuid)
.map(HsHostingServerEntity::getUuid)
.findAny().orElseThrow();
RestAssured // @formatter:off
@ -196,15 +196,15 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
.header("current-user", "selfregistered-user-drew@hostsharing.org")
.port(port)
.when()
.get("http://localhost/api/hs/hosting/managedservers/" + givenManagedServerUuid)
.get("http://localhost/api/hs/hosting/servers/" + givenServerUuid)
.then().log().body().assertThat()
.statusCode(404); // @formatter:on
}
@Test
void debitorAgentUser_canGetRelatedManagedServer() {
void debitorAgentUser_canGetRelatedServer() {
context.define("superuser-alex@hostsharing.net");
final var givenManagedServerUuid = managedServerRepo.findAll().stream()
final var givenServerUuid = serverRepo.findAll().stream()
.filter(bi -> bi.getBookingItem().getDebitor().getDebitorNumber() == 1000313)
.filter(bi -> bi.getCaption().equals("some ManagedServer"))
.findAny().orElseThrow().getUuid();
@ -214,7 +214,7 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
.header("current-user", "person-TuckerJack@example.com")
.port(port)
.when()
.get("http://localhost/api/hs/hosting/managedservers/" + givenManagedServerUuid)
.get("http://localhost/api/hs/hosting/servers/" + givenServerUuid)
.then().log().all().assertThat()
.statusCode(200)
.contentType("application/json")
@ -234,12 +234,12 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
}
@Nested
class PatchManagedServer {
class PatchServer {
@Test
void globalAdmin_canPatchAllUpdatablePropertiesOfManagedServer() {
void globalAdmin_canPatchAllUpdatablePropertiesOfServer() {
final var givenManagedServer = givenSomeTemporaryManagedServerForDebitorNumber(1000111, entry("something", 1));
final var givenServer = givenSomeTemporaryServerForDebitorNumber(1000111, entry("something", 1));
RestAssured // @formatter:off
.given()
@ -258,7 +258,7 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
""")
.port(port)
.when()
.patch("http://localhost/api/hs/hosting/managedservers/" + givenManagedServer.getUuid())
.patch("http://localhost/api/hs/hosting/servers/" + givenServer.getUuid())
.then().log().all().assertThat()
.statusCode(200)
.contentType(ContentType.JSON)
@ -275,9 +275,9 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
}
""")); // @formatter:on
// finally, the managedServer is actually updated
// finally, the server is actually updated
context.define("superuser-alex@hostsharing.net");
assertThat(managedServerRepo.findByUuid(givenManagedServer.getUuid())).isPresent().get()
assertThat(serverRepo.findByUuid(givenServer.getUuid())).isPresent().get()
.matches(mandate -> {
assertThat(mandate.getBookingItem().toShortString()).isEqualTo("D-1000111:some CloudServer");
assertThat(mandate.getValidFrom()).isEqualTo("2022-11-01");
@ -288,42 +288,42 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
}
@Nested
class DeleteManagedServer {
class DeleteServer {
@Test
void globalAdmin_canDeleteArbitraryManagedServer() {
void globalAdmin_canDeleteArbitraryServer() {
context.define("superuser-alex@hostsharing.net");
final var givenManagedServer = givenSomeTemporaryManagedServerForDebitorNumber(1000111, entry("something", 1));
final var givenServer = givenSomeTemporaryServerForDebitorNumber(1000111, entry("something", 1));
RestAssured // @formatter:off
.given()
.header("current-user", "superuser-alex@hostsharing.net")
.port(port)
.when()
.delete("http://localhost/api/hs/hosting/managedservers/" + givenManagedServer.getUuid())
.delete("http://localhost/api/hs/hosting/servers/" + givenServer.getUuid())
.then().log().body().assertThat()
.statusCode(204); // @formatter:on
// then the given managedServer is gone
assertThat(managedServerRepo.findByUuid(givenManagedServer.getUuid())).isEmpty();
// then the given server is gone
assertThat(serverRepo.findByUuid(givenServer.getUuid())).isEmpty();
}
@Test
void normalUser_canNotDeleteUnrelatedManagedServer() {
void normalUser_canNotDeleteUnrelatedServer() {
context.define("superuser-alex@hostsharing.net");
final var givenManagedServer = givenSomeTemporaryManagedServerForDebitorNumber(1000111, entry("something", 1));
final var givenServer = givenSomeTemporaryServerForDebitorNumber(1000111, entry("something", 1));
RestAssured // @formatter:off
.given()
.header("current-user", "selfregistered-user-drew@hostsharing.org")
.port(port)
.when()
.delete("http://localhost/api/hs/hosting/managedservers/" + givenManagedServer.getUuid())
.delete("http://localhost/api/hs/hosting/servers/" + givenServer.getUuid())
.then().log().body().assertThat()
.statusCode(404); // @formatter:on
// then the given managedServer is still there
assertThat(managedServerRepo.findByUuid(givenManagedServer.getUuid())).isNotEmpty();
// then the given server is still there
assertThat(serverRepo.findByUuid(givenServer.getUuid())).isNotEmpty();
}
}
@ -334,11 +334,11 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
.findAny().orElseThrow();
}
private HsManagedServerEntity givenSomeTemporaryManagedServerForDebitorNumber(final int debitorNumber,
private HsHostingServerEntity givenSomeTemporaryServerForDebitorNumber(final int debitorNumber,
final Map.Entry<String, Integer> resources) {
return jpaAttempt.transacted(() -> {
context.define("superuser-alex@hostsharing.net");
final var newManagedServer = HsManagedServerEntity.builder()
final var newServer = HsHostingServerEntity.builder()
.uuid(UUID.randomUUID())
.bookingItem(givenBookingItem("First", "some CloudServer"))
.caption("some test-booking")
@ -347,7 +347,7 @@ class HsManagedServerControllerAcceptanceTest extends ContextBasedTestWithCleanu
LocalDate.parse("2022-11-01"), LocalDate.parse("2023-03-31")))
.build();
return managedServerRepo.save(newManagedServer);
return serverRepo.save(newServer);
}).assertSuccessful().returnedValue();
}
}

1
src/test/java/net/hostsharing/hsadminng/hs/office/migration/ImportOfficeData.java
View File

@ -620,6 +620,7 @@ public class ImportOfficeData extends ContextBasedTest {
private void deleteTestDataFromHsOfficeTables() {
jpaAttempt.transacted(() -> {
context(rbacSuperuser);
em.createNativeQuery("delete from hs_hosting_server where true").executeUpdate();
em.createNativeQuery("delete from hs_booking_item where true").executeUpdate();
em.createNativeQuery("delete from hs_office_coopassetstransaction where true").executeUpdate();
em.createNativeQuery("delete from hs_office_coopassetstransaction_legacy_id where true").executeUpdate();

2
src/test/java/net/hostsharing/hsadminng/hs/office/partner/HsOfficePartnerRepositoryIntegrationTest.java
View File

@ -141,7 +141,9 @@ class HsOfficePartnerRepositoryIntegrationTest extends ContextBasedTestWithClean
.map(s -> s.replace("hs_office_", ""))
.containsExactlyInAnyOrder(distinct(from(
initialGrantNames,
// TODO.rbac: this grant should only be created for DEBITOR-Relationships, thus the RBAC DSL needs to support conditional grants
"{ grant perm:relation#HostsharingeG-with-PARTNER-EBess:INSERT>sepamandate to role:relation#HostsharingeG-with-PARTNER-EBess:ADMIN by system and assume }",
"{ grant perm:relation#HostsharingeG-with-PARTNER-EBess:INSERT>hs_booking_item to role:relation#HostsharingeG-with-PARTNER-EBess:ADMIN by system and assume }",
// permissions on partner
"{ grant perm:partner#P-20032:DELETE to role:relation#HostsharingeG-with-PARTNER-EBess:OWNER by system and assume }",

3
src/test/java/net/hostsharing/hsadminng/hs/office/relation/HsOfficeRelationRepositoryIntegrationTest.java
View File

@ -131,8 +131,9 @@ class HsOfficeRelationRepositoryIntegrationTest extends ContextBasedTestWithClea
"hs_office_relation#ErbenBesslerMelBessler-with-REPRESENTATIVE-BesslerBert:TENANT"));
assertThat(distinctGrantDisplaysOf(rawGrantRepo.findAll())).containsExactlyInAnyOrder(Array.fromFormatted(
initialGrantNames,
// TODO: this grant should only be created for DEBITOR-Relationships, thus the RBAC DSL needs to support conditional grants
// TODO.rbac: this grant should only be created for DEBITOR-Relationships, thus the RBAC DSL needs to support conditional grants
"{ grant perm:hs_office_relation#ErbenBesslerMelBessler-with-REPRESENTATIVE-BesslerBert:INSERT>hs_office_sepamandate to role:hs_office_relation#ErbenBesslerMelBessler-with-REPRESENTATIVE-BesslerBert:ADMIN by system and assume }",
"{ grant perm:hs_office_relation#ErbenBesslerMelBessler-with-REPRESENTATIVE-BesslerBert:INSERT>hs_booking_item to role:hs_office_relation#ErbenBesslerMelBessler-with-REPRESENTATIVE-BesslerBert:ADMIN by system and assume }",
"{ grant perm:hs_office_relation#ErbenBesslerMelBessler-with-REPRESENTATIVE-BesslerBert:DELETE to role:hs_office_relation#ErbenBesslerMelBessler-with-REPRESENTATIVE-BesslerBert:OWNER by system and assume }",
"{ grant role:hs_office_relation#ErbenBesslerMelBessler-with-REPRESENTATIVE-BesslerBert:OWNER to role:global#global:ADMIN by system and assume }",