service accounts - tests + fixes

infra/common/src/main/java/com/evolveum/midpoint/common/SynchronizationUtils.java

@@ -22,20 +22,22 @@
 import javax.xml.datatype.XMLGregorianCalendar;
 import javax.xml.namespace.QName;
 
-import com.evolveum.midpoint.common.refinery.RefinedResourceSchemaImpl;
-import com.evolveum.midpoint.util.QNameUtil;
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.lang.Validate;
 
 import com.evolveum.midpoint.common.refinery.RefinedResourceSchema;
+import com.evolveum.midpoint.common.refinery.RefinedResourceSchemaImpl;
 import com.evolveum.midpoint.prism.PrismObject;
 import com.evolveum.midpoint.prism.PrismPropertyValue;
 import com.evolveum.midpoint.prism.delta.PropertyDelta;
 import com.evolveum.midpoint.prism.path.ItemPath;
 import com.evolveum.midpoint.prism.xml.XmlTypeConverter;
 import com.evolveum.midpoint.schema.processor.ObjectClassComplexTypeDefinition;
 import com.evolveum.midpoint.schema.util.MiscSchemaUtil;
+import com.evolveum.midpoint.util.QNameUtil;
 import com.evolveum.midpoint.util.exception.SchemaException;
+import com.evolveum.midpoint.util.logging.Trace;
+import com.evolveum.midpoint.util.logging.TraceManager;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectSynchronizationDiscriminatorType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectSynchronizationType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType;
@@ -47,6 +49,8 @@
 
 public class SynchronizationUtils {
 
+	private static final Trace LOGGER = TraceManager.getTrace(SynchronizationUtils.class);
+
 	public static boolean isPolicyApplicable(PrismObject<? extends ShadowType> currentShadow,
 			ObjectSynchronizationType synchronizationPolicy, PrismObject<ResourceType> resource)
 					throws SchemaException {
@@ -70,7 +74,7 @@ public static boolean isPolicyApplicable(ObjectSynchronizationDiscriminatorType
 					"Illegal state, object synchronization discriminator type must have kind/intent specified. Current values are: kind="
 							+ kind + ", intent=" + intent);
 		}
-		return isPolicyApplicable(null, synchronizationDiscriminator.getKind(), synchronizationDiscriminator.getIntent(), synchronizationPolicy, resource);
+		return isPolicyApplicable(null, kind, intent, synchronizationPolicy, resource);
 
 	}
 
@@ -104,22 +108,26 @@ public static boolean isPolicyApplicable(QName objectClass, ShadowKindType kind,
 			}
 		}
 		if (policyObjectClasses != null && !policyObjectClasses.isEmpty()) {
-			if (!QNameUtil.contains(policyObjectClasses, objectClass)) {
+			if (objectClass != null && !QNameUtil.contains(policyObjectClasses, objectClass)) {
 				return false;
 			}
 		}
 
 		// kind
 		ShadowKindType policyKind = synchronizationPolicy.getKind();
+		LOGGER.trace("Comparing kinds, policy kind: {}, current kind: {}", policyKind, kind);
 		if (policyKind != null && kind != null && !policyKind.equals(kind)) {
+			LOGGER.trace("Kinds don't match, skipping policy {}", synchronizationPolicy);
 			return false;
 		}
 
 		// intent
 		// TODO is the intent always present in shadow at this time? [med]
 		String policyIntent = synchronizationPolicy.getIntent();
+		LOGGER.trace("Comparing intents, policy intent: {}, current intent: {}", policyIntent, intent);
 		if (policyIntent != null && intent != null
 				&& !MiscSchemaUtil.equalsIntent(intent, policyIntent)) {
+			LOGGER.trace("Intents don't match, skipping policy {}", synchronizationPolicy);
 			return false;
 		}
 

infra/schema/src/main/resources/xml/ns/public/common/common-core-3.xsd

@@ -9459,8 +9459,8 @@
             </xsd:documentation>
         </xsd:annotation>
         <xsd:sequence>
+        	<xsd:element name="objectSynchronizationSorter" type="tns:ObjectSynchronizationSorterType" minOccurs="0" maxOccurs="1"/>
         	<xsd:element name="objectSynchronization" type="tns:ObjectSynchronizationType" minOccurs="0" maxOccurs="unbounded"/>
-        	<xsd:element name="objectSynchronizationDivider" type="tns:ObjectSynchronizationDividerType" minOccurs="0" maxOccurs="1"/>
 		</xsd:sequence>
 	</xsd:complexType>
 
@@ -9638,7 +9638,7 @@
         </xsd:sequence>
     </xsd:complexType>
 
-    <xsd:complexType name="ObjectSynchronizationDividerType">
+    <xsd:complexType name="ObjectSynchronizationSorterType">
         <xsd:annotation>
             <xsd:documentation>
                 Defines a synchronization properties (configuration) for a
@@ -9672,6 +9672,8 @@
 		</xsd:sequence>
 	</xsd:complexType>
 
+	<xsd:element name="objectSynchronizationSorter" type="tns:ObjectSynchronizationSorterType"/>
+
 	 <xsd:complexType name="ObjectSynchronizationDiscriminatorType">
         <xsd:annotation>
             <xsd:documentation>
@@ -9680,7 +9682,7 @@
                 (live sync, reconciliation, import, ...)
             </xsd:documentation>
             <xsd:appinfo>
-  				<a:container/>
+<!--   				<a:container/> --> <!-- it's not container beacuse of the owner property. -->
    				<a:since>3.9</a:since>
    			</xsd:appinfo>
         </xsd:annotation>
@@ -9741,6 +9743,8 @@
 		</xsd:sequence>
 	</xsd:complexType>
 
+	<xsd:element name="objectSynchronizationDiscriminator" type="tns:ObjectSynchronizationDiscriminatorType"/>
+
     <xsd:complexType name="ConditionalSearchFilterType">
         <xsd:annotation>
             <xsd:documentation>

model/model-api/src/main/java/com/evolveum/midpoint/model/api/expr/MidpointFunctions.java

@@ -499,6 +499,8 @@ <F extends FocusType> void recompute(Class<F> type, String oid)
 	 * object.
 	 * </p>
 	 * 
+	 * @deprecated use searchShadowOwner instead
+	 * 
 	 * @param accountOid
 	 *            OID of the account to look for an owner
 	 * @return owner of the account or null
@@ -516,8 +518,13 @@ <F extends FocusType> void recompute(Class<F> type, String oid)
 	 *             unknown error from underlying layers or other unexpected
 	 *             state
 	 */
+	@Deprecated
 	PrismObject<UserType> findShadowOwner(String accountOid) throws ObjectNotFoundException, SecurityViolationException, SchemaException, ConfigurationException, ExpressionEvaluationException, CommunicationException;
 
+	<F extends FocusType> PrismObject<F> searchShadowOwner(String accountOid)
+			throws ObjectNotFoundException, SecurityViolationException, SchemaException, ConfigurationException,
+			ExpressionEvaluationException, CommunicationException;
+
 	/**
 	 * <p>
 	 * Search for objects.

model/model-impl/src/main/java/com/evolveum/midpoint/model/impl/expr/MidpointFunctionsImpl.java

@@ -1041,6 +1041,13 @@ public PrismObject<UserType> findShadowOwner(String accountOid)
 			ExpressionEvaluationException, CommunicationException {
 		return modelService.findShadowOwner(accountOid, getCurrentTask(), getCurrentResult());
 	}
+
+	@Override
+	public <F extends FocusType> PrismObject<F> searchShadowOwner(String accountOid)
+			throws ObjectNotFoundException, SecurityViolationException, SchemaException, ConfigurationException,
+			ExpressionEvaluationException, CommunicationException {
+		return (PrismObject<F>) modelService.searchShadowOwner(accountOid, null, getCurrentTask(), getCurrentResult());
+	}
 
 	@Override
 	public <T extends ObjectType> List<T> searchObjects(

model/model-impl/src/main/java/com/evolveum/midpoint/model/impl/sync/SynchronizationServiceImpl.java

@@ -48,6 +48,8 @@
 import com.evolveum.midpoint.prism.PrismContext;
 import com.evolveum.midpoint.prism.PrismObject;
 import com.evolveum.midpoint.prism.PrismProperty;
+import com.evolveum.midpoint.prism.PrismPropertyDefinition;
+import com.evolveum.midpoint.prism.PrismPropertyDefinitionImpl;
 import com.evolveum.midpoint.prism.PrismPropertyValue;
 import com.evolveum.midpoint.prism.delta.ChangeType;
 import com.evolveum.midpoint.prism.delta.ItemDelta;
@@ -91,7 +93,7 @@
 import com.evolveum.midpoint.xml.ns._public.common.common_3.FocusType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectSynchronizationDiscriminatorType;
-import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectSynchronizationDividerType;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectSynchronizationSorterType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectSynchronizationType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectTemplateType;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceType;
@@ -236,13 +238,15 @@ public <F extends FocusType> SynchronizationContext<F> loadSynchronizationContex
 		}
 
 		ObjectSynchronizationDiscriminatorType synchronizationDiscriminator = determineObjectSynchronizationDiscriminatorType(syncCtx, task, result);
-
 		if (synchronizationDiscriminator != null) {
+			LOGGER.trace("Setting synchronization situation to synchronization context: {}", synchronizationDiscriminator.getSynchronizationSituation());
 			syncCtx.setSituation(synchronizationDiscriminator.getSynchronizationSituation());
 			F owner = (F) syncCtx.getCurrentOwner();
 			if (owner != null && alreadyLinked(owner, syncCtx.getApplicableShadow())) {
+				LOGGER.trace("Setting owner to synchronization context: {}", synchronizationDiscriminator.getOwner());
 				syncCtx.setCurrentOwner((F) synchronizationDiscriminator.getOwner());
 			}
+			LOGGER.trace("Setting correlated owner to synchronization context: {}", synchronizationDiscriminator.getOwner());
 			syncCtx.setCorrelatedOwner((F) synchronizationDiscriminator.getOwner());
 		}
 
@@ -251,6 +255,9 @@ public <F extends FocusType> SynchronizationContext<F> loadSynchronizationContex
 				syncCtx.setObjectSynchronization(objectSynchronization);
 				return syncCtx;
 			}
+		}
+
+		for (ObjectSynchronizationType objectSynchronization : synchronization.getObjectSynchronization()) {
 			if (isPolicyApplicable(syncCtx, objectSynchronization, task, result)) {
 				syncCtx.setObjectSynchronization(objectSynchronization);
 				return syncCtx;
@@ -268,7 +275,7 @@ private <F extends FocusType> ObjectSynchronizationDiscriminatorType determineOb
 			return null;
 		}
 
-		ObjectSynchronizationDividerType divider = synchronizationType.getObjectSynchronizationDivider();
+		ObjectSynchronizationSorterType divider = synchronizationType.getObjectSynchronizationSorter();
 		if (divider == null) {
 			return null;
 		}
@@ -296,23 +303,28 @@ private <F extends FocusType> boolean isPolicyApplicable(SynchronizationContext<
 		return conditionResult != null ? conditionResult : true;
 	}
 
-	private <F extends FocusType> ObjectSynchronizationDiscriminatorType evaluateSynchronizationDivision(ObjectSynchronizationDividerType synchronizationDividerType,
+	private <F extends FocusType> ObjectSynchronizationDiscriminatorType evaluateSynchronizationDivision(ObjectSynchronizationSorterType synchronizationSorterType,
 			SynchronizationContext<F> syncCtx, Task task, OperationResult result)
 					throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException {
-		if (synchronizationDividerType.getExpression() == null) {
+		if (synchronizationSorterType.getExpression() == null) {
 			return null;
 		}
-		ExpressionType conditionExpressionType = synchronizationDividerType.getExpression();
+		ExpressionType classificationExpression = synchronizationSorterType.getExpression();
 		String desc = "syncrhonization divider type ";
 		ExpressionVariables variables = Utils.getDefaultExpressionVariables(null, syncCtx.getApplicableShadow(), null,
 				syncCtx.getResource(), syncCtx.getSystemConfiguration(), null);
 		variables.addVariableDefinition(ExpressionConstants.VAR_CHANNEL, syncCtx.getChanel());
 		try {
 			ModelExpressionThreadLocalHolder.pushExpressionEnvironment(new ExpressionEnvironment<>(task, result));
-			PrismContainerDefinition<ObjectSynchronizationDiscriminatorType> discriminatorDef = prismContext.getSchemaRegistry().findContainerDefinitionByType(ObjectSynchronizationDiscriminatorType.COMPLEX_TYPE);
-			PrismContainerValue<ObjectSynchronizationDiscriminatorType> evaluateCondition = ExpressionUtil.evaluateExpression(variables, discriminatorDef, 
-					conditionExpressionType, expressionFactory, desc, task, result);
-			return evaluateCondition.getValue();
+			PrismPropertyDefinition<ObjectSynchronizationDiscriminatorType> discriminatorDef = prismContext.getSchemaRegistry()
+					.findPropertyDefinitionByElementName(new QName(SchemaConstants.NS_C, "objectSynchronizationDiscriminator"));
+//			PrismPropertyDefinition<ObjectSynchronizationDiscriminatorType> discriminatorDef = prismContext.getSchemaRegistry().findPropertyDefinitionByElementName();
+			PrismPropertyValue<ObjectSynchronizationDiscriminatorType> evaluateDiscriminator = ExpressionUtil.evaluateExpression(variables, discriminatorDef, 
+					classificationExpression, expressionFactory, desc, task, result);
+			if (evaluateDiscriminator == null) {
+				return null;
+			}
+			return evaluateDiscriminator.getValue();
 		} finally {
 			ModelExpressionThreadLocalHolder.popExpressionEnvironment();
 		}
@@ -736,7 +748,7 @@ private <F extends FocusType> void determineSituationWithCorrelation(Synchroniza
 		}
 
 		F user = syncCtx.getCorrelatedOwner();
-
+		LOGGER.trace("Correlated owner present in synchronization context: {}", user);
 		if (user != null) {
 			if (syncCtx.getSituation() != null) {
 				return;

repo/repo-test-util/src/main/java/com/evolveum/midpoint/test/AbstractIntegrationTest.java

@@ -1936,12 +1936,12 @@ protected void assertNotLinked(String userOid, String accountOid) throws ObjectN
 		assertNotLinked(user, accountOid);
 	}
 
-	protected void assertNotLinked(PrismObject<UserType> user, PrismObject<ShadowType> account) throws ObjectNotFoundException, SchemaException {
+	protected <F extends FocusType> void assertNotLinked(PrismObject<F> user, PrismObject<ShadowType> account) throws ObjectNotFoundException, SchemaException {
 		assertNotLinked(user, account.getOid());
 	}
 
-	protected void assertNotLinked(PrismObject<UserType> user, String accountOid) throws ObjectNotFoundException, SchemaException {
-		PrismReference linkRef = user.findReference(UserType.F_LINK_REF);
+	protected <F extends FocusType> void assertNotLinked(PrismObject<F> user, String accountOid) throws ObjectNotFoundException, SchemaException {
+		PrismReference linkRef = user.findReference(FocusType.F_LINK_REF);
 		if (linkRef == null) {
 			return;
 		}
@@ -1954,7 +1954,7 @@ protected void assertNotLinked(PrismObject<UserType> user, String accountOid) th
 		assertFalse("User " + user + " IS linked to account " + accountOid + " but not expecting it", found);
 	}
 
-	protected void assertNoLinkedAccount(PrismObject<UserType> user) {
+	protected <F extends FocusType> void assertNoLinkedAccount(PrismObject<F> user) {
 		PrismReference accountRef = user.findReference(UserType.F_LINK_REF);
 		if (accountRef == null) {
 			return;