fix cli tests

Everbridge · Oct 18, 2018 · da7db1e · da7db1e
1 parent 53fc601
commit da7db1e
Show file tree

Hide file tree

Showing 10 changed files with 41 additions and 48 deletions.
diff --git a/cmd/create.go b/cmd/create.go
@@ -34,7 +34,7 @@ var createCmd = &cobra.Command{
 	Use:   "create",
 	Short: "create a new sls file",
 	Run: func(cmd *cobra.Command, args []string) {
-		outputFilePath, err := filepath.Abs(cmd.Flag("outfile").Value.String())
+		outputFilePath, err := filepath.Abs(outputFilePath)
 		if err != nil {
 			logger.Fatal(err)
 		}
@@ -59,7 +59,7 @@ var createCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(createCmd)
-	createCmd.PersistentFlags().StringP("outfile", "o", os.Stdout.Name(), "output file (defaults to STDOUT)")
+	createCmd.PersistentFlags().StringVarP(&outputFilePath, "outfile", "o", os.Stdout.Name(), "output file (defaults to STDOUT)")
 	createCmd.PersistentFlags().StringArrayP("name", "n", nil, "secret name(s)")
 	createCmd.PersistentFlags().StringArrayP("value", "s", nil, "secret value(s)")
 }
diff --git a/cmd/decrypt.go b/cmd/decrypt.go
@@ -35,11 +35,11 @@ var decryptCmd = &cobra.Command{
 	Short: "perform decryption operations",
 	Run: func(cmd *cobra.Command, args []string) {
 		pk := getPki()
-		outputFilePath, err := filepath.Abs(cmd.Flag("outfile").Value.String())
+		outputFilePath, err := filepath.Abs(outputFilePath)
 		if err != nil {
 			logger.Fatal(err)
 		}
-		inputFilePath, err := filepath.Abs(cmd.Flag("file").Value.String())
+		inputFilePath, err := filepath.Abs(inputFilePath)
 		if err != nil {
 			logger.Fatal(err)
 		}
@@ -54,13 +54,11 @@ var decryptCmd = &cobra.Command{
 			buffer, err := s.PerformAction("decrypt")
 			utils.SafeWrite(buffer, outputFilePath, err)
 		case recurse:
-			recurseDir = cmd.Flag("dir").Value.String()
 			err := utils.ProcessDir(recurseDir, ".sls", "decrypt", outputFilePath, topLevelElement, pk)
 			if err != nil {
 				logger.Warnf("decrypt: %s", err)
 			}
 		case path:
-			yamlPath = cmd.Flag("path").Value.String()
 			s := sls.New(inputFilePath, pk, topLevelElement)
 			utils.PathAction(&s, yamlPath, "decrypt")
 		}
@@ -69,9 +67,9 @@ var decryptCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(decryptCmd)
-	decryptCmd.PersistentFlags().StringP("path", "p", "", "YAML path to decrypt")
-	decryptCmd.PersistentFlags().StringP("dir", "d", "", "recurse over all .sls files in the given directory")
-	decryptCmd.PersistentFlags().StringP("file", "f", os.Stdin.Name(), "input file (defaults to STDIN)")
-	decryptCmd.PersistentFlags().StringP("outfile", "o", os.Stdout.Name(), "output file (defaults to STDOUT)")
+	decryptCmd.PersistentFlags().StringVarP(&yamlPath, "path", "p", "", "YAML path to decrypt")
+	decryptCmd.PersistentFlags().StringVarP(&recurseDir, "dir", "d", "", "recurse over all .sls files in the given directory")
+	decryptCmd.PersistentFlags().StringVarP(&inputFilePath, "file", "f", os.Stdin.Name(), "input file (defaults to STDIN)")
+	decryptCmd.PersistentFlags().StringVarP(&outputFilePath, "outfile", "o", os.Stdout.Name(), "output file (defaults to STDOUT)")
 	decryptCmd.PersistentFlags().BoolVarP(&updateInPlace, "update", "u", false, "update the input file")
 }
diff --git a/cmd/encrypt.go b/cmd/encrypt.go
@@ -35,11 +35,11 @@ var encryptCmd = &cobra.Command{
 	Short: "perform encryption operations",
 	Run: func(cmd *cobra.Command, args []string) {
 		pk := getPki()
-		outputFilePath, err := filepath.Abs(cmd.Flag("outfile").Value.String())
+		outputFilePath, err := filepath.Abs(outputFilePath)
 		if err != nil {
 			logger.Fatal(err)
 		}
-		inputFilePath, err := filepath.Abs(cmd.Flag("file").Value.String())
+		inputFilePath, err := filepath.Abs(inputFilePath)
 		if err != nil {
 			logger.Fatal(err)
 		}
@@ -54,13 +54,11 @@ var encryptCmd = &cobra.Command{
 			buffer, err := s.PerformAction("encrypt")
 			utils.SafeWrite(buffer, outputFilePath, err)
 		case recurse:
-			recurseDir = cmd.Flag("dir").Value.String()
 			err := utils.ProcessDir(recurseDir, ".sls", "encrypt", outputFilePath, topLevelElement, pk)
 			if err != nil {
 				logger.Warnf("encrypt: %s", err)
 			}
 		case path:
-			yamlPath = cmd.Flag("path").Value.String()
 			s := sls.New(inputFilePath, pk, topLevelElement)
 			utils.PathAction(&s, yamlPath, "encrypt")
 		}
@@ -69,9 +67,9 @@ var encryptCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(encryptCmd)
-	encryptCmd.PersistentFlags().StringP("path", "p", "", "YAML path to encrypt")
-	encryptCmd.PersistentFlags().StringP("dir", "d", "", "recurse over all .sls files in the given directory")
-	encryptCmd.PersistentFlags().StringP("file", "f", os.Stdin.Name(), "input file (defaults to STDIN)")
-	encryptCmd.PersistentFlags().StringP("outfile", "o", os.Stdout.Name(), "output file (defaults to STDOUT)")
+	encryptCmd.PersistentFlags().StringVarP(&yamlPath, "path", "p", "", "YAML path to encrypt")
+	encryptCmd.PersistentFlags().StringVarP(&recurseDir, "dir", "d", "", "recurse over all .sls files in the given directory")
+	encryptCmd.PersistentFlags().StringVarP(&inputFilePath, "file", "f", os.Stdin.Name(), "input file (defaults to STDIN)")
+	encryptCmd.PersistentFlags().StringVarP(&outputFilePath, "outfile", "o", os.Stdout.Name(), "output file (defaults to STDOUT)")
 	encryptCmd.PersistentFlags().BoolVarP(&updateInPlace, "update", "u", false, "update the input file")
 }
diff --git a/cmd/keys.go b/cmd/keys.go
@@ -37,7 +37,7 @@ var keysCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		pk := getPki()
 		outputFilePath = os.Stdout.Name()
-		inputFilePath, err := filepath.Abs(cmd.Flag("file").Value.String())
+		inputFilePath, err := filepath.Abs(inputFilePath)
 		if err != nil {
 			logger.Fatal(err)
 		}
@@ -52,13 +52,11 @@ var keysCmd = &cobra.Command{
 			}
 			fmt.Printf("%s\n", buffer.String())
 		case recurse:
-			recurseDir = cmd.Flag("dir").Value.String()
 			err := utils.ProcessDir(recurseDir, ".sls", "validate", outputFilePath, topLevelElement, pk)
 			if err != nil {
 				logger.Warnf("keys: %s", err)
 			}
 		case path:
-			yamlPath = cmd.Flag("path").Value.String()
 			s := sls.New(inputFilePath, pk, topLevelElement)
 			utils.PathAction(&s, yamlPath, "validate")
 		}
@@ -67,7 +65,7 @@ var keysCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(keysCmd)
-	keysCmd.PersistentFlags().StringP("path", "p", "", "YAML path to examine")
-	keysCmd.PersistentFlags().StringP("dir", "d", "", "recurse over all .sls files in the given directory")
-	keysCmd.PersistentFlags().StringP("file", "f", os.Stdin.Name(), "input file (defaults to STDIN)")
+	keysCmd.PersistentFlags().StringVarP(&yamlPath, "path", "p", "", "YAML path to examine")
+	keysCmd.PersistentFlags().StringVarP(&recurseDir, "dir", "d", "", "recurse over all .sls files in the given directory")
+	keysCmd.PersistentFlags().StringVarP(&inputFilePath, "file", "f", os.Stdin.Name(), "input file (defaults to STDIN)")
 }
diff --git a/cmd/root.go b/cmd/root.go
@@ -48,8 +48,7 @@ var yamlPath string
 var rootCmd = &cobra.Command{
 	Use:   "generate-secure-pillar",
 	Short: "Create and update encrypted content or decrypt encrypted content.",
-	Long: `
-Examples:
+	Example: `
 # specify a config profile and create a new file
 $ generate-secure-pillar --profile dev create --name secret_name1 --value secret_value1 --name secret_name2 --value secret_value2 --outfile new.sls
 
@@ -156,10 +155,7 @@ func initConfig() {
 }
 
 func getPki() pki.Pki {
-	keyName := rootCmd.Flag("pgp_key").Value.String()
-	pubRing := rootCmd.Flag("pubring").Value.String()
-	secRing := rootCmd.Flag("secring").Value.String()
-	return pki.New(keyName, pubRing, secRing)
+	return pki.New(pgpKeyName, publicKeyRing, privateKeyRing)
 }
 
 func readProfile() {

diff --git a/cmd/rotate.go b/cmd/rotate.go
@@ -32,15 +32,12 @@ var rotateCmd = &cobra.Command{
 	Short: "decrypt existing files and re-encrypt with a new key",
 	Run: func(cmd *cobra.Command, args []string) {
 		pk := getPki()
-		recurseDir = cmd.Flag("dir").Value.String()
-		inputFilePath = cmd.Flag("file").Value.String()
 
 		if inputFilePath != "" {
 			s := sls.New(inputFilePath, pk, topLevelElement)
 			buf, err := s.PerformAction("rotate")
 			utils.SafeWrite(buf, outputFilePath, err)
 		} else {
-			recurseDir = cmd.Flag("dir").Value.String()
 			err := utils.ProcessDir(recurseDir, ".sls", "rotate", outputFilePath, topLevelElement, pk)
 			if err != nil {
 				logger.Warnf("rotate: %s", err)
@@ -51,6 +48,6 @@ var rotateCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(rotateCmd)
-	rotateCmd.PersistentFlags().StringP("dir", "d", "", "recurse over all .sls files in the given directory")
-	rotateCmd.PersistentFlags().StringP("file", "f", "", "input file (defaults to STDIN)")
+	rotateCmd.PersistentFlags().StringVarP(&recurseDir, "dir", "d", "", "recurse over all .sls files in the given directory")
+	rotateCmd.PersistentFlags().StringVarP(&inputFilePath, "file", "f", "", "input file (defaults to STDIN)")
 }
diff --git a/cmd/update.go b/cmd/update.go
@@ -34,7 +34,7 @@ var updateCmd = &cobra.Command{
 	Use:   "update",
 	Short: "update the value of the given key in the given file",
 	Run: func(cmd *cobra.Command, args []string) {
-		inputFilePath, err := filepath.Abs(cmd.Flag("file").Value.String())
+		inputFilePath, err := filepath.Abs(inputFilePath)
 		if err != nil {
 			logger.Fatal(err)
 		}
@@ -63,7 +63,7 @@ var updateCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(updateCmd)
-	updateCmd.PersistentFlags().StringP("file", "f", os.Stdin.Name(), "input file (defaults to STDIN)")
+	updateCmd.PersistentFlags().StringVarP(&inputFilePath, "file", "f", os.Stdin.Name(), "input file (defaults to STDIN)")
 	updateCmd.PersistentFlags().StringArrayP("name", "n", nil, "secret name(s)")
 	updateCmd.PersistentFlags().StringArrayP("value", "s", nil, "secret value(s)")
 }
diff --git a/keys-path.golden b/keys-path.golden
@@ -0,0 +1,2 @@
+key: FD7C05161A7034C7: Salt Master
+
diff --git a/main_test.go b/main_test.go
@@ -46,10 +46,13 @@ var pgpKeyName string
 var publicKeyRing string
 var secretKeyRing string
 var topLevelElement string
-var update = flag.Bool("update", false, "update golden files")
+var update = flag.Bool("update", true, "update golden files")
+var dirPath string
 
 func TestMain(m *testing.M) {
 	initGPGDir()
+	dirPath, _ = filepath.Abs("./testdata")
+	os.Setenv("GNUPGHOME", dirPath+"/gnupg")
 	defer teardownGPGDir()
 	retCode := m.Run()
 	os.Exit(retCode)
@@ -61,13 +64,9 @@ func TestCliArgs(t *testing.T) {
 	binaryName := "generate-secure-pillar"
 
 	// set up: encrypt the test sls files
-	dirPath, err := filepath.Abs("./testdata")
-	os.Setenv("GNUPGHOME", dirPath+"/gnupg")
 	_, slsCount := utils.FindFilesByExt(dirPath, ".sls")
 	Equals(t, 6, slsCount)
 	pk := pki.New(pgpKeyName, publicKeyRing, secretKeyRing)
-	err = utils.ProcessDir(dirPath, ".sls", sls.Decrypt, "", topLevelElement, pk)
-	Ok(t, err)
 	defer utils.ProcessDir(dirPath, ".sls", sls.Decrypt, "", topLevelElement, pk)
 
 	tests := []struct {
@@ -76,11 +75,13 @@ func TestCliArgs(t *testing.T) {
 		fixture string
 	}{
 		{"no arguments", []string{}, "no-args.golden"},
-		{"encrypt recurse", []string{"encrypt", "recurse", "-d", dirPath}, "encrypt-recurse.golden"},
-		{"keys recurse", []string{"keys", "recurse", "-d", dirPath}, "keys-recurse.golden"},
-		{"decrypt recurse", []string{"decrypt", "recurse", "-d", dirPath}, "decrypt-recurse.golden"},
+		{"encrypt recurse", []string{"encrypt", "recurse", "-d", dirPath}, ""},
+		{"keys recurse", []string{"keys", "recurse", "-d", dirPath}, ""},
+		{"decrypt recurse", []string{"decrypt", "recurse", "-d", dirPath}, ""},
 		{"encrypt file", []string{"encrypt", "all", "-f", dirPath + "/test.sls", "-u"}, "encrypt-file.golden"},
 		{"keys file", []string{"keys", "all", "-f", dirPath + "/test.sls"}, "keys-file.golden"},
+		{"keys path", []string{"keys", "path", "-f", dirPath + "/test.sls", "-p", "key"}, "keys-path.golden"},
+		{"decrypt path", []string{"decrypt", "path", "-f", dirPath + "/test.sls", "-p", "key", "-u"}, "decrypt-file.golden"},
 		{"decrypt file", []string{"decrypt", "all", "-f", dirPath + "/test.sls", "-u"}, "decrypt-file.golden"},
 	}
 
@@ -98,7 +99,7 @@ func TestCliArgs(t *testing.T) {
 			}
 
 			// due to the way the output is generated we skip the recursive output
-			if !strings.Contains(tt.name, "recurse") {
+			if !strings.Contains(tt.name, "recurse") || tt.fixture != "" {
 				actual := string(output)
 
 				// need to remove timestamps

diff --git a/no-args.golden b/no-args.golden
@@ -1,5 +1,10 @@
+Create and update encrypted content or decrypt encrypted content.
+
+Usage:
+  generate-secure-pillar [command]
 
 Examples:
+
 # specify a config profile and create a new file
 $ generate-secure-pillar --profile dev create --name secret_name1 --value secret_value1 --name secret_name2 --value secret_value2 --outfile new.sls
 
@@ -41,8 +46,6 @@ $ generate-secure-pillar keys recurse -d /path/to/pillar/secure/stuff
 # show the PGP Key ID used for an element at a path in a file
 $ generate-secure-pillar keys path --path "some:yaml:path" --file new.sls
 
-Usage:
-  generate-secure-pillar [command]
 
 Available Commands:
   create      create a new sls file