client_test.go

Documentation: github.com/GoogleCloudPlatform/k8s-config-connector/scripts/generate-go-crd-clients

     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 main
    16  
    17  import (
    18  	"context"
    19  	"testing"
    20  
    21  	computev1beta1 "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/apis/compute/v1beta1"
    22  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/apis/k8s/v1alpha1"
    23  	spannerv1beta1 "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/apis/spanner/v1beta1"
    24  	computeclient "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/client/clientset/versioned/typed/compute/v1beta1"
    25  	spannerclient "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/client/clientset/versioned/typed/spanner/v1beta1"
    26  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/k8s"
    27  	testcontroller "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/test/controller"
    28  	testmain "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/test/main"
    29  	testvariable "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/test/resourcefixture/variable"
    30  
    31  	"k8s.io/apimachinery/pkg/api/errors"
    32  	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    33  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    34  	"sigs.k8s.io/controller-runtime/pkg/manager"
    35  )
    36  
    37  var mgr manager.Manager
    38  
    39  func TestSpannerInstanceGoClient(t *testing.T) {
    40  	t.Parallel()
    41  	client := spannerclient.NewForConfigOrDie(mgr.GetConfig())
    42  	testId := testvariable.NewUniqueId()
    43  	spannerInstance := spannerv1beta1.SpannerInstance{
    44  		// TypeMeta (Kind/APIVersion) is automatically filled out
    45  		ObjectMeta: v1.ObjectMeta{
    46  			Name:      "spannerinstance",
    47  			Namespace: testId,
    48  			Labels:    map[string]string{"Key": "value"},
    49  		},
    50  		Spec: spannerv1beta1.SpannerInstanceSpec{
    51  			Config:      "regional-us-west1",
    52  			DisplayName: "Unique Display Name",
    53  		},
    54  		Status: spannerv1beta1.SpannerInstanceStatus{},
    55  	}
    56  	testcontroller.SetupNamespaceForDefaultProject(t, mgr.GetClient(), testId)
    57  	if _, err := client.SpannerInstances(testId).Create(context.TODO(), &spannerInstance, v1.CreateOptions{}); err != nil {
    58  		t.Fatalf("Error creating SpannerInstance: %v", err)
    59  	}
    60  
    61  	name := k8s.GetNamespacedName(&spannerInstance)
    62  	u := unstructured.Unstructured{
    63  		Object: map[string]interface{}{
    64  			"kind":       "SpannerInstance",
    65  			"apiVersion": "spanner.cnrm.cloud.google.com/v1beta1",
    66  		},
    67  	}
    68  	if err := mgr.GetClient().Get(context.TODO(), name, &u); err != nil {
    69  		t.Fatalf("Error getting spanner instance: %v", err)
    70  	}
    71  	s, found, err := unstructured.NestedString(u.Object, "spec", "displayName")
    72  	if err != nil {
    73  		t.Errorf("Error getting nested field: %v ", err)
    74  	}
    75  	if !found {
    76  		t.Errorf("Nested field not found")
    77  	}
    78  
    79  	// Validate displayName fields match
    80  	if s != spannerInstance.Spec.DisplayName {
    81  		t.Errorf("Results mismatch: got %v, expected %v", s, spannerInstance.Spec.DisplayName)
    82  	}
    83  
    84  	// Cleanup
    85  	if err = client.SpannerInstances(testId).Delete(context.TODO(), "spannerinstance", v1.DeleteOptions{}); err != nil {
    86  		t.Errorf("Error deleting Spanner Instance: %v", err)
    87  	}
    88  	err = mgr.GetClient().Get(context.TODO(), name, &u)
    89  	if err == nil || !errors.IsNotFound(err) {
    90  		t.Errorf("Unexpected error value: '%v'", err)
    91  	}
    92  }
    93  
    94  func TestComputeInstanceGoClient(t *testing.T) {
    95  	client := computeclient.NewForConfigOrDie(mgr.GetConfig())
    96  	testId := testvariable.NewUniqueId()
    97  
    98  	// The ComputeAddress is referenced by the ComputeInstance via the
    99  	// `networkIpRef` field.
   100  	computeAddressName := "computeaddress"
   101  	location := "europe-west1"
   102  	addressType := "INTERNAL"
   103  	address := "10.0.42.42"
   104  	purpose := "GCE_ENDPOINT"
   105  
   106  	computeAddress := computev1beta1.ComputeAddress{
   107  		// TypeMeta (Kind/APIVersion) is automatically filled out
   108  		ObjectMeta: v1.ObjectMeta{
   109  			Name:      computeAddressName,
   110  			Namespace: testId,
   111  		},
   112  		Spec: computev1beta1.ComputeAddressSpec{
   113  			Location:    location,
   114  			Address:     &address,
   115  			AddressType: &addressType,
   116  			Purpose:     &purpose,
   117  		},
   118  	}
   119  
   120  	computeInstanceName := "computeinstance"
   121  	autoDelete := true
   122  	bootDiskSize := 20
   123  	bootDiskType := "pd-ssd"
   124  	machineType := "n1-standard-1"
   125  	zone := "europe-west1-b"
   126  	computeInstance := computev1beta1.ComputeInstance{
   127  		// TypeMeta (Kind/APIVersion) is automatically filled out
   128  		ObjectMeta: v1.ObjectMeta{
   129  			Name:      computeInstanceName,
   130  			Namespace: testId,
   131  			Labels:    map[string]string{"key": "value"},
   132  		},
   133  		Spec: computev1beta1.ComputeInstanceSpec{
   134  			BootDisk: &computev1beta1.InstanceBootDisk{
   135  				AutoDelete: &autoDelete,
   136  				InitializeParams: &computev1beta1.InstanceInitializeParams{
   137  					Size: &bootDiskSize,
   138  					SourceImageRef: &v1alpha1.ResourceRef{
   139  						External: "debian-cloud/debian-9",
   140  					},
   141  					Type: &bootDiskType,
   142  				},
   143  			},
   144  			MachineType: &machineType,
   145  			Zone:        &zone,
   146  			NetworkInterface: []computev1beta1.InstanceNetworkInterface{
   147  				{
   148  					NetworkRef: &v1alpha1.ResourceRef{
   149  						External: "default",
   150  					},
   151  					SubnetworkRef: &v1alpha1.ResourceRef{
   152  						External: "default",
   153  					},
   154  					NetworkIpRef: &v1alpha1.ResourceRef{
   155  						Kind: "ComputeAddress",
   156  						Name: computeAddressName,
   157  					},
   158  				},
   159  			},
   160  		},
   161  	}
   162  	testcontroller.SetupNamespaceForDefaultProject(t, mgr.GetClient(), testId)
   163  
   164  	// Create the dependent ComputeAddress first.
   165  	if _, err := client.ComputeAddresses(testId).Create(context.TODO(), &computeAddress, v1.CreateOptions{}); err != nil {
   166  		t.Fatalf("Error creating ComputeAddress: %v", err)
   167  	}
   168  
   169  	// Verify that the referenced field, `spec.address` field, has been
   170  	// properly populated in the ComputeAddress before referencing it in
   171  	// ComputeInstance
   172  	computeAddressNamespacedName := k8s.GetNamespacedName(&computeAddress)
   173  	computeAddressUnstructured := unstructured.Unstructured{
   174  		Object: map[string]interface{}{
   175  			"kind":       "ComputeAddress",
   176  			"apiVersion": "compute.cnrm.cloud.google.com/v1beta1",
   177  		},
   178  	}
   179  
   180  	if err := mgr.GetClient().Get(context.TODO(), computeAddressNamespacedName, &computeAddressUnstructured); err != nil {
   181  		t.Fatalf("Error getting ComputeAddress: %v", err)
   182  	}
   183  	ip, found, err := unstructured.NestedString(computeAddressUnstructured.Object, "spec", "address")
   184  	if err != nil {
   185  		t.Errorf("Error getting `spec.address` field: %v", err)
   186  	}
   187  
   188  	if !found || ip == "" {
   189  		t.Errorf("`spec.address` field does not have any value")
   190  	}
   191  
   192  	// Then create the ComputeInstance.
   193  	if _, err := client.ComputeInstances(testId).Create(context.TODO(), &computeInstance, v1.CreateOptions{}); err != nil {
   194  		t.Fatalf("Error creating ComputeInstance: %v", err)
   195  	}
   196  
   197  	computeInstanceNamespacedName := k8s.GetNamespacedName(&computeInstance)
   198  	computeInstanceUnstructured := unstructured.Unstructured{
   199  		Object: map[string]interface{}{
   200  			"kind":       "ComputeInstance",
   201  			"apiVersion": "compute.cnrm.cloud.google.com/v1beta1",
   202  		},
   203  	}
   204  	if err := mgr.GetClient().Get(context.TODO(), computeInstanceNamespacedName, &computeInstanceUnstructured); err != nil {
   205  		t.Fatalf("Error getting ComputeInstance: %v", err)
   206  	}
   207  
   208  	s, found, err := unstructured.NestedString(computeInstanceUnstructured.Object, "spec", "bootDisk", "initializeParams", "type")
   209  	if err != nil {
   210  		t.Errorf("Error getting nested field: %v ", err)
   211  	}
   212  	if !found {
   213  		t.Errorf("Nested field not found")
   214  	}
   215  
   216  	// Validate fields match
   217  	if s != bootDiskType {
   218  		t.Errorf("Results mismatch: got %v, expected %v", s, bootDiskType)
   219  	}
   220  
   221  	// Cleanup
   222  	if err := client.ComputeInstances(testId).Delete(context.TODO(), computeInstanceName, v1.DeleteOptions{}); err != nil {
   223  		t.Errorf("Error deleting ComputeInstance: %v", err)
   224  	}
   225  	err = mgr.GetClient().Get(context.TODO(), computeInstanceNamespacedName, &computeInstanceUnstructured)
   226  	if err == nil || !errors.IsNotFound(err) {
   227  		t.Errorf("Expect a NotFound error after deleting ComputeInstance, but got: '%v'", err)
   228  	}
   229  	if err := client.ComputeAddresses(testId).Delete(context.TODO(), computeAddressName, v1.DeleteOptions{}); err != nil {
   230  		t.Errorf("Error deleting ComputeAddress: %v", err)
   231  	}
   232  	err = mgr.GetClient().Get(context.TODO(), computeAddressNamespacedName, &computeAddressUnstructured)
   233  	if err == nil || !errors.IsNotFound(err) {
   234  		t.Errorf("Expect a NotFound error after deleting ComputeAddress, but got: '%v'", err)
   235  	}
   236  }
   237  
   238  func TestMain(m *testing.M) {
   239  	testmain.TestMainForIntegrationTests(m, &mgr)
   240  }
   241
View as plain text