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

     1  // Copyright 2021 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package resources
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/juju/errors"
    10  	core "k8s.io/api/core/v1"
    11  	rbac "k8s.io/api/rbac/v1"
    12  	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
    13  )
    14  
    15  func TestClaimHasJujuLabel(t *testing.T) {
    16  	tests := []struct {
    17  		Name   string
    18  		Obj    interface{}
    19  		Result bool
    20  	}{
    21  		{
    22  			Name: "Test that object has a single juju label",
    23  			Obj: &core.ConfigMap{
    24  				ObjectMeta: meta.ObjectMeta{
    25  					Labels: map[string]string{
    26  						"juju.io/something": "some-value",
    27  					},
    28  				},
    29  			},
    30  			Result: true,
    31  		},
    32  		{
    33  			Name: "Test that object has no juju labels",
    34  			Obj: &core.ConfigMap{
    35  				ObjectMeta: meta.ObjectMeta{
    36  					Labels: map[string]string{
    37  						"does-not-mention-secret-keys": "foo",
    38  					},
    39  				},
    40  			},
    41  			Result: false,
    42  		},
    43  		{
    44  			Name: "Test many labels with juju key",
    45  			Obj: &rbac.ClusterRole{
    46  				ObjectMeta: meta.ObjectMeta{
    47  					Labels: map[string]string{
    48  						"label1":     "foo",
    49  						"label2":     "foo",
    50  						"label3":     "foo",
    51  						"label4":     "foo",
    52  						"label5":     "foo",
    53  						"label6":     "foo",
    54  						"label7":     "foo",
    55  						"label8":     "foo",
    56  						"label9":     "foo",
    57  						"juju-model": "AA==",
    58  					},
    59  				},
    60  			},
    61  			Result: true,
    62  		},
    63  	}
    64  
    65  	for _, test := range tests {
    66  		t.Run(test.Name, func(t *testing.T) {
    67  			r, err := claimHasJujuLabel(test.Obj)
    68  			if err != nil {
    69  				t.Errorf("unexpected error testing claim has juju label %v", err)
    70  			}
    71  			if r != test.Result {
    72  				t.Errorf("unexpected result for claim has juju label, weanted %t got %t",
    73  					test.Result, r)
    74  			}
    75  		})
    76  	}
    77  }
    78  
    79  func TestClaimHasJujuLabelBadData(t *testing.T) {
    80  	r, err := claimHasJujuLabel(map[string]string{})
    81  	if r {
    82  		t.Error("expected claim has juju label with bad data returns false")
    83  	}
    84  
    85  	if err == nil {
    86  		t.Error("expected claim has juju label with bad data returns an error")
    87  	}
    88  }
    89  
    90  func TestClaimHasJujuLabelNilData(t *testing.T) {
    91  	r, err := claimHasJujuLabel(nil)
    92  	if r {
    93  		t.Error("expected claim has juju label with nil data returns false")
    94  	}
    95  
    96  	if !errors.IsNotValid(err) {
    97  		t.Error("expected claim has juju label with nil to be a not valid error")
    98  	}
    99  }
   100  
   101  func TestClaimIsManagedByJuju(t *testing.T) {
   102  	tests := []struct {
   103  		Name   string
   104  		Obj    interface{}
   105  		Result bool
   106  	}{
   107  		{
   108  			Name: "Test that object is not managed by juju",
   109  			Obj: &core.ConfigMap{
   110  				ObjectMeta: meta.ObjectMeta{
   111  					Labels: map[string]string{
   112  						"juju.io/something": "some-value",
   113  					},
   114  				},
   115  			},
   116  			Result: false,
   117  		},
   118  		{
   119  			Name: "Test that object is managed by juju",
   120  			Obj: &core.ConfigMap{
   121  				ObjectMeta: meta.ObjectMeta{
   122  					Labels: map[string]string{
   123  						"app.kubernetes.io/managed-by": "juju",
   124  					},
   125  				},
   126  			},
   127  			Result: true,
   128  		},
   129  		{
   130  			Name: "Test many labels with is managed by juju",
   131  			Obj: &rbac.ClusterRole{
   132  				ObjectMeta: meta.ObjectMeta{
   133  					Labels: map[string]string{
   134  						"label1":                       "foo",
   135  						"label2":                       "foo",
   136  						"label3":                       "foo",
   137  						"label4":                       "foo",
   138  						"label5":                       "foo",
   139  						"label6":                       "foo",
   140  						"label7":                       "foo",
   141  						"label8":                       "foo",
   142  						"label9":                       "foo",
   143  						"app.kubernetes.io/managed-by": "juju",
   144  					},
   145  				},
   146  			},
   147  			Result: true,
   148  		},
   149  		{
   150  			Name: "Test not managed by Juju",
   151  			Obj: &rbac.ClusterRole{
   152  				ObjectMeta: meta.ObjectMeta{
   153  					Labels: map[string]string{
   154  						"label1":                       "foo",
   155  						"label2":                       "foo",
   156  						"label3":                       "foo",
   157  						"label4":                       "foo",
   158  						"label5":                       "foo",
   159  						"label6":                       "foo",
   160  						"label7":                       "foo",
   161  						"label8":                       "foo",
   162  						"label9":                       "foo",
   163  						"app.kubernetes.io/managed-by": "notjuju",
   164  					},
   165  				},
   166  			},
   167  			Result: false,
   168  		},
   169  	}
   170  
   171  	for _, test := range tests {
   172  		t.Run(test.Name, func(t *testing.T) {
   173  			r, err := claimIsManagedByJuju(test.Obj)
   174  			if err != nil {
   175  				t.Errorf("unexpected error testing is managed by juju %v", err)
   176  			}
   177  			if r != test.Result {
   178  				t.Errorf("unexpected result for claim is managed by juju, weanted %t got %t",
   179  					test.Result, r)
   180  			}
   181  		})
   182  	}
   183  }
   184  
   185  func TestClaimIsManagedByJujuBadData(t *testing.T) {
   186  	r, err := claimHasJujuLabel(map[string]string{})
   187  	if r {
   188  		t.Error("expected claim is managed by juju with bad data returns false")
   189  	}
   190  
   191  	if err == nil {
   192  		t.Error("expected claim is managed by juju with bad data returns an error")
   193  	}
   194  }
   195  
   196  func TestClaimIsManagedByJujuNilData(t *testing.T) {
   197  	r, err := claimHasJujuLabel(nil)
   198  	if r {
   199  		t.Error("expected claim is managed by juju with nil data returns false")
   200  	}
   201  
   202  	if !errors.IsNotValid(err) {
   203  		t.Error("expected claim is managed by juju with nil to be a not valid error")
   204  	}
   205  }
   206  
   207  func TestClaimOrAggregateWithEmptyClaimsReturnsFalse(t *testing.T) {
   208  	r, err := ClaimAggregateOr().Assert(nil)
   209  	if err != nil {
   210  		t.Errorf("unexpected error for empty claim aggregate or %v", err)
   211  	}
   212  	if r {
   213  		t.Errorf("expected empty claim aggregate or to return false")
   214  	}
   215  }
   216  
   217  func TestClaimAggregateOrReturnsTrue(t *testing.T) {
   218  	r, err := ClaimAggregateOr(
   219  		ClaimFn(func(_ interface{}) (bool, error) {
   220  			return false, nil
   221  		}),
   222  		ClaimFn(func(_ interface{}) (bool, error) {
   223  			return true, nil
   224  		}),
   225  	).Assert(nil)
   226  	if err != nil {
   227  		t.Errorf("unexpected error for claim aggregate or %v", err)
   228  	}
   229  	if !r {
   230  		t.Errorf("expected claim aggregate or to return true")
   231  	}
   232  }
   233  
   234  func TestClaimAggregateOrReturnsFalse(t *testing.T) {
   235  	r, err := ClaimAggregateOr(
   236  		ClaimFn(func(_ interface{}) (bool, error) {
   237  			return false, nil
   238  		}),
   239  		ClaimFn(func(_ interface{}) (bool, error) {
   240  			return false, nil
   241  		}),
   242  	).Assert(nil)
   243  	if err != nil {
   244  		t.Errorf("unexpected error for claim aggregate or %v", err)
   245  	}
   246  	if r {
   247  		t.Errorf("expected claim aggregate or to return false")
   248  	}
   249  }
   250  
   251  func TestClaimAggregateOrReturnsError(t *testing.T) {
   252  	r, err := ClaimAggregateOr(
   253  		ClaimFn(func(_ interface{}) (bool, error) {
   254  			return false, nil
   255  		}),
   256  		ClaimFn(func(_ interface{}) (bool, error) {
   257  			return false, errors.New("some-error")
   258  		}),
   259  	).Assert(nil)
   260  	if err == nil {
   261  		t.Error("expected claim aggregate or to return error")
   262  	}
   263  	if r {
   264  		t.Errorf("expected claim aggregate or to return false")
   265  	}
   266  }
   267  
   268  func TestClaimJujuOwnership(t *testing.T) {
   269  	tests := []struct {
   270  		Name   string
   271  		Obj    interface{}
   272  		Result bool
   273  	}{
   274  		{
   275  			Name: "Test that object has a single juju label",
   276  			Obj: &core.ConfigMap{
   277  				ObjectMeta: meta.ObjectMeta{
   278  					Labels: map[string]string{
   279  						"juju.io/something": "some-value",
   280  					},
   281  				},
   282  			},
   283  			Result: true,
   284  		},
   285  		{
   286  			Name: "Test that object has no juju labels",
   287  			Obj: &core.ConfigMap{
   288  				ObjectMeta: meta.ObjectMeta{
   289  					Labels: map[string]string{
   290  						"does-not-mention-secret-keys": "foo",
   291  					},
   292  				},
   293  			},
   294  			Result: false,
   295  		},
   296  		{
   297  			Name: "Test many labels with juju key",
   298  			Obj: &rbac.ClusterRole{
   299  				ObjectMeta: meta.ObjectMeta{
   300  					Labels: map[string]string{
   301  						"label1":     "foo",
   302  						"label2":     "foo",
   303  						"label3":     "foo",
   304  						"label4":     "foo",
   305  						"label5":     "foo",
   306  						"label6":     "foo",
   307  						"label7":     "foo",
   308  						"label8":     "foo",
   309  						"label9":     "foo",
   310  						"juju-model": "AA==",
   311  					},
   312  				},
   313  			},
   314  			Result: true,
   315  		},
   316  		{
   317  			Name: "Test that object is managed by juju",
   318  			Obj: &core.ConfigMap{
   319  				ObjectMeta: meta.ObjectMeta{
   320  					Labels: map[string]string{
   321  						"app.kubernetes.io/managed-by": "juju",
   322  					},
   323  				},
   324  			},
   325  			Result: true,
   326  		},
   327  		{
   328  			Name: "Test many labels with is managed by juju",
   329  			Obj: &rbac.ClusterRole{
   330  				ObjectMeta: meta.ObjectMeta{
   331  					Labels: map[string]string{
   332  						"label1":                       "foo",
   333  						"label2":                       "foo",
   334  						"label3":                       "foo",
   335  						"label4":                       "foo",
   336  						"label5":                       "foo",
   337  						"label6":                       "foo",
   338  						"label7":                       "foo",
   339  						"label8":                       "foo",
   340  						"label9":                       "foo",
   341  						"app.kubernetes.io/managed-by": "juju",
   342  					},
   343  				},
   344  			},
   345  			Result: true,
   346  		},
   347  		{
   348  			Name: "Test not managed by Juju",
   349  			Obj: &rbac.ClusterRole{
   350  				ObjectMeta: meta.ObjectMeta{
   351  					Labels: map[string]string{
   352  						"label1":                       "foo",
   353  						"label2":                       "foo",
   354  						"label3":                       "foo",
   355  						"label4":                       "foo",
   356  						"label5":                       "foo",
   357  						"label6":                       "foo",
   358  						"label7":                       "foo",
   359  						"label8":                       "foo",
   360  						"label9":                       "foo",
   361  						"app.kubernetes.io/managed-by": "notjuju",
   362  					},
   363  				},
   364  			},
   365  			Result: false,
   366  		},
   367  	}
   368  
   369  	for _, test := range tests {
   370  		t.Run(test.Name, func(t *testing.T) {
   371  			r, err := ClaimJujuOwnership.Assert(test.Obj)
   372  			if err != nil {
   373  				t.Errorf("unexpected error testing claim juju ownership %v", err)
   374  			}
   375  			if r != test.Result {
   376  				t.Errorf("unexpected result for claim juju ownership, weanted %t got %t",
   377  					test.Result, r)
   378  			}
   379  		})
   380  	}
   381  }