add basic tests for custom-commands

vendor/github.com/coryb/figtree/figtree.go

@@ -104,11 +104,11 @@ func (f *FigTree) LoadConfigBytes(config []byte, source string, options interfac
 		reflect.ValueOf(options),
 		reflect.ValueOf(tmp),
 	)
+	f.populateEnv(options)
 	if m.Config.Stop {
 		f.stop = true
 		return nil
 	}
-	f.populateEnv(options)
 	return nil
 }
 
@@ -350,6 +350,60 @@ Outer:
 	return ov
 }
 
+func (f *FigTree) formatEnvName(name string) string {
+	name = fmt.Sprintf("%s_%s", f.EnvPrefix, strings.ToUpper(name))
+
+	return strings.Map(func(r rune) rune {
+		if unicode.IsDigit(r) || unicode.IsLetter(r) {
+			return r
+		}
+		return '_'
+	}, name)
+}
+
+func (f *FigTree) formatEnvValue(value reflect.Value) (string, bool) {
+	switch t := value.Interface().(type) {
+	case string:
+		return t, true
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, bool:
+		return fmt.Sprintf("%v", t), true
+	default:
+		switch value.Kind() {
+		case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+			if value.IsNil() {
+				return "", false
+			}
+		}
+		if t == nil {
+			return "", false
+		}
+		type definable interface {
+			IsDefined() bool
+		}
+		if def, ok := t.(definable); ok {
+			// skip fields that are not defined
+			if !def.IsDefined() {
+				return "", false
+			}
+		}
+		type gettable interface {
+			GetValue() interface{}
+		}
+		if get, ok := t.(gettable); ok {
+			return fmt.Sprintf("%v", get.GetValue()), true
+		} else {
+			if b, err := json.Marshal(t); err == nil {
+				val := strings.TrimSpace(string(b))
+				if val == "null" {
+					return "", true
+				}
+				return val, true
+			}
+		}
+	}
+	return "", false
+}
+
 func (f *FigTree) populateEnv(data interface{}) {
 	options := reflect.ValueOf(data)
 	if options.Kind() == reflect.Ptr {
@@ -370,8 +424,11 @@ func (f *FigTree) populateEnv(data interface{}) {
 				}
 
 				name := strings.Join(allParts, "_")
-				envName := fmt.Sprintf("%s_%s", f.EnvPrefix, strings.ToUpper(name))
-				os.Setenv(envName, fmt.Sprintf("%v", options.MapIndex(key).Interface()))
+				envName := f.formatEnvName(name)
+				val, ok := f.formatEnvValue(options.MapIndex(key))
+				if ok {
+					os.Setenv(envName, val)
+				}
 			}
 		}
 	} else if options.Kind() == reflect.Struct {
@@ -400,54 +457,11 @@ func (f *FigTree) populateEnv(data interface{}) {
 				}
 			}
 
-			envName := fmt.Sprintf("%s_%s", f.EnvPrefix, strings.ToUpper(name))
-
-			envName = strings.Map(func(r rune) rune {
-				if unicode.IsDigit(r) || unicode.IsLetter(r) {
-					return r
-				}
-				return '_'
-			}, envName)
-			var val string
-			switch t := options.Field(i).Interface().(type) {
-			case string:
-				val = t
-			case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, bool:
-				val = fmt.Sprintf("%v", t)
-			default:
-				switch options.Field(i).Kind() {
-				case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-					if options.Field(i).IsNil() {
-						continue
-					}
-				}
-				if t == nil {
-					continue
-				}
-				type definable interface {
-					IsDefined() bool
-				}
-				if def, ok := t.(definable); ok {
-					// skip fields that are not defined
-					if !def.IsDefined() {
-						continue
-					}
-				}
-				type gettable interface {
-					GetValue() interface{}
-				}
-				if get, ok := t.(gettable); ok {
-					val = fmt.Sprintf("%v", get.GetValue())
-				} else {
-					if b, err := json.Marshal(t); err == nil {
-						val = strings.TrimSpace(string(b))
-						if val == "null" {
-							val = ""
-						}
-					}
-				}
+			envName := f.formatEnvName(name)
+			val, ok := f.formatEnvValue(options.Field(i))
+			if ok {
+				os.Setenv(envName, val)
 			}
-			os.Setenv(envName, val)
 		}
 	}
 }

vendor/golang.org/x/crypto/nacl/box/box.go

@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 /*
-Package box authenticates and encrypts messages using public-key cryptography.
+Package box authenticates and encrypts small messages using public-key cryptography.
 
 Box uses Curve25519, XSalsa20 and Poly1305 to encrypt and authenticate
 messages. The length of messages is not hidden.
@@ -13,6 +13,23 @@ example, by using nonce 1 for the first message, nonce 2 for the second
 message, etc. Nonces are long enough that randomly generated nonces have
 negligible risk of collision.
 
+Messages should be small because:
+
+1. The whole message needs to be held in memory to be processed.
+
+2. Using large messages pressures implementations on small machines to decrypt
+and process plaintext before authenticating it. This is very dangerous, and
+this API does not allow it, but a protocol that uses excessive message sizes
+might present some implementations with no other choice.
+
+3. Fixed overheads will be sufficiently amortised by messages as small as 8KB.
+
+4. Performance may be improved by working with messages that fit into data caches.
+
+Thus large amounts of data should be chunked so that each message is small.
+(Each message still needs a unique nonce.) If in doubt, 16KB is a reasonable
+chunk size.
+
 This package is interoperable with NaCl: https://nacl.cr.yp.to/box.html.
 */
 package box // import "golang.org/x/crypto/nacl/box"

vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go

@@ -13,6 +13,23 @@ example, by using nonce 1 for the first message, nonce 2 for the second
 message, etc. Nonces are long enough that randomly generated nonces have
 negligible risk of collision.
 
+Messages should be small because:
+
+1. The whole message needs to be held in memory to be processed.
+
+2. Using large messages pressures implementations on small machines to decrypt
+and process plaintext before authenticating it. This is very dangerous, and
+this API does not allow it, but a protocol that uses excessive message sizes
+might present some implementations with no other choice.
+
+3. Fixed overheads will be sufficiently amortised by messages as small as 8KB.
+
+4. Performance may be improved by working with messages that fit into data caches.
+
+Thus large amounts of data should be chunked so that each message is small.
+(Each message still needs a unique nonce.) If in doubt, 16KB is a reasonable
+chunk size.
+
 This package is interoperable with NaCl: https://nacl.cr.yp.to/secretbox.html.
 */
 package secretbox // import "golang.org/x/crypto/nacl/secretbox"

vendor/golang.org/x/crypto/openpgp/keys_test.go

@@ -12,7 +12,10 @@ import (
 )
 
 func TestKeyExpiry(t *testing.T) {
-	kring, _ := ReadKeyRing(readerFromHex(expiringKeyHex))
+	kring, err := ReadKeyRing(readerFromHex(expiringKeyHex))
+	if err != nil {
+		t.Fatal(err)
+	}
 	entity := kring[0]
 
 	const timeFormat = "2006-01-02"
@@ -104,7 +107,10 @@ func TestGoodCrossSignature(t *testing.T) {
 
 // TestExternallyRevokableKey attempts to load and parse a key with a third party revocation permission.
 func TestExternallyRevocableKey(t *testing.T) {
-	kring, _ := ReadKeyRing(readerFromHex(subkeyUsageHex))
+	kring, err := ReadKeyRing(readerFromHex(subkeyUsageHex))
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	// The 0xA42704B92866382A key can be revoked by 0xBE3893CB843D0FE70C
 	// according to this signature that appears within the key:
@@ -125,7 +131,10 @@ func TestExternallyRevocableKey(t *testing.T) {
 }
 
 func TestKeyRevocation(t *testing.T) {
-	kring, _ := ReadKeyRing(readerFromHex(revokedKeyHex))
+	kring, err := ReadKeyRing(readerFromHex(revokedKeyHex))
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	// revokedKeyHex contains these keys:
 	// pub   1024R/9A34F7C0 2014-03-25 [revoked: 2014-03-25]
@@ -145,7 +154,10 @@ func TestKeyRevocation(t *testing.T) {
 }
 
 func TestSubkeyRevocation(t *testing.T) {
-	kring, _ := ReadKeyRing(readerFromHex(revokedSubkeyHex))
+	kring, err := ReadKeyRing(readerFromHex(revokedSubkeyHex))
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	// revokedSubkeyHex contains these keys:
 	// pub   1024R/4EF7E4BECCDE97F0 2014-03-25
@@ -178,7 +190,10 @@ func TestSubkeyRevocation(t *testing.T) {
 }
 
 func TestKeyUsage(t *testing.T) {
-	kring, _ := ReadKeyRing(readerFromHex(subkeyUsageHex))
+	kring, err := ReadKeyRing(readerFromHex(subkeyUsageHex))
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	// subkeyUsageHex contains these keys:
 	// pub  1024R/2866382A  created: 2014-04-01  expires: never       usage: SC

vendor/golang.org/x/sys/unix/dev_freebsd.go

@@ -0,0 +1,30 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Functions to access/create device major and minor numbers matching the
+// encoding used in FreeBSD's sys/types.h header.
+//
+// The information below is extracted and adapted from sys/types.h:
+//
+// Minor gives a cookie instead of an index since in order to avoid changing the
+// meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
+// devices that don't use them.
+
+package unix
+
+// Major returns the major component of a FreeBSD device number.
+func Major(dev uint64) uint32 {
+	return uint32((dev >> 8) & 0xff)
+}
+
+// Minor returns the minor component of a FreeBSD device number.
+func Minor(dev uint64) uint32 {
+	return uint32(dev & 0xffff00ff)
+}
+
+// Mkdev returns a FreeBSD device number generated from the given major and
+// minor components.
+func Mkdev(major, minor uint32) uint64 {
+	return uint64((major << 8) | minor)
+}