github.com/hairyhenderson/gomplate/v3@v3.11.7/internal/iohelpers/writers_test.go (about)

     1  package iohelpers
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io"
     7  	"os"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestAllWhitespace(t *testing.T) {
    14  	testdata := []struct {
    15  		in       []byte
    16  		expected bool
    17  	}{
    18  		{[]byte(" "), true},
    19  		{[]byte("foo"), false},
    20  		{[]byte("   \t\n\n\v\r\n"), true},
    21  		{[]byte("   foo   "), false},
    22  	}
    23  
    24  	for _, d := range testdata {
    25  		assert.Equal(t, d.expected, allWhitespace(d.in))
    26  	}
    27  }
    28  
    29  func TestEmptySkipper(t *testing.T) {
    30  	testdata := []struct {
    31  		in    []byte
    32  		empty bool
    33  	}{
    34  		{[]byte(" "), true},
    35  		{[]byte("foo"), false},
    36  		{[]byte("   \t\n\n\v\r\n"), true},
    37  		{[]byte("   foo   "), false},
    38  	}
    39  
    40  	for _, d := range testdata {
    41  		w := newBufferCloser(&bytes.Buffer{})
    42  		opened := false
    43  		f, ok := NewEmptySkipper(func() (io.Writer, error) {
    44  			opened = true
    45  			return w, nil
    46  		}).(*emptySkipper)
    47  
    48  		assert.True(t, ok)
    49  		n, err := f.Write(d.in)
    50  		assert.NoError(t, err)
    51  		assert.Equal(t, len(d.in), n)
    52  		err = f.Close()
    53  		assert.NoError(t, err)
    54  		if d.empty {
    55  			assert.Nil(t, f.w)
    56  			assert.False(t, opened)
    57  		} else {
    58  			assert.NotNil(t, f.w)
    59  			assert.True(t, opened)
    60  			assert.EqualValues(t, d.in, w.Bytes())
    61  		}
    62  	}
    63  }
    64  
    65  func newBufferCloser(b *bytes.Buffer) *bufferCloser {
    66  	return &bufferCloser{b, false}
    67  }
    68  
    69  type bufferCloser struct {
    70  	*bytes.Buffer
    71  
    72  	closed bool
    73  }
    74  
    75  func (b *bufferCloser) Close() error {
    76  	b.closed = true
    77  	return nil
    78  }
    79  
    80  func TestSameSkipper(t *testing.T) {
    81  	testdata := []struct {
    82  		in   []byte
    83  		out  []byte
    84  		same bool
    85  	}{
    86  		{[]byte(" "), []byte(" "), true},
    87  		{[]byte("foo"), []byte("foo"), true},
    88  		{[]byte("foo"), nil, false},
    89  		{[]byte("foo"), []byte("bar"), false},
    90  		{[]byte("foobar"), []byte("foo"), false},
    91  		{[]byte("foo"), []byte("foobar"), false},
    92  	}
    93  
    94  	for _, d := range testdata {
    95  		d := d
    96  		t.Run(fmt.Sprintf("in:%q/out:%q/same:%v", d.in, d.out, d.same), func(t *testing.T) {
    97  			r := bytes.NewBuffer(d.out)
    98  			w := newBufferCloser(&bytes.Buffer{})
    99  			opened := false
   100  			f, ok := SameSkipper(r, func() (io.WriteCloser, error) {
   101  				opened = true
   102  				return w, nil
   103  			}).(*sameSkipper)
   104  			assert.True(t, ok)
   105  
   106  			n, err := f.Write(d.in)
   107  			assert.NoError(t, err)
   108  			assert.Equal(t, len(d.in), n)
   109  			err = f.Close()
   110  			assert.NoError(t, err)
   111  			if d.same {
   112  				assert.Nil(t, f.w)
   113  				assert.False(t, opened)
   114  				assert.Empty(t, w.Bytes())
   115  			} else {
   116  				assert.NotNil(t, f.w)
   117  				assert.True(t, opened)
   118  				assert.EqualValues(t, d.in, w.Bytes())
   119  			}
   120  		})
   121  	}
   122  }
   123  
   124  func TestLazyWriteCloser(t *testing.T) {
   125  	w := newBufferCloser(&bytes.Buffer{})
   126  	opened := false
   127  	l, ok := LazyWriteCloser(func() (io.WriteCloser, error) {
   128  		opened = true
   129  		return w, nil
   130  	}).(*lazyWriteCloser)
   131  	assert.True(t, ok)
   132  
   133  	assert.False(t, opened)
   134  	assert.Nil(t, l.w)
   135  	assert.False(t, w.closed)
   136  
   137  	p := []byte("hello world")
   138  	n, err := l.Write(p)
   139  	assert.NoError(t, err)
   140  	assert.True(t, opened)
   141  	assert.Equal(t, 11, n)
   142  
   143  	err = l.Close()
   144  	assert.NoError(t, err)
   145  	assert.True(t, w.closed)
   146  
   147  	// test error propagation
   148  	l = LazyWriteCloser(func() (io.WriteCloser, error) {
   149  		return nil, os.ErrNotExist
   150  	}).(*lazyWriteCloser)
   151  
   152  	assert.Nil(t, l.w)
   153  
   154  	p = []byte("hello world")
   155  	_, err = l.Write(p)
   156  	assert.Error(t, err)
   157  
   158  	err = l.Close()
   159  	assert.Error(t, err)
   160  }