fsslice_test.go

Documentation: sigs.k8s.io/kustomize/api/filters/fsslice

     1  // Copyright 2019 The Kubernetes Authors.
     2  // SPDX-License-Identifier: Apache-2.0
     3  
     4  package fsslice_test
     5  
     6  import (
     7  	"bytes"
     8  	"strings"
     9  	"testing"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  	"sigs.k8s.io/kustomize/api/filters/filtersutil"
    13  	. "sigs.k8s.io/kustomize/api/filters/fsslice"
    14  	"sigs.k8s.io/kustomize/kyaml/kio"
    15  	"sigs.k8s.io/kustomize/kyaml/yaml"
    16  )
    17  
    18  type TestCase struct {
    19  	input    string
    20  	expected string
    21  	filter   Filter
    22  	fsSlice  string
    23  	error    string
    24  }
    25  
    26  var tests = map[string]TestCase{
    27  	"empty": {
    28  		fsSlice: `
    29  `,
    30  		input: `
    31  apiVersion: foo/v1
    32  kind: Bar
    33  `,
    34  		expected: `
    35  apiVersion: foo/v1
    36  kind: Bar
    37  `,
    38  		filter: Filter{
    39  			SetValue:   filtersutil.SetScalar("e"),
    40  			CreateKind: yaml.ScalarNode,
    41  		},
    42  	},
    43  	"two": {
    44  		fsSlice: `
    45  - path: a/b
    46    group: foo
    47    version: v1
    48    create: true
    49    kind: Bar
    50  - path: q/r[]/s/t
    51    group: foo
    52    version: v1
    53    create: true
    54    kind: Bar
    55  `,
    56  		input: `
    57  apiVersion: foo/v1
    58  kind: Bar
    59  q:
    60    r:
    61    - s: {}
    62  `,
    63  		expected: `
    64  apiVersion: foo/v1
    65  kind: Bar
    66  q:
    67    r:
    68    - s: {t: e}
    69  a:
    70    b: e
    71  `,
    72  		filter: Filter{
    73  			SetValue:   filtersutil.SetScalar("e"),
    74  			CreateKind: yaml.ScalarNode,
    75  		},
    76  	},
    77  }
    78  
    79  func TestFilter(t *testing.T) {
    80  	for name := range tests {
    81  		test := tests[name]
    82  		t.Run(name, func(t *testing.T) {
    83  			err := yaml.Unmarshal([]byte(test.fsSlice), &test.filter.FsSlice)
    84  			if !assert.NoError(t, err) {
    85  				t.FailNow()
    86  			}
    87  
    88  			out := &bytes.Buffer{}
    89  			rw := &kio.ByteReadWriter{
    90  				Reader:                bytes.NewBufferString(test.input),
    91  				Writer:                out,
    92  				OmitReaderAnnotations: true,
    93  			}
    94  
    95  			// run the filter
    96  			err = kio.Pipeline{
    97  				Inputs:  []kio.Reader{rw},
    98  				Filters: []kio.Filter{kio.FilterAll(test.filter)},
    99  				Outputs: []kio.Writer{rw},
   100  			}.Execute()
   101  			if test.error != "" {
   102  				if !assert.EqualError(t, err, test.error) {
   103  					t.FailNow()
   104  				}
   105  				// stop rest of test
   106  				return
   107  			}
   108  
   109  			if !assert.NoError(t, err) {
   110  				t.FailNow()
   111  			}
   112  
   113  			// check results
   114  			if !assert.Equal(t,
   115  				strings.TrimSpace(test.expected),
   116  				strings.TrimSpace(out.String())) {
   117  				t.FailNow()
   118  			}
   119  		})
   120  	}
   121  }
   122
View as plain text