utils_test.go

Documentation: k8s.io/kubernetes/test/e2e/storage/utils

     1  /*
     2  Copyright 2018 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 utils
    18  
    19  import (
    20  	"testing"
    21  
    22  	e2evolume "k8s.io/kubernetes/test/e2e/framework/volume"
    23  )
    24  
    25  // getSizeRangesIntersection takes two instances of storage size ranges and determines the
    26  // intersection of the intervals (if it exists) and return the minimum of the intersection
    27  // to be used as the claim size for the test.
    28  // if value not set, that means there's no minimum or maximum size limitation and we set default size for it.
    29  // Considerate all corner case as followed:
    30  // first: A,B is regular value and ? means unspecified
    31  // second: C,D is regular value and ? means unspecified
    32  // ----------------------------------------------------------------
    33  // |    \second| min=C,max=?| min=C,max=D| min=?,max=D| min=?,max=?|
    34  // |first\     |            |            |            |            |
    35  // |----------------------------------------------------------------
    36  // |min=A,max=?|    #1      |     #2     |     #3     |    #4      |
    37  // -----------------------------------------------------------------
    38  // |min=A,max=B|    #5      |     #6     |     #7     |    #8      |
    39  // -----------------------------------------------------------------
    40  // |min=?,max=B|    #9      |     #10    |     #11    |    #12     |
    41  // -----------------------------------------------------------------
    42  // |min=?,max=?|    #13     |     #14    |     #15    |    #16     |
    43  // |---------------------------------------------------------------|
    44  func Test_GetSizeRangesIntersection(t *testing.T) {
    45  	type args struct {
    46  		first  e2evolume.SizeRange
    47  		second e2evolume.SizeRange
    48  	}
    49  	tests := []struct {
    50  		name    string
    51  		args    args
    52  		want    string
    53  		wantErr bool
    54  	}{
    55  		{
    56  			name: "case #1: first{min=A,max=?} second{min=C,max=?} where C > A ",
    57  			args: args{
    58  				first: e2evolume.SizeRange{
    59  					Min: "5Gi",
    60  				},
    61  				second: e2evolume.SizeRange{
    62  					Min: "10Gi",
    63  				},
    64  			},
    65  			want:    "10Gi",
    66  			wantErr: false,
    67  		},
    68  		{
    69  			name: "case #1: first{min=A,max=?} second{min=C,max=?} where C < A ",
    70  			args: args{
    71  				first: e2evolume.SizeRange{
    72  					Min: "5Gi",
    73  				},
    74  				second: e2evolume.SizeRange{
    75  					Min: "1Gi",
    76  				},
    77  			},
    78  			want:    "5Gi",
    79  			wantErr: false,
    80  		},
    81  		{
    82  			name: "case #2: first{min=A,max=?} second{min=C,max=D} where A > D ",
    83  			args: args{
    84  				first: e2evolume.SizeRange{
    85  					Min: "5Gi",
    86  				},
    87  				second: e2evolume.SizeRange{
    88  					Min: "1Gi",
    89  					Max: "4Gi",
    90  				},
    91  			},
    92  			want:    "",
    93  			wantErr: true,
    94  		},
    95  		{
    96  			name: "case #2: first{min=A,max=?} second{min=C,max=D} where D > A > C ",
    97  			args: args{
    98  				first: e2evolume.SizeRange{
    99  					Min: "5Gi",
   100  					Max: "",
   101  				},
   102  				second: e2evolume.SizeRange{
   103  					Min: "3Gi",
   104  					Max: "10Gi",
   105  				},
   106  			},
   107  			want:    "5Gi",
   108  			wantErr: false,
   109  		},
   110  		{
   111  			name: "case #2: first{min=A,max=?} second{min=C,max=D} where A < C ",
   112  			args: args{
   113  				first: e2evolume.SizeRange{
   114  					Min: "5Gi",
   115  					Max: "",
   116  				},
   117  				second: e2evolume.SizeRange{
   118  					Min: "6Gi",
   119  					Max: "10Gi",
   120  				},
   121  			},
   122  			want:    "6Gi",
   123  			wantErr: false,
   124  		},
   125  		{
   126  			name: "case #3: first{min=A,max=?} second{min=?,max=D} where A > D",
   127  			args: args{
   128  				first: e2evolume.SizeRange{
   129  					Min: "5Gi",
   130  					Max: "",
   131  				},
   132  				second: e2evolume.SizeRange{
   133  					Max: "1Gi",
   134  				},
   135  			},
   136  			want:    "",
   137  			wantErr: true,
   138  		},
   139  		{
   140  			name: "case #3: first{min=A,max=?} second{min=?,max=D} where A < D",
   141  			args: args{
   142  				first: e2evolume.SizeRange{
   143  					Min: "5Gi",
   144  					Max: "",
   145  				},
   146  				second: e2evolume.SizeRange{
   147  					Max: "10Gi",
   148  				},
   149  			},
   150  			want:    "5Gi",
   151  			wantErr: false,
   152  		},
   153  		{
   154  			name: "case #4: first{min=A,max=?} second{min=?,max=?} ",
   155  			args: args{
   156  				first: e2evolume.SizeRange{
   157  					Min: "5Gi",
   158  					Max: "",
   159  				},
   160  				second: e2evolume.SizeRange{},
   161  			},
   162  			want:    "5Gi",
   163  			wantErr: false,
   164  		},
   165  
   166  		{
   167  			name: "case #5: first{min=A,max=B} second{min=C,max=?} where C < A ",
   168  			args: args{
   169  				first: e2evolume.SizeRange{
   170  					Min: "5Gi",
   171  					Max: "10Gi",
   172  				},
   173  				second: e2evolume.SizeRange{
   174  					Min: "1Gi",
   175  				},
   176  			},
   177  			want:    "5Gi",
   178  			wantErr: false,
   179  		},
   180  		{
   181  			name: "case #5: first{min=A,max=B} second{min=C,max=?} where B > C > A ",
   182  			args: args{
   183  				first: e2evolume.SizeRange{
   184  					Min: "5Gi",
   185  					Max: "10Gi",
   186  				},
   187  				second: e2evolume.SizeRange{
   188  					Min: "6Gi",
   189  				},
   190  			},
   191  			want:    "6Gi",
   192  			wantErr: false,
   193  		},
   194  		{
   195  			name: "case #5: first{min=A,max=B} second{min=C,max=?} where C > B ",
   196  			args: args{
   197  				first: e2evolume.SizeRange{
   198  					Min: "5Gi",
   199  					Max: "10Gi",
   200  				},
   201  				second: e2evolume.SizeRange{
   202  					Min: "15Gi",
   203  				},
   204  			},
   205  			want:    "",
   206  			wantErr: true,
   207  		},
   208  		{
   209  			name: "case #6: first{min=A,max=B} second{min=C,max=D} where A < B < C < D",
   210  			args: args{
   211  				first: e2evolume.SizeRange{
   212  					Min: "5Gi",
   213  					Max: "6Gi",
   214  				},
   215  				second: e2evolume.SizeRange{
   216  					Min: "7Gi",
   217  					Max: "8Gi",
   218  				},
   219  			},
   220  			want:    "",
   221  			wantErr: true,
   222  		},
   223  		{
   224  			name: "case #6: first{min=A,max=B} second{min=C,max=D} where A < C < B < D ",
   225  			args: args{
   226  				first: e2evolume.SizeRange{
   227  					Min: "5Gi",
   228  					Max: "10Gi",
   229  				},
   230  				second: e2evolume.SizeRange{
   231  					Min: "8Gi",
   232  					Max: "15Gi",
   233  				},
   234  			},
   235  			want:    "8Gi",
   236  			wantErr: false,
   237  		},
   238  		{
   239  			name: "case #7: first{min=A,max=B} second{min=?,max=D} where D < A",
   240  			args: args{
   241  				first: e2evolume.SizeRange{
   242  					Min: "5Gi",
   243  					Max: "10Gi",
   244  				},
   245  				second: e2evolume.SizeRange{
   246  					Max: "3Gi",
   247  				},
   248  			},
   249  			want:    "",
   250  			wantErr: true,
   251  		},
   252  		{
   253  			name: "case #7: first{min=A,max=B} second{min=?,max=D} where B > D > A",
   254  			args: args{
   255  				first: e2evolume.SizeRange{
   256  					Min: "5Gi",
   257  					Max: "10Gi",
   258  				},
   259  				second: e2evolume.SizeRange{
   260  					Max: "8Gi",
   261  				},
   262  			},
   263  			want:    "5Gi",
   264  			wantErr: false,
   265  		},
   266  		{
   267  			name: "case #7: first{min=A,max=B} second{min=?,max=D} where D > B",
   268  			args: args{
   269  				first: e2evolume.SizeRange{
   270  					Min: "5Gi",
   271  					Max: "10Gi",
   272  				},
   273  				second: e2evolume.SizeRange{
   274  					Max: "15Gi",
   275  				},
   276  			},
   277  			want:    "5Gi",
   278  			wantErr: false,
   279  		},
   280  		{
   281  			name: "case #8: first{min=A,max=B} second{min=?,max=?}",
   282  			args: args{
   283  				first: e2evolume.SizeRange{
   284  					Min: "5Gi",
   285  					Max: "10Gi",
   286  				},
   287  				second: e2evolume.SizeRange{},
   288  			},
   289  			want:    "5Gi",
   290  			wantErr: false,
   291  		},
   292  		{
   293  			name: "case #9: first{min=?,max=B} second{min=C,max=?} where C > B",
   294  			args: args{
   295  				first: e2evolume.SizeRange{
   296  					Max: "5Gi",
   297  				},
   298  				second: e2evolume.SizeRange{
   299  					Min: "10Gi",
   300  				},
   301  			},
   302  			want:    "",
   303  			wantErr: true,
   304  		},
   305  		{
   306  			name: "case #9: first{min=?,max=B} second{min=C,max=?} where C < B",
   307  			args: args{
   308  				first: e2evolume.SizeRange{
   309  					Max: "10Gi",
   310  				},
   311  				second: e2evolume.SizeRange{
   312  					Min: "5Gi",
   313  				},
   314  			},
   315  			want:    "5Gi",
   316  			wantErr: false,
   317  		},
   318  		{
   319  			name: "case #10: first{min=?,max=B} second{min=C,max=D} where B > D",
   320  			args: args{
   321  				first: e2evolume.SizeRange{
   322  					Max: "10Gi",
   323  				},
   324  				second: e2evolume.SizeRange{
   325  					Min: "1Gi",
   326  					Max: "5Gi",
   327  				},
   328  			},
   329  			want:    "1Gi",
   330  			wantErr: false,
   331  		},
   332  		{
   333  			name: "case #10: first{min=?,max=B} second{min=C,max=D} where C < B < D",
   334  			args: args{
   335  				first: e2evolume.SizeRange{
   336  					Max: "10Gi",
   337  				},
   338  				second: e2evolume.SizeRange{
   339  					Min: "5Gi",
   340  					Max: "15Gi",
   341  				},
   342  			},
   343  			want:    "5Gi",
   344  			wantErr: false,
   345  		},
   346  		{
   347  			name: "case #10: first{min=?,max=B} second{min=C,max=D} where B < C",
   348  			args: args{
   349  				first: e2evolume.SizeRange{
   350  					Max: "10Gi",
   351  				},
   352  				second: e2evolume.SizeRange{
   353  					Min: "15Gi",
   354  					Max: "20Gi",
   355  				},
   356  			},
   357  			want:    "",
   358  			wantErr: true,
   359  		},
   360  		{
   361  			name: "case #11: first{min=?,max=B} second{min=?,max=D} where D < B",
   362  			args: args{
   363  				first: e2evolume.SizeRange{
   364  					Max: "10Gi",
   365  				},
   366  				second: e2evolume.SizeRange{
   367  					Max: "5Gi",
   368  				},
   369  			},
   370  			want:    minValidSize,
   371  			wantErr: false,
   372  		},
   373  		{
   374  			name: "case #11: first{min=?,max=B} second{min=?,max=D} where D > B",
   375  			args: args{
   376  				first: e2evolume.SizeRange{
   377  					Max: "10Gi",
   378  				},
   379  				second: e2evolume.SizeRange{
   380  					Max: "15Gi",
   381  				},
   382  			},
   383  			want:    minValidSize,
   384  			wantErr: false,
   385  		},
   386  		{
   387  			name: "case #12: first{min=?,max=B} second{min=?,max=?} ",
   388  			args: args{
   389  				first: e2evolume.SizeRange{
   390  					Max: "10Gi",
   391  				},
   392  				second: e2evolume.SizeRange{},
   393  			},
   394  			want:    minValidSize,
   395  			wantErr: false,
   396  		},
   397  		{
   398  			name: "case #13: first{min=?,max=?} second{min=C,max=?} ",
   399  			args: args{
   400  				first: e2evolume.SizeRange{},
   401  				second: e2evolume.SizeRange{
   402  					Min: "5Gi",
   403  				},
   404  			},
   405  			want:    "5Gi",
   406  			wantErr: false,
   407  		},
   408  		{
   409  			name: "case #14: first{min=?,max=?} second{min=C,max=D} where C < D",
   410  			args: args{
   411  				first: e2evolume.SizeRange{},
   412  				second: e2evolume.SizeRange{
   413  					Min: "5Gi",
   414  					Max: "10Gi",
   415  				},
   416  			},
   417  			want:    "5Gi",
   418  			wantErr: false,
   419  		},
   420  		{
   421  			name: "case #14: first{min=?,max=?} second{min=C,max=D} where C > D",
   422  			args: args{
   423  				first: e2evolume.SizeRange{},
   424  				second: e2evolume.SizeRange{
   425  					Min: "10Gi",
   426  					Max: "5Gi",
   427  				},
   428  			},
   429  			want:    "",
   430  			wantErr: true,
   431  		},
   432  		{
   433  			name: "case #14: first{min=?,max=?} second{min=C,max=D} where C = D",
   434  			args: args{
   435  				first: e2evolume.SizeRange{},
   436  				second: e2evolume.SizeRange{
   437  					Min: "1Mi",
   438  					Max: "1Mi",
   439  				},
   440  			},
   441  			want:    "1Mi",
   442  			wantErr: false,
   443  		},
   444  		{
   445  			name: "case #15: first{min=?,max=?} second{min=?,max=D}",
   446  			args: args{
   447  				first: e2evolume.SizeRange{},
   448  				second: e2evolume.SizeRange{
   449  					Max: "10Gi",
   450  				},
   451  			},
   452  			want:    minValidSize,
   453  			wantErr: false,
   454  		},
   455  		{
   456  			name: "case #16: first{min=?,max=?} second{min=?,max=?}",
   457  			args: args{
   458  				first:  e2evolume.SizeRange{},
   459  				second: e2evolume.SizeRange{},
   460  			},
   461  			want:    minValidSize,
   462  			wantErr: false,
   463  		},
   464  	}
   465  	for _, tt := range tests {
   466  		got, err := GetSizeRangesIntersection(tt.args.first, tt.args.second)
   467  		if (err != nil) != tt.wantErr {
   468  			t.Errorf("%q. GetSizeRangesIntersection() error = %v, wantErr %v", tt.name, err, tt.wantErr)
   469  			continue
   470  		}
   471  		if got != tt.want {
   472  			t.Errorf("%q. GetSizeRangesIntersection() = %v, want %v", tt.name, got, tt.want)
   473  		}
   474  	}
   475  }
   476
View as plain text