github.com/weaviate/weaviate@v1.24.6/usecases/config/config_handler_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 config
    13  
    14  import (
    15  	"fmt"
    16  	"os"
    17  	"testing"
    18  
    19  	"github.com/stretchr/testify/assert"
    20  	"github.com/stretchr/testify/require"
    21  )
    22  
    23  func TestConfig(t *testing.T) {
    24  	t.Run("invalid DefaultVectorDistanceMetric", func(t *testing.T) {
    25  		moduleProvider := &fakeModuleProvider{
    26  			valid: []string{"text2vec-contextionary"},
    27  		}
    28  		config := Config{
    29  			DefaultVectorizerModule:     "text2vec-contextionary",
    30  			DefaultVectorDistanceMetric: "euclidean",
    31  		}
    32  		err := config.Validate(moduleProvider)
    33  		assert.EqualError(
    34  			t,
    35  			err,
    36  			"default vector distance metric: must be one of [\"cosine\", \"dot\", \"l2-squared\", \"manhattan\",\"hamming\"]",
    37  		)
    38  	})
    39  
    40  	t.Run("invalid DefaultVectorizerModule", func(t *testing.T) {
    41  		moduleProvider := &fakeModuleProvider{
    42  			valid: []string{"text2vec-contextionary"},
    43  		}
    44  		config := Config{
    45  			DefaultVectorizerModule:     "contextionary",
    46  			DefaultVectorDistanceMetric: "cosine",
    47  		}
    48  		err := config.Validate(moduleProvider)
    49  		assert.EqualError(
    50  			t,
    51  			err,
    52  			"default vectorizer module: invalid vectorizer \"contextionary\"",
    53  		)
    54  	})
    55  
    56  	t.Run("all valid configurations", func(t *testing.T) {
    57  		moduleProvider := &fakeModuleProvider{
    58  			valid: []string{"text2vec-contextionary"},
    59  		}
    60  		config := Config{
    61  			DefaultVectorizerModule:     "text2vec-contextionary",
    62  			DefaultVectorDistanceMetric: "l2-squared",
    63  		}
    64  		err := config.Validate(moduleProvider)
    65  		assert.Nil(t, err, "should not error")
    66  	})
    67  
    68  	t.Run("without DefaultVectorDistanceMetric", func(t *testing.T) {
    69  		moduleProvider := &fakeModuleProvider{
    70  			valid: []string{"text2vec-contextionary"},
    71  		}
    72  		config := Config{
    73  			DefaultVectorizerModule: "text2vec-contextionary",
    74  		}
    75  		err := config.Validate(moduleProvider)
    76  		assert.Nil(t, err, "should not error")
    77  	})
    78  
    79  	t.Run("with none DefaultVectorizerModule", func(t *testing.T) {
    80  		moduleProvider := &fakeModuleProvider{
    81  			valid: []string{"text2vec-contextionary"},
    82  		}
    83  		config := Config{
    84  			DefaultVectorizerModule: "none",
    85  		}
    86  		err := config.Validate(moduleProvider)
    87  		assert.Nil(t, err, "should not error")
    88  	})
    89  
    90  	t.Run("parse config.yaml file", func(t *testing.T) {
    91  		configFileName := "config.yaml"
    92  		configYaml := `authentication:
    93    apikey:
    94      enabled: true
    95      allowed_keys:
    96        - api-key-1
    97      users:
    98        - readonly@weaviate.io`
    99  
   100  		filepath := fmt.Sprintf("%s/%s", t.TempDir(), configFileName)
   101  		f, err := os.Create(filepath)
   102  		require.Nil(t, err)
   103  		defer f.Close()
   104  		_, err2 := f.WriteString(configYaml)
   105  		require.Nil(t, err2)
   106  
   107  		file, err := os.ReadFile(filepath)
   108  		require.Nil(t, err)
   109  		weaviateConfig := &WeaviateConfig{}
   110  		config, err := weaviateConfig.parseConfigFile(file, configFileName)
   111  		require.Nil(t, err)
   112  
   113  		assert.True(t, config.Authentication.APIKey.Enabled)
   114  		assert.ElementsMatch(t, []string{"api-key-1"}, config.Authentication.APIKey.AllowedKeys)
   115  		assert.ElementsMatch(t, []string{"readonly@weaviate.io"}, config.Authentication.APIKey.Users)
   116  	})
   117  
   118  	t.Run("parse config.yaml file with admin_list and read_only_users", func(t *testing.T) {
   119  		configFileName := "config.yaml"
   120  		configYaml := `authorization:
   121    admin_list:
   122      enabled: true
   123      users:
   124        - userA
   125      read_only_users:
   126        - userA@read.only
   127        - userB@read.only`
   128  
   129  		filepath := fmt.Sprintf("%s/%s", t.TempDir(), configFileName)
   130  		f, err := os.Create(filepath)
   131  		require.Nil(t, err)
   132  		defer f.Close()
   133  		_, err2 := f.WriteString(configYaml)
   134  		require.Nil(t, err2)
   135  
   136  		file, err := os.ReadFile(filepath)
   137  		require.Nil(t, err)
   138  		weaviateConfig := &WeaviateConfig{}
   139  		config, err := weaviateConfig.parseConfigFile(file, configFileName)
   140  		require.Nil(t, err)
   141  
   142  		assert.True(t, config.Authorization.AdminList.Enabled)
   143  		assert.ElementsMatch(t, []string{"userA"}, config.Authorization.AdminList.Users)
   144  		assert.ElementsMatch(t, []string{"userA@read.only", "userB@read.only"}, config.Authorization.AdminList.ReadOnlyUsers)
   145  	})
   146  
   147  	t.Run("parse config.yaml file multiple keys and users", func(t *testing.T) {
   148  		configFileName := "config.yaml"
   149  		configYaml := `authentication:
   150    apikey:
   151      enabled: true
   152      allowed_keys:
   153        - api-key-1
   154        - api-key-2
   155        - api-key-3
   156      users:
   157        - user1@weaviate.io
   158        - user2@weaviate.io`
   159  
   160  		filepath := fmt.Sprintf("%s/%s", t.TempDir(), configFileName)
   161  		f, err := os.Create(filepath)
   162  		require.Nil(t, err)
   163  		defer f.Close()
   164  		_, err2 := f.WriteString(configYaml)
   165  		require.Nil(t, err2)
   166  
   167  		file, err := os.ReadFile(filepath)
   168  		require.Nil(t, err)
   169  		weaviateConfig := &WeaviateConfig{}
   170  		config, err := weaviateConfig.parseConfigFile(file, configFileName)
   171  		require.Nil(t, err)
   172  
   173  		assert.True(t, config.Authentication.APIKey.Enabled)
   174  		assert.ElementsMatch(t, []string{"api-key-1", "api-key-2", "api-key-3"}, config.Authentication.APIKey.AllowedKeys)
   175  		assert.ElementsMatch(t, []string{"user1@weaviate.io", "user2@weaviate.io"}, config.Authentication.APIKey.Users)
   176  	})
   177  }