private Map<Field, String> getCallbackValues() { return providerModel.getModelProperty(OAuthCallbackValuesModelProperty.class) .map(OAuthCallbackValuesModelProperty::getCallbackValues) .orElseGet(Collections::emptyMap); }
/** * @return a {@link SoapServiceProvider} implementation {@link Class} for a given {@link ConnectionProviderModel}. */ private static Class<SoapServiceProvider> getServiceProviderType(ConnectionProviderModel model) { return model.getModelProperty(ImplementingTypeModelProperty.class) .map(prop -> (Class<SoapServiceProvider>) prop.getType()) .orElseThrow(() -> new IllegalStateException(format("No %s was defined in connection provider [%s]", ImplementingTypeModelProperty.class.getSimpleName(), model.getName()))); }
private void withCustomParameters(BiConsumer<ParameterModel, OAuthParameterModelProperty> delegate) { providerModel.getAllParameterModels().forEach(parameter -> parameter.getModelProperty(OAuthParameterModelProperty.class) .ifPresent(property -> delegate.accept(parameter, property))); }
/** * Tests the given {@code connectionProviderModel} for a {@link ConnectionTypeModelProperty} and if present it returns the * enclosed connection type. If no such property is found, then a {@link IllegalConnectionProviderModelDefinitionException} is * thrown * * @param connectionProviderModel a {@link ConnectionProviderModel} * @return a connection {@link Class} * @throws IllegalConnectionProviderModelDefinitionException if the connection provider is not properly enriched */ public static Type getConnectionType(ConnectionProviderModel connectionProviderModel) { return fromModelProperty(connectionProviderModel, ConnectionTypeModelProperty.class, ConnectionTypeModelProperty::getConnectionTypeElement, () -> new IllegalConnectionProviderModelDefinitionException( format("Connection Provider '%s' does not specify a connection type", connectionProviderModel .getName()))); }
private void assertTestConnectionModuleOn(String modulePath) { ExtensionModel extensionModel = getExtensionModelFrom(modulePath); assertThat(extensionModel.getName(), is("module-test-connection")); assertThat(extensionModel.getConfigurationModels().size(), is(1)); ConfigurationModel configurationModel = extensionModel.getConfigurationModels().get(0); assertThat(configurationModel.getName(), is(CONFIG_NAME)); assertThat(configurationModel.getAllParameterModels().size(), is(4)); Optional<ConnectionProviderModel> connectionProviderModel = configurationModel.getConnectionProviderModel(MODULE_CONNECTION_GLOBAL_ELEMENT_NAME); assertThat(connectionProviderModel.isPresent(), is(true)); assertThat(connectionProviderModel.get().supportsConnectivityTesting(), is(true)); }
private ConnectionProvider<C> applyConnectionManagement(ConnectionProvider<C> provider) { final ConnectionManagementType connectionManagementType = providerModel.getConnectionManagementType(); if (connectionManagementType == POOLING) { provider = new PoolingConnectionProviderWrapper<>(provider, poolingProfile, reconnectionConfig); } else { provider = new ReconnectableConnectionProviderWrapper<>(provider, reconnectionConfig); } return provider; }
@Override public List<ValueProviderModel> getConnectionModels(String providerName) throws ValueResolvingException { return withConnectionProviderInfo((connection, model) -> getValueProviderModels(model.getAllParameterModels())); }
private Optional<String> getTestConnectionGlobalElement(ConfigurationModel configurationModel) { final Optional<ConnectionProviderModel> connectionProviderModel = configurationModel.getConnectionProviderModel(MODULE_CONNECTION_GLOBAL_ELEMENT_NAME); if (connectionProviderModel.isPresent()) { final Optional<TestConnectionGlobalElementModelProperty> modelProperty = connectionProviderModel.get().getModelProperty(TestConnectionGlobalElementModelProperty.class); return modelProperty.map(TestConnectionGlobalElementModelProperty::getGlobalElementName); } else { return empty(); } } }
/** * Tests the given {@code connectionProviderModel} for a {@link ConnectionProviderFactoryModelProperty} and if present it * returns the enclosed {@link ConnectionProviderFactory}. If no such property is found, then a * {@link IllegalConnectionProviderModelDefinitionException} is thrown * * @param connectionProviderModel a {@link ConnectionProviderModel} * @return a {@link SourceFactory} * @throws IllegalConnectionProviderModelDefinitionException if the connection provider is not properly enriched */ public static ConnectionProviderFactory getConnectionProviderFactory(ConnectionProviderModel connectionProviderModel) { return fromModelProperty(connectionProviderModel, ConnectionProviderFactoryModelProperty.class, ConnectionProviderFactoryModelProperty::getConnectionProviderFactory, () -> new IllegalConnectionProviderModelDefinitionException( format("Connection Provider '%s' does not provide a %s", connectionProviderModel.getName(), ConnectionProviderFactory.class .getSimpleName()))); }
@Test public void untesteableConnetionProvider() throws Exception { ConnectionProviderModel connectionProviderModel = veganExtension.getConfigurationModel(APPLE) .map(c -> c.getConnectionProviders().get(0)) .get(); assertThat(connectionProviderModel.supportsConnectivityTesting(), is(false)); }
@Test public void contentParameterValidationIsSkipped() { ParameterModel offending = getParameter(SIMPLE_PARAM_NAME, String.class); when(offending.getRole()).thenReturn(CONTENT); when(connectionProviderModel.getAllParameterModels()) .thenReturn(asList(simpleConnectionProviderParam, topLevelConnectionProviderParam, offending)); validate(); }
private AuthorizationCodeGrantType getGrantType() { return providerModel.getModelProperty(OAuthModelProperty.class) .map(p -> (AuthorizationCodeGrantType) p.getGrantTypes().get(0)).get(); }
private List<ConnectionProviderModel> mockConnectionProviders(String... names) { return Stream.of(names).map(name -> { ConnectionProviderModel mock = mock(ConnectionProviderModel.class, Mockito.RETURNS_DEEP_STUBS); when(mock.getName()).thenReturn(name); return mock; }).collect(toList()); }
@Test public void testeableConnectionProvider() throws Exception { ConnectionProviderModel connectionProviderModel = veganExtension.getConfigurationModel(BANANA) .map(c -> c.getConnectionProviders().get(0)) .get(); assertThat(connectionProviderModel.supportsConnectivityTesting(), is(true)); }
@Test public void connectionProviderWithMultipleConfigReferenceParameter() { ParameterModel paramWithReferences = configuration.getConnectionProviders().get(0).getAllParameterModels().get(0); List<StereotypeModel> allowedStereotypes = paramWithReferences.getAllowedStereotypes(); assertThat(allowedStereotypes, hasSize(2)); assertStereotype(allowedStereotypes.get(0), HEISENBERG, "config", CONFIG); assertStereotype(allowedStereotypes.get(1), MARVEL_EXTENSION, CONFIG_NAME, CONFIG); }
/** * Resolves the correspondent {@link ConnectionProviderModel} for a given {@link ConnectionProvider} instance. * * @param connectionProvider connection provider class * @param allConnectionProviders list of available {@link ConnectionProviderModel} * @return an {@link Optional} value of the {@link ConnectionProviderModel} */ public static Optional<ConnectionProviderModel> getConnectionProviderModel( Class<? extends ConnectionProvider> connectionProvider, List<ConnectionProviderModel> allConnectionProviders) { for (ConnectionProviderModel providerModel : allConnectionProviders) { Optional<ImplementingTypeModelProperty> modelProperty = providerModel.getModelProperty(ImplementingTypeModelProperty.class); if (modelProperty.isPresent()) { ImplementingTypeModelProperty property = modelProperty.get(); if (property.getType().equals(connectionProvider)) { return of(providerModel); } } } return empty(); }
@Test public void connectionProviderNameWithOperationParameterNoChild() { when(connectionProviderModel.getName()).thenReturn(SIMPLE_PARAM_NAME); ParameterModel offending = getParameter(connectionProviderModel.getName(), NoChildTest.class); when(operationModel.getAllParameterModels()).thenReturn(asList(topLevelOperationParam, offending)); validate(); }
@Override protected void onConnectionProvider(ConnectionProviderModel model) { if (model.getModelProperty(OAuthModelProperty.class).isPresent()) { connectionProvider.set(model); stop(); } } }.walk(extensionModel);
@Test public void connectionProviderNameClashesWithAnotherConnectionProviderName() { exception.expect(IllegalModelDefinitionException.class); ConnectionProviderModel anotherConnectionProviderModel = mock(ConnectionProviderModel.class); when(anotherConnectionProviderModel.getName()).thenReturn(CONNECTION_PROVIDER_NAME); when(extensionModel.getConnectionProviders()).thenReturn(asList(connectionProviderModel, anotherConnectionProviderModel)); validate(); }
@Test public void connectionProvider() { ConnectionProviderModel provider = extensionModel.getConfigurationModel(REQUESTER_CONFIG_NAME).get().getConnectionProviders().get(0); assertThat(provider.getName(), is(REQUESTER_PROVIDER)); } }