github.com/hashicorp/terraform-plugin-sdk@v1.17.2/internal/lang/funcs/string_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 TestJoin(t *testing.T) {
    11  	tests := []struct {
    12  		Sep   cty.Value
    13  		Lists []cty.Value
    14  		Want  cty.Value
    15  	}{
    16  		{
    17  			cty.StringVal(" "),
    18  			[]cty.Value{
    19  				cty.ListVal([]cty.Value{
    20  					cty.StringVal("Hello"),
    21  					cty.StringVal("World"),
    22  				}),
    23  			},
    24  			cty.StringVal("Hello World"),
    25  		},
    26  		{
    27  			cty.StringVal(" "),
    28  			[]cty.Value{
    29  				cty.ListVal([]cty.Value{
    30  					cty.StringVal("Hello"),
    31  					cty.StringVal("World"),
    32  				}),
    33  				cty.ListVal([]cty.Value{
    34  					cty.StringVal("Foo"),
    35  					cty.StringVal("Bar"),
    36  				}),
    37  			},
    38  			cty.StringVal("Hello World Foo Bar"),
    39  		},
    40  		{
    41  			cty.StringVal(" "),
    42  			[]cty.Value{
    43  				cty.ListValEmpty(cty.String),
    44  			},
    45  			cty.StringVal(""),
    46  		},
    47  		{
    48  			cty.StringVal(" "),
    49  			[]cty.Value{
    50  				cty.ListValEmpty(cty.String),
    51  				cty.ListValEmpty(cty.String),
    52  				cty.ListValEmpty(cty.String),
    53  			},
    54  			cty.StringVal(""),
    55  		},
    56  		{
    57  			cty.StringVal(" "),
    58  			[]cty.Value{
    59  				cty.ListValEmpty(cty.String),
    60  				cty.ListVal([]cty.Value{
    61  					cty.StringVal("Foo"),
    62  					cty.StringVal("Bar"),
    63  				}),
    64  			},
    65  			cty.StringVal("Foo Bar"),
    66  		},
    67  		{
    68  			cty.UnknownVal(cty.String),
    69  			[]cty.Value{
    70  				cty.ListVal([]cty.Value{
    71  					cty.StringVal("Hello"),
    72  					cty.StringVal("World"),
    73  				}),
    74  			},
    75  			cty.UnknownVal(cty.String),
    76  		},
    77  		{
    78  			cty.StringVal(" "),
    79  			[]cty.Value{
    80  				cty.ListVal([]cty.Value{
    81  					cty.StringVal("Hello"),
    82  					cty.UnknownVal(cty.String),
    83  				}),
    84  			},
    85  			cty.UnknownVal(cty.String),
    86  		},
    87  		{
    88  			cty.StringVal(" "),
    89  			[]cty.Value{
    90  				cty.UnknownVal(cty.List(cty.String)),
    91  			},
    92  			cty.UnknownVal(cty.String),
    93  		},
    94  	}
    95  
    96  	for _, test := range tests {
    97  		t.Run(fmt.Sprintf("Join(%#v, %#v...)", test.Sep, test.Lists), func(t *testing.T) {
    98  			got, err := Join(test.Sep, test.Lists...)
    99  
   100  			if err != nil {
   101  				t.Fatalf("unexpected error: %s", err)
   102  			}
   103  
   104  			if !got.RawEquals(test.Want) {
   105  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   106  			}
   107  		})
   108  	}
   109  }
   110  
   111  func TestSort(t *testing.T) {
   112  	tests := []struct {
   113  		List cty.Value
   114  		Want cty.Value
   115  	}{
   116  		{
   117  			cty.ListValEmpty(cty.String),
   118  			cty.ListValEmpty(cty.String),
   119  		},
   120  		{
   121  			cty.ListVal([]cty.Value{
   122  				cty.StringVal("banana"),
   123  			}),
   124  			cty.ListVal([]cty.Value{
   125  				cty.StringVal("banana"),
   126  			}),
   127  		},
   128  		{
   129  			cty.ListVal([]cty.Value{
   130  				cty.StringVal("banana"),
   131  				cty.StringVal("apple"),
   132  			}),
   133  			cty.ListVal([]cty.Value{
   134  				cty.StringVal("apple"),
   135  				cty.StringVal("banana"),
   136  			}),
   137  		},
   138  		{
   139  			cty.ListVal([]cty.Value{
   140  				cty.StringVal("8"),
   141  				cty.StringVal("9"),
   142  				cty.StringVal("10"),
   143  			}),
   144  			cty.ListVal([]cty.Value{
   145  				cty.StringVal("10"), // lexicographical sort, not numeric sort
   146  				cty.StringVal("8"),
   147  				cty.StringVal("9"),
   148  			}),
   149  		},
   150  		{
   151  			cty.UnknownVal(cty.List(cty.String)),
   152  			cty.UnknownVal(cty.List(cty.String)),
   153  		},
   154  		{
   155  			cty.ListVal([]cty.Value{
   156  				cty.UnknownVal(cty.String),
   157  			}),
   158  			cty.UnknownVal(cty.List(cty.String)),
   159  		},
   160  		{
   161  			cty.ListVal([]cty.Value{
   162  				cty.UnknownVal(cty.String),
   163  				cty.StringVal("banana"),
   164  			}),
   165  			cty.UnknownVal(cty.List(cty.String)),
   166  		},
   167  	}
   168  
   169  	for _, test := range tests {
   170  		t.Run(fmt.Sprintf("Sort(%#v)", test.List), func(t *testing.T) {
   171  			got, err := Sort(test.List)
   172  
   173  			if err != nil {
   174  				t.Fatalf("unexpected error: %s", err)
   175  			}
   176  
   177  			if !got.RawEquals(test.Want) {
   178  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   179  			}
   180  		})
   181  	}
   182  }
   183  func TestSplit(t *testing.T) {
   184  	tests := []struct {
   185  		Sep  cty.Value
   186  		Str  cty.Value
   187  		Want cty.Value
   188  	}{
   189  		{
   190  			cty.StringVal(" "),
   191  			cty.StringVal("Hello World"),
   192  			cty.ListVal([]cty.Value{
   193  				cty.StringVal("Hello"),
   194  				cty.StringVal("World"),
   195  			}),
   196  		},
   197  		{
   198  			cty.StringVal(" "),
   199  			cty.StringVal("Hello"),
   200  			cty.ListVal([]cty.Value{
   201  				cty.StringVal("Hello"),
   202  			}),
   203  		},
   204  		{
   205  			cty.StringVal(" "),
   206  			cty.StringVal(""),
   207  			cty.ListVal([]cty.Value{
   208  				cty.StringVal(""),
   209  			}),
   210  		},
   211  		{
   212  			cty.StringVal(""),
   213  			cty.StringVal(""),
   214  			cty.ListValEmpty(cty.String),
   215  		},
   216  		{
   217  			cty.UnknownVal(cty.String),
   218  			cty.StringVal("Hello World"),
   219  			cty.UnknownVal(cty.List(cty.String)),
   220  		},
   221  		{
   222  			cty.StringVal(" "),
   223  			cty.UnknownVal(cty.String),
   224  			cty.UnknownVal(cty.List(cty.String)),
   225  		},
   226  		{
   227  			cty.UnknownVal(cty.String),
   228  			cty.UnknownVal(cty.String),
   229  			cty.UnknownVal(cty.List(cty.String)),
   230  		},
   231  	}
   232  
   233  	for _, test := range tests {
   234  		t.Run(fmt.Sprintf("Split(%#v, %#v)", test.Sep, test.Str), func(t *testing.T) {
   235  			got, err := Split(test.Sep, test.Str)
   236  
   237  			if err != nil {
   238  				t.Fatalf("unexpected error: %s", err)
   239  			}
   240  
   241  			if !got.RawEquals(test.Want) {
   242  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   243  			}
   244  		})
   245  	}
   246  }
   247  
   248  func TestChomp(t *testing.T) {
   249  	tests := []struct {
   250  		String cty.Value
   251  		Want   cty.Value
   252  		Err    bool
   253  	}{
   254  		{
   255  			cty.StringVal("hello world"),
   256  			cty.StringVal("hello world"),
   257  			false,
   258  		},
   259  		{
   260  			cty.StringVal("goodbye\ncruel\nworld"),
   261  			cty.StringVal("goodbye\ncruel\nworld"),
   262  			false,
   263  		},
   264  		{
   265  			cty.StringVal("goodbye\r\nwindows\r\nworld"),
   266  			cty.StringVal("goodbye\r\nwindows\r\nworld"),
   267  			false,
   268  		},
   269  		{
   270  			cty.StringVal("goodbye\ncruel\nworld\n"),
   271  			cty.StringVal("goodbye\ncruel\nworld"),
   272  			false,
   273  		},
   274  		{
   275  			cty.StringVal("goodbye\ncruel\nworld\n\n\n\n"),
   276  			cty.StringVal("goodbye\ncruel\nworld"),
   277  			false,
   278  		},
   279  		{
   280  			cty.StringVal("goodbye\r\nwindows\r\nworld\r\n"),
   281  			cty.StringVal("goodbye\r\nwindows\r\nworld"),
   282  			false,
   283  		},
   284  		{
   285  			cty.StringVal("goodbye\r\nwindows\r\nworld\r\n\r\n\r\n\r\n"),
   286  			cty.StringVal("goodbye\r\nwindows\r\nworld"),
   287  			false,
   288  		},
   289  	}
   290  
   291  	for _, test := range tests {
   292  		t.Run(fmt.Sprintf("chomp(%#v)", test.String), func(t *testing.T) {
   293  			got, err := Chomp(test.String)
   294  
   295  			if test.Err {
   296  				if err == nil {
   297  					t.Fatal("succeeded; want error")
   298  				}
   299  				return
   300  			} else if err != nil {
   301  				t.Fatalf("unexpected error: %s", err)
   302  			}
   303  
   304  			if !got.RawEquals(test.Want) {
   305  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   306  			}
   307  		})
   308  	}
   309  }
   310  
   311  func TestIndent(t *testing.T) {
   312  	tests := []struct {
   313  		String cty.Value
   314  		Spaces cty.Value
   315  		Want   cty.Value
   316  		Err    bool
   317  	}{
   318  		{
   319  			cty.StringVal(`Fleas:
   320  Adam
   321  Had'em
   322  
   323  E.E. Cummings`),
   324  			cty.NumberIntVal(4),
   325  			cty.StringVal("Fleas:\n    Adam\n    Had'em\n    \n    E.E. Cummings"),
   326  			false,
   327  		},
   328  		{
   329  			cty.StringVal("oneliner"),
   330  			cty.NumberIntVal(4),
   331  			cty.StringVal("oneliner"),
   332  			false,
   333  		},
   334  		{
   335  			cty.StringVal(`#!/usr/bin/env bash
   336  date
   337  pwd`),
   338  			cty.NumberIntVal(4),
   339  			cty.StringVal("#!/usr/bin/env bash\n    date\n    pwd"),
   340  			false,
   341  		},
   342  	}
   343  
   344  	for _, test := range tests {
   345  		t.Run(fmt.Sprintf("indent(%#v, %#v)", test.Spaces, test.String), func(t *testing.T) {
   346  			got, err := Indent(test.Spaces, test.String)
   347  
   348  			if test.Err {
   349  				if err == nil {
   350  					t.Fatal("succeeded; want error")
   351  				}
   352  				return
   353  			} else if err != nil {
   354  				t.Fatalf("unexpected error: %s", err)
   355  			}
   356  
   357  			if !got.RawEquals(test.Want) {
   358  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   359  			}
   360  		})
   361  	}
   362  }
   363  
   364  func TestReplace(t *testing.T) {
   365  	tests := []struct {
   366  		String  cty.Value
   367  		Substr  cty.Value
   368  		Replace cty.Value
   369  		Want    cty.Value
   370  		Err     bool
   371  	}{
   372  		{ // Regular search and replace
   373  			cty.StringVal("hello"),
   374  			cty.StringVal("hel"),
   375  			cty.StringVal("bel"),
   376  			cty.StringVal("bello"),
   377  			false,
   378  		},
   379  		{ // Search string doesn't match
   380  			cty.StringVal("hello"),
   381  			cty.StringVal("nope"),
   382  			cty.StringVal("bel"),
   383  			cty.StringVal("hello"),
   384  			false,
   385  		},
   386  		{ // Regular expression
   387  			cty.StringVal("hello"),
   388  			cty.StringVal("/l/"),
   389  			cty.StringVal("L"),
   390  			cty.StringVal("heLLo"),
   391  			false,
   392  		},
   393  		{
   394  			cty.StringVal("helo"),
   395  			cty.StringVal("/(l)/"),
   396  			cty.StringVal("$1$1"),
   397  			cty.StringVal("hello"),
   398  			false,
   399  		},
   400  		{ // Bad regexp
   401  			cty.StringVal("hello"),
   402  			cty.StringVal("/(l/"),
   403  			cty.StringVal("$1$1"),
   404  			cty.UnknownVal(cty.String),
   405  			true,
   406  		},
   407  	}
   408  
   409  	for _, test := range tests {
   410  		t.Run(fmt.Sprintf("replace(%#v, %#v, %#v)", test.String, test.Substr, test.Replace), func(t *testing.T) {
   411  			got, err := Replace(test.String, test.Substr, test.Replace)
   412  
   413  			if test.Err {
   414  				if err == nil {
   415  					t.Fatal("succeeded; want error")
   416  				}
   417  				return
   418  			} else if err != nil {
   419  				t.Fatalf("unexpected error: %s", err)
   420  			}
   421  
   422  			if !got.RawEquals(test.Want) {
   423  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   424  			}
   425  		})
   426  	}
   427  }
   428  
   429  func TestTitle(t *testing.T) {
   430  	tests := []struct {
   431  		String cty.Value
   432  		Want   cty.Value
   433  		Err    bool
   434  	}{
   435  		{
   436  			cty.StringVal("hello"),
   437  			cty.StringVal("Hello"),
   438  			false,
   439  		},
   440  		{
   441  			cty.StringVal("hello world"),
   442  			cty.StringVal("Hello World"),
   443  			false,
   444  		},
   445  		{
   446  			cty.StringVal(""),
   447  			cty.StringVal(""),
   448  			false,
   449  		},
   450  	}
   451  
   452  	for _, test := range tests {
   453  		t.Run(fmt.Sprintf("title(%#v)", test.String), func(t *testing.T) {
   454  			got, err := Title(test.String)
   455  
   456  			if test.Err {
   457  				if err == nil {
   458  					t.Fatal("succeeded; want error")
   459  				}
   460  				return
   461  			} else if err != nil {
   462  				t.Fatalf("unexpected error: %s", err)
   463  			}
   464  
   465  			if !got.RawEquals(test.Want) {
   466  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   467  			}
   468  		})
   469  	}
   470  }
   471  
   472  func TestTrimSpace(t *testing.T) {
   473  	tests := []struct {
   474  		String cty.Value
   475  		Want   cty.Value
   476  		Err    bool
   477  	}{
   478  		{
   479  			cty.StringVal(" hello "),
   480  			cty.StringVal("hello"),
   481  			false,
   482  		},
   483  		{
   484  			cty.StringVal(""),
   485  			cty.StringVal(""),
   486  			false,
   487  		},
   488  	}
   489  
   490  	for _, test := range tests {
   491  		t.Run(fmt.Sprintf("trimspace(%#v)", test.String), func(t *testing.T) {
   492  			got, err := TrimSpace(test.String)
   493  
   494  			if test.Err {
   495  				if err == nil {
   496  					t.Fatal("succeeded; want error")
   497  				}
   498  				return
   499  			} else if err != nil {
   500  				t.Fatalf("unexpected error: %s", err)
   501  			}
   502  
   503  			if !got.RawEquals(test.Want) {
   504  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   505  			}
   506  		})
   507  	}
   508  }