111 lines
2.8 KiB
Go
111 lines
2.8 KiB
Go
package sprig
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestSha256Sum(t *testing.T) {
|
|
tpl := `{{"abc" | sha256sum}}`
|
|
if err := runt(tpl, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestDerivePassword(t *testing.T) {
|
|
expectations := map[string]string{
|
|
`{{derivePassword 1 "long" "password" "user" "example.com"}}`: "ZedaFaxcZaso9*",
|
|
`{{derivePassword 2 "long" "password" "user" "example.com"}}`: "Fovi2@JifpTupx",
|
|
`{{derivePassword 1 "maximum" "password" "user" "example.com"}}`: "pf4zS1LjCg&LjhsZ7T2~",
|
|
`{{derivePassword 1 "medium" "password" "user" "example.com"}}`: "ZedJuz8$",
|
|
`{{derivePassword 1 "basic" "password" "user" "example.com"}}`: "pIS54PLs",
|
|
`{{derivePassword 1 "short" "password" "user" "example.com"}}`: "Zed5",
|
|
`{{derivePassword 1 "pin" "password" "user" "example.com"}}`: "6685",
|
|
}
|
|
|
|
for tpl, result := range expectations {
|
|
out, err := runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if 0 != strings.Compare(out, result) {
|
|
t.Error("Generated password does not match for", tpl)
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE(bacongobbler): this test is really _slow_ because of how long it takes to compute
|
|
// and generate a new crypto key.
|
|
func TestGenPrivateKey(t *testing.T) {
|
|
// test that calling by default generates an RSA private key
|
|
tpl := `{{genPrivateKey ""}}`
|
|
out, err := runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !strings.Contains(out, "RSA PRIVATE KEY") {
|
|
t.Error("Expected RSA PRIVATE KEY")
|
|
}
|
|
// test all acceptable arguments
|
|
tpl = `{{genPrivateKey "rsa"}}`
|
|
out, err = runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !strings.Contains(out, "RSA PRIVATE KEY") {
|
|
t.Error("Expected RSA PRIVATE KEY")
|
|
}
|
|
tpl = `{{genPrivateKey "dsa"}}`
|
|
out, err = runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !strings.Contains(out, "DSA PRIVATE KEY") {
|
|
t.Error("Expected DSA PRIVATE KEY")
|
|
}
|
|
tpl = `{{genPrivateKey "ecdsa"}}`
|
|
out, err = runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !strings.Contains(out, "EC PRIVATE KEY") {
|
|
t.Error("Expected EC PRIVATE KEY")
|
|
}
|
|
// test bad
|
|
tpl = `{{genPrivateKey "bad"}}`
|
|
out, err = runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if out != "Unknown type bad" {
|
|
t.Error("Expected type 'bad' to be an unknown crypto algorithm")
|
|
}
|
|
// ensure that we can base64 encode the string
|
|
tpl = `{{genPrivateKey "rsa" | b64enc}}`
|
|
out, err = runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestUUIDGeneration(t *testing.T) {
|
|
tpl := `{{uuidv4}}`
|
|
out, err := runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if len(out) != 36 {
|
|
t.Error("Expected UUID of length 36")
|
|
}
|
|
|
|
out2, err := runRaw(tpl, nil)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if out == out2 {
|
|
t.Error("Expected subsequent UUID generations to be different")
|
|
}
|
|
}
|