Increase test coverage (gopasspw#568)

Makefile

@@ -132,7 +132,7 @@ codequality:
 		$(GO) get -u github.com/fzipp/gocyclo; \
 	fi
 	@$(foreach gofile, $(GOFILES_NOVENDOR),\
-			gocyclo -over 15 $(gofile);)
+			gocyclo -over 15 $(gofile) || exit 1;)
 	@$(call ok)
 
 	@echo -n "     LINT      "

action/action_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/blang/semver"
+	"github.com/fatih/color"
 	"github.com/google/go-cmp/cmp"
 	gpgmock "github.com/justwatchcom/gopass/backend/gpg/mock"
 	"github.com/justwatchcom/gopass/config"
@@ -53,6 +54,10 @@ func newMock(ctx context.Context, dir string) (*Action, error) {
 func capture(t *testing.T, fn func() error) string {
 	t.Helper()
 	old := os.Stdout
+
+	oldcol := color.NoColor
+	color.NoColor = true
+
 	r, w, _ := os.Pipe()
 	os.Stdout = w
 
@@ -67,6 +72,7 @@ func capture(t *testing.T, fn func() error) string {
 	// back to normal
 	_ = w.Close()
 	os.Stdout = old
+	color.NoColor = oldcol
 	if err != nil {
 		t.Errorf("Error: %s", err)
 	}

action/binary_test.go

@@ -62,25 +62,93 @@ func TestBinary(t *testing.T) {
 	if err := act.BinarySum(ctx, c); err == nil {
 		t.Errorf("Should fail")
 	}
+}
+
+func TestBinaryCat(t *testing.T) {
+	td, err := ioutil.TempDir("", "gopass-")
+	if err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+	defer func() {
+		_ = os.RemoveAll(td)
+	}()
+
+	ctx := context.Background()
+	ctx = ctxutil.WithAlwaysYes(ctx, true)
+	ctx = out.WithHidden(ctx, true)
+	act, err := newMock(ctx, td)
+	if err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+
+	app := cli.NewApp()
+
+	buf := &bytes.Buffer{}
+	out.Stdout = buf
+	defer func() {
+		out.Stdout = os.Stdout
+	}()
+
+	infile := filepath.Join(td, "input.txt")
+	if err := ioutil.WriteFile(infile, []byte("0xDEADBEEF"), 0644); err != nil {
+		t.Fatalf("Failed to write input file: %s", err)
+	}
+	if err := act.binaryCopy(ctx, infile, "bar", true); err != nil {
+		t.Fatalf("Failed to move file to store: %s", err)
+	}
 
 	// binary cat bar
-	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	fs := flag.NewFlagSet("default", flag.ContinueOnError)
 	if err := fs.Parse([]string{"bar"}); err != nil {
 		t.Fatalf("Error: %s", err)
 	}
-	c = cli.NewContext(app, fs, nil)
+	c := cli.NewContext(app, fs, nil)
 	if err := act.BinaryCat(ctx, c); err != nil {
 		t.Errorf("Should not fail")
 	}
+}
+
+func TestBinaryCopy(t *testing.T) {
+	td, err := ioutil.TempDir("", "gopass-")
+	if err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+	defer func() {
+		_ = os.RemoveAll(td)
+	}()
+
+	ctx := context.Background()
+	ctx = ctxutil.WithAlwaysYes(ctx, true)
+	ctx = out.WithHidden(ctx, true)
+	act, err := newMock(ctx, td)
+	if err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+
+	app := cli.NewApp()
+
+	buf := &bytes.Buffer{}
+	out.Stdout = buf
+	defer func() {
+		out.Stdout = os.Stdout
+	}()
+
+	infile := filepath.Join(td, "input.txt")
+	if err := ioutil.WriteFile(infile, []byte("0xDEADBEEF"), 0644); err != nil {
+		t.Fatalf("Failed to write input file: %s", err)
+	}
+	if err := act.binaryCopy(ctx, infile, "bar", true); err != nil {
+		t.Fatalf("Failed to move file to store: %s", err)
+	}
 
 	outfile := filepath.Join(td, "output.txt")
 
 	// binary copy bar tempdir/bar
-	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	fs := flag.NewFlagSet("default", flag.ContinueOnError)
 	if err := fs.Parse([]string{"bar", outfile}); err != nil {
 		t.Fatalf("Error: %s", err)
 	}
-	c = cli.NewContext(app, fs, nil)
+	c := cli.NewContext(app, fs, nil)
 	if err := act.BinaryCopy(ctx, c); err != nil {
 		t.Errorf("Should not fail")
 	}
@@ -94,13 +162,47 @@ func TestBinary(t *testing.T) {
 	if err := act.BinaryMove(ctx, c); err != nil {
 		t.Errorf("Should not fail")
 	}
+}
+
+func TestBinarySum(t *testing.T) {
+	td, err := ioutil.TempDir("", "gopass-")
+	if err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+	defer func() {
+		_ = os.RemoveAll(td)
+	}()
+
+	ctx := context.Background()
+	ctx = ctxutil.WithAlwaysYes(ctx, true)
+	ctx = out.WithHidden(ctx, true)
+	act, err := newMock(ctx, td)
+	if err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+
+	app := cli.NewApp()
+
+	buf := &bytes.Buffer{}
+	out.Stdout = buf
+	defer func() {
+		out.Stdout = os.Stdout
+	}()
+
+	infile := filepath.Join(td, "input.txt")
+	if err := ioutil.WriteFile(infile, []byte("0xDEADBEEF"), 0644); err != nil {
+		t.Fatalf("Failed to write input file: %s", err)
+	}
+	if err := act.binaryCopy(ctx, infile, "bar", true); err != nil {
+		t.Fatalf("Failed to move file to store: %s", err)
+	}
 
 	// binary sum bar
-	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	fs := flag.NewFlagSet("default", flag.ContinueOnError)
 	if err := fs.Parse([]string{"bar"}); err != nil {
 		t.Fatalf("Error: %s", err)
 	}
-	c = cli.NewContext(app, fs, nil)
+	c := cli.NewContext(app, fs, nil)
 	if err := act.BinarySum(ctx, c); err != nil {
 		t.Errorf("Should not fail")
 	}

action/config_test.go

@@ -72,9 +72,8 @@ func TestConfig(t *testing.T) {
 	}
 	buf.Reset()
 
-	act.cfg.Mounts["foo"] = &config.StoreConfig{}
-
 	// action.printConfigValues
+	act.cfg.Mounts["foo"] = &config.StoreConfig{}
 	if err := act.printConfigValues(ctx, "", "nopager"); err != nil {
 		t.Errorf("Error: %s", err)
 	}
@@ -84,5 +83,40 @@ foo/nopager: false`
 	if sv != want {
 		t.Errorf("Wrong config result: '%s' != '%s'", sv, want)
 	}
+
+	delete(act.cfg.Mounts, "foo")
 	buf.Reset()
+
+	// config autoimport
+	fs := flag.NewFlagSet("default", flag.ContinueOnError)
+	if err := fs.Parse([]string{"autoimport"}); err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+	c = cli.NewContext(app, fs, nil)
+	if err := act.Config(ctx, c); err != nil {
+		t.Errorf("Error: %s", err)
+	}
+	want = `autoimport: true`
+	sv = strings.TrimSpace(buf.String())
+	if sv != want {
+		t.Errorf("Wrong config result: '%s' != '%s'", sv, want)
+	}
+	buf.Reset()
+
+	// config autoimport false
+	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	if err := fs.Parse([]string{"autoimport", "false"}); err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+	c = cli.NewContext(app, fs, nil)
+	if err := act.Config(ctx, c); err != nil {
+		t.Errorf("Error: %s", err)
+	}
+	want = `autoimport: false`
+	sv = strings.TrimSpace(buf.String())
+	if sv != want {
+		t.Errorf("Wrong config result: '%s' != '%s'", sv, want)
+	}
+	buf.Reset()
+
 }

action/copy_test.go

@@ -27,20 +27,43 @@ func TestCopy(t *testing.T) {
 		t.Fatalf("Error: %s", err)
 	}
 
+	buf := &bytes.Buffer{}
+	out.Stdout = buf
+	defer func() {
+		out.Stdout = os.Stdout
+	}()
+
 	app := cli.NewApp()
+	// copy foo bar
 	fs := flag.NewFlagSet("default", flag.ContinueOnError)
 	if err := fs.Parse([]string{"foo", "bar"}); err != nil {
 		t.Fatalf("Error: %s", err)
 	}
 	c := cli.NewContext(app, fs, nil)
 
-	buf := &bytes.Buffer{}
-	out.Stdout = buf
-	defer func() {
-		out.Stdout = os.Stdout
-	}()
-
 	if err := act.Copy(ctx, c); err != nil {
 		t.Errorf("Error: %s", err)
 	}
+	buf.Reset()
+
+	// copy not-found still-not-there
+	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	if err := fs.Parse([]string{"not-found", "still-not-there"}); err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+	c = cli.NewContext(app, fs, nil)
+
+	if err := act.Copy(ctx, c); err == nil {
+		t.Errorf("Should fail")
+	}
+	buf.Reset()
+
+	// copy
+	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	c = cli.NewContext(app, fs, nil)
+
+	if err := act.Copy(ctx, c); err == nil {
+		t.Errorf("Should fail")
+	}
+	buf.Reset()
 }

action/create_test.go

@@ -1,9 +1,21 @@
 package action
 
-import "testing"
+import (
+	"bytes"
+	"context"
+	"flag"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/justwatchcom/gopass/utils/ctxutil"
+	"github.com/justwatchcom/gopass/utils/out"
+	"github.com/urfave/cli"
+)
 
 func TestExtractHostname(t *testing.T) {
 	for in, out := range map[string]string{
+		"": "",
 		"http://www.example.org/":              "www.example.org",
 		"++#+++#jhlkadsrezu 33 553q ++++##$§&": "jhlkadsrezu_33_553q",
 		"www.example.org/?foo=bar#abc":         "www.example.org",
@@ -13,3 +25,36 @@ func TestExtractHostname(t *testing.T) {
 		}
 	}
 }
+
+func TestCreate(t *testing.T) {
+	td, err := ioutil.TempDir("", "gopass-")
+	if err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+	defer func() {
+		_ = os.RemoveAll(td)
+	}()
+
+	ctx := context.Background()
+	ctx = ctxutil.WithAlwaysYes(ctx, true)
+	act, err := newMock(ctx, td)
+	if err != nil {
+		t.Fatalf("Error: %s", err)
+	}
+
+	buf := &bytes.Buffer{}
+	out.Stdout = buf
+	defer func() {
+		out.Stdout = os.Stdout
+	}()
+
+	app := cli.NewApp()
+	// create
+	fs := flag.NewFlagSet("default", flag.ContinueOnError)
+	c := cli.NewContext(app, fs, nil)
+
+	if err := act.Create(ctx, c); err == nil {
+		t.Errorf("Should fail")
+	}
+	buf.Reset()
+}