func TestAddVideo(t *testing.T) {
var invalidType *mockInvalidType
lib := &Library{}
expected := ErrInvalidIndexVideoType
got := lib.Add(invalidType, mockLogEntry)
if got != expected {
t.Errorf("expected error %q, got %q", expected, got)
}
}
func TestDeleteEpisode(t *testing.T) {
lib, err := newMockLibrary()
defer lib.cleanup()
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Get a mock show
show, err := lib.mockShow()
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// The mock detailer fakes episodes, let's remove them
show.Episodes = nil
// Get a mock episode
episode, err := lib.mockEpisode("episodeTest.mp4")
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Set the show of the episode
episode.Show = show
// Add the episode to the library
if err := lib.Add(episode, mockLogEntry); err != nil {
t.Fatalf("failed to add the episode: %q", err)
}
// Add the episode to the library
if err := lib.Delete(episode, mockLogEntry); err != nil {
t.Fatalf("failed to remove the episode: %q", err)
}
// Ensure the index if valid
gotIDs := lib.ShowIDs()
expectedIDs := map[string]index.IndexedShow{}
if !reflect.DeepEqual(expectedIDs, gotIDs) {
t.Errorf("invalid show ids, expected %+v got %+v", expectedIDs, gotIDs)
}
// Rebuild the index
if err := lib.RebuildIndex(mockLogEntry); err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Ensure the index is still valid after a rebuild
gotIDs = lib.ShowIDs()
if !reflect.DeepEqual(expectedIDs, gotIDs) {
t.Errorf("invalid show ids, expected %+v got %+v", expectedIDs, gotIDs)
}
}
func TestDeleteMovie(t *testing.T) {
lib, err := newMockLibrary()
defer lib.cleanup()
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
m, err := lib.mockMovie("movieTest")
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Add the movie to the library
if err := lib.Add(m, mockLogEntry); err != nil {
t.Fatalf("failed to add the movie: %q", err)
}
// Count the movies in the index
ids := lib.MovieIDs()
movieCount := len(ids)
if movieCount != 1 {
t.Fatalf("the library should contains 1 movie instead of %d", movieCount)
}
// Delete the movie from the library
if err := lib.Delete(m, mockLogEntry); err != nil {
t.Fatalf("failed to add the movie: %q", err)
}
// Count the movies in the index
ids = lib.MovieIDs()
movieCount = len(ids)
if movieCount != 0 {
t.Fatalf("the library should contains 0 movie instead of %d", movieCount)
}
// Ensure the movie folder has been deleted
if exists(lib.getMovieDir(m)) {
t.Fatal("the movie directory should have been deleted", err)
}
// Rebuild the index, it should remain empty
if err := lib.RebuildIndex(mockLogEntry); err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Count the movies in the index
ids = lib.MovieIDs()
movieCount = len(ids)
if movieCount != 0 {
t.Fatalf("the library should contains 0 movie instead of %d", movieCount)
}
}
func TestAddEpisode(t *testing.T) {
lib, err := newMockLibrary()
defer lib.cleanup()
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Get a mock show
show, err := lib.mockShow()
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// The mock detailer fakes episodes, let's remove them
show.Episodes = nil
// Get a mock episode
episode, err := lib.mockEpisode("episodeTest.mp4")
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Set the show of the episode
episode.Show = show
oldEpisodePath := episode.Path
// Add the episode to the library
if err := lib.Add(episode, mockLogEntry); err != nil {
t.Fatalf("failed to add the episode: %q", err)
}
// Check the new file location
expectedPath := filepath.Join(lib.tmpDir, "shows/Show tt12345/Season 1/episodeTest.mp4")
if episode.Path != expectedPath {
t.Errorf("file location, expected %q got %q", expectedPath, episode.Path)
}
// Check that the old path is a symlink that point to the episode's new path
gotNewPath, err := filepath.EvalSymlinks(oldEpisodePath)
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
if gotNewPath != episode.Path {
t.Errorf("invalid symlink, expected %q got %q", episode.Path, gotNewPath)
}
// Get a new mock episode
episode, err = lib.mockEpisode("episodeTest.mp4")
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
episode.Show = show
// Add the same episode again, this should replace the old one
if err := lib.Add(episode, mockLogEntry); err != nil {
t.Fatalf("failed to add the episode again: %q", err)
}
// Test the show content
testShow(t, episode, lib)
// Test the season
testSeason(t, episode, lib)
episodeFromLib, err := lib.GetEpisode(episode.ShowImdbID, episode.Season, episode.Episode)
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// The show is not retrieved by get the GetEpisode method, let's add it
// manually
episodeFromLib.Show = episode.Show
if !reflect.DeepEqual(episode, episodeFromLib) {
t.Errorf("invalid episode from lib, expected %+v got %+v", episode, episodeFromLib)
}
// Expected indexed season
expectedIndexedSeason := index.IndexedSeason{
Path: filepath.Join(lib.tmpDir, "shows/Show tt12345/Season 1"),
Episodes: map[int]string{
1: filepath.Join(lib.tmpDir, "shows/Show tt12345/Season 1/episodeTest.mp4"),
},
}
// Expected indexed show
expectedIndexedShow := index.IndexedShow{
Path: filepath.Join(lib.tmpDir, "shows/Show tt12345"),
Seasons: map[int]index.IndexedSeason{
1: expectedIndexedSeason,
},
}
// Expected IDs
expectedIDs := map[string]index.IndexedShow{
"tt12345": expectedIndexedShow,
}
// Ensure the index if valid
gotIDs := lib.ShowIDs()
if !reflect.DeepEqual(expectedIDs, gotIDs) {
t.Errorf("invalid show ids, expected %+v got %+v", expectedIDs, gotIDs)
}
// Ensure the library has the show episode
hasEpisode, err := lib.HasVideo(episode)
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
if !hasEpisode {
t.Fatal("the episode should be in the index")
}
// Get the indexed show
gotIndexedShow, err := lib.GetIndexedShow(episode.ShowImdbID)
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
if !reflect.DeepEqual(expectedIndexedShow, gotIndexedShow) {
t.Errorf("invalid show ids, expected %+v got %+v", expectedIndexedShow, gotIndexedShow)
}
// Get the indexed season
gotIndexedSeason, err := lib.GetIndexedSeason(episode.ShowImdbID, episode.Season)
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
if !reflect.DeepEqual(expectedIndexedSeason, gotIndexedSeason) {
t.Errorf("invalid show ids, expected %+v got %+v", expectedIndexedSeason, gotIndexedSeason)
}
// Rebuild the index, the episode should be found and added to the index
if err := lib.RebuildIndex(mockLogEntry); err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Ensure the index is still valid after a rebuild
gotIDs = lib.ShowIDs()
if !reflect.DeepEqual(expectedIDs, gotIDs) {
t.Errorf("invalid show ids, expected %+v got %+v", expectedIDs, gotIDs)
}
}
func TestAddMovie(t *testing.T) {
lib, err := newMockLibrary()
defer lib.cleanup()
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
m, err := lib.mockMovie("movieTest.mp4")
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
oldMoviePath := m.Path
// Add the movie to the library
if err := lib.Add(m, mockLogEntry); err != nil {
t.Fatalf("failed to add the movie: %q", err)
}
// Check the new file location
expectedPath := filepath.Join(lib.tmpDir, "movies/Movie tt12345 (2000)/movieTest.mp4")
if m.Path != expectedPath {
t.Errorf("file location, expected %q got %q", expectedPath, m.Path)
}
// Check that the old path is a symlink that point to the movie's new path
gotNewPath, err := filepath.EvalSymlinks(oldMoviePath)
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
if gotNewPath != m.Path {
t.Errorf("invalid symlink, expected %q got %q", m.Path, gotNewPath)
}
// Get the same mock movie again
m, err = lib.mockMovie("movieTest.mp4")
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Add the movie again, this should replace the old file
if err := lib.Add(m, mockLogEntry); err != nil {
t.Fatalf("failed to add the movie again: %q", err)
}
// Check the content of the downloaded files
for _, imgPath := range []string{
m.MovieFanartPath(),
m.MovieThumbPath(),
} {
content, err := ioutil.ReadFile(imgPath)
if err != nil {
t.Fatalf("failed to add the movie: %q", err)
}
// The mock content comes from the httptest server
if string(content) != "mockContent" {
t.Error("invalid image content")
}
}
// Check the movie index
expectedIDs := []string{m.ImdbID}
gotIDs := lib.MovieIDs()
if !reflect.DeepEqual(gotIDs, expectedIDs) {
t.Errorf("invalid ids, expected %+v got %+v", expectedIDs, gotIDs)
}
// Ensure the library has the movie
hasMovie, err := lib.HasVideo(m)
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
if !hasMovie {
t.Fatal("the movie should be in the index")
}
// Get the movie from the lib
movieFromLib, err := lib.GetMovie(m.ImdbID)
if err != nil {
t.Fatalf("expected no error, got %q", err)
}
if !reflect.DeepEqual(m, movieFromLib) {
t.Errorf("invalid movie from lib, expected %+v got %+v", m, movieFromLib)
}
// Rebuild the index, the movie should be found and added to the index
if err := lib.RebuildIndex(mockLogEntry); err != nil {
t.Fatalf("expected no error, got %q", err)
}
// Check the movie index again
gotIDs = lib.MovieIDs()
if !reflect.DeepEqual(gotIDs, expectedIDs) {
t.Errorf("invalid ids, expected %+v got %+v", expectedIDs, gotIDs)
}
}