OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
package controller
import (
"context"
"os"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"sigs.k8s.io/controller-runtime/pkg/client/fake"
)
func TestEnvVarManager_ThreeLevelPriority(t *testing.T) {
// Create a manager with some defaults
manager := &EnvVarManager{
DefaultLangflowEnvVars: map[string]string{
"VAR_A": "default_a",
"VAR_B": "default_b",
"VAR_C": "default_c",
},
}
// Set up operator environment variables (level 2)
_ = os.Setenv("OPTLF_VAR_B", "operator_b")
_ = os.Setenv("OPTLF_VAR_C", "operator_c")
defer func() {
_ = os.Unsetenv("OPTLF_VAR_B")
_ = os.Unsetenv("OPTLF_VAR_C")
}()
// CR spec env vars (level 3 - highest priority)
crEnvVars := []corev1.EnvVar{
{Name: "VAR_C", Value: "cr_c"},
}
// No secrets to resolve, so ctx and client can be nil
result, err := manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", crEnvVars)
require.NoError(t, err)
// Verify priority:
// VAR_A: only in defaults -> should be "default_a"
// VAR_B: in defaults and operator env -> should be "operator_b"
// VAR_C: in all three levels -> should be "cr_c" (highest priority)
assert.Equal(t, "default_a", result["VAR_A"], "VAR_A should use default value")
assert.Equal(t, "operator_b", result["VAR_B"], "VAR_B should use operator env value")
assert.Equal(t, "cr_c", result["VAR_C"], "VAR_C should use CR value (highest priority)")
}
func TestEnvVarManager_OperatorEnvPrefixFiltering(t *testing.T) {
manager := &EnvVarManager{
DefaultLangflowEnvVars: map[string]string{
"TEST_VAR": "default",
},
}
// Set various env vars - only OPTLF_ should be picked up
_ = os.Setenv("OPTLF_TEST_VAR", "langflow_value")
_ = os.Setenv("OPTORBE_TEST_VAR", "backend_value")
_ = os.Setenv("OPTORFE_TEST_VAR", "frontend_value")
_ = os.Setenv("RANDOM_VAR", "random_value")
defer func() {
_ = os.Unsetenv("OPTLF_TEST_VAR")
_ = os.Unsetenv("OPTORBE_TEST_VAR")
_ = os.Unsetenv("OPTORFE_TEST_VAR")
_ = os.Unsetenv("RANDOM_VAR")
}()
// Test Langflow - should only pick up OPTLF_
lfResult, err := manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", nil)
require.NoError(t, err)
assert.Equal(t, "langflow_value", lfResult["TEST_VAR"], "Langflow should use OPTLF_ prefixed var")
// Test Backend - should only pick up OPTORBE_
manager.DefaultOpenRagBEEnvVars = map[string]string{"TEST_VAR": "default"}
beResult, err := manager.GetBackendEnvVars(context.Background(), nil, "test-ns", nil)
require.NoError(t, err)
assert.Equal(t, "backend_value", beResult["TEST_VAR"], "Backend should use OPTORBE_ prefixed var")
// Test Frontend - should only pick up OPTORFE_
manager.DefaultOpenRagFEEnvVars = map[string]string{"TEST_VAR": "default"}
feResult, err := manager.GetFrontendEnvVars(context.Background(), nil, "test-ns", nil)
require.NoError(t, err)
assert.Equal(t, "frontend_value", feResult["TEST_VAR"], "Frontend should use OPTORFE_ prefixed var")
}
func TestEnvVarManager_CREnvVarOverride(t *testing.T) {
manager := &EnvVarManager{
DefaultLangflowEnvVars: map[string]string{
"DATABASE_URL": "sqlite:///default.db",
"LOG_LEVEL": "INFO",
},
}
_ = os.Setenv("OPTLF_DATABASE_URL", "sqlite:///operator.db")
defer func() {
_ = os.Unsetenv("OPTLF_DATABASE_URL")
}()
// CR overrides everything
crEnvVars := []corev1.EnvVar{
{Name: "DATABASE_URL", Value: "postgresql://cr.db"},
{Name: "LOG_LEVEL", Value: "DEBUG"},
}
result, err := manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", crEnvVars)
require.NoError(t, err)
assert.Equal(t, "postgresql://cr.db", result["DATABASE_URL"], "CR should override operator env")
assert.Equal(t, "DEBUG", result["LOG_LEVEL"], "CR should override defaults")
}
// TestEnvVarManager_CREmptyValueOverridesDefault verifies that an explicit empty string
// in the CR is respected as-is and overrides any default or operator-set value.
func TestEnvVarManager_CREmptyValueOverridesDefault(t *testing.T) {
manager := &EnvVarManager{
DefaultLangflowEnvVars: map[string]string{
"LANGFLOW_KEY": "some-default-key",
"SEGMENT_WRITES": "default-segment-key",
},
}
_ = os.Setenv("OPTLF_LANGFLOW_KEY", "operator-key")
defer func() {
err := os.Unsetenv("OPTLF_LANGFLOW_KEY")
require.NoError(t, err)
}()
crEnvVars := []corev1.EnvVar{
{Name: "LANGFLOW_KEY", Value: ""}, // explicit empty — must win
{Name: "SEGMENT_WRITES", Value: ""}, // overrides default
}
result, err := manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", crEnvVars)
require.NoError(t, err)
assert.Equal(t, "", result["LANGFLOW_KEY"], "CR empty string must override operator env value")
assert.Equal(t, "", result["SEGMENT_WRITES"], "CR empty string must override default value")
}
// TestEnvVarManager_CRValueIsLiterallyRespected verifies that CR values containing
// special characters (spaces, quotes, hashes, URLs) are passed through without modification.
func TestEnvVarManager_CRValueIsLiterallyRespected(t *testing.T) {
manager := &EnvVarManager{
DefaultOpenRagBEEnvVars: map[string]string{
"DATABASE_URL": "default-url",
"DESCRIPTION": "default-desc",
"API_KEY": "default-key",
},
}
crEnvVars := []corev1.EnvVar{
{Name: "DATABASE_URL", Value: "postgresql://user:p@ss#word@host:5432/db"},
{Name: "DESCRIPTION", Value: "hello world with spaces"},
{Name: "API_KEY", Value: "key with \"quotes\" inside"},
}
result, err := manager.GetBackendEnvVars(context.Background(), nil, "test-ns", crEnvVars)
require.NoError(t, err)
assert.Equal(t, "postgresql://user:p@ss#word@host:5432/db", result["DATABASE_URL"])
assert.Equal(t, "hello world with spaces", result["DESCRIPTION"])
assert.Equal(t, `key with "quotes" inside`, result["API_KEY"])
}
func TestEnvVarManager_EmptyCREnvVars(t *testing.T) {
manager := &EnvVarManager{
DefaultLangflowEnvVars: map[string]string{
"VAR1": "default1",
},
}
result, err := manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", nil)
require.NoError(t, err)
assert.Equal(t, "default1", result["VAR1"], "Should use defaults when no CR env vars")
result, err = manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", []corev1.EnvVar{})
require.NoError(t, err)
assert.Equal(t, "default1", result["VAR1"], "Should use defaults when empty CR env vars")
}
func TestEnvVarManager_CREnvVarWithValueFrom(t *testing.T) {
// Create scheme and fake client with a secret
s := runtime.NewScheme()
_ = corev1.AddToScheme(s)
secret := &corev1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: "my-secret",
Namespace: "test-ns",
},
Data: map[string][]byte{
"key": []byte("resolved_secret_value"),
},
}
fakeClient := fake.NewClientBuilder().WithScheme(s).WithObjects(secret).Build()
manager := &EnvVarManager{
DefaultLangflowEnvVars: map[string]string{
"SECRET_KEY": "default_secret",
},
}
// CR env var with valueFrom should be RESOLVED (new behavior)
crEnvVars := []corev1.EnvVar{
{
Name: "SECRET_KEY",
ValueFrom: &corev1.EnvVarSource{
SecretKeyRef: &corev1.SecretKeySelector{
LocalObjectReference: corev1.LocalObjectReference{Name: "my-secret"},
Key: "key",
},
},
},
}
result, err := manager.GetLangflowEnvVars(context.Background(), fakeClient, "test-ns", crEnvVars)
require.NoError(t, err)
// Should resolve secret and use the resolved value (NEW behavior)
assert.Equal(t, "resolved_secret_value", result["SECRET_KEY"], "Should resolve secret from valueFrom")
}
func TestEnvVarManager_BuildEnvFileContent(t *testing.T) {
manager := &EnvVarManager{}
envVars := map[string]string{
"VAR1": "value1",
"VAR2": "value2",
"VAR3": "value3",
}
content := manager.BuildEnvFileContent(envVars)
// Should contain all three vars in raw key=value format (no quotes for simple values)
assert.Contains(t, content, "VAR1=value1")
assert.Contains(t, content, "VAR2=value2")
assert.Contains(t, content, "VAR3=value3")
// Should have newlines
assert.Contains(t, content, "\n")
// Should be deterministic (alphabetically sorted)
expected := "VAR1=value1\nVAR2=value2\nVAR3=value3\n"
assert.Equal(t, expected, content, "Output should be deterministic and sorted")
t.Run("quotes values that need dotenv protection", func(t *testing.T) {
protected := map[string]string{
"HASH_VALUE": "postgresql://user:p@ss#word@host/db",
"MULTILINE": "line1\nline2",
"CR_VALUE": "line1\rline2",
}
protectedContent := manager.BuildEnvFileContent(protected)
assert.Contains(t, protectedContent, `HASH_VALUE="postgresql://user:p@ss#word@host/db"`)
assert.Contains(t, protectedContent, `MULTILINE="line1\nline2"`)
assert.Contains(t, protectedContent, `CR_VALUE="line1\rline2"`)
})
// Verify determinism by calling multiple times
for i := 0; i < 10; i++ {
result := manager.BuildEnvFileContent(envVars)
assert.Equal(t, expected, result, "Output should be identical on iteration %d", i)
}
}
func TestEnvVarManager_RealWorldScenario(t *testing.T) {
// Simulate a real deployment scenario
manager := NewEnvVarManager()
// Operator running with some env vars set
_ = os.Setenv("OPTLF_LANGFLOW_WORKERS", "8")
_ = os.Setenv("OPTLF_LANGFLOW_LOG_LEVEL", "INFO")
defer func() {
_ = os.Unsetenv("OPTLF_LANGFLOW_WORKERS")
_ = os.Unsetenv("OPTLF_LANGFLOW_LOG_LEVEL")
}()
// User's CR overrides LOG_LEVEL
crEnvVars := []corev1.EnvVar{
{Name: "LANGFLOW_LOG_LEVEL", Value: "ERROR"},
}
result, err := manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", crEnvVars)
require.NoError(t, err)
// Verify the three-level priority worked correctly
assert.Equal(t, "true", result["LANGFLOW_AUTO_LOGIN"], "Default should be used")
assert.Equal(t, "8", result["LANGFLOW_WORKERS"], "Operator env should override default")
assert.Equal(t, "ERROR", result["LANGFLOW_LOG_LEVEL"], "CR should override operator env")
}
func TestEnvVarManager_NewEnvVarManagerDefaults(t *testing.T) {
manager := NewEnvVarManager()
// Verify Langflow defaults
assert.NotNil(t, manager.DefaultLangflowEnvVars)
assert.Equal(t, "sqlite:////app/data/langflow.db", manager.DefaultLangflowEnvVars["LANGFLOW_DATABASE_URL"])
assert.Equal(t, "true", manager.DefaultLangflowEnvVars["LANGFLOW_AUTO_LOGIN"])
assert.Equal(t, "/app/flows", manager.DefaultLangflowEnvVars["LANGFLOW_LOAD_FLOWS_PATH"])
assert.Equal(t, "4", manager.DefaultLangflowEnvVars["LANGFLOW_WORKERS"])
// Verify Backend defaults
assert.NotNil(t, manager.DefaultOpenRagBEEnvVars)
assert.Equal(t, "http://openrag-be:8000", manager.DefaultOpenRagBEEnvVars["OPENRAG_BACKEND_INTERNAL_URL"])
assert.Equal(t, "2400", manager.DefaultOpenRagBEEnvVars["LANGFLOW_TIMEOUT"])
assert.Equal(t, "/app/backend-data", manager.DefaultOpenRagBEEnvVars["OPENRAG_DATA_PATH"])
assert.Equal(t, "/app/openrag-documents", manager.DefaultOpenRagBEEnvVars["OPENRAG_DOCUMENTS_PATH"])
assert.Equal(t, "DEBUG", manager.DefaultOpenRagBEEnvVars["LOG_LEVEL"])
assert.Equal(t, "json", manager.DefaultOpenRagBEEnvVars["LOG_FORMAT"])
assert.Equal(t, "3600", manager.DefaultOpenRagBEEnvVars["INGESTION_TIMEOUT"])
assert.Equal(t, "4", manager.DefaultOpenRagBEEnvVars["MAX_WORKERS"])
// Verify Frontend defaults (empty for now)
assert.NotNil(t, manager.DefaultOpenRagFEEnvVars)
}
func TestEnvVarManager_EnsureRequiredEnvVars(t *testing.T) {
tests := []struct {
name string
inputEnvVars map[string]string
expectedResult map[string]string
description string
}{
{
name: "adds missing variables with None",
inputEnvVars: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "VAR1,VAR2,VAR3",
"VAR1": "existing_value",
},
expectedResult: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "VAR1,VAR2,VAR3",
"VAR1": "existing_value",
"VAR2": "None",
"VAR3": "None",
},
description: "Should add VAR2 and VAR3 with 'None' value, preserve VAR1",
},
{
name: "handles whitespace in variable list",
inputEnvVars: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "VAR1, VAR2 , VAR3",
},
expectedResult: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "VAR1, VAR2 , VAR3",
"VAR1": "None",
"VAR2": "None",
"VAR3": "None",
},
description: "Should trim whitespace from variable names",
},
{
name: "skips empty variable names",
inputEnvVars: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "VAR1,,VAR2, ,VAR3",
},
expectedResult: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "VAR1,,VAR2, ,VAR3",
"VAR1": "None",
"VAR2": "None",
"VAR3": "None",
},
description: "Should skip empty strings and whitespace-only entries",
},
{
name: "does nothing when LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT is missing",
inputEnvVars: map[string]string{
"VAR1": "value1",
},
expectedResult: map[string]string{
"VAR1": "value1",
},
description: "Should not modify envVars when the list variable is missing",
},
{
name: "does nothing when LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT is empty",
inputEnvVars: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "",
"VAR1": "value1",
},
expectedResult: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "",
"VAR1": "value1",
},
description: "Should not modify envVars when the list is empty",
},
{
name: "preserves existing values including empty strings",
inputEnvVars: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "VAR1,VAR2,VAR3",
"VAR1": "",
"VAR2": "0",
},
expectedResult: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "VAR1,VAR2,VAR3",
"VAR1": "",
"VAR2": "0",
"VAR3": "None",
},
description: "Should preserve empty string and '0' values, only add missing VAR3",
},
{
name: "handles real-world variable list",
inputEnvVars: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "JWT,OPENSEARCH_PASSWORD,OPENSEARCH_URL,DOCLING_SERVE_URL",
"JWT": "token123",
"OPENSEARCH_PASSWORD": "secret",
},
expectedResult: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "JWT,OPENSEARCH_PASSWORD,OPENSEARCH_URL,DOCLING_SERVE_URL",
"JWT": "token123",
"OPENSEARCH_PASSWORD": "secret",
"OPENSEARCH_URL": "None",
"DOCLING_SERVE_URL": "None",
},
description: "Should add missing OpenSearch and Docling variables",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
manager := &EnvVarManager{}
// Call the function
manager.EnsureRequiredEnvVars(tt.inputEnvVars)
// Verify the result
assert.Equal(t, tt.expectedResult, tt.inputEnvVars, tt.description)
})
}
}
func TestEnvVarManager_EnsureRequiredEnvVars_Integration(t *testing.T) {
// Test with the actual default configuration
manager := NewEnvVarManager()
// Get the default Langflow env vars
envVars, err := manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", nil)
require.NoError(t, err)
// Verify LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT exists
requiredVarsStr, exists := envVars["LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT"]
assert.True(t, exists, "LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT should exist in defaults")
assert.NotEmpty(t, requiredVarsStr, "LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT should not be empty")
// Call EnsureRequiredEnvVars
manager.EnsureRequiredEnvVars(envVars)
// Parse the required variables list
requiredVars := []string{"JWT", "OPENRAG_QUERY_FILTER", "OPENSEARCH_PASSWORD", "OPENSEARCH_URL",
"OPENSEARCH_INDEX_NAME", "DOCLING_SERVE_URL", "DOCLING_SERVE_VERIFY_SSL", "DOCLING_TASK_ID", "OWNER", "OWNER_NAME",
"OWNER_EMAIL", "CONNECTOR_TYPE", "DOCUMENT_ID", "SOURCE_URL", "ALLOWED_USERS",
"ALLOWED_GROUPS", "FILENAME", "MIMETYPE", "FILESIZE", "SELECTED_EMBEDDING_MODEL",
"OPENAI_API_KEY", "ANTHROPIC_API_KEY", "WATSONX_API_KEY", "WATSONX_ENDPOINT",
"WATSONX_PROJECT_ID", "OLLAMA_BASE_URL"}
// Verify all required variables exist in the envVars map
for _, varName := range requiredVars {
_, exists := envVars[varName]
assert.True(t, exists, "Variable %s should exist in envVars", varName)
// Note: Some variables may have empty string as their default value (e.g., DOCUMENT_ID, SOURCE_URL, SELECTED_EMBEDDING_MODEL)
// The important thing is that they exist in the map
}
// Verify the newly added defaults are present
assert.Equal(t, "None", envVars["OPENSEARCH_PASSWORD"], "OPENSEARCH_PASSWORD should have default 'None'")
assert.Equal(t, "None", envVars["OPENSEARCH_URL"], "OPENSEARCH_URL should have default 'None'")
assert.Equal(t, "None", envVars["OPENSEARCH_INDEX_NAME"], "OPENSEARCH_INDEX_NAME should have default 'None'")
assert.Equal(t, "None", envVars["DOCLING_SERVE_URL"], "DOCLING_SERVE_URL should have default 'None'")
assert.Equal(t, "false", envVars["DOCLING_SERVE_VERIFY_SSL"], "DOCLING_SERVE_VERIFY_SSL should have default 'false'")
}
func TestEnvVarManager_EnsureRequiredEnvVars_CustomList(t *testing.T) {
// Test with a custom LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT value
manager := &EnvVarManager{
DefaultLangflowEnvVars: map[string]string{
"LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "CUSTOM_VAR1,CUSTOM_VAR2",
"CUSTOM_VAR1": "value1",
},
}
envVars, err := manager.GetLangflowEnvVars(context.Background(), nil, "test-ns", nil)
require.NoError(t, err)
manager.EnsureRequiredEnvVars(envVars)
// Verify custom variables are handled
assert.Equal(t, "value1", envVars["CUSTOM_VAR1"], "CUSTOM_VAR1 should preserve existing value")
assert.Equal(t, "None", envVars["CUSTOM_VAR2"], "CUSTOM_VAR2 should be added with 'None'")
}