match Get() API in libsecret and keychain, and add tests

.gitignore

@@ -0,0 +1 @@
+.vagrant

array.go

@@ -48,3 +48,7 @@ func (k *ArrayKeyring) Keys() ([]string, error) {
 	}
 	return keys, nil
 }
+
+func (k *ArrayKeyring) GetMetadata(_ string) (Metadata, error) {
+	return Metadata{}, ErrMetadataNeedsCredentials
+}

keychain.go

@@ -193,6 +193,9 @@ func (k *keychain) Remove(key string) error {
 		kc := gokeychain.NewWithPath(k.path)
 
 		if err := kc.Status(); err != nil {
+			if err == gokeychain.ErrorNoSuchKeychain {
+				return ErrKeyNotFound
+			}
 			return err
 		}
 
@@ -214,6 +217,9 @@ func (k *keychain) Keys() ([]string, error) {
 		kc := gokeychain.NewWithPath(k.path)
 
 		if err := kc.Status(); err != nil {
+			if err == gokeychain.ErrorNoSuchKeychain {
+				return []string{}, nil
+			}
 			return nil, err
 		}
 

keychain_test.go

@@ -103,7 +103,27 @@ func TestOSXKeychainKeyringOverwrite(t *testing.T) {
 	}
 }
 
-func TestOSXKeychainKeyringListKeys(t *testing.T) {
+func TestOSXKeychainKeyringListKeysWhenEmpty(t *testing.T) {
+	path := tempPath()
+	defer deleteKeychain(path, t)
+
+	k := &keychain{
+		path:         path,
+		service:      "test",
+		passwordFunc: fixedStringPrompt("test password"),
+		isTrusted:    true,
+	}
+
+	keys, err := k.Keys()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(keys) != 0 {
+		t.Fatalf("Expected 0 keys, got %d", len(keys))
+	}
+}
+
+func TestOSXKeychainKeyringListKeysWhenNotEmpty(t *testing.T) {
 	path := tempPath()
 	defer deleteKeychain(path, t)
 
@@ -149,6 +169,102 @@ func deleteKeychain(path string, t *testing.T) {
 	}
 }
 
+func TestOSXKeychainGetKeyWhenEmpty(t *testing.T) {
+	path := tempPath()
+	defer deleteKeychain(path, t)
+
+	k := &keychain{
+		path:         path,
+		passwordFunc: fixedStringPrompt("test password"),
+		service:      "test",
+		isTrusted:    true,
+	}
+
+	_, err := k.Get("no-such-key")
+	if err != ErrKeyNotFound {
+		t.Fatal("expected ErrKeyNotFound")
+	}
+}
+
+func TestOSXKeychainGetKeyWhenNotEmpty(t *testing.T) {
+	path := tempPath()
+	defer deleteKeychain(path, t)
+
+	k := &keychain{
+		path:         path,
+		passwordFunc: fixedStringPrompt("test password"),
+		service:      "test",
+		isTrusted:    true,
+	}
+	item := Item{
+		Key:         "llamas",
+		Label:       "Arbitrary label",
+		Description: "A freetext description",
+		Data:        []byte("llamas are ok"),
+	}
+
+	if err := k.Set(item); err != nil {
+		t.Fatal(err)
+	}
+
+	v1, err := k.Get("llamas")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(v1.Data) != string(item.Data) {
+		t.Fatalf("Data stored was not the data retrieved: %q vs %q", v1.Data, item.Data)
+	}
+}
+
+func TestOSXKeychainRemoveKeyWhenEmpty(t *testing.T) {
+	path := tempPath()
+	defer deleteKeychain(path, t)
+
+	k := &keychain{
+		path:         path,
+		passwordFunc: fixedStringPrompt("test password"),
+		service:      "test",
+		isTrusted:    true,
+	}
+
+	err := k.Remove("no-such-key")
+	if err != ErrKeyNotFound {
+		t.Fatalf("expected ErrKeyNotFound, got: %v", err)
+	}
+}
+
+func TestOSXKeychainRemoveKeyWhenNotEmpty(t *testing.T) {
+	path := tempPath()
+	defer deleteKeychain(path, t)
+
+	k := &keychain{
+		path:         path,
+		passwordFunc: fixedStringPrompt("test password"),
+		service:      "test",
+		isTrusted:    true,
+	}
+	item := Item{
+		Key:         "llamas",
+		Label:       "Arbitrary label",
+		Description: "A freetext description",
+		Data:        []byte("llamas are ok"),
+	}
+
+	if err := k.Set(item); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := k.Get("llamas")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = k.Remove("llamas")
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
 func tempPath() string {
 	// TODO make filename configurable
 	return filepath.Join(os.TempDir(), fmt.Sprintf("keyring-test-%d.keychain", time.Now().UnixNano()))

libsecret.go

@@ -4,7 +4,7 @@ package keyring
 
 import (
 	"encoding/json"
-	"fmt"
+	"errors"
 
 	"github.com/godbus/dbus"
 	"github.com/gsterjov/go-libsecret"
@@ -54,6 +54,8 @@ func (e *secretsError) Error() string {
 	return e.message
 }
 
+var errCollectionNotFound = errors.New("The collection does not exist. Please add a key first")
+
 func (k *secretsKeyring) openSecrets() error {
 	session, err := k.service.Open()
 	if err != nil {
@@ -85,17 +87,21 @@ func (k *secretsKeyring) openCollection() error {
 	}
 
 	if k.collection == nil {
-		return &secretsError{fmt.Sprintf(
-			"The collection %q does not exist. Please add a key first",
-			k.name,
-		)}
+		return errCollectionNotFound
+		// return &secretsError{fmt.Sprintf(
+		// 	"The collection %q does not exist. Please add a key first",
+		// 	k.name,
+		// )}
 	}
 
 	return nil
 }
 
 func (k *secretsKeyring) Get(key string) (Item, error) {
 	if err := k.openCollection(); err != nil {
+		if err == errCollectionNotFound {
+			return Item{}, ErrKeyNotFound
+		}
 		return Item{}, err
 	}
 
@@ -105,7 +111,7 @@ func (k *secretsKeyring) Get(key string) (Item, error) {
 	}
 
 	if len(items) == 0 {
-		return Item{}, err
+		return Item{}, ErrKeyNotFound
 	}
 
 	// use the first item whenever there are multiples
@@ -193,8 +199,10 @@ func (k *secretsKeyring) Set(item Item) error {
 }
 
 func (k *secretsKeyring) Remove(key string) error {
-	err := k.openCollection()
-	if err != nil {
+	if err := k.openCollection(); err != nil {
+		if err == errCollectionNotFound {
+			return ErrKeyNotFound
+		}
 		return err
 	}
 
@@ -231,8 +239,10 @@ func (k *secretsKeyring) Remove(key string) error {
 }
 
 func (k *secretsKeyring) Keys() ([]string, error) {
-	err := k.openCollection()
-	if err != nil {
+	if err := k.openCollection(); err != nil {
+		if err == errCollectionNotFound {
+			return []string{}, nil
+		}
 		return []string{}, err
 	}
 
@@ -252,3 +262,11 @@ func (k *secretsKeyring) Keys() ([]string, error) {
 
 	return keys, nil
 }
+
+// deleteCollection deletes the keyring's collection if it exists. This is mainly to support testing.
+func (k *secretsKeyring) deleteCollection() error {
+	if err := k.openCollection(); err != nil {
+		return err
+	}
+	return k.collection.Delete()
+}

libsecret_test.go

@@ -0,0 +1,143 @@
+// +build linux
+
+package keyring
+
+import (
+	"os"
+	"sort"
+	"testing"
+
+	"github.com/gsterjov/go-libsecret"
+)
+
+// NOTE: These tests are not runnable from a headless environment such as
+// Docker or a CI pipeline due to the DBus "prompt" interface being called
+// by the underlying go-libsecret when creating and unlocking a keychain.
+//
+// TODO: Investigate a way to automate the prompting. Some ideas:
+//
+//  1. I've looked extensively but have not found a headless CLI tool that
+//     could be run in the background of eg: a docker container
+//  2. It might be possible to make a mock prompter that connects to DBus
+//     and provides the Prompt interface using the go-libsecret library.
+
+func libSecretSetup(t *testing.T) (Keyring, func(t *testing.T)) {
+	if os.Getenv("CI") != "" {
+		t.Skip("Skipping testing in CI environment")
+	}
+
+	service, err := libsecret.NewService()
+	if err != nil {
+		t.Fatal(err)
+	}
+	kr := &secretsKeyring{
+		name:    "keyring-test",
+		service: service,
+	}
+	return kr, func(t *testing.T) {
+		if err := kr.deleteCollection(); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestLibSecretKeysWhenEmpty(t *testing.T) {
+	kr, _ := libSecretSetup(t)
+
+	keys, err := kr.Keys()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(keys) != 0 {
+		t.Fatalf("Expected 0 keys, got %d", len(keys))
+	}
+}
+
+func TestLibSecretKeysWhenNotEmpty(t *testing.T) {
+	kr, teardown := libSecretSetup(t)
+	defer teardown(t)
+
+	item := Item{Key: "llamas", Data: []byte("llamas are great")}
+	item2 := Item{Key: "alpacas", Data: []byte("alpacas are better")}
+
+	if err := kr.Set(item); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := kr.Set(item2); err != nil {
+		t.Fatal(err)
+	}
+
+	keys, err := kr.Keys()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(keys) != 2 {
+		t.Fatalf("Expected 2 keys, got %d", len(keys))
+	}
+
+	sort.Strings(keys)
+	if keys[0] != "alpacas" {
+		t.Fatalf("Expected alpacas")
+	}
+	if keys[1] != "llamas" {
+		t.Fatalf("Expected llamas")
+	}
+}
+
+func TestLibSecretGetWhenEmpty(t *testing.T) {
+	kr, _ := libSecretSetup(t)
+
+	_, err := kr.Get("llamas")
+	if err != ErrKeyNotFound {
+		t.Fatalf("Expected ErrKeyNotFound, got: %s", err)
+	}
+}
+
+func TestLibSecretGetWhenNotEmpty(t *testing.T) {
+	kr, teardown := libSecretSetup(t)
+	defer teardown(t)
+
+	item := Item{Key: "llamas", Data: []byte("llamas are great")}
+
+	if err := kr.Set(item); err != nil {
+		t.Fatal(err)
+	}
+
+	it, err := kr.Get(item.Key)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if it.Key != item.Key {
+		t.Fatal("Expected item not returned")
+	}
+}
+
+func TestLibSecretRemoveWhenEmpty(t *testing.T) {
+	kr, _ := libSecretSetup(t)
+
+	err := kr.Remove("no-such-key")
+	if err != ErrKeyNotFound {
+		t.Fatalf("Expected ErrKeyNotFound, got: %s", err)
+	}
+}
+
+func TestLibSecretRemoveWhenNotEmpty(t *testing.T) {
+	kr, teardown := libSecretSetup(t)
+	defer teardown(t)
+
+	item := Item{Key: "llamas", Data: []byte("llamas are great")}
+
+	if err := kr.Set(item); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := kr.Get("llamas"); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := kr.Remove("llamas"); err != nil {
+		t.Fatal(err)
+	}
+}