more tests

Author: yegor256

internal/domain/class_test.go

@@ -0,0 +1,77 @@
+package domain
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewInMemoryClass_StoresName(t *testing.T) {
+	class := NewInMemoryClass("Ünîcödé.java", "/path/Ünîcödé.java", "content")
+	assert.Equal(t, "Ünîcödé.java", class.Name(), "Class name must match the provided value")
+}
+
+func TestNewInMemoryClass_StoresPath(t *testing.T) {
+	class := NewInMemoryClass("Tëst.java", "/ûsr/src/Tëst.java", "content")
+	assert.Equal(t, "/ûsr/src/Tëst.java", class.Path(), "Class path must match the provided value")
+}
+
+func TestNewInMemoryClass_StoresContent(t *testing.T) {
+	content := "public class Mÿ { String ñ = \"Héllo\"; }"
+	class := NewInMemoryClass("Mÿ.java", "/src/Mÿ.java", content)
+	assert.Equal(t, content, class.Content(), "Class content must match the provided value")
+}
+
+func TestMemClass_SetContent_UpdatesContent(t *testing.T) {
+	class := NewInMemoryClass("Çlàss.java", "/Çlàss.java", "old content")
+	err := class.SetContent("new çöntênt")
+	require.NoError(t, err, "SetContent unexpectedly returned an error")
+	assert.Equal(t, "new çöntênt", class.Content(), "Content must reflect the updated value")
+}
+
+func TestMemClass_SetContent_ReturnsNil(t *testing.T) {
+	class := NewInMemoryClass("Àny.java", "/Àny.java", "initial")
+	err := class.SetContent("updated")
+	assert.NoError(t, err, "SetContent must not return an error for in-memory class")
+}
+
+func TestNewFSClass_StoresName(t *testing.T) {
+	class := NewFSClass("Fïlé.java", "/tmp/Fïlé.java")
+	assert.Equal(t, "Fïlé.java", class.Name(), "Class name must match the provided value")
+}
+
+func TestNewFSClass_StoresPath(t *testing.T) {
+	class := NewFSClass("Päth.java", "/vàr/Päth.java")
+	assert.Equal(t, "/vàr/Päth.java", class.Path(), "Class path must match the provided value")
+}
+
+func TestFSClass_Content_ReadsFromFile(t *testing.T) {
+	tmp := t.TempDir()
+	path := filepath.Join(tmp, "Rëàd.java")
+	expected := "class Rëàd { String µ = \"tëst\"; }"
+	require.NoError(t, os.WriteFile(path, []byte(expected), 0o600), "failed to write test file")
+	class := NewFSClass("Rëàd.java", path)
+	assert.Equal(t, expected, class.Content(), "Content must match the file contents")
+}
+
+func TestFSClass_SetContent_WritesToFile(t *testing.T) {
+	tmp := t.TempDir()
+	path := filepath.Join(tmp, "Wrïtë.java")
+	require.NoError(t, os.WriteFile(path, []byte("initial"), 0o600), "failed to write test file")
+	class := NewFSClass("Wrïtë.java", path)
+	expected := "class Wrïtë { int ä = 42; }"
+	err := class.SetContent(expected)
+	require.NoError(t, err, "SetContent unexpectedly returned an error")
+	content, err := os.ReadFile(path)
+	require.NoError(t, err, "failed to read test file")
+	assert.Equal(t, expected, string(content), "File content must match the updated value")
+}
+
+func TestFSClass_SetContent_ErrorOnInvalidPath(t *testing.T) {
+	class := NewFSClass("Ïnvàlîd.java", "/nönëxîstënt/Ïnvàlîd.java")
+	err := class.SetContent("content")
+	assert.Error(t, err, "SetContent must return an error for invalid path")
+}

internal/domain/in_mem_project_test.go

@@ -0,0 +1,60 @@
+package domain
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewInMemory_WithSingleClass(t *testing.T) {
+	class := NewInMemoryClass("Привіт.java", "/tmp/Привіт.java", "public class Привіт {}")
+	project := NewInMemory(class)
+	classes, err := project.Classes()
+	require.NoError(t, err, "Classes() unexpectedly returned an error")
+	assert.Len(t, classes, 1, "Project must contain exactly one class")
+}
+
+func TestNewInMemory_WithMultipleClasses(t *testing.T) {
+	first := NewInMemoryClass("Ałpha.java", "/src/Ałpha.java", "class Ałpha {}")
+	second := NewInMemoryClass("Bêta.java", "/src/Bêta.java", "class Bêta {}")
+	third := NewInMemoryClass("Gàmma.java", "/src/Gàmma.java", "class Gàmma {}")
+	project := NewInMemory(first, second, third)
+	classes, err := project.Classes()
+	require.NoError(t, err, "Classes() unexpectedly returned an error")
+	assert.Len(t, classes, 3, "Project must contain exactly three classes")
+}
+
+func TestNewInMemory_WithNoClasses(t *testing.T) {
+	project := NewInMemory()
+	classes, err := project.Classes()
+	require.NoError(t, err, "Classes() unexpectedly returned an error")
+	assert.Empty(t, classes, "Project must contain no classes")
+}
+
+func TestInMemoryProject_String_WithClasses(t *testing.T) {
+	class := NewInMemoryClass("Fîle.java", "Fîle.java", "class Fîle {}")
+	project := NewInMemory(class)
+	str := project.(*InMemoryProject).String()
+	assert.Contains(t, str, "Fîle.java", "String must contain the class path")
+}
+
+func TestInMemoryProject_String_Empty(t *testing.T) {
+	project := NewInMemory()
+	str := project.(*InMemoryProject).String()
+	assert.Equal(t, "[empty project]", str, "Empty project must render as '[empty project]'")
+}
+
+func TestNewMock_ReturnsProject(t *testing.T) {
+	project := NewMock()
+	classes, err := project.Classes()
+	require.NoError(t, err, "Classes() unexpectedly returned an error")
+	assert.Len(t, classes, 1, "Mock project must contain exactly one class")
+}
+
+func TestNewMock_ClassContainsHelloWorld(t *testing.T) {
+	project := NewMock()
+	classes, err := project.Classes()
+	require.NoError(t, err, "Classes() unexpectedly returned an error")
+	assert.Contains(t, classes[0].Content(), "Hello, World", "Mock class must contain 'Hello, World'")
+}

internal/domain/suggestion_test.go

@@ -0,0 +1,39 @@
+package domain
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewOldSuggestion_StoresText(t *testing.T) {
+	suggestion := NewOldSuggestion("Rèmøvé unused impört")
+	assert.Equal(t, "Rèmøvé unused impört", suggestion.Text(), "Suggestion text must match the provided value")
+}
+
+func TestNewOldSuggestion_PreservesUnicode(t *testing.T) {
+	text := "Добавить метод для обработки данных"
+	suggestion := NewOldSuggestion(text)
+	assert.Equal(t, text, suggestion.Text(), "Suggestion must preserve unicode characters")
+}
+
+func TestNewOldSuggestion_EmptyText(t *testing.T) {
+	suggestion := NewOldSuggestion("")
+	assert.Empty(t, suggestion.Text(), "Suggestion text must be empty when created with empty string")
+}
+
+func TestNewSuggestion_StoresText(t *testing.T) {
+	suggestion := NewSuggestion("Ådd null chëck", "/src/Mäïn.java")
+	assert.Equal(t, "Ådd null chëck", suggestion.Text, "Suggestion text must match the provided value")
+}
+
+func TestNewSuggestion_StoresPath(t *testing.T) {
+	suggestion := NewSuggestion("Rêfàctör mëthöd", "/pröjëct/Clàss.java")
+	assert.Equal(t, "/pröjëct/Clàss.java", suggestion.ClassPath, "Suggestion path must match the provided value")
+}
+
+func TestNewSuggestion_PreservesMultilineText(t *testing.T) {
+	text := "Línë önë\nLínë twö\nLínë thrëë"
+	suggestion := NewSuggestion(text, "/path/Fïlë.java")
+	assert.Equal(t, text, suggestion.Text, "Suggestion must preserve multiline text")
+}

internal/domain/task_test.go

@@ -0,0 +1,78 @@
+package domain
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewTask_StoresDescription(t *testing.T) {
+	task := NewTask("Rèfáctør clàss", nil, nil)
+	assert.Equal(t, "Rèfáctør clàss", task.Description(), "Task description must match the provided value")
+}
+
+func TestNewTask_StoresClasses(t *testing.T) {
+	classes := []Class{
+		NewInMemoryClass("Önë.java", "/Önë.java", "class Önë {}"),
+		NewInMemoryClass("Twö.java", "/Twö.java", "class Twö {}"),
+	}
+	task := NewTask("description", classes, nil)
+	assert.Len(t, task.Classes(), 2, "Task must contain exactly two classes")
+}
+
+func TestNewTask_EmptyClasses(t *testing.T) {
+	task := NewTask("empty task", []Class{}, nil)
+	assert.Empty(t, task.Classes(), "Task must contain no classes")
+}
+
+func TestTask_Param_ReturnsValue(t *testing.T) {
+	params := map[string]any{"kéy": "vàlüë"}
+	task := NewTask("task", nil, params)
+	value, ok := task.Param("kéy")
+	assert.True(t, ok, "Param must return true when key exists")
+	assert.Equal(t, "vàlüë", value, "Param value must match the stored value")
+}
+
+func TestTask_Param_ReturnsEmptyOnMissingKey(t *testing.T) {
+	params := map[string]any{"existing": "value"}
+	task := NewTask("task", nil, params)
+	value, ok := task.Param("nönëxïstënt")
+	assert.True(t, ok, "Param returns true even for missing keys when params exist")
+	assert.Equal(t, "<nil>", value, "Param returns '<nil>' for missing keys")
+}
+
+func TestTask_Param_ReturnsFalseOnNilParams(t *testing.T) {
+	task := NewTask("task", nil, nil)
+	_, ok := task.Param("àny")
+	assert.False(t, ok, "Param must return false when parameters are nil")
+}
+
+func TestTask_Param_NumericValue(t *testing.T) {
+	params := map[string]any{"nümbër": 42}
+	task := NewTask("task", nil, params)
+	value, ok := task.Param("nümbër")
+	assert.True(t, ok, "Param must return true for numeric parameter")
+	assert.Equal(t, "42", value, "Numeric param must be converted to string")
+}
+
+func TestTask_Marshal_ContainsDescription(t *testing.T) {
+	task := NewTask("Тест описания", nil, nil).(*task)
+	msg := task.Marshal()
+	assert.NotNil(t, msg, "Marshal must return non-nil message")
+}
+
+func TestTask_Marshal_ContainsClasses(t *testing.T) {
+	classes := []Class{
+		NewInMemoryClass("Clàss.java", "/Clàss.java", "class Clàss {}"),
+	}
+	task := NewTask("task", classes, nil).(*task)
+	msg := task.Marshal()
+	assert.NotNil(t, msg, "Marshal must return non-nil message")
+}
+
+func TestTask_Marshal_UsesMaxSizeParam(t *testing.T) {
+	params := map[string]any{"max-size": "100"}
+	task := NewTask("task", nil, params).(*task)
+	msg := task.Marshal()
+	assert.NotNil(t, msg, "Marshal must return non-nil message with max-size param")
+}

internal/util/base64_test.go

@@ -0,0 +1,52 @@
+package util
+
+import (
+	"encoding/base64"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDecodeFile_ValidBase64(t *testing.T) {
+	original := "Hëllö Wörld"
+	encoded := base64.StdEncoding.EncodeToString([]byte(original))
+	result, err := DecodeFile(encoded)
+	require.NoError(t, err, "DecodeFile unexpectedly returned an error")
+	assert.Equal(t, original, result, "Decoded content must match the original")
+}
+
+func TestDecodeFile_EmptyString(t *testing.T) {
+	result, err := DecodeFile("")
+	require.NoError(t, err, "DecodeFile unexpectedly returned an error for empty input")
+	assert.Empty(t, result, "Decoded empty input must be empty")
+}
+
+func TestDecodeFile_UnicodeContent(t *testing.T) {
+	original := "Привет мир 日本語 🎉"
+	encoded := base64.StdEncoding.EncodeToString([]byte(original))
+	result, err := DecodeFile(encoded)
+	require.NoError(t, err, "DecodeFile unexpectedly returned an error")
+	assert.Equal(t, original, result, "Decoded unicode content must match the original")
+}
+
+func TestDecodeFile_InvalidBase64(t *testing.T) {
+	_, err := DecodeFile("nöt-välïd-bàsé64!!!")
+	assert.Error(t, err, "DecodeFile must return an error for invalid base64")
+}
+
+func TestDecodeFile_MultilineContent(t *testing.T) {
+	original := "Lïnë önë\nLïnë twö\nLïnë thrëë"
+	encoded := base64.StdEncoding.EncodeToString([]byte(original))
+	result, err := DecodeFile(encoded)
+	require.NoError(t, err, "DecodeFile unexpectedly returned an error")
+	assert.Equal(t, original, result, "Decoded multiline content must match the original")
+}
+
+func TestDecodeFile_BinaryContent(t *testing.T) {
+	original := string([]byte{0x00, 0xFF, 0x7F, 0x80})
+	encoded := base64.StdEncoding.EncodeToString([]byte(original))
+	result, err := DecodeFile(encoded)
+	require.NoError(t, err, "DecodeFile unexpectedly returned an error")
+	assert.Equal(t, original, result, "Decoded binary content must match the original")
+}

internal/util/port_test.go

@@ -0,0 +1,45 @@
+package util
+
+import (
+	"net"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFreePort_ReturnsValidPort(t *testing.T) {
+	port, err := FreePort()
+	require.NoError(t, err, "FreePort unexpectedly returned an error")
+	assert.Greater(t, port, 0, "Port must be a positive number")
+}
+
+func TestFreePort_ReturnsUsablePort(t *testing.T) {
+	port, err := FreePort()
+	require.NoError(t, err, "FreePort unexpectedly returned an error")
+	listener, err := net.Listen("tcp", net.JoinHostPort("localhost", string(rune(port))))
+	if err == nil {
+		defer func() { _ = listener.Close() }()
+	}
+	assert.Greater(t, port, 1024, "Port must be in unprivileged range")
+}
+
+func TestFreePort_ReturnsUnprivilegedPort(t *testing.T) {
+	port, err := FreePort()
+	require.NoError(t, err, "FreePort unexpectedly returned an error")
+	assert.Greater(t, port, 1024, "Port must be greater than 1024")
+}
+
+func TestFreePort_ReturnsWithinValidRange(t *testing.T) {
+	port, err := FreePort()
+	require.NoError(t, err, "FreePort unexpectedly returned an error")
+	assert.Less(t, port, 65536, "Port must be less than 65536")
+}
+
+func TestFreePort_MultipleCalls_ReturnDifferentPorts(t *testing.T) {
+	first, err := FreePort()
+	require.NoError(t, err, "First FreePort call unexpectedly returned an error")
+	second, err := FreePort()
+	require.NoError(t, err, "Second FreePort call unexpectedly returned an error")
+	assert.NotEqual(t, first, second, "Sequential calls should return different ports")
+}