Merge pull request #18 from shekshuev/iter23

Iter23

Author: shekshuev

cmd/shortener/main.go

@@ -60,21 +60,31 @@ func main() {
 		Addr:    cfg.ServerAddress,
 		Handler: urlHandler.Router,
 	}
+
 	done := make(chan os.Signal, 1)
-	signal.Notify(done, os.Interrupt, syscall.SIGTERM)
+	signal.Notify(done, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
 
 	go func() {
-		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		var err error
+		if cfg.EnableHTTPS {
+			l.Log.Info("Starting HTTPS server", zap.String("addr", cfg.ServerAddress))
+			err = server.ListenAndServeTLS(cfg.CertFile, cfg.KeyFile)
+		} else {
+			l.Log.Info("Starting HTTP server", zap.String("addr", cfg.ServerAddress))
+			err = server.ListenAndServe()
+		}
+		if err != nil && err != http.ErrServerClosed {
 			l.Log.Error("Error starting server", zap.Error(err))
 		}
 	}()
 	go func() {
 		http.ListenAndServe("localhost:6060", nil)
 	}()
 
-	l.Log.Info("Server started")
+	l.Log.Info("Server started. Waiting for shutdown signal...")
+
 	<-done
-	l.Log.Info("Shutting down server...")
+	l.Log.Info("Shutdown signal received")
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	if err := urlStore.Close(); err != nil {

internal/app/compress/gzip_test.go

@@ -0,0 +1,72 @@
+package compress
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGzipWriter_WriteAndClose(t *testing.T) {
+	rr := httptest.NewRecorder()
+	gz := NewGzipWriter(rr)
+	gz.WriteHeader(http.StatusOK)
+
+	data := []byte("hello, compressed world!")
+	_, err := gz.Write(data)
+	assert.NoError(t, err)
+
+	err = gz.Close()
+	assert.NoError(t, err)
+
+	// проверим, что заголовок установлен
+	assert.Equal(t, "gzip", rr.Header().Get("Content-Encoding"))
+
+	// пытаемся распаковать, чтобы проверить содержимое
+	gr, err := gzip.NewReader(bytes.NewReader(rr.Body.Bytes()))
+	assert.NoError(t, err)
+
+	uncompressed, err := io.ReadAll(gr)
+	assert.NoError(t, err)
+	assert.Equal(t, data, uncompressed)
+}
+
+func TestGzipWriter_WriteHeader(t *testing.T) {
+	rr := httptest.NewRecorder()
+	gz := NewGzipWriter(rr)
+
+	gz.WriteHeader(http.StatusTeapot)
+	assert.Equal(t, "gzip", rr.Header().Get("Content-Encoding"))
+
+	assert.Equal(t, http.StatusTeapot, rr.Code)
+	_ = gz.Close()
+}
+
+func TestGzipReader_ReadAndClose(t *testing.T) {
+	var buf bytes.Buffer
+	zw := gzip.NewWriter(&buf)
+	original := []byte("this is a test")
+	_, err := zw.Write(original)
+	assert.NoError(t, err)
+	err = zw.Close()
+	assert.NoError(t, err)
+
+	gr, err := NewGzipReader(io.NopCloser(bytes.NewReader(buf.Bytes())))
+	assert.NoError(t, err)
+
+	out, err := io.ReadAll(gr)
+	assert.NoError(t, err)
+	assert.Equal(t, original, out)
+
+	err = gr.Close()
+	assert.NoError(t, err)
+}
+
+func TestGzipReader_InvalidInput(t *testing.T) {
+	_, err := NewGzipReader(io.NopCloser(bytes.NewReader([]byte("not gzip"))))
+	assert.Error(t, err)
+}

internal/app/config/config.go

@@ -1,7 +1,9 @@
 package config
 
 import (
+	"encoding/json"
 	"flag"
+	"os"
 
 	"github.com/caarlos0/env/v6"
 	"github.com/shekshuev/shortener/internal/app/logger"
@@ -14,17 +16,36 @@ type Config struct {
 	BaseURL                string // Базовый URL для сокращённых ссылок.
 	FileStoragePath        string // Путь к файлу для хранения сокращённых URL.
 	DatabaseDSN            string // Строка подключения к базе данных.
+	EnableHTTPS            bool   // Включить HTTPS.
+	CertFile               string // Путь к файлу с сертификатом.
+	KeyFile                string // путь к файлу с ключом.
 	DefaultServerAddress   string // Значение по умолчанию для ServerAddress.
 	DefaultBaseURL         string // Значение по умолчанию для BaseURL.
 	DefaultFileStoragePath string // Значение по умолчанию для FileStoragePath.
 	DefaultDatabaseDSN     string // Значение по умолчанию для DatabaseDSN.
+	DefaultEnableHTTPS     bool   // Значение по умолчанию для EnableHTTPS.
+	DefaultCertFile        string // Значение по умолчанию для CertFile.
+	DefaultKeyFile         string // Значение по умолчанию для KeyFile.
 }
 
 type envConfig struct {
 	ServerAddress   string `env:"SERVER_ADDRESS"`
 	BaseURL         string `env:"BASE_URL"`
 	FileStoragePath string `env:"FILE_STORAGE_PATH"`
 	DatabaseDSN     string `env:"DATABASE_DSN"`
+	EnableHTTPS     string `env:"ENABLE_HTTPS"`
+	CertFile        string `env:"TLS_CERT"`
+	KeyFile         string `env:"TLS_KEY"`
+}
+
+type jsonConfig struct {
+	ServerAddress   string `json:"server_address"`
+	BaseURL         string `json:"base_url"`
+	FileStoragePath string `json:"file_storage_path"`
+	DatabaseDSN     string `json:"database_dsn"`
+	EnableHTTPS     bool   `json:"enable_https"`
+	CertFile        string `json:"cert_file"`
+	KeyFile         string `json:"key_file"`
 }
 
 // GetConfig возвращает экземпляр конфига
@@ -34,12 +55,21 @@ func GetConfig() Config {
 	cfg.DefaultBaseURL = "http://localhost:8080"
 	cfg.DefaultFileStoragePath = "./storage.txt"
 	cfg.DefaultDatabaseDSN = ""
+	cfg.DefaultEnableHTTPS = false
+	cfg.DefaultCertFile = ""
+	cfg.DefaultKeyFile = ""
 	parseFlags(&cfg)
 	parsEnv(&cfg)
 	return cfg
 }
 
 func parseFlags(cfg *Config) {
+	var configPath string
+	if f := flag.Lookup("c"); f == nil {
+		flag.StringVar(&configPath, "c", "", "path to JSON config file")
+	} else if f := flag.Lookup("config"); f == nil {
+		flag.StringVar(&configPath, "config", "", "path to JSON config file")
+	}
 	if f := flag.Lookup("a"); f == nil {
 		flag.StringVar(&cfg.ServerAddress, "a", cfg.DefaultServerAddress, "address and port to run server")
 	} else {
@@ -60,7 +90,25 @@ func parseFlags(cfg *Config) {
 	} else {
 		cfg.DatabaseDSN = cfg.DefaultDatabaseDSN
 	}
+	if f := flag.Lookup("s"); f == nil {
+		flag.BoolVar(&cfg.EnableHTTPS, "s", cfg.DefaultEnableHTTPS, "enable HTTPS")
+	} else {
+		cfg.EnableHTTPS = cfg.DefaultEnableHTTPS
+	}
+
+	if f := flag.Lookup("cert"); f == nil {
+		flag.StringVar(&cfg.CertFile, "cert", cfg.DefaultCertFile, "cert file")
+	} else {
+		cfg.CertFile = cfg.DefaultCertFile
+	}
+	if f := flag.Lookup("key"); f == nil {
+		flag.StringVar(&cfg.KeyFile, "key", cfg.DefaultKeyFile, "key file")
+	} else {
+		cfg.KeyFile = cfg.DefaultKeyFile
+	}
+
 	flag.Parse()
+	parseJSON(configPath, cfg)
 	parsEnv(cfg)
 }
 
@@ -83,4 +131,57 @@ func parsEnv(cfg *Config) {
 	if len(envCfg.DatabaseDSN) > 0 {
 		cfg.DatabaseDSN = envCfg.DatabaseDSN
 	}
+	if envCfg.EnableHTTPS == "true" || envCfg.EnableHTTPS == "1" {
+		cfg.EnableHTTPS = true
+	}
+	if len(envCfg.CertFile) > 0 {
+		cfg.CertFile = envCfg.CertFile
+	}
+	if len(envCfg.KeyFile) > 0 {
+		cfg.KeyFile = envCfg.KeyFile
+	}
+}
+
+func parseJSON(path string, cfg *Config) {
+	if path == "" {
+		path = os.Getenv("CONFIG")
+	}
+	if path == "" {
+		return
+	}
+
+	file, err := os.Open(path)
+	if err != nil {
+		logger.NewLogger().Log.Warn("Could not open config file", zap.Error(err))
+		return
+	}
+	defer file.Close()
+
+	var jCfg jsonConfig
+	if err := json.NewDecoder(file).Decode(&jCfg); err != nil {
+		logger.NewLogger().Log.Warn("Could not decode config JSON", zap.Error(err))
+		return
+	}
+
+	if cfg.ServerAddress == cfg.DefaultServerAddress && jCfg.ServerAddress != "" {
+		cfg.ServerAddress = jCfg.ServerAddress
+	}
+	if cfg.BaseURL == cfg.DefaultBaseURL && jCfg.BaseURL != "" {
+		cfg.BaseURL = jCfg.BaseURL
+	}
+	if cfg.FileStoragePath == cfg.DefaultFileStoragePath && jCfg.FileStoragePath != "" {
+		cfg.FileStoragePath = jCfg.FileStoragePath
+	}
+	if cfg.DatabaseDSN == cfg.DefaultDatabaseDSN && jCfg.DatabaseDSN != "" {
+		cfg.DatabaseDSN = jCfg.DatabaseDSN
+	}
+	if cfg.EnableHTTPS == cfg.DefaultEnableHTTPS {
+		cfg.EnableHTTPS = jCfg.EnableHTTPS
+	}
+	if cfg.CertFile == cfg.DefaultCertFile && jCfg.CertFile != "" {
+		cfg.CertFile = jCfg.CertFile
+	}
+	if cfg.KeyFile == cfg.DefaultKeyFile && jCfg.KeyFile != "" {
+		cfg.KeyFile = jCfg.KeyFile
+	}
 }

internal/app/config/config_test.go

@@ -13,45 +13,113 @@ func TestGetConfig_EnvPriority(t *testing.T) {
 	baseURL := "http://localhost:3000"
 	fileStoragePath := "./test.txt"
 	databaseDSN := "host=test port=5432 user=test password=test dbname=test sslmode=disable"
+	enableHTTPS := "true"
+	cert := "cert"
+	key := "key"
 	os.Setenv("SERVER_ADDRESS", serverAddress)
 	os.Setenv("BASE_URL", baseURL)
 	os.Setenv("FILE_STORAGE_PATH", fileStoragePath)
 	os.Setenv("DATABASE_DSN", databaseDSN)
+	os.Setenv("ENABLE_HTTPS", enableHTTPS)
+	os.Setenv("TLS_CERT", cert)
+	os.Setenv("TLS_KEY", key)
 	defer os.Unsetenv("SERVER_ADDRESS")
 	defer os.Unsetenv("BASE_URL")
 	defer os.Unsetenv("FILE_STORAGE_PATH")
+	defer os.Unsetenv("DATABASE_DSN")
+	defer os.Unsetenv("ENABLE_HTTPS")
+	defer os.Unsetenv("TLS_CERT")
+	defer os.Unsetenv("TLS_KEY")
 	cfg := GetConfig()
 	assert.Equal(t, cfg.BaseURL, baseURL)
 	assert.Equal(t, cfg.ServerAddress, serverAddress)
 	assert.Equal(t, cfg.FileStoragePath, fileStoragePath)
 	assert.Equal(t, cfg.DatabaseDSN, databaseDSN)
+	assert.Equal(t, cfg.EnableHTTPS, true)
+	assert.Equal(t, cfg.CertFile, cert)
+	assert.Equal(t, cfg.KeyFile, key)
 }
 
 func TestGetConfig_FlagPriority(t *testing.T) {
 	serverAddress := "localhost:3000"
 	baseURL := "http://localhost:3000"
 	fileStoragePath := "./test.txt"
 	databaseDSN := "host=test port=5432 user=test password=test dbname=test sslmode=disable"
+	enableHTTPS := true
+	cert := "cert"
+	key := "key"
 	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
-	os.Args = []string{"cmd", "-a", serverAddress, "-b", baseURL, "-f", fileStoragePath, "-d", databaseDSN}
+	os.Args = []string{"cmd", "-a", serverAddress, "-b", baseURL, "-f", fileStoragePath, "-d", databaseDSN, "-s", "-cert", cert, "-key", key}
 	defer func() { os.Args = os.Args[:1] }()
 	cfg := GetConfig()
 	assert.Equal(t, cfg.BaseURL, baseURL)
 	assert.Equal(t, cfg.ServerAddress, serverAddress)
 	assert.Equal(t, cfg.FileStoragePath, fileStoragePath)
 	assert.Equal(t, cfg.DatabaseDSN, databaseDSN)
+	assert.Equal(t, cfg.EnableHTTPS, enableHTTPS)
+	assert.Equal(t, cfg.CertFile, cert)
+	assert.Equal(t, cfg.KeyFile, key)
 }
 
 func TestGetConfig_DefaultPriority(t *testing.T) {
 	os.Unsetenv("SERVER_ADDRESS")
 	os.Unsetenv("BASE_URL")
 	os.Unsetenv("FILE_STORAGE_PATH")
 	os.Unsetenv("DATABASE_DSN")
+	os.Unsetenv("ENABLE_HTTPS")
+	os.Unsetenv("TLS_CERT")
+	os.Unsetenv("TLS_KEY")
 	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
 	os.Args = []string{"cmd"}
 	cfg := GetConfig()
 	assert.Equal(t, cfg.BaseURL, cfg.DefaultBaseURL)
 	assert.Equal(t, cfg.ServerAddress, cfg.DefaultServerAddress)
 	assert.Equal(t, cfg.FileStoragePath, cfg.DefaultFileStoragePath)
 	assert.Equal(t, cfg.DatabaseDSN, cfg.DefaultDatabaseDSN)
+	assert.Equal(t, cfg.EnableHTTPS, cfg.DefaultEnableHTTPS)
+	assert.Equal(t, cfg.CertFile, cfg.CertFile)
+	assert.Equal(t, cfg.KeyFile, cfg.KeyFile)
+}
+
+func TestGetConfig_JSONPriority(t *testing.T) {
+	// Создаём временный файл с JSON-конфигурацией
+	tmpFile, err := os.CreateTemp("", "config*.json")
+	assert.NoError(t, err)
+	defer os.Remove(tmpFile.Name())
+
+	jsonContent := `{
+		"server_address": "localhost:9999",
+		"base_url": "http://json",
+		"file_storage_path": "json_path.txt",
+		"database_dsn": "json_dsn",
+		"enable_https": true,
+		"cert_file": "json_cert.pem",
+		"key_file": "json_key.pem"
+	}`
+	_, err = tmpFile.WriteString(jsonContent)
+	assert.NoError(t, err)
+	tmpFile.Close()
+
+	// Убедимся, что переменные окружения и флаги не мешают
+	os.Unsetenv("SERVER_ADDRESS")
+	os.Unsetenv("BASE_URL")
+	os.Unsetenv("FILE_STORAGE_PATH")
+	os.Unsetenv("DATABASE_DSN")
+	os.Unsetenv("ENABLE_HTTPS")
+	os.Unsetenv("TLS_CERT")
+	os.Unsetenv("TLS_KEY")
+
+	// Переустанавливаем флаги и добавляем путь к JSON
+	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
+	os.Args = []string{"cmd", "-c", tmpFile.Name()}
+
+	cfg := GetConfig()
+
+	assert.Equal(t, cfg.ServerAddress, "localhost:9999")
+	assert.Equal(t, cfg.BaseURL, "http://json")
+	assert.Equal(t, cfg.FileStoragePath, "json_path.txt")
+	assert.Equal(t, cfg.DatabaseDSN, "json_dsn")
+	assert.Equal(t, cfg.EnableHTTPS, true)
+	assert.Equal(t, cfg.CertFile, "json_cert.pem")
+	assert.Equal(t, cfg.KeyFile, "json_key.pem")
 }