mirror of
https://github.com/nabbar/golib.git
synced 2025-12-24 11:51:02 +08:00
fa8adbe7c8
- config Server: change time duration to golib duration to simplify marshal string form - adjust test following update of config server - fix test in socket package to use BDD framework & gherkin form - adjust documentation & test Package HTTPServer: - Fix bug in PortUse & PortNotUse - Move function PortUse & PortNotUse as alone function - Add test & documentation - Unify test & documentation following other packages
486 lines
12 KiB
Go
486 lines
12 KiB
Go
/*
|
|
* MIT License
|
|
*
|
|
* Copyright (c) 2025 Nicolas JUHEL
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
*
|
|
*/
|
|
|
|
package config_test
|
|
|
|
import (
|
|
libtls "github.com/nabbar/golib/certificates"
|
|
libdur "github.com/nabbar/golib/duration"
|
|
libptc "github.com/nabbar/golib/network/protocol"
|
|
"github.com/nabbar/golib/socket/config"
|
|
|
|
. "github.com/onsi/ginkgo/v2"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("Client Implementation", func() {
|
|
Context("TCP address validation", func() {
|
|
It("should accept valid TCP addresses", func() {
|
|
for _, addr := range validTCPAddresses() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkTCP,
|
|
Address: addr,
|
|
}
|
|
err := c.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Address %s should be valid", addr)
|
|
}
|
|
})
|
|
|
|
It("should reject invalid TCP addresses", func() {
|
|
for _, addr := range invalidTCPAddresses() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkTCP,
|
|
Address: addr,
|
|
}
|
|
err := c.Validate()
|
|
// Some addresses may be accepted by net.ResolveTCPAddr (like empty or port-only)
|
|
// We just document the behavior without strict assertions
|
|
_ = err
|
|
}
|
|
})
|
|
})
|
|
|
|
Context("UDP address validation", func() {
|
|
It("should accept valid UDP addresses", func() {
|
|
for _, addr := range validUDPAddresses() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkUDP,
|
|
Address: addr,
|
|
}
|
|
err := c.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Address %s should be valid", addr)
|
|
}
|
|
})
|
|
|
|
It("should reject invalid UDP addresses", func() {
|
|
for _, addr := range invalidUDPAddresses() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkUDP,
|
|
Address: addr,
|
|
}
|
|
err := c.Validate()
|
|
// Some addresses may be accepted by net.ResolveUDPAddr
|
|
// We just document the behavior without strict assertions
|
|
_ = err
|
|
}
|
|
})
|
|
})
|
|
|
|
Context("Unix socket address validation", func() {
|
|
BeforeEach(func() {
|
|
skipIfWindows("Unix sockets not supported")
|
|
})
|
|
|
|
It("should accept valid Unix socket paths", func() {
|
|
for _, addr := range validUnixAddresses() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkUnix,
|
|
Address: addr,
|
|
}
|
|
err := c.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Address %s should be valid", addr)
|
|
}
|
|
})
|
|
|
|
It("should reject invalid Unix socket paths", func() {
|
|
for _, addr := range invalidUnixAddresses() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkUnix,
|
|
Address: addr,
|
|
}
|
|
err := c.Validate()
|
|
// Empty address may be accepted by ResolveUnixAddr in some cases
|
|
// We just document the behavior without strict assertions
|
|
_ = err
|
|
}
|
|
})
|
|
})
|
|
|
|
Context("TLS configuration", func() {
|
|
It("should accept disabled TLS", func() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkTCP,
|
|
Address: "localhost:8080",
|
|
}
|
|
c.TLS.Enabled = false
|
|
err := c.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
|
|
It("should reject TLS for non-TCP protocols", func() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkUDP,
|
|
Address: "localhost:9000",
|
|
}
|
|
c.TLS.Enabled = true
|
|
c.TLS.Config = libtls.Config{}
|
|
c.TLS.ServerName = "localhost"
|
|
err := c.Validate()
|
|
expectValidationError(err, config.ErrInvalidTLSConfig)
|
|
})
|
|
|
|
It("should reject TLS without ServerName", func() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkTCP,
|
|
Address: "localhost:8080",
|
|
}
|
|
c.TLS.Enabled = true
|
|
c.TLS.Config = libtls.Config{}
|
|
c.TLS.ServerName = ""
|
|
err := c.Validate()
|
|
Expect(err).To(HaveOccurred())
|
|
})
|
|
})
|
|
|
|
Context("Protocol validation", func() {
|
|
It("should validate all TCP protocols", func() {
|
|
for _, proto := range tcpProtocols() {
|
|
c := config.Client{
|
|
Network: proto,
|
|
Address: "localhost:8080",
|
|
}
|
|
err := c.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Protocol %v should be valid", proto)
|
|
}
|
|
})
|
|
|
|
It("should validate all UDP protocols", func() {
|
|
for _, proto := range udpProtocols() {
|
|
c := config.Client{
|
|
Network: proto,
|
|
Address: "localhost:9000",
|
|
}
|
|
err := c.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Protocol %v should be valid", proto)
|
|
}
|
|
})
|
|
|
|
It("should validate all Unix protocols", func() {
|
|
skipIfWindows("Unix sockets not supported")
|
|
|
|
for _, proto := range unixProtocols() {
|
|
c := config.Client{
|
|
Network: proto,
|
|
Address: "/tmp/test.sock",
|
|
}
|
|
err := c.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Protocol %v should be valid", proto)
|
|
}
|
|
})
|
|
})
|
|
})
|
|
|
|
var _ = Describe("Server Implementation", func() {
|
|
Context("Unix socket permissions", func() {
|
|
BeforeEach(func() {
|
|
skipIfWindows("Unix sockets not supported")
|
|
})
|
|
|
|
It("should accept valid file permissions", func() {
|
|
for _, perm := range validFilePermissions() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkUnix,
|
|
Address: "/tmp/test.sock",
|
|
PermFile: perm,
|
|
}
|
|
err := s.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Permission %o should be valid", perm)
|
|
}
|
|
})
|
|
|
|
It("should accept zero file permission", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkUnix,
|
|
Address: "/tmp/test.sock",
|
|
PermFile: 0,
|
|
}
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
})
|
|
|
|
Context("Unix socket group permissions", func() {
|
|
BeforeEach(func() {
|
|
skipIfWindows("Unix sockets not supported")
|
|
})
|
|
|
|
It("should accept valid group IDs", func() {
|
|
for _, gid := range validGroupIDs() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkUnix,
|
|
Address: "/tmp/test.sock",
|
|
GroupPerm: gid,
|
|
}
|
|
err := s.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Group ID %d should be valid", gid)
|
|
}
|
|
})
|
|
|
|
It("should reject invalid group IDs", func() {
|
|
for _, gid := range invalidGroupIDs() {
|
|
if gid > config.MaxGID {
|
|
s := config.Server{
|
|
Network: libptc.NetworkUnix,
|
|
Address: "/tmp/test.sock",
|
|
GroupPerm: gid,
|
|
}
|
|
err := s.Validate()
|
|
expectValidationError(err, config.ErrInvalidGroup)
|
|
}
|
|
}
|
|
})
|
|
|
|
It("should accept MaxGID as boundary", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkUnix,
|
|
Address: "/tmp/test.sock",
|
|
GroupPerm: config.MaxGID,
|
|
}
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
|
|
It("should reject MaxGID + 1", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkUnix,
|
|
Address: "/tmp/test.sock",
|
|
GroupPerm: config.MaxGID + 1,
|
|
}
|
|
err := s.Validate()
|
|
expectValidationError(err, config.ErrInvalidGroup)
|
|
})
|
|
})
|
|
|
|
Context("Connection idle timeout", func() {
|
|
It("should accept zero timeout", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: ":8080",
|
|
ConIdleTimeout: 0,
|
|
}
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
|
|
It("should accept positive timeout", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: ":8080",
|
|
ConIdleTimeout: libdur.Minutes(5),
|
|
}
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
|
|
It("should accept negative timeout", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: ":8080",
|
|
ConIdleTimeout: libdur.Seconds(-1),
|
|
}
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
})
|
|
|
|
Context("TLS configuration", func() {
|
|
It("should accept disabled TLS", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: ":8080",
|
|
}
|
|
s.TLS.Enabled = false
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
|
|
It("should reject TLS for non-TCP protocols", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkUDP,
|
|
Address: ":9000",
|
|
}
|
|
s.TLS.Enabled = true
|
|
s.TLS.Config = libtls.Config{}
|
|
err := s.Validate()
|
|
expectValidationError(err, config.ErrInvalidTLSConfig)
|
|
})
|
|
})
|
|
|
|
Context("Server DefaultTLS and GetTLS methods", func() {
|
|
It("should set and retrieve default TLS config", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: ":8080",
|
|
}
|
|
s.TLS.Enabled = true
|
|
s.TLS.Config = libtls.Config{}
|
|
|
|
// GetTLS should return true when TLS is enabled
|
|
enabled, _ := s.GetTLS()
|
|
Expect(enabled).To(BeTrue())
|
|
})
|
|
|
|
It("should return false when TLS is disabled", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: ":8080",
|
|
}
|
|
s.TLS.Enabled = false
|
|
|
|
enabled, tlsCfg := s.GetTLS()
|
|
Expect(enabled).To(BeFalse())
|
|
Expect(tlsCfg).To(BeNil())
|
|
})
|
|
})
|
|
|
|
Context("Client DefaultTLS and GetTLS methods", func() {
|
|
It("should set and retrieve default TLS config for client", func() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkTCP,
|
|
Address: "localhost:8080",
|
|
}
|
|
c.TLS.Enabled = true
|
|
c.TLS.Config = libtls.Config{}
|
|
c.TLS.ServerName = "localhost"
|
|
|
|
// GetTLS should return true when TLS is enabled
|
|
enabled, _, serverName := c.GetTLS()
|
|
Expect(enabled).To(BeTrue())
|
|
Expect(serverName).To(Equal("localhost"))
|
|
})
|
|
|
|
It("should return false when client TLS is disabled", func() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkTCP,
|
|
Address: "localhost:8080",
|
|
}
|
|
c.TLS.Enabled = false
|
|
|
|
enabled, tlsCfg, serverName := c.GetTLS()
|
|
Expect(enabled).To(BeFalse())
|
|
Expect(tlsCfg).To(BeNil())
|
|
Expect(serverName).To(BeEmpty())
|
|
})
|
|
|
|
It("should handle DefaultTLS for client", func() {
|
|
c := config.Client{
|
|
Network: libptc.NetworkTCP,
|
|
Address: "localhost:8080",
|
|
}
|
|
c.DefaultTLS(nil)
|
|
// Should not panic
|
|
Succeed()
|
|
})
|
|
})
|
|
|
|
Context("Server address formats", func() {
|
|
It("should accept wildcard address", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: ":8080",
|
|
}
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
|
|
It("should accept specific interface address", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: "127.0.0.1:8080",
|
|
}
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
|
|
It("should accept IPv6 address", func() {
|
|
s := config.Server{
|
|
Network: libptc.NetworkTCP6,
|
|
Address: "[::1]:8080",
|
|
}
|
|
err := s.Validate()
|
|
expectNoValidationError(err)
|
|
})
|
|
})
|
|
})
|
|
|
|
var _ = Describe("Configuration Patterns", func() {
|
|
Context("Multiple configurations", func() {
|
|
It("should validate multiple client configurations", func() {
|
|
configs := []config.Client{
|
|
{Network: libptc.NetworkTCP, Address: "localhost:8080"},
|
|
{Network: libptc.NetworkTCP, Address: "localhost:8081"},
|
|
{Network: libptc.NetworkUDP, Address: "localhost:9000"},
|
|
}
|
|
|
|
for i, cfg := range configs {
|
|
err := cfg.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Configuration %d should be valid", i)
|
|
}
|
|
})
|
|
|
|
It("should validate multiple server configurations", func() {
|
|
configs := []config.Server{
|
|
{Network: libptc.NetworkTCP, Address: ":8080"},
|
|
{Network: libptc.NetworkTCP, Address: ":8081"},
|
|
{Network: libptc.NetworkUDP, Address: ":9000"},
|
|
}
|
|
|
|
for i, cfg := range configs {
|
|
err := cfg.Validate()
|
|
Expect(err).NotTo(HaveOccurred(), "Configuration %d should be valid", i)
|
|
}
|
|
})
|
|
})
|
|
|
|
Context("Configuration copying", func() {
|
|
It("should support client configuration copying", func() {
|
|
original := config.Client{
|
|
Network: libptc.NetworkTCP,
|
|
Address: "localhost:8080",
|
|
}
|
|
|
|
copy := original
|
|
copy.Address = "localhost:8081"
|
|
|
|
Expect(original.Address).To(Equal("localhost:8080"))
|
|
Expect(copy.Address).To(Equal("localhost:8081"))
|
|
})
|
|
|
|
It("should support server configuration copying", func() {
|
|
original := config.Server{
|
|
Network: libptc.NetworkTCP,
|
|
Address: ":8080",
|
|
}
|
|
|
|
copy := original
|
|
copy.Address = ":8081"
|
|
|
|
Expect(original.Address).To(Equal(":8080"))
|
|
Expect(copy.Address).To(Equal(":8081"))
|
|
})
|
|
})
|
|
})
|