github.com/verrazzano/verrazzano@v1.7.0/application-operator/controllers/navigation/names_test.go (about)

     1  // Copyright (c) 2020, 2023, Oracle and/or its affiliates.
     2  // Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
     3  
     4  package navigation
     5  
     6  import (
     7  	asserts "github.com/stretchr/testify/assert"
     8  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
     9  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    10  	"k8s.io/apimachinery/pkg/types"
    11  	"testing"
    12  )
    13  
    14  // TestGetDefinitionOfResource tests various use cases of GetDefinitionOfResource
    15  func TestGetDefinitionOfResource(t *testing.T) {
    16  	assert := asserts.New(t)
    17  
    18  	var actual types.NamespacedName
    19  	var expect types.NamespacedName
    20  
    21  	// GIVEN an valid resource group version kind
    22  	// WHEN the GVK is converted to a CRD name
    23  	// THEN verify the name is correct.
    24  	actual = GetDefinitionOfResource("core.oam.dev/v1alpha2", "ContainerizedWorkload")
    25  	expect = types.NamespacedName{Namespace: "", Name: "containerizedworkloads.core.oam.dev"}
    26  	assert.Equal(expect, actual)
    27  
    28  	// GIVEN an valid "core" resource group version kind
    29  	// WHEN the GVK is converted to a CRD name
    30  	// THEN verify the name is correct.
    31  	actual = GetDefinitionOfResource("v1", "Pod")
    32  	expect = types.NamespacedName{Namespace: "", Name: "pods"}
    33  	assert.Equal(expect, actual)
    34  }
    35  
    36  // TestParseGroupAndVersionFromAPIVersion test various use cases of ParseGroupAndVersionFromAPIVersion
    37  func TestParseGroupAndVersionFromAPIVersion(t *testing.T) {
    38  	assert := asserts.New(t)
    39  
    40  	var group string
    41  	var version string
    42  
    43  	group, version = ParseGroupAndVersionFromAPIVersion("core.oam.dev/v1alpha2")
    44  	assert.Equal("core.oam.dev", group)
    45  	assert.Equal("v1alpha2", version)
    46  
    47  	group, version = ParseGroupAndVersionFromAPIVersion("v1")
    48  	assert.Equal("", group)
    49  	assert.Equal("v1", version)
    50  }
    51  
    52  func TestGetNamespacedNameFromObjectMeta(t *testing.T) {
    53  	assert := asserts.New(t)
    54  	var objMeta metav1.ObjectMeta
    55  	var nname types.NamespacedName
    56  
    57  	objMeta = metav1.ObjectMeta{}
    58  	nname = GetNamespacedNameFromObjectMeta(objMeta)
    59  	assert.Equal("", nname.Namespace)
    60  	assert.Equal("", nname.Name)
    61  }
    62  
    63  func TestGetNamespacedNameFromUnstructured(t *testing.T) {
    64  	assert := asserts.New(t)
    65  	var uns unstructured.Unstructured
    66  	var nname types.NamespacedName
    67  
    68  	uns = unstructured.Unstructured{}
    69  	nname = GetNamespacedNameFromUnstructured(&uns)
    70  	assert.Equal("", nname.Namespace)
    71  	assert.Equal("", nname.Name)
    72  }
    73  
    74  // TestParseNamespacedNameFromQualifiedName tests various use cases of ParseNamespacedNameFromQualifiedName
    75  func TestParseNamespacedNameFromQualifiedName(t *testing.T) {
    76  	assert := asserts.New(t)
    77  	var qname string
    78  	var nname *types.NamespacedName
    79  	var err error
    80  
    81  	// GIVEN an empty qualified name
    82  	// WHEN a namespaced name is extracted
    83  	// THEN expect an error and nil namespaced name
    84  	qname = ""
    85  	nname, err = ParseNamespacedNameFromQualifiedName(qname)
    86  	assert.Error(err)
    87  	assert.Nil(nname)
    88  
    89  	// GIVEN an valid qualified name
    90  	// WHEN a namespaced name is extracted
    91  	// THEN expect no error and a correct namespaced name returned
    92  	qname = "test-space/test-name"
    93  	nname, err = ParseNamespacedNameFromQualifiedName(qname)
    94  	assert.NoError(err)
    95  	assert.Equal("test-space", nname.Namespace)
    96  	assert.Equal("test-name", nname.Name)
    97  
    98  	// GIVEN an valid name qualified with "default" namespace
    99  	// WHEN a namespaced name is extracted
   100  	// THEN expect no error and a correct namespaced name returned
   101  	qname = "/test-name"
   102  	nname, err = ParseNamespacedNameFromQualifiedName(qname)
   103  	assert.NoError(err)
   104  	assert.Equal("", nname.Namespace)
   105  	assert.Equal("test-name", nname.Name)
   106  
   107  	// GIVEN an valid unqualified name
   108  	// WHEN a namespaced name is extracted
   109  	// THEN expect an error and nil namespaced name
   110  	qname = "test-name"
   111  	nname, err = ParseNamespacedNameFromQualifiedName(qname)
   112  	assert.Error(err)
   113  	assert.Nil(nname)
   114  
   115  	// GIVEN an invalid name
   116  	// WHEN a namespaced name is extracted
   117  	// THEN expect an error and nil namespaced name
   118  	qname = "/"
   119  	nname, err = ParseNamespacedNameFromQualifiedName(qname)
   120  	assert.Error(err)
   121  	assert.Nil(nname)
   122  }