github.com/grafana/tanka@v0.26.1-0.20240506093700-c22cfc35c21a/pkg/jsonnet/native/funcs_test.go (about)

     1  package native
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  // callNative calls a native function used by jsonnet VM.
    12  func callNative(name string, data []interface{}) (res interface{}, err error, callerr error) {
    13  	for _, fun := range Funcs() {
    14  		if fun.Name == name {
    15  			// Call the function
    16  			ret, err := fun.Func(data)
    17  			return ret, err, nil
    18  		}
    19  	}
    20  
    21  	return nil, nil, fmt.Errorf("could not find native function %s", name)
    22  }
    23  
    24  func TestSha256(t *testing.T) {
    25  	ret, err, callerr := callNative("sha256", []interface{}{"foo"})
    26  
    27  	assert.Empty(t, callerr)
    28  	assert.Equal(t, "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae", ret)
    29  	assert.Empty(t, err)
    30  }
    31  
    32  func TestParseJSONEmptyDict(t *testing.T) {
    33  	ret, err, callerr := callNative("parseJson", []interface{}{"{}"})
    34  
    35  	assert.Empty(t, callerr)
    36  	assert.Equal(t, map[string]interface{}{}, ret)
    37  	assert.Empty(t, err)
    38  }
    39  
    40  func TestParseJSONkeyValuet(t *testing.T) {
    41  	ret, err, callerr := callNative("parseJson", []interface{}{"{\"a\": 47}"})
    42  
    43  	assert.Empty(t, callerr)
    44  	assert.Equal(t, map[string]interface{}{"a": 47.0}, ret)
    45  	assert.Empty(t, err)
    46  }
    47  
    48  func TestParseJSONInvalid(t *testing.T) {
    49  	ret, err, callerr := callNative("parseJson", []interface{}{""})
    50  
    51  	assert.Empty(t, callerr)
    52  	assert.Empty(t, ret)
    53  	assert.IsType(t, &json.SyntaxError{}, err)
    54  }
    55  
    56  func TestParseYAMLEmpty(t *testing.T) {
    57  	ret, err, callerr := callNative("parseYaml", []interface{}{""})
    58  
    59  	assert.Empty(t, callerr)
    60  	assert.Equal(t, []interface{}{}, ret)
    61  	assert.Empty(t, err)
    62  }
    63  
    64  func TestParseYAMLKeyValue(t *testing.T) {
    65  	ret, err, callerr := callNative("parseYaml", []interface{}{"a: 47"})
    66  
    67  	assert.Empty(t, callerr)
    68  	assert.Equal(t, []interface{}{map[string]interface{}{"a": 47.0}}, ret)
    69  	assert.Empty(t, err)
    70  }
    71  
    72  func TestParseYAMLInvalid(t *testing.T) {
    73  	ret, err, callerr := callNative("parseYaml", []interface{}{"'"})
    74  
    75  	assert.Empty(t, callerr)
    76  	assert.Empty(t, ret)
    77  	assert.NotEmpty(t, err)
    78  }
    79  
    80  func TestManifestJSONFromJSON(t *testing.T) {
    81  	ret, err, callerr := callNative("manifestJsonFromJson", []interface{}{"{}", float64(4)})
    82  
    83  	assert.Empty(t, callerr)
    84  	assert.Equal(t, "{}\n", ret)
    85  	assert.Empty(t, err)
    86  }
    87  
    88  func TestManifestJSONFromJSONReindent(t *testing.T) {
    89  	ret, err, callerr := callNative("manifestJsonFromJson", []interface{}{"{ \"a\": 47}", float64(4)})
    90  
    91  	assert.Empty(t, callerr)
    92  	assert.Equal(t, "{\n    \"a\": 47\n}\n", ret)
    93  	assert.Empty(t, err)
    94  }
    95  
    96  func TestManifestJSONFromJSONInvalid(t *testing.T) {
    97  	ret, err, callerr := callNative("manifestJsonFromJson", []interface{}{"", float64(4)})
    98  
    99  	assert.Empty(t, callerr)
   100  	assert.Empty(t, ret)
   101  	assert.NotEmpty(t, err)
   102  }
   103  
   104  func TestManifestYAMLFromJSONEmpty(t *testing.T) {
   105  	ret, err, callerr := callNative("manifestYamlFromJson", []interface{}{"{}"})
   106  
   107  	assert.Empty(t, callerr)
   108  	assert.Equal(t, "{}\n", ret)
   109  	assert.Empty(t, err)
   110  }
   111  
   112  func TestManifestYAMLFromJSONKeyValue(t *testing.T) {
   113  	ret, err, callerr := callNative("manifestYamlFromJson", []interface{}{"{ \"a\": 47}"})
   114  
   115  	assert.Empty(t, callerr)
   116  	assert.Equal(t, "a: 47\n", ret)
   117  	assert.Empty(t, err)
   118  }
   119  
   120  func TestManifestYAMLFromJSONList(t *testing.T) {
   121  	ret, err, callerr := callNative("manifestYamlFromJson", []interface{}{`{ "list": ["a", "b", "c"]}`})
   122  
   123  	assert.Empty(t, callerr)
   124  	assert.Equal(t, `list:
   125      - a
   126      - b
   127      - c
   128  `, ret)
   129  	assert.Empty(t, err)
   130  }
   131  
   132  func TestManifestYAMLFromJSONInvalid(t *testing.T) {
   133  	ret, err, callerr := callNative("manifestYamlFromJson", []interface{}{""})
   134  
   135  	assert.Empty(t, callerr)
   136  	assert.Empty(t, ret)
   137  	assert.NotEmpty(t, err)
   138  }
   139  
   140  func TestEscapeStringRegex(t *testing.T) {
   141  	ret, err, callerr := callNative("escapeStringRegex", []interface{}{""})
   142  
   143  	assert.Empty(t, callerr)
   144  	assert.Equal(t, "", ret)
   145  	assert.Empty(t, err)
   146  }
   147  
   148  func TestEscapeStringRegexValue(t *testing.T) {
   149  	ret, err, callerr := callNative("escapeStringRegex", []interface{}{"([0-9]+).*\\s"})
   150  
   151  	assert.Empty(t, callerr)
   152  	assert.Equal(t, "\\(\\[0-9\\]\\+\\)\\.\\*\\\\s", ret)
   153  	assert.Empty(t, err)
   154  }
   155  
   156  func TestEscapeStringRegexInvalid(t *testing.T) {
   157  	ret, err, callerr := callNative("escapeStringRegex", []interface{}{"([0-9]+"})
   158  
   159  	assert.Empty(t, callerr)
   160  	assert.Equal(t, "\\(\\[0-9\\]\\+", ret)
   161  	assert.Empty(t, err)
   162  }
   163  
   164  func TestRegexMatch(t *testing.T) {
   165  	ret, err, callerr := callNative("regexMatch", []interface{}{"", "a"})
   166  
   167  	assert.Empty(t, callerr)
   168  	assert.Equal(t, true, ret)
   169  	assert.Empty(t, err)
   170  }
   171  
   172  func TestRegexMatchNoMatch(t *testing.T) {
   173  	ret, err, callerr := callNative("regexMatch", []interface{}{"a", "b"})
   174  
   175  	assert.Empty(t, callerr)
   176  	assert.Equal(t, false, ret)
   177  	assert.Empty(t, err)
   178  }
   179  
   180  func TestRegexMatchInvalidRegex(t *testing.T) {
   181  	ret, err, callerr := callNative("regexMatch", []interface{}{"[0-", "b"})
   182  
   183  	assert.Empty(t, callerr)
   184  	assert.Empty(t, ret)
   185  	assert.NotEmpty(t, err)
   186  }
   187  
   188  func TestRegexSubstNoChange(t *testing.T) {
   189  	ret, err, callerr := callNative("regexSubst", []interface{}{"a", "b", "c"})
   190  
   191  	assert.Empty(t, callerr)
   192  	assert.Equal(t, "b", ret)
   193  	assert.Empty(t, err)
   194  }
   195  
   196  func TestRegexSubstValid(t *testing.T) {
   197  	ret, err, callerr := callNative("regexSubst", []interface{}{"p[^m]*", "pm", "poe"})
   198  
   199  	assert.Empty(t, callerr)
   200  	assert.Equal(t, "poem", ret)
   201  	assert.Empty(t, err)
   202  }
   203  
   204  func TestRegexSubstInvalid(t *testing.T) {
   205  	ret, err, callerr := callNative("regexSubst", []interface{}{"p[^m*", "pm", "poe"})
   206  
   207  	assert.Empty(t, callerr)
   208  	assert.Empty(t, ret)
   209  	assert.NotEmpty(t, err)
   210  }