servicemappingloader_test.go

Documentation: github.com/GoogleCloudPlatform/k8s-config-connector/pkg/servicemapping/servicemappingloader

     1  // Copyright 2022 Google LLC
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package servicemappingloader_test
    16  
    17  import (
    18  	"fmt"
    19  	"testing"
    20  
    21  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/servicemapping/servicemappingloader"
    22  	testservicemappingloader "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/test/servicemappingloader"
    23  
    24  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    25  )
    26  
    27  const (
    28  	PubSubGroup                                   = "pubsub.cnrm.cloud.google.com"
    29  	PubSubTopicKind                               = "PubSubTopic"
    30  	PubSubTopicResourceConfigName                 = "google_pubsub_topic"
    31  	ComputeGroup                                  = "compute.cnrm.cloud.google.com"
    32  	ComputeAddressKind                            = "ComputeAddress"
    33  	ComputeAddressResourceConfigName              = "google_compute_address"
    34  	ComputeGlobalAddressResourceConfigName        = "google_compute_global_address"
    35  	ComputeInstanceKind                           = "ComputeInstance"
    36  	ComputeInstanceResourceConfigName             = "google_compute_instance"
    37  	ComputeInstanceFromTemplateResourceConfigName = "google_compute_instance_from_template"
    38  )
    39  
    40  type ServiceMappingTestCase struct {
    41  	Name          string
    42  	ShouldSucceed bool
    43  	Group         string
    44  }
    45  
    46  var serviceMappingTestCases = []ServiceMappingTestCase{
    47  	{"NilGroup", false, ""},
    48  	{"InvalidGroup", false, "invalidgroup.google.com"},
    49  	{"Group", true, PubSubGroup},
    50  }
    51  
    52  func TestGetServiceMapping(t *testing.T) {
    53  	t.Parallel()
    54  	smLoader := testservicemappingloader.New(t)
    55  	for _, tc := range serviceMappingTestCases {
    56  		t.Run(tc.Name, func(t *testing.T) {
    57  			getServiceMappingAssertResult(t, tc, smLoader)
    58  		})
    59  	}
    60  }
    61  
    62  func getServiceMappingAssertResult(t *testing.T, tc ServiceMappingTestCase, smLoader *servicemappingloader.ServiceMappingLoader) {
    63  	sm, err := smLoader.GetServiceMapping(tc.Group)
    64  	if tc.ShouldSucceed {
    65  		if err != nil {
    66  			t.Fatalf("unexpected error: %v", err)
    67  		}
    68  	} else {
    69  		if err == nil {
    70  			t.Fatalf("expected error, instead got nil")
    71  		}
    72  		return
    73  	}
    74  	if sm == nil {
    75  		t.Fatalf("unexpected nil service mapping value for group '%v'", tc.Group)
    76  	}
    77  	if sm.Name != tc.Group {
    78  		t.Errorf("mismatched value for 'name': got '%v', want '%v'", sm.Name, tc.Group)
    79  	}
    80  }
    81  
    82  type ResourceConfigTestCase struct {
    83  	Name               string
    84  	ShouldSucceed      bool
    85  	ResourceConfigName string
    86  	Obj                *unstructured.Unstructured
    87  }
    88  
    89  var resourceConfigTestCases = []ResourceConfigTestCase{
    90  	{"valid kind", true, PubSubTopicResourceConfigName, &unstructured.Unstructured{
    91  		Object: map[string]interface{}{
    92  			"kind":       PubSubTopicKind,
    93  			"apiVersion": groupToApiVersion(PubSubGroup),
    94  		},
    95  	}},
    96  	{"invalid kind", false, "", &unstructured.Unstructured{
    97  		Object: map[string]interface{}{
    98  			"kind":       "InvalidKind",
    99  			"apiVersion": groupToApiVersion(PubSubGroup),
   100  		},
   101  	}},
   102  	{"regional resource", true, ComputeAddressResourceConfigName, &unstructured.Unstructured{
   103  		Object: map[string]interface{}{
   104  			"spec": map[string]interface{}{
   105  				"location": "us-central1",
   106  			},
   107  			"kind":       ComputeAddressKind,
   108  			"apiVersion": groupToApiVersion(ComputeGroup),
   109  		},
   110  	}},
   111  	{"global resource", true, ComputeGlobalAddressResourceConfigName, &unstructured.Unstructured{
   112  		Object: map[string]interface{}{
   113  			"spec": map[string]interface{}{
   114  				"location": "global",
   115  			},
   116  			"kind":       ComputeAddressKind,
   117  			"apiVersion": groupToApiVersion(ComputeGroup),
   118  		},
   119  	}},
   120  	{"global address resource without location", false, ComputeAddressResourceConfigName, &unstructured.Unstructured{
   121  		Object: map[string]interface{}{
   122  			"kind":       ComputeAddressKind,
   123  			"apiVersion": groupToApiVersion(ComputeGroup),
   124  		},
   125  	}},
   126  	{"compute address resource with invalid location", false, ComputeAddressResourceConfigName, &unstructured.Unstructured{
   127  		Object: map[string]interface{}{
   128  			"kind":       ComputeAddressKind,
   129  			"apiVersion": groupToApiVersion(ComputeGroup),
   130  			"spec": map[string]interface{}{
   131  				"location": "asia-east1-a",
   132  			},
   133  		},
   134  	}},
   135  	{"KCC compute instance using compute_instance TF resource", true, ComputeInstanceResourceConfigName, &unstructured.Unstructured{
   136  		Object: map[string]interface{}{
   137  			"kind":       ComputeInstanceKind,
   138  			"apiVersion": groupToApiVersion(ComputeGroup),
   139  		},
   140  	}},
   141  	{"KCC compute instance using compute_instance_from_template TF resource", true, ComputeInstanceFromTemplateResourceConfigName, &unstructured.Unstructured{
   142  		Object: map[string]interface{}{
   143  			"kind":       ComputeInstanceKind,
   144  			"apiVersion": groupToApiVersion(ComputeGroup),
   145  			"spec": map[string]interface{}{
   146  				"instanceTemplateRef": map[string]interface{}{
   147  					"name": "test-ref",
   148  				},
   149  			},
   150  		},
   151  	}},
   152  }
   153  
   154  func TestGetResourceConfig(t *testing.T) {
   155  	t.Parallel()
   156  	smLoader := testservicemappingloader.New(t)
   157  	for _, tc := range resourceConfigTestCases {
   158  		t.Run(tc.Name, func(t *testing.T) {
   159  			getResourceConfigAssertResult(t, tc, smLoader)
   160  		})
   161  	}
   162  }
   163  
   164  func getResourceConfigAssertResult(t *testing.T, tc ResourceConfigTestCase, smLoader *servicemappingloader.ServiceMappingLoader) {
   165  	rc, err := smLoader.GetResourceConfig(tc.Obj)
   166  	if tc.ShouldSucceed {
   167  		if err != nil {
   168  			t.Fatalf("unexpected error: %v", err)
   169  		}
   170  	} else {
   171  		if err == nil {
   172  			t.Fatalf("expected error, instead got nil")
   173  		}
   174  		return
   175  	}
   176  	if rc == nil {
   177  		t.Fatalf("unexpected nil resource config value with gvk '%v'", tc.Obj.GroupVersionKind())
   178  	}
   179  	if rc.Name != tc.ResourceConfigName {
   180  		t.Errorf("mismatched value for resource config name: got '%v', want '%v'", rc.Name, tc.ResourceConfigName)
   181  	}
   182  }
   183  
   184  func groupToApiVersion(groupName string) string {
   185  	return fmt.Sprintf("%v/v1beta1", groupName)
   186  }
   187
View as plain text