goyave.dev/goyave/v4@v4.4.11/parametrizeable_test.go (about)

     1  package goyave
     2  
     3  import (
     4  	"regexp"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/suite"
     8  )
     9  
    10  type ParameterizableTestSuite struct {
    11  	suite.Suite
    12  }
    13  
    14  func (suite *ParameterizableTestSuite) TestCompileParameters() {
    15  	regexCache := make(map[string]*regexp.Regexp, 5)
    16  	p := &parameterizable{}
    17  	p.compileParameters("/product/{id:[0-9]+}", true, regexCache)
    18  	suite.Equal([]string{"id"}, p.parameters)
    19  	suite.NotNil(p.regex)
    20  	suite.True(p.regex.MatchString("/product/666"))
    21  	suite.False(p.regex.MatchString("/product/"))
    22  	suite.False(p.regex.MatchString("/product/qwerty"))
    23  
    24  	p = &parameterizable{}
    25  	p.compileParameters("/product/{id:[0-9]+}/{name}", true, regexCache)
    26  	suite.Equal([]string{"id", "name"}, p.parameters)
    27  	suite.NotNil(p.regex)
    28  	suite.False(p.regex.MatchString("/product/666"))
    29  	suite.False(p.regex.MatchString("/product//"))
    30  	suite.False(p.regex.MatchString("/product/qwerty"))
    31  	suite.False(p.regex.MatchString("/product/qwerty/test"))
    32  	suite.True(p.regex.MatchString("/product/666/test"))
    33  
    34  	suite.Panics(func() { // Empty param, expect error
    35  		p.compileParameters("/product/{}", true, regexCache)
    36  	})
    37  	suite.Panics(func() { // Empty name, expect error
    38  		p.compileParameters("/product/{:[0-9]+}", true, regexCache)
    39  	})
    40  	suite.Panics(func() { // Empty pattern, expect error
    41  		p.compileParameters("/product/{id:}", true, regexCache)
    42  	})
    43  	suite.Panics(func() { // Capturing groups
    44  		p.compileParameters("/product/{name:(.*)}", true, regexCache)
    45  	})
    46  	suite.NotPanics(func() { // Non-capturing groups
    47  		p.compileParameters("/product/{name:(?:.*)}", true, regexCache)
    48  	})
    49  }
    50  
    51  func (suite *ParameterizableTestSuite) TestCompileParametersRouter() {
    52  	regexCache := make(map[string]*regexp.Regexp, 5)
    53  	p := &parameterizable{}
    54  	p.compileParameters("/product/{id:[0-9]+}", false, regexCache)
    55  	suite.Equal([]string{"id"}, p.parameters)
    56  	suite.NotNil(p.regex)
    57  	suite.True(p.regex.MatchString("/product/666"))
    58  	suite.True(p.regex.MatchString("/product/666/extra"))
    59  	suite.False(p.regex.MatchString("/product/"))
    60  	suite.False(p.regex.MatchString("/product/qwerty"))
    61  	suite.False(p.regex.MatchString("/product/qwerty/extra"))
    62  }
    63  
    64  func (suite *ParameterizableTestSuite) TestBraceIndices() {
    65  	p := &parameterizable{}
    66  	str := "/product/{id:[0-9]+}"
    67  	idxs, err := p.braceIndices(str)
    68  	suite.Nil(err)
    69  	suite.Equal([]int{9, 19}, idxs)
    70  
    71  	str = "/product/{id}"
    72  	idxs, err = p.braceIndices(str)
    73  	suite.Nil(err)
    74  	suite.Equal([]int{9, 12}, idxs)
    75  
    76  	str = "/product/{id:[0-9]+}/{name}" // Multiple params
    77  	idxs, err = p.braceIndices(str)
    78  	suite.Nil(err)
    79  	suite.Equal([]int{9, 19, 21, 26}, idxs)
    80  
    81  	str = "/product/{id}/{name:[\\w]+}"
    82  	idxs, err = p.braceIndices(str)
    83  	suite.Nil(err)
    84  	suite.Equal([]int{9, 12, 14, 25}, idxs)
    85  
    86  	str = "/product/{}" // Empty param, expect error
    87  	idxs, err = p.braceIndices(str)
    88  	suite.NotNil(err)
    89  	suite.Equal("empty route parameter in \"/product/{}\"", err.Error())
    90  	suite.Nil(idxs)
    91  
    92  	str = "/product/{id:{[0-9]+}" // Unbalanced
    93  	idxs, err = p.braceIndices(str)
    94  	suite.NotNil(err)
    95  	suite.Equal("unbalanced braces in \"/product/{id:{[0-9]+}\"", err.Error())
    96  	suite.Nil(idxs)
    97  
    98  	str = "/product/{id:}[0-9]+}" // Unbalanced
    99  	idxs, err = p.braceIndices(str)
   100  	suite.NotNil(err)
   101  	suite.Equal("unbalanced braces in \"/product/{id:}[0-9]+}\"", err.Error())
   102  	suite.Nil(idxs)
   103  }
   104  
   105  func (suite *ParameterizableTestSuite) TestMakeParameters() {
   106  	matches := []string{"/product/33/param", "33", "param"}
   107  	names := []string{"id", "name"}
   108  
   109  	p := &parameterizable{}
   110  	params := p.makeParameters(matches, names)
   111  
   112  	for k := 1; k < len(matches); k++ {
   113  		suite.Equal(matches[k], params[names[k-1]])
   114  	}
   115  }
   116  
   117  func (suite *ParameterizableTestSuite) TestRegexCache() {
   118  	regexCache := make(map[string]*regexp.Regexp, 5)
   119  	path := "/product/{id:[0-9]+}"
   120  	regex := "^/product/([0-9]+)$"
   121  	p1 := &parameterizable{}
   122  	p1.compileParameters(path, true, regexCache)
   123  	suite.NotNil(regexCache[regex])
   124  
   125  	p2 := &parameterizable{}
   126  	p2.compileParameters(path, true, regexCache)
   127  	suite.Equal(p1.regex, p2.regex)
   128  	suite.Same(p1.regex, p2.regex)
   129  }
   130  
   131  func (suite *ParameterizableTestSuite) TestGetParameters() {
   132  	p := &parameterizable{
   133  		parameters: []string{"a", "b"},
   134  	}
   135  	params := p.GetParameters()
   136  	suite.Equal(p.parameters, params)
   137  	suite.NotSame(p.parameters, params)
   138  }
   139  
   140  func TestParameterizableTestSuite(t *testing.T) {
   141  	suite.Run(t, new(ParameterizableTestSuite))
   142  }