refactor: more stable transcoder, based on http.FileSystem

engine/media_streamer_test.go

@@ -1,7 +1,12 @@
 package engine
 
 import (
-	"time"
+	"context"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strings"
 
 	"github.com/deluan/navidrome/conf"
 	"github.com/deluan/navidrome/log"
@@ -15,61 +20,58 @@ var _ = Describe("MediaStreamer", func() {
 
 	var streamer MediaStreamer
 	var ds model.DataStore
+	var tempDir string
 	ctx := log.NewContext(nil)
 
-	BeforeEach(func() {
+	BeforeSuite(func() {
 		conf.Server.EnableDownsampling = true
+		tempDir, err := ioutil.TempDir("", "stream_tests")
+		if err != nil {
+			panic(err)
+		}
+		conf.Server.DataFolder = tempDir
+	})
+
+	BeforeEach(func() {
 		ds = &persistence.MockDataStore{}
 		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "bitRate": 128}]`, 1)
-		streamer = NewMediaStreamer(ds)
+		streamer = NewMediaStreamer(ds, &fakeFFmpeg{})
 	})
 
-	Context("NewStream", func() {
-		It("returns a rawMediaStream if format is 'raw'", func() {
-			Expect(streamer.NewStream(ctx, "123", 0, "raw")).To(BeAssignableToTypeOf(&rawMediaStream{}))
+	AfterSuite(func() {
+		os.RemoveAll(tempDir)
+	})
+
+	getFile := func(id string, maxBitRate int, format string) (http.File, error) {
+		fs, _ := streamer.NewFileSystem(ctx, maxBitRate, format)
+		return fs.Open(id)
+	}
+
+	Context("NewFileSystem", func() {
+		It("returns a File if format is 'raw'", func() {
+			Expect(getFile("123", 0, "raw")).To(BeAssignableToTypeOf(&os.File{}))
 		})
-		It("returns a rawMediaStream if maxBitRate is 0", func() {
-			Expect(streamer.NewStream(ctx, "123", 0, "mp3")).To(BeAssignableToTypeOf(&rawMediaStream{}))
+		It("returns a File if maxBitRate is 0", func() {
+			Expect(getFile("123", 0, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
 		})
-		It("returns a rawMediaStream if maxBitRate is higher than file bitRate", func() {
-			Expect(streamer.NewStream(ctx, "123", 256, "mp3")).To(BeAssignableToTypeOf(&rawMediaStream{}))
+		It("returns a File if maxBitRate is higher than file bitRate", func() {
+			Expect(getFile("123", 256, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
 		})
-		It("returns a transcodedMediaStream if maxBitRate is lower than file bitRate", func() {
-			s, err := streamer.NewStream(ctx, "123", 64, "mp3")
+		It("returns a transcodingFile if maxBitRate is lower than file bitRate", func() {
+			s, err := getFile("123", 64, "mp3")
 			Expect(err).To(BeNil())
-			Expect(s).To(BeAssignableToTypeOf(&transcodedMediaStream{}))
-			Expect(s.(*transcodedMediaStream).bitRate).To(Equal(64))
+			Expect(s).To(BeAssignableToTypeOf(&transcodingFile{}))
+			Expect(s.(*transcodingFile).bitRate).To(Equal(64))
 		})
-	})
-
-	Context("rawMediaStream", func() {
-		var rawStream mediaStream
-		var modTime time.Time
-
-		BeforeEach(func() {
-			modTime = time.Now()
-			mf := &model.MediaFile{ID: "123", Path: "test.mp3", UpdatedAt: modTime, Suffix: "mp3"}
-			rawStream = &rawMediaStream{mf: mf, ctx: ctx}
+		It("returns a File if the transcoding is cached", func() {
+			Expect(getFile("123", 64, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
 		})
-
-		It("returns the ContentType", func() {
-			Expect(rawStream.ContentType()).To(Equal("audio/mpeg"))
-		})
-
-		It("returns the ModTime", func() {
-			Expect(rawStream.ModTime()).To(Equal(modTime))
-		})
-	})
-
-	Context("createTranscodeCommand", func() {
-		BeforeEach(func() {
-			conf.Server.DownsampleCommand = "ffmpeg -i %s -b:a %bk mp3 -"
-		})
-		It("creates a valid command line", func() {
-			cmd, args := createTranscodeCommand("/music library/file.mp3", 123, "")
-			Expect(cmd).To(Equal("ffmpeg"))
-			Expect(args).To(Equal([]string{"-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
-		})
-
 	})
 })
+
+type fakeFFmpeg struct {
+}
+
+func (ff *fakeFFmpeg) StartTranscoding(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
+	return ioutil.NopCloser(strings.NewReader("fake data")), nil
+}