Add partial import functionality (#812)

pkg/scene/marker_import_test.go

@@ -0,0 +1,210 @@
+package scene
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stashapp/stash/pkg/manager/jsonschema"
+	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/models/mocks"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+const (
+	seconds      = "5"
+	secondsFloat = 5.0
+	errSceneID   = 999
+)
+
+func TestMarkerImporterName(t *testing.T) {
+	i := MarkerImporter{
+		Input: jsonschema.SceneMarker{
+			Title:   title,
+			Seconds: seconds,
+		},
+	}
+
+	assert.Equal(t, title+" (5)", i.Name())
+}
+
+func TestMarkerImporterPreImportWithTag(t *testing.T) {
+	tagReaderWriter := &mocks.TagReaderWriter{}
+
+	i := MarkerImporter{
+		TagWriter:           tagReaderWriter,
+		MissingRefBehaviour: models.ImportMissingRefEnumFail,
+		Input: jsonschema.SceneMarker{
+			PrimaryTag: existingTagName,
+		},
+	}
+
+	tagReaderWriter.On("FindByNames", []string{existingTagName}, false).Return([]*models.Tag{
+		{
+			ID:   existingTagID,
+			Name: existingTagName,
+		},
+	}, nil).Times(4)
+	tagReaderWriter.On("FindByNames", []string{existingTagErr}, false).Return(nil, errors.New("FindByNames error")).Times(2)
+
+	err := i.PreImport()
+	assert.Nil(t, err)
+	assert.Equal(t, existingTagID, i.marker.PrimaryTagID)
+
+	i.Input.PrimaryTag = existingTagErr
+	err = i.PreImport()
+	assert.NotNil(t, err)
+
+	i.Input.PrimaryTag = existingTagName
+	i.Input.Tags = []string{
+		existingTagName,
+	}
+	err = i.PreImport()
+	assert.Nil(t, err)
+	assert.Equal(t, existingTagID, i.tags[0].ID)
+
+	i.Input.Tags[0] = existingTagErr
+	err = i.PreImport()
+	assert.NotNil(t, err)
+
+	tagReaderWriter.AssertExpectations(t)
+}
+
+func TestMarkerImporterPostImportUpdateTags(t *testing.T) {
+	joinReaderWriter := &mocks.JoinReaderWriter{}
+
+	i := MarkerImporter{
+		JoinWriter: joinReaderWriter,
+		tags: []*models.Tag{
+			{
+				ID: existingTagID,
+			},
+		},
+	}
+
+	updateErr := errors.New("UpdateSceneMarkersTags error")
+
+	joinReaderWriter.On("UpdateSceneMarkersTags", sceneID, []models.SceneMarkersTags{
+		{
+			TagID:         existingTagID,
+			SceneMarkerID: sceneID,
+		},
+	}).Return(nil).Once()
+	joinReaderWriter.On("UpdateSceneMarkersTags", errTagsID, mock.AnythingOfType("[]models.SceneMarkersTags")).Return(updateErr).Once()
+
+	err := i.PostImport(sceneID)
+	assert.Nil(t, err)
+
+	err = i.PostImport(errTagsID)
+	assert.NotNil(t, err)
+
+	joinReaderWriter.AssertExpectations(t)
+}
+
+func TestMarkerImporterFindExistingID(t *testing.T) {
+	readerWriter := &mocks.SceneMarkerReaderWriter{}
+
+	i := MarkerImporter{
+		ReaderWriter: readerWriter,
+		SceneID:      sceneID,
+		marker: models.SceneMarker{
+			Seconds: secondsFloat,
+		},
+	}
+
+	expectedErr := errors.New("FindBy* error")
+	readerWriter.On("FindBySceneID", sceneID).Return([]*models.SceneMarker{
+		{
+			ID:      existingSceneID,
+			Seconds: secondsFloat,
+		},
+	}, nil).Times(2)
+	readerWriter.On("FindBySceneID", errSceneID).Return(nil, expectedErr).Once()
+
+	id, err := i.FindExistingID()
+	assert.Equal(t, existingSceneID, *id)
+	assert.Nil(t, err)
+
+	i.marker.Seconds++
+	id, err = i.FindExistingID()
+	assert.Nil(t, id)
+	assert.Nil(t, err)
+
+	i.SceneID = errSceneID
+	id, err = i.FindExistingID()
+	assert.Nil(t, id)
+	assert.NotNil(t, err)
+
+	readerWriter.AssertExpectations(t)
+}
+
+func TestMarkerImporterCreate(t *testing.T) {
+	readerWriter := &mocks.SceneMarkerReaderWriter{}
+
+	scene := models.SceneMarker{
+		Title: title,
+	}
+
+	sceneErr := models.SceneMarker{
+		Title: sceneNameErr,
+	}
+
+	i := MarkerImporter{
+		ReaderWriter: readerWriter,
+		marker:       scene,
+	}
+
+	errCreate := errors.New("Create error")
+	readerWriter.On("Create", scene).Return(&models.SceneMarker{
+		ID: sceneID,
+	}, nil).Once()
+	readerWriter.On("Create", sceneErr).Return(nil, errCreate).Once()
+
+	id, err := i.Create()
+	assert.Equal(t, sceneID, *id)
+	assert.Nil(t, err)
+
+	i.marker = sceneErr
+	id, err = i.Create()
+	assert.Nil(t, id)
+	assert.NotNil(t, err)
+
+	readerWriter.AssertExpectations(t)
+}
+
+func TestMarkerImporterUpdate(t *testing.T) {
+	readerWriter := &mocks.SceneMarkerReaderWriter{}
+
+	scene := models.SceneMarker{
+		Title: title,
+	}
+
+	sceneErr := models.SceneMarker{
+		Title: sceneNameErr,
+	}
+
+	i := MarkerImporter{
+		ReaderWriter: readerWriter,
+		marker:       scene,
+	}
+
+	errUpdate := errors.New("Update error")
+
+	// id needs to be set for the mock input
+	scene.ID = sceneID
+	readerWriter.On("Update", scene).Return(nil, nil).Once()
+
+	err := i.Update(sceneID)
+	assert.Nil(t, err)
+
+	i.marker = sceneErr
+
+	// need to set id separately
+	sceneErr.ID = errImageID
+	readerWriter.On("Update", sceneErr).Return(nil, errUpdate).Once()
+
+	err = i.Update(errImageID)
+	assert.NotNil(t, err)
+
+	readerWriter.AssertExpectations(t)
+}