Rework tests (#693)

Signed-off-by: Anatolii Bazko <abazko@redhat.com>
2021-03-02 13:56:29 +02:00 · 2021-03-02 13:56:29 +02:00 · 385976dfd3
parent ce614f70e3
commit 385976dfd3
2 changed files with 557 additions and 692 deletions
--- a/pkg/controller/che/che_controller_test.go
+++ b/pkg/controller/che/che_controller_test.go
@ -14,10 +14,11 @@ package che
 import (
 	"context"
 	"fmt"
-	mocks "github.com/eclipse/che-operator/mocks"
 	"io/ioutil"
 	"os"

+	mocks "github.com/eclipse/che-operator/mocks"
+
 	"reflect"
 	"time"

@ -973,697 +974,6 @@ func TestConfiguringLabelsForRoutes(t *testing.T) {
 	}
 }

-func TestShouldSetUpCorrectlyInternalIdentityProviderServiceURL(t *testing.T) {
-	os.Setenv("OPENSHIFT_VERSION", "3")
-
-	type testCase struct {
-		name                                string
-		cheCR                               *orgv1.CheCluster
-		expectedIdentityProviderInternalURL string
-	}
-
-	// Set the logger to development mode for verbose logs.
-	logf.SetLogger(logf.ZapLogger(true))
-
-	testCases := []testCase{
-		{
-			name: "Should use 'external' public identity provider url, when internal network is enabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: true,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth:           util.NewBoolPointer(false),
-						ExternalIdentityProvider: true,
-						IdentityProviderURL:      "http://external-keycloak",
-					},
-				},
-			},
-			expectedIdentityProviderInternalURL: "http://external-keycloak/auth",
-		},
-		{
-			name: "Should use 'external' public identity provider url, when internal network is disabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: false,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth:           util.NewBoolPointer(false),
-						ExternalIdentityProvider: true,
-						IdentityProviderURL:      "http://external-keycloak",
-					},
-				},
-			},
-			expectedIdentityProviderInternalURL: "http://external-keycloak/auth",
-		},
-		{
-			name: "Should use public identity provider url, when internal network is disabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: false,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth:           util.NewBoolPointer(false),
-						ExternalIdentityProvider: false,
-					},
-				},
-			},
-			expectedIdentityProviderInternalURL: "http://keycloak/auth",
-		},
-		{
-			name: "Should use internal identity provider url, when internal network is enabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: true,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth:           util.NewBoolPointer(false),
-						ExternalIdentityProvider: false,
-					},
-				},
-			},
-			expectedIdentityProviderInternalURL: "http://keycloak.eclipse-che.svc:8080/auth",
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			scheme := scheme.Scheme
-			orgv1.SchemeBuilder.AddToScheme(scheme)
-			scheme.AddKnownTypes(routev1.SchemeGroupVersion, &routev1.Route{})
-
-			cli := fake.NewFakeClientWithScheme(scheme, testCase.cheCR)
-			nonCachedClient := fake.NewFakeClientWithScheme(scheme, testCase.cheCR)
-			clientSet := fakeclientset.NewSimpleClientset()
-			fakeDiscovery, ok := clientSet.Discovery().(*fakeDiscovery.FakeDiscovery)
-			fakeDiscovery.Fake.Resources = []*metav1.APIResourceList{}
-			if !ok {
-				t.Fatal("Error creating fake discovery client")
-			}
-			r := &ReconcileChe{
-				client:          cli,
-				nonCachedClient: nonCachedClient,
-				discoveryClient: fakeDiscovery,
-				scheme:          scheme,
-				tests:           true,
-			}
-			req := reconcile.Request{
-				NamespacedName: types.NamespacedName{
-					Name:      name,
-					Namespace: namespace,
-				},
-			}
-
-			clusterAPI := deploy.ClusterAPI{
-				Client: r.client,
-				Scheme: r.scheme,
-			}
-			deployContext := &deploy.DeployContext{
-				CheCluster: testCase.cheCR,
-				ClusterAPI: clusterAPI,
-			}
-
-			// Set up che host for route
-			cheRoute, _ := deploy.GetSpecRoute(deployContext, deploy.DefaultCheFlavor(testCase.cheCR), "che-host", "che-host", 8080, orgv1.RouteCustomSettings{}, "che")
-			r.client.Create(context.TODO(), cheRoute)
-			// Set up keycloak host for route
-			keycloakRoute, _ := deploy.GetSpecRoute(deployContext, deploy.IdentityProviderName, "keycloak", deploy.IdentityProviderName, 8080, orgv1.RouteCustomSettings{}, deploy.IdentityProviderName)
-			r.client.Create(context.TODO(), keycloakRoute)
-
-			_, err := r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-			_, err = r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-			_, err = r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-
-			cheCm := &corev1.ConfigMap{}
-			if err := r.client.Get(context.TODO(), types.NamespacedName{Name: "che", Namespace: testCase.cheCR.Namespace}, cheCm); err != nil {
-				t.Errorf("ConfigMap %s not found: %s", cheCm.Name, err)
-			}
-
-			keycloakInternalURLActual := cheCm.Data["CHE_KEYCLOAK_AUTH__INTERNAL__SERVER__URL"]
-			keycloakInternalURLExpected := testCase.expectedIdentityProviderInternalURL
-			if keycloakInternalURLActual != keycloakInternalURLExpected {
-				t.Fatalf("Keycloak internal url must be %s", keycloakInternalURLExpected)
-			}
-		})
-	}
-}
-
-func TestShouldSetUpCorrectlyInternalPluginRegistryServiceURL(t *testing.T) {
-	os.Setenv("OPENSHIFT_VERSION", "3")
-
-	type testCase struct {
-		name                              string
-		cheCR                             *orgv1.CheCluster
-		expectedPluginRegistryInternalURL string
-	}
-
-	// Set the logger to development mode for verbose logs.
-	logf.SetLogger(logf.ZapLogger(true))
-
-	testCases := []testCase{
-		{
-			name: "Should use 'external' public plugin registry url, when internal network is enabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: true,
-						ExternalPluginRegistry:     true,
-						PluginRegistryUrl:          "http://external-plugin-registry",
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedPluginRegistryInternalURL: "http://external-plugin-registry",
-		},
-		{
-			name: "Should use 'external' public plugin registry url, when internal network is disabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: false,
-						ExternalPluginRegistry:     true,
-						PluginRegistryUrl:          "http://external-plugin-registry",
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedPluginRegistryInternalURL: "http://external-plugin-registry",
-		},
-		{
-			name: "Should use public plugin registry url, when internal network is disabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: false,
-						ExternalPluginRegistry:     false,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedPluginRegistryInternalURL: "http://plugin-registry/v3",
-		},
-		{
-			name: "Should use internal plugin registry url, when internal network is enabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: true,
-						ExternalPluginRegistry:     false,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedPluginRegistryInternalURL: "http://plugin-registry.eclipse-che.svc:8080/v3",
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			scheme := scheme.Scheme
-			orgv1.SchemeBuilder.AddToScheme(scheme)
-			scheme.AddKnownTypes(routev1.SchemeGroupVersion, &routev1.Route{})
-
-			cli := fake.NewFakeClientWithScheme(scheme, testCase.cheCR)
-			nonCachedClient := fake.NewFakeClientWithScheme(scheme, testCase.cheCR)
-			clientSet := fakeclientset.NewSimpleClientset()
-			fakeDiscovery, ok := clientSet.Discovery().(*fakeDiscovery.FakeDiscovery)
-			fakeDiscovery.Fake.Resources = []*metav1.APIResourceList{}
-			if !ok {
-				t.Fatal("Error creating fake discovery client")
-			}
-			r := &ReconcileChe{
-				client:          cli,
-				nonCachedClient: nonCachedClient,
-				discoveryClient: fakeDiscovery,
-				scheme:          scheme,
-				tests:           true,
-			}
-			req := reconcile.Request{
-				NamespacedName: types.NamespacedName{
-					Name:      name,
-					Namespace: namespace,
-				},
-			}
-
-			clusterAPI := deploy.ClusterAPI{
-				Client: r.client,
-				Scheme: r.scheme,
-			}
-			deployContext := &deploy.DeployContext{
-				CheCluster: testCase.cheCR,
-				ClusterAPI: clusterAPI,
-			}
-
-			// Set up che host for route
-			cheRoute, _ := deploy.GetSpecRoute(deployContext, deploy.DefaultCheFlavor(testCase.cheCR), "che-host", "che-host", 8080, orgv1.RouteCustomSettings{}, "che")
-			r.client.Create(context.TODO(), cheRoute)
-			// Set up keycloak host for route
-			keycloakRoute, _ := deploy.GetSpecRoute(deployContext, deploy.IdentityProviderName, "keycloak", deploy.IdentityProviderName, 8080, orgv1.RouteCustomSettings{}, deploy.IdentityProviderName)
-			r.client.Create(context.TODO(), keycloakRoute)
-			// Set up plugin registry host for route
-			pluginRegistryRoute, _ := deploy.GetSpecRoute(deployContext, deploy.PluginRegistryName, "plugin-registry", deploy.PluginRegistryName, 8080, orgv1.RouteCustomSettings{}, deploy.PluginRegistryName)
-			r.client.Create(context.TODO(), pluginRegistryRoute)
-			// Set up devfile registry host for route
-			devfileRegistryRoute, _ := deploy.GetSpecRoute(deployContext, deploy.DevfileRegistryName, "devfile-registry", deploy.DevfileRegistryName, 8080, orgv1.RouteCustomSettings{}, deploy.DevfileRegistryName)
-			r.client.Create(context.TODO(), devfileRegistryRoute)
-
-			_, err := r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-			_, err = r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-
-			cheCm := &corev1.ConfigMap{}
-			if err := r.client.Get(context.TODO(), types.NamespacedName{Name: "che", Namespace: testCase.cheCR.Namespace}, cheCm); err != nil {
-				t.Errorf("ConfigMap %s not found: %s", cheCm.Name, err)
-			}
-
-			pluginRegistryInternalURLActual := cheCm.Data["CHE_WORKSPACE_PLUGIN__REGISTRY__INTERNAL__URL"]
-			pluginRegistryInternalURLExpected := testCase.expectedPluginRegistryInternalURL
-			if pluginRegistryInternalURLActual != pluginRegistryInternalURLExpected {
-				t.Fatalf("plugin registry internal url must be %s", pluginRegistryInternalURLExpected)
-			}
-		})
-	}
-}
-
-func TestShouldSetUpCorrectlyInternalDevfileRegistryServiceURL(t *testing.T) {
-	os.Setenv("OPENSHIFT_VERSION", "3")
-
-	type testCase struct {
-		name                               string
-		cheCR                              *orgv1.CheCluster
-		expectedDevfileRegistryInternalURL string
-	}
-
-	// Set the logger to development mode for verbose logs.
-	logf.SetLogger(logf.ZapLogger(true))
-
-	testCases := []testCase{
-		{
-			name: "Should use 'external' devfile registry url, when internal network is enabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: true,
-						ExternalDevfileRegistry:    true,
-						DevfileRegistryUrl:         "http://external-devfile-registry",
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedDevfileRegistryInternalURL: "http://external-devfile-registry",
-		},
-		{
-			name: "Should use 'external' public devfile registry url, when internal network is disabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: false,
-						ExternalDevfileRegistry:    true,
-						DevfileRegistryUrl:         "http://external-devfile-registry",
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedDevfileRegistryInternalURL: "http://external-devfile-registry",
-		},
-		{
-			name: "Should use public devfile registry url, when internal network is disabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: false,
-						ExternalDevfileRegistry:    false,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedDevfileRegistryInternalURL: "http://devfile-registry",
-		},
-		{
-			name: "Should use internal devfile registry url, when internal network is enabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: true,
-						ExternalDevfileRegistry:    false,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedDevfileRegistryInternalURL: "http://devfile-registry.eclipse-che.svc:8080",
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			scheme := scheme.Scheme
-			orgv1.SchemeBuilder.AddToScheme(scheme)
-			scheme.AddKnownTypes(routev1.SchemeGroupVersion, &routev1.Route{})
-
-			cli := fake.NewFakeClientWithScheme(scheme, testCase.cheCR)
-			nonCachedClient := fake.NewFakeClientWithScheme(scheme, testCase.cheCR)
-			clientSet := fakeclientset.NewSimpleClientset()
-			fakeDiscovery, ok := clientSet.Discovery().(*fakeDiscovery.FakeDiscovery)
-			fakeDiscovery.Fake.Resources = []*metav1.APIResourceList{}
-			if !ok {
-				t.Fatal("Error creating fake discovery client")
-			}
-			r := &ReconcileChe{
-				client:          cli,
-				nonCachedClient: nonCachedClient,
-				discoveryClient: fakeDiscovery,
-				scheme:          scheme,
-				tests:           true,
-			}
-			req := reconcile.Request{
-				NamespacedName: types.NamespacedName{
-					Name:      name,
-					Namespace: namespace,
-				},
-			}
-
-			clusterAPI := deploy.ClusterAPI{
-				Client: r.client,
-				Scheme: r.scheme,
-			}
-			deployContext := &deploy.DeployContext{
-				CheCluster: testCase.cheCR,
-				ClusterAPI: clusterAPI,
-			}
-
-			// Set up che host for route
-			cheRoute, _ := deploy.GetSpecRoute(deployContext, deploy.DefaultCheFlavor(testCase.cheCR), "che-host", "che-host", 8080, orgv1.RouteCustomSettings{}, "che")
-			r.client.Create(context.TODO(), cheRoute)
-			// Set up keycloak host for route
-			keycloakRoute, _ := deploy.GetSpecRoute(deployContext, deploy.IdentityProviderName, "keycloak", deploy.IdentityProviderName, 8080, orgv1.RouteCustomSettings{}, deploy.IdentityProviderName)
-			r.client.Create(context.TODO(), keycloakRoute)
-			// Set up plugin registry host for route
-			pluginRegistryRoute, _ := deploy.GetSpecRoute(deployContext, deploy.PluginRegistryName, "plugin-registry", deploy.PluginRegistryName, 8080, orgv1.RouteCustomSettings{}, deploy.PluginRegistryName)
-			r.client.Create(context.TODO(), pluginRegistryRoute)
-			// Set up devfile registry host for route
-			devfileRegistryRoute, _ := deploy.GetSpecRoute(deployContext, deploy.DevfileRegistryName, "devfile-registry", deploy.DevfileRegistryName, 8080, orgv1.RouteCustomSettings{}, deploy.DevfileRegistryName)
-			r.client.Create(context.TODO(), devfileRegistryRoute)
-
-			_, err := r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-			_, err = r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-
-			cheCm := &corev1.ConfigMap{}
-			if err := r.client.Get(context.TODO(), types.NamespacedName{Name: "che", Namespace: testCase.cheCR.Namespace}, cheCm); err != nil {
-				t.Errorf("ConfigMap %s not found: %s", cheCm.Name, err)
-			}
-
-			devfileRegistryInternalURLActual := cheCm.Data["CHE_WORKSPACE_DEVFILE__REGISTRY__INTERNAL__URL"]
-			devfileRegistryInternalURLExpected := testCase.expectedDevfileRegistryInternalURL
-			if devfileRegistryInternalURLActual != devfileRegistryInternalURLExpected {
-				t.Fatalf("devfile registry internal url must be %s", devfileRegistryInternalURLExpected)
-			}
-		})
-	}
-}
-
-func TestShouldSetUpCorrectlyInternalCheServerURL(t *testing.T) {
-	os.Setenv("OPENSHIFT_VERSION", "3")
-
-	type testCase struct {
-		name                         string
-		cheCR                        *orgv1.CheCluster
-		expectedCheServerInternalURL string
-	}
-
-	// Set the logger to development mode for verbose logs.
-	logf.SetLogger(logf.ZapLogger(true))
-
-	testCases := []testCase{
-		{
-			name: "Should use public che-server url, when internal network is disabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: false,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedCheServerInternalURL: "http://che-host/api",
-		},
-		{
-			name: "Should use internal che-server url, when internal network is enabled",
-			cheCR: &orgv1.CheCluster{
-				TypeMeta: metav1.TypeMeta{
-					Kind:       "CheCluster",
-					APIVersion: "org.eclipse.che/v1",
-				},
-				ObjectMeta: metav1.ObjectMeta{
-					Name:            name,
-					Namespace:       namespace,
-					ResourceVersion: "1",
-				},
-				Spec: orgv1.CheClusterSpec{
-					Server: orgv1.CheClusterSpecServer{
-						UseInternalClusterSVCNames: true,
-						ExternalDevfileRegistry:    false,
-					},
-					Auth: orgv1.CheClusterSpecAuth{
-						OpenShiftoAuth: util.NewBoolPointer(false),
-					},
-				},
-			},
-			expectedCheServerInternalURL: "http://che-host.eclipse-che.svc:8080/api",
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			scheme := scheme.Scheme
-			orgv1.SchemeBuilder.AddToScheme(scheme)
-			scheme.AddKnownTypes(routev1.SchemeGroupVersion, &routev1.Route{})
-
-			cli := fake.NewFakeClientWithScheme(scheme, testCase.cheCR)
-			nonCachedClient := fake.NewFakeClientWithScheme(scheme, testCase.cheCR)
-			clientSet := fakeclientset.NewSimpleClientset()
-			fakeDiscovery, ok := clientSet.Discovery().(*fakeDiscovery.FakeDiscovery)
-			fakeDiscovery.Fake.Resources = []*metav1.APIResourceList{}
-			if !ok {
-				t.Fatal("Error creating fake discovery client")
-			}
-			r := &ReconcileChe{
-				client:          cli,
-				nonCachedClient: nonCachedClient,
-				discoveryClient: fakeDiscovery,
-				scheme:          scheme,
-				tests:           true,
-			}
-			req := reconcile.Request{
-				NamespacedName: types.NamespacedName{
-					Name:      name,
-					Namespace: namespace,
-				},
-			}
-
-			clusterAPI := deploy.ClusterAPI{
-				Client: r.client,
-				Scheme: r.scheme,
-			}
-			deployContext := &deploy.DeployContext{
-				CheCluster: testCase.cheCR,
-				ClusterAPI: clusterAPI,
-			}
-
-			// Set up che host for route
-			cheRoute, _ := deploy.GetSpecRoute(deployContext, deploy.DefaultCheFlavor(testCase.cheCR), "che-host", "che-host", 8080, orgv1.RouteCustomSettings{}, "che")
-			r.client.Create(context.TODO(), cheRoute)
-			// Set up keycloak host for route
-			keycloakRoute, _ := deploy.GetSpecRoute(deployContext, deploy.IdentityProviderName, "keycloak", deploy.IdentityProviderName, 8080, orgv1.RouteCustomSettings{}, deploy.IdentityProviderName)
-			r.client.Create(context.TODO(), keycloakRoute)
-			// Set up plugin registry host for route
-			pluginRegistryRoute, _ := deploy.GetSpecRoute(deployContext, deploy.PluginRegistryName, "plugin-registry", deploy.PluginRegistryName, 8080, orgv1.RouteCustomSettings{}, deploy.PluginRegistryName)
-			r.client.Create(context.TODO(), pluginRegistryRoute)
-			// Set up devfile registry host for route
-			devfileRegistryRoute, _ := deploy.GetSpecRoute(deployContext, deploy.DevfileRegistryName, "devfile-registry", deploy.DevfileRegistryName, 8080, orgv1.RouteCustomSettings{}, deploy.DevfileRegistryName)
-			r.client.Create(context.TODO(), devfileRegistryRoute)
-
-			_, err := r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-			_, err = r.Reconcile(req)
-			if err != nil {
-				t.Fatalf("Error reconciling: %v", err)
-			}
-
-			cheCm := &corev1.ConfigMap{}
-			if err := r.client.Get(context.TODO(), types.NamespacedName{Name: "che", Namespace: testCase.cheCR.Namespace}, cheCm); err != nil {
-				t.Errorf("ConfigMap %s not found: %s", cheCm.Name, err)
-			}
-
-			cheServerInternalURLActual := cheCm.Data["CHE_API_INTERNAL"]
-			cheServerInternalURLExpected := testCase.expectedCheServerInternalURL
-			if cheServerInternalURLActual != cheServerInternalURLExpected {
-				t.Fatalf("che-server internal url must be %s", cheServerInternalURLExpected)
-			}
-		})
-	}
-}
-
 func TestShouldDelegatePermissionsForCheWorkspaces(t *testing.T) {
 	os.Setenv("OPENSHIFT_VERSION", "3")
 	type testCase struct {
--- a/pkg/deploy/server/che_configmap_test.go
+++ b/pkg/deploy/server/che_configmap_test.go
@ -362,3 +362,558 @@ func TestUpdateBitBucketEndpoints(t *testing.T) {
 		})
 	}
 }
+
+func TestShouldSetUpCorrectlyInternalDevfileRegistryServiceURL(t *testing.T) {
+	type testCase struct {
+		name         string
+		isOpenShift  bool
+		isOpenShift4 bool
+		initObjects  []runtime.Object
+		cheCluster   *orgv1.CheCluster
+		expectedData map[string]string
+	}
+
+	testCases := []testCase{
+		{
+			name: "Should use 'external' devfile registry url, when internal network is enabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: true,
+						ExternalDevfileRegistry:    true,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					DevfileRegistryURL: "http://external-devfile-registry",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_WORKSPACE_DEVFILE__REGISTRY__INTERNAL__URL": "http://external-devfile-registry",
+			},
+		},
+		{
+			name: "Should use 'external' devfile registry url, when internal network is disabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: false,
+						ExternalDevfileRegistry:    true,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					DevfileRegistryURL: "http://external-devfile-registry",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_WORKSPACE_DEVFILE__REGISTRY__INTERNAL__URL": "http://external-devfile-registry",
+			},
+		},
+		{
+			name: "Should use public devfile registry url, when internal network is disabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: false,
+						ExternalDevfileRegistry:    false,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					DevfileRegistryURL: "http://devfile-registry",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_WORKSPACE_DEVFILE__REGISTRY__INTERNAL__URL": "http://devfile-registry",
+			},
+		},
+		{
+			name: "Should use internal devfile registry url, when internal network is enabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: true,
+						ExternalDevfileRegistry:    false,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					DevfileRegistryURL: "http://external-devfile-registry",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_WORKSPACE_DEVFILE__REGISTRY__INTERNAL__URL": "http://devfile-registry.eclipse-che.svc:8080",
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			logf.SetLogger(zap.LoggerTo(os.Stdout, true))
+			orgv1.SchemeBuilder.AddToScheme(scheme.Scheme)
+			testCase.initObjects = append(testCase.initObjects)
+			cli := fake.NewFakeClientWithScheme(scheme.Scheme, testCase.initObjects...)
+			nonCachedClient := fake.NewFakeClientWithScheme(scheme.Scheme, testCase.initObjects...)
+
+			deployContext := &deploy.DeployContext{
+				CheCluster: testCase.cheCluster,
+				ClusterAPI: deploy.ClusterAPI{
+					Client:          cli,
+					NonCachedClient: nonCachedClient,
+					Scheme:          scheme.Scheme,
+				},
+				Proxy: &deploy.Proxy{},
+				InternalService: deploy.InternalService{
+					DevfileRegistryHost: "http://devfile-registry.eclipse-che.svc:8080",
+				},
+			}
+
+			util.IsOpenShift = testCase.isOpenShift
+			util.IsOpenShift4 = testCase.isOpenShift4
+
+			actualData, err := GetCheConfigMapData(deployContext)
+			if err != nil {
+				t.Fatalf("Error creating ConfigMap data: %v", err)
+			}
+
+			util.ValidateContainData(actualData, testCase.expectedData, t)
+		})
+	}
+}
+
+func TestShouldSetUpCorrectlyInternalPluginRegistryServiceURL(t *testing.T) {
+	type testCase struct {
+		name         string
+		isOpenShift  bool
+		isOpenShift4 bool
+		initObjects  []runtime.Object
+		cheCluster   *orgv1.CheCluster
+		expectedData map[string]string
+	}
+
+	testCases := []testCase{
+		{
+			name: "Should use 'external' public plugin registry url, when internal network is enabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: true,
+						ExternalPluginRegistry:     true,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					PluginRegistryURL: "http://external-plugin-registry",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_WORKSPACE_PLUGIN__REGISTRY__INTERNAL__URL": "http://external-plugin-registry",
+			},
+		},
+		{
+			name: "Should use 'external' public plugin registry url, when internal network is disabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: false,
+						ExternalPluginRegistry:     true,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					PluginRegistryURL: "http://external-plugin-registry",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_WORKSPACE_PLUGIN__REGISTRY__INTERNAL__URL": "http://external-plugin-registry",
+			},
+		},
+		{
+			name: "Should use public plugin registry url, when internal network is disabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: false,
+						ExternalPluginRegistry:     false,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					PluginRegistryURL: "http://plugin-registry/v3",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_WORKSPACE_PLUGIN__REGISTRY__INTERNAL__URL": "http://plugin-registry/v3",
+			},
+		},
+		{
+			name: "Should use internal plugin registry url, when internal network is enabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: true,
+						ExternalPluginRegistry:     false,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					PluginRegistryURL: "http://external-plugin-registry",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_WORKSPACE_PLUGIN__REGISTRY__INTERNAL__URL": "http://plugin-registry.eclipse-che.svc:8080/v3",
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			logf.SetLogger(zap.LoggerTo(os.Stdout, true))
+			orgv1.SchemeBuilder.AddToScheme(scheme.Scheme)
+			testCase.initObjects = append(testCase.initObjects)
+			cli := fake.NewFakeClientWithScheme(scheme.Scheme, testCase.initObjects...)
+			nonCachedClient := fake.NewFakeClientWithScheme(scheme.Scheme, testCase.initObjects...)
+
+			deployContext := &deploy.DeployContext{
+				CheCluster: testCase.cheCluster,
+				ClusterAPI: deploy.ClusterAPI{
+					Client:          cli,
+					NonCachedClient: nonCachedClient,
+					Scheme:          scheme.Scheme,
+				},
+				Proxy: &deploy.Proxy{},
+				InternalService: deploy.InternalService{
+					PluginRegistryHost: "http://plugin-registry.eclipse-che.svc:8080/v3",
+				},
+			}
+
+			util.IsOpenShift = testCase.isOpenShift
+			util.IsOpenShift4 = testCase.isOpenShift4
+
+			actualData, err := GetCheConfigMapData(deployContext)
+			if err != nil {
+				t.Fatalf("Error creating ConfigMap data: %v", err)
+			}
+
+			util.ValidateContainData(actualData, testCase.expectedData, t)
+		})
+	}
+}
+
+func TestShouldSetUpCorrectlyInternalCheServerURL(t *testing.T) {
+	type testCase struct {
+		name         string
+		isOpenShift  bool
+		isOpenShift4 bool
+		initObjects  []runtime.Object
+		cheCluster   *orgv1.CheCluster
+		expectedData map[string]string
+	}
+
+	testCases := []testCase{
+		{
+			name: "Should use public che-server url, when internal network is disabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: false,
+						CheHost:                    "che-host",
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_API_INTERNAL": "http://che-host/api",
+			},
+		},
+		{
+			name: "Should use internal che-server url, when internal network is enabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: true,
+						CheHost:                    "http://che-host",
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth: util.NewBoolPointer(false),
+					},
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_API_INTERNAL": "http://che-host.eclipse-che.svc:8080/api",
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			logf.SetLogger(zap.LoggerTo(os.Stdout, true))
+			orgv1.SchemeBuilder.AddToScheme(scheme.Scheme)
+			testCase.initObjects = append(testCase.initObjects)
+			cli := fake.NewFakeClientWithScheme(scheme.Scheme, testCase.initObjects...)
+			nonCachedClient := fake.NewFakeClientWithScheme(scheme.Scheme, testCase.initObjects...)
+
+			deployContext := &deploy.DeployContext{
+				CheCluster: testCase.cheCluster,
+				ClusterAPI: deploy.ClusterAPI{
+					Client:          cli,
+					NonCachedClient: nonCachedClient,
+					Scheme:          scheme.Scheme,
+				},
+				Proxy: &deploy.Proxy{},
+				InternalService: deploy.InternalService{
+					CheHost: "http://che-host.eclipse-che.svc:8080",
+				},
+			}
+
+			util.IsOpenShift = testCase.isOpenShift
+			util.IsOpenShift4 = testCase.isOpenShift4
+
+			actualData, err := GetCheConfigMapData(deployContext)
+			if err != nil {
+				t.Fatalf("Error creating ConfigMap data: %v", err)
+			}
+
+			util.ValidateContainData(actualData, testCase.expectedData, t)
+		})
+	}
+}
+
+func TestShouldSetUpCorrectlyInternalIdentityProviderServiceURL(t *testing.T) {
+	type testCase struct {
+		name         string
+		isOpenShift  bool
+		isOpenShift4 bool
+		initObjects  []runtime.Object
+		cheCluster   *orgv1.CheCluster
+		expectedData map[string]string
+	}
+
+	testCases := []testCase{
+		{
+			name: "Should use 'external' public identity provider url, when internal network is enabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: true,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth:           util.NewBoolPointer(false),
+						ExternalIdentityProvider: true,
+						IdentityProviderURL:      "http://external-keycloak",
+					},
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_KEYCLOAK_AUTH__INTERNAL__SERVER__URL": "http://external-keycloak/auth",
+			},
+		},
+		{
+			name: "Should use 'external' public identity provider url, when internal network is disabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: false,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth:           util.NewBoolPointer(false),
+						ExternalIdentityProvider: true,
+						IdentityProviderURL:      "http://external-keycloak",
+					},
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_KEYCLOAK_AUTH__INTERNAL__SERVER__URL": "http://external-keycloak/auth",
+			},
+		},
+		{
+			name: "Should use public identity provider url, when internal network is disabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: false,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth:           util.NewBoolPointer(false),
+						ExternalIdentityProvider: false,
+						IdentityProviderURL:      "http://keycloak",
+					},
+				},
+				Status: orgv1.CheClusterStatus{
+					KeycloakURL: "http://keycloak",
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_KEYCLOAK_AUTH__INTERNAL__SERVER__URL": "http://keycloak/auth",
+			},
+		},
+		{
+			name: "Should use internal identity provider url, when internal network is enabled",
+			cheCluster: &orgv1.CheCluster{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "CheCluster",
+					APIVersion: "org.eclipse.che/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: "eclipse-che",
+				},
+				Spec: orgv1.CheClusterSpec{
+					Server: orgv1.CheClusterSpecServer{
+						UseInternalClusterSVCNames: true,
+					},
+					Auth: orgv1.CheClusterSpecAuth{
+						OpenShiftoAuth:           util.NewBoolPointer(false),
+						ExternalIdentityProvider: false,
+						IdentityProviderURL:      "http://keycloak",
+					},
+				},
+			},
+			expectedData: map[string]string{
+				"CHE_KEYCLOAK_AUTH__INTERNAL__SERVER__URL": "http://keycloak.eclipse-che.svc:8080/auth",
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			logf.SetLogger(zap.LoggerTo(os.Stdout, true))
+			orgv1.SchemeBuilder.AddToScheme(scheme.Scheme)
+			testCase.initObjects = append(testCase.initObjects)
+			cli := fake.NewFakeClientWithScheme(scheme.Scheme, testCase.initObjects...)
+			nonCachedClient := fake.NewFakeClientWithScheme(scheme.Scheme, testCase.initObjects...)
+
+			deployContext := &deploy.DeployContext{
+				CheCluster: testCase.cheCluster,
+				ClusterAPI: deploy.ClusterAPI{
+					Client:          cli,
+					NonCachedClient: nonCachedClient,
+					Scheme:          scheme.Scheme,
+				},
+				Proxy: &deploy.Proxy{},
+				InternalService: deploy.InternalService{
+					KeycloakHost: "http://keycloak.eclipse-che.svc:8080",
+				},
+			}
+
+			util.IsOpenShift = testCase.isOpenShift
+			util.IsOpenShift4 = testCase.isOpenShift4
+
+			actualData, err := GetCheConfigMapData(deployContext)
+			if err != nil {
+				t.Fatalf("Error creating ConfigMap data: %v", err)
+			}
+
+			util.ValidateContainData(actualData, testCase.expectedData, t)
+		})
+	}
+}