From 9c690c0a8c1715a07f2b0673c7d1feb5ac22fd17 Mon Sep 17 00:00:00 2001
From: Dominik Schulz <dominik.schulz@gmail.com>
Date: Wed, 28 Mar 2018 12:06:58 +0200
Subject: [PATCH] Improve test coverage (#732)

---
 main.go                           |  8 +++--
 main_test.go                      | 11 ++++++
 pkg/action/audit_test.go          |  7 ++++
 pkg/action/copy_test.go           |  9 +++++
 pkg/action/create/create_test.go  |  4 +--
 pkg/action/edit_test.go           | 47 +++++++++++++++++++++++++
 pkg/action/fsck_test.go           | 51 +++++++++++++++++++++++++++
 pkg/action/generate_test.go       | 11 ++++--
 pkg/action/history_test.go        | 14 +++++++-
 pkg/action/insert_test.go         | 14 +++++++-
 pkg/action/mount_test.go          | 15 ++++++++
 pkg/action/otp_test.go            |  4 +++
 pkg/action/templates_test.go      |  6 ++++
 pkg/backend/context_test.go       |  1 +
 pkg/config/secrets/config_test.go | 29 ++++++++++++++++
 pkg/cui/cui.go                    |  7 ++--
 pkg/cui/recipients_test.go        |  7 ++++
 pkg/hibp/dump/scanner.go          |  2 +-
 pkg/hibp/dump/scanner_test.go     | 26 +++++++++++---
 pkg/store/root/fsck_test.go       | 25 +++++++++++++
 pkg/store/sub/fsck_test.go        | 58 +++++++++++++++++++++++++++++++
 pkg/termio/ask.go                 |  2 +-
 tests/generate_test.go            |  2 +-
 23 files changed, 341 insertions(+), 19 deletions(-)
 create mode 100644 pkg/action/edit_test.go
 create mode 100644 pkg/action/fsck_test.go
 create mode 100644 pkg/store/root/fsck_test.go
 create mode 100644 pkg/store/sub/fsck_test.go

diff --git a/main.go b/main.go
index 14ee67995d..695b543fa3 100644
--- a/main.go
+++ b/main.go
@@ -57,7 +57,7 @@ func main() {
 		out: colorable.NewColorableStderr(),
 	}
 	sv := getVersion()
-	cli.VersionPrinter = makeVersionPrinter(sv)
+	cli.VersionPrinter = makeVersionPrinter(os.Stdout, sv)
 
 	app := setupApp(ctx, sv)
 	if err := app.Run(os.Args); err != nil {
@@ -65,7 +65,7 @@ func main() {
 	}
 }
 
-func makeVersionPrinter(sv semver.Version) func(c *cli.Context) {
+func makeVersionPrinter(out io.Writer, sv semver.Version) func(c *cli.Context) {
 	return func(c *cli.Context) {
 		buildtime := ""
 		if bt, err := time.Parse("2006-01-02T15:04:05-0700", date); err == nil {
@@ -84,7 +84,9 @@ func makeVersionPrinter(sv semver.Version) func(c *cli.Context) {
 		if buildInfo != "" {
 			buildInfo = "(" + buildInfo + ") "
 		}
-		fmt.Printf("%s %s %s%s %s %s\n",
+		fmt.Fprintf(
+			out,
+			"%s %s %s%s %s %s\n",
 			name,
 			sv.String(),
 			buildInfo,
diff --git a/main_test.go b/main_test.go
index 6767557908..827bef2d5d 100644
--- a/main_test.go
+++ b/main_test.go
@@ -1,10 +1,14 @@
 package main
 
 import (
+	"bytes"
 	"context"
 	"flag"
+	"fmt"
+	"runtime"
 	"testing"
 
+	"github.com/blang/semver"
 	"github.com/justwatchcom/gopass/pkg/ctxutil"
 	"github.com/stretchr/testify/assert"
 	"github.com/urfave/cli"
@@ -25,3 +29,10 @@ func TestGlobalFlags(t *testing.T) {
 
 	assert.Equal(t, true, ctxutil.IsAlwaysYes(withGlobalFlags(ctx, c)))
 }
+
+func TestVersionPrinter(t *testing.T) {
+	buf := &bytes.Buffer{}
+	vp := makeVersionPrinter(buf, semver.Version{Major: 1})
+	vp(nil)
+	assert.Equal(t, fmt.Sprintf("gopass 1.0.0 %s %s %s\n", runtime.Version(), runtime.GOOS, runtime.GOARCH), buf.String())
+}
diff --git a/pkg/action/audit_test.go b/pkg/action/audit_test.go
index 9cdf332354..c7a502e82e 100644
--- a/pkg/action/audit_test.go
+++ b/pkg/action/audit_test.go
@@ -42,4 +42,11 @@ func TestAudit(t *testing.T) {
 
 	assert.Error(t, act.Audit(ctx, c))
 	buf.Reset()
+
+	// test with filter
+	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	assert.NoError(t, fs.Parse([]string{"foo"}))
+	c = cli.NewContext(app, fs, nil)
+	assert.Error(t, act.Audit(ctx, c))
+	buf.Reset()
 }
diff --git a/pkg/action/copy_test.go b/pkg/action/copy_test.go
index bfd3c7a635..5f05700a97 100644
--- a/pkg/action/copy_test.go
+++ b/pkg/action/copy_test.go
@@ -32,6 +32,7 @@ func TestCopy(t *testing.T) {
 	}()
 
 	app := cli.NewApp()
+
 	// copy foo bar
 	fs := flag.NewFlagSet("default", flag.ContinueOnError)
 	assert.NoError(t, fs.Parse([]string{"foo", "bar"}))
@@ -40,6 +41,14 @@ func TestCopy(t *testing.T) {
 	assert.NoError(t, act.Copy(ctx, c))
 	buf.Reset()
 
+	// copy foo bar (again, should fail)
+	{
+		ctx := ctxutil.WithAlwaysYes(ctx, false)
+		ctx = ctxutil.WithInteractive(ctx, false)
+		assert.Error(t, act.Copy(ctx, c))
+		buf.Reset()
+	}
+
 	// copy not-found still-not-there
 	fs = flag.NewFlagSet("default", flag.ContinueOnError)
 	assert.NoError(t, fs.Parse([]string{"not-found", "still-not-there"}))
diff --git a/pkg/action/create/create_test.go b/pkg/action/create/create_test.go
index a65b3639d3..70d5a927ae 100644
--- a/pkg/action/create/create_test.go
+++ b/pkg/action/create/create_test.go
@@ -56,7 +56,7 @@ func TestCreateWebsite(t *testing.T) {
 	s := creator{mockstore.New("")}
 
 	ctx := context.Background()
-	ctx = ctxutil.WithInteractive(ctx, false)
+	ctx = ctxutil.WithInteractive(ctx, true)
 
 	buf := &bytes.Buffer{}
 	out.Stdout = buf
@@ -107,7 +107,7 @@ func TestCreatePIN(t *testing.T) {
 	s := creator{mockstore.New("")}
 
 	ctx := context.Background()
-	ctx = ctxutil.WithInteractive(ctx, false)
+	ctx = ctxutil.WithInteractive(ctx, true)
 
 	buf := &bytes.Buffer{}
 	out.Stdout = buf
diff --git a/pkg/action/edit_test.go b/pkg/action/edit_test.go
new file mode 100644
index 0000000000..2dbb91ad83
--- /dev/null
+++ b/pkg/action/edit_test.go
@@ -0,0 +1,47 @@
+package action
+
+import (
+	"bytes"
+	"context"
+	"flag"
+	"os"
+	"testing"
+
+	"github.com/justwatchcom/gopass/pkg/ctxutil"
+	"github.com/justwatchcom/gopass/pkg/out"
+	"github.com/justwatchcom/gopass/tests/gptest"
+	"github.com/stretchr/testify/assert"
+	"github.com/urfave/cli"
+)
+
+func TestEdit(t *testing.T) {
+	u := gptest.NewUnitTester(t)
+	defer u.Remove()
+
+	ctx := context.Background()
+	ctx = ctxutil.WithAlwaysYes(ctx, true)
+	ctx = ctxutil.WithTerminal(ctx, false)
+	act, err := newMock(ctx, u)
+	assert.NoError(t, err)
+
+	buf := &bytes.Buffer{}
+	out.Stdout = buf
+	defer func() {
+		out.Stdout = os.Stdout
+	}()
+
+	app := cli.NewApp()
+
+	// edit
+	c := cli.NewContext(app, flag.NewFlagSet("default", flag.ContinueOnError), nil)
+	assert.Error(t, act.Edit(ctx, c))
+	buf.Reset()
+
+	// edit foo
+	fs := flag.NewFlagSet("default", flag.ContinueOnError)
+	assert.NoError(t, fs.Parse([]string{"foo"}))
+	c = cli.NewContext(app, fs, nil)
+
+	assert.Error(t, act.Edit(ctx, c))
+	buf.Reset()
+}
diff --git a/pkg/action/fsck_test.go b/pkg/action/fsck_test.go
new file mode 100644
index 0000000000..4f3af97a05
--- /dev/null
+++ b/pkg/action/fsck_test.go
@@ -0,0 +1,51 @@
+package action
+
+import (
+	"bytes"
+	"context"
+	"flag"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/fatih/color"
+	"github.com/justwatchcom/gopass/pkg/ctxutil"
+	"github.com/justwatchcom/gopass/pkg/out"
+	"github.com/justwatchcom/gopass/tests/gptest"
+	"github.com/stretchr/testify/assert"
+	"github.com/urfave/cli"
+)
+
+func TestFsck(t *testing.T) {
+	u := gptest.NewUnitTester(t)
+	defer u.Remove()
+
+	ctx := context.Background()
+	ctx = ctxutil.WithTerminal(ctx, false)
+	act, err := newMock(ctx, u)
+	assert.NoError(t, err)
+
+	buf := &bytes.Buffer{}
+	out.Stdout = buf
+	stdout = buf
+	defer func() {
+		stdout = os.Stdout
+		out.Stdout = os.Stdout
+	}()
+	color.NoColor = true
+
+	app := cli.NewApp()
+
+	// fsck
+	c := cli.NewContext(app, flag.NewFlagSet("default", flag.ContinueOnError), nil)
+	assert.NoError(t, act.Fsck(ctx, c))
+
+	// fsck fo
+	fs := flag.NewFlagSet("default", flag.ContinueOnError)
+	assert.NoError(t, fs.Parse([]string{"fo"}))
+	c = cli.NewContext(app, fs, nil)
+
+	assert.NoError(t, act.Fsck(ctx, c))
+	assert.Equal(t, "Extra recipients on foo: [0xFEEDBEEF]\nPushed changes to git remote\nExtra recipients on foo: [0xFEEDBEEF]\nPushed changes to git remote", strings.TrimSpace(buf.String()))
+	buf.Reset()
+}
diff --git a/pkg/action/generate_test.go b/pkg/action/generate_test.go
index 8308b688ff..e570d51de3 100644
--- a/pkg/action/generate_test.go
+++ b/pkg/action/generate_test.go
@@ -32,11 +32,18 @@ func TestGenerate(t *testing.T) {
 
 	app := cli.NewApp()
 
-	// generate foobar
+	// generate
 	fs := flag.NewFlagSet("default", flag.ContinueOnError)
-	assert.NoError(t, fs.Parse([]string{"foobar"}))
 	c := cli.NewContext(app, fs, nil)
 
+	assert.Error(t, act.Generate(ctx, c))
+	buf.Reset()
+
+	// generate foobar
+	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	assert.NoError(t, fs.Parse([]string{"foobar"}))
+	c = cli.NewContext(app, fs, nil)
+
 	assert.NoError(t, act.Generate(ctx, c))
 	buf.Reset()
 
diff --git a/pkg/action/history_test.go b/pkg/action/history_test.go
index 231f903446..9747a8cff1 100644
--- a/pkg/action/history_test.go
+++ b/pkg/action/history_test.go
@@ -22,7 +22,6 @@ func TestHistory(t *testing.T) {
 	defer u.Remove()
 
 	ctx := context.Background()
-	ctx = ctxutil.WithDebug(ctx, true)
 	ctx = ctxutil.WithAlwaysYes(ctx, true)
 	ctx = backend.WithRCSBackend(ctx, backend.GitCLI)
 	ctx = backend.WithCryptoBackend(ctx, backend.Plain)
@@ -60,4 +59,17 @@ func TestHistory(t *testing.T) {
 
 	assert.NoError(t, act.History(ctx, c))
 	buf.Reset()
+
+	// history --password bar
+	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	sf := cli.StringFlag{
+		Name:  "password",
+		Usage: "password",
+	}
+	assert.NoError(t, sf.ApplyWithError(fs))
+	assert.NoError(t, fs.Parse([]string{"--password=true", "bar"}))
+	c = cli.NewContext(app, fs, nil)
+
+	assert.NoError(t, act.History(ctx, c))
+	buf.Reset()
 }
diff --git a/pkg/action/insert_test.go b/pkg/action/insert_test.go
index dc69c40bbd..b9bc5bab83 100644
--- a/pkg/action/insert_test.go
+++ b/pkg/action/insert_test.go
@@ -21,6 +21,7 @@ func TestInsert(t *testing.T) {
 
 	ctx := context.Background()
 	ctx = ctxutil.WithAlwaysYes(ctx, true)
+	ctx = ctxutil.WithTerminal(ctx, false)
 	act, err := newMock(ctx, u)
 	assert.NoError(t, err)
 
@@ -52,10 +53,21 @@ func TestInsert(t *testing.T) {
 	buf.Reset()
 
 	assert.NoError(t, act.show(ctx, c, "baz", "", false))
-	assert.Equal(t, "foobar\n", buf.String())
+	assert.Equal(t, "foobar", buf.String())
 	buf.Reset()
 
 	// insert zab#key
 	assert.NoError(t, act.insertYAML(ctx, "zab", "key", []byte("foobar")))
 
+	// insert --multiline foo
+	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	bf := cli.BoolFlag{
+		Name:  "multiline",
+		Usage: "multiline",
+	}
+	assert.NoError(t, bf.ApplyWithError(fs))
+	assert.NoError(t, fs.Parse([]string{"--multiline=true", "bar", "baz"}))
+	c = cli.NewContext(app, fs, nil)
+
+	assert.NoError(t, act.Insert(ctx, c))
 }
diff --git a/pkg/action/mount_test.go b/pkg/action/mount_test.go
index 2b2a9e19f6..caa2dab9f6 100644
--- a/pkg/action/mount_test.go
+++ b/pkg/action/mount_test.go
@@ -26,8 +26,10 @@ func TestMounts(t *testing.T) {
 
 	buf := &bytes.Buffer{}
 	out.Stdout = buf
+	stdout = buf
 	defer func() {
 		out.Stdout = os.Stdout
+		stdout = os.Stdout
 	}()
 
 	app := cli.NewApp()
@@ -68,4 +70,17 @@ func TestMounts(t *testing.T) {
 
 	assert.Error(t, act.MountAdd(ctx, c))
 	buf.Reset()
+
+	// add some mounts
+	assert.NoError(t, u.InitStore("mount1"))
+	assert.NoError(t, u.InitStore("mount2"))
+	assert.NoError(t, act.Store.AddMount(ctx, "mount1", u.StoreDir("mount1")))
+	assert.NoError(t, act.Store.AddMount(ctx, "mount2", u.StoreDir("mount2")))
+
+	// print mounts
+	fs = flag.NewFlagSet("default", flag.ContinueOnError)
+	c = cli.NewContext(app, fs, nil)
+
+	assert.NoError(t, act.MountsPrint(ctx, c))
+	buf.Reset()
 }
diff --git a/pkg/action/otp_test.go b/pkg/action/otp_test.go
index d33f104ac6..f9e1c24d26 100644
--- a/pkg/action/otp_test.go
+++ b/pkg/action/otp_test.go
@@ -52,6 +52,10 @@ func TestOTP(t *testing.T) {
 	assert.NoError(t, act.OTP(ctx, c))
 	buf.Reset()
 
+	// copy to clipboard
+	assert.NoError(t, act.otp(ctx, "bar", "", true))
+	buf.Reset()
+
 	// write QR file
 	fs = flag.NewFlagSet("default", flag.ContinueOnError)
 	sf := cli.StringFlag{
diff --git a/pkg/action/templates_test.go b/pkg/action/templates_test.go
index f00505d893..7fd082d755 100644
--- a/pkg/action/templates_test.go
+++ b/pkg/action/templates_test.go
@@ -21,6 +21,7 @@ func TestTemplates(t *testing.T) {
 
 	ctx := context.Background()
 	ctx = ctxutil.WithAlwaysYes(ctx, true)
+	ctx = ctxutil.WithTerminal(ctx, false)
 	act, err := newMock(ctx, u)
 	assert.NoError(t, err)
 
@@ -63,6 +64,11 @@ gopass
 	// print template
 	assert.NoError(t, act.TemplatePrint(ctx, c))
 	assert.Equal(t, "foobar\n", buf.String())
+	buf.Reset()
+
+	// edit template
+	assert.Error(t, act.TemplateEdit(ctx, c))
+	buf.Reset()
 
 	// remove template
 	assert.NoError(t, act.TemplateRemove(ctx, c))
diff --git a/pkg/backend/context_test.go b/pkg/backend/context_test.go
index 875deddd69..a5f1e47d4b 100644
--- a/pkg/backend/context_test.go
+++ b/pkg/backend/context_test.go
@@ -24,6 +24,7 @@ func TestRCSBackend(t *testing.T) {
 	assert.Equal(t, Noop, GetRCSBackend(ctx))
 	assert.Equal(t, GitCLI, GetRCSBackend(WithRCSBackendString(ctx, "gitcli")))
 	assert.Equal(t, GitCLI, GetRCSBackend(WithRCSBackend(ctx, GitCLI)))
+	assert.Equal(t, Noop, GetRCSBackend(WithRCSBackendString(ctx, "foobar")))
 	assert.Equal(t, true, HasRCSBackend(WithRCSBackend(ctx, GitCLI)))
 }
 
diff --git a/pkg/config/secrets/config_test.go b/pkg/config/secrets/config_test.go
index e5feeaea50..8f8cff86f9 100644
--- a/pkg/config/secrets/config_test.go
+++ b/pkg/config/secrets/config_test.go
@@ -27,3 +27,32 @@ func TestSaveLoad(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, d, data)
 }
+
+func TestNew(t *testing.T) {
+	tempdir, err := ioutil.TempDir("", "gopass-")
+	assert.NoError(t, err)
+	defer func() {
+		_ = os.RemoveAll(tempdir)
+	}()
+	pass := "foobar"
+
+	cfg, err := New(tempdir, pass)
+	assert.NoError(t, err)
+
+	v, err := cfg.Get("foo")
+	assert.NoError(t, err)
+	assert.Equal(t, "", v)
+
+	assert.NoError(t, cfg.Set("foo", "bar"))
+
+	v, err = cfg.Get("foo")
+	assert.NoError(t, err)
+	assert.Equal(t, "bar", v)
+
+	cfg, err = New(tempdir, pass)
+	assert.NoError(t, err)
+
+	v, err = cfg.Get("foo")
+	assert.NoError(t, err)
+	assert.Equal(t, "bar", v)
+}
diff --git a/pkg/cui/cui.go b/pkg/cui/cui.go
index 3ae0b91849..51fe1f4206 100644
--- a/pkg/cui/cui.go
+++ b/pkg/cui/cui.go
@@ -3,6 +3,7 @@ package cui
 import (
 	"context"
 	"fmt"
+	"io"
 	"os"
 	"runtime"
 
@@ -65,18 +66,18 @@ func (s *selection) layout(g *gocui.Gui) error {
 	return nil
 }
 
-func (s *selection) renderHeader(v *gocui.View, maxx int) {
+func (s *selection) renderHeader(v io.Writer, maxx int) {
 	fmt.Fprintf(v, "%s\n", color.GreenString("gopass"))
 	fmt.Fprintf(v, s.prompt)
 }
 
-func (s *selection) render(v *gocui.View, maxx int) {
+func (s *selection) render(v io.Writer, maxx int) {
 	for _, item := range s.choices {
 		fmt.Fprintf(v, "%s\n", item)
 	}
 }
 
-func (s *selection) renderFooter(v *gocui.View, maxx int) {
+func (s *selection) renderFooter(v io.Writer, maxx int) {
 	fmt.Fprintf(v, "\u001b[1m%s\u001b[0m\n", s.usage)
 }
 
diff --git a/pkg/cui/recipients_test.go b/pkg/cui/recipients_test.go
index cf6bf02486..bc449dc51f 100644
--- a/pkg/cui/recipients_test.go
+++ b/pkg/cui/recipients_test.go
@@ -14,6 +14,7 @@ import (
 
 func TestConfirmRecipients(t *testing.T) {
 	ctx := context.Background()
+	ctx = ctxutil.WithTerminal(ctx, false)
 
 	buf := &bytes.Buffer{}
 	Stdout = buf
@@ -34,6 +35,12 @@ func TestConfirmRecipients(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, in, got)
 	buf.Reset()
+
+	// IsEditRecipients true
+	in = []string{"foo", "bar"}
+	_, err = ConfirmRecipients(ctxutil.WithEditRecipients(ctx, true), plain.New(), "test", in)
+	assert.Error(t, err)
+	buf.Reset()
 }
 
 func TestAskForPrivateKey(t *testing.T) {
diff --git a/pkg/hibp/dump/scanner.go b/pkg/hibp/dump/scanner.go
index 5bbf28419a..6b9b421a8d 100644
--- a/pkg/hibp/dump/scanner.go
+++ b/pkg/hibp/dump/scanner.go
@@ -125,7 +125,7 @@ func isSorted(fn string) bool {
 		}
 		lastLine = line
 	}
-	return false
+	return true
 }
 
 func (s *Scanner) scanSortedFile(ctx context.Context, fn string, in []string, results chan string) {
diff --git a/pkg/hibp/dump/scanner_test.go b/pkg/hibp/dump/scanner_test.go
index 5526f5749f..5820919940 100644
--- a/pkg/hibp/dump/scanner_test.go
+++ b/pkg/hibp/dump/scanner_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-const testHibpSample = `000000005AD76BD555C1D6D771DE417A4B87E4B4
+const testHibpSampleSorted = `000000005AD76BD555C1D6D771DE417A4B87E4B4
 00000000A8DAE4228F821FB418F59826079BF368:42
 00000000DD7F2A1C68A35673713783CA390C9E93:42
 00000001E225B908BAC31C56DB04D892E47536E0:42
@@ -21,6 +21,16 @@ const testHibpSample = `000000005AD76BD555C1D6D771DE417A4B87E4B4
 0000000CAEF405439D57847A8657218C618160B2:42
 0000000FC1C08E6454BED24F463EA2129E254D43:42
 00000010F4B38525354491E099EB1796278544B1`
+const testHibpSampleUnsorted = `000000005AD76BD555C1D6D771DE417A4B87E4B4
+00000000A8DAE4228F821FB418F59826079BF368:42
+00000008CD1806EB7B9B46A8F87690B2AC16F617:42
+0000000A0E3B9F25FF41DE4B5AC238C2D545C7A8:42
+0000000A1D4B746FAA3FD526FF6D5BC8052FDB38:42
+0000000CAEF405439D57847A8657218C618160B2:42
+0000000FC1C08E6454BED24F463EA2129E254D43:42
+00000000DD7F2A1C68A35673713783CA390C9E93:42
+00000001E225B908BAC31C56DB04D892E47536E0:42
+00000010F4B38525354491E099EB1796278544B1`
 
 func TestScanner(t *testing.T) {
 	td, err := ioutil.TempDir("", "gopass-")
@@ -36,17 +46,25 @@ func TestScanner(t *testing.T) {
 	_, err = New()
 	assert.Error(t, err)
 
-	// setup file and env
+	// setup file and env (sorted)
 	fn := filepath.Join(td, "dump.txt")
-	assert.NoError(t, ioutil.WriteFile(fn, []byte(testHibpSample), 0644))
+	assert.NoError(t, ioutil.WriteFile(fn, []byte(testHibpSampleSorted), 0644))
 
 	scanner, err := New(fn)
 	assert.NoError(t, err)
 	assert.Equal(t, []string{}, scanner.LookupBatch(ctx, []string{"foobar"}))
 
+	// setup file and env (unsorted)
+	fn = filepath.Join(td, "dump.txt")
+	assert.NoError(t, ioutil.WriteFile(fn, []byte(testHibpSampleUnsorted), 0644))
+
+	scanner, err = New(fn)
+	assert.NoError(t, err)
+	assert.Equal(t, []string{}, scanner.LookupBatch(ctx, []string{"foobar"}))
+
 	// gzip
 	fn = filepath.Join(td, "dump.txt.gz")
-	assert.NoError(t, testWriteGZ(fn, []byte(testHibpSample)))
+	assert.NoError(t, testWriteGZ(fn, []byte(testHibpSampleSorted)))
 
 	scanner, err = New(fn)
 	assert.NoError(t, err)
diff --git a/pkg/store/root/fsck_test.go b/pkg/store/root/fsck_test.go
new file mode 100644
index 0000000000..955051791c
--- /dev/null
+++ b/pkg/store/root/fsck_test.go
@@ -0,0 +1,25 @@
+package root
+
+import (
+	"context"
+	"testing"
+
+	"github.com/justwatchcom/gopass/pkg/ctxutil"
+	"github.com/justwatchcom/gopass/pkg/out"
+	"github.com/justwatchcom/gopass/tests/gptest"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFsck(t *testing.T) {
+	u := gptest.NewUnitTester(t)
+	defer u.Remove()
+
+	ctx := context.Background()
+	ctx = ctxutil.WithAlwaysYes(ctx, true)
+	ctx = out.WithHidden(ctx, true)
+
+	rs, err := createRootStore(ctx, u)
+	assert.NoError(t, err)
+
+	assert.NoError(t, rs.Fsck(ctx, ""))
+}
diff --git a/pkg/store/sub/fsck_test.go b/pkg/store/sub/fsck_test.go
new file mode 100644
index 0000000000..f043ccba13
--- /dev/null
+++ b/pkg/store/sub/fsck_test.go
@@ -0,0 +1,58 @@
+package sub
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/justwatchcom/gopass/pkg/backend"
+	"github.com/justwatchcom/gopass/pkg/backend/crypto/plain"
+	"github.com/justwatchcom/gopass/pkg/backend/rcs/noop"
+	"github.com/justwatchcom/gopass/pkg/backend/storage/fs"
+	"github.com/justwatchcom/gopass/pkg/out"
+	"github.com/justwatchcom/gopass/pkg/store/secret"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFsck(t *testing.T) {
+	ctx := context.Background()
+
+	obuf := &bytes.Buffer{}
+	out.Stdout = obuf
+	defer func() {
+		out.Stdout = os.Stdout
+	}()
+
+	// common setup
+	tempdir, err := ioutil.TempDir("", "gopass-")
+	assert.NoError(t, err)
+
+	s := &Store{
+		alias:   "",
+		url:     backend.FromPath(tempdir),
+		crypto:  plain.New(),
+		rcs:     noop.New(),
+		storage: fs.New(tempdir),
+	}
+	assert.NoError(t, s.saveRecipients(ctx, []string{"john.doe"}, "test", false))
+
+	for _, e := range []string{"foo/bar", "foo/baz", "foo/zab"} {
+		assert.NoError(t, s.Set(ctx, e, secret.New("bar", "")))
+	}
+
+	assert.NoError(t, s.Fsck(ctx, ""))
+	obuf.Reset()
+
+	// common tear down
+	_ = os.RemoveAll(tempdir)
+}
+func TestCompareStringSlices(t *testing.T) {
+	want := []string{"foo", "bar"}
+	have := []string{"baz", "bar"}
+
+	missing, extra := compareStringSlices(want, have)
+	assert.Equal(t, []string{"foo"}, missing)
+	assert.Equal(t, []string{"baz"}, extra)
+}
diff --git a/pkg/termio/ask.go b/pkg/termio/ask.go
index a72a0f56e6..92f528b9c5 100644
--- a/pkg/termio/ask.go
+++ b/pkg/termio/ask.go
@@ -27,7 +27,7 @@ const (
 // AskForString asks for a string once, using the default if the
 // anser is empty. Errors are only returned on I/O errors
 func AskForString(ctx context.Context, text, def string) (string, error) {
-	if ctxutil.IsAlwaysYes(ctx) {
+	if ctxutil.IsAlwaysYes(ctx) || !ctxutil.IsInteractive(ctx) {
 		return def, nil
 	}
 
diff --git a/tests/generate_test.go b/tests/generate_test.go
index 6e73092ff8..ec8d93d6c3 100644
--- a/tests/generate_test.go
+++ b/tests/generate_test.go
@@ -16,7 +16,7 @@ func TestGenerate(t *testing.T) {
 
 	out, err := ts.run("generate")
 	assert.Error(t, err)
-	assert.Equal(t, "Which name do you want to use? []: \nError: please provide a password name\n", out)
+	assert.Equal(t, "\nError: please provide a password name\n", out)
 
 	out, err = ts.run("generate foo 0")
 	assert.Error(t, err)