github.com/hairyhenderson/gomplate/v4@v4.0.0-pre-2.0.20240520121557-362f058f0c93/internal/funcs/test_test.go (about)

     1  package funcs
     2  
     3  import (
     4  	"context"
     5  	"strconv"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func TestCreateTestFuncs(t *testing.T) {
    13  	t.Parallel()
    14  
    15  	for i := 0; i < 10; i++ {
    16  		// Run this a bunch to catch race conditions
    17  		t.Run(strconv.Itoa(i), func(t *testing.T) {
    18  			t.Parallel()
    19  
    20  			ctx := context.Background()
    21  			fmap := CreateTestFuncs(ctx)
    22  			actual := fmap["test"].(func() interface{})
    23  
    24  			assert.Equal(t, ctx, actual().(*TestFuncs).ctx)
    25  		})
    26  	}
    27  }
    28  
    29  func TestAssert(t *testing.T) {
    30  	t.Parallel()
    31  
    32  	f := TestFuncs{ctx: context.Background()}
    33  	_, err := f.Assert(false)
    34  	require.Error(t, err)
    35  
    36  	_, err = f.Assert(true)
    37  	require.NoError(t, err)
    38  
    39  	_, err = f.Assert("foo", true)
    40  	require.NoError(t, err)
    41  
    42  	_, err = f.Assert("foo", "false")
    43  	require.EqualError(t, err, "assertion failed: foo")
    44  }
    45  
    46  func TestRequired(t *testing.T) {
    47  	t.Parallel()
    48  
    49  	f := TestFuncs{ctx: context.Background()}
    50  	errMsg := "can not render template: a required value was not set"
    51  	v, err := f.Required("")
    52  	require.Error(t, err)
    53  	require.EqualError(t, err, errMsg)
    54  	assert.Nil(t, v)
    55  
    56  	v, err = f.Required(nil)
    57  	require.Error(t, err)
    58  	require.EqualError(t, err, errMsg)
    59  	assert.Nil(t, v)
    60  
    61  	errMsg = "hello world"
    62  	v, err = f.Required(errMsg, nil)
    63  	require.Error(t, err)
    64  	require.EqualError(t, err, errMsg)
    65  	assert.Nil(t, v)
    66  
    67  	v, err = f.Required(42, nil)
    68  	require.Error(t, err)
    69  	require.EqualError(t, err, "at <1>: expected string; found int")
    70  	assert.Nil(t, v)
    71  
    72  	v, err = f.Required()
    73  	require.Error(t, err)
    74  	require.EqualError(t, err, "wrong number of args: want 1 or 2, got 0")
    75  	assert.Nil(t, v)
    76  
    77  	v, err = f.Required("", 2, 3)
    78  	require.Error(t, err)
    79  	require.EqualError(t, err, "wrong number of args: want 1 or 2, got 3")
    80  	assert.Nil(t, v)
    81  
    82  	v, err = f.Required(0)
    83  	require.NoError(t, err)
    84  	assert.Zero(t, v)
    85  
    86  	v, err = f.Required("foo")
    87  	require.NoError(t, err)
    88  	assert.Equal(t, "foo", v)
    89  }
    90  
    91  func TestTernary(t *testing.T) {
    92  	t.Parallel()
    93  
    94  	f := TestFuncs{ctx: context.Background()}
    95  	testdata := []struct {
    96  		tval, fval, b interface{}
    97  		expected      interface{}
    98  	}{
    99  		{"foo", 42, false, 42},
   100  		{"foo", 42, "yes", "foo"},
   101  		{false, true, true, false},
   102  	}
   103  	for _, d := range testdata {
   104  		assert.Equal(t, d.expected, f.Ternary(d.tval, d.fval, d.b))
   105  	}
   106  }
   107  
   108  func TestKind(t *testing.T) {
   109  	t.Parallel()
   110  
   111  	f := TestFuncs{ctx: context.Background()}
   112  	testdata := []struct {
   113  		arg      interface{}
   114  		expected string
   115  	}{
   116  		{"foo", "string"},
   117  		{nil, "invalid"},
   118  		{false, "bool"},
   119  		{[]string{"foo", "bar"}, "slice"},
   120  		{map[string]string{"foo": "bar"}, "map"},
   121  		{42, "int"},
   122  		{42.0, "float64"},
   123  		{uint(42), "uint"},
   124  		{struct{}{}, "struct"},
   125  	}
   126  	for _, d := range testdata {
   127  		assert.Equal(t, d.expected, f.Kind(d.arg))
   128  	}
   129  }
   130  
   131  func TestIsKind(t *testing.T) {
   132  	t.Parallel()
   133  
   134  	f := TestFuncs{ctx: context.Background()}
   135  	truedata := []struct {
   136  		arg  interface{}
   137  		kind string
   138  	}{
   139  		{"foo", "string"},
   140  		{nil, "invalid"},
   141  		{false, "bool"},
   142  		{[]string{"foo", "bar"}, "slice"},
   143  		{map[string]string{"foo": "bar"}, "map"},
   144  		{42, "int"},
   145  		{42.0, "float64"},
   146  		{uint(42), "uint"},
   147  		{struct{}{}, "struct"},
   148  		{42.0, "number"},
   149  		{42, "number"},
   150  		{uint32(64000), "number"},
   151  		{complex128(64000), "number"},
   152  	}
   153  	for _, d := range truedata {
   154  		assert.True(t, f.IsKind(d.kind, d.arg))
   155  	}
   156  
   157  	falsedata := []struct {
   158  		arg  interface{}
   159  		kind string
   160  	}{
   161  		{"foo", "bool"},
   162  		{nil, "struct"},
   163  		{false, "string"},
   164  		{[]string{"foo", "bar"}, "map"},
   165  		{map[string]string{"foo": "bar"}, "int"},
   166  		{42, "int64"},
   167  		{42.0, "float32"},
   168  		{uint(42), "int"},
   169  		{struct{}{}, "interface"},
   170  	}
   171  	for _, d := range falsedata {
   172  		assert.False(t, f.IsKind(d.kind, d.arg))
   173  	}
   174  }