tests and parsing

Author: tychoish

file.go

@@ -4,6 +4,7 @@ import (
 	"os"
 
 	"github.com/mongodb/grip"
+	"github.com/mongodb/grip/message"
 	"github.com/pkg/errors"
 )
 
@@ -19,17 +20,24 @@ func FileExists(path string) bool {
 	return !os.IsNotExist(err)
 }
 
-// WriteFile provides a clearer interface for writing string data to a
-// file.
-func WriteFile(path string, data string) error {
+// WriteRawFile writes a sequence of byes to a new file created at the
+// specified path.
+func WriteRawFile(path string, data []byte) error {
 	file, err := os.Create(path)
 	if err != nil {
 		return errors.Wrapf(err, "problem creating file '%s'", path)
 	}
 
-	_, err = file.WriteString(data)
+	n, err := file.Write(data)
 	if err != nil {
-		grip.Warning(errors.Wrapf(file.Close(), "problem closing file '%s' after error", path))
+		grip.Warning(message.WrapError(errors.WithStack(file.Close()),
+			message.Fields{
+				"message":       "problem closing file after error",
+				"path":          path,
+				"bytes_written": n,
+				"input_len":     len(data),
+			}))
+
 		return errors.Wrapf(err, "problem writing data to file '%s'", path)
 	}
 
@@ -39,3 +47,9 @@ func WriteFile(path string, data string) error {
 
 	return nil
 }
+
+// WriteFile provides a clearer interface for writing string data to a
+// file.
+func WriteFile(path string, data string) error {
+	return errors.WithStack(WriteRawFile(path, []byte(data)))
+}

parsing.go

@@ -2,6 +2,7 @@ package utility
 
 import (
 	"encoding/json"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -10,24 +11,30 @@ import (
 	yaml "gopkg.in/yaml.v2"
 )
 
+// ReadYAML provides an alternate interface to yaml.Unmarshal that
+// reads data from an io.ReadCloser.
 func ReadYAML(r io.ReadCloser, target interface{}) error {
 	defer r.Close()
-	bytes, err := ioutil.ReadAll(r)
+	data, err := ioutil.ReadAll(r)
 	if err != nil {
 		return errors.WithStack(err)
 	}
-	return errors.WithStack(yaml.Unmarshal(bytes, data))
+	return errors.WithStack(yaml.Unmarshal(data, target))
 }
 
+// ReadJSON provides an alternate interface to json.Unmarshal that
+// reads data from an io.ReadCloser.
 func ReadJSON(r io.ReadCloser, target interface{}) error {
 	defer r.Close()
-	bytes, err := ioutil.ReadAll(r)
+	data, err := ioutil.ReadAll(r)
 	if err != nil {
 		return errors.WithStack(err)
 	}
-	return errors.WithStack(json.Unmarshal(bytes, data))
+	return errors.WithStack(json.Unmarshal(data, target))
 }
 
+// ReadYAMLFile parses yaml into the target argument from the file
+// located at the specifed path.
 func ReadYAMLFile(path string, target interface{}) error {
 	if !FileExists(path) {
 		return errors.Errorf("file '%s' does not exist", path)
@@ -38,9 +45,11 @@ func ReadYAMLFile(path string, target interface{}) error {
 		return errors.Wrapf(err, "invalid file: %s", path)
 	}
 
-	return errors.Wrap(ReadYAML(file, target), "problem reading yaml from '%s'", path)
+	return errors.Wrapf(ReadYAML(file, target), "problem reading yaml from '%s'", path)
 }
 
+// ReadJSONFile parses json into the target argument from the file
+// located at the specifed path.
 func ReadJSONFile(path string, target interface{}) error {
 	if !FileExists(path) {
 		return errors.Errorf("file '%s' does not exist", path)
@@ -51,27 +60,39 @@ func ReadJSONFile(path string, target interface{}) error {
 		return errors.Wrapf(err, "invalid file: %s", path)
 	}
 
-	return errors.Wrap(ReadYAML(file, target), "problem reading json from '%s'", path)
+	return errors.Wrapf(ReadYAML(file, target), "problem reading json from '%s'", path)
 }
 
-func WriteJSON(out io.Writer, data interface{}) error {
-	out, err := json.Marshal(data)
+// PrintJSON marshals the data to a pretty-printed (indented) string
+// and then prints it to standard output.
+func PrintJSON(data interface{}) error {
+	out, err := json.MarshalIndent(data, "", "   ")
 	if err != nil {
-		return errors.Wrap(err, "problem writing JSON")
+		return errors.Wrap(err, "problem writing data")
 	}
 
+	fmt.Println(string(out))
 	return nil
 }
 
+// WriteJSONFile marshals the data into json and writes it into a file
+// at the specified path.
 func WriteJSONFile(fn string, data interface{}) error {
-	file, err := os.Create(fn)
+	payload, err := json.Marshal(data)
 	if err != nil {
-		return errors.Wrapf(err, "problem creating file '%s'", fn)
+		return errors.Wrap(err, "problem constructing JSON")
 	}
 
-	err = WriteJSON(file, data)
-	if err != nil {
+	return errors.WithStack(WriteRawFile(fn, payload))
+}
 
+// WriteYAMLFile marshals the data into json and writes it into a file
+// at the specified path.
+func WriteYAMLFile(fn string, data interface{}) error {
+	payload, err := yaml.Marshal(data)
+	if err != nil {
+		return errors.Wrap(err, "problem constructing YAML")
 	}
 
+	return errors.WithStack(WriteRawFile(fn, payload))
 }

random.go

@@ -5,9 +5,17 @@ import (
 	"encoding/hex"
 )
 
-// RandomString returns a cryptographically random string.
-func RandomString() string {
-	b := make([]byte, 16)
+// MakeRandomString constructs a hex-encoded random string of a
+// specific length. The size reflects the number of random bytes, not
+// the length of the string.
+func MakeRandomString(size int) string {
+	b := make([]byte, size)
 	_, _ = rand.Read(b)
 	return hex.EncodeToString(b)
+
 }
+
+// RandomString returns a hex-encoded cryptographically random string.
+// This function always returns 16bytes of randomness encoded in a 32
+// character string.
+func RandomString() string { return MakeRandomString(16) }

random_test.go

@@ -0,0 +1,31 @@
+package utility
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRandom(t *testing.T) {
+	t.Run("Legacy", func(t *testing.T) {
+		r1 := RandomString()
+		r2 := RandomString()
+		assert.NotEqual(t, r1, r2)
+		assert.Len(t, RandomString(), 32)
+	})
+	t.Run("Sized", func(t *testing.T) {
+		assert.Len(t, MakeRandomString(32), 64)
+		assert.Len(t, MakeRandomString(64), 128)
+		assert.Len(t, MakeRandomString(2), 4)
+		assert.Len(t, MakeRandomString(1), 2)
+		assert.Len(t, MakeRandomString(3), 6)
+
+		for i := 1; i < 100; i++ {
+			a := MakeRandomString(i)
+			b := MakeRandomString(i)
+			assert.Equal(t, len(a), len(b))
+			assert.NotEqual(t, a, b)
+			assert.Len(t, a, 2*i)
+		}
+	})
+}