Separate association simulation from the rest

Here are some fixes/improvements to make some model-intest test pass. Work in progress. Tests may still fail.
Evolveum · Mar 5, 2024 · ddc17ea · ddc17ea
1 parent 4cf3260
commit ddc17ea
Show file tree

Hide file tree

Showing 56 changed files with 1,020 additions and 807 deletions.
diff --git a/...chema/src/main/java/com/evolveum/midpoint/schema/config/AbstractAssignmentConfigItem.java b/...chema/src/main/java/com/evolveum/midpoint/schema/config/AbstractAssignmentConfigItem.java
@@ -15,23 +15,18 @@
 /** Exception from naming convention (because of assignment vs inducement dichotomy). */
 public class AbstractAssignmentConfigItem extends ConfigurationItem<AssignmentType> {
 
-    @SuppressWarnings("unused") // called dynamically
+    @SuppressWarnings({ "unused", "WeakerAccess" }) // called dynamically
     public AbstractAssignmentConfigItem(@NotNull ConfigurationItem<AssignmentType> original) {
         super(original);
     }
 
-    public AbstractAssignmentConfigItem(@NotNull AssignmentType value, @NotNull ConfigurationItemOrigin origin) {
-        super(value, origin);
+    AbstractAssignmentConfigItem(
+            @NotNull AssignmentType value, @NotNull ConfigurationItemOrigin origin, @Nullable ConfigurationItem<?> parent) {
+        super(value, origin, parent);
     }
 
     public static AbstractAssignmentConfigItem of(@NotNull AssignmentType bean, @NotNull ConfigurationItemOrigin origin) {
-        return new AbstractAssignmentConfigItem(bean, origin);
-    }
-
-    public static AbstractAssignmentConfigItem of(
-            @NotNull AssignmentType bean,
-            @NotNull OriginProvider<? super AssignmentType> originProvider) {
-        return new AbstractAssignmentConfigItem(bean, originProvider.origin(bean));
+        return new AbstractAssignmentConfigItem(bean, origin, null);
     }
 
     @Override

diff --git a/...chema/src/main/java/com/evolveum/midpoint/schema/config/AbstractPolicyRuleConfigItem.java b/...chema/src/main/java/com/evolveum/midpoint/schema/config/AbstractPolicyRuleConfigItem.java
@@ -28,13 +28,13 @@
 /** Exception from naming rules */
 public abstract class AbstractPolicyRuleConfigItem<R extends PolicyRuleType> extends ConfigurationItem<R> {
 
-    @SuppressWarnings("unused") // invoked dynamically
-    AbstractPolicyRuleConfigItem(@NotNull ConfigurationItem<R> original) {
+    @SuppressWarnings({ "unused", "WeakerAccess" }) // invoked dynamically
+    public AbstractPolicyRuleConfigItem(@NotNull ConfigurationItem<R> original) {
         super(original);
     }
 
     AbstractPolicyRuleConfigItem(@NotNull R value, @NotNull ConfigurationItemOrigin origin) {
-        super(value, origin);
+        super(value, origin, null); // TODO provide parent some day
     }
 
     public @Nullable String getName() {

diff --git a/.../java/com/evolveum/midpoint/schema/config/AbstractResourceObjectDefinitionConfigItem.java b/.../java/com/evolveum/midpoint/schema/config/AbstractResourceObjectDefinitionConfigItem.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2010-2023 Evolveum and contributors
+ *
+ * This work is dual-licensed under the Apache License 2.0
+ * and European Union Public License. See LICENSE file for details.
+ */
+
+package com.evolveum.midpoint.schema.config;
+
+import com.evolveum.midpoint.prism.path.ItemName;
+import com.evolveum.midpoint.util.MiscUtil;
+import com.evolveum.midpoint.util.QNameUtil;
+import com.evolveum.midpoint.util.exception.SchemaException;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceObjectTypeDelineationType;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.evolveum.midpoint.prism.path.ItemPath;
+import com.evolveum.midpoint.util.exception.ConfigurationException;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceAttributeDefinitionType;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceObjectTypeDefinitionType;
+
+import org.jetbrains.annotations.Nullable;
+
+import javax.xml.namespace.QName;
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.evolveum.midpoint.util.MiscUtil.stateCheck;
+
+/** Type or class definition in schema handling. */
+public class AbstractResourceObjectDefinitionConfigItem
+        extends ConfigurationItem<ResourceObjectTypeDefinitionType> {
+
+    @SuppressWarnings({ "unused", "WeakerAccess" }) // called dynamically
+    public AbstractResourceObjectDefinitionConfigItem(@NotNull ConfigurationItem<ResourceObjectTypeDefinitionType> original) {
+        super(original);
+    }
+
+    void checkAttributeNames() throws ConfigurationException {
+        for (var attrDefCI : getAttributes()) {
+            attrDefCI.getAttributeName();
+        }
+    }
+
+    public @NotNull List<QName> getAuxiliaryObjectClassNames() throws ConfigurationException {
+        ResourceObjectTypeDelineationType delineation = value().getDelineation();
+        List<QName> newValues = delineation != null ? delineation.getAuxiliaryObjectClass() : List.of();
+        List<QName> legacyValues = value().getAuxiliaryObjectClass();
+        // We do not want to compare the lists (etc) - we simply disallow specifying at both places.
+        configCheck(newValues.isEmpty() || legacyValues.isEmpty(),
+                "Auxiliary object classes must not be specified in both new and legacy ways in %s", DESC);
+        if (!newValues.isEmpty()) {
+            return newValues;
+        } else {
+            return legacyValues;
+        }
+    }
+
+    public List<ResourceAttributeDefinitionConfigItem> getAttributes() {
+        return children(
+                value().getAttribute(),
+                ResourceAttributeDefinitionConfigItem.class,
+                ResourceObjectTypeDefinitionType.F_ATTRIBUTE);
+    }
+
+    public List<ResourceObjectAssociationConfigItem> getAssociations() {
+        return children(
+                value().getAssociation(),
+                ResourceObjectAssociationConfigItem.class,
+                ResourceObjectTypeDefinitionType.F_ASSOCIATION);
+    }
+
+    public @Nullable ResourceAttributeDefinitionConfigItem getAttributeDefinitionIfPresent(ItemName attrName)
+            throws ConfigurationException {
+        List<ResourceAttributeDefinitionConfigItem> matching = new ArrayList<>();
+        for (var attrDef : getAttributes()) {
+            if (QNameUtil.match(attrDef.getAttributeName(), attrName)) {
+                matching.add(attrDef);
+            }
+        }
+        return single(matching, "Duplicate definition of attribute '%s' in %s", attrName, DESC);
+    }
+}
diff --git a/infra/schema/src/main/java/com/evolveum/midpoint/schema/config/AssignmentConfigItem.java b/infra/schema/src/main/java/com/evolveum/midpoint/schema/config/AssignmentConfigItem.java
@@ -13,12 +13,13 @@
 
 public class AssignmentConfigItem extends AbstractAssignmentConfigItem {
 
+    @SuppressWarnings("unused") // invoked dynamically
     public AssignmentConfigItem(@NotNull ConfigurationItem<AssignmentType> original) {
         super(original);
     }
 
-    public AssignmentConfigItem(@NotNull AssignmentType value, @NotNull ConfigurationItemOrigin origin) {
-        super(value, origin);
+    private AssignmentConfigItem(@NotNull AssignmentType value, @NotNull ConfigurationItemOrigin origin) {
+        super(value, origin, null);
     }
 
     public static AssignmentConfigItem of(

diff --git a/infra/schema/src/main/java/com/evolveum/midpoint/schema/config/AssociationConfigItem.java b/infra/schema/src/main/java/com/evolveum/midpoint/schema/config/AssociationConfigItem.java
@@ -23,7 +23,11 @@
 import java.io.Serializable;
 import java.util.List;
 
-/** Used to access both "legacy" and "modern" association definitions. Should be quite self-explanatory. */
+/**
+ * Used to access both "legacy" and "modern" association definitions. Should be quite self-explanatory.
+ *
+ * TODO better name
+ */
 public interface AssociationConfigItem extends DebugDumpable {
 
     @Nullable MappingConfigItem getOutboundMapping() throws ConfigurationException;

diff --git a/...a/src/main/java/com/evolveum/midpoint/schema/config/AssociationsCapabilityConfigItem.java b/...a/src/main/java/com/evolveum/midpoint/schema/config/AssociationsCapabilityConfigItem.java
@@ -25,12 +25,7 @@ public AssociationsCapabilityConfigItem(@NotNull ConfigurationItem<AssociationsC
         super(original);
     }
 
-    public static AssociationsCapabilityConfigItem of(
-            @NotNull AssociationsCapabilityType value, @NotNull ConfigurationItemOrigin origin) {
-        return ConfigurationItem.of(value, origin)
-                .as(AssociationsCapabilityConfigItem.class);
-    }
-
+    @SuppressWarnings("WeakerAccess")
     public @NotNull List<SimulatedAssociationClassConfigItem> getAssociationClasses() {
         return children(
                 value().getAssociationClass(),

diff --git a/...schema/src/main/java/com/evolveum/midpoint/schema/config/AutoAssignMappingConfigItem.java b/...schema/src/main/java/com/evolveum/midpoint/schema/config/AutoAssignMappingConfigItem.java
@@ -11,35 +11,18 @@
 import com.evolveum.midpoint.xml.ns._public.common.common_3.AutoassignMappingType;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /** Unfortunately, this cannot extend MappingConfigItem because of the conflict in generic type parameters. */
 public class AutoAssignMappingConfigItem
         extends ConfigurationItem<AutoassignMappingType>
         implements AbstractMappingConfigItem<AutoassignMappingType> {
 
-    @SuppressWarnings("unused") // called dynamically
+    @SuppressWarnings({ "unused", "WeakerAccess" }) // called dynamically
     public AutoAssignMappingConfigItem(@NotNull ConfigurationItem<AutoassignMappingType> original) {
         super(original);
     }
 
-    public AutoAssignMappingConfigItem(@NotNull AutoassignMappingType value, @NotNull ConfigurationItemOrigin origin) {
-        super(value, origin);
-    }
-
-    public static AutoAssignMappingConfigItem embedded(@NotNull AutoassignMappingType bean) {
-        return of(bean, ConfigurationItemOrigin.embedded(bean));
-    }
-
-    public static AutoAssignMappingConfigItem of(@NotNull AutoassignMappingType bean, @NotNull ConfigurationItemOrigin origin) {
-        return new AutoAssignMappingConfigItem(bean, origin);
-    }
-
-    public static AutoAssignMappingConfigItem of(
-            @NotNull AutoassignMappingType bean,
-            @NotNull OriginProvider<? super AutoassignMappingType> originProvider) {
-        return new AutoAssignMappingConfigItem(bean, originProvider.origin(bean));
-    }
-
     /** See LensUtil.setMappingTarget */
     public @NotNull AutoAssignMappingConfigItem setTargetIfMissing(@NotNull ItemPath path) {
         return setTargetIfMissing(path, AutoAssignMappingConfigItem.class);

diff --git a/.../src/main/java/com/evolveum/midpoint/schema/config/AutoassignSpecificationConfigItem.java b/.../src/main/java/com/evolveum/midpoint/schema/config/AutoassignSpecificationConfigItem.java
@@ -13,6 +13,8 @@
 import com.evolveum.midpoint.xml.ns._public.common.common_3.AutoassignSpecificationType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.FocalAutoassignSpecificationType;
 
+import static com.evolveum.midpoint.schema.config.ConfigurationItem.configItem;
+
 public class AutoassignSpecificationConfigItem extends ConfigurationItem<AutoassignSpecificationType> {
 
     @SuppressWarnings("unused") // called dynamically
@@ -21,8 +23,7 @@ public AutoassignSpecificationConfigItem(@NotNull ConfigurationItem<AutoassignSp
     }
 
     public static AutoassignSpecificationConfigItem embedded(@NotNull AutoassignSpecificationType value) {
-        return ConfigurationItem.embedded(value)
-                .as(AutoassignSpecificationConfigItem.class);
+        return configItem(value, ConfigurationItemOrigin.embedded(value), AutoassignSpecificationConfigItem.class);
     }
 
     public boolean isEnabled() {
@@ -38,4 +39,9 @@ public boolean isEnabled() {
             return null;
         }
     }
+
+    @Override
+    public @NotNull String localDescription() {
+        return "auto-assignment mapping";
+    }
 }