Added more test-cases

For the commands that write to STDIO we've introduced a level of
indirection using a handle for writing to.  We then look for that
output when running tests - mocking the writes to a temporary buffer

Author: skx

config_cmd.go

@@ -101,10 +101,10 @@ delay   | The amount of time to sleep between retried HTTP-fetches.
 // Execute is invoked if the user specifies `add` as the subcommand.
 func (a *configCmd) Execute(args []string) int {
 
-	fmt.Printf("This command only exists to show help, when executed as")
-	fmt.Printf("\n")
-	fmt.Printf("rss2email help config")
-	fmt.Printf("\n")
+	fmt.Fprintf(out, "This command only exists to show help, when executed as:")
+	fmt.Fprintf(out, "\n")
+	fmt.Fprintf(out, "rss2email help config")
+	fmt.Fprintf(out, "\n")
 
 	// All done, with no errors.
 	return 0

config_cmd_test.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestConfig(t *testing.T) {
+
+	bak := out
+	out = new(bytes.Buffer)
+	defer func() { out = bak }()
+
+	s := configCmd{}
+
+	//
+	// Call the handler.
+	//
+	s.Execute([]string{})
+
+	//
+	// Look for some lines in the output
+	//
+	expected := []string{
+		"only exists to show help",
+		"rss2email help config",
+	}
+
+	// The text written to stdout
+	output := out.(*bytes.Buffer).String()
+
+	for _, txt := range expected {
+		if !strings.Contains(output, txt) {
+			t.Fatalf("Failed to find expected output")
+		}
+	}
+}

export_cmd.go

@@ -5,8 +5,8 @@
 package main
 
 import (
+	"flag"
 	"fmt"
-	"os"
 	"text/template"
 
 	"github.com/skx/rss2email/configfile"
@@ -18,6 +18,9 @@ type exportCmd struct {
 
 	// We embed the NoFlags option, because we accept no command-line flags.
 	subcommands.NoFlags
+
+	// Configuration file, used for testing
+	config *configfile.ConfigFile
 }
 
 // Info is part of the subcommand-API
@@ -37,6 +40,14 @@ Example:
 `
 }
 
+// Arguments handles argument-flags we might have.
+//
+// In our case we use this as a hook to setup our configuration-file,
+// which allows testing.
+func (e *exportCmd) Arguments(flags *flag.FlagSet) {
+	e.config = configfile.New()
+}
+
 // Execute is invoked if the user specifies `add` as the subcommand.
 func (e *exportCmd) Execute(args []string) int {
 
@@ -51,14 +62,11 @@ func (e *exportCmd) Execute(args []string) int {
 	}
 	data := TemplateData{}
 
-	// Get the configuration-file
-	conf := configfile.New()
-
-	// Upgrade it if necessary
-	conf.Upgrade()
+	// Upgrade our configuration file if necessary
+	e.config.Upgrade()
 
 	// Now do the parsing
-	entries, err := conf.Parse()
+	entries, err := e.config.Parse()
 	if err != nil {
 		fmt.Printf("Error with config-file: %s\n", err.Error())
 		return 1
@@ -83,7 +91,7 @@ func (e *exportCmd) Execute(args []string) int {
 `
 	// Compile the template and write to STDOUT
 	t := template.Must(template.New("tmpl").Parse(tmpl))
-	err = t.Execute(os.Stdout, data)
+	err = t.Execute(out, data)
 	if err != nil {
 		fmt.Printf("error rendering template: %s\n", err.Error())
 		return 1

export_cmd_test.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/skx/rss2email/configfile"
+)
+
+func TestExport(t *testing.T) {
+
+	// Replace the STDIO handle
+	bak := out
+	out = new(bytes.Buffer)
+	defer func() { out = bak }()
+
+	// Create a simple configuration file
+	content := `# Comment here
+https://example.org/
+https://example.net/
+ - foo: bar
+`
+	data := []byte(content)
+	tmpfile, err := ioutil.TempFile("", "example")
+	if err != nil {
+		t.Fatalf("Error creating temporary file")
+	}
+
+	if _, err := tmpfile.Write(data); err != nil {
+		t.Fatalf("Error writing to config file")
+	}
+	if err := tmpfile.Close(); err != nil {
+		t.Fatalf("Error creating temporary file")
+	}
+
+	// Create an instance of the command, and setup the config file
+	ex := exportCmd{}
+	ex.Arguments(nil)
+	config := configfile.NewWithPath(tmpfile.Name())
+	ex.config = config
+
+	// Run the export
+	ex.Execute([]string{})
+
+	//
+	// Look for some lines in the output
+	//
+	expected := []string{
+		"Feed Export",
+		"xmlUrl=\"https://example.org/\"",
+		"</opml>",
+	}
+
+	// The text written to stdout
+	output := out.(*bytes.Buffer).String()
+
+	for _, txt := range expected {
+		if !strings.Contains(output, txt) {
+			t.Fatalf("Failed to find expected output")
+		}
+	}
+
+	// Cleanup
+	os.Remove(tmpfile.Name())
+}

list_default_template_cmd.go

@@ -54,6 +54,6 @@ func (l *listDefaultTemplateCmd) Execute(args []string) int {
 		os.Exit(1)
 	}
 
-	fmt.Printf("%s\n", string(content))
+	fmt.Fprintf(out, "%s\n", string(content))
 	return 0
 }

list_default_template_cmd_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"strings"
+	"testing"
+)
+
+func TestDefaultTemplate(t *testing.T) {
+
+	bak := out
+	out = new(bytes.Buffer)
+	defer func() { out = bak }()
+
+	s := listDefaultTemplateCmd{}
+
+	//
+	// Call the Arguments function for coverage.
+	//
+	flags := flag.NewFlagSet("test", flag.ContinueOnError)
+	s.Arguments(flags)
+
+	//
+	// Call the handler.
+	//
+	s.Execute([]string{})
+
+	//
+	// Look for some lines in the output
+	//
+	expected := []string{
+		"X-RSS-Link: {{.Link}}",
+		"Content-Type: multipart/alternative;",
+		"the default template which is used by default to generate emails",
+	}
+
+	// The text written to stdout
+	output := out.(*bytes.Buffer).String()
+
+	for _, txt := range expected {
+		if !strings.Contains(output, txt) {
+			t.Fatalf("Failed to find expected output")
+		}
+	}
+}

version_cmd.go

@@ -7,9 +7,16 @@ package main
 import (
 	"flag"
 	"fmt"
+	"io"
+	"os"
 	"runtime"
 )
 
+//
+// modified during testing
+//
+var out io.Writer = os.Stdout
+
 var (
 	version = "unreleased"
 )
@@ -35,9 +42,9 @@ func (v *versionCmd) Arguments(f *flag.FlagSet) {
 // Show the version - using the "out"-writer.
 //
 func showVersion(verbose bool) {
-	fmt.Printf("%s\n", version)
+	fmt.Fprintf(out, "%s\n", version)
 	if verbose {
-		fmt.Printf("Built with %s\n", runtime.Version())
+		fmt.Fprintf(out, "Built with %s\n", runtime.Version())
 	}
 }
 

version_cmd_test.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"runtime"
+	"testing"
+)
+
+func TestVersion(t *testing.T) {
+	bak := out
+	out = new(bytes.Buffer)
+	defer func() { out = bak }()
+
+	//
+	// Expected
+	//
+	expected := "unreleased\n"
+
+	s := versionCmd{}
+
+	//
+	// Call the Arguments function for coverage.
+	//
+	flags := flag.NewFlagSet("test", flag.ContinueOnError)
+	s.Arguments(flags)
+
+	//
+	// Call the handler.
+	//
+	s.Execute([]string{})
+
+	if out.(*bytes.Buffer).String() != expected {
+		t.Errorf("Expected '%s' received '%s'", expected, out)
+	}
+}
+
+func TestVersionVerbose(t *testing.T) {
+	bak := out
+	out = new(bytes.Buffer)
+	defer func() { out = bak }()
+
+	//
+	// Expected
+	//
+	expected := "unreleased\nBuilt with " + runtime.Version() + "\n"
+
+	s := versionCmd{verbose: true}
+
+	//
+	// Call the handler.
+	//
+	s.Execute([]string{})
+
+	if out.(*bytes.Buffer).String() != expected {
+		t.Errorf("Expected '%s' received '%s'", expected, out)
+	}
+}