tests(parser): adding tests for parser package. (#243)

* fix(parser): remove superfluous error catch

* tests(parser): adding tests for parser package.

* tests(parser): add additional parser tests for additional command args.

* fix(parser): use cmdr print functions for printHelp

* tests(parser): add parser tests for bare commands.

* tests(parser): better detect which function is called by returning specific error.

* tests(parser): remove FakeCommander.

* tests(parser): minor move to keep tests similar.

* tests(parser): minor addition of ps->ps:list test

* Revert "fix(parser): use cmdr print functions for printHelp"

This reverts commit 572014fe7bba29efe76fc896e1adb72519936197.

Author: ultimateboy

parser/apps_test.go

@@ -0,0 +1,118 @@
+package parser
+
+import (
+	"bytes"
+	"errors"
+	"testing"
+
+	"github.com/arschles/assert"
+	"github.com/deis/workflow-cli/pkg/testutil"
+)
+
+// Create fake implementations of each method that return the argument
+// we expect to have called the function (as an error to satisfy the interface).
+
+func (d FakeDeisCmd) AppCreate(string, string, string, bool) error {
+	return errors.New("apps:create")
+}
+
+func (d FakeDeisCmd) AppsList(int) error {
+	return errors.New("apps:list")
+}
+
+func (d FakeDeisCmd) AppInfo(string) error {
+	return errors.New("apps:info")
+}
+
+func (d FakeDeisCmd) AppOpen(string) error {
+	return errors.New("apps:open")
+}
+
+func (d FakeDeisCmd) AppLogs(string, int) error {
+	return errors.New("apps:logs")
+}
+
+func (d FakeDeisCmd) AppRun(string, string) error {
+	return errors.New("apps:run")
+}
+
+func (d FakeDeisCmd) AppDestroy(string, string) error {
+	return errors.New("apps:destroy")
+}
+
+func (d FakeDeisCmd) AppTransfer(string, string) error {
+	return errors.New("apps:transfer")
+}
+
+func TestApps(t *testing.T) {
+	t.Parallel()
+
+	cf, server, err := testutil.NewTestServerAndClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer server.Close()
+	var b bytes.Buffer
+	cmdr := FakeDeisCmd{WOut: &b, ConfigFile: cf}
+
+	// cases defines the arguments and expected return of the call.
+	// if expected is "", it defaults to args[0].
+	cases := []struct {
+		args     []string
+		expected string
+	}{
+		{
+			args:     []string{"apps:create"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps:list"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps:info"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps:open"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps:logs"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps:logs", "--lines=1"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps:run", "ls"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps:destroy"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps:transfer", "test-user"},
+			expected: "",
+		},
+		{
+			args:     []string{"apps"},
+			expected: "apps:list",
+		},
+	}
+
+	// For each case, check that calling the route with the arguments
+	// returns the expected error, which is args[0] if not provided.
+	for _, c := range cases {
+		var expected string
+		if c.expected == "" {
+			expected = c.args[0]
+		} else {
+			expected = c.expected
+		}
+		err = Apps(c.args, cmdr)
+		assert.Err(t, errors.New(expected), err)
+	}
+}

parser/auth_test.go

@@ -0,0 +1,106 @@
+package parser
+
+import (
+	"bytes"
+	"errors"
+	"testing"
+
+	"github.com/arschles/assert"
+	"github.com/deis/workflow-cli/pkg/testutil"
+)
+
+// Create fake implementations of each method that return the argument
+// we expect to have called the function (as an error to satisfy the interface).
+
+func (d FakeDeisCmd) Register(string, string, string, string, bool) error {
+	return errors.New("auth:register")
+}
+
+func (d FakeDeisCmd) Login(string, string, string, bool) error {
+	return errors.New("auth:login")
+}
+
+func (d FakeDeisCmd) Logout() error {
+	return errors.New("auth:logout")
+}
+
+func (d FakeDeisCmd) Passwd(string, string, string) error {
+	return errors.New("auth:passwd")
+}
+
+func (d FakeDeisCmd) Cancel(string, string, bool) error {
+	return errors.New("auth:cancel")
+}
+
+func (d FakeDeisCmd) Whoami(bool) error {
+	return errors.New("auth:whoami")
+}
+
+func (d FakeDeisCmd) Regenerate(string, bool) error {
+	return errors.New("auth:regenerate")
+}
+
+func TestAuth(t *testing.T) {
+	t.Parallel()
+
+	cf, server, err := testutil.NewTestServerAndClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer server.Close()
+	var b bytes.Buffer
+	cmdr := FakeDeisCmd{WOut: &b, ConfigFile: cf}
+
+	// cases defines the arguments and expected return of the call.
+	// if expected is "", it defaults to args[0].
+	cases := []struct {
+		args     []string
+		expected string
+	}{
+		{
+			args:     []string{"auth:register", server.Server.URL},
+			expected: "",
+		},
+		{
+			args:     []string{"auth:login", server.Server.URL},
+			expected: "",
+		},
+		{
+			args:     []string{"auth:login", server.Server.URL, "--ssl-verify=true"},
+			expected: "",
+		},
+		{
+			args:     []string{"auth:logout"},
+			expected: "",
+		},
+		{
+			args:     []string{"auth:passwd"},
+			expected: "",
+		},
+		{
+			args:     []string{"auth:whoami"},
+			expected: "",
+		},
+		{
+			args:     []string{"auth:cancel"},
+			expected: "",
+		},
+		{
+			args:     []string{"auth:regenerate"},
+			expected: "",
+		},
+	}
+
+	// For each case, check that calling the route with the arguments
+	// returns the expected error, which is args[0] if not provided.
+	for _, c := range cases {
+		var expected string
+		if c.expected == "" {
+			expected = c.args[0]
+		} else {
+			expected = c.expected
+		}
+		err = Auth(c.args, cmdr)
+		assert.Err(t, errors.New(expected), err)
+	}
+}

parser/autoscale_test.go

@@ -0,0 +1,74 @@
+package parser
+
+import (
+	"bytes"
+	"errors"
+	"testing"
+
+	"github.com/arschles/assert"
+	"github.com/deis/workflow-cli/pkg/testutil"
+)
+
+// Create fake implementations of each method that return the argument
+// we expect to have called the function (as an error to satisfy the interface).
+
+func (d FakeDeisCmd) AutoscaleList(string) error {
+	return errors.New("autoscale:list")
+}
+
+func (d FakeDeisCmd) AutoscaleSet(string, string, int, int, int) error {
+	return errors.New("autoscale:set")
+}
+
+func (d FakeDeisCmd) AutoscaleUnset(string, string) error {
+	return errors.New("autoscale:unset")
+}
+
+func TestAutoscale(t *testing.T) {
+	t.Parallel()
+
+	cf, server, err := testutil.NewTestServerAndClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer server.Close()
+	var b bytes.Buffer
+	cmdr := FakeDeisCmd{WOut: &b, ConfigFile: cf}
+
+	// cases defines the arguments and expected return of the call.
+	// if expected is "", it defaults to args[0].
+	cases := []struct {
+		args     []string
+		expected string
+	}{
+		{
+			args:     []string{"autoscale:list"},
+			expected: "",
+		},
+		{
+			args:     []string{"autoscale:set", "web/cmd", "--min=1", "--max=3", "--cpu-percent=50"},
+			expected: "",
+		},
+		{
+			args:     []string{"autoscale:unset", "web/cmd"},
+			expected: "",
+		},
+		{
+			args:     []string{"autoscale"},
+			expected: "autoscale:list",
+		},
+	}
+
+	// For each case, check that calling the route with the arguments
+	// returns the expected error, which is args[0] if not provided.
+	for _, c := range cases {
+		var expected string
+		if c.expected == "" {
+			expected = c.args[0]
+		} else {
+			expected = c.expected
+		}
+		err = Autoscale(c.args, cmdr)
+		assert.Err(t, errors.New(expected), err)
+	}
+}

parser/builds_test.go

@@ -0,0 +1,63 @@
+package parser
+
+import (
+	"bytes"
+	"errors"
+	"testing"
+
+	"github.com/arschles/assert"
+	"github.com/deis/workflow-cli/pkg/testutil"
+)
+
+func (d FakeDeisCmd) BuildsList(string, int) error {
+	return errors.New("builds:list")
+}
+
+func (d FakeDeisCmd) BuildsCreate(string, string, string) error {
+	return errors.New("builds:create")
+}
+
+func TestBuilds(t *testing.T) {
+	t.Parallel()
+
+	cf, server, err := testutil.NewTestServerAndClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer server.Close()
+	var b bytes.Buffer
+	cmdr := FakeDeisCmd{WOut: &b, ConfigFile: cf}
+
+	// cases defines the arguments and expected return of the call.
+	// if expected is "", it defaults to args[0].
+	cases := []struct {
+		args     []string
+		expected string
+	}{
+		{
+			args:     []string{"builds:list"},
+			expected: "",
+		},
+		{
+			args:     []string{"builds:create", "deis/example-go:latest"},
+			expected: "",
+		},
+		{
+			args:     []string{"builds"},
+			expected: "builds:list",
+		},
+	}
+
+	// For each case, check that calling the route with the arguments
+	// returns the expected error, which is args[0] if not provided.
+	for _, c := range cases {
+		var expected string
+		if c.expected == "" {
+			expected = c.args[0]
+		} else {
+			expected = c.expected
+		}
+		err = Builds(c.args, cmdr)
+		assert.Err(t, errors.New(expected), err)
+	}
+}