1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.syncope.fit.core;
20
21 import static org.junit.jupiter.api.Assertions.assertEquals;
22 import static org.junit.jupiter.api.Assertions.assertFalse;
23 import static org.junit.jupiter.api.Assertions.assertNotNull;
24 import static org.junit.jupiter.api.Assertions.assertNull;
25 import static org.junit.jupiter.api.Assertions.assertTrue;
26 import static org.junit.jupiter.api.Assertions.fail;
27
28 import java.util.List;
29 import javax.ws.rs.core.Response;
30 import org.apache.syncope.common.lib.SyncopeClientException;
31 import org.apache.syncope.common.lib.to.AnyTypeClassTO;
32 import org.apache.syncope.common.lib.to.DerSchemaTO;
33 import org.apache.syncope.common.lib.to.PlainSchemaTO;
34 import org.apache.syncope.common.lib.types.AttrSchemaType;
35 import org.apache.syncope.common.lib.types.ClientExceptionType;
36 import org.apache.syncope.common.lib.types.SchemaType;
37 import org.apache.syncope.common.rest.api.service.AnyTypeClassService;
38 import org.apache.syncope.fit.AbstractITCase;
39 import org.junit.jupiter.api.Test;
40
41 public class AnyTypeClassITCase extends AbstractITCase {
42
43 @Test
44 public void read() {
45 AnyTypeClassTO minimalGroup = ANY_TYPE_CLASS_SERVICE.read("minimal group");
46 assertNotNull(minimalGroup);
47
48 assertFalse(minimalGroup.getPlainSchemas().isEmpty());
49 assertFalse(minimalGroup.getDerSchemas().isEmpty());
50 assertFalse(minimalGroup.getVirSchemas().isEmpty());
51 }
52
53 @Test
54 public void list() {
55 List<AnyTypeClassTO> list = ANY_TYPE_CLASS_SERVICE.list();
56 assertFalse(list.isEmpty());
57 }
58
59 @Test
60 public void crud() {
61
62 PlainSchemaTO plainSchema = new PlainSchemaTO();
63 plainSchema.setKey("new_plain_schema" + getUUIDString());
64 plainSchema.setType(AttrSchemaType.String);
65 plainSchema = createSchema(SchemaType.PLAIN, plainSchema);
66
67 DerSchemaTO derSchema = new DerSchemaTO();
68 derSchema.setKey("new_der_schema" + getUUIDString());
69 derSchema.setExpression(plainSchema.getKey() + " + '_' + derived_dx");
70 derSchema = createSchema(SchemaType.DERIVED, derSchema);
71
72
73 AnyTypeClassTO newClass = new AnyTypeClassTO();
74 newClass.setKey("new class" + getUUIDString());
75 newClass.getPlainSchemas().add(plainSchema.getKey());
76
77 Response response = ANY_TYPE_CLASS_SERVICE.create(newClass);
78 assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatusInfo().getStatusCode());
79
80 newClass = getObject(response.getLocation(), AnyTypeClassService.class, AnyTypeClassTO.class);
81 assertNotNull(newClass);
82 assertFalse(newClass.getPlainSchemas().isEmpty());
83 assertTrue(newClass.getDerSchemas().isEmpty());
84 assertTrue(newClass.getVirSchemas().isEmpty());
85
86 newClass.getDerSchemas().add(derSchema.getKey());
87 ANY_TYPE_CLASS_SERVICE.update(newClass);
88
89 newClass = ANY_TYPE_CLASS_SERVICE.read(newClass.getKey());
90 assertNotNull(newClass);
91 assertFalse(newClass.getPlainSchemas().isEmpty());
92 assertFalse(newClass.getDerSchemas().isEmpty());
93 assertTrue(newClass.getVirSchemas().isEmpty());
94
95 assertEquals(newClass.getKey(), SCHEMA_SERVICE.read(SchemaType.PLAIN, plainSchema.getKey()).getAnyTypeClass());
96 assertEquals(newClass.getKey(), SCHEMA_SERVICE.read(SchemaType.DERIVED, derSchema.getKey()).getAnyTypeClass());
97
98 ANY_TYPE_CLASS_SERVICE.delete(newClass.getKey());
99
100 try {
101 ANY_TYPE_CLASS_SERVICE.read(newClass.getKey());
102 fail("This should not happen");
103 } catch (SyncopeClientException e) {
104 assertEquals(ClientExceptionType.NotFound, e.getType());
105 }
106
107 assertNull(SCHEMA_SERVICE.read(SchemaType.PLAIN, plainSchema.getKey()).getAnyTypeClass());
108 assertNull(SCHEMA_SERVICE.read(SchemaType.DERIVED, derSchema.getKey()).getAnyTypeClass());
109 }
110
111 @Test
112 public void deleteSchema() {
113 PlainSchemaTO newSchema = new PlainSchemaTO();
114 newSchema.setKey("newSchema" + getUUIDString());
115 newSchema.setType(AttrSchemaType.Date);
116 createSchema(SchemaType.PLAIN, newSchema);
117
118 AnyTypeClassTO newClass = new AnyTypeClassTO();
119 newClass.setKey("new class" + getUUIDString());
120 newClass.getPlainSchemas().add(newSchema.getKey());
121
122 Response response = ANY_TYPE_CLASS_SERVICE.create(newClass);
123 assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatusInfo().getStatusCode());
124
125 newClass = getObject(response.getLocation(), AnyTypeClassService.class, AnyTypeClassTO.class);
126 assertNotNull(newClass);
127 assertTrue(newClass.getPlainSchemas().contains(newSchema.getKey()));
128
129 SCHEMA_SERVICE.delete(SchemaType.PLAIN, newSchema.getKey());
130
131 newClass = ANY_TYPE_CLASS_SERVICE.read(newClass.getKey());
132 assertNotNull(newClass);
133 assertFalse(newClass.getPlainSchemas().contains(newSchema.getKey()));
134 }
135
136 @Test
137 public void issueSYNCOPE759() {
138 AnyTypeClassTO minimalGroup = ANY_TYPE_CLASS_SERVICE.read("minimal group");
139 assertNotNull(minimalGroup);
140
141 AnyTypeClassTO newAnyTypeClass = new AnyTypeClassTO();
142 newAnyTypeClass.setKey(minimalGroup.getKey());
143
144 try {
145 ANY_TYPE_CLASS_SERVICE.create(newAnyTypeClass);
146 fail("This should not happen");
147 } catch (SyncopeClientException e) {
148 assertEquals(ClientExceptionType.EntityExists, e.getType());
149 }
150 }
151 }