sigs.k8s.io/cluster-api-provider-azure@v1.14.3/api/v1beta1/azuremanagedcontrolplanetemplate_default_test.go (about)

     1  /*
     2  Copyright 2023 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package v1beta1
    18  
    19  import (
    20  	"encoding/json"
    21  	"reflect"
    22  	"testing"
    23  
    24  	. "github.com/onsi/gomega"
    25  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    26  )
    27  
    28  func TestDefaultVirtualNetworkTemplate(t *testing.T) {
    29  	cases := []struct {
    30  		name                 string
    31  		controlPlaneTemplate *AzureManagedControlPlaneTemplate
    32  		outputTemplate       *AzureManagedControlPlaneTemplate
    33  	}{
    34  		{
    35  			name: "virtual network not specified",
    36  			controlPlaneTemplate: &AzureManagedControlPlaneTemplate{
    37  				ObjectMeta: metav1.ObjectMeta{
    38  					Name: "test-cluster-template",
    39  				},
    40  				Spec: AzureManagedControlPlaneTemplateSpec{
    41  					Template: AzureManagedControlPlaneTemplateResource{},
    42  				},
    43  			},
    44  			outputTemplate: &AzureManagedControlPlaneTemplate{
    45  				ObjectMeta: metav1.ObjectMeta{
    46  					Name: "test-cluster-template",
    47  				},
    48  				Spec: AzureManagedControlPlaneTemplateSpec{
    49  					Template: AzureManagedControlPlaneTemplateResource{
    50  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
    51  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
    52  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
    53  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
    54  										Name:      "test-cluster-template",
    55  										CIDRBlock: defaultAKSVnetCIDR,
    56  									},
    57  								},
    58  							},
    59  						},
    60  					},
    61  				},
    62  			},
    63  		},
    64  		{
    65  			name: "custom name",
    66  			controlPlaneTemplate: &AzureManagedControlPlaneTemplate{
    67  				ObjectMeta: metav1.ObjectMeta{
    68  					Name: "test-cluster-template",
    69  				},
    70  				Spec: AzureManagedControlPlaneTemplateSpec{
    71  					Template: AzureManagedControlPlaneTemplateResource{
    72  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
    73  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
    74  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
    75  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
    76  										Name: "custom-vnet-name",
    77  									},
    78  								},
    79  							},
    80  						},
    81  					},
    82  				},
    83  			},
    84  			outputTemplate: &AzureManagedControlPlaneTemplate{
    85  				ObjectMeta: metav1.ObjectMeta{
    86  					Name: "test-cluster-template",
    87  				},
    88  				Spec: AzureManagedControlPlaneTemplateSpec{
    89  					Template: AzureManagedControlPlaneTemplateResource{
    90  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
    91  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
    92  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
    93  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
    94  										Name:      "custom-vnet-name",
    95  										CIDRBlock: defaultAKSVnetCIDR,
    96  									},
    97  								},
    98  							},
    99  						},
   100  					},
   101  				},
   102  			},
   103  		},
   104  		{
   105  			name: "custom cidr block",
   106  			controlPlaneTemplate: &AzureManagedControlPlaneTemplate{
   107  				ObjectMeta: metav1.ObjectMeta{
   108  					Name: "test-cluster-template",
   109  				},
   110  				Spec: AzureManagedControlPlaneTemplateSpec{
   111  					Template: AzureManagedControlPlaneTemplateResource{
   112  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
   113  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
   114  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
   115  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
   116  										CIDRBlock: "10.0.0.16/24",
   117  									},
   118  								},
   119  							},
   120  						},
   121  					},
   122  				},
   123  			},
   124  			outputTemplate: &AzureManagedControlPlaneTemplate{
   125  				ObjectMeta: metav1.ObjectMeta{
   126  					Name: "test-cluster-template",
   127  				},
   128  				Spec: AzureManagedControlPlaneTemplateSpec{
   129  					Template: AzureManagedControlPlaneTemplateResource{
   130  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
   131  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
   132  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
   133  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
   134  										Name:      "test-cluster-template",
   135  										CIDRBlock: "10.0.0.16/24",
   136  									},
   137  								},
   138  							},
   139  						},
   140  					},
   141  				},
   142  			},
   143  		},
   144  	}
   145  
   146  	for _, c := range cases {
   147  		tc := c
   148  		t.Run(tc.name, func(t *testing.T) {
   149  			t.Parallel()
   150  			tc.controlPlaneTemplate.setDefaultVirtualNetwork()
   151  			if !reflect.DeepEqual(tc.controlPlaneTemplate, tc.outputTemplate) {
   152  				expected, _ := json.MarshalIndent(tc.outputTemplate, "", "\t")
   153  				actual, _ := json.MarshalIndent(tc.controlPlaneTemplate, "", "\t")
   154  				t.Errorf("Expected %s, got %s", string(expected), string(actual))
   155  			}
   156  		})
   157  	}
   158  }
   159  
   160  func TestDefaultSubnetTemplate(t *testing.T) {
   161  	cases := []struct {
   162  		name                 string
   163  		controlPlaneTemplate *AzureManagedControlPlaneTemplate
   164  		outputTemplate       *AzureManagedControlPlaneTemplate
   165  	}{
   166  		{
   167  			name: "subnet not specified",
   168  			controlPlaneTemplate: &AzureManagedControlPlaneTemplate{
   169  				ObjectMeta: metav1.ObjectMeta{
   170  					Name: "test-cluster-template",
   171  				},
   172  				Spec: AzureManagedControlPlaneTemplateSpec{
   173  					Template: AzureManagedControlPlaneTemplateResource{},
   174  				},
   175  			},
   176  			outputTemplate: &AzureManagedControlPlaneTemplate{
   177  				ObjectMeta: metav1.ObjectMeta{
   178  					Name: "test-cluster-template",
   179  				},
   180  				Spec: AzureManagedControlPlaneTemplateSpec{
   181  					Template: AzureManagedControlPlaneTemplateResource{
   182  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
   183  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
   184  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
   185  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
   186  										Subnet: ManagedControlPlaneSubnet{
   187  											Name:      "test-cluster-template",
   188  											CIDRBlock: defaultAKSNodeSubnetCIDR,
   189  										},
   190  									},
   191  								},
   192  							},
   193  						},
   194  					},
   195  				},
   196  			},
   197  		},
   198  		{
   199  			name: "custom name",
   200  			controlPlaneTemplate: &AzureManagedControlPlaneTemplate{
   201  				ObjectMeta: metav1.ObjectMeta{
   202  					Name: "test-cluster-template",
   203  				},
   204  				Spec: AzureManagedControlPlaneTemplateSpec{
   205  					Template: AzureManagedControlPlaneTemplateResource{
   206  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
   207  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
   208  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
   209  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
   210  										Subnet: ManagedControlPlaneSubnet{
   211  											Name: "custom-subnet-name",
   212  										},
   213  									},
   214  								},
   215  							},
   216  						},
   217  					},
   218  				},
   219  			},
   220  			outputTemplate: &AzureManagedControlPlaneTemplate{
   221  				ObjectMeta: metav1.ObjectMeta{
   222  					Name: "test-cluster-template",
   223  				},
   224  				Spec: AzureManagedControlPlaneTemplateSpec{
   225  					Template: AzureManagedControlPlaneTemplateResource{
   226  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
   227  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
   228  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
   229  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
   230  										Subnet: ManagedControlPlaneSubnet{
   231  											Name:      "custom-subnet-name",
   232  											CIDRBlock: defaultAKSNodeSubnetCIDR,
   233  										},
   234  									},
   235  								},
   236  							},
   237  						},
   238  					},
   239  				},
   240  			},
   241  		},
   242  		{
   243  			name: "custom cidr block",
   244  			controlPlaneTemplate: &AzureManagedControlPlaneTemplate{
   245  				ObjectMeta: metav1.ObjectMeta{
   246  					Name: "test-cluster-template",
   247  				},
   248  				Spec: AzureManagedControlPlaneTemplateSpec{
   249  					Template: AzureManagedControlPlaneTemplateResource{
   250  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
   251  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
   252  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
   253  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
   254  										Subnet: ManagedControlPlaneSubnet{
   255  											CIDRBlock: "10.0.0.16/24",
   256  										},
   257  									},
   258  								},
   259  							},
   260  						},
   261  					},
   262  				},
   263  			},
   264  			outputTemplate: &AzureManagedControlPlaneTemplate{
   265  				ObjectMeta: metav1.ObjectMeta{
   266  					Name: "test-cluster-template",
   267  				},
   268  				Spec: AzureManagedControlPlaneTemplateSpec{
   269  					Template: AzureManagedControlPlaneTemplateResource{
   270  						Spec: AzureManagedControlPlaneTemplateResourceSpec{
   271  							AzureManagedControlPlaneClassSpec: AzureManagedControlPlaneClassSpec{
   272  								VirtualNetwork: ManagedControlPlaneVirtualNetwork{
   273  									ManagedControlPlaneVirtualNetworkClassSpec: ManagedControlPlaneVirtualNetworkClassSpec{
   274  										Subnet: ManagedControlPlaneSubnet{
   275  											Name:      "test-cluster-template",
   276  											CIDRBlock: "10.0.0.16/24",
   277  										},
   278  									},
   279  								},
   280  							},
   281  						},
   282  					},
   283  				},
   284  			},
   285  		},
   286  	}
   287  
   288  	for _, c := range cases {
   289  		tc := c
   290  		t.Run(tc.name, func(t *testing.T) {
   291  			t.Parallel()
   292  			tc.controlPlaneTemplate.setDefaultSubnet()
   293  			if !reflect.DeepEqual(tc.controlPlaneTemplate, tc.outputTemplate) {
   294  				expected, _ := json.MarshalIndent(tc.outputTemplate, "", "\t")
   295  				actual, _ := json.MarshalIndent(tc.controlPlaneTemplate, "", "\t")
   296  				t.Errorf("Expected %s, got %s", string(expected), string(actual))
   297  			}
   298  		})
   299  	}
   300  }
   301  
   302  func TestSetDefault(t *testing.T) {
   303  	g := NewGomegaWithT(t)
   304  
   305  	type Struct struct{ name string }
   306  
   307  	var s *Struct
   308  	setDefault(&s, &Struct{"hello"})
   309  	g.Expect(s.name).To(Equal("hello"))
   310  	setDefault(&s, &Struct{"world"})
   311  	g.Expect(s.name).To(Equal("hello"))
   312  
   313  	r := &Struct{}
   314  	setDefault(&r, &Struct{"a name"})
   315  	g.Expect(r.name).To(BeEmpty())
   316  	setDefault(&r.name, "hello")
   317  	g.Expect(r.name).To(Equal("hello"))
   318  	setDefault(&r.name, "world")
   319  	g.Expect(r.name).To(Equal("hello"))
   320  
   321  	str := ""
   322  	setDefault(&str, "a string")
   323  	g.Expect(str).To(Equal("a string"))
   324  	setDefault(&str, "another string")
   325  	g.Expect(str).To(Equal("a string"))
   326  }