/** * 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()); } }
private boolean isMyRef(@NotNull ExternalIdentityRef ref) { final String refProviderName = ref.getProviderName(); return refProviderName == null || refProviderName.isEmpty() || getName().equals(refProviderName); }
/** * Checks if the given authorizable was synced from the same IDP by comparing the IDP name of the * {@value #REP_EXTERNAL_ID} property. * * @param auth the authorizable. * @return {@code true} if same IDP. */ protected boolean isSameIDP(@Nullable Authorizable auth) throws RepositoryException { ExternalIdentityRef ref = getIdentityRef(auth); return ref != null && idp.getName().equals(ref.getProviderName()); }
private boolean isMyIDP(@NotNull SyncedIdentity id) { ExternalIdentityRef ref = id.getExternalIdRef(); String providerName = (ref == null) ? null : ref.getProviderName(); return providerName != null && (providerName.isEmpty() || providerName.equals(idp.getName())); }
@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; } }
@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; } }
protected TestIdentity withGroups(String ... grps) { for (String grp: grps) { groups.add(new ExternalIdentityRef(grp, id.getProviderName())); } return this; } }
@Test public void testGetProviderName() { assertNull(refNullProvider.getProviderName()); assertNull(refEmptyProvider.getProviderName()); assertEquals(PROVIDER_NAME, ref.getProviderName()); }
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; }
@Test public void testToString() { for (ExternalIdentityRef r : ImmutableList.of(ref, refEmptyProvider, refEmptyProvider)) { assertEquals("ExternalIdentityRef{" + "id='" + r.getId() + '\'' + ", providerName='" + r.getProviderName() + '\'' + '}', r.toString()); } } }
for (String externalId : externalIds) { 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 {
@Test public void testListIdentitiesIgnoresLocal() throws Exception { sync(USER_ID, false); Iterator<SyncedIdentity> identities = syncHandler.listIdentities(userManager); while (identities.hasNext()) { SyncedIdentity si = identities.next(); ExternalIdentityRef ref = si.getExternalIdRef(); assertNotNull(ref); assertNotNull(ref.getProviderName()); } } }
@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)); }
private void sync(@NotNull String id, boolean isGroup) throws Exception { ctx = sh.createContext(idp, userManager, valueFactory); ExternalIdentity exIdentity = (isGroup) ? idp.getGroup(id) : idp.getUser(id); assertNotNull(exIdentity); SyncResult res = ctx.sync(exIdentity); assertEquals(idp.getName(), res.getIdentity().getExternalIdRef().getProviderName()); assertSame(SyncResult.Status.ADD, res.getStatus()); r.commit(); }
@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()); }
@Test public void testFindExternalIdentity() throws Exception { login(new SimpleCredentials(USER_ID, new char[0])).close(); root.refresh(); SyncedIdentity id = syncHandler.findIdentity(userManager, USER_ID); assertNotNull("known authorizable should exist", id); ExternalIdentityRef ref = id.getExternalIdRef(); assertNotNull(ref); assertEquals("external user should have correct external ref.idp", idp.getName(), ref.getProviderName()); assertEquals("external user should have correct external ref.id", USER_ID, id.getExternalIdRef().getId()); }