Skip to content

Commit

Permalink
Tests: Change util GoConvey tests to use testify (grafana#26724)
Browse files Browse the repository at this point in the history
  • Loading branch information
@sakjur
sakjur committed Aug 13, 2020
1 parent 3bed324 commit d664853
Show file tree
Hide file tree
Showing 7 changed files with 298 additions and 254 deletions.
18 changes: 9 additions & 9 deletions pkg/events/events_test.go
View file
Expand Up @@ -4,21 +4,21 @@ import (
"testing"
"time"

. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

type TestEvent struct {
Timestamp time.Time
}

func TestEventCreation(t *testing.T) {
Convey("Event to wire event", t, func() {
e := TestEvent{
Timestamp: time.Unix(1231421123, 223),
}
e := TestEvent{
Timestamp: time.Unix(1231421123, 223),
}

wire, _ := ToOnWriteEvent(&e)
So(e.Timestamp.Unix(), ShouldEqual, wire.Timestamp.Unix())
So(wire.EventType, ShouldEqual, "TestEvent")
})
wire, err := ToOnWriteEvent(&e)
require.NoError(t, err)
assert.Equal(t, e.Timestamp.Unix(), wire.Timestamp.Unix())
assert.Equal(t, "TestEvent", wire.EventType)
}
32 changes: 18 additions & 14 deletions pkg/util/encoding_test.go
View file
Expand Up @@ -3,28 +3,32 @@ package util
import (
"testing"

. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestEncoding(t *testing.T) {
Convey("When generating base64 header", t, func() {
func TestGetBasicAuthHeader_Encoding(t *testing.T) {
t.Run("generating base64 header", func(t *testing.T) {
result := GetBasicAuthHeader("grafana", "1234")

So(result, ShouldEqual, "Basic Z3JhZmFuYToxMjM0")
assert.Equal(t, "Basic Z3JhZmFuYToxMjM0", result)
})

Convey("When decoding basic auth header", t, func() {
t.Run("decoding basic auth header", func(t *testing.T) {
header := GetBasicAuthHeader("grafana", "1234")
username, password, err := DecodeBasicAuthHeader(header)
So(err, ShouldBeNil)
require.NoError(t, err)

So(username, ShouldEqual, "grafana")
So(password, ShouldEqual, "1234")
assert.Equal(t, "grafana", username)
assert.Equal(t, "1234", password)
})
}

Convey("When encoding password", t, func() {
encodedPassword, err := EncodePassword("iamgod", "pepper")
So(err, ShouldBeNil)
So(encodedPassword, ShouldEqual, "e59c568621e57756495a468f47c74e07c911b037084dd464bb2ed72410970dc849cabd71b48c394faf08a5405dae53741ce9")
})
func TestEncodePassword(t *testing.T) {
encodedPassword, err := EncodePassword("iamgod", "pepper")
require.NoError(t, err)
assert.Equal(
t,
"e59c568621e57756495a468f47c74e07c911b037084dd464bb2ed72410970dc849cabd71b48c394faf08a5405dae53741ce9",
encodedPassword,
)
}
26 changes: 14 additions & 12 deletions pkg/util/encryption_test.go
View file
Expand Up @@ -3,26 +3,28 @@ package util
import (
"testing"

. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestEncryption(t *testing.T) {
Convey("When getting encryption key", t, func() {
t.Run("getting encryption key", func(t *testing.T) {
key, err := encryptionKeyToBytes("secret", "salt")
So(err, ShouldBeNil)
So(len(key), ShouldEqual, 32)
require.NoError(t, err)
assert.Len(t, key, 32)

key, err = encryptionKeyToBytes("a very long secret key that is larger then 32bytes", "salt")
So(err, ShouldBeNil)
So(len(key), ShouldEqual, 32)
require.NoError(t, err)
assert.Len(t, key, 32)
})

Convey("When decrypting basic payload", t, func() {
encrypted, encryptErr := Encrypt([]byte("grafana"), "1234")
decrypted, decryptErr := Decrypt(encrypted, "1234")
t.Run("decrypting basic payload", func(t *testing.T) {
encrypted, err := Encrypt([]byte("grafana"), "1234")
require.NoError(t, err)

So(encryptErr, ShouldBeNil)
So(decryptErr, ShouldBeNil)
So(string(decrypted), ShouldEqual, "grafana")
decrypted, err := Decrypt(encrypted, "1234")
require.NoError(t, err)

assert.Equal(t, []byte("grafana"), decrypted)
})
}
209 changes: 87 additions & 122 deletions pkg/util/ip_address_test.go
View file
@@ -1,135 +1,100 @@
package util

import (
"fmt"
"testing"

. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestParseIPAddress(t *testing.T) {
Convey("Test parse ip address", t, func() {
addr, err := ParseIPAddress("192.168.0.140:456")
So(err, ShouldBeNil)
So(addr, ShouldEqual, "192.168.0.140")

addr, err = ParseIPAddress("192.168.0.140")
So(err, ShouldBeNil)
So(addr, ShouldEqual, "192.168.0.140")

addr, err = ParseIPAddress("[::1]:456")
So(err, ShouldBeNil)
So(addr, ShouldEqual, "::1")

addr, err = ParseIPAddress("[::1]")
So(err, ShouldBeNil)
So(addr, ShouldEqual, "::1")
})

Convey("Invalid address", t, func() {
_, err := ParseIPAddress("[::1")
So(err, ShouldBeError, fmt.Errorf(
`failed to split network address "[::1" by host and port: Malformed IPv6 address: '[::1'`))

_, err = ParseIPAddress("::1]")
So(err, ShouldBeError, fmt.Errorf(
`failed to split network address "::1]" by host and port: net.SplitHostPort failed for '::1]': address ::1]: too many colons in address`))

_, err = ParseIPAddress("")
So(err, ShouldBeError, fmt.Errorf(
`failed to split network address "" by host and port: Input is empty`))
})

Convey("Loopback address", t, func() {
addr, err := ParseIPAddress("127.0.0.1")
So(err, ShouldBeNil)
So(addr, ShouldEqual, "127.0.0.1")

addr, err = ParseIPAddress("[::1]")
So(err, ShouldBeNil)
So(addr, ShouldEqual, "::1")
})
func TestParseIPAddress_Valid(t *testing.T) {
tests := []struct {
input string
expected string
}{
{input: "127.0.0.1", expected: "127.0.0.1"},
{input: "192.168.0.140:456", expected: "192.168.0.140"},
{input: "192.168.0.140", expected: "192.168.0.140"},
{input: "[::1]:456", expected: "::1"},
{input: "[::1]", expected: "::1"},
}
for _, testcase := range tests {
addr, err := ParseIPAddress(testcase.input)
require.NoError(t, err)
assert.Equal(t, testcase.expected, addr)
}
}

func TestSplitHostPortDefault(t *testing.T) {
Convey("Test split ip address to host and port", t, func() {
addr, err := SplitHostPortDefault("192.168.0.140:456", "", "")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "192.168.0.140")
So(addr.Port, ShouldEqual, "456")

addr, err = SplitHostPortDefault("192.168.0.140", "", "123")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "192.168.0.140")
So(addr.Port, ShouldEqual, "123")

addr, err = SplitHostPortDefault("[::1]:456", "", "")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "::1")
So(addr.Port, ShouldEqual, "456")

addr, err = SplitHostPortDefault("[::1]", "", "123")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "::1")
So(addr.Port, ShouldEqual, "123")

addr, err = SplitHostPortDefault(":456", "1.2.3.4", "")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "1.2.3.4")
So(addr.Port, ShouldEqual, "456")

addr, err = SplitHostPortDefault("xyz.rds.amazonaws.com", "", "123")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "xyz.rds.amazonaws.com")
So(addr.Port, ShouldEqual, "123")

addr, err = SplitHostPortDefault("xyz.rds.amazonaws.com:123", "", "")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "xyz.rds.amazonaws.com")
So(addr.Port, ShouldEqual, "123")

addr, err = SplitHostPortDefault("", "localhost", "1433")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "localhost")
So(addr.Port, ShouldEqual, "1433")
})
func TestParseIPAddress_Invalid(t *testing.T) {
tests := []struct {
input string
err string
}{
{
input: "[::1",
err: "failed to split network address \"[::1\" by host and port: Malformed IPv6 address: '[::1'",
},
{
input: "::1]",
err: "failed to split network address \"::1]\" by host and port: net.SplitHostPort failed for '::1]': address ::1]: too many colons in address",
},
{
input: "",
err: "failed to split network address \"\" by host and port: Input is empty",
},
}
for _, testcase := range tests {
addr, err := ParseIPAddress(testcase.input)
assert.EqualError(t, err, testcase.err)
assert.Empty(t, addr)
}
}

func TestSplitHostPort(t *testing.T) {
Convey("Test split ip address to host and port", t, func() {
addr, err := SplitHostPort("192.168.0.140:456")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "192.168.0.140")
So(addr.Port, ShouldEqual, "456")

addr, err = SplitHostPort("192.168.0.140")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "192.168.0.140")
So(addr.Port, ShouldEqual, "")

addr, err = SplitHostPort("[::1]:456")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "::1")
So(addr.Port, ShouldEqual, "456")

addr, err = SplitHostPort("[::1]")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "::1")
So(addr.Port, ShouldEqual, "")

addr, err = SplitHostPort(":456")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "")
So(addr.Port, ShouldEqual, "456")

addr, err = SplitHostPort("xyz.rds.amazonaws.com")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "xyz.rds.amazonaws.com")
So(addr.Port, ShouldEqual, "")
func TestSplitHostPortDefault_Valid(t *testing.T) {
tests := []struct {
input string
defaultHost string
defaultPort string

host string
port string
}{
{input: "192.168.0.140:456", defaultHost: "", defaultPort: "", host: "192.168.0.140", port: "456"},
{input: "192.168.0.140", defaultHost: "", defaultPort: "123", host: "192.168.0.140", port: "123"},
{input: "[::1]:456", defaultHost: "", defaultPort: "", host: "::1", port: "456"},
{input: "[::1]", defaultHost: "", defaultPort: "123", host: "::1", port: "123"},
{input: ":456", defaultHost: "1.2.3.4", defaultPort: "", host: "1.2.3.4", port: "456"},
{input: "xyz.rds.amazonaws.com", defaultHost: "", defaultPort: "123", host: "xyz.rds.amazonaws.com", port: "123"},
{input: "xyz.rds.amazonaws.com:123", defaultHost: "", defaultPort: "", host: "xyz.rds.amazonaws.com", port: "123"},
{input: "", defaultHost: "localhost", defaultPort: "1433", host: "localhost", port: "1433"},
}

for _, testcase := range tests {
addr, err := SplitHostPortDefault(testcase.input, testcase.defaultHost, testcase.defaultPort)
assert.NoError(t, err)
assert.Equal(t, testcase.host, addr.Host)
assert.Equal(t, testcase.port, addr.Port)
}
}

addr, err = SplitHostPort("xyz.rds.amazonaws.com:123")
So(err, ShouldBeNil)
So(addr.Host, ShouldEqual, "xyz.rds.amazonaws.com")
So(addr.Port, ShouldEqual, "123")
})
func TestSplitHostPort_Valid(t *testing.T) {
tests := []struct {
input string
host string
port string
}{
{input: "192.168.0.140:456", host: "192.168.0.140", port: "456"},
{input: "192.168.0.140", host: "192.168.0.140", port: ""},
{input: "[::1]:456", host: "::1", port: "456"},
{input: "[::1]", host: "::1", port: ""},
{input: ":456", host: "", port: "456"},
{input: "xyz.rds.amazonaws.com", host: "xyz.rds.amazonaws.com", port: ""},
{input: "xyz.rds.amazonaws.com:123", host: "xyz.rds.amazonaws.com", port: "123"},
}
for _, testcase := range tests {
addr, err := SplitHostPort(testcase.input)
require.NoError(t, err)
assert.Equal(t, testcase.host, addr.Host)
assert.Equal(t, testcase.port, addr.Port)
}
}

0 comments on commit d664853

Please sign in to comment.