Implement rewind command

Author: kkentzo

README.md

@@ -20,6 +20,8 @@ workspace.
 
 ## Usage
 
+All commands and options can be inspected by using `rv help`.
+
 ### Release new version
 
 `rv` can be instructed to "release" a new version of the software
@@ -77,6 +79,31 @@ $ rv list -w /opt/workspace
 20240313151207.365
 ```
 
-## Rollback to an existing version
+## Rewind to an existing version
+
+`rv` can be instructed to perform a rewind operation from the latest
+release to a previous target release. If no specific target is
+specified by the user, then the `current` link is set to the release
+that precedes the current one.
+
+The rewind operation will **delete** all releases that were performed
+after the target release so as to maintain the integrity of the
+cleanup operations.
+
+So, given:
+
+```bash
+$ rv list -w /opt/workspace
+20240313151323.508 <== current
+20240313151207.365
+```
+
+the rollback operation to the previous version can be achieved by:
 
-TBD
+```bash
+$ rv rollback -w /opt/workspace
+[info] current=20240313151323.508
+[rewind] setting current to 20240313151207.365
+[cleanup] deleting 20240313151323.508
+[success] active version is 20240313151207.365
+```

cmd/common_test.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/google/uuid"
 	"github.com/kkentzo/rv/release"
@@ -35,6 +36,31 @@ func createRelease(workspacePath, includedFile string, keepN uint) (string, erro
 	return cmdOutput.String(), nil
 }
 
+func createReleases(workspacePath string, n uint) ([]string, error) {
+	releases := []string{}
+	for i := 0; i < int(n); i++ {
+		out, err := createRelease(workspacePath, "foo", n)
+		if err != nil {
+			return releases, err
+		}
+		releases = append(releases, parseReleaseFromOutput(out))
+		time.Sleep(10 * time.Millisecond)
+	}
+	return releases, nil
+}
+
+func rewindRelease(workspacePath, target string) (string, error) {
+	// prepare command
+	cmdOutput := createOutputBuffer(RootCmd)
+	args := []string{"rewind", "-w", workspacePath, "-t", target}
+	RootCmd.SetArgs(args)
+	// FIRE!
+	if err := RootCmd.Execute(); err != nil {
+		return "", err
+	}
+	return cmdOutput.String(), nil
+}
+
 func parseReleaseFromOutput(out string) string {
 	for _, line := range strings.Split(out, "\n") {
 		if strings.HasPrefix(line, "[success]") {

cmd/rewind.go

@@ -0,0 +1,36 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/kkentzo/rv/release"
+	"github.com/spf13/cobra"
+)
+
+// rewindCmd represents the rewind command
+var (
+	// command-line arguments
+	target string
+	// command
+	rewindCmdDescription = "Reset the current release"
+	RewindCmd            = &cobra.Command{
+		Use:   "rewind",
+		Short: rewindCmdDescription,
+		Long:  rewindCmdDescription,
+		Run: func(cmd *cobra.Command, args []string) {
+			// perform release
+			releaseID, err := release.Rewind(globalWorkspacePath, target, cmd.OutOrStdout())
+			if err != nil {
+				fmt.Fprintf(cmd.OutOrStderr(), "error: %v\n", err)
+			} else {
+				fmt.Fprintf(cmd.OutOrStdout(), "[success] active version is %s\n", releaseID)
+			}
+		},
+	}
+)
+
+func init() {
+	requireWorkspaceFlag(RewindCmd)
+	RewindCmd.Flags().StringVarP(&target, "target", "t", "", "target release to reset the current link to")
+	RootCmd.AddCommand(RewindCmd)
+}

cmd/rewind_test.go

@@ -0,0 +1,144 @@
+package cmd
+
+import (
+	"os"
+	"path"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/kkentzo/rv/release"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_Rewind_NoTarget_ShouldResetCurrentAndDeletePreviousCurrent(t *testing.T) {
+	workspacePath := uuid.NewString()
+	defer os.RemoveAll(workspacePath)
+
+	releases, err := createReleases(workspacePath, 3)
+	require.Len(t, releases, 3)
+
+	// verify the current release
+	current, err := release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[2], current)
+
+	// ok, let's rewind now with no target
+	_, err = rewindRelease(workspacePath, "")
+	require.NoError(t, err)
+
+	// verify the remaining releases
+	assert.DirExists(t, path.Join(workspacePath, releases[0]))
+	assert.DirExists(t, path.Join(workspacePath, releases[1]))
+	assert.NoDirExists(t, path.Join(workspacePath, releases[2]))
+
+	// verify the current link
+	current, err = release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[1], current)
+}
+
+func Test_Rewind_WithTarget_ShouldResetCurrentAndDeletePreviousCurrent(t *testing.T) {
+	workspacePath := uuid.NewString()
+	defer os.RemoveAll(workspacePath)
+
+	releases, err := createReleases(workspacePath, 3)
+	require.Len(t, releases, 3)
+
+	// verify the current release
+	current, err := release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[2], current)
+
+	// ok, let's rewind now
+	_, err = rewindRelease(workspacePath, releases[0])
+	require.NoError(t, err)
+
+	// verify the remaining releases
+	assert.DirExists(t, path.Join(workspacePath, releases[0]))
+	assert.NoDirExists(t, path.Join(workspacePath, releases[1]))
+	assert.NoDirExists(t, path.Join(workspacePath, releases[2]))
+
+	// verify the current link
+	current, err = release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[0], current)
+}
+
+func Test_Rewind_WhenTheTargetDoesNotExist(t *testing.T) {
+	workspacePath := uuid.NewString()
+	defer os.RemoveAll(workspacePath)
+
+	releases, err := createReleases(workspacePath, 3)
+	require.Len(t, releases, 3)
+
+	// verify the current release
+	current, err := release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[2], current)
+
+	// ok, let's rewind now with no target
+	out, err := rewindRelease(workspacePath, "a_non_existent_target")
+	assert.NoError(t, err)
+	assert.Contains(t, out, "a_non_existent_target not found")
+
+	assert.DirExists(t, path.Join(workspacePath, releases[0]))
+	assert.DirExists(t, path.Join(workspacePath, releases[1]))
+	assert.DirExists(t, path.Join(workspacePath, releases[2]))
+
+	// verify the current link
+	current, err = release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[2], current)
+}
+
+func Test_Rewind_WhenThereIsOnlyOneRelease(t *testing.T) {
+	workspacePath := uuid.NewString()
+	defer os.RemoveAll(workspacePath)
+
+	releases, err := createReleases(workspacePath, 1)
+	require.Len(t, releases, 1)
+
+	// verify the current link
+	current, err := release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[0], current)
+
+	// ok, let's rewind now
+	out, err := rewindRelease(workspacePath, "")
+	assert.NoError(t, err)
+	assert.Contains(t, out, "only one release in workspace")
+
+	assert.DirExists(t, path.Join(workspacePath, releases[0]))
+
+	// verify the current link
+	current, err = release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[0], current)
+}
+
+func Test_Rewind_WhenTargetIsAlreadyCurrent(t *testing.T) {
+	workspacePath := uuid.NewString()
+	defer os.RemoveAll(workspacePath)
+
+	releases, err := createReleases(workspacePath, 2)
+	require.Len(t, releases, 2)
+
+	// verify the current release
+	current, err := release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[1], current)
+
+	// ok, let's rewind now with no target
+	out, err := rewindRelease(workspacePath, releases[1])
+	assert.NoError(t, err)
+	assert.Contains(t, out, "will not rewind")
+
+	assert.DirExists(t, path.Join(workspacePath, releases[0]))
+	assert.DirExists(t, path.Join(workspacePath, releases[1]))
+
+	// verify the current link
+	current, err = release.GetCurrent(workspacePath)
+	assert.NoError(t, err)
+	assert.Equal(t, releases[1], current)
+}