github.com/oam-dev/kubevela@v1.9.11/pkg/velaql/parse_test.go (about)

     1  /*
     2   Copyright 2021. The KubeVela Authors.
     3  
     4   Licensed under the Apache License, Version 2.0 (the "License");
     5   you may not use this file except in compliance with the License.
     6   You may obtain a copy of the License at
     7  
     8       http://www.apache.org/licenses/LICENSE-2.0
     9  
    10   Unless required by applicable law or agreed to in writing, software
    11   distributed under the License is distributed on an "AS IS" BASIS,
    12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   See the License for the specific language governing permissions and
    14   limitations under the License.
    15  */
    16  
    17  package velaql
    18  
    19  import (
    20  	"testing"
    21  
    22  	"github.com/pkg/errors"
    23  	"github.com/stretchr/testify/assert"
    24  )
    25  
    26  func TestParseVelaQL(t *testing.T) {
    27  	testcases := []struct {
    28  		ql    string
    29  		query QueryView
    30  		err   error
    31  	}{{
    32  		ql:  `view{test=,test1=hello}.output`,
    33  		err: errors.New("key or value in parameter shouldn't be empty"),
    34  	}, {
    35  		ql:  `{test=1,app="name"}.Export`,
    36  		err: errors.New("fail to parse the velaQL"),
    37  	}, {
    38  		ql:  `view.{test=true}.output.value.spec"`,
    39  		err: errors.New("fail to parse the velaQL"),
    40  	}, {
    41  		ql: `view{test=1,app="name"}`,
    42  		query: QueryView{
    43  			View:   "view",
    44  			Export: "status",
    45  		},
    46  		err: nil,
    47  	}, {
    48  		ql: `view{test=1,app="name"}.Export`,
    49  		query: QueryView{
    50  			View:   "view",
    51  			Export: "Export",
    52  		},
    53  		err: nil,
    54  	}, {
    55  		ql: `view{test=true}.output.value.spec`,
    56  		query: QueryView{
    57  			View:   "view",
    58  			Export: "output.value.spec",
    59  		},
    60  		err: nil,
    61  	}, {
    62  		ql: `view{test=true}.output.value[0].spec`,
    63  		query: QueryView{
    64  			View:   "view",
    65  			Export: "output.value[0].spec",
    66  		},
    67  		err: nil,
    68  	}}
    69  
    70  	for _, testcase := range testcases {
    71  		q, err := ParseVelaQL(testcase.ql)
    72  		assert.Equal(t, testcase.err != nil, err != nil)
    73  		if err == nil {
    74  			assert.Equal(t, testcase.query.View, q.View)
    75  			assert.Equal(t, testcase.query.Export, q.Export)
    76  		} else {
    77  			assert.Equal(t, testcase.err.Error(), err.Error())
    78  		}
    79  	}
    80  }
    81  
    82  func TestParseParameter(t *testing.T) {
    83  	testcases := []struct {
    84  		parameter    string
    85  		parameterMap map[string]interface{}
    86  		err          error
    87  	}{{
    88  		parameter: `{    }`,
    89  		err:       errors.New("parameter shouldn't be empty"),
    90  	}, {
    91  		parameter: `{}`,
    92  		err:       errors.New("parameter shouldn't be empty"),
    93  	}, {
    94  		parameter: `{ testString = "pod" , testFloat= , testBoolean=true}`,
    95  		err:       errors.New("key or value in parameter shouldn't be empty"),
    96  	}, {
    97  		parameter: `{testString="pod",testFloat=1000.10,testBoolean=true,testInt=1}`,
    98  		parameterMap: map[string]interface{}{
    99  			"testString":  "pod",
   100  			"testFloat":   1000.1,
   101  			"testBoolean": true,
   102  			"testInt":     int64(1),
   103  		},
   104  		err: nil,
   105  	}, {
   106  		parameter: `{testString="pod",testFloat=1000.10,testBoolean=true,testInt=1,}`,
   107  		parameterMap: map[string]interface{}{
   108  			"testString":  "pod",
   109  			"testFloat":   1000.1,
   110  			"testBoolean": true,
   111  			"testInt":     int64(1),
   112  		},
   113  		err: nil,
   114  	}, {
   115  		parameter: `{ testString = "pod" , testFloat=1000.10 , testBoolean=true , testInt=1, }`,
   116  		parameterMap: map[string]interface{}{
   117  			"testString":  "pod",
   118  			"testFloat":   1000.1,
   119  			"testBoolean": true,
   120  			"testInt":     int64(1),
   121  		},
   122  		err: nil,
   123  	}}
   124  
   125  	for _, testcase := range testcases {
   126  		result, err := ParseParameter(testcase.parameter)
   127  		assert.Equal(t, testcase.err != nil, err != nil)
   128  		if err == nil {
   129  			for k, v := range result {
   130  				assert.Equal(t, testcase.parameterMap[k], v)
   131  			}
   132  		} else {
   133  			assert.Equal(t, testcase.err.Error(), err.Error())
   134  		}
   135  	}
   136  }