Add unit test for helper pkg

Author: nightfury1204

pkg/helpers/atom_test.go

@@ -0,0 +1,35 @@
+package helpers_test
+
+import (
+	"testing"
+
+	"github.com/convox/rack/pkg/helpers"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAtomStatus(t *testing.T) {
+	testData := []struct {
+		given, expect string
+	}{
+		{
+			given:  "Failed",
+			expect: "failed",
+		},
+		{
+			given:  "Rollback",
+			expect: "rollback",
+		},
+		{
+			given:  "Deadline",
+			expect: "updating",
+		},
+		{
+			given:  "dfdf",
+			expect: "running",
+		},
+	}
+
+	for _, td := range testData {
+		require.Equal(t, td.expect, helpers.AtomStatus(td.given))
+	}
+}

pkg/helpers/aws_test.go

@@ -0,0 +1,182 @@
+package helpers_test
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/cloudformation"
+	"github.com/aws/aws-sdk-go/service/cloudwatchlogs"
+	"github.com/convox/rack/pkg/helpers"
+	mockaws "github.com/convox/rack/pkg/mock/aws"
+	"github.com/convox/rack/pkg/structs"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCloudformationDescribe(t *testing.T) {
+	cf := &mockaws.CloudFormationAPI{}
+	expectStack := &cloudformation.Stack{
+		StackId:   aws.String("id1"),
+		StackName: aws.String("stack1"),
+	}
+
+	cf.On("DescribeStacks", mock.Anything).Return(func(st *cloudformation.DescribeStacksInput) *cloudformation.DescribeStacksOutput {
+		require.Equal(t, expectStack.StackName, st.StackName)
+		return &cloudformation.DescribeStacksOutput{
+			Stacks: []*cloudformation.Stack{
+				expectStack,
+			},
+		}
+	}, nil)
+
+	stack, err := helpers.CloudformationDescribe(cf, *expectStack.StackName)
+	require.NoError(t, err)
+	require.Equal(t, expectStack, stack)
+}
+
+func TestCloudformationInstall(t *testing.T) {
+	cf := &mockaws.CloudFormationAPI{}
+	expectStack := &cloudformation.Stack{
+		StackId:     aws.String("id1"),
+		StackName:   aws.String("stack1"),
+		StackStatus: aws.String("CREATE_COMPLETE"),
+	}
+
+	cf.On("CreateChangeSet", mock.Anything).Return(func(st *cloudformation.CreateChangeSetInput) *cloudformation.CreateChangeSetOutput {
+		return &cloudformation.CreateChangeSetOutput{
+			StackId: expectStack.StackId,
+		}
+	}, nil)
+
+	cf.On("WaitUntilChangeSetCreateComplete", mock.Anything).Return(func(in *cloudformation.DescribeChangeSetInput) error {
+		require.Equal(t, expectStack.StackId, in.StackName)
+		return nil
+	})
+
+	cf.On("DescribeChangeSet", mock.Anything).Return(func(in *cloudformation.DescribeChangeSetInput) *cloudformation.DescribeChangeSetOutput {
+		require.Equal(t, expectStack.StackId, in.StackName)
+		return &cloudformation.DescribeChangeSetOutput{}
+	}, nil)
+
+	cf.On("ExecuteChangeSet", mock.Anything).Return(nil, func(in *cloudformation.ExecuteChangeSetInput) error {
+		require.Equal(t, expectStack.StackId, in.StackName)
+		return nil
+	})
+
+	cf.On("DescribeStacks", mock.Anything).Return(&cloudformation.DescribeStacksOutput{
+		Stacks: []*cloudformation.Stack{
+			expectStack,
+		},
+	}, nil)
+
+	err := helpers.CloudformationInstall(cf, *expectStack.StackName, "", map[string]string{}, map[string]string{}, func(i1, i2 int) {})
+	require.NoError(t, err)
+}
+
+func TestCloudformationParameters(t *testing.T) {
+	data := `
+Parameters:
+  key1: 1
+  key2: 2
+`
+	expect := map[string]bool{
+		"key1": true,
+		"key2": true,
+	}
+	got, err := helpers.CloudformationParameters([]byte(data))
+	require.NoError(t, err)
+	require.Equal(t, expect, got)
+}
+
+func TestCloudformationUninstall(t *testing.T) {
+	cf := &mockaws.CloudFormationAPI{}
+	expectStack := &cloudformation.Stack{
+		StackId:     aws.String("id1"),
+		StackName:   aws.String("stack1"),
+		StackStatus: aws.String("CREATE_COMPLETE"),
+	}
+
+	cf.On("DeleteStack", mock.Anything).Return(nil, nil)
+
+	cf.On("WaitUntilStackDeleteComplete", mock.Anything).Return(func(in *cloudformation.DescribeStacksInput) error {
+		require.Equal(t, expectStack.StackName, in.StackName)
+		return nil
+	})
+
+	err := helpers.CloudformationUninstall(cf, *expectStack.StackName)
+	require.NoError(t, err)
+}
+
+func TestCloudformationUpdate(t *testing.T) {
+	cf := &mockaws.CloudFormationAPI{}
+	expectStack := &cloudformation.Stack{
+		StackId:   aws.String("id1"),
+		StackName: aws.String("stack1"),
+		Parameters: []*cloudformation.Parameter{
+			{
+				ParameterKey:   aws.String("param1"),
+				ParameterValue: aws.String("old"),
+			},
+		},
+	}
+
+	cf.On("DescribeStacks", mock.Anything).Return(&cloudformation.DescribeStacksOutput{
+		Stacks: []*cloudformation.Stack{
+			expectStack,
+		},
+	}, nil)
+
+	cf.On("UpdateStack", mock.Anything).Return(func(in *cloudformation.UpdateStackInput) *cloudformation.UpdateStackOutput {
+		require.Equal(t, expectStack.Parameters[0].ParameterKey, in.Parameters[0].ParameterKey)
+		require.Equal(t, aws.String("new"), in.Parameters[0].ParameterValue)
+		return nil
+	}, nil)
+
+	err := helpers.CloudformationUpdate(cf, *expectStack.StackName, "", map[string]string{
+		"param1": "new",
+	}, map[string]string{}, "")
+	require.NoError(t, err)
+}
+
+func TestCloudWatchLogsStream(t *testing.T) {
+	cf := &mockaws.CloudWatchLogsAPI{}
+	cf.On("FilterLogEvents", mock.Anything).Return(func(in *cloudwatchlogs.FilterLogEventsInput) *cloudwatchlogs.FilterLogEventsOutput {
+		return &cloudwatchlogs.FilterLogEventsOutput{
+			Events: []*cloudwatchlogs.FilteredLogEvent{
+				{
+					EventId:       aws.String("id1"),
+					IngestionTime: aws.Int64(time.Now().Unix()),
+					LogStreamName: aws.String("strm"),
+					Message:       aws.String("hello"),
+					Timestamp:     aws.Int64(time.Now().Unix()),
+				},
+			},
+		}
+	}, nil)
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	go func() {
+		time.Sleep(1 * time.Second)
+		cancel()
+	}()
+
+	wc := &myWriteCloser{
+		bufio.NewWriter(&bytes.Buffer{}),
+	}
+	err := helpers.CloudWatchLogsStream(ctx, cf, wc, "grp", "strm", structs.LogsOptions{})
+	require.NoError(t, err)
+}
+
+type myWriteCloser struct {
+	*bufio.Writer
+}
+
+func (mwc *myWriteCloser) Close() error {
+	// Noop
+	return nil
+}

pkg/helpers/certificate_test.go

@@ -0,0 +1,16 @@
+package helpers_test
+
+import (
+	"testing"
+
+	"github.com/convox/rack/pkg/helpers"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCertificate(t *testing.T) {
+	cert, err := helpers.CertificateSelfSigned("convox.com")
+	require.NoError(t, err)
+
+	_, err = helpers.CertificateCA("convox.com", cert)
+	require.NoError(t, err)
+}

pkg/helpers/coalesec_test.go

@@ -0,0 +1,56 @@
+package helpers_test
+
+import (
+	"testing"
+
+	"github.com/convox/rack/pkg/helpers"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCoalesceInt(t *testing.T) {
+	testData := []struct {
+		given  []int
+		expect int
+	}{
+		{
+			given:  []int{1, 2, 3, 4, 5},
+			expect: 1,
+		},
+		{
+			given:  []int{1},
+			expect: 1,
+		},
+		{
+			given:  []int{0, 0, 0, 2, 4},
+			expect: 2,
+		},
+	}
+
+	for _, td := range testData {
+		require.Equal(t, td.expect, helpers.CoalesceInt(td.given...))
+	}
+}
+
+func TestCoalesceString(t *testing.T) {
+	testData := []struct {
+		given  []string
+		expect string
+	}{
+		{
+			given:  []string{"1", "2"},
+			expect: "1",
+		},
+		{
+			given:  []string{"1"},
+			expect: "1",
+		},
+		{
+			given:  []string{"", "", "2", "3"},
+			expect: "2",
+		},
+	}
+
+	for _, td := range testData {
+		require.Equal(t, td.expect, helpers.CoalesceString(td.given...))
+	}
+}

pkg/helpers/endpoint_test.go

@@ -0,0 +1,30 @@
+package helpers_test
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/convox/rack/pkg/helpers"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEndpointCheck(t *testing.T) {
+	ht := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		return
+	}))
+	defer ht.Close()
+
+	err := helpers.EndpointCheck(ht.URL)
+	require.NoError(t, err)
+}
+
+func TestEndpointWait(t *testing.T) {
+	ht := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		return
+	}))
+	defer ht.Close()
+
+	err := helpers.EndpointWait(ht.URL)
+	require.NoError(t, err)
+}

pkg/helpers/env_test.go

@@ -0,0 +1,54 @@
+package helpers_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/convox/rack/pkg/helpers"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEnvDiff(t *testing.T) {
+	testData := []struct {
+		env1   map[string]string
+		env2   map[string]string
+		expect string
+	}{
+		{
+			env1: map[string]string{
+				"a": "1",
+				"b": "1",
+			},
+			env2: map[string]string{
+				"a": "2",
+				"c": "1",
+			},
+			expect: "add:c change:a remove:b",
+		},
+		{
+			env1: map[string]string{
+				"a": "1",
+				"b": "1",
+			},
+			env2: map[string]string{
+				"a": "1",
+				"b": "1",
+			},
+			expect: "",
+		},
+	}
+
+	envGen := func(m map[string]string) string {
+		out := ""
+		for k, v := range m {
+			out = out + fmt.Sprintf("%s=%s\n", k, v)
+		}
+		return out
+	}
+
+	for _, td := range testData {
+		got, err := helpers.EnvDiff(envGen(td.env1), envGen(td.env2))
+		require.NoError(t, err)
+		require.Equal(t, td.expect, got)
+	}
+}