refactor: new transcoding engine. third (fourth?) time is a charm!

engine/media_streamer_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"io"
 	"io/ioutil"
-	"net/http"
 	"os"
 	"strings"
 
@@ -12,53 +11,82 @@ import (
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
 	"github.com/deluan/navidrome/persistence"
+	"github.com/djherbis/fscache"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"gopkg.in/djherbis/fscache.v0"
 )
 
 var _ = Describe("MediaStreamer", func() {
-
 	var streamer MediaStreamer
 	var ds model.DataStore
+	var cache fscache.Cache
+	var tempDir string
+	ffmpeg := &fakeFFmpeg{}
 	ctx := log.NewContext(nil)
 
+	BeforeSuite(func() {
+		tempDir, _ = ioutil.TempDir("", "stream_tests")
+		fs, _ := fscache.NewFs(tempDir, 0755)
+		cache, _ = fscache.NewCache(fs, nil)
+	})
+
 	BeforeEach(func() {
 		conf.Server.EnableDownsampling = true
-		fs := fscache.NewMemFs()
-		cache, _ := fscache.NewCache(fs, nil)
 		ds = &persistence.MockDataStore{}
-		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "bitRate": 128}]`, 1)
-		streamer = NewMediaStreamer(ds, &fakeFFmpeg{}, cache)
+		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "bitRate": 128, "duration": 257.0}]`, 1)
+		streamer = NewMediaStreamer(ds, ffmpeg, cache)
 	})
 
-	getFile := func(id string, maxBitRate int, format string) (http.File, error) {
-		fs, _ := streamer.NewFileSystem(ctx, maxBitRate, format)
-		return fs.Open(id)
-	}
+	AfterSuite(func() {
+		os.RemoveAll(tempDir)
+	})
 
 	Context("NewFileSystem", func() {
-		It("returns a File if format is 'raw'", func() {
-			Expect(getFile("123", 0, "raw")).To(BeAssignableToTypeOf(&os.File{}))
+		It("returns a seekable stream if format is 'raw'", func() {
+			s, err := streamer.NewStream(ctx, "123", 0, "raw")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
 		})
-		It("returns a File if maxBitRate is 0", func() {
-			Expect(getFile("123", 0, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
+		It("returns a seekable stream if maxBitRate is 0", func() {
+			s, err := streamer.NewStream(ctx, "123", 0, "mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
 		})
-		It("returns a File if maxBitRate is higher than file bitRate", func() {
-			Expect(getFile("123", 256, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
+		It("returns a seekable stream if maxBitRate is higher than file bitRate", func() {
+			s, err := streamer.NewStream(ctx, "123", 320, "mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
 		})
-		It("returns a transcodingFile if maxBitRate is lower than file bitRate", func() {
-			s, err := getFile("123", 64, "mp3")
+		It("returns a NON seekable stream if transcode is required", func() {
+			s, err := streamer.NewStream(ctx, "123", 64, "mp3")
 			Expect(err).To(BeNil())
-			Expect(s).To(BeAssignableToTypeOf(&transcodingFile{}))
-			Expect(s.(*transcodingFile).bitRate).To(Equal(64))
+			Expect(s.Seekable()).To(BeFalse())
+			Expect(s.Duration()).To(Equal(float32(257.0)))
+		})
+		It("returns a seekable stream if the file is complete in the cache", func() {
+			Eventually(func() bool { return ffmpeg.closed }).Should(BeTrue())
+			s, err := streamer.NewStream(ctx, "123", 64, "mp3")
+			Expect(err).To(BeNil())
+			Expect(s.Seekable()).To(BeTrue())
 		})
 	})
 })
 
 type fakeFFmpeg struct {
+	r      io.Reader
+	closed bool
 }
 
 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
+	ff.r = strings.NewReader("fake data")
+	return ff, nil
+}
+
+func (ff *fakeFFmpeg) Read(p []byte) (n int, err error) {
+	return ff.r.Read(p)
+}
+
+func (ff *fakeFFmpeg) Close() error {
+	ff.closed = true
+	return nil
 }