mirror of
https://github.com/hhftechnology/middleware-manager.git
synced 2026-11-20 23:16:15 +00:00
Replace direct defers that ignored returned errors with explicit defer func() { _ = ... }() and use blank-assignment for Setenv/RemoveAll/Close to satisfy error-checking and ensure closures run. Convert several if-else chains to switch for clarity (status filter, test server path matching), switch strings.Replace to strings.ReplaceAll, and normalize some error/log message casing. These changes are minor refactors across handlers, services, database and tests to improve lint compliance and readability.
541 lines
13 KiB
Go
541 lines
13 KiB
Go
package services
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/hhftechnology/middleware-manager/models"
|
|
)
|
|
|
|
// TestNewPluginFetcher tests plugin fetcher creation
|
|
func TestNewPluginFetcher(t *testing.T) {
|
|
config := models.DataSourceConfig{
|
|
URL: "http://localhost:8080",
|
|
}
|
|
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
if fetcher == nil {
|
|
t.Fatal("NewPluginFetcher() returned nil")
|
|
}
|
|
if fetcher.httpClient == nil {
|
|
t.Error("fetcher.httpClient is nil")
|
|
}
|
|
if fetcher.config.URL != config.URL {
|
|
t.Errorf("config.URL = %q, want %q", fetcher.config.URL, config.URL)
|
|
}
|
|
}
|
|
|
|
// TestPluginFetcher_FetchPlugins tests fetching plugins
|
|
func TestPluginFetcher_FetchPlugins(t *testing.T) {
|
|
// Create mock server
|
|
middlewares := []models.TraefikMiddleware{
|
|
{
|
|
Name: "test-plugin@file",
|
|
Type: "plugin",
|
|
Provider: "file",
|
|
Config: map[string]interface{}{
|
|
"plugin": map[string]interface{}{
|
|
"testPlugin": map[string]interface{}{
|
|
"moduleName": "github.com/example/test-plugin",
|
|
"version": "v1.0.0",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/api/http/middlewares":
|
|
writeJSONResponse(w, middlewares)
|
|
case "/api/overview":
|
|
var overview models.TraefikPluginOverview
|
|
overview.Plugins.Enabled = []string{"testPlugin"}
|
|
writeJSONResponse(w, overview)
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
config := models.DataSourceConfig{
|
|
URL: server.URL,
|
|
}
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
ctx := context.Background()
|
|
plugins, err := fetcher.FetchPlugins(ctx)
|
|
if err != nil {
|
|
t.Fatalf("FetchPlugins() error = %v", err)
|
|
}
|
|
|
|
if len(plugins) == 0 {
|
|
t.Log("No plugins returned (may be expected if no plugin middlewares found)")
|
|
}
|
|
}
|
|
|
|
// TestPluginFetcher_FetchPlugins_WithBasicAuth tests fetching with auth
|
|
func TestPluginFetcher_FetchPlugins_WithBasicAuth(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
user, pass, ok := r.BasicAuth()
|
|
if !ok || user != "admin" || pass != "secret" {
|
|
http.Error(w, "Unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
writeJSONResponse(w, []models.TraefikMiddleware{})
|
|
}))
|
|
defer server.Close()
|
|
|
|
config := models.DataSourceConfig{
|
|
URL: server.URL,
|
|
BasicAuth: struct {
|
|
Username string `json:"username"`
|
|
Password string `json:"password"`
|
|
}{
|
|
Username: "admin",
|
|
Password: "secret",
|
|
},
|
|
}
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
ctx := context.Background()
|
|
_, err := fetcher.FetchPlugins(ctx)
|
|
if err != nil {
|
|
t.Fatalf("FetchPlugins() with auth error = %v", err)
|
|
}
|
|
}
|
|
|
|
// TestPluginFetcher_FetchPlugins_ServerError tests handling server errors
|
|
// FetchPlugins intentionally degrades gracefully on upstream errors: middleware
|
|
// fetch failures are logged and FetchPlugins returns an empty slice rather than
|
|
// propagating the error. This test locks that contract.
|
|
func TestPluginFetcher_FetchPlugins_ServerError(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
|
|
}))
|
|
defer server.Close()
|
|
|
|
config := models.DataSourceConfig{
|
|
URL: server.URL,
|
|
}
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
ctx := context.Background()
|
|
plugins, err := fetcher.FetchPlugins(ctx)
|
|
if err != nil {
|
|
t.Fatalf("FetchPlugins() returned error on upstream 500, expected graceful empty: %v", err)
|
|
}
|
|
if len(plugins) != 0 {
|
|
t.Errorf("FetchPlugins() len = %d, want 0 on upstream error", len(plugins))
|
|
}
|
|
}
|
|
|
|
// TestPluginFetcher_RateLimiting tests rate limiting
|
|
func TestPluginFetcher_RateLimiting(t *testing.T) {
|
|
callCount := 0
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
callCount++
|
|
switch r.URL.Path {
|
|
case "/api/http/middlewares":
|
|
writeJSONResponse(w, []models.TraefikMiddleware{})
|
|
case "/api/overview":
|
|
writeJSONResponse(w, models.TraefikPluginOverview{})
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
config := models.DataSourceConfig{
|
|
URL: server.URL,
|
|
}
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
ctx := context.Background()
|
|
|
|
// First call
|
|
_, err := fetcher.FetchPlugins(ctx)
|
|
if err != nil {
|
|
t.Fatalf("First FetchPlugins() error = %v", err)
|
|
}
|
|
firstCallCount := callCount
|
|
|
|
// Immediate second call should return cached data
|
|
_, err = fetcher.FetchPlugins(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Second FetchPlugins() error = %v", err)
|
|
}
|
|
|
|
// Call count should not increase significantly due to caching
|
|
if callCount > firstCallCount*2 {
|
|
t.Log("Rate limiting may not be preventing extra calls")
|
|
}
|
|
}
|
|
|
|
// TestPluginFetcher_GetCachedPlugins tests getting cached plugins
|
|
func TestPluginFetcher_GetCachedPlugins(t *testing.T) {
|
|
config := models.DataSourceConfig{
|
|
URL: "http://localhost:8080",
|
|
}
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
// Should return nil or empty when no cache
|
|
cached := fetcher.GetCachedPlugins()
|
|
if len(cached) > 0 {
|
|
t.Error("expected nil or empty cache initially")
|
|
}
|
|
}
|
|
|
|
// TestPluginFetcher_InvalidateCache tests cache invalidation
|
|
func TestPluginFetcher_InvalidateCache(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/api/http/middlewares":
|
|
writeJSONResponse(w, []models.TraefikMiddleware{})
|
|
case "/api/overview":
|
|
writeJSONResponse(w, models.TraefikPluginOverview{})
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
config := models.DataSourceConfig{
|
|
URL: server.URL,
|
|
}
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
ctx := context.Background()
|
|
|
|
// Fetch to populate cache
|
|
if _, err := fetcher.FetchPlugins(ctx); err != nil {
|
|
t.Fatalf("FetchPlugins() error = %v", err)
|
|
}
|
|
|
|
// Invalidate cache
|
|
fetcher.InvalidateCache()
|
|
|
|
// Cache should be empty
|
|
cached := fetcher.GetCachedPlugins()
|
|
if len(cached) > 0 {
|
|
t.Error("expected nil or empty cache after invalidation")
|
|
}
|
|
}
|
|
|
|
// TestPluginFetcher_ContextCancellation tests context cancellation
|
|
func TestPluginFetcher_ContextCancellation(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
time.Sleep(5 * time.Second) // Simulate slow response
|
|
writeJSONResponse(w, []models.TraefikMiddleware{})
|
|
}))
|
|
defer server.Close()
|
|
|
|
config := models.DataSourceConfig{
|
|
URL: server.URL,
|
|
}
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
|
|
defer cancel()
|
|
|
|
_, err := fetcher.FetchPlugins(ctx)
|
|
// Should error due to context timeout
|
|
if err == nil {
|
|
t.Log("Expected error due to context timeout, but got success")
|
|
}
|
|
}
|
|
|
|
// TestIsPluginMiddleware tests plugin middleware detection
|
|
func TestIsPluginMiddleware(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mw models.TraefikMiddleware
|
|
expected bool
|
|
}{
|
|
{
|
|
name: "plugin type",
|
|
mw: models.TraefikMiddleware{
|
|
Type: "plugin",
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "plugin in config",
|
|
mw: models.TraefikMiddleware{
|
|
Type: "headers",
|
|
Config: map[string]interface{}{
|
|
"plugin": map[string]interface{}{},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "not a plugin",
|
|
mw: models.TraefikMiddleware{
|
|
Type: "headers",
|
|
Config: map[string]interface{}{},
|
|
},
|
|
expected: false,
|
|
},
|
|
{
|
|
name: "plugin in type name",
|
|
mw: models.TraefikMiddleware{
|
|
Type: "myPlugin",
|
|
},
|
|
expected: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := isPluginMiddleware(tt.mw)
|
|
if got != tt.expected {
|
|
t.Errorf("isPluginMiddleware() = %v, want %v", got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestExtractPluginName tests plugin name extraction
|
|
func TestExtractPluginName(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mw models.TraefikMiddleware
|
|
expected string
|
|
}{
|
|
{
|
|
name: "from config",
|
|
mw: models.TraefikMiddleware{
|
|
Name: "test-middleware",
|
|
Config: map[string]interface{}{
|
|
"plugin": map[string]interface{}{
|
|
"myPlugin": map[string]interface{}{},
|
|
},
|
|
},
|
|
},
|
|
expected: "myPlugin",
|
|
},
|
|
{
|
|
name: "from name with suffix",
|
|
mw: models.TraefikMiddleware{
|
|
Name: "badger@file",
|
|
},
|
|
expected: "badger",
|
|
},
|
|
{
|
|
// extractPluginName unconditionally strips the "-plugin" suffix.
|
|
name: "strips -plugin suffix from name",
|
|
mw: models.TraefikMiddleware{
|
|
Name: "simple-plugin",
|
|
},
|
|
expected: "simple",
|
|
},
|
|
{
|
|
name: "strip middleware suffix",
|
|
mw: models.TraefikMiddleware{
|
|
Name: "badger-middleware",
|
|
},
|
|
expected: "badger",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := extractPluginName(tt.mw)
|
|
if got != tt.expected {
|
|
t.Errorf("extractPluginName() = %q, want %q", got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestExtractPluginNameFromMiddlewareName tests name extraction from middleware name
|
|
func TestExtractPluginNameFromMiddlewareName(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
expected string
|
|
}{
|
|
{
|
|
name: "plugin prefix with suffix",
|
|
input: "plugin-badger@file",
|
|
expected: "badger",
|
|
},
|
|
{
|
|
name: "middleware suffix",
|
|
input: "test-middleware",
|
|
expected: "test",
|
|
},
|
|
{
|
|
name: "simple name",
|
|
input: "myPlugin",
|
|
expected: "myPlugin",
|
|
},
|
|
{
|
|
name: "with provider",
|
|
input: "auth@docker",
|
|
expected: "auth",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := extractPluginNameFromMiddlewareName(tt.input)
|
|
if got != tt.expected {
|
|
t.Errorf("extractPluginNameFromMiddlewareName(%q) = %q, want %q", tt.input, got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestExtractModuleName tests module name extraction
|
|
func TestExtractModuleName(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mw models.TraefikMiddleware
|
|
fallback string
|
|
expected string
|
|
}{
|
|
{
|
|
name: "from config",
|
|
mw: models.TraefikMiddleware{
|
|
Config: map[string]interface{}{
|
|
"plugin": map[string]interface{}{
|
|
"myPlugin": map[string]interface{}{
|
|
"moduleName": "github.com/example/my-plugin",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
fallback: "default",
|
|
expected: "github.com/example/my-plugin",
|
|
},
|
|
{
|
|
name: "fallback when not found",
|
|
mw: models.TraefikMiddleware{},
|
|
fallback: "fallback-module",
|
|
expected: "fallback-module",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := extractModuleName(tt.mw, tt.fallback)
|
|
if got != tt.expected {
|
|
t.Errorf("extractModuleName() = %q, want %q", got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestExtractVersion tests version extraction
|
|
func TestExtractVersion(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mw models.TraefikMiddleware
|
|
expected string
|
|
}{
|
|
{
|
|
name: "from config",
|
|
mw: models.TraefikMiddleware{
|
|
Config: map[string]interface{}{
|
|
"plugin": map[string]interface{}{
|
|
"myPlugin": map[string]interface{}{
|
|
"version": "v1.2.3",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: "v1.2.3",
|
|
},
|
|
{
|
|
name: "empty when not found",
|
|
mw: models.TraefikMiddleware{},
|
|
expected: "",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := extractVersion(tt.mw)
|
|
if got != tt.expected {
|
|
t.Errorf("extractVersion() = %q, want %q", got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestPluginFetcher_BuildPluginResponses tests building plugin responses
|
|
func TestPluginFetcher_BuildPluginResponses(t *testing.T) {
|
|
config := models.DataSourceConfig{
|
|
URL: "http://localhost:8080",
|
|
}
|
|
fetcher := NewPluginFetcher(config)
|
|
|
|
middlewares := []models.TraefikMiddleware{
|
|
{
|
|
Name: "badger@file",
|
|
Type: "plugin",
|
|
Provider: "file",
|
|
Config: map[string]interface{}{
|
|
"plugin": map[string]interface{}{
|
|
"badger": map[string]interface{}{},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
overview := &models.TraefikPluginOverview{}
|
|
overview.Plugins.Enabled = []string{"badger"}
|
|
|
|
plugins := fetcher.buildPluginResponses(middlewares, overview)
|
|
|
|
if len(plugins) == 0 {
|
|
t.Error("expected at least one plugin")
|
|
return
|
|
}
|
|
|
|
// Find the badger plugin
|
|
var found bool
|
|
for _, p := range plugins {
|
|
if p.Name == "badger" {
|
|
found = true
|
|
if p.Status != "enabled" {
|
|
t.Errorf("expected status 'enabled', got %q", p.Status)
|
|
}
|
|
if !p.IsInstalled {
|
|
t.Error("expected IsInstalled true")
|
|
}
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
t.Error("badger plugin not found in responses")
|
|
}
|
|
}
|
|
|
|
// TestParseNextDataPlugins tests parsing Next.js data structure
|
|
func TestParseNextDataPlugins(t *testing.T) {
|
|
validHTML := `<html><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"plugins":[{"id":"test","name":"Test Plugin","type":"middleware"}]}}}</script></html>`
|
|
|
|
plugins, err := parseNextDataPlugins(validHTML)
|
|
if err != nil {
|
|
t.Fatalf("parseNextDataPlugins() error = %v", err)
|
|
}
|
|
|
|
if len(plugins) != 1 {
|
|
t.Errorf("expected 1 plugin, got %d", len(plugins))
|
|
}
|
|
|
|
if len(plugins) > 0 && plugins[0].Name != "Test Plugin" {
|
|
t.Errorf("plugin name = %q, want 'Test Plugin'", plugins[0].Name)
|
|
}
|
|
}
|
|
|
|
// TestParseNextDataPlugins_InvalidHTML tests parsing invalid HTML
|
|
func TestParseNextDataPlugins_InvalidHTML(t *testing.T) {
|
|
_, err := parseNextDataPlugins("<html><body>No script here</body></html>")
|
|
if err == nil {
|
|
t.Error("parseNextDataPlugins() should error for invalid HTML")
|
|
}
|
|
}
|