feat: Allow multiple listen addresses

This change implements the ability to specify multiple listen addresses.
This allows the application to listen on different interfaces or ports simultaneously,
or a combination of IP addresses and Unix sockets.

Closes #3343

internal/config/parser_test.go

@@ -4,6 +4,7 @@
 package config // import "miniflux.app/v2/internal/config"
 
 import (
+	"reflect"
 	"testing"
 )
 
@@ -58,3 +59,108 @@ func TestParseIntValue(t *testing.T) {
 		t.Errorf(`Defined variables should returns the specified value`)
 	}
 }
+
+func TestParseListenAddr(t *testing.T) {
+	defaultExpected := []string{defaultListenAddr}
+
+	tests := []struct {
+		name           string
+		listenAddr     string
+		port           string
+		expected       []string
+		lines          []string // Used for direct lines parsing instead of individual env vars
+		isLineOriented bool     // Flag to indicate if we use lines
+	}{
+		{
+			name:       "Single LISTEN_ADDR",
+			listenAddr: "127.0.0.1:8080",
+			expected:   []string{"127.0.0.1:8080"},
+		},
+		{
+			name:       "Multiple LISTEN_ADDR comma-separated",
+			listenAddr: "127.0.0.1:8080,:8081,/tmp/miniflux.sock",
+			expected:   []string{"127.0.0.1:8080", ":8081", "/tmp/miniflux.sock"},
+		},
+		{
+			name:       "Multiple LISTEN_ADDR with spaces around commas",
+			listenAddr: "127.0.0.1:8080 , :8081",
+			expected:   []string{"127.0.0.1:8080", ":8081"},
+		},
+		{
+			name:       "Empty LISTEN_ADDR",
+			listenAddr: "",
+			expected:   defaultExpected,
+		},
+		{
+			name:       "PORT overrides LISTEN_ADDR",
+			listenAddr: "127.0.0.1:8000",
+			port:       "8082",
+			expected:   []string{":8082"},
+		},
+		{
+			name:       "PORT overrides empty LISTEN_ADDR",
+			listenAddr: "",
+			port:       "8083",
+			expected:   []string{":8083"},
+		},
+		{
+			name:       "LISTEN_ADDR with empty segment (comma)",
+			listenAddr: "127.0.0.1:8080,,:8081",
+			expected:   []string{"127.0.0.1:8080", ":8081"},
+		},
+		{
+			name:           "PORT override with lines parsing",
+			isLineOriented: true,
+			lines:          []string{"LISTEN_ADDR=127.0.0.1:8000", "PORT=8082"},
+			expected:       []string{":8082"},
+		},
+		{
+			name:           "LISTEN_ADDR only with lines parsing (comma)",
+			isLineOriented: true,
+			lines:          []string{"LISTEN_ADDR=10.0.0.1:9090,10.0.0.2:9091"},
+			expected:       []string{"10.0.0.1:9090", "10.0.0.2:9091"},
+		},
+		{
+			name:           "Empty LISTEN_ADDR with lines parsing (default)",
+			isLineOriented: true,
+			lines:          []string{"LISTEN_ADDR="},
+			expected:       defaultExpected,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			parser := NewParser()
+			var err error
+
+			if tt.isLineOriented {
+				err = parser.parseLines(tt.lines)
+			} else {
+				// Simulate os.Environ() behaviour for individual var testing
+				var envLines []string
+				if tt.listenAddr != "" {
+					envLines = append(envLines, "LISTEN_ADDR="+tt.listenAddr)
+				}
+				if tt.port != "" {
+					envLines = append(envLines, "PORT="+tt.port)
+				}
+				// Add a dummy var if both are empty to avoid empty lines slice if not intended
+				if tt.listenAddr == "" && tt.port == "" && tt.name == "Empty LISTEN_ADDR" {
+					// This case specifically tests empty LISTEN_ADDR resulting in default
+					// So, we pass LISTEN_ADDR=
+					envLines = append(envLines, "LISTEN_ADDR=")
+				}
+				err = parser.parseLines(envLines)
+			}
+
+			if err != nil {
+				t.Fatalf("parseLines() error = %v", err)
+			}
+
+			opts := parser.opts
+			if !reflect.DeepEqual(opts.ListenAddr(), tt.expected) {
+				t.Errorf("ListenAddr() got = %v, want %v", opts.ListenAddr(), tt.expected)
+			}
+		})
+	}
+}