github.com/weaviate/weaviate@v1.24.6/modules/ner-transformers/additional/tokens/tokens_params_extractor_test.go (about)

     1  //                           _       _
     2  // __      _____  __ ___   ___  __ _| |_ ___
     3  // \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
     4  //  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
     5  //   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
     6  //
     7  //  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
     8  //
     9  //  CONTACT: hello@weaviate.io
    10  //
    11  
    12  package tokens
    13  
    14  import (
    15  	"reflect"
    16  	"testing"
    17  
    18  	"github.com/stretchr/testify/assert"
    19  	"github.com/tailor-inc/graphql/language/ast"
    20  )
    21  
    22  func Test_parseTokenArguments(t *testing.T) {
    23  	type args struct {
    24  		args []*ast.Argument
    25  	}
    26  	tests := []struct {
    27  		name string
    28  		args args
    29  		want *Params
    30  	}{
    31  		{
    32  			name: "Should create with no params",
    33  			args: args{},
    34  			want: &Params{},
    35  		},
    36  		{
    37  			name: "Should create with all params (and distance)",
    38  			args: args{
    39  				args: []*ast.Argument{
    40  					createArg("distance", "0.4"),
    41  					createArg("limit", "1"),
    42  					createListArg("properties", []string{"prop1", "prop2"}),
    43  				},
    44  			},
    45  			want: &Params{
    46  				Properties: []string{"prop1", "prop2"},
    47  				Distance:   ptFloat64(0.4),
    48  				Limit:      ptInt(1),
    49  			},
    50  		},
    51  		{
    52  			name: "Should create with all params (and certainty)",
    53  			args: args{
    54  				args: []*ast.Argument{
    55  					createArg("certainty", "0.4"),
    56  					createArg("limit", "1"),
    57  					createListArg("properties", []string{"prop1", "prop2"}),
    58  				},
    59  			},
    60  			want: &Params{
    61  				Properties: []string{"prop1", "prop2"},
    62  				Certainty:  ptFloat64(0.4),
    63  				Limit:      ptInt(1),
    64  			},
    65  		},
    66  	}
    67  	for _, tt := range tests {
    68  		t.Run(tt.name, func(t *testing.T) {
    69  			p := &TokenProvider{}
    70  			if got := p.parseTokenArguments(tt.args.args); !reflect.DeepEqual(got, tt.want) {
    71  				t.Errorf("parseTokenArguments() = %v, want %v", got, tt.want)
    72  			}
    73  			actual := p.parseTokenArguments(tt.args.args)
    74  			assert.Equal(t, tt.want, actual)
    75  		})
    76  	}
    77  }
    78  
    79  func createArg(name string, value string) *ast.Argument {
    80  	n := ast.Name{
    81  		Value: name,
    82  	}
    83  	val := ast.StringValue{
    84  		Kind:  "Kind",
    85  		Value: value,
    86  	}
    87  	arg := ast.Argument{
    88  		Name:  ast.NewName(&n),
    89  		Kind:  "Kind",
    90  		Value: ast.NewStringValue(&val),
    91  	}
    92  	a := ast.NewArgument(&arg)
    93  	return a
    94  }
    95  
    96  func createListArg(name string, valuesIn []string) *ast.Argument {
    97  	n := ast.Name{
    98  		Value: name,
    99  	}
   100  
   101  	valuesAst := make([]ast.Value, len(valuesIn))
   102  	for i, value := range valuesIn {
   103  		valuesAst[i] = &ast.StringValue{
   104  			Kind:  "Kind",
   105  			Value: value,
   106  		}
   107  	}
   108  	vals := ast.ListValue{
   109  		Kind:   "Kind",
   110  		Values: valuesAst,
   111  	}
   112  	arg := ast.Argument{
   113  		Name:  ast.NewName(&n),
   114  		Kind:  "Kind",
   115  		Value: &vals,
   116  	}
   117  	a := ast.NewArgument(&arg)
   118  	return a
   119  }
   120  
   121  func ptFloat64(in float64) *float64 {
   122  	return &in
   123  }