d750365ed9
- Introduced new test cases for Structured and Semantic providers to validate schema retrieval functionality. - Updated existing tests across various providers to ensure they check for non-nil schemas, enhancing error handling and test coverage. - Ensured consistency in error messages for schema validation across different provider tests.
313 lines
9.1 KiB
Go
313 lines
9.1 KiB
Go
package converters
|
|
|
|
import (
|
|
"testing"
|
|
|
|
kbtypes "github.com/yaoapp/yao/kb/types"
|
|
)
|
|
|
|
func TestOffice_Make(t *testing.T) {
|
|
office := &Office{}
|
|
|
|
t.Run("nil option should return error for missing vision converter", func(t *testing.T) {
|
|
_, err := office.Make(nil)
|
|
if err == nil {
|
|
t.Error("Expected error for missing vision converter")
|
|
}
|
|
if err.Error() != "vision converter is required for office document processing" {
|
|
t.Errorf("Expected specific error message, got: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("empty option should return error for missing vision converter", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{}
|
|
_, err := office.Make(option)
|
|
if err == nil {
|
|
t.Error("Expected error for missing vision converter")
|
|
}
|
|
if err.Error() != "vision converter is required for office document processing" {
|
|
t.Errorf("Expected specific error message, got: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("option with office processing properties should set all values", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"max_concurrency": 8,
|
|
"temp_dir": "/tmp/office",
|
|
"cleanup_temp": false,
|
|
"vision": map[string]interface{}{
|
|
"converter": "__yao.vision",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.gpt-4o-mini",
|
|
},
|
|
},
|
|
"video": map[string]interface{}{
|
|
"converter": "__yao.video",
|
|
"properties": map[string]interface{}{
|
|
"keyframe_interval": 10.0,
|
|
},
|
|
},
|
|
"audio": map[string]interface{}{
|
|
"converter": "__yao.whisper",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.whisper",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
// This will fail because converter factories aren't set up in tests
|
|
_, err := office.Make(option)
|
|
if err == nil {
|
|
t.Error("Expected error due to mock factory limitation")
|
|
}
|
|
// In real usage, this would work with proper factory setup
|
|
})
|
|
|
|
t.Run("numeric values should handle both int and float64", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"max_concurrency": 6.0, // float64 -> int
|
|
"vision": map[string]interface{}{
|
|
"converter": "__yao.vision",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.gpt-4o-mini",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
// This will fail due to factory setup, but we're testing the parsing logic
|
|
_, err := office.Make(option)
|
|
// We expect error due to vision converter factory not being set up
|
|
if err == nil {
|
|
t.Error("Expected error due to test limitations")
|
|
}
|
|
})
|
|
|
|
t.Run("boolean values should be handled correctly", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"cleanup_temp": true,
|
|
"vision": map[string]interface{}{
|
|
"converter": "__yao.vision",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.gpt-4o-mini",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
// This will fail due to factory setup, but we're testing the parsing logic
|
|
_, err := office.Make(option)
|
|
// We expect error due to vision converter factory not being set up
|
|
if err == nil {
|
|
t.Error("Expected error due to test limitations")
|
|
}
|
|
})
|
|
|
|
t.Run("invalid property types should be ignored", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"max_concurrency": "invalid", // invalid type
|
|
"temp_dir": 123, // invalid type
|
|
"cleanup_temp": "invalid", // invalid type
|
|
"vision": map[string]interface{}{
|
|
"converter": "__yao.vision",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.gpt-4o-mini",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
// This will fail due to factory setup, but we're testing the parsing logic
|
|
_, err := office.Make(option)
|
|
// We expect error due to vision converter factory not being set up
|
|
if err == nil {
|
|
t.Error("Expected error due to test limitations")
|
|
}
|
|
})
|
|
|
|
t.Run("only vision converter should work", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"vision": map[string]interface{}{
|
|
"converter": "__yao.vision",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.gpt-4o-mini",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
// This will fail due to factory setup, but we're testing the parsing logic
|
|
_, err := office.Make(option)
|
|
// We expect error due to vision converter factory not being set up
|
|
if err == nil {
|
|
t.Error("Expected error due to test limitations")
|
|
}
|
|
})
|
|
|
|
t.Run("invalid vision converter should return error", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"vision": "invalid_format", // should be a map
|
|
},
|
|
}
|
|
_, err := office.Make(option)
|
|
if err == nil {
|
|
t.Error("Expected error for invalid vision converter format")
|
|
}
|
|
})
|
|
|
|
t.Run("invalid video converter should return error", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"vision": map[string]interface{}{
|
|
"converter": "__yao.vision",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.gpt-4o-mini",
|
|
},
|
|
},
|
|
"video": []string{"invalid"}, // should be a map
|
|
},
|
|
}
|
|
_, err := office.Make(option)
|
|
if err == nil {
|
|
t.Error("Expected error for invalid video converter format")
|
|
}
|
|
})
|
|
|
|
t.Run("invalid audio converter should return error", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"vision": map[string]interface{}{
|
|
"converter": "__yao.vision",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.gpt-4o-mini",
|
|
},
|
|
},
|
|
"audio": 123, // should be a map
|
|
},
|
|
}
|
|
_, err := office.Make(option)
|
|
if err == nil {
|
|
t.Error("Expected error for invalid audio converter format")
|
|
}
|
|
})
|
|
|
|
t.Run("partial properties should use defaults for missing values", func(t *testing.T) {
|
|
option := &kbtypes.ProviderOption{
|
|
Properties: map[string]interface{}{
|
|
"max_concurrency": 12,
|
|
"vision": map[string]interface{}{
|
|
"converter": "__yao.vision",
|
|
"properties": map[string]interface{}{
|
|
"connector": "openai.gpt-4o-mini",
|
|
},
|
|
},
|
|
// temp_dir and cleanup_temp should use defaults
|
|
},
|
|
}
|
|
// This will fail due to factory setup, but we're testing the parsing logic
|
|
_, err := office.Make(option)
|
|
// We expect error due to vision converter factory not being set up
|
|
if err == nil {
|
|
t.Error("Expected error due to test limitations")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestOffice_AutoDetect(t *testing.T) {
|
|
office := &Office{
|
|
Autodetect: []string{".docx", ".pptx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
|
|
MatchPriority: 10,
|
|
}
|
|
|
|
t.Run("should detect .docx files", func(t *testing.T) {
|
|
match, priority, err := office.AutoDetect("document.docx", "")
|
|
if err != nil {
|
|
t.Errorf("Expected no error, got %v", err)
|
|
}
|
|
if !match {
|
|
t.Error("Expected match for .docx file")
|
|
}
|
|
if priority != 10 {
|
|
t.Errorf("Expected priority 10, got %d", priority)
|
|
}
|
|
})
|
|
|
|
t.Run("should detect .pptx files", func(t *testing.T) {
|
|
match, priority, err := office.AutoDetect("presentation.pptx", "")
|
|
if err != nil {
|
|
t.Errorf("Expected no error, got %v", err)
|
|
}
|
|
if !match {
|
|
t.Error("Expected match for .pptx file")
|
|
}
|
|
if priority != 10 {
|
|
t.Errorf("Expected priority 10, got %d", priority)
|
|
}
|
|
})
|
|
|
|
t.Run("should detect by content type", func(t *testing.T) {
|
|
match, priority, err := office.AutoDetect("unknown", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
|
|
if err != nil {
|
|
t.Errorf("Expected no error, got %v", err)
|
|
}
|
|
if !match {
|
|
t.Error("Expected match for Word document content type")
|
|
}
|
|
if priority != 10 {
|
|
t.Errorf("Expected priority 10, got %d", priority)
|
|
}
|
|
})
|
|
|
|
t.Run("should not detect unsupported files", func(t *testing.T) {
|
|
match, priority, err := office.AutoDetect("image.jpg", "image/jpeg")
|
|
if err != nil {
|
|
t.Errorf("Expected no error, got %v", err)
|
|
}
|
|
if match {
|
|
t.Error("Expected no match for .jpg file")
|
|
}
|
|
if priority != 0 {
|
|
t.Errorf("Expected priority 0, got %d", priority)
|
|
}
|
|
})
|
|
|
|
t.Run("should not detect old Office formats", func(t *testing.T) {
|
|
match, priority, err := office.AutoDetect("document.doc", "application/msword")
|
|
if err != nil {
|
|
t.Errorf("Expected no error, got %v", err)
|
|
}
|
|
if match {
|
|
t.Error("Expected no match for .doc file (old format)")
|
|
}
|
|
if priority != 0 {
|
|
t.Errorf("Expected priority 0, got %d", priority)
|
|
}
|
|
})
|
|
|
|
t.Run("empty autodetect should not match", func(t *testing.T) {
|
|
emptyOffice := &Office{}
|
|
match, priority, err := emptyOffice.AutoDetect("document.docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
|
|
if err != nil {
|
|
t.Errorf("Expected no error, got %v", err)
|
|
}
|
|
if match {
|
|
t.Error("Expected no match when autodetect is empty")
|
|
}
|
|
if priority != 0 {
|
|
t.Errorf("Expected priority 0, got %d", priority)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestOffice_Schema(t *testing.T) {
|
|
office := &Office{}
|
|
schema, err := office.Schema(nil, "en")
|
|
if err != nil {
|
|
t.Errorf("Expected no error, got %v", err)
|
|
}
|
|
if schema == nil {
|
|
t.Error("Expected non-nil schema from factory.GetSchemaFromBindata")
|
|
}
|
|
}
|