Improve README SEO and increase test coverage to 50%

Optimized README for better discoverability with keywords: api, habits, self-hosted. Consolidated content to reduce redundancy while maintaining clarity.

Added comprehensive test coverage across multiple layers:
- Infrastructure: bcrypt hashing, JWT tokens, configuration validation
- Application commands: user deletion, password reset, token revocation, email verification
- Application queries: login, token refresh
- Domain entities: refresh tokens, password reset tokens

Coverage increased from 42.5% to 50.8% with meaningful business logic tests.

Fixed integration test handler initialization with correct parameters.

internal/application/commands/revoke_token_test.go

@@ -0,0 +1,188 @@
+package commands
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"apocapoc-api/internal/domain/entities"
+	"apocapoc-api/internal/shared/errors"
+)
+
+type mockRefreshTokenRepo struct {
+	tokens map[string]*entities.RefreshToken
+}
+
+func (m *mockRefreshTokenRepo) Create(ctx context.Context, token *entities.RefreshToken) error {
+	m.tokens[token.Token] = token
+	return nil
+}
+
+func (m *mockRefreshTokenRepo) FindByToken(ctx context.Context, token string) (*entities.RefreshToken, error) {
+	if t, ok := m.tokens[token]; ok {
+		return t, nil
+	}
+	return nil, errors.ErrNotFound
+}
+
+func (m *mockRefreshTokenRepo) FindByUserID(ctx context.Context, userID string) ([]*entities.RefreshToken, error) {
+	var tokens []*entities.RefreshToken
+	for _, t := range m.tokens {
+		if t.UserID == userID {
+			tokens = append(tokens, t)
+		}
+	}
+	return tokens, nil
+}
+
+func (m *mockRefreshTokenRepo) RevokeByToken(ctx context.Context, token string) error {
+	if t, ok := m.tokens[token]; ok {
+		t.Revoke()
+		return nil
+	}
+	return errors.ErrNotFound
+}
+
+func (m *mockRefreshTokenRepo) RevokeAllByUserID(ctx context.Context, userID string) error {
+	for _, t := range m.tokens {
+		if t.UserID == userID {
+			t.Revoke()
+		}
+	}
+	return nil
+}
+
+func (m *mockRefreshTokenRepo) DeleteExpired(ctx context.Context) error {
+	return nil
+}
+
+func TestRevokeTokenHandler_Handle(t *testing.T) {
+	repo := &mockRefreshTokenRepo{
+		tokens: make(map[string]*entities.RefreshToken),
+	}
+
+	handler := NewRevokeTokenHandler(repo)
+
+	token := entities.NewRefreshToken("user-123", "valid-token", time.Now().Add(24*time.Hour))
+	repo.Create(context.Background(), token)
+
+	tests := []struct {
+		name        string
+		cmd         RevokeTokenCommand
+		expectError bool
+		expectedErr error
+	}{
+		{
+			name: "revoke valid token",
+			cmd: RevokeTokenCommand{
+				RefreshToken: "valid-token",
+			},
+			expectError: false,
+		},
+		{
+			name: "revoke empty token",
+			cmd: RevokeTokenCommand{
+				RefreshToken: "",
+			},
+			expectError: true,
+			expectedErr: errors.ErrInvalidInput,
+		},
+		{
+			name: "revoke non-existent token",
+			cmd: RevokeTokenCommand{
+				RefreshToken: "non-existent-token",
+			},
+			expectError: true,
+			expectedErr: errors.ErrNotFound,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := handler.Handle(context.Background(), tt.cmd)
+
+			if tt.expectError {
+				if err == nil {
+					t.Fatal("Handle() expected error but got nil")
+				}
+				if tt.expectedErr != nil && err != tt.expectedErr {
+					t.Errorf("Handle() error = %v, want %v", err, tt.expectedErr)
+				}
+			} else {
+				if err != nil {
+					t.Fatalf("Handle() unexpected error = %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestRevokeAllTokensHandler_Handle(t *testing.T) {
+	repo := &mockRefreshTokenRepo{
+		tokens: make(map[string]*entities.RefreshToken),
+	}
+
+	handler := NewRevokeAllTokensHandler(repo)
+
+	token1 := entities.NewRefreshToken("user-123", "token-1", time.Now().Add(24*time.Hour))
+	token2 := entities.NewRefreshToken("user-123", "token-2", time.Now().Add(24*time.Hour))
+	token3 := entities.NewRefreshToken("user-456", "token-3", time.Now().Add(24*time.Hour))
+
+	repo.Create(context.Background(), token1)
+	repo.Create(context.Background(), token2)
+	repo.Create(context.Background(), token3)
+
+	tests := []struct {
+		name        string
+		cmd         RevokeAllTokensCommand
+		expectError bool
+		expectedErr error
+	}{
+		{
+			name: "revoke all tokens for user",
+			cmd: RevokeAllTokensCommand{
+				UserID: "user-123",
+			},
+			expectError: false,
+		},
+		{
+			name: "revoke with empty user ID",
+			cmd: RevokeAllTokensCommand{
+				UserID: "",
+			},
+			expectError: true,
+			expectedErr: errors.ErrInvalidInput,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := handler.Handle(context.Background(), tt.cmd)
+
+			if tt.expectError {
+				if err == nil {
+					t.Fatal("Handle() expected error but got nil")
+				}
+				if tt.expectedErr != nil && err != tt.expectedErr {
+					t.Errorf("Handle() error = %v, want %v", err, tt.expectedErr)
+				}
+			} else {
+				if err != nil {
+					t.Fatalf("Handle() unexpected error = %v", err)
+				}
+
+				if !tt.expectError && tt.cmd.UserID == "user-123" {
+					if repo.tokens["token-1"].RevokedAt == nil {
+						t.Error("token-1 should be revoked")
+					}
+					if repo.tokens["token-2"].RevokedAt == nil {
+						t.Error("token-2 should be revoked")
+					}
+					if repo.tokens["token-3"].RevokedAt != nil {
+						t.Error("token-3 should not be revoked")
+					}
+				}
+			}
+		})
+	}
+}