diff --git a/controller/deployments.go b/controller/deployments.go index 28616cf5af..d6e41d0e47 100644 --- a/controller/deployments.go +++ b/controller/deployments.go @@ -157,8 +157,8 @@ func (g *defaultClientGetter) GetKubeClient(ctx context.Context) (kubernetes.Kub if err != nil { log.Error(ctx, map[string]interface{}{ "err": err, - }, "could not retrieve tenant data") - return nil, errs.Wrap(err, "could not retrieve tenant data") + }, "could not create urlProvider") + return nil, errs.Wrap(err, "could not create urlProvider") } /* Timeout used per HTTP request to Kubernetes/OpenShift API servers. diff --git a/controller/deployments_osioclient.go b/controller/deployments_osioclient.go index 52609789a1..42c2e40d8d 100644 --- a/controller/deployments_osioclient.go +++ b/controller/deployments_osioclient.go @@ -96,7 +96,6 @@ func (osioclient *OSIOClient) GetNamespaceByType(ctx context.Context, userServic } // GetUserServices - fetch array of user services -// In the future, consider calling the tenant service (as /api/user/services implementation does) func (osioclient *OSIOClient) GetUserServices(ctx context.Context) (*app.UserService, error) { if osioclient.userServices != nil { diff --git a/controller/deployments_urlprovider.go b/controller/deployments_urlprovider.go index cba02b6cf0..355b5721bf 100644 --- a/controller/deployments_urlprovider.go +++ b/controller/deployments_urlprovider.go @@ -2,18 +2,10 @@ package controller import ( "context" - "encoding/json" "fmt" - "io/ioutil" - "net/http" "net/url" - "strings" - "github.com/fabric8-services/fabric8-wit/app" - "github.com/fabric8-services/fabric8-wit/auth" - "github.com/fabric8-services/fabric8-wit/auth/authservice" "github.com/fabric8-services/fabric8-wit/configuration" - "github.com/fabric8-services/fabric8-wit/goasupport" "github.com/fabric8-services/fabric8-wit/kubernetes" "github.com/fabric8-services/fabric8-wit/log" @@ -21,316 +13,104 @@ import ( errs "github.com/pkg/errors" ) -// there are several concrete instantiations: -// -// - access /api/user/services instead of Auth -// - use proxy (if present) for normal OSO API calls -// - access OSO metrics directly (until proxy supports this) +// This incarnation uses the proxy for ALL OSO API calls and will not function without a proxy -type tenantURLProvider struct { - apiURL string - apiToken string - tenant *app.UserService - namespaces map[string]*app.NamespaceAttributes - tokens map[string]string - TokenRetriever +type deploymentsURLProvider struct { + apiURL string + apiToken string + kubernetes.BaseURLProvider } -// TokenRetriever is a service that will respond with an authorization token, given a service endpoint or name -type TokenRetriever interface { - TokenForService(serviceURL string) (*string, error) -} - -type tokenRetriever struct { - authClient *authservice.Client - context context.Context -} - -func (tr *tokenRetriever) TokenForService(forService string) (*string, error) { - - resp, err := tr.authClient.RetrieveToken(goasupport.ForwardContextRequestID(tr.context), authservice.RetrieveTokenPath(), forService, nil) - if err != nil { - return nil, errs.Wrapf(err, "unable to retrieve Auth token for '%s' service", forService) - } - - defer resp.Body.Close() - - respBody, err := ioutil.ReadAll(resp.Body) - - status := resp.StatusCode - if status != http.StatusOK { - log.Error(nil, map[string]interface{}{ - "err": err, - "request_path": authservice.ShowUserPath(), - "for_service": forService, - "http_status": status, - }, "failed to GET token from auth service due to HTTP error %s", status) - return nil, errs.Errorf("failed to GET Auth token for '%s' service due to status code %d", forService, status) - } - - var respType authservice.TokenData - err = json.Unmarshal(respBody, &respType) - if err != nil { - log.Error(nil, map[string]interface{}{ - "err": err, - "request_path": authservice.ShowUserPath(), - "for_service": forService, - "http_status": status, - "response_body": respBody, - }, "unable to unmarshal Auth token") - return nil, errs.Wrapf(err, "unable to unmarshal Auth token for '%s' service from Auth service", forService) - } - - return respType.AccessToken, nil -} - -// ensure tenantURLProvider implements BaseURLProvider -var _ kubernetes.BaseURLProvider = &tenantURLProvider{} -var _ kubernetes.BaseURLProvider = (*tenantURLProvider)(nil) +// ensure deploymentsURLProvider implements BaseURLProvider +var _ kubernetes.BaseURLProvider = &deploymentsURLProvider{} +var _ kubernetes.BaseURLProvider = (*deploymentsURLProvider)(nil) // NewURLProvider looks at what servers are available and create a BaseURLProvder that fits func NewURLProvider(ctx context.Context, config *configuration.Registry, osioclient OpenshiftIOClient) (kubernetes.BaseURLProvider, error) { - userServices, err := osioclient.GetUserServices(ctx) - if err != nil { - log.Error(ctx, map[string]interface{}{ - "err": err, - }, "error accessing Tenant API") - return nil, err - } - token := goajwt.ContextJWT(ctx).Raw proxyURL := config.GetOpenshiftProxyURL() - up, err := newTenantURLProviderFromTenant(userServices, token, proxyURL) - if err != nil { - return nil, err + if len(proxyURL) == 0 { + log.Error(ctx, map[string]interface{}{}, "No Proxy URL configured") + return nil, errs.Errorf("No Proxy URL configured") } - // create Auth API client - required to get OSO tokens - authClient, err := auth.CreateClient(ctx, config) + up, err := NewProxyURLProvider(token, proxyURL) if err != nil { - log.Error(ctx, map[string]interface{}{ - "err": err, - }, "error accessing Auth server") - return nil, errs.Wrap(err, "error creating Auth client") - } - up.TokenRetriever = &tokenRetriever{ - authClient: authClient, - context: ctx, + return nil, err } - // if we're not using a proxy then the API URL is actually the cluster of namespace 0, - // so the apiToken should be the token for that cluster. - // there should be no defaults, but that's deferred later - if len(proxyURL) == 0 { - tokenData, err := up.TokenForService(up.apiURL) - if err != nil { - return nil, err - } - up.apiToken = *tokenData - } return up, nil } -// newTenantURLProviderFromTenant create a provider from a UserService object -func newTenantURLProviderFromTenant(t *app.UserService, token string, proxyURL string) (*tenantURLProvider, error) { - - if t.ID == nil { - log.Error(nil, map[string]interface{}{}, "app.UserService is malformed: no ID field") - return nil, errs.New("app.UserService is malformed: no ID field") - } - - if t.Attributes == nil { - log.Error(nil, map[string]interface{}{ - "tenant": *t.ID, - }, "app.UserService is malformed: no Attribute field ID=%s", *t.ID) - return nil, errs.Errorf("app.UserService is malformed: no Attribute field (ID=%s)", *t.ID) - } - - if len(t.Attributes.Namespaces) == 0 { - log.Error(nil, map[string]interface{}{ - "tenant": *t.ID, - }, "this tenant has no namespaces: %s", *t.ID) - return nil, errs.Errorf("app.UserService is malformed: no Namespaces (ID=%s)", *t.ID) - } - - defaultNamespace := t.Attributes.Namespaces[0] - namespaceMap := make(map[string]*app.NamespaceAttributes) - for i, namespace := range t.Attributes.Namespaces { - namespaceMap[*namespace.Name] = t.Attributes.Namespaces[i] - if namespace.Type != nil && *namespace.Type == "user" { - defaultNamespace = namespace - } - } - - defaultClusterURL := *defaultNamespace.ClusterURL - - if len(proxyURL) != 0 { - // all non-metric API calls go via the proxy - defaultClusterURL = proxyURL - } - - provider := &tenantURLProvider{ - apiURL: defaultClusterURL, - apiToken: token, - tenant: t, - namespaces: namespaceMap, +// NewProxyURLProvider create a provider from a UserService object (exposed for testing) +func NewProxyURLProvider(token string, proxyURL string) (kubernetes.BaseURLProvider, error) { + provider := &deploymentsURLProvider{ + apiURL: proxyURL, + apiToken: token, } return provider, nil } -// NewTenantURLProviderFromTenant create a provider from a UserService object (exposed for testing) -func NewTenantURLProviderFromTenant(t *app.UserService, token string, proxyURL string) (kubernetes.BaseURLProvider, error) { - return newTenantURLProviderFromTenant(t, token, proxyURL) -} - -// GetEnvironmentMapping returns a map whose keys are environment names, and values are the Kubernetes namespaces -// that represent those environments -func (up *tenantURLProvider) GetEnvironmentMapping() map[string]string { - result := make(map[string]string) - // Exclude internal namespaces where the user cannot deploy applications - - // Deployments API will receive requests by environment name (e.g. "run", "stage"). - // These names correspond to the "type" attribute in Namespaces. - for envNS, attr := range up.namespaces { - envName := attr.Type - if envName == nil || len(*envName) == 0 { - log.Error(nil, map[string]interface{}{ - "namespace": envNS, - }, "namespace has no type") - } else { - result[*envName] = envNS - } - } - return result -} - -// Types of namespaces where the user does not deploy applications -var internalNamespaceTypes = map[string]struct{}{"user": {}, "che": {}, "jenkins": {}} - -// CanDeploy returns true if the environment type provided can be deployed to as part of a pipeline -func (up *tenantURLProvider) CanDeploy(envType string) bool { - _, pres := internalNamespaceTypes[envType] - return !pres -} - -func (up *tenantURLProvider) GetAPIToken() (*string, error) { +func (up *deploymentsURLProvider) GetAPIToken() (*string, error) { return &up.apiToken, nil } -func (up *tenantURLProvider) GetAPIURL() (*string, error) { +func (up *deploymentsURLProvider) GetAPIURL() (*string, error) { // TODO this may be different for every namespace if no proxy return &up.apiURL, nil } -func (up *tenantURLProvider) GetMetricsToken(envNS string) (*string, error) { - // since metrics bypasses the proxy, this is the OSO cluster token - token := up.tokens[envNS] - if len(token) == 0 { - ns := up.namespaces[envNS] - if ns == nil { - return nil, errs.Errorf("Namespace '%s' is not in tenant '%s'", envNS, *up.tenant.ID) - } - if up.TokenRetriever != nil { - tokenData, err := up.TokenForService(*ns.ClusterURL) - if err != nil { - return nil, err - } - token = *tokenData - } else { - tokenData, err := up.GetAPIToken() - if err != nil { - return nil, err - } - token = *tokenData - } - } - return &token, nil +func (up *deploymentsURLProvider) GetMetricsToken(envNS string) (*string, error) { + return &up.apiToken, nil } -func (up *tenantURLProvider) GetConsoleURL(envNS string) (*string, error) { - ns := up.namespaces[envNS] - if ns == nil { - return nil, errs.Errorf("Namespace '%s' is not in tenant '%s'", envNS, *up.tenant.ID) - } - // Note that the Auth/Tenant appends /console to the hostname for console/logging - baseURL := ns.ClusterConsoleURL - if baseURL == nil || len(*baseURL) == 0 { - // if it's missing, modify the cluster URL - bu, err := modifyURL(*ns.ClusterURL, "console", "/console") - if err != nil { - return nil, err - } - buStr := bu.String() - baseURL = &buStr +func (up *deploymentsURLProvider) GetConsoleURL(envNS string) (*string, error) { + mu, err := modifyPath(up.apiURL, "/console") + if err != nil { + return nil, err } - consoleURL := fmt.Sprintf("%s/project/%s", *baseURL, envNS) + urlStr := mu.String() + + consoleURL := fmt.Sprintf("%s/project/%s", urlStr, envNS) return &consoleURL, nil } -func (up *tenantURLProvider) GetLoggingURL(envNS string, deployName string) (*string, error) { - ns := up.namespaces[envNS] - if ns == nil { - return nil, errs.Errorf("Namespace '%s' is not in tenant '%s'", envNS, *up.tenant.ID) - } - // Note that the Auth/Tenant appends /console to the hostname for console/logging - baseURL := ns.ClusterLoggingURL - if baseURL == nil || len(*baseURL) == 0 { - // if it's missing, modify the cluster URL - bu, err := modifyURL(*ns.ClusterURL, "console", "/console") - if err != nil { - return nil, err - } - buStr := bu.String() - baseURL = &buStr +func (up *deploymentsURLProvider) GetLoggingURL(envNS string, deployName string) (*string, error) { + mu, err := modifyPath(up.apiURL, "/logs") + if err != nil { + return nil, err } - loggingURL := fmt.Sprintf("%s/project/%s/browse/rc/%s?tab=logs", *baseURL, envNS, deployName) + urlStr := mu.String() + + loggingURL := fmt.Sprintf("%s/project/%s/browse/rc/%s?tab=logs", urlStr, envNS, deployName) return &loggingURL, nil } -func (up *tenantURLProvider) GetMetricsURL(envNS string) (*string, error) { - ns := up.namespaces[envNS] - if ns == nil { - return nil, errs.Errorf("Namespace '%s' is not in tenant '%s'", envNS, *up.tenant.ID) - } +func (up *deploymentsURLProvider) GetMetricsURL(envNS string) (*string, error) { - baseURL := ns.ClusterMetricsURL - if baseURL == nil || len(*baseURL) == 0 { - // In the absence of a better way (i.e. tenant) to get the user's metrics URL, - // substitute "api" with "metrics" in user's cluster URL - mu, err := modifyURL(*ns.ClusterURL, "metrics", "") - if err != nil { - return nil, err - } - muStr := mu.String() - baseURL = &muStr - } - // Hawkular implementation is sensitive and requires no trailing '/' - if strings.HasSuffix(*baseURL, "/") { - nurl := (*baseURL)[:len(*baseURL)-1] - baseURL = &nurl + // substitute "api" with "metrics" in user's cluster URL + mu, err := modifyPath(up.apiURL, "/metrics") + if err != nil { + return nil, err } - return baseURL, nil + urlStr := mu.String() + + return &urlStr, nil } -func modifyURL(apiURLStr string, prefix string, path string) (*url.URL, error) { +func modifyPath(apiURLStr string, path string) (*url.URL, error) { // Parse as URL to give us easy access to the hostname apiURL, err := url.Parse(apiURLStr) if err != nil { return nil, errs.WithStack(err) } - // Get the hostname (without port) and replace api prefix with prefix arg - apiHostname := apiURL.Hostname() - if !strings.HasPrefix(apiHostname, "api") { - return nil, errs.Errorf("cluster URL does not begin with \"api\": %s", apiHostname) - } - newHostname := strings.Replace(apiHostname, "api", prefix, 1) // Construct URL using just scheme from API URL, modified hostname and supplied path newURL := &url.URL{ Scheme: apiURL.Scheme, - Host: newHostname, + Host: apiURL.Hostname(), Path: path, } return newURL, nil diff --git a/controller/deployments_urlprovider_test.go b/controller/deployments_urlprovider_test.go index 99cd0c11c2..d818a853e1 100644 --- a/controller/deployments_urlprovider_test.go +++ b/controller/deployments_urlprovider_test.go @@ -1,196 +1,88 @@ package controller_test import ( - "encoding/json" - "fmt" - "io/ioutil" "strings" "testing" - "github.com/fabric8-services/fabric8-wit/app" "github.com/fabric8-services/fabric8-wit/controller" "github.com/fabric8-services/fabric8-wit/kubernetes" - errs "github.com/pkg/errors" "github.com/stretchr/testify/require" ) -const defaultAPIURL = "https://api.hostname/api" +const defaultAPIURL = "https://proxy.hostname/api" const defaultAPIToken = "token1" const defaultNS = "myDefaultNS" -// testing Tenant-based URL provider -var defaultTenant *app.UserService - -// Path to JSON resources -const pathToURLProviderJSON = "../test/kubernetes/urlprovider-" - -func getTenantFromFile(filename string) (*app.UserService, error) { - path := pathToURLProviderJSON + filename - jsonBytes, err := ioutil.ReadFile(path) - if err != nil { - return nil, errs.WithStack(err) - } - t := &app.UserService{} - err = json.Unmarshal(jsonBytes, t) - if err != nil { - return nil, errs.WithStack(err) - } - return t, nil -} - -func getDefaultTenant() (*app.UserService, error) { - if defaultTenant == nil { - t, err := getTenantFromFile("tenant-default.json") - if err != nil { - fmt.Printf("error reading tenant: %s", err.Error()) - return nil, err - } - //fmt.Printf("default tenant = \n%s\n", tostring(*t)) - defaultTenant = t - } - return defaultTenant, nil -} - -func getBadTenantProvider() (kubernetes.BaseURLProvider, error) { - t, err := getTenantFromFile("tenant-missingurls.json") - if err != nil { - fmt.Printf("error reading bad tenant: %s", err.Error()) - return nil, err - } - return controller.NewTenantURLProviderFromTenant(t, defaultAPIToken, "") -} - -func getDefaultTenantProvider() (kubernetes.BaseURLProvider, error) { - t, err := getDefaultTenant() - if err != nil { - return nil, err - } - if t == nil { - fmt.Printf("error reading default tenant: %s", err.Error()) - } - return controller.NewTenantURLProviderFromTenant(t, defaultAPIToken, "") +func getDefaultURLProvider() (kubernetes.BaseURLProvider, error) { + return controller.NewProxyURLProvider(defaultAPIToken, defaultAPIURL) } -func TestTenantAPIURL(t *testing.T) { - p, err := getDefaultTenantProvider() +func TestGetAPIURL(t *testing.T) { + p, err := getDefaultURLProvider() require.NoError(t, err) require.NotNil(t, p) + apiurl, err := p.GetAPIURL() require.NoError(t, err) require.NotNil(t, apiurl) require.Equal(t, defaultAPIURL, *apiurl, "GetAPIURL() returned wrong value") } -func TestTenantGetMalformedData(t *testing.T) { - us, err := getTenantFromFile("tenant-malformed.json") +func TestGetDefaultMetricsURL(t *testing.T) { + p, err := getDefaultURLProvider() require.NoError(t, err) - require.NotNilf(t, us, "error reading test file %s", "tenant-malformed.json") - - up, err := controller.NewTenantURLProviderFromTenant(us, defaultAPIToken, "") - require.Nil(t, up) - require.Error(t, err) -} -func TestTenantGetDefaultMetricsURL(t *testing.T) { - p, err := getDefaultTenantProvider() - require.NoError(t, err) murl, err := p.GetMetricsURL(defaultNS) require.NoError(t, err, "GetMetricsURL() returned an error") require.NotNil(t, murl) - apiurl, err := p.GetAPIURL() - require.NoError(t, err) - require.NotNil(t, apiurl) - // converts leading "api" to leading "metrics" - apiMetricsURL := strings.Replace(strings.Replace(*apiurl, "//api.", "//metrics.", 1), "/api", "", 1) - require.NotEqual(t, apiMetricsURL, *murl, "GetMetricsURL() defaulted to API URL") - expected := *defaultTenant.Attributes.Namespaces[0].ClusterMetricsURL - require.Equal(t, expected, *murl, "GetMetricsURL() did not return the correct value from JSON") -} -func TestTenantGetMissingMetricsURL(t *testing.T) { - p, err := getBadTenantProvider() - require.NoError(t, err) - murl, err := p.GetMetricsURL(defaultNS) - require.NoError(t, err, "GetMetricsURL() returned an error") - require.NotNil(t, murl) apiurl, err := p.GetAPIURL() require.NoError(t, err) require.NotNil(t, apiurl) - // converts leading "api" to leading "metrics" - apiMetricsURL := strings.Replace(strings.Replace(*apiurl, "//api.", "//metrics.", 1), "/api", "", 1) - require.Equal(t, apiMetricsURL, *murl, "empty or missing GetMetricsURL() must default to API URL") + require.NotEqual(t, apiurl, *murl, "GetMetricsURL() defaulted to API URL") + + expected := strings.Replace(*apiurl, "/api", "/metrics", 1) + require.Equal(t, expected, *murl, "GetMetricsURL() has wrong value") } -func TestTenantGetConsoleURL(t *testing.T) { - p, err := getDefaultTenantProvider() +func TestGetConsoleURL(t *testing.T) { + p, err := getDefaultURLProvider() require.NoError(t, err) + url, err := p.GetConsoleURL(defaultNS) require.NoError(t, err, "GetConsoleURL() returned an error") require.NotNil(t, url) + apiurl, err := p.GetAPIURL() require.NoError(t, err) require.NotNil(t, apiurl) - // Note that the Auth/Tenant appends /console to the hostname for console/logging - apiConsoleURL := strings.Replace(strings.Replace(*apiurl, "//api.", "//console.", 1), "/api", "", 1) + "/project/" + defaultNS - require.NotEqual(t, apiConsoleURL, *url, "GetConsoleURL() defaulted to API URL") - expected := *defaultTenant.Attributes.Namespaces[0].ClusterConsoleURL - expected = expected + "/project/" + defaultNS + require.NotEqual(t, *apiurl, *url, "GetConsoleURL() defaulted to API URL") + + expected := strings.Replace(*apiurl, "/api", "/console", 1) + "/project/" + defaultNS require.Equal(t, expected, *url, "GetConsoleURL() did not return the correct value from JSON") } -func TestTenantGetMissingConsoleURL(t *testing.T) { - p, err := getBadTenantProvider() - require.NoError(t, err) - url, err := p.GetConsoleURL(defaultNS) - require.NoError(t, err, "GetConsoleURL() returned an error") - require.NotNil(t, url) - apiurl, err := p.GetAPIURL() - require.NoError(t, err) - require.NotNil(t, apiurl) - // Note that the Auth/Tenant appends /console to the hostname for console/logging - we have to to this here - apiConsoleURL := strings.Replace(strings.Replace(*apiurl, "//api.", "//console.", 1), "/api", "", 1) + "/console/project/" + defaultNS - require.Equal(t, apiConsoleURL, *url, "GetConsoleURL()must default to API URL") -} -func TestTenantGetLoggingURL(t *testing.T) { +func TestGetLoggingURL(t *testing.T) { const deployName = "aDeployName" - p, err := getDefaultTenantProvider() - require.NoError(t, err) - url, err := p.GetLoggingURL(defaultNS, deployName) - require.NoError(t, err, "GetLoggingURL() returned an error") - require.NotNil(t, url) - apiurl, err := p.GetAPIURL() + p, err := getDefaultURLProvider() require.NoError(t, err) - require.NotNil(t, apiurl) - // converts leading "api" to leading "metrics" - // Note that the Auth/Tenant appends /console to the hostname for console/logging - apiConsoleURL := strings.Replace(strings.Replace(*apiurl, "//api.", "//console.", 1), "/api", "", 1) + "/project/" + defaultNS - apiLoggingURL := fmt.Sprintf("%s/browse/rc/%s?tab=logs", apiConsoleURL, deployName) - require.NotEqual(t, apiLoggingURL, *url, "GetLoggingURL() defaulted to API URL") - expected := *defaultTenant.Attributes.Namespaces[0].ClusterLoggingURL - expected = expected + "/project/" + defaultNS + "/browse/rc/" + deployName + "?tab=logs" - require.Equal(t, expected, *url, "GetLoggingURL() did not return correct value") -} -func TestTenantGetMissingLoggingURL(t *testing.T) { - const deployName = "aDeployName" - p, err := getBadTenantProvider() - require.NoError(t, err) url, err := p.GetLoggingURL(defaultNS, deployName) require.NoError(t, err, "GetLoggingURL() returned an error") require.NotNil(t, url) + apiurl, err := p.GetAPIURL() require.NoError(t, err) require.NotNil(t, apiurl) - // converts leading "api" to leading "metrics" - // Note that the Auth/Tenant appends /console to the hostname for console/logging - we have to to this here - apiConsoleURL := strings.Replace(strings.Replace(*apiurl, "//api.", "//console.", 1), "/api", "", 1) + "/console/project/" + defaultNS - apiLoggingURL := fmt.Sprintf("%s/browse/rc/%s?tab=logs", apiConsoleURL, deployName) - require.Equal(t, apiLoggingURL, *url, "GetLoggingURL() must default to API URL") + require.NotEqual(t, *apiurl, *url, "GetLoggingURL() defaulted to API URL") + + expected := strings.Replace(*apiurl, "/api", "/logs", 1) + "/project/" + defaultNS + "/browse/rc/" + deployName + "?tab=logs" + require.Equal(t, expected, *url, "GetLoggingURL() did not return correct value") } -func TestTenantGetAPIToken(t *testing.T) { - p, err := getDefaultTenantProvider() +func TestGetAPIToken(t *testing.T) { + p, err := getDefaultURLProvider() require.NoError(t, err) token, err := p.GetAPIToken() require.NoError(t, err) @@ -198,105 +90,11 @@ func TestTenantGetAPIToken(t *testing.T) { require.Equal(t, defaultAPIToken, *token, "GetAPIToken() did not return API token") } -func TestTenantGetDefaultMetricsToken(t *testing.T) { - p, err := getDefaultTenantProvider() +func TestGetDefaultMetricsToken(t *testing.T) { + p, err := getDefaultURLProvider() require.NoError(t, err) mtoken, err := p.GetMetricsToken(defaultNS) require.NoError(t, err) require.NotNil(t, mtoken) - require.Equal(t, defaultAPIToken, *mtoken, "GetMetricsToken() did not default to API token") -} - -func TestTenantGetUnknownMetricsToken(t *testing.T) { - p, err := getDefaultTenantProvider() - require.NoError(t, err) - mtoken, err := p.GetMetricsToken("unknown NS") - require.Error(t, err) - require.Nil(t, mtoken) -} - -func TestTenantGetEnvironmentMapping(t *testing.T) { - testCases := []struct { - testName string - inputFile string - expectedMap map[string]string - }{ - { - testName: "Basic", - inputFile: "user-services.json", - expectedMap: map[string]string{ - "user": "theuser", - "run": "theuser-run", - "stage": "theuser-stage", - "che": "theuser-che", - "jenkins": "theuser-jenkins", - }, - }, - { - testName: "No Type", - inputFile: "user-services-no-type.json", - expectedMap: map[string]string{ - "user": "theuser", - "run": "theuser-run", - "che": "theuser-che", - "jenkins": "theuser-jenkins", - }, - }, - { - testName: "Empty Type", - inputFile: "user-services-empty-type.json", - expectedMap: map[string]string{ - "user": "theuser", - "run": "theuser-run", - "che": "theuser-che", - "jenkins": "theuser-jenkins", - }, - }, - } - - for _, testCase := range testCases { - t.Run(testCase.testName, func(t *testing.T) { - userSvc, err := getTenantFromFile(testCase.inputFile) - require.NoError(t, err, "error reading tenant") - provider, err := controller.NewTenantURLProviderFromTenant(userSvc, defaultAPIToken, "") - require.NoError(t, err, "error creating URL provider") - - envMap := provider.GetEnvironmentMapping() - require.NotNil(t, envMap) - require.Equal(t, testCase.expectedMap, envMap, "GetEnvironmentMapping() did not return the expected environments") - }) - } -} - -func TestTenantCanDeploy(t *testing.T) { - testCases := []struct { - envType string - expected bool - }{ - {"user", false}, - {"test", true}, - {"stage", true}, - {"run", true}, - {"che", false}, - {"jenkins", false}, - } - - for _, testCase := range testCases { - t.Run(testCase.envType, func(t *testing.T) { - provider, err := getDefaultTenantProvider() - require.NoError(t, err) - result := provider.CanDeploy(testCase.envType) - require.Equal(t, testCase.expected, result, "Incorrect result from CanDeploy") - }) - } -} - -////////////////////////////////////////////////////////////////////////////////////////////////// - -func tostring(item interface{}) string { - bytes, err := json.MarshalIndent(item, "", " ") - if err != nil { - return err.Error() - } - return string(bytes) + require.Equal(t, defaultAPIToken, *mtoken, "GetMetricsToken() did not return API token") } diff --git a/test/kubernetes/urlprovider-tenant-default.json b/test/kubernetes/urlprovider-tenant-default.json deleted file mode 100644 index 87eba6910b..0000000000 --- a/test/kubernetes/urlprovider-tenant-default.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "id": "240dd5ce-23b8-11e8-95d6-507b9dac9ad3", - "type": "tenant", - "attributes": { - "email": "user@domain.tld", - "profile": "", - "namespaces": [ - { - "name": "myDefaultNS", - "type": "", - "_valid_type_values": "user|che|jenkins|stage|test|run", - "state": "Running", - "cluster-app-domain" : "", - "cluster-console-url" : "https://cnsl.host1.com/ccc", - "cluster-logging-url" : "https://lgging.host2.com/lll", - "cluster-metrics-url" : "https://mtrcs.host3.com/mmm", - "cluster-url" : "https://api.hostname/api" - }, - { - "name": "someEnvNS2", - "type": "", - "_valid_type_values": "user|che|jenkins|stage|test|run", - "state": "Running", - "cluster-app-domain" : "", - "cluster-console-url" : "https://cnsl.junk1.com/ccc", - "cluster-logging-url" : "https://lgging.junk2.com/lll", - "cluster-metrics-url" : "https://mtrcs.junk3.com/mmm", - "cluster-url" : "https://api.hostname2/api" - } - ] - } -} \ No newline at end of file diff --git a/test/kubernetes/urlprovider-tenant-malformed.json b/test/kubernetes/urlprovider-tenant-malformed.json deleted file mode 100644 index 3db0b95d7c..0000000000 --- a/test/kubernetes/urlprovider-tenant-malformed.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "notanid": "240dd5ce-23b8-11e8-95d6-507b9dac9ad3", - "type": "tenant", - "attributes": { - "email": "user@domain.tld", - "profile": "", - "namespaces": [ - { - "name": "someEnvNS", - "type": "", - "_valid_type_values": "user|che|jenkins|stage|test|run", - "state": "Running", - "cluster-app-domain" : "", - "cluster-url" : "https://api.somehost/api" - } - ] - } -} \ No newline at end of file diff --git a/test/kubernetes/urlprovider-tenant-missingurls.json b/test/kubernetes/urlprovider-tenant-missingurls.json deleted file mode 100644 index 654b3b66ae..0000000000 --- a/test/kubernetes/urlprovider-tenant-missingurls.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "id": "240dd5ce-23b8-11e8-95d6-507b9dac9ad3", - "type": "tenant", - "attributes": { - "email": "user@domain.tld", - "profile": "", - "namespaces": [ - { - "name": "myDefaultNS", - "type": "", - "_valid_type_values": "user|che|jenkins|stage|test|run", - "state": "Running", - "cluster-app-domain" : "", - "cluster-url" : "https://api.somehost/api" - } - ] - } -} \ No newline at end of file