conversion_test.go

Documentation: github.com/emissary-ingress/emissary/v3/pkg/api/getambassador.io/v2

     1  package v2
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"github.com/emissary-ingress/emissary/v3/pkg/api/getambassador.io/v3alpha1"
    10  )
    11  
    12  func bosNil() *BoolOrString {
    13  	return &BoolOrString{}
    14  }
    15  
    16  func bosBool(b bool) *BoolOrString {
    17  	return &BoolOrString{
    18  		Bool: &b,
    19  	}
    20  }
    21  
    22  func bosString(str string) *BoolOrString {
    23  	return &BoolOrString{
    24  		String: &str,
    25  	}
    26  }
    27  
    28  func stringPtr(s string) *string {
    29  	return &s
    30  }
    31  
    32  func TestConvert_v2_TLS_To_v3alpha1_TLS(t *testing.T) {
    33  	t.Parallel()
    34  	type subtest struct {
    35  		inputTLS *BoolOrString
    36  		inputSvc string
    37  
    38  		expectedTLS            string
    39  		expectedExplicitTLS    string
    40  		expectedSvc            string
    41  		expectedExplicitScheme *string
    42  	}
    43  	subtests := map[string]subtest{
    44  		// falsey .tls
    45  		//       {               inputs              /**/,             outputs                },
    46  		"nn-ba": {nil /*************/, "svc" /**********/, "", "", "svc", nil},
    47  		"nn-lh": {nil /*************/, "http://svc" /***/, "", "", "http://svc", nil},
    48  		"nn-uh": {nil /*************/, "HTTP://svc" /***/, "", "", "HTTP://svc", nil},
    49  		"nn-ls": {nil /*************/, "https://svc" /**/, "", "", "https://svc", nil},
    50  		"nn-us": {nil /*************/, "HTTPS://svc" /**/, "", "", "HTTPS://svc", nil},
    51  		"bn-ba": {bosNil() /********/, "svc" /**********/, "", "null", "svc", nil},
    52  		"bn-lh": {bosNil() /********/, "http://svc" /***/, "", "null", "http://svc", nil},
    53  		"bn-uh": {bosNil() /********/, "HTTP://svc" /***/, "", "null", "HTTP://svc", nil},
    54  		"bn-ls": {bosNil() /********/, "https://svc" /**/, "", "null", "https://svc", nil},
    55  		"bn-us": {bosNil() /********/, "HTTPS://svc" /**/, "", "null", "HTTPS://svc", nil},
    56  		"bf-ba": {bosBool(false) /**/, "svc" /**********/, "", "bool:false", "svc", nil},
    57  		"bf-lh": {bosBool(false) /**/, "http://svc" /***/, "", "bool:false", "http://svc", nil},
    58  		"bf-uh": {bosBool(false) /**/, "HTTP://svc" /***/, "", "bool:false", "HTTP://svc", nil},
    59  		"bf-ls": {bosBool(false) /**/, "https://svc" /**/, "", "bool:false", "https://svc", nil},
    60  		"bf-us": {bosBool(false) /**/, "HTTPS://svc" /**/, "", "bool:false", "HTTPS://svc", nil},
    61  		"be-ba": {bosString("") /***/, "svc" /**********/, "", "string", "svc", nil},
    62  		"be-lh": {bosString("") /***/, "http://svc" /***/, "", "string", "http://svc", nil},
    63  		"be-uh": {bosString("") /***/, "HTTP://svc" /***/, "", "string", "HTTP://svc", nil},
    64  		"be-ls": {bosString("") /***/, "https://svc" /**/, "", "string", "https://svc", nil},
    65  		"be-us": {bosString("") /***/, "HTTPS://svc" /**/, "", "string", "HTTPS://svc", nil},
    66  
    67  		// truthy .tls
    68  		//       {                inputs               /**/,               outputs                },
    69  		"bt-ba": {bosBool(true) /*****/, "svc" /**********/, "", "bool:true", "https://svc", stringPtr("")},
    70  		"bt-lh": {bosBool(true) /*****/, "http://svc" /***/, "", "bool:true", "https://svc", stringPtr("http://")},
    71  		"bt-uh": {bosBool(true) /*****/, "HTTP://svc" /***/, "", "bool:true", "https://svc", stringPtr("HTTP://")},
    72  		"bt-ls": {bosBool(true) /*****/, "https://svc" /**/, "", "bool:true", "https://svc", nil},
    73  		"bt-hs": {bosBool(true) /*****/, "HTTPS://svc" /**/, "", "bool:true", "HTTPS://svc", nil},
    74  		"bc-ba": {bosString("ctx") /**/, "svc" /**********/, "ctx", "", "svc", nil},
    75  		"bc-lh": {bosString("ctx") /**/, "http://svc" /***/, "ctx", "", "http://svc", nil},
    76  		"bc-uh": {bosString("ctx") /**/, "HTTP://svc" /***/, "ctx", "", "HTTP://svc", nil},
    77  		"bc-ls": {bosString("ctx") /**/, "https://svc" /**/, "ctx", "", "https://svc", nil},
    78  		"bc-hs": {bosString("ctx") /**/, "HTTPS://svc" /**/, "ctx", "", "HTTPS://svc", nil},
    79  	}
    80  	for name, info := range subtests {
    81  		info := info // capture loop variable
    82  		t.Run(name, func(t *testing.T) {
    83  			t.Parallel()
    84  			var (
    85  				actualTLS      string
    86  				actualSvc      string
    87  				actualExplicit *v3alpha1.V2ExplicitTLS
    88  			)
    89  
    90  			convert_v2_TLS_To_v3alpha1_TLS(
    91  				info.inputTLS, info.inputSvc,
    92  				&actualTLS, &actualSvc, &actualExplicit)
    93  			assert.Equal(t, info.expectedTLS, actualTLS, "v2→v3alpha1 tls")
    94  			assert.Equal(t, info.expectedSvc, actualSvc, "v2→v3alpha1 svc")
    95  			if actualExplicit == nil {
    96  				actualExplicit = &v3alpha1.V2ExplicitTLS{}
    97  			}
    98  			assert.Equal(t, info.expectedExplicitTLS, actualExplicit.TLS, "v2→v3alpha1 explicit.tls")
    99  			assert.Equal(t, info.expectedExplicitScheme, actualExplicit.ServiceScheme, "v2→v3alpha1 explicit.svc")
   100  
   101  			var (
   102  				rtTLS *BoolOrString
   103  				rtSvc string
   104  			)
   105  			convert_v3alpha1_TLS_To_v2_TLS(
   106  				actualTLS, actualSvc, actualExplicit,
   107  				&rtTLS, &rtSvc)
   108  			assert.Equal(t, info.inputTLS, rtTLS, "v2→v3alpha1→v2 tls")
   109  			assert.Equal(t, info.inputSvc, rtSvc, "v2→v3alpha1→v2 svc")
   110  		})
   111  	}
   112  }
   113  
   114  func TestConvert_v3alpha1_TLS_To_v2_TLS(t *testing.T) {
   115  	t.Parallel()
   116  	type subtest struct {
   117  		inputTLS            string
   118  		inputSvc            string
   119  		inputExplicitTLS    string
   120  		inputExplicitScheme *string
   121  
   122  		expectedTLS *BoolOrString
   123  		expectedSvc string
   124  	}
   125  	// Because TestConvert_v2_TLS_To_v3alpha1_TLS tests round-trips, we only need to test the
   126  	// cases where one of the explicit fields is *ignored*.  This can happen if a resource that
   127  	// was originally v2 is later edited as v3alpha1.
   128  	subtests := map[string]subtest{
   129  		// empty
   130  		"minimal":   { /*input:*/ "", "svc", "", nil /*output:*/, nil, "svc"},
   131  		"http":      { /*input:*/ "", "HTTP://svc", "", nil /*output:*/, nil, "HTTP://svc"},
   132  		"https":     { /*input:*/ "", "HTTPS://svc", "", nil /*output:*/, nil, "HTTPS://svc"},
   133  		"http-ctx":  { /*input:*/ "ctx", "HTTP://svc", "", nil /*output:*/, bosString("ctx"), "HTTP://svc"},
   134  		"https-ctx": { /*input:*/ "ctx", "HTTPS://svc", "", nil /*output:*/, bosString("ctx"), "HTTPS://svc"},
   135  
   136  		// ignore explicitTLS:
   137  		"ignoretls-n":  { /*input:*/ "ctx", "HTTP://svc", "null", nil /*output:*/, bosString("ctx"), "HTTP://svc"},
   138  		"ignoretls-f":  { /*input:*/ "ctx", "HTTP://svc", "bool:false", nil /*output:*/, bosString("ctx"), "HTTP://svc"},
   139  		"ignoretls-t":  { /*input:*/ "ctx", "HTTP://svc", "bool:true", nil /*output:*/, bosString("ctx"), "HTTP://svc"},
   140  		"ignoretls-s":  { /*input:*/ "ctx", "HTTP://svc", "string", nil /*output:*/, bosString("ctx"), "HTTP://svc"},
   141  		"ignoretls-t2": { /*input:*/ "", "HTTP://svc", "bool:true", nil /*output:*/, nil, "HTTP://svc"},
   142  
   143  		// ignore explicitSvc
   144  		"ignoresvc-http":  { /*input:*/ "", "HTTP://svc", "", stringPtr("https://") /*output:*/, nil, "HTTP://svc"},
   145  		"ignoresvc-https": { /*input:*/ "", "HTTPS://svc", "", stringPtr("http://") /*output:*/, nil, "HTTPS://svc"},
   146  	}
   147  	for name, info := range subtests {
   148  		info := info // capture loop variable
   149  		t.Run(name, func(t *testing.T) {
   150  			t.Parallel()
   151  			var (
   152  				actualTLS *BoolOrString
   153  				actualSvc string
   154  			)
   155  			convert_v3alpha1_TLS_To_v2_TLS(
   156  				info.inputTLS, info.inputSvc,
   157  				&v3alpha1.V2ExplicitTLS{
   158  					TLS:           info.inputExplicitTLS,
   159  					ServiceScheme: info.inputExplicitScheme,
   160  				},
   161  				&actualTLS, &actualSvc)
   162  			assert.Equal(t, info.expectedTLS, actualTLS, "v3alpha1→v2 tls")
   163  			assert.Equal(t, info.expectedSvc, actualSvc, "v3alpha1→v2 svc")
   164  
   165  			var (
   166  				rtTLS      string
   167  				rtSvc      string
   168  				rtExplicit *v3alpha1.V2ExplicitTLS
   169  			)
   170  			convert_v2_TLS_To_v3alpha1_TLS(
   171  				actualTLS, actualSvc,
   172  				&rtTLS, &rtSvc, &rtExplicit)
   173  			if rtExplicit == nil {
   174  				rtExplicit = &v3alpha1.V2ExplicitTLS{}
   175  			}
   176  			assert.Equal(t, info.inputTLS, rtTLS, "v3alpha1→v2→v3alpha1 tls")
   177  			assert.Equal(t, info.inputSvc, rtSvc, "v3alpha1→v2→v3alpha1 svc")
   178  			if !strings.Contains(t.Name(), "ignoretls") {
   179  				assert.Equal(t, info.inputExplicitTLS, rtExplicit.TLS, "v3alpha1→v2→v3alpha1 explicit.tls")
   180  			}
   181  			if !strings.Contains(t.Name(), "ignoresvc") {
   182  				assert.Equal(t, info.inputExplicitScheme, rtExplicit.ServiceScheme, "v3alpha1→v2→v3alpha1 explicit.svc")
   183  			}
   184  		})
   185  	}
   186  }
   187
View as plain text