github.com/tilt-dev/tilt@v0.33.15-0.20240515162809-0a22ed45d8a0/internal/k8s/names_test.go (about)

     1  package k8s
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    10  
    11  	"github.com/tilt-dev/tilt/internal/k8s/testyaml"
    12  )
    13  
    14  type workload struct {
    15  	name                 string
    16  	kind                 string
    17  	namespace            string
    18  	group                string
    19  	expectedResourceName string
    20  }
    21  
    22  func TestUniqueResourceNames(t *testing.T) {
    23  	testCases := []struct {
    24  		testName  string
    25  		workloads []workload
    26  	}{
    27  		{"one workload, just name", []workload{
    28  			{"foo", "Deployment", "default", "", "foo"},
    29  		}},
    30  		{"one workload, same name", []workload{
    31  			{"foo", "Deployment", "default", "", "foo:deployment:default:core:0"},
    32  			{"foo", "Deployment", "default", "", "foo:deployment:default:core:1"},
    33  		}},
    34  		{"one workload, by name", []workload{
    35  			{"foo", "Deployment", "default", "", "foo"},
    36  			{"bar", "Deployment", "default", "", "bar"},
    37  		}},
    38  		{"two workloads, by kind", []workload{
    39  			{"foo", "Deployment", "default", "", "foo:deployment"},
    40  			{"foo", "CronJob", "default", "", "foo:cronjob"},
    41  		}},
    42  		{"two workloads, by namespace", []workload{
    43  			{"foo", "Deployment", "default", "", "foo:deployment:default"},
    44  			{"foo", "Deployment", "fission", "", "foo:deployment:fission"},
    45  		}},
    46  		{"two workloads, by group", []workload{
    47  			{"foo", "Deployment", "default", "a", "foo:deployment:default:a"},
    48  			{"foo", "Deployment", "default", "b", "foo:deployment:default:b"},
    49  		}},
    50  		{"three workloads, one by kind, two by namespace", []workload{
    51  			{"foo", "Deployment", "default", "a", "foo:deployment:default"},
    52  			{"foo", "Deployment", "fission", "b", "foo:deployment:fission"},
    53  			{"foo", "CronJob", "default", "b", "foo:cronjob"},
    54  		}},
    55  	}
    56  
    57  	for _, test := range testCases {
    58  		t.Run(test.testName, func(t *testing.T) {
    59  			var entities []K8sEntity
    60  			var expectedNames []string
    61  			for _, w := range test.workloads {
    62  				obj := unstructured.Unstructured{}
    63  				obj.SetName(w.name)
    64  				obj.SetNamespace(w.namespace)
    65  				obj.SetKind(w.kind)
    66  				obj.SetAPIVersion(fmt.Sprintf("%s/1.0", w.group))
    67  				entities = append(entities, NewK8sEntity(&obj))
    68  
    69  				expectedNames = append(expectedNames, w.expectedResourceName)
    70  			}
    71  
    72  			actualNames := UniqueNames(entities, 1)
    73  			require.Equal(t, expectedNames, actualNames)
    74  		})
    75  	}
    76  }
    77  
    78  func TestFragmentsToEntities(t *testing.T) {
    79  	entities, err := ParseYAMLFromString(testyaml.BlorgBackendYAML)
    80  	if err != nil {
    81  		t.Fatal(err)
    82  	}
    83  
    84  	actual := FragmentsToEntities(entities)
    85  
    86  	expected := map[string][]K8sEntity{
    87  		"devel-nick-lb-blorg-be":                      {entities[0]},
    88  		"devel-nick-lb-blorg-be:service":              {entities[0]},
    89  		"devel-nick-lb-blorg-be:service:default":      {entities[0]},
    90  		"devel-nick-lb-blorg-be:service:default:core": {entities[0]},
    91  
    92  		"devel-nick-blorg-be":                               {entities[1]},
    93  		"devel-nick-blorg-be:deployment":                    {entities[1]},
    94  		"devel-nick-blorg-be:deployment:default":            {entities[1]},
    95  		"devel-nick-blorg-be:deployment:default:extensions": {entities[1]},
    96  	}
    97  
    98  	assert.Equal(t, expected, actual)
    99  }
   100  
   101  func TestFragmentsToEntitiesAmbiguous(t *testing.T) {
   102  	entities, err := ParseYAMLFromString(testyaml.BlorgBackendAmbiguousYAML)
   103  	if err != nil {
   104  		t.Fatal(err)
   105  	}
   106  
   107  	actual := FragmentsToEntities(entities)
   108  
   109  	expected := map[string][]K8sEntity{
   110  		"blorg":                      {entities[0], entities[1]},
   111  		"blorg:service":              {entities[0]},
   112  		"blorg:service:default":      {entities[0]},
   113  		"blorg:service:default:core": {entities[0]},
   114  
   115  		"blorg:deployment":                    {entities[1]},
   116  		"blorg:deployment:default":            {entities[1]},
   117  		"blorg:deployment:default:extensions": {entities[1]},
   118  	}
   119  
   120  	assert.Equal(t, expected, actual)
   121  }