diff --git a/api/src/main/java/com/okta/sdk/resource/application/ApplicationBuilder.java b/api/src/main/java/com/okta/sdk/resource/application/ApplicationBuilder.java new file mode 100644 index 00000000000..75aa07d5c47 --- /dev/null +++ b/api/src/main/java/com/okta/sdk/resource/application/ApplicationBuilder.java @@ -0,0 +1,43 @@ +/* + * Copyright 2020-Present Okta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.okta.sdk.resource.application; + +import com.okta.commons.lang.Classes; +import com.okta.sdk.client.Client; + +public interface ApplicationBuilder { + static ApplicationBuilder instance() { + return Classes.newInstance("com.okta.sdk.impl.resource.DefaultApplicationBuilder"); + } + + T setName(String name); + + T setLabel(String label); + + T setErrorRedirectUrl(String errorRedirectUrl); + + T setLoginRedirectUrl(String loginRedirectUrl); + + T setSelfService(Boolean selfService); + + T setSignOnMode(ApplicationSignOnMode signOnMode); + + T setIOS(Boolean iOS); + + T setWeb(Boolean web); + + Application buildAndCreate(Client client); +} diff --git a/api/src/main/java/com/okta/sdk/resource/application/OIdCApplicationBuilder.java b/api/src/main/java/com/okta/sdk/resource/application/OIdCApplicationBuilder.java new file mode 100644 index 00000000000..e4dc8f8c5da --- /dev/null +++ b/api/src/main/java/com/okta/sdk/resource/application/OIdCApplicationBuilder.java @@ -0,0 +1,61 @@ +/* + * Copyright 2020-Present Okta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.okta.sdk.resource.application; + +import com.okta.commons.lang.Classes; + +import java.util.List; + +public interface OIdCApplicationBuilder extends ApplicationBuilder { + + static OIdCApplicationBuilder instance() { + return Classes.newInstance("com.okta.sdk.impl.resource.DefaultOIdCApplicationBuilder"); + } + + OIdCApplicationBuilder setApplicationType(OpenIdConnectApplicationType applicationType); + + OIdCApplicationBuilder setClientUri(String clientUri); + + OIdCApplicationBuilder setConsentMethod(OpenIdConnectApplicationConsentMethod consentMethod); + + OIdCApplicationBuilder setGrantTypes(List grantTypes); + + OIdCApplicationBuilder addGrantTypes(OAuthGrantType grantType); + + OIdCApplicationBuilder setLogoUri(String logoUri); + + OIdCApplicationBuilder setPolicyUri(String policyUri); + + OIdCApplicationBuilder setRedirectUris(List redirectUris); + + OIdCApplicationBuilder addRedirectUris(String redirectUri); + + OIdCApplicationBuilder setResponseTypes(List responseTypes); + + OIdCApplicationBuilder addResponseTypes(OAuthResponseType responseType); + + OIdCApplicationBuilder setTosUri(String tosUri); + + OIdCApplicationBuilder setClientId(String clientId); + + OIdCApplicationBuilder setClientSecret(String clientSecret); + + OIdCApplicationBuilder setAutoKeyRotation(Boolean autoKeyRotation); + + OIdCApplicationBuilder setTokenEndpointAuthMethod(OAuthEndpointAuthenticationMethod tokenEndpointAuthMethod); + + +} diff --git a/impl/src/main/java/com/okta/sdk/impl/resource/DefaultApplicationBuilder.java b/impl/src/main/java/com/okta/sdk/impl/resource/DefaultApplicationBuilder.java new file mode 100644 index 00000000000..00f0868433d --- /dev/null +++ b/impl/src/main/java/com/okta/sdk/impl/resource/DefaultApplicationBuilder.java @@ -0,0 +1,130 @@ +/* + * Copyright 2020-Present Okta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.okta.sdk.impl.resource; + +import com.okta.commons.lang.Strings; +import com.okta.sdk.client.Client; +import com.okta.sdk.resource.application.*; + +import java.util.Objects; + +public class DefaultApplicationBuilder implements ApplicationBuilder { + + protected String name; + protected String label; + protected String errorRedirectUrl; + protected String loginRedirectUrl; + protected Boolean selfService; + protected ApplicationSignOnMode signOnMode; + protected Boolean iOS; + protected Boolean web; + + + @Override + public T setName(String name) { + this.name = name; + return self(); + } + + @Override + public T setLabel(String label) { + this.label = label; + return self(); + } + + @Override + public T setErrorRedirectUrl(String errorRedirectUrl) { + this.errorRedirectUrl = errorRedirectUrl; + return self(); + } + + @Override + public T setLoginRedirectUrl(String loginRedirectUrl) { + this.loginRedirectUrl = loginRedirectUrl; + return self(); + } + + @Override + public T setSelfService(Boolean selfService) { + this.selfService = selfService; + return self(); + } + + @Override + public T setSignOnMode(ApplicationSignOnMode signOnMode) { + this.signOnMode = signOnMode; + return self(); + } + + @Override + public T setIOS(Boolean iOS) { + this.iOS = iOS; + return self(); + } + + @Override + public T setWeb(Boolean web) { + this.web = web; + return self(); + } + + @SuppressWarnings("unchecked") + protected T self() { return (T) this;} + + @Override + public Application buildAndCreate(Client client) { return client.createApplication(build(client)); } + + private Application build(Client client){ + + Application application = client.instantiate(Application.class); + + if (Strings.hasText(name)) + ((AbstractResource)application).setProperty("name", name, true); + + if (Strings.hasText(label)) application.setLabel(label); + + if (Objects.nonNull(signOnMode)) application.setSignOnMode(signOnMode); + + // Accessibility + application.setAccessibility(client.instantiate(ApplicationAccessibility.class)); + ApplicationAccessibility applicationAccessibility = application.getAccessibility(); + + if (Strings.hasText(loginRedirectUrl)) + applicationAccessibility.setLoginRedirectUrl(loginRedirectUrl); + + if (Strings.hasText(errorRedirectUrl)) + applicationAccessibility.setErrorRedirectUrl(errorRedirectUrl); + + if (Objects.nonNull(selfService)) + applicationAccessibility.setSelfService(selfService); + + // Visibility + application.setVisibility(client.instantiate(ApplicationVisibility.class)); + ApplicationVisibility applicationVisibility = application.getVisibility(); + ApplicationVisibilityHide applicationVisibilityHide = client.instantiate(ApplicationVisibilityHide.class); + + if(Objects.nonNull(iOS)) + applicationVisibility.setHide(applicationVisibilityHide + .setIOS(iOS)); + + if(Objects.nonNull(web)) + applicationVisibility.setHide(applicationVisibilityHide + .setWeb(web)); + + return application; + } + +} diff --git a/impl/src/main/java/com/okta/sdk/impl/resource/DefaultOIdCApplicationBuilder.java b/impl/src/main/java/com/okta/sdk/impl/resource/DefaultOIdCApplicationBuilder.java new file mode 100644 index 00000000000..64c02a13bf7 --- /dev/null +++ b/impl/src/main/java/com/okta/sdk/impl/resource/DefaultOIdCApplicationBuilder.java @@ -0,0 +1,234 @@ +/* + * Copyright 2020-Present Okta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.okta.sdk.impl.resource; + +import com.okta.commons.lang.Strings; +import com.okta.sdk.client.Client; +import com.okta.sdk.resource.application.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public class DefaultOIdCApplicationBuilder extends DefaultApplicationBuilder implements OIdCApplicationBuilder { + + private OpenIdConnectApplicationType applicationType; + private String clientUri; + private OpenIdConnectApplicationConsentMethod consentMethod; + private List grantTypes = new ArrayList<>(); + private String logoUri; + private String policyUri; + private List redirectUris = new ArrayList<>(); + private List responseTypes = new ArrayList<>(); + private String tosUri; + private String clientId; + private String clientSecret; + private Boolean autoKeyRotation; + private OAuthEndpointAuthenticationMethod tokenEndpointAuthMethod; + + + @Override + public OIdCApplicationBuilder setApplicationType(OpenIdConnectApplicationType applicationType) { + this.applicationType = applicationType; + return this; + } + + @Override + public OIdCApplicationBuilder setClientUri(String clientUri) { + this.clientUri = clientUri; + return this; + } + + @Override + public OIdCApplicationBuilder setConsentMethod(OpenIdConnectApplicationConsentMethod consentMethod) { + this.consentMethod = consentMethod; + return this; + } + + @Override + public OIdCApplicationBuilder setGrantTypes(List grantTypes) { + this.grantTypes = grantTypes; + return this; + } + + @Override + public OIdCApplicationBuilder addGrantTypes(OAuthGrantType grantType) { + this.grantTypes.add(grantType); + return this; + } + + @Override + public OIdCApplicationBuilder setLogoUri(String logoUri) { + this.logoUri = logoUri; + return this; + } + + @Override + public OIdCApplicationBuilder setPolicyUri(String policyUri) { + this.policyUri = policyUri; + return this; + } + + @Override + public OIdCApplicationBuilder setRedirectUris(List redirectUris) { + this.redirectUris = redirectUris; + return this; + } + + @Override + public OIdCApplicationBuilder addRedirectUris(String redirectUri) { + this.redirectUris.add(redirectUri); + return this; + } + + @Override + public OIdCApplicationBuilder setResponseTypes(List responseTypes) { + this.responseTypes = responseTypes; + return this; + } + + @Override + public OIdCApplicationBuilder addResponseTypes(OAuthResponseType responseType) { + this.responseTypes.add(responseType); + return this; + } + + @Override + public OIdCApplicationBuilder setTosUri(String tosUri) { + this.tosUri = tosUri; + return this; + } + + @Override + public OIdCApplicationBuilder setClientId(String clientId) { + this.clientId = clientId; + return this; + } + + @Override + public OIdCApplicationBuilder setClientSecret(String clientSecret) { + this.clientSecret = clientSecret; + return this; + } + + @Override + public OIdCApplicationBuilder setAutoKeyRotation(Boolean autoKeyRotation) { + this.autoKeyRotation = autoKeyRotation; + return this; + } + + @Override + public OIdCApplicationBuilder setTokenEndpointAuthMethod(OAuthEndpointAuthenticationMethod tokenEndpointAuthMethod) { + this.tokenEndpointAuthMethod = tokenEndpointAuthMethod; + return this; + } + + @Override + public OpenIdConnectApplication buildAndCreate(Client client){ return (OpenIdConnectApplication) client.createApplication(build(client)); } + + private Application build(Client client){ + OpenIdConnectApplication application = client.instantiate(OpenIdConnectApplication.class); + + if (Strings.hasText(label)) application.setLabel(label); + + if (Objects.nonNull(signOnMode)) application.setSignOnMode(signOnMode); + + // Accessibility + application.setAccessibility(client.instantiate(ApplicationAccessibility.class)); + ApplicationAccessibility applicationAccessibility = application.getAccessibility(); + + if (Strings.hasText(loginRedirectUrl)) + applicationAccessibility.setLoginRedirectUrl(loginRedirectUrl); + + if (Strings.hasText(errorRedirectUrl)) + applicationAccessibility.setErrorRedirectUrl(errorRedirectUrl); + + if (Objects.nonNull(selfService)) + applicationAccessibility.setSelfService(selfService); + + // Visibility + application.setVisibility(client.instantiate(ApplicationVisibility.class)); + ApplicationVisibility applicationVisibility = application.getVisibility(); + ApplicationVisibilityHide applicationVisibilityHide = client.instantiate(ApplicationVisibilityHide.class); + + if(Objects.nonNull(iOS)) + applicationVisibility.setHide(applicationVisibilityHide + .setIOS(iOS)); + + if(Objects.nonNull(web)) + applicationVisibility.setHide(applicationVisibilityHide + .setWeb(web)); + + // Settings + application.setSettings(client.instantiate(OpenIdConnectApplicationSettings.class)); + OpenIdConnectApplicationSettings openIdConnectApplicationSettings = application.getSettings(); + OpenIdConnectApplicationSettingsClient openIdConnectApplicationSettingsClient= client.instantiate(OpenIdConnectApplicationSettingsClient.class); + + if (Strings.hasText(clientUri)) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setClientUri(clientUri)); + + if (Strings.hasText(logoUri)) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setLogoUri(logoUri)); + + if (Strings.hasText(policyUri)) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setPolicyUri(policyUri)); + + if (Strings.hasText(tosUri)) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setTosUri(tosUri)); + + if (Objects.nonNull(redirectUris)) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setRedirectUris(redirectUris)); + + if (Objects.nonNull(responseTypes) && responseTypes.size()>0) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setResponseTypes(responseTypes)); + else + throw new IllegalArgumentException("Response Type cannot be null, value should be of type OAuthResponseType"); + + if (Objects.nonNull(grantTypes) && grantTypes.size()>0) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setGrantTypes(grantTypes)); + else + throw new IllegalArgumentException("Grant Type cannot be null, value should be of type OAuthGrantType"); + + if (Objects.nonNull(consentMethod)) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setConsentMethod(consentMethod)); + + if (Objects.nonNull(applicationType)) + openIdConnectApplicationSettings.setOAuthClient(openIdConnectApplicationSettingsClient.setApplicationType(applicationType)); + else + throw new IllegalArgumentException("Application Type cannot be null, value should be of type OpenIdConnectApplicationType"); + + // Credentials + application.setCredentials(client.instantiate(OAuthApplicationCredentials.class)); + OAuthApplicationCredentials oAuthApplicationCredentials = application.getCredentials(); + ApplicationCredentialsOAuthClient applicationCredentialsOAuthClient = client.instantiate(ApplicationCredentialsOAuthClient.class); + + if (Strings.hasText(clientId)) + oAuthApplicationCredentials.setOAuthClient(applicationCredentialsOAuthClient.setClientId(clientId)); + + if (Strings.hasText(clientSecret)) + oAuthApplicationCredentials.setOAuthClient(applicationCredentialsOAuthClient.setClientSecret(clientSecret)); + + if (Objects.nonNull(autoKeyRotation)) + oAuthApplicationCredentials.setOAuthClient(applicationCredentialsOAuthClient.setAutoKeyRotation(autoKeyRotation)); + + if (Objects.nonNull(tokenEndpointAuthMethod)) + oAuthApplicationCredentials.setOAuthClient(applicationCredentialsOAuthClient.setTokenEndpointAuthMethod(tokenEndpointAuthMethod)); + else + throw new IllegalArgumentException("Token Endpoint Auth Method cannot be null, value should be of type OAuthEndpointAuthenticationMethod"); + + return application; + } +} diff --git a/impl/src/test/groovy/com/okta/sdk/impl/resource/DefaultApplicationBuilderTest.groovy b/impl/src/test/groovy/com/okta/sdk/impl/resource/DefaultApplicationBuilderTest.groovy new file mode 100644 index 00000000000..3e016baa90c --- /dev/null +++ b/impl/src/test/groovy/com/okta/sdk/impl/resource/DefaultApplicationBuilderTest.groovy @@ -0,0 +1,60 @@ +/* + * Copyright 2020-Present Okta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.okta.sdk.impl.resource + +import com.okta.sdk.client.Client +import com.okta.sdk.resource.application.* +import org.testng.annotations.Test + +import static org.mockito.ArgumentMatchers.eq +import static org.mockito.Mockito.* + +class DefaultApplicationBuilderTest { + @Test + void basicUsage() { + def client = mock(Client) + def application = mock(Application) + def applicationAccessibility = mock(ApplicationAccessibility) + def applicationVisibilityHide = mock(ApplicationVisibilityHide) + def applicationVisibility = mock(ApplicationVisibility) + + when(client.instantiate(Application.class)).thenReturn(application); + when(client.instantiate(ApplicationAccessibility.class)).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibilityHide.class)).thenReturn(applicationVisibilityHide) + when(application.getAccessibility()).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibility.class)).thenReturn(applicationVisibility) + when(application.getVisibility())thenReturn(applicationVisibility) + + new DefaultApplicationBuilder() + .setLabel("test_app") + .setLoginRedirectUrl("http://www.myApp.com") + .setErrorRedirectUrl("http://www.myApp.com/error") + .setSelfService(false) + .setSignOnMode(ApplicationSignOnMode.AUTO_LOGIN) + .setIOS(false) + .setWeb(true) + .buildAndCreate(client); + + verify(client).createApplication(eq(application)) + verify(application).setLabel("test_app") + verify(application).setSignOnMode(ApplicationSignOnMode.AUTO_LOGIN) + verify(applicationAccessibility).setSelfService(false) + verify(applicationAccessibility).setErrorRedirectUrl("http://www.myApp.com/error") + verify(applicationAccessibility).setLoginRedirectUrl("http://www.myApp.com") + verify(applicationVisibilityHide).setWeb(true) + verify(applicationVisibilityHide).setIOS(false) + } +} diff --git a/impl/src/test/groovy/com/okta/sdk/impl/resource/DefaultOIdcApplicationBuilderTest.groovy b/impl/src/test/groovy/com/okta/sdk/impl/resource/DefaultOIdcApplicationBuilderTest.groovy new file mode 100644 index 00000000000..09e41448222 --- /dev/null +++ b/impl/src/test/groovy/com/okta/sdk/impl/resource/DefaultOIdcApplicationBuilderTest.groovy @@ -0,0 +1,214 @@ +/* + * Copyright 2020-Present Okta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.okta.sdk.impl.resource + +import com.okta.sdk.client.Client +import com.okta.sdk.resource.application.* +import org.testng.annotations.Test + +import static com.okta.sdk.impl.Util.expect +import static org.mockito.ArgumentMatchers.eq +import static org.mockito.Mockito.* + +class DefaultOIdcApplicationBuilderTest { + + @Test + void basicUsage() { + def client = mock(Client) + def application = mock(OpenIdConnectApplication) + def applicationAccessibility = mock(ApplicationAccessibility) + def applicationVisibilityHide = mock(ApplicationVisibilityHide) + def applicationVisibility = mock(ApplicationVisibility) + def openIdConnectApplicationSettingsClient = mock(OpenIdConnectApplicationSettingsClient) + def applicationCredentialsOAuthClient = mock(ApplicationCredentialsOAuthClient) + def openIdConnectApplicationSettings = mock(OpenIdConnectApplicationSettings) + def oAuthApplicationCredentials = mock(OAuthApplicationCredentials) + + when(client.instantiate(OpenIdConnectApplication.class)).thenReturn(application); + when(client.instantiate(ApplicationAccessibility.class)).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibilityHide.class)).thenReturn(applicationVisibilityHide) + when(application.getAccessibility()).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibility.class)).thenReturn(applicationVisibility) + when(application.getVisibility())thenReturn(applicationVisibility) + when(client.instantiate(OpenIdConnectApplicationSettingsClient.class))thenReturn(openIdConnectApplicationSettingsClient) + when(client.instantiate(ApplicationCredentialsOAuthClient.class))thenReturn(applicationCredentialsOAuthClient) + //when(client.instantiate(OpenIdConnectApplicationSettings.class))thenReturn(applicationCredentialsOAuthClient) + when(application.getSettings()).thenReturn(openIdConnectApplicationSettings) + when(application.getCredentials())thenReturn(oAuthApplicationCredentials) + + new DefaultOIdCApplicationBuilder() + .setName("oidc_client") + .setLabel("test_app") + .addRedirectUris("http://www.google.com") + .setResponseTypes(Arrays.asList(OAuthResponseType.TOKEN, OAuthResponseType.CODE)) + .setGrantTypes(Arrays.asList(OAuthGrantType.IMPLICIT, OAuthGrantType.AUTHORIZATION_CODE)) + .setApplicationType(OpenIdConnectApplicationType.NATIVE) + .setClientId("dummy_id") + .setClientSecret("dummy_shgfhsgdhfgwg") + .setAutoKeyRotation(true) + .setTokenEndpointAuthMethod(OAuthEndpointAuthenticationMethod.NONE) + .setIOS(true) + .setWeb(false) + .setLoginRedirectUrl("http://www.myApp.com") + .setErrorRedirectUrl("http://www.myApp.com/errror") + .setSelfService(false) + .buildAndCreate(client); + + verify(client).createApplication(eq(application)) + verify(application).setLabel("test_app") + verify(applicationAccessibility).setSelfService(false) + verify(applicationAccessibility).setErrorRedirectUrl("http://www.myApp.com/errror") + verify(applicationAccessibility).setLoginRedirectUrl("http://www.myApp.com") + verify(applicationVisibilityHide).setWeb(false) + verify(applicationVisibilityHide).setIOS(true) + verify(openIdConnectApplicationSettingsClient).setResponseTypes(Arrays.asList(OAuthResponseType.TOKEN, OAuthResponseType.CODE)) + } + + @Test + void createWithoutResponseType(){ + + def client = mock(Client) + def application = mock(OpenIdConnectApplication) + def applicationAccessibility = mock(ApplicationAccessibility) + def applicationVisibilityHide = mock(ApplicationVisibilityHide) + def applicationVisibility = mock(ApplicationVisibility) + def openIdConnectApplicationSettingsClient = mock(OpenIdConnectApplicationSettingsClient) + def applicationCredentialsOAuthClient = mock(ApplicationCredentialsOAuthClient) + def openIdConnectApplicationSettings = mock(OpenIdConnectApplicationSettings) + def oAuthApplicationCredentials = mock(OAuthApplicationCredentials) + + when(client.instantiate(OpenIdConnectApplication.class)).thenReturn(application); + when(client.instantiate(ApplicationAccessibility.class)).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibilityHide.class)).thenReturn(applicationVisibilityHide) + when(application.getAccessibility()).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibility.class)).thenReturn(applicationVisibility) + when(application.getVisibility())thenReturn(applicationVisibility) + when(client.instantiate(OpenIdConnectApplicationSettingsClient.class))thenReturn(openIdConnectApplicationSettingsClient) + when(client.instantiate(ApplicationCredentialsOAuthClient.class))thenReturn(applicationCredentialsOAuthClient) + when(application.getSettings()).thenReturn(openIdConnectApplicationSettings) + when(application.getCredentials())thenReturn(oAuthApplicationCredentials) + + expect IllegalArgumentException, { + new DefaultOIdCApplicationBuilder() + .setName("oidc_client") + .setLabel("test_app") + .addRedirectUris("http://www.google.com") + .setGrantTypes(Arrays.asList(OAuthGrantType.IMPLICIT, OAuthGrantType.AUTHORIZATION_CODE)) + .setApplicationType(OpenIdConnectApplicationType.NATIVE) + .setClientId("dummy_id") + .setClientSecret("dummy_shgfhsgdhfgwg") + .setAutoKeyRotation(true) + .setTokenEndpointAuthMethod(OAuthEndpointAuthenticationMethod.NONE) + .setIOS(true) + .setWeb(false) + .setLoginRedirectUrl("http://www.myApp.com") + .setErrorRedirectUrl("http://www.myApp.com/errror") + .setSelfService(false) + .buildAndCreate(client); + } + + } + + @Test + void createWithoutGrantType(){ + + def client = mock(Client) + def application = mock(OpenIdConnectApplication) + def applicationAccessibility = mock(ApplicationAccessibility) + def applicationVisibilityHide = mock(ApplicationVisibilityHide) + def applicationVisibility = mock(ApplicationVisibility) + def openIdConnectApplicationSettingsClient = mock(OpenIdConnectApplicationSettingsClient) + def applicationCredentialsOAuthClient = mock(ApplicationCredentialsOAuthClient) + def openIdConnectApplicationSettings = mock(OpenIdConnectApplicationSettings) + def oAuthApplicationCredentials = mock(OAuthApplicationCredentials) + + when(client.instantiate(OpenIdConnectApplication.class)).thenReturn(application); + when(client.instantiate(ApplicationAccessibility.class)).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibilityHide.class)).thenReturn(applicationVisibilityHide) + when(application.getAccessibility()).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibility.class)).thenReturn(applicationVisibility) + when(application.getVisibility())thenReturn(applicationVisibility) + when(client.instantiate(OpenIdConnectApplicationSettingsClient.class))thenReturn(openIdConnectApplicationSettingsClient) + when(client.instantiate(ApplicationCredentialsOAuthClient.class))thenReturn(applicationCredentialsOAuthClient) + when(application.getSettings()).thenReturn(openIdConnectApplicationSettings) + when(application.getCredentials())thenReturn(oAuthApplicationCredentials) + + expect IllegalArgumentException, { + new DefaultOIdCApplicationBuilder() + .setName("oidc_client") + .setLabel("test_app") + .addRedirectUris("http://www.google.com") + .setResponseTypes(Arrays.asList(OAuthResponseType.TOKEN, OAuthResponseType.CODE)) + .setApplicationType(OpenIdConnectApplicationType.NATIVE) + .setClientId("dummy_id") + .setClientSecret("dummy_shgfhsgdhfgwg") + .setAutoKeyRotation(true) + .setTokenEndpointAuthMethod(OAuthEndpointAuthenticationMethod.NONE) + .setIOS(true) + .setWeb(false) + .setLoginRedirectUrl("http://www.myApp.com") + .setErrorRedirectUrl("http://www.myApp.com/errror") + .setSelfService(false) + .buildAndCreate(client); + } + + } + + @Test + void createWithoutApplicationType(){ + + def client = mock(Client) + def application = mock(OpenIdConnectApplication) + def applicationAccessibility = mock(ApplicationAccessibility) + def applicationVisibilityHide = mock(ApplicationVisibilityHide) + def applicationVisibility = mock(ApplicationVisibility) + def openIdConnectApplicationSettingsClient = mock(OpenIdConnectApplicationSettingsClient) + def applicationCredentialsOAuthClient = mock(ApplicationCredentialsOAuthClient) + def openIdConnectApplicationSettings = mock(OpenIdConnectApplicationSettings) + def oAuthApplicationCredentials = mock(OAuthApplicationCredentials) + + when(client.instantiate(OpenIdConnectApplication.class)).thenReturn(application); + when(client.instantiate(ApplicationAccessibility.class)).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibilityHide.class)).thenReturn(applicationVisibilityHide) + when(application.getAccessibility()).thenReturn(applicationAccessibility) + when(client.instantiate(ApplicationVisibility.class)).thenReturn(applicationVisibility) + when(application.getVisibility())thenReturn(applicationVisibility) + when(client.instantiate(OpenIdConnectApplicationSettingsClient.class))thenReturn(openIdConnectApplicationSettingsClient) + when(client.instantiate(ApplicationCredentialsOAuthClient.class))thenReturn(applicationCredentialsOAuthClient) + when(application.getSettings()).thenReturn(openIdConnectApplicationSettings) + when(application.getCredentials())thenReturn(oAuthApplicationCredentials) + + expect IllegalArgumentException, { + new DefaultOIdCApplicationBuilder() + .setName("oidc_client") + .setLabel("test_app") + .addRedirectUris("http://www.google.com") + .setResponseTypes(Arrays.asList(OAuthResponseType.TOKEN, OAuthResponseType.CODE)) + .setGrantTypes(Arrays.asList(OAuthGrantType.IMPLICIT, OAuthGrantType.AUTHORIZATION_CODE)) + .setClientId("dummy_id") + .setClientSecret("dummy_shgfhsgdhfgwg") + .setAutoKeyRotation(true) + .setTokenEndpointAuthMethod(OAuthEndpointAuthenticationMethod.NONE) + .setIOS(true) + .setWeb(false) + .setLoginRedirectUrl("http://www.myApp.com") + .setErrorRedirectUrl("http://www.myApp.com/errror") + .setSelfService(false) + .buildAndCreate(client); + } + + } +} diff --git a/integration-tests/src/test/groovy/com/okta/sdk/tests/it/OIdCApplicationIT.groovy b/integration-tests/src/test/groovy/com/okta/sdk/tests/it/OIdCApplicationIT.groovy new file mode 100644 index 00000000000..ef19b9d2371 --- /dev/null +++ b/integration-tests/src/test/groovy/com/okta/sdk/tests/it/OIdCApplicationIT.groovy @@ -0,0 +1,72 @@ +/* + * Copyright 2020-Present Okta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.okta.sdk.tests.it + +import com.okta.sdk.client.Client +import com.okta.sdk.resource.application.* +import com.okta.sdk.tests.it.util.ITSupport + +import static org.hamcrest.MatcherAssert.assertThat +import static org.hamcrest.Matchers.is + +class OIdCApplicationIT extends ITSupport implements CrudTestSupport{ + @Override + def create(Client client) { + Application app = OIdCApplicationBuilder.instance() + .setName("oidc_client") + .setLabel("SDK test app - 1") + .addRedirectUris("http://www.google.com") + .setResponseTypes(Arrays.asList(OAuthResponseType.TOKEN, OAuthResponseType.CODE)) + .setGrantTypes(Arrays.asList(OAuthGrantType.IMPLICIT, OAuthGrantType.AUTHORIZATION_CODE)) + .setApplicationType(OpenIdConnectApplicationType.NATIVE) + .setClientId("dummy_id") + .setClientSecret("dummy_shgfhsgdhfgwg") + .setAutoKeyRotation(true) + .setTokenEndpointAuthMethod(OAuthEndpointAuthenticationMethod.NONE) + .setIOS(false) + .setWeb(true) + .setLoginRedirectUrl("http://www.myapp.com") + .setErrorRedirectUrl("http://www.myapp.com/errror") + .buildAndCreate(client); + + return (OpenIdConnectApplication)app + } + + @Override + def read(Client client, String id) { + return client.getApplication(id) + } + + @Override + Iterator getResourceCollectionIterator(Client client) { + return client.listApplications().iterator() + } + + @Override + void update(Client client, def application) { + application.setLabel("test_app") + application.visibility.hide.iOS = false + application.update() + } + + @Override + void assertUpdate(Client client, def app) { + assertThat app.label, is("test_app") + assertThat app.visibility.hide.iOS, is(false) + assertThat app.credentials.oauthClient.client_id, is("dummy_id") + + } +}