feat: Allow caller to *not* write to output file. Major restructuring to CommandLineSettings and other classes to support full unit testing.

Author: gboysko

README.md

@@ -68,7 +68,7 @@ To run the unit tests, use the following command line:
 
 ```bash
 // Assumes that you are inside the cloud-resource-counter folder
-$ go test . -v
+$ go test
 ```
 
 ## Minimal IAM Policy

accountId_test.go

@@ -91,6 +91,8 @@ func TestGetAccountID(t *testing.T) {
 		} else if actualAccountID != c.expectedAccountID {
 			// Does the expected value NOT match the actual value?
 			t.Errorf("Error: Account returned '%s'; expected %s", actualAccountID, c.expectedAccountID)
+		} else if mon.ProgramExited {
+			t.Errorf("Unexpected Exit: The program unexpected exited with status code=%d", mon.ExitCode)
 		}
 	}
 }

activityMonitor.go

@@ -10,7 +10,6 @@ package main
 import (
 	"fmt"
 	"io"
-	"os"
 	"strings"
 
 	"github.com/aws/aws-sdk-go/aws/awserr"
@@ -26,12 +25,14 @@ type ActivityMonitor interface {
 	CheckError(error) bool
 	ActionError(string, ...interface{})
 	EndAction(string, ...interface{})
+	Exit(int)
 }
 
 // TerminalActivityMonitor is our terminal-based activity monitor. It allows
 // the caller to supply an io.Writer to direct output to.
 type TerminalActivityMonitor struct {
 	io.Writer
+	ExitFn func(int)
 }
 
 // Message constructs a simple message from the format string and arguments
@@ -85,14 +86,23 @@ func (tam *TerminalActivityMonitor) CheckError(err error) bool {
 // ActionError formats the supplied format string (and associated parameters) in
 // RED and exits the tool.
 func (tam *TerminalActivityMonitor) ActionError(format string, v ...interface{}) {
+	// Display an error message (and newline)
 	fmt.Fprintln(tam.Writer, color.Red(fmt.Sprintf(format, v...)))
 	fmt.Fprintln(tam.Writer)
 
-	os.Exit(1)
+	// Exit the program
+	tam.Exit(1)
 }
 
 // EndAction receives a format string (and arguments) and sends to the supplied
 // Writer.
 func (tam *TerminalActivityMonitor) EndAction(format string, v ...interface{}) {
 	fmt.Fprintln(tam.Writer, fmt.Sprintf(format, v...))
 }
+
+// Exit causes the application to exit
+func (tam *TerminalActivityMonitor) Exit(resultCode int) {
+	if tam.ExitFn != nil {
+		tam.ExitFn(resultCode)
+	}
+}

activityMonitor_test.go

@@ -0,0 +1,124 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+func TestTerminalActivityMonitorMessage(t *testing.T) {
+	// Create a builder to hold our contents...
+	builder := strings.Builder{}
+
+	// Create an instance of the Terminal Activity Monitor
+	mon := TerminalActivityMonitor{
+		Writer: &builder,
+	}
+
+	// Send it some messages...
+	mon.Message("Testing %d,%d,%d", 1, 2, 3)
+	if builder.String() != "Testing 1,2,3" {
+		t.Errorf("Unexpected message: expected %s, actual %s", "Testing 1,2,3", builder.String())
+	}
+}
+
+func TestTerminalActivityMonitorStartAction(t *testing.T) {
+	// Create a builder to hold our contents...
+	builder := strings.Builder{}
+
+	// Create an instance of the Terminal Activity Monitor
+	mon := TerminalActivityMonitor{
+		Writer: &builder,
+	}
+
+	// Start an action
+	mon.StartAction("Doing something good")
+	if builder.String() != " * Doing something good..." {
+		t.Errorf("Unexpected StartAction: expected %s, actual %s", " * Doing something good...", builder.String())
+	}
+}
+
+func TestTerminalActivityMonitorEndAction(t *testing.T) {
+	// Create a builder to hold our contents...
+	builder := strings.Builder{}
+
+	// Create an instance of the Terminal Activity Monitor
+	mon := TerminalActivityMonitor{
+		Writer: &builder,
+	}
+
+	// Start an action
+	mon.EndAction("OK (%d)", 123)
+	if builder.String() != "OK (123)\n" {
+		t.Errorf("Unexpected EndAction: expected %s, actual %s", "OK (123)\n", builder.String())
+	}
+}
+
+func TestTerminalActivityMonitorCheckError(t *testing.T) {
+	// Create some test cases with actual errors...
+	cases := []struct {
+		Error          error
+		IsEmpty        bool
+		ContainsString string
+	}{
+		{
+			IsEmpty: true,
+		},
+		{
+			Error:          errors.New("Something is very wrong"),
+			ContainsString: "Something is very wrong",
+		},
+		{
+			Error:          awserr.New("NoCredentialProviders", "blah", nil),
+			ContainsString: "profile does not exist",
+		},
+		{
+			Error:          awserr.New("AccessDeniedException", "You don't have access to do this stuff\nAnd another thing", nil),
+			ContainsString: "You don't have access to do this stuff",
+		},
+		{
+			Error:          awserr.New("InvalidClientTokenId", "This is a very technical error\nBlah, blah, blah", nil),
+			ContainsString: "region is not supported",
+		},
+		{
+			Error:          awserr.New("SomethingSmellsFishy", "There is something not quite right\nNot really sure what it is", nil),
+			ContainsString: "SomethingSmellsFishy: There is something not quite right",
+		},
+	}
+
+	// Loop through the test cases...
+	for _, c := range cases {
+		// Create an exit function which simply sets a value
+		var exitMsg string
+		exitFn := func(resultCode int) {
+			exitMsg = fmt.Sprintf("Status %d", resultCode)
+		}
+
+		// Create a builder to hold our contents...
+		builder := strings.Builder{}
+
+		// Create an instance of the Terminal Activity Monitor
+		mon := TerminalActivityMonitor{
+			Writer: &builder,
+			ExitFn: exitFn,
+		}
+
+		// Check for error
+		mon.CheckError(c.Error)
+
+		// Get our actual string
+		actual := builder.String()
+
+		// Do we expect a string?
+		if c.IsEmpty && actual != "" {
+			t.Errorf("Unexpected CheckError: expected %s, actual %s", "", actual)
+		} else if !strings.Contains(actual, c.ContainsString) {
+			t.Errorf("Unexpected CheckError: expected '%s' to be contained in '%s', but it was not", c.ContainsString, actual)
+		} else if c.Error != nil && exitMsg != "Status 1" {
+			t.Errorf("Unexpected CheckError: ExitFn: expected %s, actual %s", "Status 1", exitMsg)
+		}
+	}
+}

api.go

@@ -9,7 +9,7 @@ package main
 
 import (
 	"fmt"
-	"os"
+	"io"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
@@ -193,7 +193,7 @@ type AWSServiceFactory struct {
 	Session     *session.Session
 	ProfileName string
 	RegionName  string
-	TraceFile   *os.File
+	TraceWriter io.Writer
 }
 
 // Init initializes the AWS service factory by creating an
@@ -202,7 +202,7 @@ type AWSServiceFactory struct {
 // tracing (if requested).
 func (awssf *AWSServiceFactory) Init() {
 	// Create an initial configuration object (pointer)
-	var config *aws.Config = aws.NewConfig()
+	config := &aws.Config{}
 
 	// Was a region specified by the user?
 	if awssf.RegionName != "" {
@@ -211,27 +211,25 @@ func (awssf *AWSServiceFactory) Init() {
 	}
 
 	// Was tracing specified by the user?
-	if awssf.TraceFile != nil {
+	if awssf.TraceWriter != nil {
 		// Enable logging of AWS Calls with Body
 		config = config.WithLogLevel(aws.LogDebugWithHTTPBody)
 
 		// Enable a logger function which writes to the Trace file
 		config = config.WithLogger(aws.LoggerFunc(func(args ...interface{}) {
-			fmt.Fprintln(awssf.TraceFile, args...)
+			fmt.Fprintln(awssf.TraceWriter, args...)
 		}))
 	}
 
 	// Construct our session Options object
-	input := session.Options{
+	options := session.Options{
 		SharedConfigState: session.SharedConfigEnable,
 		Profile:           awssf.ProfileName,
 		Config:            *config,
 	}
 
 	// Ensure that we have a session
-	// It is not clear how a flawed session would manifest itself in this call
-	// (as there is no error object returned). Perhaps a panic() is raised.
-	sess := session.Must(session.NewSessionWithOptions(input))
+	sess := session.Must(session.NewSessionWithOptions(options))
 
 	// Does this session have a region? If not, use the default region
 	if *sess.Config.Region == "" {