github.com/hugorut/terraform@v1.1.3/src/lang/funcs/encoding_test.go (about)

     1  package funcs
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/zclconf/go-cty/cty"
     8  )
     9  
    10  func TestBase64Decode(t *testing.T) {
    11  	tests := []struct {
    12  		String cty.Value
    13  		Want   cty.Value
    14  		Err    bool
    15  	}{
    16  		{
    17  			cty.StringVal("YWJjMTIzIT8kKiYoKSctPUB+"),
    18  			cty.StringVal("abc123!?$*&()'-=@~"),
    19  			false,
    20  		},
    21  		{ // Invalid base64 data decoding
    22  			cty.StringVal("this-is-an-invalid-base64-data"),
    23  			cty.UnknownVal(cty.String),
    24  			true,
    25  		},
    26  		{ // Invalid utf-8
    27  			cty.StringVal("\xc3\x28"),
    28  			cty.UnknownVal(cty.String),
    29  			true,
    30  		},
    31  	}
    32  
    33  	for _, test := range tests {
    34  		t.Run(fmt.Sprintf("base64decode(%#v)", test.String), func(t *testing.T) {
    35  			got, err := Base64Decode(test.String)
    36  
    37  			if test.Err {
    38  				if err == nil {
    39  					t.Fatal("succeeded; want error")
    40  				}
    41  				return
    42  			} else if err != nil {
    43  				t.Fatalf("unexpected error: %s", err)
    44  			}
    45  
    46  			if !got.RawEquals(test.Want) {
    47  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
    48  			}
    49  		})
    50  	}
    51  }
    52  
    53  func TestBase64Encode(t *testing.T) {
    54  	tests := []struct {
    55  		String cty.Value
    56  		Want   cty.Value
    57  		Err    bool
    58  	}{
    59  		{
    60  			cty.StringVal("abc123!?$*&()'-=@~"),
    61  			cty.StringVal("YWJjMTIzIT8kKiYoKSctPUB+"),
    62  			false,
    63  		},
    64  	}
    65  
    66  	for _, test := range tests {
    67  		t.Run(fmt.Sprintf("base64encode(%#v)", test.String), func(t *testing.T) {
    68  			got, err := Base64Encode(test.String)
    69  
    70  			if test.Err {
    71  				if err == nil {
    72  					t.Fatal("succeeded; want error")
    73  				}
    74  				return
    75  			} else if err != nil {
    76  				t.Fatalf("unexpected error: %s", err)
    77  			}
    78  
    79  			if !got.RawEquals(test.Want) {
    80  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
    81  			}
    82  		})
    83  	}
    84  }
    85  
    86  func TestBase64Gzip(t *testing.T) {
    87  	tests := []struct {
    88  		String cty.Value
    89  		Want   cty.Value
    90  		Err    bool
    91  	}{
    92  		{
    93  			cty.StringVal("test"),
    94  			cty.StringVal("H4sIAAAAAAAA/ypJLS4BAAAA//8BAAD//wx+f9gEAAAA"),
    95  			false,
    96  		},
    97  	}
    98  
    99  	for _, test := range tests {
   100  		t.Run(fmt.Sprintf("base64gzip(%#v)", test.String), func(t *testing.T) {
   101  			got, err := Base64Gzip(test.String)
   102  
   103  			if test.Err {
   104  				if err == nil {
   105  					t.Fatal("succeeded; want error")
   106  				}
   107  				return
   108  			} else if err != nil {
   109  				t.Fatalf("unexpected error: %s", err)
   110  			}
   111  
   112  			if !got.RawEquals(test.Want) {
   113  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   114  			}
   115  		})
   116  	}
   117  }
   118  
   119  func TestURLEncode(t *testing.T) {
   120  	tests := []struct {
   121  		String cty.Value
   122  		Want   cty.Value
   123  		Err    bool
   124  	}{
   125  		{
   126  			cty.StringVal("abc123-_"),
   127  			cty.StringVal("abc123-_"),
   128  			false,
   129  		},
   130  		{
   131  			cty.StringVal("foo:bar@localhost?foo=bar&bar=baz"),
   132  			cty.StringVal("foo%3Abar%40localhost%3Ffoo%3Dbar%26bar%3Dbaz"),
   133  			false,
   134  		},
   135  		{
   136  			cty.StringVal("mailto:email?subject=this+is+my+subject"),
   137  			cty.StringVal("mailto%3Aemail%3Fsubject%3Dthis%2Bis%2Bmy%2Bsubject"),
   138  			false,
   139  		},
   140  		{
   141  			cty.StringVal("foo/bar"),
   142  			cty.StringVal("foo%2Fbar"),
   143  			false,
   144  		},
   145  	}
   146  
   147  	for _, test := range tests {
   148  		t.Run(fmt.Sprintf("urlencode(%#v)", test.String), func(t *testing.T) {
   149  			got, err := URLEncode(test.String)
   150  
   151  			if test.Err {
   152  				if err == nil {
   153  					t.Fatal("succeeded; want error")
   154  				}
   155  				return
   156  			} else if err != nil {
   157  				t.Fatalf("unexpected error: %s", err)
   158  			}
   159  
   160  			if !got.RawEquals(test.Want) {
   161  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   162  			}
   163  		})
   164  	}
   165  }
   166  
   167  func TestBase64TextEncode(t *testing.T) {
   168  	tests := []struct {
   169  		String   cty.Value
   170  		Encoding cty.Value
   171  		Want     cty.Value
   172  		Err      string
   173  	}{
   174  		{
   175  			cty.StringVal("abc123!?$*&()'-=@~"),
   176  			cty.StringVal("UTF-8"),
   177  			cty.StringVal("YWJjMTIzIT8kKiYoKSctPUB+"),
   178  			``,
   179  		},
   180  		{
   181  			cty.StringVal("abc123!?$*&()'-=@~"),
   182  			cty.StringVal("UTF-16LE"),
   183  			cty.StringVal("YQBiAGMAMQAyADMAIQA/ACQAKgAmACgAKQAnAC0APQBAAH4A"),
   184  			``,
   185  		},
   186  		{
   187  			cty.StringVal("abc123!?$*&()'-=@~"),
   188  			cty.StringVal("CP936"),
   189  			cty.StringVal("YWJjMTIzIT8kKiYoKSctPUB+"),
   190  			``,
   191  		},
   192  		{
   193  			cty.StringVal("abc123!?$*&()'-=@~"),
   194  			cty.StringVal("NOT-EXISTS"),
   195  			cty.UnknownVal(cty.String),
   196  			`"NOT-EXISTS" is not a supported IANA encoding name or alias in this Terraform version`,
   197  		},
   198  		{
   199  			cty.StringVal("🤔"),
   200  			cty.StringVal("cp437"),
   201  			cty.UnknownVal(cty.String),
   202  			`the given string contains characters that cannot be represented in IBM437`,
   203  		},
   204  		{
   205  			cty.UnknownVal(cty.String),
   206  			cty.StringVal("windows-1250"),
   207  			cty.UnknownVal(cty.String),
   208  			``,
   209  		},
   210  		{
   211  			cty.StringVal("hello world"),
   212  			cty.UnknownVal(cty.String),
   213  			cty.UnknownVal(cty.String),
   214  			``,
   215  		},
   216  	}
   217  
   218  	for _, test := range tests {
   219  		t.Run(fmt.Sprintf("textencodebase64(%#v, %#v)", test.String, test.Encoding), func(t *testing.T) {
   220  			got, err := TextEncodeBase64(test.String, test.Encoding)
   221  
   222  			if test.Err != "" {
   223  				if err == nil {
   224  					t.Fatal("succeeded; want error")
   225  				}
   226  				if got, want := err.Error(), test.Err; got != want {
   227  					t.Fatalf("wrong error\ngot:  %s\nwant: %s", got, want)
   228  				}
   229  				return
   230  			} else if err != nil {
   231  				t.Fatalf("unexpected error: %s", err)
   232  			}
   233  
   234  			if !got.RawEquals(test.Want) {
   235  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   236  			}
   237  		})
   238  	}
   239  }
   240  
   241  func TestBase64TextDecode(t *testing.T) {
   242  	tests := []struct {
   243  		String   cty.Value
   244  		Encoding cty.Value
   245  		Want     cty.Value
   246  		Err      string
   247  	}{
   248  		{
   249  			cty.StringVal("YWJjMTIzIT8kKiYoKSctPUB+"),
   250  			cty.StringVal("UTF-8"),
   251  			cty.StringVal("abc123!?$*&()'-=@~"),
   252  			``,
   253  		},
   254  		{
   255  			cty.StringVal("YQBiAGMAMQAyADMAIQA/ACQAKgAmACgAKQAnAC0APQBAAH4A"),
   256  			cty.StringVal("UTF-16LE"),
   257  			cty.StringVal("abc123!?$*&()'-=@~"),
   258  			``,
   259  		},
   260  		{
   261  			cty.StringVal("YWJjMTIzIT8kKiYoKSctPUB+"),
   262  			cty.StringVal("CP936"),
   263  			cty.StringVal("abc123!?$*&()'-=@~"),
   264  			``,
   265  		},
   266  		{
   267  			cty.StringVal("doesn't matter"),
   268  			cty.StringVal("NOT-EXISTS"),
   269  			cty.UnknownVal(cty.String),
   270  			`"NOT-EXISTS" is not a supported IANA encoding name or alias in this Terraform version`,
   271  		},
   272  		{
   273  			cty.StringVal("<invalid base64>"),
   274  			cty.StringVal("cp437"),
   275  			cty.UnknownVal(cty.String),
   276  			`the given value is has an invalid base64 symbol at offset 0`,
   277  		},
   278  		{
   279  			cty.StringVal("gQ=="), // this is 0x81, which is not defined in windows-1250
   280  			cty.StringVal("windows-1250"),
   281  			cty.StringVal("�"),
   282  			`the given string contains symbols that are not defined for windows-1250`,
   283  		},
   284  		{
   285  			cty.UnknownVal(cty.String),
   286  			cty.StringVal("windows-1250"),
   287  			cty.UnknownVal(cty.String),
   288  			``,
   289  		},
   290  		{
   291  			cty.StringVal("YQBiAGMAMQAyADMAIQA/ACQAKgAmACgAKQAnAC0APQBAAH4A"),
   292  			cty.UnknownVal(cty.String),
   293  			cty.UnknownVal(cty.String),
   294  			``,
   295  		},
   296  	}
   297  
   298  	for _, test := range tests {
   299  		t.Run(fmt.Sprintf("textdecodebase64(%#v, %#v)", test.String, test.Encoding), func(t *testing.T) {
   300  			got, err := TextDecodeBase64(test.String, test.Encoding)
   301  
   302  			if test.Err != "" {
   303  				if err == nil {
   304  					t.Fatal("succeeded; want error")
   305  				}
   306  				if got, want := err.Error(), test.Err; got != want {
   307  					t.Fatalf("wrong error\ngot:  %s\nwant: %s", got, want)
   308  				}
   309  				return
   310  			} else if err != nil {
   311  				t.Fatalf("unexpected error: %s", err)
   312  			}
   313  
   314  			if !got.RawEquals(test.Want) {
   315  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   316  			}
   317  		})
   318  	}
   319  }