feat: add tests for filter options

Signed-off-by: Sidney Glinton <[email protected]>

Author: syntaxsdev

catalog/internal/catalog/db_catalog_test.go

@@ -794,6 +794,168 @@ func TestDBCatalog(t *testing.T) {
 			assert.Contains(t, err.Error(), "invalid model name")
 		})
 	})
+
+	t.Run("TestGetFilterOptions", func(t *testing.T) {
+		// Create models with various properties for filter options testing
+		model1 := &models.CatalogModelImpl{
+			TypeID: apiutils.Of(int32(catalogModelTypeID)),
+			Attributes: &models.CatalogModelAttributes{
+				Name:       apiutils.Of("filter-options-model-1"),
+				ExternalID: apiutils.Of("filter-opt-1"),
+			},
+			Properties: &[]mr_models.Properties{
+				{Name: "source_id", StringValue: apiutils.Of("filter-test-source")},
+				{Name: "license", StringValue: apiutils.Of("MIT")},
+				{Name: "provider", StringValue: apiutils.Of("HuggingFace")},
+				{Name: "maturity", StringValue: apiutils.Of("stable")},
+				{Name: "library_name", StringValue: apiutils.Of("transformers")},
+				{Name: "language", StringValue: apiutils.Of(`["python", "rust"]`)},
+				{Name: "tasks", StringValue: apiutils.Of(`["text-classification", "token-classification"]`)},
+			},
+		}
+
+		model2 := &models.CatalogModelImpl{
+			TypeID: apiutils.Of(int32(catalogModelTypeID)),
+			Attributes: &models.CatalogModelAttributes{
+				Name:       apiutils.Of("filter-options-model-2"),
+				ExternalID: apiutils.Of("filter-opt-2"),
+			},
+			Properties: &[]mr_models.Properties{
+				{Name: "source_id", StringValue: apiutils.Of("filter-test-source")},
+				{Name: "license", StringValue: apiutils.Of("Apache-2.0")},
+				{Name: "provider", StringValue: apiutils.Of("OpenAI")},
+				{Name: "maturity", StringValue: apiutils.Of("experimental")},
+				{Name: "library_name", StringValue: apiutils.Of("openai")},
+				{Name: "language", StringValue: apiutils.Of(`["python", "javascript"]`)},
+				{Name: "tasks", StringValue: apiutils.Of(`["text-generation", "conversational"]`)},
+				{Name: "readme", StringValue: apiutils.Of("This is a very long readme that exceeds 100 characters and should be excluded from filter options because it's too verbose for filtering purposes.")},
+			},
+		}
+
+		model3 := &models.CatalogModelImpl{
+			TypeID: apiutils.Of(int32(catalogModelTypeID)),
+			Attributes: &models.CatalogModelAttributes{
+				Name:       apiutils.Of("filter-options-model-3"),
+				ExternalID: apiutils.Of("filter-opt-3"),
+			},
+			Properties: &[]mr_models.Properties{
+				{Name: "source_id", StringValue: apiutils.Of("filter-test-source")},
+				{Name: "license", StringValue: apiutils.Of("MIT")},
+				{Name: "provider", StringValue: apiutils.Of("PyTorch")},
+				{Name: "maturity", StringValue: apiutils.Of("stable")},
+				{Name: "language", StringValue: apiutils.Of(`["python"]`)},
+				{Name: "tasks", StringValue: apiutils.Of(`["image-classification"]`)},
+				{Name: "logo", StringValue: apiutils.Of("https://example.com/logo.png")},
+				{Name: "license_link", StringValue: apiutils.Of("https://example.com/license")},
+			},
+		}
+
+		_, err := catalogModelRepo.Save(model1)
+		require.NoError(t, err)
+		_, err = catalogModelRepo.Save(model2)
+		require.NoError(t, err)
+		_, err = catalogModelRepo.Save(model3)
+		require.NoError(t, err)
+
+		// Test GetFilterOptions
+		filterOptions, err := dbCatalog.GetFilterOptions(ctx)
+		require.NoError(t, err)
+		require.NotNil(t, filterOptions)
+		require.NotNil(t, filterOptions.Filters)
+
+		filters := *filterOptions.Filters
+
+		// Should include short properties
+		assert.Contains(t, filters, "license")
+		assert.Contains(t, filters, "provider")
+		assert.Contains(t, filters, "maturity")
+		assert.Contains(t, filters, "library_name")
+		assert.Contains(t, filters, "language")
+		assert.Contains(t, filters, "tasks")
+
+		// Should exclude internal/verbose fields
+		assert.NotContains(t, filters, "source_id", "source_id should be excluded")
+		assert.NotContains(t, filters, "logo", "logo should be excluded")
+		assert.NotContains(t, filters, "license_link", "license_link should be excluded")
+		assert.NotContains(t, filters, "readme", "readme should be excluded (too long)")
+
+		licenseFilter := filters["license"]
+		assert.Equal(t, "string", licenseFilter.Type)
+		assert.NotNil(t, licenseFilter.Values)
+		assert.GreaterOrEqual(t, len(licenseFilter.Values), 2, "Should have at least MIT and Apache-2.0")
+
+		// Convert to string slice for easier checking
+		licenseValues := make([]string, 0)
+		for _, v := range licenseFilter.Values {
+			if strVal, ok := v.(string); ok {
+				licenseValues = append(licenseValues, strVal)
+			}
+		}
+		assert.Contains(t, licenseValues, "MIT")
+		assert.Contains(t, licenseValues, "Apache-2.0")
+
+		// Verify provider filter options
+		providerFilter := filters["provider"]
+		assert.Equal(t, "string", providerFilter.Type)
+		providerValues := make([]string, 0)
+		for _, v := range providerFilter.Values {
+			if strVal, ok := v.(string); ok {
+				providerValues = append(providerValues, strVal)
+			}
+		}
+		assert.Contains(t, providerValues, "HuggingFace")
+		assert.Contains(t, providerValues, "OpenAI")
+		assert.Contains(t, providerValues, "PyTorch")
+
+		// Verify JSON array fields are properly parsed and expanded
+		languageFilter := filters["language"]
+		assert.Equal(t, "string", languageFilter.Type)
+		languageValues := make([]string, 0)
+		for _, v := range languageFilter.Values {
+			if strVal, ok := v.(string); ok {
+				languageValues = append(languageValues, strVal)
+			}
+		}
+		// Should contain individual values from JSON arrays
+		assert.Contains(t, languageValues, "python")
+		assert.Contains(t, languageValues, "rust")
+		assert.Contains(t, languageValues, "javascript")
+
+		// Verify tasks are properly expanded
+		tasksFilter := filters["tasks"]
+		assert.Equal(t, "string", tasksFilter.Type)
+		tasksValues := make([]string, 0)
+		for _, v := range tasksFilter.Values {
+			if strVal, ok := v.(string); ok {
+				tasksValues = append(tasksValues, strVal)
+			}
+		}
+		assert.Contains(t, tasksValues, "text-classification")
+		assert.Contains(t, tasksValues, "token-classification")
+		assert.Contains(t, tasksValues, "text-generation")
+		assert.Contains(t, tasksValues, "conversational")
+		assert.Contains(t, tasksValues, "image-classification")
+
+		// Verify no duplicates
+		pythonCount := 0
+		for _, v := range languageValues {
+			if v == "python" {
+				pythonCount++
+			}
+		}
+		assert.Equal(t, 1, pythonCount, "python should appear only once (deduplicated)")
+
+		// Verify maturity options
+		maturityFilter := filters["maturity"]
+		maturityValues := make([]string, 0)
+		for _, v := range maturityFilter.Values {
+			if strVal, ok := v.(string); ok {
+				maturityValues = append(maturityValues, strVal)
+			}
+		}
+		assert.Contains(t, maturityValues, "stable")
+		assert.Contains(t, maturityValues, "experimental")
+	})
 }
 
 // Helper functions to get type IDs from database

catalog/internal/db/service/catalog_model.go

@@ -237,20 +237,23 @@ func mapDataLayerToCatalogModel(modelCtx schema.Context, propertiesCtx []schema.
 func (r *CatalogModelRepositoryImpl) GetFilterableProperties(maxLength int) (map[string][]string, error) {
 	config := r.GetConfig()
 
+	// Get table names using GORM utilities for database compatibility
+	contextTable := utils.GetTableName(config.DB, &schema.Context{})
+	propertyTable := utils.GetTableName(config.DB, &schema.ContextProperty{})
+
 	// Simplified query: get distinct property name/value pairs
-	query := `
+	query := fmt.Sprintf(`
 		SELECT DISTINCT cp.name, cp.string_value
-		FROM "ContextProperty" cp
+		FROM %s cp
 		WHERE cp.context_id IN (
-			SELECT id FROM "Context" WHERE type_id = ?
+			SELECT id FROM %s WHERE type_id = ?
 		)
 		AND cp.name IN (
-			-- Only include property names where max length is within threshold
 			SELECT name FROM (
 				SELECT name, MAX(CHAR_LENGTH(string_value)) as max_len
-				FROM "ContextProperty"
+				FROM %s
 				WHERE context_id IN (
-					SELECT id FROM "Context" WHERE type_id = ?
+					SELECT id FROM %s WHERE type_id = ?
 				)
 				AND string_value IS NOT NULL
 				AND string_value != ''
@@ -261,7 +264,7 @@ func (r *CatalogModelRepositoryImpl) GetFilterableProperties(maxLength int) (map
 		AND cp.string_value IS NOT NULL
 		AND cp.string_value != ''
 		ORDER BY cp.name, cp.string_value
-	`
+	`, propertyTable, contextTable, propertyTable, contextTable)
 
 	type propertyRow struct {
 		Name        string

catalog/internal/db/service/catalog_model_test.go

@@ -337,6 +337,85 @@ func TestCatalogModelRepository(t *testing.T) {
 		require.NotNil(t, retrieved.GetCustomProperties())
 		assert.Len(t, *retrieved.GetCustomProperties(), 2)
 	})
+
+	t.Run("TestGetFilterableProperties", func(t *testing.T) {
+		// Create models with various property lengths
+		shortValueModel := &models.CatalogModelImpl{
+			Attributes: &models.CatalogModelAttributes{
+				Name:       apiutils.Of("short-value-model"),
+				ExternalID: apiutils.Of("short-ext"),
+			},
+			Properties: &[]dbmodels.Properties{
+				{Name: "license", StringValue: apiutils.Of("MIT")},
+				{Name: "provider", StringValue: apiutils.Of("HuggingFace")},
+				{Name: "maturity", StringValue: apiutils.Of("stable")},
+			},
+		}
+
+		longValueModel := &models.CatalogModelImpl{
+			Attributes: &models.CatalogModelAttributes{
+				Name:       apiutils.Of("long-value-model"),
+				ExternalID: apiutils.Of("long-ext"),
+			},
+			Properties: &[]dbmodels.Properties{
+				{Name: "license", StringValue: apiutils.Of("Apache-2.0")},
+				{Name: "readme", StringValue: apiutils.Of("This is a very long readme that should be excluded from filterable properties because it exceeds the maximum length threshold of 100 characters. It contains detailed information about the model.")},
+				{Name: "description", StringValue: apiutils.Of("This is also a very long description that should be excluded from filterable properties because it exceeds 100 chars")},
+			},
+		}
+
+		jsonArrayModel := &models.CatalogModelImpl{
+			Attributes: &models.CatalogModelAttributes{
+				Name:       apiutils.Of("json-array-model"),
+				ExternalID: apiutils.Of("json-ext"),
+			},
+			Properties: &[]dbmodels.Properties{
+				{Name: "language", StringValue: apiutils.Of(`["python", "go"]`)},
+				{Name: "tasks", StringValue: apiutils.Of(`["text-classification", "question-answering"]`)},
+			},
+		}
+
+		_, err := repo.Save(shortValueModel)
+		require.NoError(t, err)
+		_, err = repo.Save(longValueModel)
+		require.NoError(t, err)
+		_, err = repo.Save(jsonArrayModel)
+		require.NoError(t, err)
+
+		// Test with max length of 100
+		result, err := repo.GetFilterableProperties(100)
+		require.NoError(t, err)
+		require.NotNil(t, result)
+
+		// Should include short properties
+		assert.Contains(t, result, "license")
+		assert.Contains(t, result, "provider")
+		assert.Contains(t, result, "maturity")
+		assert.Contains(t, result, "language")
+		assert.Contains(t, result, "tasks")
+
+		// Should exclude long properties
+		assert.NotContains(t, result, "readme")
+		assert.NotContains(t, result, "description")
+
+		// Verify license has both values
+		licenseValues := result["license"]
+		assert.GreaterOrEqual(t, len(licenseValues), 2)
+		assert.Contains(t, licenseValues, "MIT")
+		assert.Contains(t, licenseValues, "Apache-2.0")
+
+		// Test with smaller max length
+		result, err = repo.GetFilterableProperties(10)
+		require.NoError(t, err)
+		require.NotNil(t, result)
+
+		// Should include only very short properties
+		assert.Contains(t, result, "license")
+		// Should exclude longer properties
+		assert.NotContains(t, result, "provider") // "HuggingFace" is > 10 chars
+		assert.NotContains(t, result, "language")
+		assert.NotContains(t, result, "tasks")
+	})
 }
 
 // Helper function to get or create CatalogModel type ID

catalog/internal/server/openapi/api_model_catalog_service_service_test.go

@@ -776,6 +776,11 @@ func (m *mockModelProvider) GetArtifacts(ctx context.Context, name string, sourc
 	}, nil
 }
 
+func (m *mockModelProvider) GetFilterOptions(ctx context.Context) (*model.FilterOptionsList, error) {
+	emptyFilters := make(map[string]model.FilterOption)
+	return &model.FilterOptionsList{Filters: &emptyFilters}, nil
+}
+
 func TestGetModel(t *testing.T) {
 	testCases := []struct {
 		name           string
@@ -1003,3 +1008,44 @@ func TestGetAllModelArtifacts(t *testing.T) {
 		})
 	}
 }
+
+func TestFindModelsFilterOptions(t *testing.T) {
+	testCases := []struct {
+		name           string
+		provider       catalog.APIProvider
+		expectedStatus int
+		expectedError  bool
+	}{
+		{
+			name: "Successfully retrieve filter options",
+			provider: &mockModelProvider{
+				models: map[string]*model.CatalogModel{},
+			},
+			expectedStatus: http.StatusOK,
+			expectedError:  false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			sources := catalog.NewSourceCollection()
+			service := NewModelCatalogServiceAPIService(tc.provider, sources)
+
+			resp, err := service.FindModelsFilterOptions(context.Background())
+
+			assert.Equal(t, tc.expectedStatus, resp.Code)
+
+			if tc.expectedError {
+				assert.Error(t, err)
+				return
+			}
+			require.NotNil(t, resp.Body)
+
+			// Type assertion to access the FilterOptionsList
+			filterOptions, ok := resp.Body.(*model.FilterOptionsList)
+			require.True(t, ok, "Response body should be a FilterOptionsList")
+
+			require.NotNil(t, filterOptions.Filters)
+		})
+	}
+}