@Override protected void runTest() throws Exception { String[] externalIds = new String[batchSize]; for (int i = 0; i < batchSize; i++) { externalIds[i] = new ExternalIdentityRef(getRandomUserId(), idp.getName()).getString(); } bean.syncExternalUsers(externalIds); } }
@NotNull @Override public String fromExternalIdentityRef(@NotNull ExternalIdentityRef externalIdentityRef) throws ExternalIdentityException { if (!isMyRef(externalIdentityRef)) { throw new ExternalIdentityException("Foreign IDP " + externalIdentityRef.getString()); } return externalIdentityRef.getId(); }
@Test public void testFromString() { ExternalIdentityRef r = ExternalIdentityRef.fromString(refNullProvider.getString()); assertEquals(refNullProvider, r); assertEquals(USERID, r.getId()); assertEquals(refNullProvider.getString(), r.getString()); assertNull(r.getProviderName()); r = ExternalIdentityRef.fromString(refEmptyProvider.getString()); assertEquals(refEmptyProvider, r); assertEquals(USERID, r.getId()); assertEquals(refEmptyProvider.getString(), r.getString()); assertNull(r.getProviderName()); // empty provider string is converted to null r = ExternalIdentityRef.fromString(ref.getString()); assertEquals(ref, r); assertEquals(USERID, r.getId()); assertEquals(PROVIDER_NAME, r.getProviderName()); assertEquals(ref.getString(), r.getString()); }
@Nullable private String getIdpName(@NotNull Tree userTree) { PropertyState ps = userTree.getProperty(REP_EXTERNAL_ID); if (ps != null) { return ExternalIdentityRef.fromString(ps.getValue(Type.STRING)).getProviderName(); } else { return null; } }
protected TestIdentity withGroups(String ... grps) { for (String grp: grps) { groups.add(new ExternalIdentityRef(grp, id.getProviderName())); } return this; } }
/** * Returns the DN as principal name. * @return the DN */ @NotNull @Override public String getPrincipalName() { return ref.getId(); }
@NotNull @Override public ExternalIdentityRef getExternalId() { return new ExternalIdentityRef(userId, getName()); }
@NotNull @Override public String getPrincipalName() { return "p_" + getExternalId().getString(); }
@Test public void testEquals() { assertEquals(refNullProvider, refNullProvider); assertEquals(refNullProvider, new ExternalIdentityRef(USERID, refNullProvider.getProviderName())); assertEquals(refNullProvider, new ExternalIdentityRef(USERID, refEmptyProvider.getProviderName())); assertEquals(refNullProvider, refEmptyProvider); assertEquals(refEmptyProvider, refNullProvider); assertEquals(ref, ref); assertEquals(ref, new ExternalIdentityRef(ref.getId(), ref.getProviderName())); assertEquals(ref, new ExternalIdentityRef(USERID, PROVIDER_NAME)); }
@Override public ExternalIdentity getIdentity(@NotNull ExternalIdentityRef ref) throws ExternalIdentityException { if (getName().equals(ref.getProviderName())) { String id = ref.getId(); ExternalIdentity ei = getUser(id); if (ei == null) { ei = getGroup(id); } return ei; } else { return null; } }
} else { for (Value value: attr) { ExternalIdentityRef memberRef = new ExternalIdentityRef(value.getString(), this.getName()); members.put(memberRef.getId(), memberRef); log.debug("members lookup of {} found {} members. {}", ref.getId(), members.size(), timer.getString());
ExternalIdentityRef ref = ExternalIdentityRef.fromString(externalId); if (!idp.getName().equals(ref.getProviderName())) { results.add(new DefaultSyncResultImpl(new DefaultSyncedIdentity(ref.getId(), ref, false, -1), SyncResult.Status.FOREIGN)); } else { try {
private boolean ignore(@Nullable SyncedIdentity syncedIdentity, @Nullable PreAuthenticatedLogin preAuthLogin) { if (syncedIdentity != null) { ExternalIdentityRef externalIdRef = syncedIdentity.getExternalIdRef(); if (externalIdRef == null) { debug("ignoring local user: {}", syncedIdentity.getId()); return true; } else if (!idp.getName().equals(externalIdRef.getProviderName())) { debug("ignoring foreign identity: {} (idp={})", externalIdRef.getString(), idp.getName()); return true; } if (preAuthLogin != null && !syncHandler.requiresSync(syncedIdentity)) { debug("pre-authenticated external user {} does not require syncing.", syncedIdentity.toString()); return true; } } return false; }
/** * Tests if the given {@link ExternalIdentityRef} refers to the same IDP * as associated with this context instance. * * @param ref The {@link ExternalIdentityRef} to be tested. * @return {@code true} if {@link ExternalIdentityRef#getProviderName()} refers * to the IDP associated with this context instance. */ protected boolean isSameIDP(@NotNull ExternalIdentityRef ref) { return idp.getName().equals(ref.getProviderName()); } }
@Test public void testNotEquals() { Map<ExternalIdentityRef, ExternalIdentityRef> notEqual = new HashMap<>(); notEqual.put(refNullProvider, ref); notEqual.put(refEmptyProvider, ref); notEqual.put(refNullProvider, null); notEqual.put(refNullProvider, new ExternalIdentityRef("anotherId", null)); notEqual.put(ref, new ExternalIdentityRef("anotherId", PROVIDER_NAME)); notEqual.put(ref, new ExternalIdentityRef(USERID, "anotherProvider")); for (Map.Entry<ExternalIdentityRef, ExternalIdentityRef> entry : notEqual.entrySet()) { ExternalIdentityRef r1 = entry.getKey(); ExternalIdentityRef r2 = entry.getValue(); assertFalse(r1.equals(r2)); if (r2 != null) { assertFalse(r2.equals(r1)); } } }
/** * Retrieves the external identity ref from the authorizable * @param auth the authorizable * @return the ref * @throws RepositoryException if an error occurs */ @Nullable public static ExternalIdentityRef getIdentityRef(@Nullable Authorizable auth) throws RepositoryException { if (auth == null) { return null; } Value[] v = auth.getProperty(REP_EXTERNAL_ID); if (v == null || v.length == 0) { return null; } return ExternalIdentityRef.fromString(v[0].getString()); }
@Test public void testNotEqualsExternalIdentity() { assertFalse(ref.equals(new ExternalIdentity() { @NotNull @Override
@NotNull @Override public String fromExternalIdentityRef(@NotNull ExternalIdentityRef externalIdentityRef) { return "p_" + externalIdentityRef.getId(); } }
@NotNull @Override public Iterable<ExternalIdentityRef> getDeclaredMembers() throws ExternalIdentityException { Set<ExternalIdentityRef> members = new HashSet<ExternalIdentityRef>(); for (Map.Entry<String, Set<String>> entry : userGroupMap.entrySet()) { if (entry.getValue().contains(name)) { members.add(new ExternalIdentityRef(entry.getKey(), getName())); } } return members; }
@NotNull @Override public String getPrincipalName() { return "p_" + getExternalId().getString(); }