update vendor

this commit updates the vendored files to the newest versions, incorporating the removal of bare identities

Author: vincetiu8

migration2/after/bridge/core/auth/credential.go

@@ -16,10 +16,10 @@ import (
 const (
 	keyringKeyPrefix     = "auth-"
 	keyringKeyKind       = "kind"
-	keyringKeyTarget     = "target"
+	keyringKeyTarget     = "TargetT"
 	keyringKeyCreateTime = "createtime"
-	keyringKeySalt       = "salt"
-	keyringKeyPrefixMeta = "meta."
+	keyringKeySalt       = "SaltT"
+	keyringKeyPrefixMeta = "MetaT."
 
 	MetaKeyLogin   = "login"
 	MetaKeyBaseURL = "base-url"

migration2/after/bridge/core/auth/credential_base.go

@@ -17,10 +17,6 @@ type CredentialBase struct {
 	MetaT       map[string]string `json:"meta"`
 }
 
-func NewCredentialBase(target string, createTime time.Time, salt []byte, meta map[string]string) *CredentialBase {
-	return &CredentialBase{TargetT: target, CreateTimeT: createTime, SaltT: salt, MetaT: meta}
-}
-
 func newCredentialBase(target string) *CredentialBase {
 	return &CredentialBase{
 		TargetT:     target,

migration2/after/bridge/core/auth/credential_test.go

@@ -3,6 +3,7 @@ package auth
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/MichaelMure/git-bug-migration/migration2/after/entity"
@@ -23,66 +24,66 @@ func TestCredential(t *testing.T) {
 
 	// Store + Load
 	err := Store(repo, token)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	token2, err := LoadWithId(repo, token.ID())
-	require.NoError(t, err)
-	require.Equal(t, token.CreateTimeT.Unix(), token2.CreateTime().Unix())
+	assert.NoError(t, err)
+	assert.Equal(t, token.CreateTimeT.Unix(), token2.CreateTime().Unix())
 	token.CreateTimeT = token2.CreateTime()
-	require.Equal(t, token, token2)
+	assert.Equal(t, token, token2)
 
 	prefix := string(token.ID())[:10]
 
 	// LoadWithPrefix
 	token3, err := LoadWithPrefix(repo, prefix)
-	require.NoError(t, err)
-	require.Equal(t, token.CreateTimeT.Unix(), token3.CreateTime().Unix())
+	assert.NoError(t, err)
+	assert.Equal(t, token.CreateTimeT.Unix(), token3.CreateTime().Unix())
 	token.CreateTimeT = token3.CreateTime()
-	require.Equal(t, token, token3)
+	assert.Equal(t, token, token3)
 
 	token4 := storeToken("foo", "gitlab")
 	token5 := storeToken("bar", "github")
 
 	// List + options
 	creds, err := List(repo, WithTarget("github"))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	sameIds(t, creds, []Credential{token, token5})
 
 	creds, err = List(repo, WithTarget("gitlab"))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	sameIds(t, creds, []Credential{token4})
 
 	creds, err = List(repo, WithKind(KindToken))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	sameIds(t, creds, []Credential{token, token4, token5})
 
 	creds, err = List(repo, WithKind(KindLoginPassword))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	sameIds(t, creds, []Credential{})
 
 	// Metadata
 
 	token4.SetMetadata("key", "value")
 	err = Store(repo, token4)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	creds, err = List(repo, WithMeta("key", "value"))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	sameIds(t, creds, []Credential{token4})
 
 	// Exist
 	exist := IdExist(repo, token.ID())
-	require.True(t, exist)
+	assert.True(t, exist)
 
 	exist = PrefixExist(repo, prefix)
-	require.True(t, exist)
+	assert.True(t, exist)
 
 	// Remove
 	err = Remove(repo, token.ID())
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	creds, err = List(repo)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	sameIds(t, creds, []Credential{token4, token5})
 }
 
@@ -97,27 +98,27 @@ func sameIds(t *testing.T, a []Credential, b []Credential) {
 		return result
 	}
 
-	require.ElementsMatch(t, ids(a), ids(b))
+	assert.ElementsMatch(t, ids(a), ids(b))
 }
 
 func testCredentialSerial(t *testing.T, original Credential) Credential {
 	repo := repository.NewMockRepoForTest()
 
 	original.SetMetadata("test", "value")
 
-	require.NotEmpty(t, original.ID().String())
-	require.NotEmpty(t, original.Salt())
-	require.NoError(t, Store(repo, original))
+	assert.NotEmpty(t, original.ID().String())
+	assert.NotEmpty(t, original.Salt())
+	assert.NoError(t, Store(repo, original))
 
 	loaded, err := LoadWithId(repo, original.ID())
-	require.NoError(t, err)
-
-	require.Equal(t, original.ID(), loaded.ID())
-	require.Equal(t, original.Kind(), loaded.Kind())
-	require.Equal(t, original.Target(), loaded.Target())
-	require.Equal(t, original.CreateTime().Unix(), loaded.CreateTime().Unix())
-	require.Equal(t, original.Salt(), loaded.Salt())
-	require.Equal(t, original.Metadata(), loaded.Metadata())
+	assert.NoError(t, err)
+
+	assert.Equal(t, original.ID(), loaded.ID())
+	assert.Equal(t, original.Kind(), loaded.Kind())
+	assert.Equal(t, original.Target(), loaded.Target())
+	assert.Equal(t, original.CreateTime().Unix(), loaded.CreateTime().Unix())
+	assert.Equal(t, original.Salt(), loaded.Salt())
+	assert.Equal(t, original.Metadata(), loaded.Metadata())
 
 	return loaded
 }

migration2/after/bridge/core/auth/login_password_test.go

@@ -3,12 +3,12 @@ package auth
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLoginPasswordSerial(t *testing.T) {
 	original := NewLoginPassword("github", "jean", "jacques")
 	loaded := testCredentialSerial(t, original)
-	require.Equal(t, original.Login, loaded.(*LoginPassword).Login)
-	require.Equal(t, original.Password, loaded.(*LoginPassword).Password)
+	assert.Equal(t, original.Login, loaded.(*LoginPassword).Login)
+	assert.Equal(t, original.Password, loaded.(*LoginPassword).Password)
 }

migration2/after/bridge/core/auth/login_test.go

@@ -3,11 +3,11 @@ package auth
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLoginSerial(t *testing.T) {
 	original := NewLogin("github", "jean")
 	loaded := testCredentialSerial(t, original)
-	require.Equal(t, original.Login, loaded.(*Login).Login)
+	assert.Equal(t, original.Login, loaded.(*Login).Login)
 }

migration2/after/bridge/core/auth/token_test.go

@@ -3,11 +3,11 @@ package auth
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestTokenSerial(t *testing.T) {
 	original := NewToken("github", "value")
 	loaded := testCredentialSerial(t, original)
-	require.Equal(t, original.Value, loaded.(*Token).Value)
+	assert.Equal(t, original.Value, loaded.(*Token).Value)
 }

migration2/after/repository/config.go

@@ -13,15 +13,11 @@ var (
 
 // Config represent the common function interacting with the repository config storage
 type Config interface {
-	// Store writes a single key/value pair in the config
-	StoreString(key, value string) error
-
-	// Store writes a key and timestamp value to the config
-	StoreTimestamp(key string, value time.Time) error
-
-	// Store writes a key and boolean value to the config
-	StoreBool(key string, value bool) error
+	ConfigRead
+	ConfigWrite
+}
 
+type ConfigRead interface {
 	// ReadAll reads all key/value pair matching the key prefix
 	ReadAll(keyPrefix string) (map[string]string, error)
 
@@ -39,6 +35,17 @@ type Config interface {
 	// Return ErrNoConfigEntry or ErrMultipleConfigEntry if
 	// there is zero or more than one entry for this key
 	ReadTimestamp(key string) (time.Time, error)
+}
+
+type ConfigWrite interface {
+	// Store writes a single key/value pair in the config
+	StoreString(key, value string) error
+
+	// Store writes a key and timestamp value to the config
+	StoreTimestamp(key string, value time.Time) error
+
+	// Store writes a key and boolean value to the config
+	StoreBool(key string, value bool) error
 
 	// RemoveAll removes all key/value pair matching the key prefix
 	RemoveAll(keyPrefix string) error
@@ -52,3 +59,87 @@ func ParseTimestamp(s string) (time.Time, error) {
 
 	return time.Unix(int64(timestamp), 0), nil
 }
+
+// mergeConfig is a helper to easily support RepoConfig.AnyConfig()
+// from two separate local and global Config
+func mergeConfig(local ConfigRead, global ConfigRead) *mergedConfig {
+	return &mergedConfig{
+		local:  local,
+		global: global,
+	}
+}
+
+var _ ConfigRead = &mergedConfig{}
+
+type mergedConfig struct {
+	local  ConfigRead
+	global ConfigRead
+}
+
+func (m *mergedConfig) ReadAll(keyPrefix string) (map[string]string, error) {
+	values, err := m.global.ReadAll(keyPrefix)
+	if err != nil {
+		return nil, err
+	}
+	locals, err := m.local.ReadAll(keyPrefix)
+	if err != nil {
+		return nil, err
+	}
+	for k, val := range locals {
+		values[k] = val
+	}
+	return values, nil
+}
+
+func (m *mergedConfig) ReadBool(key string) (bool, error) {
+	v, err := m.local.ReadBool(key)
+	if err == nil {
+		return v, nil
+	}
+	if err != ErrNoConfigEntry && err != ErrMultipleConfigEntry {
+		return false, err
+	}
+	return m.global.ReadBool(key)
+}
+
+func (m *mergedConfig) ReadString(key string) (string, error) {
+	val, err := m.local.ReadString(key)
+	if err == nil {
+		return val, nil
+	}
+	if err != ErrNoConfigEntry && err != ErrMultipleConfigEntry {
+		return "", err
+	}
+	return m.global.ReadString(key)
+}
+
+func (m *mergedConfig) ReadTimestamp(key string) (time.Time, error) {
+	val, err := m.local.ReadTimestamp(key)
+	if err == nil {
+		return val, nil
+	}
+	if err != ErrNoConfigEntry && err != ErrMultipleConfigEntry {
+		return time.Time{}, err
+	}
+	return m.global.ReadTimestamp(key)
+}
+
+var _ ConfigWrite = &configPanicWriter{}
+
+type configPanicWriter struct{}
+
+func (c configPanicWriter) StoreString(key, value string) error {
+	panic("not implemented")
+}
+
+func (c configPanicWriter) StoreTimestamp(key string, value time.Time) error {
+	panic("not implemented")
+}
+
+func (c configPanicWriter) StoreBool(key string, value bool) error {
+	panic("not implemented")
+}
+
+func (c configPanicWriter) RemoveAll(keyPrefix string) error {
+	panic("not implemented")
+}

migration2/after/repository/config_test.go

@@ -0,0 +1,54 @@
+package repository
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestMergedConfig(t *testing.T) {
+	local := NewMemConfig()
+	global := NewMemConfig()
+	merged := mergeConfig(local, global)
+
+	require.NoError(t, global.StoreBool("bool", true))
+	require.NoError(t, global.StoreString("string", "foo"))
+	require.NoError(t, global.StoreTimestamp("timestamp", time.Unix(1234, 0)))
+
+	val1, err := merged.ReadBool("bool")
+	require.NoError(t, err)
+	require.Equal(t, val1, true)
+
+	val2, err := merged.ReadString("string")
+	require.NoError(t, err)
+	require.Equal(t, val2, "foo")
+
+	val3, err := merged.ReadTimestamp("timestamp")
+	require.NoError(t, err)
+	require.Equal(t, val3, time.Unix(1234, 0))
+
+	require.NoError(t, local.StoreBool("bool", false))
+	require.NoError(t, local.StoreString("string", "bar"))
+	require.NoError(t, local.StoreTimestamp("timestamp", time.Unix(5678, 0)))
+
+	val1, err = merged.ReadBool("bool")
+	require.NoError(t, err)
+	require.Equal(t, val1, false)
+
+	val2, err = merged.ReadString("string")
+	require.NoError(t, err)
+	require.Equal(t, val2, "bar")
+
+	val3, err = merged.ReadTimestamp("timestamp")
+	require.NoError(t, err)
+	require.Equal(t, val3, time.Unix(5678, 0))
+
+	all, err := merged.ReadAll("")
+	require.NoError(t, err)
+	require.Equal(t, all, map[string]string{
+		"bool":      "false",
+		"string":    "bar",
+		"timestamp": "5678",
+	})
+}