github.com/hairyhenderson/templater@v3.5.0+incompatible/funcs/strings_test.go (about)

     1  package funcs
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  )
     8  
     9  func TestReplaceAll(t *testing.T) {
    10  	sf := &StringFuncs{}
    11  
    12  	assert.Equal(t, "Replaced",
    13  		sf.ReplaceAll("Orig", "Replaced", "Orig"))
    14  	assert.Equal(t, "ReplacedReplaced",
    15  		sf.ReplaceAll("Orig", "Replaced", "OrigOrig"))
    16  }
    17  
    18  func TestIndent(t *testing.T) {
    19  	sf := &StringFuncs{}
    20  
    21  	testdata := []struct {
    22  		args []interface{}
    23  		out  string
    24  	}{
    25  		{[]interface{}{"foo\nbar\nbaz"}, " foo\n bar\n baz"},
    26  		{[]interface{}{"  ", "foo\nbar\nbaz"}, "  foo\n  bar\n  baz"},
    27  		{[]interface{}{3, "-", "foo\nbar\nbaz"}, "---foo\n---bar\n---baz"},
    28  		{[]interface{}{3, "foo\nbar\nbaz"}, "   foo\n   bar\n   baz"},
    29  	}
    30  
    31  	for _, d := range testdata {
    32  		out, err := sf.Indent(d.args...)
    33  		assert.NoError(t, err)
    34  		assert.Equal(t, d.out, out)
    35  	}
    36  }
    37  
    38  func TestTrimPrefix(t *testing.T) {
    39  	sf := &StringFuncs{}
    40  
    41  	assert.Equal(t, "Bar",
    42  		sf.TrimPrefix("Foo", "FooBar"))
    43  }
    44  
    45  func TestTrunc(t *testing.T) {
    46  	sf := &StringFuncs{}
    47  	assert.Equal(t, "", sf.Trunc(5, ""))
    48  	assert.Equal(t, "", sf.Trunc(0, nil))
    49  	assert.Equal(t, "123", sf.Trunc(3, 123456789))
    50  	assert.Equal(t, "hello, world", sf.Trunc(-1, "hello, world"))
    51  }
    52  
    53  func TestAbbrev(t *testing.T) {
    54  	sf := &StringFuncs{}
    55  	_, err := sf.Abbrev()
    56  	assert.Error(t, err)
    57  
    58  	_, err = sf.Abbrev("foo")
    59  	assert.Error(t, err)
    60  
    61  	s, err := sf.Abbrev(3, "foo")
    62  	assert.NoError(t, err)
    63  	assert.Equal(t, "foo", s)
    64  
    65  	s, err = sf.Abbrev(2, 6, "foobar")
    66  	assert.NoError(t, err)
    67  	assert.Equal(t, "foobar", s)
    68  
    69  	s, err = sf.Abbrev(6, 9, "foobarbazquxquux")
    70  	assert.NoError(t, err)
    71  	assert.Equal(t, "...baz...", s)
    72  }
    73  
    74  func TestSlug(t *testing.T) {
    75  	sf := &StringFuncs{}
    76  	s := sf.Slug(nil)
    77  	assert.Equal(t, "nil", s)
    78  
    79  	s = sf.Slug(0)
    80  	assert.Equal(t, "0", s)
    81  
    82  	s = sf.Slug(1.85e-5)
    83  	assert.Equal(t, "1-85e-05", s)
    84  
    85  	s = sf.Slug("Hello, World!")
    86  	assert.Equal(t, "hello-world", s)
    87  
    88  	s = sf.Slug("foo@example.com")
    89  	assert.Equal(t, "fooatexample-com", s)
    90  
    91  	s = sf.Slug("rock & roll!")
    92  	assert.Equal(t, "rock-and-roll", s)
    93  
    94  	s = sf.Slug("foo@example.com")
    95  	assert.Equal(t, "fooatexample-com", s)
    96  
    97  	s = sf.Slug(`100%`)
    98  	assert.Equal(t, "100", s)
    99  }
   100  
   101  func TestSort(t *testing.T) {
   102  	sf := &StringFuncs{}
   103  	in := []string{"foo", "bar", "baz"}
   104  	out := []string{"bar", "baz", "foo"}
   105  	assert.Equal(t, out, must(sf.Sort(in)))
   106  
   107  	assert.Equal(t, out, must(sf.Sort([]interface{}{"foo", "bar", "baz"})))
   108  }
   109  
   110  func TestQuote(t *testing.T) {
   111  	sf := &StringFuncs{}
   112  	testdata := []struct {
   113  		in  interface{}
   114  		out string
   115  	}{
   116  		{``, `""`},
   117  		{`foo`, `"foo"`},
   118  		{nil, `"nil"`},
   119  		{123.4, `"123.4"`},
   120  		{`hello "world"`, `"hello \"world\""`},
   121  		{`it's its`, `"it's its"`},
   122  	}
   123  
   124  	for _, d := range testdata {
   125  		assert.Equal(t, d.out, sf.Quote(d.in))
   126  	}
   127  }
   128  
   129  func TestSquote(t *testing.T) {
   130  	sf := &StringFuncs{}
   131  	testdata := []struct {
   132  		in  interface{}
   133  		out string
   134  	}{
   135  		{``, `''`},
   136  		{`foo`, `'foo'`},
   137  		{nil, `'nil'`},
   138  		{123.4, `'123.4'`},
   139  		{`hello "world"`, `'hello "world"'`},
   140  		{`it's its`, `'it''s its'`},
   141  	}
   142  
   143  	for _, d := range testdata {
   144  		assert.Equal(t, d.out, sf.Squote(d.in))
   145  	}
   146  }
   147  
   148  func TestRuneCount(t *testing.T) {
   149  	sf := &StringFuncs{}
   150  
   151  	n, err := sf.RuneCount("")
   152  	assert.NoError(t, err)
   153  	assert.Equal(t, 0, n)
   154  
   155  	n, err = sf.RuneCount("foo")
   156  	assert.NoError(t, err)
   157  	assert.Equal(t, 3, n)
   158  
   159  	n, err = sf.RuneCount("foo", "bar")
   160  	assert.NoError(t, err)
   161  	assert.Equal(t, 6, n)
   162  
   163  	n, err = sf.RuneCount(42, true)
   164  	assert.NoError(t, err)
   165  	assert.Equal(t, 6, n)
   166  
   167  	n, err = sf.RuneCount("😂\U0001F602")
   168  	assert.NoError(t, err)
   169  	assert.Equal(t, 2, n)
   170  
   171  	n, err = sf.RuneCount("\U0001F600", 3.14)
   172  	assert.NoError(t, err)
   173  	assert.Equal(t, 5, n)
   174  }