test: add more tests for updating shard-group duration.

cmd/influx/bucket_test.go

@@ -90,6 +90,21 @@ func TestCmdBucket(t *testing.T) {
 					OrgID:           orgID,
 				},
 			},
+			{
+				name: "with explicit shard-group duration",
+				flags: []string{
+					"-r=1h",
+					"--shard-group-duration=1m",
+					"-o=org name",
+					"-n=new name",
+				},
+				expectedBucket: influxdb.Bucket{
+					Name:               "new name",
+					RetentionPeriod:    time.Hour,
+					ShardGroupDuration: time.Minute,
+					OrgID:              orgID,
+				},
+			},
 		}
 
 		cmdFn := func(expectedBkt influxdb.Bucket) func(*globalFlags, genericCLIOpts) *cobra.Command {
@@ -408,6 +423,16 @@ func TestCmdBucket(t *testing.T) {
 					RetentionPeriod: durPtr(time.Minute),
 				},
 			},
+			{
+				name: "shard-group duration",
+				flags: []string{
+					"-i=" + influxdb.ID(3).String(),
+					"--shard-group-duration=1m",
+				},
+				expected: influxdb.BucketUpdate{
+					ShardGroupDuration: durPtr(time.Minute),
+				},
+			},
 		}
 
 		cmdFn := func(expectedUpdate influxdb.BucketUpdate) func(*globalFlags, genericCLIOpts) *cobra.Command {

cmd/influxd/launcher/storage_test.go

@@ -8,11 +8,11 @@ import (
 	"testing"
 	"time"
 
+	"github.com/dustin/go-humanize"
 	"github.com/google/go-cmp/cmp"
 	"github.com/influxdata/influxdb/v2"
 	"github.com/influxdata/influxdb/v2/cmd/influxd/launcher"
 	"github.com/influxdata/influxdb/v2/http"
-	"github.com/influxdata/influxdb/v2/pkg/testing/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -200,20 +200,125 @@ func TestLauncher_DeleteWithPredicate(t *testing.T) {
 }
 
 func TestLauncher_UpdateRetentionPolicy(t *testing.T) {
-	l := launcher.RunAndSetupNewLauncherOrFail(ctx, t)
-	defer l.ShutdownOrFail(t, ctx)
+	durPtr := func(d time.Duration) *time.Duration {
+		return &d
+	}
 
-	bucket, err := l.BucketService(t).FindBucket(ctx, influxdb.BucketFilter{ID: &l.Bucket.ID})
-	require.NoError(t, err)
-	require.NotNil(t, bucket)
+	testCases := []struct {
+		name            string
+		initRp          time.Duration
+		initSgd         time.Duration
+		derivedSgd      *time.Duration
+		newRp           *time.Duration
+		newSgd          *time.Duration
+		expectInitErr   bool
+		expectUpdateErr bool
+	}{
+		{
+			name:       "infinite to 1w",
+			initRp:     0,
+			derivedSgd: durPtr(humanize.Week),
+			newRp:      durPtr(humanize.Week),
+		},
+		{
+			name:       "1w to 1d",
+			initRp:     humanize.Week,
+			derivedSgd: durPtr(humanize.Day),
+			newRp:      durPtr(humanize.Day),
+		},
+		{
+			name:       "1d to 1h",
+			initRp:     humanize.Day,
+			derivedSgd: durPtr(time.Hour),
+			newRp:      durPtr(time.Hour),
+		},
+		{
+			name:       "infinite, update shard duration",
+			initSgd:    humanize.Month,
+			derivedSgd: durPtr(humanize.Month),
+			newSgd:     durPtr(humanize.Week),
+		},
+		{
+			name:    "1w, update shard duration",
+			initRp:  humanize.Week,
+			initSgd: humanize.Week,
+			newSgd:  durPtr(time.Hour),
+		},
+		{
+			name:    "1d, update shard duration",
+			initRp:  humanize.Day,
+			initSgd: 3 * time.Hour,
+			newSgd:  durPtr(1*time.Hour + 30*time.Minute),
+		},
+		{
+			name:          "init shard duration larger than RP",
+			initRp:        time.Hour,
+			initSgd:       humanize.Day,
+			expectInitErr: true,
+		},
+		{
+			name:            "updated shard duration larger than RP",
+			initRp:          humanize.Day,
+			initSgd:         time.Hour,
+			newSgd:          durPtr(humanize.Week),
+			expectUpdateErr: true,
+		},
+	}
 
-	newRetentionPeriod := 1 * time.Hour
-	newSgDuration := 1 * time.Hour
-	bucket, err = l.BucketService(t).UpdateBucket(ctx, bucket.ID, influxdb.BucketUpdate{
-		RetentionPeriod: &newRetentionPeriod,
-		ShardGroupDuration: &newSgDuration,
-	})
-	require.NoError(t, err)
-	assert.Equal(t, bucket.RetentionPeriod, newRetentionPeriod)
-	assert.Equal(t, bucket.ShardGroupDuration, newSgDuration)
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			l := launcher.RunAndSetupNewLauncherOrFail(ctx, t)
+			defer l.ShutdownOrFail(t, ctx)
+			bucketService := l.BucketService(t)
+
+			bucket := &influxdb.Bucket{
+				OrgID:              l.Org.ID,
+				RetentionPeriod:    tc.initRp,
+				ShardGroupDuration: tc.initSgd,
+			}
+			err := bucketService.CreateBucket(ctx, bucket)
+			if tc.expectInitErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			defer bucketService.DeleteBucket(ctx, bucket.ID)
+
+			bucket, err = bucketService.FindBucketByID(ctx, bucket.ID)
+			require.NoError(t, err)
+
+			expectedSgd := tc.initSgd
+			if tc.derivedSgd != nil {
+				expectedSgd = *tc.derivedSgd
+			}
+			require.Equal(t, tc.initRp, bucket.RetentionPeriod)
+			require.Equal(t, expectedSgd, bucket.ShardGroupDuration)
+
+			bucket, err = bucketService.UpdateBucket(ctx, bucket.ID, influxdb.BucketUpdate{
+				RetentionPeriod:    tc.newRp,
+				ShardGroupDuration: tc.newSgd,
+			})
+			if tc.expectUpdateErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			bucket, err = bucketService.FindBucketByID(ctx, bucket.ID)
+			require.NoError(t, err)
+
+			expectedRp := tc.initRp
+			if tc.newRp != nil {
+				expectedRp = *tc.newRp
+			}
+			if tc.newSgd != nil {
+				expectedSgd = *tc.newSgd
+			}
+			require.Equal(t, expectedRp, bucket.RetentionPeriod)
+			require.Equal(t, expectedSgd, bucket.ShardGroupDuration)
+		})
+	}
 }