nginx-ui/internal/nginx_log/analytics/service_test.go

package analytics

import (
	"context"
	"errors"
	"testing"

	"github.com/0xJacky/Nginx-UI/internal/nginx_log/searcher"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
)

// MockSearcher implements searcher.Searcher for testing
type MockSearcher struct {
	mock.Mock
}

func (m *MockSearcher) Search(ctx context.Context, req *searcher.SearchRequest) (*searcher.SearchResult, error) {
	args := m.Called(ctx, req)
	if args.Get(0) == nil {
		return nil, args.Error(1)
	}
	return args.Get(0).(*searcher.SearchResult), args.Error(1)
}

func (m *MockSearcher) SearchAsync(ctx context.Context, req *searcher.SearchRequest) (<-chan *searcher.SearchResult, <-chan error) {
	args := m.Called(ctx, req)
	return args.Get(0).(<-chan *searcher.SearchResult), args.Get(1).(<-chan error)
}

func (m *MockSearcher) Aggregate(ctx context.Context, req *searcher.AggregationRequest) (*searcher.AggregationResult, error) {
	args := m.Called(ctx, req)
	if args.Get(0) == nil {
		return nil, args.Error(1)
	}
	return args.Get(0).(*searcher.AggregationResult), args.Error(1)
}

func (m *MockSearcher) Suggest(ctx context.Context, text string, field string, size int) ([]*searcher.Suggestion, error) {
	args := m.Called(ctx, text, field, size)
	if args.Get(0) == nil {
		return nil, args.Error(1)
	}
	return args.Get(0).([]*searcher.Suggestion), args.Error(1)
}

func (m *MockSearcher) Analyze(ctx context.Context, text string, analyzer string) ([]string, error) {
	args := m.Called(ctx, text, analyzer)
	if args.Get(0) == nil {
		return nil, args.Error(1)
	}
	return args.Get(0).([]string), args.Error(1)
}

func (m *MockSearcher) ClearCache() error {
	args := m.Called()
	return args.Error(0)
}

func (m *MockSearcher) GetCacheStats() *searcher.CacheStats {
	args := m.Called()
	if args.Get(0) == nil {
		return nil
	}
	return args.Get(0).(*searcher.CacheStats)
}

func (m *MockSearcher) IsHealthy() bool {
	args := m.Called()
	return args.Bool(0)
}

func (m *MockSearcher) GetStats() *searcher.Stats {
	args := m.Called()
	if args.Get(0) == nil {
		return nil
	}
	return args.Get(0).(*searcher.Stats)
}

func (m *MockSearcher) GetConfig() *searcher.Config {
	args := m.Called()
	if args.Get(0) == nil {
		return nil
	}
	return args.Get(0).(*searcher.Config)
}

func (m *MockSearcher) Stop() error {
	args := m.Called()
	return args.Error(0)
}

func TestNewService(t *testing.T) {
	mockSearcher := &MockSearcher{}
	service := NewService(mockSearcher)

	assert.NotNil(t, service)
	assert.Implements(t, (*Service)(nil), service)
}

func TestService_ValidateLogPath(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher)

	tests := []struct {
		name    string
		logPath string
		wantErr bool
	}{
		{
			name:    "empty path should be valid",
			logPath: "",
			wantErr: false,
		},
		{
			name:    "non-empty path should be invalid without whitelist",
			logPath: "/var/log/nginx/access.log",
			wantErr: true, // In test environment, no whitelist is configured
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := s.ValidateLogPath(tt.logPath)
			if tt.wantErr {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
			}
		})
	}
}

func TestService_ValidateTimeRange(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher)

	tests := []struct {
		name      string
		startTime int64
		endTime   int64
		wantErr   bool
	}{
		{
			name:      "valid time range",
			startTime: 1000,
			endTime:   2000,
			wantErr:   false,
		},
		{
			name:      "same start and end time should error",
			startTime: 1000,
			endTime:   1000,
			wantErr:   true,
		},
		{
			name:      "start time after end time should error",
			startTime: 2000,
			endTime:   1000,
			wantErr:   true,
		},
		{
			name:      "negative start time should error",
			startTime: -1000,
			endTime:   2000,
			wantErr:   true,
		},
		{
			name:      "negative end time should error",
			startTime: 1000,
			endTime:   -2000,
			wantErr:   true,
		},
		{
			name:      "zero values should be valid",
			startTime: 0,
			endTime:   0,
			wantErr:   false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := s.ValidateTimeRange(tt.startTime, tt.endTime)
			if tt.wantErr {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)
			}
		})
	}
}

func TestService_GetTopPaths_Basic(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher)

	ctx := context.Background()
	req := &TopListRequest{
		StartTime: 1000,
		EndTime:   2000,
		LogPath:   "/var/log/nginx/access.log",
		Limit:     10,
		Field:     FieldPath,
	}

	expectedResult := &searcher.SearchResult{
		TotalHits: 100,
		Facets: map[string]*searcher.Facet{
			"path_exact": {
				Field: "path_exact",
				Total: 100,
				Terms: []*searcher.FacetTerm{
					{Term: "/api/users", Count: 50},
					{Term: "/api/posts", Count: 30},
					{Term: "/", Count: 20},
				},
			},
		},
	}

	mockSearcher.On("Search", ctx, mock.AnythingOfType("*searcher.SearchRequest")).Return(expectedResult, nil)

	result, err := s.GetTopPaths(ctx, req)

	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Len(t, result, 3)
	assert.Equal(t, "/api/users", result[0].Key)
	assert.Equal(t, 50, result[0].Value)
	assert.Equal(t, "/api/posts", result[1].Key)
	assert.Equal(t, 30, result[1].Value)

	mockSearcher.AssertExpectations(t)
}

func TestService_GetTopPaths_NilRequest(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher)

	ctx := context.Background()
	result, err := s.GetTopPaths(ctx, nil)

	assert.Error(t, err)
	assert.Nil(t, result)
	assert.Contains(t, err.Error(), "request cannot be nil")
}

func TestService_GetTopPaths_SearchError(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher)

	ctx := context.Background()
	req := &TopListRequest{
		StartTime: 1000,
		EndTime:   2000,
		Limit:     10,
		Field:     FieldPath,
	}

	expectedError := errors.New("search failed")
	mockSearcher.On("Search", ctx, mock.AnythingOfType("*searcher.SearchRequest")).Return(nil, expectedError)

	result, err := s.GetTopPaths(ctx, req)

	assert.Error(t, err)
	assert.Nil(t, result)
	assert.Contains(t, err.Error(), "failed to get top paths")

	mockSearcher.AssertExpectations(t)
}

func TestService_GetTopIPs_Basic(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher)

	ctx := context.Background()
	req := &TopListRequest{
		StartTime: 1000,
		EndTime:   2000,
		Limit:     5,
		Field:     FieldIP,
	}

	expectedResult := &searcher.SearchResult{
		TotalHits: 100,
		Facets: map[string]*searcher.Facet{
			"ip": {
				Field: "ip",
				Total: 100,
				Terms: []*searcher.FacetTerm{
					{Term: "192.168.1.1", Count: 40},
					{Term: "192.168.1.2", Count: 30},
					{Term: "192.168.1.3", Count: 30},
				},
			},
		},
	}

	mockSearcher.On("Search", ctx, mock.AnythingOfType("*searcher.SearchRequest")).Return(expectedResult, nil)

	result, err := s.GetTopIPs(ctx, req)

	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Len(t, result, 3)
	assert.Equal(t, "192.168.1.1", result[0].Key)
	assert.Equal(t, 40, result[0].Value)

	mockSearcher.AssertExpectations(t)
}

func TestService_GetLogEntriesStats_Basic(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher)

	ctx := context.Background()
	req := &searcher.SearchRequest{
		Limit:  100,
		Offset: 0,
	}

	expectedResult := &searcher.SearchResult{
		TotalHits: 1000,
		Facets: map[string]*searcher.Facet{
			"status": {
				Terms: []*searcher.FacetTerm{
					{Term: "200", Count: 800},
					{Term: "404", Count: 150},
					{Term: "500", Count: 50},
				},
			},
			"method": {
				Terms: []*searcher.FacetTerm{
					{Term: "GET", Count: 700},
					{Term: "POST", Count: 300},
				},
			},
			"path_exact": {
				Terms: []*searcher.FacetTerm{
					{Term: "/api/users", Count: 400},
					{Term: "/api/posts", Count: 300},
				},
			},
			"ip": {
				Terms: []*searcher.FacetTerm{
					{Term: "192.168.1.1", Count: 500},
					{Term: "192.168.1.2", Count: 300},
				},
			},
			"user_agent": {
				Terms: []*searcher.FacetTerm{
					{Term: "Chrome", Count: 600},
					{Term: "Firefox", Count: 400},
				},
			},
		},
		Stats: &searcher.SearchStats{
			TotalBytes: 1000000,
			AvgBytes:   1000,
			MinBytes:   100,
			MaxBytes:   5000,
			AvgReqTime: 0.5,
			MinReqTime: 0.1,
			MaxReqTime: 2.0,
		},
	}

	mockSearcher.On("Search", ctx, mock.AnythingOfType("*searcher.SearchRequest")).Return(expectedResult, nil)

	result, err := s.GetLogEntriesStats(ctx, req)

	assert.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, int64(1000), result.TotalEntries)
	assert.Equal(t, 800, result.StatusCodeDist["200"])
	assert.Equal(t, 150, result.StatusCodeDist["404"])
	assert.Equal(t, 700, result.MethodDist["GET"])
	assert.Equal(t, 300, result.MethodDist["POST"])
	assert.NotNil(t, result.BytesStats)
	assert.Equal(t, int64(1000000), result.BytesStats.Total)
	assert.NotNil(t, result.ResponseTimeStats)
	assert.Equal(t, 0.5, result.ResponseTimeStats.Average)

	mockSearcher.AssertExpectations(t)
}

func TestService_buildBaseSearchRequest(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher).(*service)

	tests := []struct {
		name      string
		startTime int64
		endTime   int64
		logPath   string
	}{
		{
			name:      "with time range",
			startTime: 1000,
			endTime:   2000,
			logPath:   "/var/log/nginx/access.log",
		},
		{
			name:      "without time range",
			startTime: 0,
			endTime:   0,
			logPath:   "",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			req := s.buildBaseSearchRequest(tt.startTime, tt.endTime, tt.logPath)

			assert.NotNil(t, req)
			assert.Equal(t, DefaultLimit, req.Limit)
			assert.Equal(t, 0, req.Offset)
			assert.True(t, req.UseCache)

			if tt.startTime > 0 {
				assert.NotNil(t, req.StartTime)
				assert.Equal(t, tt.startTime, *req.StartTime)
			} else {
				assert.Nil(t, req.StartTime)
			}

			if tt.endTime > 0 {
				assert.NotNil(t, req.EndTime)
				assert.Equal(t, tt.endTime, *req.EndTime)
			} else {
				assert.Nil(t, req.EndTime)
			}
		})
	}
}

func TestService_validateAndNormalizeSearchRequest(t *testing.T) {
	mockSearcher := &MockSearcher{}
	s := NewService(mockSearcher).(*service)

	tests := []struct {
		name    string
		req     *searcher.SearchRequest
		wantErr bool
	}{
		{
			name:    "nil request",
			req:     nil,
			wantErr: true,
		},
		{
			name: "valid request",
			req: &searcher.SearchRequest{
				Limit:  10,
				Offset: 0,
			},
			wantErr: false,
		},
		{
			name: "zero limit gets default",
			req: &searcher.SearchRequest{
				Limit:  0,
				Offset: 0,
			},
			wantErr: false,
		},
		{
			name: "negative offset gets normalized",
			req: &searcher.SearchRequest{
				Limit:  10,
				Offset: -10,
			},
			wantErr: false,
		},
		{
			name: "limit too high gets capped",
			req: &searcher.SearchRequest{
				Limit:  10000,
				Offset: 0,
			},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := s.validateAndNormalizeSearchRequest(tt.req)

			if tt.wantErr {
				assert.Error(t, err)
			} else {
				assert.NoError(t, err)

				if tt.req != nil {
					if tt.name == "zero limit gets default" {
						assert.Equal(t, DefaultLimit, tt.req.Limit)
					}
					if tt.name == "negative offset gets normalized" {
						assert.Equal(t, 0, tt.req.Offset)
					}
					if tt.name == "limit too high gets capped" {
						assert.Equal(t, MaxLimit, tt.req.Limit)
					}
				}
			}
		})
	}
}