Add --dry-run flag to put

cmd/help_json_test.go

@@ -277,12 +277,15 @@ func TestJSONHelpManifestV1MachineFields(t *testing.T) {
 	}
 	assertJSONHelpArg(t, put.Args, "source", true, "local_path", true)
 	assertJSONHelpArg(t, put.Args, "target", false, "dropbox_path", false)
+	if jsonHelpFlagByName(t, put.Flags, dryRunFlagName).ValueKind != "boolean" {
+		t.Fatalf("put --%s value_kind = %q, want boolean", dryRunFlagName, jsonHelpFlagByName(t, put.Flags, dryRunFlagName).ValueKind)
+	}
 	assertStringSliceEqual(t, "put --if-exists enum", jsonHelpFlagByName(t, put.Flags, "if-exists").EnumValues, []string{"overwrite", "skip", "fail", "autorename"})
 	if !put.StdinStdout.ReadsStdin || put.StdinStdout.WritesBinaryStdout {
 		t.Fatalf("put stdin_stdout = %+v, want stdin only", put.StdinStdout)
 	}
 	assertStringSliceEqual(t, "put warning codes", put.WarningCodes, []string{jsonWarningCodeSkippedSymlink})
-	assertStringSliceEqual(t, "put result statuses", put.ResultStatuses, []string{"autorenamed", "created", "existing", "skipped", "uploaded"})
+	assertStringSliceEqual(t, "put result statuses", put.ResultStatuses, []string{"autorenamed", "created", "existing", "skipped", "uploaded", jsonStatusPlanned})
 	assertStringSliceEqual(t, "put result kinds", put.ResultKinds, []string{"file", "folder"})
 	assertStringSliceEqual(t, "put scopes", put.DropboxScopes, []string{"files.content.write", "files.metadata.read"})
 	if put.ScopeAccuracy != commandManifestScopeAccuracyBestEffort {

cmd/help_manifest.go

@@ -188,11 +188,12 @@ var commandManifestRegistry = map[string]jsonCommandManifestMetadata{
 			{Description: "Upload from stdin", Command: "printf 'hello' | dbxcli put - /hello.txt"},
 		},
 		Flags: map[string]jsonCommandFlagMetadata{
-			"chunksize": {ValueKind: "bytes"},
-			"debug":     {ValueKind: "boolean"},
-			"if-exists": {EnumValues: []string{"overwrite", "skip", "fail", "autorename"}, ValueKind: "enum"},
-			"recursive": {ValueKind: "boolean"},
-			"workers":   {ValueKind: "integer"},
+			"chunksize":    {ValueKind: "bytes"},
+			"debug":        {ValueKind: "boolean"},
+			dryRunFlagName: {ValueKind: "boolean"},
+			"if-exists":    {EnumValues: []string{"overwrite", "skip", "fail", "autorename"}, ValueKind: "enum"},
+			"recursive":    {ValueKind: "boolean"},
+			"workers":      {ValueKind: "integer"},
 		},
 		DropboxScopes: []string{"files.content.write", "files.metadata.read"},
 		StdinStdout:   jsonCommandStdinStdout{ReadsStdin: true},
@@ -351,7 +352,7 @@ var commandContractRegistry = map[string]jsonCommandContractMetadata{
 	"ls":                  {Statuses: []string{"listed"}, Kinds: []string{"deleted", "file", "folder"}},
 	"mkdir":               {Statuses: []string{"created", "existing", jsonStatusPlanned}, Kinds: []string{"folder"}},
 	"mv":                  {Statuses: []string{"autorenamed", "moved", "skipped", jsonStatusPlanned}, Kinds: []string{"deleted", "file", "folder"}},
-	"put":                 {Statuses: []string{"autorenamed", "created", "existing", "skipped", "uploaded"}, Kinds: []string{"file", "folder"}, Warnings: []string{jsonWarningCodeSkippedSymlink}},
+	"put":                 {Statuses: []string{"autorenamed", "created", "existing", "skipped", "uploaded", jsonStatusPlanned}, Kinds: []string{"file", "folder"}, Warnings: []string{jsonWarningCodeSkippedSymlink}},
 	"restore":             {Statuses: []string{"restored", jsonStatusPlanned}, Kinds: []string{"file"}},
 	"revs":                {Statuses: []string{"revision"}, Kinds: []string{"file"}},
 	"rm":                  {Statuses: []string{"deleted", "permanently_deleted", jsonStatusPlanned}, Kinds: []string{"deleted", "file", "folder"}},

cmd/json_contract_test.go

@@ -739,8 +739,8 @@ func jsonGoldenSuccessOutputExamples() map[string]jsonOperationOutput {
 		"mv": newJSONOperationOutput(nil, []jsonOperationResult{
 			newJSONOperationResult(relocationJSONStatusMoved, "file", relocationInput{FromPath: "/Reports/copy.pdf", ToPath: "/Reports/moved.pdf"}, sampleJSONFileMetadata("/Reports/moved.pdf")),
 		}, nil),
-		"put": newJSONOperationOutput(putCommandInput{Source: "README.md", Target: "/README.md", Recursive: true, IfExists: putIfExistsOverwrite, Stdin: false}, []jsonOperationResult{
-			newJSONOperationResult(putStatusUploaded, putKindFile, putResultInput{Source: "README.md", Target: "/README.md"}, sampleJSONFileMetadata("/README.md")),
+		"put": newJSONOperationOutput(putCommandInput{Source: "README.md", Target: "/README.md", Recursive: true, IfExists: putIfExistsOverwrite, Stdin: false, DryRun: false}, []jsonOperationResult{
+			newJSONOperationResult(putStatusUploaded, putKindFile, putResultInput{Source: "README.md", Target: "/README.md", DryRun: false}, sampleJSONFileMetadata("/README.md")),
 		}, []jsonWarning{{Code: jsonWarningCodeSkippedSymlink, Message: "skipped symlink", Path: "docs/link"}}),
 		"restore": newJSONOperationOutput(restoreInput{Path: "/Reports/old.pdf", Revision: "015f"}, []jsonOperationResult{
 			newJSONOperationResult(restoreStatusRestored, restoreKindFile, restoreInput{Path: "/Reports/old.pdf", Revision: "015f"}, file),
@@ -1094,7 +1094,7 @@ func jsonCommandSchemas() map[string]jsonGoldenCommandSchema {
 		"logout":            operationSchema("empty", schemaRef("empty"), "logout_result", []string{logoutStatusAlreadyLoggedOut, logoutStatusLoggedOut}, []string{logoutKindAuth}, []string{jsonWarningCodeTokenRevokeFailed}),
 		"mkdir":             operationSchema("mkdir_input", schemaRef("mkdir_input"), "metadata", []string{mkdirStatusCreated, mkdirStatusExisting, jsonStatusPlanned}, []string{mkdirKindFolder}, nil),
 		"mv":                operationSchema("empty", schemaRef("relocation_input"), "metadata", []string{relocationJSONStatusAutorenamed, relocationJSONStatusMoved, relocationJSONStatusSkipped, jsonStatusPlanned}, metadataKinds(), nil),
-		"put":               operationSchema("put_input", schemaRef("put_result_input"), "metadata", []string{putStatusAutorenamed, putStatusCreated, putStatusExisting, putStatusSkipped, putStatusUploaded}, []string{putKindFile, putKindFolder}, []string{jsonWarningCodeSkippedSymlink}),
+		"put":               operationSchema("put_input", schemaRef("put_result_input"), "metadata", []string{putStatusAutorenamed, putStatusCreated, putStatusExisting, putStatusSkipped, putStatusUploaded, jsonStatusPlanned}, []string{putKindFile, putKindFolder}, []string{jsonWarningCodeSkippedSymlink}),
 		"restore":           operationSchema("restore_input", schemaRef("restore_input"), "metadata", []string{restoreStatusRestored, jsonStatusPlanned}, []string{restoreKindFile}, nil),
 		"revs":              operationSchema("revs_input", schemaRef("empty"), "metadata", []string{revsJSONStatusRevision}, []string{"file"}, nil),
 		"rm":                operationSchema("empty", schemaRef("remove_input"), "metadata", []string{removeJSONStatusDeleted, removeJSONStatusPermanentlyDeleted, jsonStatusPlanned}, metadataKinds(), nil),

cmd/pipe_test.go

@@ -183,6 +183,71 @@ func TestPutStdinIfExistsSkipDoesNotReadStdin(t *testing.T) {
 	}
 }
 
+func TestPutStdinDryRunDoesNotReadStdin(t *testing.T) {
+	cmd := testPutCmdWithStdin(failReadReader{t: t})
+	if err := cmd.Flags().Set(dryRunFlagName, "true"); err != nil {
+		t.Fatal(err)
+	}
+
+	var stdout bytes.Buffer
+	cmd.SetOut(&stdout)
+	stubFilesClient(t, &mockFilesClient{
+		getMetadataFn: func(arg *files.GetMetadataArg) (files.IsMetadata, error) {
+			t.Fatalf("GetMetadata called during stdin dry-run: %v", arg)
+			return nil, nil
+		},
+		uploadFn: func(arg *files.UploadArg, r io.Reader) (*files.FileMetadata, error) {
+			t.Fatalf("Upload called during stdin dry-run: %v", arg)
+			return nil, nil
+		},
+	})
+
+	if err := put(cmd, []string{"-", "/stdin.txt"}); err != nil {
+		t.Fatalf("put stdin dry-run error: %v", err)
+	}
+
+	const want = "Would upload - to /stdin.txt\n"
+	if got := stdout.String(); got != want {
+		t.Fatalf("stdout = %q, want %q", got, want)
+	}
+}
+
+func TestPutStdinJSONDryRunOutputsPlannedResult(t *testing.T) {
+	cmd := testPutCmdWithStdin(failReadReader{t: t})
+	cmd.Flags().String(outputFlag, "text", "")
+	if err := cmd.Flags().Set(outputFlag, "json"); err != nil {
+		t.Fatal(err)
+	}
+	if err := cmd.Flags().Set(dryRunFlagName, "true"); err != nil {
+		t.Fatal(err)
+	}
+
+	var stdout bytes.Buffer
+	cmd.SetOut(&stdout)
+	stubFilesClient(t, &mockFilesClient{
+		uploadFn: func(arg *files.UploadArg, r io.Reader) (*files.FileMetadata, error) {
+			t.Fatalf("Upload called during stdin dry-run: %v", arg)
+			return nil, nil
+		},
+	})
+
+	if err := put(cmd, []string{"-", "/stdin.txt"}); err != nil {
+		t.Fatalf("put stdin dry-run error: %v", err)
+	}
+
+	got := decodePutOutput(t, &stdout)
+	if got.Input.Source != "-" || got.Input.Target != "/stdin.txt" || !got.Input.Stdin || !got.Input.DryRun {
+		t.Fatalf("input = %+v, want stdin dry-run", got.Input)
+	}
+	result := got.Results[0]
+	if result.Status != jsonStatusPlanned || result.Kind != putKindFile || !result.Input.DryRun {
+		t.Fatalf("result = %+v, want planned file dry-run", result)
+	}
+	if result.Result == nil || result.Result.PathDisplay != "/stdin.txt" {
+		t.Fatalf("metadata = %+v, want planned stdin target metadata", result.Result)
+	}
+}
+
 func TestPutStdin_UploadsToDashPath(t *testing.T) {
 	content := "dash path"
 	cmd := testPutCmdWithStdin(strings.NewReader(content))