lixuan/es-demo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 增加ism管理接口

Browse Source 
test: 索引模板和ism的单元测试和集成测试
This commit is contained in:
mouseleee
2025-11-16 23:00:31 +08:00
parent da3883205c
commit fc14798af5
10 changed files with 1777 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

306
operations/index/template_test.go
View File

@@ -2,23 +2,27 @@ package index
import (
"context"
"errors"
"testing"
"time"
"es-demo/client"
"es-demo/config"
)
func TestPutTemplate(t *testing.T) {
if testing.Short() {
t.Skip("skipping integration test in short mode")
// setupIntegrationTest loads configuration and creates a client for integration tests.
func setupIntegrationTest(t *testing.T) *client.Client {
t.Helper()
// Load configuration from project root
if err := config.Load("../../.env"); err != nil {
t.Logf("warning: failed to load .env file: %v", err)
}
cfg := &client.Config{
Endpoint: "https://example.com",
Region: "us-east-1",
AccessKey: "test-key",
SecretKey: "test-secret",
Endpoint: config.Endpoint,
Region: config.Region,
AccessKey: config.AccessKey,
SecretKey: config.SecretKey,
}
c, err := client.NewClient(cfg)
@@ -26,11 +30,139 @@ func TestPutTemplate(t *testing.T) {
t.Fatalf("failed to create client: %v", err)
}
return c
}
// TestTemplateIntegration tests complete template lifecycle
func TestTemplateIntegration(t *testing.T) {
if testing.Short() {
t.Skip("skipping integration test in short mode")
}
c := setupIntegrationTest(t)
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
templateName := "test-template-integration"
// Cleanup before test
_ = DeleteTemplate(ctx, c, templateName)
// Test 1: Create template
template := &Template{
IndexPatterns: []string{"test-integration-*"},
Settings: map[string]any{
"number_of_shards": 1,
"number_of_replicas": 0,
},
Mappings: map[string]any{
"properties": map[string]any{
"timestamp": map[string]any{
"type": "date",
},
"message": map[string]any{
"type": "text",
},
},
},
Priority: 100,
}
t.Run("PutTemplate", func(t *testing.T) {
err := PutTemplate(ctx, c, templateName, template)
if err != nil {
t.Fatalf("PutTemplate() error = %v", err)
}
t.Log("Template created successfully")
})
// Test 2: Get template
t.Run("GetTemplate", func(t *testing.T) {
retrieved, err := GetTemplate(ctx, c, templateName)
if err != nil {
t.Fatalf("GetTemplate() error = %v", err)
}
if len(retrieved.IndexPatterns) != len(template.IndexPatterns) {
t.Errorf("IndexPatterns = %v, want %v", retrieved.IndexPatterns, template.IndexPatterns)
}
if retrieved.Priority != template.Priority {
t.Errorf("Priority = %d, want %d", retrieved.Priority, template.Priority)
}
t.Logf("Retrieved template: %d index patterns, priority %d", len(retrieved.IndexPatterns), retrieved.Priority)
})
// Test 3: Update template
t.Run("UpdateTemplate", func(t *testing.T) {
template.Priority = 200
err := PutTemplate(ctx, c, templateName, template)
if err != nil {
t.Fatalf("PutTemplate() (update) error = %v", err)
}
retrieved, err := GetTemplate(ctx, c, templateName)
if err != nil {
t.Fatalf("GetTemplate() error = %v", err)
}
if retrieved.Priority != 200 {
t.Errorf("Updated Priority = %d, want 200", retrieved.Priority)
}
t.Log("Template updated successfully")
})
// Test 4: List templates
t.Run("ListTemplates", func(t *testing.T) {
templates, err := ListTemplates(ctx, c)
if err != nil {
t.Fatalf("ListTemplates() error = %v", err)
}
if _, exists := templates[templateName]; !exists {
t.Errorf("Template %q not found in list", templateName)
}
t.Logf("Found %d templates", len(templates))
})
// Test 5: Delete template
t.Run("DeleteTemplate", func(t *testing.T) {
err := DeleteTemplate(ctx, c, templateName)
if err != nil {
t.Fatalf("DeleteTemplate() error = %v", err)
}
// Verify deletion
_, err = GetTemplate(ctx, c, templateName)
if err == nil {
t.Error("GetTemplate() should return error after deletion")
}
t.Log("Template deleted successfully")
})
}
func TestPutTemplate(t *testing.T) {
if testing.Short() {
t.Skip("skipping integration test in short mode")
}
c := setupIntegrationTest(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
templateName := "test-put-template"
defer func() {
_ = DeleteTemplate(context.Background(), c, templateName)
}()
template := &Template{
IndexPatterns: []string{"test-*"},
IndexPatterns: []string{"test-put-*"},
Settings: map[string]any{
"number_of_shards": 1,
"number_of_replicas": 0,
@@ -44,11 +176,12 @@ func TestPutTemplate(t *testing.T) {
},
}
// This will fail without a real cluster
err = PutTemplate(ctx, c, "test-template", template)
if err == nil {
t.Log("PutTemplate succeeded (unexpected in unit test)")
err := PutTemplate(ctx, c, templateName, template)
if err != nil {
t.Fatalf("PutTemplate() error = %v", err)
}
t.Log("PutTemplate succeeded")
}
func TestGetTemplate(t *testing.T) {
@@ -56,26 +189,41 @@ func TestGetTemplate(t *testing.T) {
t.Skip("skipping integration test in short mode")
}
cfg := &client.Config{
Endpoint: "https://example.com",
Region: "us-east-1",
AccessKey: "test-key",
SecretKey: "test-secret",
}
c, err := client.NewClient(cfg)
if err != nil {
t.Fatalf("failed to create client: %v", err)
}
c := setupIntegrationTest(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
// This will fail without a real cluster
_, err = GetTemplate(ctx, c, "test-template")
if err == nil {
t.Log("GetTemplate succeeded (unexpected in unit test)")
templateName := "test-get-template"
// Create a template first
template := &Template{
IndexPatterns: []string{"test-get-*"},
Settings: map[string]any{
"number_of_shards": 1,
},
}
err := PutTemplate(ctx, c, templateName, template)
if err != nil {
t.Fatalf("setup: PutTemplate() error = %v", err)
}
defer func() {
_ = DeleteTemplate(context.Background(), c, templateName)
}()
// Test getting the template
retrieved, err := GetTemplate(ctx, c, templateName)
if err != nil {
t.Fatalf("GetTemplate() error = %v", err)
}
if len(retrieved.IndexPatterns) == 0 {
t.Error("GetTemplate() returned empty index patterns")
}
t.Logf("GetTemplate succeeded: %v", retrieved.IndexPatterns)
}
func TestDeleteTemplate(t *testing.T) {
@@ -83,26 +231,30 @@ func TestDeleteTemplate(t *testing.T) {
t.Skip("skipping integration test in short mode")
}
cfg := &client.Config{
Endpoint: "https://example.com",
Region: "us-east-1",
AccessKey: "test-key",
SecretKey: "test-secret",
}
c, err := client.NewClient(cfg)
if err != nil {
t.Fatalf("failed to create client: %v", err)
}
c := setupIntegrationTest(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
// This will fail without a real cluster
err = DeleteTemplate(ctx, c, "test-template")
if err == nil {
t.Log("DeleteTemplate succeeded (unexpected in unit test)")
templateName := "test-delete-template"
// Create a template
template := &Template{
IndexPatterns: []string{"test-delete-*"},
}
err := PutTemplate(ctx, c, templateName, template)
if err != nil {
t.Fatalf("setup: PutTemplate() error = %v", err)
}
// Test deletion
err = DeleteTemplate(ctx, c, templateName)
if err != nil {
t.Fatalf("DeleteTemplate() error = %v", err)
}
t.Log("DeleteTemplate succeeded")
}
func TestListTemplates(t *testing.T) {
@@ -110,71 +262,19 @@ func TestListTemplates(t *testing.T) {
t.Skip("skipping integration test in short mode")
}
cfg := &client.Config{
Endpoint: "https://example.com",
Region: "us-east-1",
AccessKey: "test-key",
SecretKey: "test-secret",
}
c, err := client.NewClient(cfg)
if err != nil {
t.Fatalf("failed to create client: %v", err)
}
c := setupIntegrationTest(t)
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
// This will fail without a real cluster
_, err = ListTemplates(ctx, c)
if err == nil {
t.Log("ListTemplates succeeded (unexpected in unit test)")
}
}
func TestTemplate_Validate(t *testing.T) {
tests := []struct {
name string
template *Template
wantErr error
}{
{
name: "valid template",
template: &Template{
IndexPatterns: []string{"logs-*"},
Settings: map[string]any{
"number_of_shards": 1,
},
},
wantErr: nil,
},
{
name: "nil template",
template: nil,
wantErr: ErrInvalidTemplate,
},
{
name: "empty index patterns",
template: &Template{
IndexPatterns: []string{},
},
wantErr: ErrInvalidTemplate,
},
{
name: "nil index patterns",
template: &Template{
IndexPatterns: nil,
},
wantErr: ErrInvalidTemplate,
},
templates, err := ListTemplates(ctx, c)
if err != nil {
t.Fatalf("ListTemplates() error = %v", err)
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := validateTemplate(tt.template)
if !errors.Is(err, tt.wantErr) {
t.Errorf("validateTemplate() error = %v, wantErr %v", err, tt.wantErr)
}
})
if templates == nil {
t.Error("ListTemplates() returned nil")
}
t.Logf("ListTemplates succeeded: found %d templates", len(templates))
}