github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/caas/kubernetes/provider/storage/metadata_test.go (about)

     1  // Copyright 2022 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package storage_test
     5  
     6  import (
     7  	gc "gopkg.in/check.v1"
     8  	storagev1 "k8s.io/api/storage/v1"
     9  	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
    10  
    11  	"github.com/juju/juju/caas/kubernetes/provider/storage"
    12  )
    13  
    14  type metadataSuite struct{}
    15  
    16  var _ = gc.Suite(&metadataSuite{})
    17  
    18  func (*metadataSuite) TestPreferredStorageAny(c *gc.C) {
    19  	tests := []struct {
    20  		Name         string
    21  		StorageClass *storagev1.StorageClass
    22  		Result       bool
    23  	}{
    24  		{
    25  			Name: "Test Any Storage Class",
    26  			StorageClass: &storagev1.StorageClass{
    27  				ObjectMeta: meta.ObjectMeta{
    28  					Name: "test1",
    29  				},
    30  			},
    31  			Result: true,
    32  		},
    33  		{
    34  			Name:         "Test Any Storage Class returns false for nil",
    35  			StorageClass: nil,
    36  			Result:       false,
    37  		},
    38  	}
    39  
    40  	for _, test := range tests {
    41  		c.Logf("running test %s", test.Name)
    42  		any := storage.PreferredStorageAny{}
    43  		c.Assert(any.Matches(test.StorageClass), gc.Equals, test.Result)
    44  	}
    45  }
    46  
    47  func (*metadataSuite) TestPreferredStorageNominated(c *gc.C) {
    48  	tests := []struct {
    49  		Name             string
    50  		StorageClass     *storagev1.StorageClass
    51  		NominatedStorage string
    52  		Result           bool
    53  	}{
    54  		{
    55  			Name: "Test match nominated storage",
    56  			StorageClass: &storagev1.StorageClass{
    57  				ObjectMeta: meta.ObjectMeta{
    58  					Name: "Test1",
    59  				},
    60  			},
    61  			NominatedStorage: "Test1",
    62  			Result:           true,
    63  		},
    64  		{
    65  			Name:             "Test match nominated storage nil class",
    66  			StorageClass:     nil,
    67  			NominatedStorage: "test2",
    68  			Result:           false,
    69  		},
    70  		{
    71  			Name: "Test empty string does not match",
    72  			StorageClass: &storagev1.StorageClass{
    73  				ObjectMeta: meta.ObjectMeta{
    74  					Name: "",
    75  				},
    76  			},
    77  			NominatedStorage: "",
    78  			Result:           false,
    79  		},
    80  		{
    81  			Name: "Test case sensitive does not match",
    82  			StorageClass: &storagev1.StorageClass{
    83  				ObjectMeta: meta.ObjectMeta{
    84  					Name: "AaBb",
    85  				},
    86  			},
    87  			NominatedStorage: "aabb",
    88  			Result:           false,
    89  		},
    90  	}
    91  
    92  	for _, test := range tests {
    93  		c.Logf("running test %s", test.Name)
    94  		nominated := storage.PreferredStorageNominated{StorageClassName: test.NominatedStorage}
    95  		c.Assert(nominated.Matches(test.StorageClass), gc.Equals, test.Result)
    96  	}
    97  }
    98  
    99  func (*metadataSuite) TestPreferredStorageOperatorAnnotation(c *gc.C) {
   100  	tests := []struct {
   101  		Name         string
   102  		StorageClass *storagev1.StorageClass
   103  		Result       bool
   104  	}{
   105  		{
   106  			Name: "Test operator storage annotation matches",
   107  			StorageClass: &storagev1.StorageClass{
   108  				ObjectMeta: meta.ObjectMeta{
   109  					Name: "test1",
   110  					Annotations: map[string]string{
   111  						"juju.is/operator-storage": "true",
   112  					},
   113  				},
   114  			},
   115  			Result: true,
   116  		},
   117  		{
   118  			Name: "Test operator storage doesn't match bad value",
   119  			StorageClass: &storagev1.StorageClass{
   120  				ObjectMeta: meta.ObjectMeta{
   121  					Name: "test1",
   122  					Annotations: map[string]string{
   123  						"juju.is/operator-storage": "false",
   124  					},
   125  				},
   126  			},
   127  			Result: false,
   128  		},
   129  		{
   130  			Name: "Test operator storage doesn't match workload storage",
   131  			StorageClass: &storagev1.StorageClass{
   132  				ObjectMeta: meta.ObjectMeta{
   133  					Name: "test1",
   134  					Annotations: map[string]string{
   135  						"juju.is/workload-storage": "true",
   136  					},
   137  				},
   138  			},
   139  			Result: false,
   140  		},
   141  	}
   142  
   143  	for _, test := range tests {
   144  		c.Logf("running test %s", test.Name)
   145  		annotation := storage.PreferredStorageOperatorAnnotation{}
   146  		c.Assert(annotation.Matches(test.StorageClass), gc.Equals, test.Result)
   147  	}
   148  }
   149  
   150  func (*metadataSuite) TestPreferredStorageWorkloadAnnotation(c *gc.C) {
   151  	tests := []struct {
   152  		Name         string
   153  		StorageClass *storagev1.StorageClass
   154  		Result       bool
   155  	}{
   156  		{
   157  			Name: "Test operator storage annotation matches",
   158  			StorageClass: &storagev1.StorageClass{
   159  				ObjectMeta: meta.ObjectMeta{
   160  					Name: "test1",
   161  					Annotations: map[string]string{
   162  						"juju.is/workload-storage": "true",
   163  					},
   164  				},
   165  			},
   166  			Result: true,
   167  		},
   168  		{
   169  			Name: "Test operator storage doesn't match bad value",
   170  			StorageClass: &storagev1.StorageClass{
   171  				ObjectMeta: meta.ObjectMeta{
   172  					Name: "test1",
   173  					Annotations: map[string]string{
   174  						"juju.is/workload-storage": "false",
   175  					},
   176  				},
   177  			},
   178  			Result: false,
   179  		},
   180  		{
   181  			Name: "Test operator storage doesn't match operator storage",
   182  			StorageClass: &storagev1.StorageClass{
   183  				ObjectMeta: meta.ObjectMeta{
   184  					Name: "test1",
   185  					Annotations: map[string]string{
   186  						"juju.is/operator-storage": "true",
   187  					},
   188  				},
   189  			},
   190  			Result: false,
   191  		},
   192  	}
   193  
   194  	for _, test := range tests {
   195  		c.Logf("running test %s", test.Name)
   196  		annotation := storage.PreferredStorageWorkloadAnnotation{}
   197  		c.Assert(annotation.Matches(test.StorageClass), gc.Equals, test.Result)
   198  	}
   199  }
   200  
   201  func (*metadataSuite) TestPreferredStorageDefault(c *gc.C) {
   202  	tests := []struct {
   203  		Name         string
   204  		StorageClass *storagev1.StorageClass
   205  		Result       bool
   206  	}{
   207  		{
   208  			Name: "Test default storage matches",
   209  			StorageClass: &storagev1.StorageClass{
   210  				ObjectMeta: meta.ObjectMeta{
   211  					Name: "test1",
   212  					Annotations: map[string]string{
   213  						"storageclass.kubernetes.io/is-default-class": "true",
   214  					},
   215  				},
   216  			},
   217  			Result: true,
   218  		},
   219  		{
   220  			Name: "Test default storage beta matches",
   221  			StorageClass: &storagev1.StorageClass{
   222  				ObjectMeta: meta.ObjectMeta{
   223  					Name: "test1",
   224  					Annotations: map[string]string{
   225  						"storageclass.beta.kubernetes.io/is-default-class": "true",
   226  					},
   227  				},
   228  			},
   229  			Result: true,
   230  		},
   231  		{
   232  			Name: "Test default storage both annotations match",
   233  			StorageClass: &storagev1.StorageClass{
   234  				ObjectMeta: meta.ObjectMeta{
   235  					Name: "test1",
   236  					Annotations: map[string]string{
   237  						"storageclass.beta.kubernetes.io/is-default-class": "true",
   238  						"storageclass.kubernetes.io/is-default-class":      "true",
   239  					},
   240  				},
   241  			},
   242  			Result: true,
   243  		},
   244  		{
   245  			Name: "Test default storage both annotations different order match",
   246  			StorageClass: &storagev1.StorageClass{
   247  				ObjectMeta: meta.ObjectMeta{
   248  					Name: "test1",
   249  					Annotations: map[string]string{
   250  						"storageclass.kubernetes.io/is-default-class":      "true",
   251  						"storageclass.beta.kubernetes.io/is-default-class": "true",
   252  					},
   253  				},
   254  			},
   255  			Result: true,
   256  		},
   257  		{
   258  			Name: "Test default storage type sensitive annotation",
   259  			StorageClass: &storagev1.StorageClass{
   260  				ObjectMeta: meta.ObjectMeta{
   261  					Name: "test1",
   262  					Annotations: map[string]string{
   263  						"Storageclass.kubernetes.io/is-default-class": "true",
   264  					},
   265  				},
   266  			},
   267  			Result: false,
   268  		},
   269  		{
   270  			Name: "Test default storage doesn't match",
   271  			StorageClass: &storagev1.StorageClass{
   272  				ObjectMeta: meta.ObjectMeta{
   273  					Name: "test1",
   274  					Annotations: map[string]string{
   275  						"junk": "true",
   276  					},
   277  				},
   278  			},
   279  			Result: false,
   280  		},
   281  	}
   282  
   283  	for _, test := range tests {
   284  		c.Logf("running test %s", test.Name)
   285  		defStorage := storage.PreferredStorageDefault{}
   286  		c.Assert(defStorage.Matches(test.StorageClass), gc.Equals, test.Result)
   287  	}
   288  }
   289  
   290  func (*metadataSuite) TestPreferredStorageProvisioner(c *gc.C) {
   291  	tests := []struct {
   292  		Name         string
   293  		StorageClass *storagev1.StorageClass
   294  		Provisioner  string
   295  		Result       bool
   296  	}{
   297  		{
   298  			Name: "Test provisioner empty string matches",
   299  			StorageClass: &storagev1.StorageClass{
   300  				ObjectMeta: meta.ObjectMeta{
   301  					Name: "test1",
   302  				},
   303  				Provisioner: "",
   304  			},
   305  			Provisioner: "",
   306  			Result:      true,
   307  		},
   308  		{
   309  			Name: "Test Azure provisioner",
   310  			StorageClass: &storagev1.StorageClass{
   311  				ObjectMeta: meta.ObjectMeta{
   312  					Name: "test1",
   313  				},
   314  				Provisioner: "kubernetes.io/azure-disk",
   315  			},
   316  			Provisioner: "kubernetes.io/azure-disk",
   317  			Result:      true,
   318  		},
   319  		{
   320  			Name: "Test provisioner doesn't match 1",
   321  			StorageClass: &storagev1.StorageClass{
   322  				ObjectMeta: meta.ObjectMeta{
   323  					Name: "test1",
   324  				},
   325  				Provisioner: "kubernetes.io/azure-disk",
   326  			},
   327  			Provisioner: "",
   328  			Result:      false,
   329  		},
   330  		{
   331  			Name: "Test provisioner doesn't match 2",
   332  			StorageClass: &storagev1.StorageClass{
   333  				ObjectMeta: meta.ObjectMeta{
   334  					Name: "test1",
   335  				},
   336  				Provisioner: "kubernetes.io/azure-disk",
   337  			},
   338  			Provisioner: "junk",
   339  			Result:      false,
   340  		},
   341  	}
   342  
   343  	for _, test := range tests {
   344  		c.Logf("running test %s", test.Name)
   345  		provisioner := storage.PreferredStorageProvisioner{
   346  			NameVal:     "test-storage-provisioner",
   347  			Provisioner: test.Provisioner,
   348  		}
   349  		c.Assert(provisioner.Matches(test.StorageClass), gc.Equals, test.Result)
   350  	}
   351  }