mirror of
https://github.com/navidrome/navidrome.git
synced 2026-11-16 15:18:41 +01:00
181 lines
5.4 KiB
Go
181 lines
5.4 KiB
Go
package jellyfin
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"net"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/navidrome/navidrome/conf"
|
|
. "github.com/onsi/ginkgo/v2"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
type failingConn struct {
|
|
net.PacketConn
|
|
closed bool
|
|
}
|
|
|
|
func (c *failingConn) ReadFrom([]byte) (int, net.Addr, error) {
|
|
return 0, nil, errors.New("read failed")
|
|
}
|
|
|
|
func (c *failingConn) Close() error {
|
|
c.closed = true
|
|
return nil
|
|
}
|
|
|
|
var _ = Describe("Discovery", func() {
|
|
var d *Discovery
|
|
|
|
BeforeEach(func() {
|
|
conf.Update(func(c *conf.Options) {
|
|
c.Jellyfin.ServerName = "Test Server"
|
|
c.Address = "0.0.0.0"
|
|
c.Port = 4533
|
|
c.BaseHost = ""
|
|
c.BaseScheme = ""
|
|
c.BasePath = ""
|
|
c.TLSCert = ""
|
|
c.TLSKey = ""
|
|
})
|
|
d = &Discovery{}
|
|
})
|
|
|
|
DescribeTable("discoveryAddress",
|
|
func(setup func(), expected string) {
|
|
setup()
|
|
remote := &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 50000}
|
|
Expect(discoveryAddress(context.Background(), remote)).To(Equal(expected))
|
|
},
|
|
Entry("uses the BaseURL host and scheme when set", func() {
|
|
conf.Update(func(c *conf.Options) {
|
|
c.BaseScheme = "https"
|
|
c.BaseHost = "music.example.com"
|
|
c.BasePath = "/nd"
|
|
})
|
|
}, "https://music.example.com/nd/jellyfin"),
|
|
Entry("uses a specific bind Address with the Port", func() {
|
|
conf.Update(func(c *conf.Options) { c.Address = "192.168.1.10" })
|
|
}, "http://192.168.1.10:4533/jellyfin"),
|
|
Entry("falls back to the interface facing the requester when Address is unspecified", func() {},
|
|
"http://127.0.0.1:4533/jellyfin"),
|
|
Entry("falls back to the interface facing the requester when Address is empty", func() {
|
|
conf.Update(func(c *conf.Options) { c.Address = "" })
|
|
}, "http://127.0.0.1:4533/jellyfin"),
|
|
Entry("advertises https when TLS is configured", func() {
|
|
conf.Update(func(c *conf.Options) {
|
|
c.TLSCert = "/path/cert.pem"
|
|
c.TLSKey = "/path/key.pem"
|
|
})
|
|
}, "https://127.0.0.1:4533/jellyfin"),
|
|
Entry("advertises http when only the TLS cert is configured", func() {
|
|
conf.Update(func(c *conf.Options) { c.TLSCert = "/path/cert.pem" })
|
|
}, "http://127.0.0.1:4533/jellyfin"),
|
|
Entry("keeps a path-only BaseURL as the path prefix", func() {
|
|
conf.Update(func(c *conf.Options) { c.BasePath = "/music" })
|
|
}, "http://127.0.0.1:4533/music/jellyfin"),
|
|
Entry("does not double the slash when BasePath has a trailing slash", func() {
|
|
conf.Update(func(c *conf.Options) { c.BasePath = "/music/" })
|
|
}, "http://127.0.0.1:4533/music/jellyfin"),
|
|
)
|
|
|
|
DescribeTable("hasAdvertisableAddress",
|
|
func(address, baseHost string, expected bool) {
|
|
conf.Update(func(c *conf.Options) {
|
|
c.Address = address
|
|
c.BaseHost = baseHost
|
|
})
|
|
Expect(hasAdvertisableAddress()).To(Equal(expected))
|
|
},
|
|
Entry("TCP listener", "0.0.0.0", "", true),
|
|
Entry("unix socket without a BaseURL host", "unix:/tmp/navidrome.sock", "", false),
|
|
Entry("unix socket behind a proxy named by BaseURL", "unix:/tmp/navidrome.sock", "music.example.com", true),
|
|
)
|
|
|
|
It("closes the connection when the read loop fails", func() {
|
|
fake := &failingConn{}
|
|
d.ServeOn(context.Background(), fake)
|
|
Expect(fake.closed).To(BeTrue())
|
|
})
|
|
|
|
Describe("ServeOn", func() {
|
|
var (
|
|
server net.PacketConn
|
|
client net.PacketConn
|
|
cancel context.CancelFunc
|
|
done chan struct{}
|
|
)
|
|
|
|
BeforeEach(func() {
|
|
var err error
|
|
server, err = net.ListenPacket("udp4", "127.0.0.1:0")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
client, err = net.ListenPacket("udp4", "127.0.0.1:0")
|
|
Expect(err).ToNot(HaveOccurred())
|
|
DeferCleanup(client.Close)
|
|
|
|
var ctx context.Context
|
|
ctx, cancel = context.WithCancel(context.Background())
|
|
done = make(chan struct{})
|
|
go func() {
|
|
defer close(done)
|
|
d.ServeOn(ctx, server)
|
|
}()
|
|
DeferCleanup(func() {
|
|
cancel()
|
|
Eventually(done).Should(BeClosed())
|
|
})
|
|
})
|
|
|
|
send := func(msg string) {
|
|
_, err := client.WriteTo([]byte(msg), server.LocalAddr())
|
|
Expect(err).ToNot(HaveOccurred())
|
|
}
|
|
receive := func() ([]byte, error) {
|
|
Expect(client.SetReadDeadline(time.Now().Add(time.Second))).To(Succeed())
|
|
buf := make([]byte, 1024)
|
|
n, _, err := client.ReadFrom(buf)
|
|
return buf[:n], err
|
|
}
|
|
|
|
It("answers the discovery query with the server identity", func() {
|
|
send("who is JellyfinServer?")
|
|
res, err := receive()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
var info discoveryInfo
|
|
Expect(json.Unmarshal(res, &info)).To(Succeed())
|
|
Expect(info.Address).To(Equal("http://127.0.0.1:4533/jellyfin"))
|
|
Expect(info.Id).To(Equal(d.serverID(context.Background())))
|
|
Expect(info.Name).To(Equal("Test Server"))
|
|
Expect(string(res)).To(ContainSubstring(`"EndpointAddress":null`))
|
|
})
|
|
|
|
It("matches the query case-insensitively", func() {
|
|
send("WHO IS JELLYFINSERVER?")
|
|
_, err := receive()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
})
|
|
|
|
// The loop is serial, so a reply to the first packet would arrive before the second's.
|
|
It("ignores unrelated packets", func() {
|
|
send("who is PlexServer?")
|
|
send("who is JellyfinServer?")
|
|
_, err := receive()
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(client.SetReadDeadline(time.Now().Add(50 * time.Millisecond))).To(Succeed())
|
|
_, _, err = client.ReadFrom(make([]byte, 1024))
|
|
Expect(errors.Is(err, os.ErrDeadlineExceeded)).To(BeTrue())
|
|
})
|
|
|
|
It("stops and closes the socket when the context is cancelled", func() {
|
|
cancel()
|
|
Eventually(done).Should(BeClosed())
|
|
_, _, err := server.ReadFrom(make([]byte, 1))
|
|
Expect(err).To(HaveOccurred())
|
|
})
|
|
})
|
|
})
|