/** * <p> * Determines if there is exactly one bean that matches the required type and qualifiers and is eligible for injection * into the class into which the parent <tt>Instance</tt> was injected. * </p> * * @since 2.0 * @return <tt>true</tt> if there is exactly one bean that matches the required type and qualifiers and is eligible for * injection into the class into which the parent <tt>Instance</tt> was injected, or <tt>false</tt> otherwise. */ default boolean isResolvable() { return !isUnsatisfied() && !isAmbiguous(); }
@Override public boolean isAmbiguous() { return instance().isAmbiguous(); }
@Inject public SSHKeyAuthenticatorImpl(final SSHKeyStoreService keyStoreService, final Instance<WorkbenchUserManager> workbenchUserManagerInstance) { this.keyStoreService = keyStoreService; if (!workbenchUserManagerInstance.isUnsatisfied() && !workbenchUserManagerInstance.isAmbiguous()) { this.userManager = workbenchUserManagerInstance.get(); } else { LOGGER.warn("Cannot find any implementation of 'WorkbenchUserManager'. Loading default implementation on SSH module"); this.userManager = this::getUser; } }
@Override public boolean isAmbiguous() { return instance().isAmbiguous(); }
private User getDefaultUser() { if (user.isAmbiguous() || user.isUnsatisfied()) { throw new IllegalStateException("Cannot get session info outside of servlet thread when no default user is provided."); } else { return user.get(); } }
/** * @return {@code true} if there is exactly one {@link javax.enterprise.inject.spi.Bean} * which resolves according to the currently selected type and qualifiers. * In other words: whether the Instance can serve an actual Contextual Reference. * * @since 2.0 */ default boolean isResolvable() { return !isAmbiguous() && !isUnsatisfied(); }
private User getDefaultUser() { if (user.isAmbiguous() || user.isUnsatisfied()) { throw new IllegalStateException("Cannot get session info outside of servlet thread when no default user is provided."); } else { return user.get(); } }
/** * <p> * Determines if there is exactly one bean that matches the required type and qualifiers and is eligible for injection * into the class into which the parent <tt>Instance</tt> was injected. * </p> * * @since 2.0 * @return <tt>true</tt> if there is exactly one bean that matches the required type and qualifiers and is eligible for * injection into the class into which the parent <tt>Instance</tt> was injected, or <tt>false</tt> otherwise. */ default boolean isResolvable() { return !isUnsatisfied() && !isAmbiguous(); }
public Messages getMessages() { if (instanceMessage.isUnsatisfied() || instanceMessage.isAmbiguous()) { return new Messages(); } return instanceMessage.get(); } }
public Alerts getAlerts() { if (instanceAlert.isUnsatisfied() || instanceAlert.isAmbiguous()) { return new Alerts(); } return instanceAlert.get(); }
@Test(dataProvider = ARQUILLIAN_DATA_PROVIDER) @SpecAssertion(section = Sections.TRIMMED_BEAN_ARCHIVE, id = "a") public void testProducerNotDsicovered(Instance<Bike> bikeInstance) { Assert.assertTrue(extension.isBikerProducerPATFired()); Assert.assertFalse(extension.isBikerProducerPBAFired()); Assert.assertFalse(bikeInstance.isAmbiguous()); }
@Test @SpecAssertions({ @SpecAssertion(section = DYNAMIC_LOOKUP, id = "ia"), @SpecAssertion(section = DYNAMIC_LOOKUP, id = "ib"), @SpecAssertion(section = DYNAMIC_LOOKUP, id = "la"), @SpecAssertion(section = DYNAMIC_LOOKUP, id = "m") }) public void testAlternatives() { Instance<Common> instance = getContextualReference(ObtainsInstanceBean.class).getCommon(); assertFalse(instance.isAmbiguous()); Iterator<Common> iterator = instance.iterator(); assertTrue(iterator.hasNext()); assertTrue(iterator.next() instanceof Baz); assertFalse(iterator.hasNext()); assertTrue(instance.get().ping()); }
@Test @SpecAssertions({ @SpecAssertion(section = DECLARING_ALTERNATIVE, id = "aa"), @SpecAssertion(section = SPECIALIZE_MANAGED_BEAN, id = "ac") }) public void testNotEnabledAlternativeDoesNotSpecialize() { assertFalse(bean1.getFactory() instanceof AlternativeSpecializedFactory); assertFalse(bean1.getProduct().isUnsatisfied()); assertFalse(bean1.getProduct().isAmbiguous()); assertNotNull(bean1.getProduct().get()); assertFalse(bean2.getFactory() instanceof AlternativeSpecializedFactory); assertFalse(bean2.getProduct().isUnsatisfied()); assertFalse(bean2.getProduct().isAmbiguous()); assertNotNull(bean2.getProduct().get()); }
@Test @SpecAssertions({ @SpecAssertion(section = "5.6", id = "da"), @SpecAssertion(section = "5.6.1", id = "m") }) public void testIsAmbiguous() { ObtainsInstanceBean injectionPoint = getInstanceByType(ObtainsInstanceBean.class); assert injectionPoint.getAnyPaymentProcessor().isAmbiguous(); assert !injectionPoint.getPaymentProcessor().isAmbiguous(); } }
@Test public void testConflictingDescriptors() { List<Object> events = extension.getEvents(); // ConflictingBeansXmlTest, VerifyExtension, Foo, AfterBeanDiscovery assertEquals(events.toString(), 4, events.size()); assertFalse(fooInstance.isUnsatisfied()); assertFalse(fooInstance.isAmbiguous()); fooInstance.get().ping(); }
@Test(groups = INTEGRATION) @SpecAssertions({ @SpecAssertion(section = DECLARING_ALTERNATIVE, id = "aa"), @SpecAssertion(section = SPECIALIZE_MANAGED_BEAN, id = "ac"), @SpecAssertion(section = DECLARING_SELECTED_ALTERNATIVES_BEAN_ARCHIVE, id = "i"), @SpecAssertion(section = SPECIALIZATION, id = "ca"), @SpecAssertion(section = SPECIALIZATION, id = "cb") }) public void testEnabledAlternativeSpecializes() { assertTrue(bean1.getFactory().get() instanceof AlternativeSpecializedFactory); assertTrue(bean1.getProduct().isUnsatisfied()); assertTrue(bean2.getFactory().isUnsatisfied()); assertTrue(bean2.getProduct().isUnsatisfied()); assertFalse(bean2.getProduct().isAmbiguous()); }
@Test(groups = INTEGRATION) @SpecAssertions({ @SpecAssertion(section = DECLARING_ALTERNATIVE, id = "aa"), @SpecAssertion(section = SPECIALIZE_MANAGED_BEAN, id = "ac"), @SpecAssertion(section = DECLARING_SELECTED_ALTERNATIVES_BEAN_ARCHIVE, id = "i"), @SpecAssertion(section = SPECIALIZATION, id = "ca"), @SpecAssertion(section = SPECIALIZATION, id = "cb") }) public void testEnabledAlternativeSpecializes() { assertTrue(bean1.getFactory().isUnsatisfied()); assertTrue(bean1.getProduct().isUnsatisfied()); assertFalse(bean1.getProduct().isAmbiguous()); assertTrue(bean2.getFactory().get() instanceof AlternativeSpecializedFactory); assertTrue(bean2.getProduct().isUnsatisfied()); }
@Test(groups = JAVAEE_FULL) @SpecAssertions({ @SpecAssertion(section = DECLARING_ALTERNATIVE, id = "aa"), @SpecAssertion(section = SPECIALIZE_MANAGED_BEAN, id = "ac"), @SpecAssertion(section = DECLARING_SELECTED_ALTERNATIVES_BEAN_ARCHIVE, id = "i"), @SpecAssertion(section = SPECIALIZATION, id = "ca"), @SpecAssertion(section = SPECIALIZATION, id = "cb") }) public void testEnabledAlternativeSpecializes() { assertTrue(bean1.getFactory().isUnsatisfied()); assertTrue(bean1.getProduct().isUnsatisfied()); assertTrue(bean2.getFactory().isUnsatisfied()); assertTrue(bean2.getProduct().isUnsatisfied()); assertFalse(bean2.getProduct().isAmbiguous()); }
@Test public void returnDefaultUserOutsideOfSessionThread() { when(userInstance.isAmbiguous()).thenReturn(false); when(userInstance.isUnsatisfied()).thenReturn(false); when(userInstance.get()).thenReturn(defaultUser); SessionInfo sessionInfo = factory.getSessionInfo(authService); assertSame(defaultUser, sessionInfo.getIdentity()); }
@Test public void returnAuthenticatedUserInSessionThread() { when(userInstance.isAmbiguous()).thenReturn(false); when(userInstance.isUnsatisfied()).thenReturn(false); when(userInstance.get()).thenReturn(defaultUser); reset(authService); when(authService.getUser()).thenReturn(sessionUser); RpcContext.set(threadMessage); SessionInfo sessionInfo = factory.getSessionInfo(authService); assertSame(sessionUser, sessionInfo.getIdentity()); }