Initial commit.

internal/protocol/protocol_test.go

@@ -0,0 +1,227 @@
+package protocol
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewRequest(t *testing.T) {
+	tests := []struct {
+		name    string
+		reqType RequestType
+		payload interface{}
+		wantErr bool
+	}{
+		{
+			name:    "ping request without payload",
+			reqType: RequestPing,
+			payload: nil,
+			wantErr: false,
+		},
+		{
+			name:    "set request with payload",
+			reqType: RequestSet,
+			payload: SetPayload{Alias: "test", Enabled: true},
+			wantErr: false,
+		},
+		{
+			name:    "preset request with payload",
+			reqType: RequestPreset,
+			payload: PresetPayload{Name: "local"},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req, err := NewRequest(tt.reqType, tt.payload)
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, tt.reqType, req.Type)
+			if tt.payload != nil {
+				assert.NotNil(t, req.Payload)
+			}
+		})
+	}
+}
+
+func TestRequest_ParsePayload(t *testing.T) {
+	t.Run("valid payload", func(t *testing.T) {
+		payload := SetPayload{Alias: "test-alias", Enabled: true, Force: false}
+		req, err := NewRequest(RequestSet, payload)
+		require.NoError(t, err)
+
+		var parsed SetPayload
+		err = req.ParsePayload(&parsed)
+		require.NoError(t, err)
+		assert.Equal(t, "test-alias", parsed.Alias)
+		assert.True(t, parsed.Enabled)
+		assert.False(t, parsed.Force)
+	})
+
+	t.Run("nil payload", func(t *testing.T) {
+		req := &Request{Type: RequestPing}
+		var parsed SetPayload
+		err := req.ParsePayload(&parsed)
+		assert.Error(t, err)
+	})
+}
+
+func TestNewOKResponse(t *testing.T) {
+	t.Run("with data", func(t *testing.T) {
+		data := StatusData{
+			Running:      true,
+			Version:      "1.0.0",
+			Uptime:       3600,
+			ActiveCount:  5,
+			RequestCount: 100,
+		}
+
+		resp, err := NewOKResponse(data)
+		require.NoError(t, err)
+		assert.Equal(t, "ok", resp.Status)
+		assert.NotNil(t, resp.Data)
+		assert.True(t, resp.IsOK())
+	})
+
+	t.Run("without data", func(t *testing.T) {
+		resp, err := NewOKResponse(nil)
+		require.NoError(t, err)
+		assert.Equal(t, "ok", resp.Status)
+		assert.Nil(t, resp.Data)
+	})
+}
+
+func TestNewErrorResponse(t *testing.T) {
+	resp := NewErrorResponse(ErrCodeBlockedDomain, "domain is blocked")
+
+	assert.Equal(t, "error", resp.Status)
+	assert.Equal(t, ErrCodeBlockedDomain, resp.Code)
+	assert.Equal(t, "domain is blocked", resp.Message)
+	assert.False(t, resp.IsOK())
+}
+
+func TestResponse_ParseData(t *testing.T) {
+	t.Run("valid data", func(t *testing.T) {
+		data := ListData{
+			Entries: []HostEntry{
+				{Domain: "example.com", IP: "127.0.0.1", Alias: "example", Enabled: true, Group: "dev"},
+			},
+		}
+		resp, err := NewOKResponse(data)
+		require.NoError(t, err)
+
+		var parsed ListData
+		err = resp.ParseData(&parsed)
+		require.NoError(t, err)
+		assert.Len(t, parsed.Entries, 1)
+		assert.Equal(t, "example.com", parsed.Entries[0].Domain)
+	})
+
+	t.Run("nil data", func(t *testing.T) {
+		resp := &Response{Status: "ok"}
+		var parsed ListData
+		err := resp.ParseData(&parsed)
+		assert.Error(t, err)
+	})
+}
+
+func TestRequestTypes(t *testing.T) {
+	types := []RequestType{
+		RequestPing,
+		RequestStatus,
+		RequestList,
+		RequestSet,
+		RequestSync,
+		RequestPreset,
+		RequestRollback,
+		RequestBackups,
+	}
+
+	for _, rt := range types {
+		t.Run(string(rt), func(t *testing.T) {
+			req, err := NewRequest(rt, nil)
+			require.NoError(t, err)
+			assert.Equal(t, rt, req.Type)
+
+			// Verify JSON marshaling works
+			data, err := json.Marshal(req)
+			require.NoError(t, err)
+			assert.Contains(t, string(data), string(rt))
+		})
+	}
+}
+
+func TestErrorCodes(t *testing.T) {
+	codes := []ErrorCode{
+		ErrCodeInvalidRequest,
+		ErrCodeInvalidDomain,
+		ErrCodeInvalidIP,
+		ErrCodeBlockedDomain,
+		ErrCodeRateLimited,
+		ErrCodeNotFound,
+		ErrCodeConflict,
+		ErrCodeInternalError,
+		ErrCodePermissionError,
+	}
+
+	for _, code := range codes {
+		t.Run(string(code), func(t *testing.T) {
+			resp := NewErrorResponse(code, "test error")
+			assert.Equal(t, code, resp.Code)
+
+			// Verify JSON marshaling works
+			data, err := json.Marshal(resp)
+			require.NoError(t, err)
+			assert.Contains(t, string(data), string(code))
+		})
+	}
+}
+
+func TestHostEntry(t *testing.T) {
+	entry := HostEntry{
+		Domain:  "example.com",
+		IP:      "127.0.0.1",
+		Alias:   "example-local",
+		Enabled: true,
+		Group:   "development",
+	}
+
+	data, err := json.Marshal(entry)
+	require.NoError(t, err)
+
+	var parsed HostEntry
+	err = json.Unmarshal(data, &parsed)
+	require.NoError(t, err)
+
+	assert.Equal(t, entry.Domain, parsed.Domain)
+	assert.Equal(t, entry.IP, parsed.IP)
+	assert.Equal(t, entry.Alias, parsed.Alias)
+	assert.Equal(t, entry.Enabled, parsed.Enabled)
+	assert.Equal(t, entry.Group, parsed.Group)
+}
+
+func TestBackupInfo(t *testing.T) {
+	info := BackupInfo{
+		Name:      "hosts.20231201-120000.bak",
+		Timestamp: 1701432000,
+		Size:      1024,
+	}
+
+	data, err := json.Marshal(info)
+	require.NoError(t, err)
+
+	var parsed BackupInfo
+	err = json.Unmarshal(data, &parsed)
+	require.NoError(t, err)
+
+	assert.Equal(t, info.Name, parsed.Name)
+	assert.Equal(t, info.Timestamp, parsed.Timestamp)
+	assert.Equal(t, info.Size, parsed.Size)
+}