MYST-224 Refactor identityHandler, add tests

cmd/mysterium_server/command_run/factory.go

@@ -33,15 +33,16 @@ func NewCommandWith(
 ) *CommandRun {
 
 	keystoreInstance := keystore.NewKeyStore(options.DirectoryKeystore, keystore.StandardScryptN, keystore.StandardScryptP)
+	cache := identity.NewIdentityCache(options.DirectoryKeystore, "remember.json")
 	identityHandler := NewNodeIdentityHandler(
 		identity.NewIdentityManager(keystoreInstance),
 		mysteriumClient,
-		options.DirectoryKeystore,
+		cache,
 	)
 
 	return &CommandRun{
 		identitySelector: func() (identity.Identity, error) {
-			return identityHandler.Select(options.NodeKey)
+			return SelectIdentity(identityHandler, options.NodeKey)
 		},
 		ipifyClient:     ipifyClient,
 		mysteriumClient: mysteriumClient,

cmd/mysterium_server/command_run/identity_handler.go

@@ -6,39 +6,39 @@ import (
 	"github.com/mysterium/node/server"
 )
 
+func SelectIdentity(identityHandler *identityHandler, keyOption string) (id identity.Identity, err error) {
+	if len(keyOption) > 0 {
+		return identityHandler.UseExisting(keyOption)
+	}
+
+	if id, err = identityHandler.UseLast(); err == nil {
+		return id, err
+	}
+
+	return identityHandler.UseNew()
+}
+
 const nodeIdentityPassword = ""
 
 type identityHandler struct {
 	manager     identity.IdentityManagerInterface
 	identityApi server.Client
-	cache       *identity.IdentityCache
+	cache       identity.IdentityCacheInterface
 }
 
 func NewNodeIdentityHandler(
 	manager identity.IdentityManagerInterface,
 	identityApi server.Client,
-	cacheDir string,
+	cache identity.IdentityCacheInterface,
 ) *identityHandler {
 	return &identityHandler{
 		manager:     manager,
 		identityApi: identityApi,
-		cache:       identity.NewIdentityCache(cacheDir, "remember.json"),
+		cache:       cache,
 	}
 }
 
-func (ih *identityHandler) Select(identityAddressWanted string) (id identity.Identity, err error) {
-	if len(identityAddressWanted) > 0 {
-		return ih.useExisting(identityAddressWanted)
-	}
-
-	if id, err = ih.useLast(); err == nil {
-		return id, err
-	}
-
-	return ih.useNew()
-}
-
-func (ih *identityHandler) useExisting(address string) (id identity.Identity, err error) {
+func (ih *identityHandler) UseExisting(address string) (id identity.Identity, err error) {
 	id, err = ih.manager.GetIdentity(address)
 	if err != nil {
 		return
@@ -48,7 +48,7 @@ func (ih *identityHandler) useExisting(address string) (id identity.Identity, er
 	return
 }
 
-func (ih *identityHandler) useLast() (identity identity.Identity, err error) {
+func (ih *identityHandler) UseLast() (identity identity.Identity, err error) {
 	identity, err = ih.cache.GetIdentity()
 	if err != nil || !ih.manager.HasIdentity(identity.Address) {
 		return identity, errors.New("identity not found in cache")
@@ -57,7 +57,7 @@ func (ih *identityHandler) useLast() (identity identity.Identity, err error) {
 	return identity, nil
 }
 
-func (ih *identityHandler) useNew() (id identity.Identity, err error) {
+func (ih *identityHandler) UseNew() (id identity.Identity, err error) {
 	// if all fails, create a new one
 	id, err = ih.manager.CreateNewIdentity(nodeIdentityPassword)
 	if err != nil {

cmd/mysterium_server/command_run/identity_handler_test.go

@@ -0,0 +1,51 @@
+package command_run
+
+import (
+	"testing"
+
+	"github.com/mysterium/node/identity"
+	"github.com/mysterium/node/server"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_identityHandler_UseExisting(t *testing.T) {
+	identityManager := identity.NewIdentityManagerFake()
+	client := server.NewClientFake()
+	cache := identity.NewIdentityCacheFake()
+
+	handler := NewNodeIdentityHandler(identityManager, client, cache)
+
+	id, err := handler.UseExisting("address")
+	assert.Equal(t, identityManager.FakeIdentity1, id)
+	assert.Nil(t, err)
+	assert.Equal(t, "", client.RegisteredIdentity.Address)
+}
+
+func Test_identityHandler_UseLast(t *testing.T) {
+	identityManager := identity.NewIdentityManagerFake()
+	client := server.NewClientFake()
+	cache := identity.NewIdentityCacheFake()
+
+	fakeIdentity := identity.FromAddress("abc")
+	cache.StoreIdentity(fakeIdentity)
+
+	handler := NewNodeIdentityHandler(identityManager, client, cache)
+
+	id, err := handler.UseLast()
+	assert.Equal(t, fakeIdentity, id)
+	assert.Nil(t, err)
+	assert.Equal(t, "", client.RegisteredIdentity.Address)
+}
+
+func Test_identityHandler_UseNew(t *testing.T) {
+	identityManager := identity.NewIdentityManagerFake()
+	client := server.NewClientFake()
+	cache := identity.NewIdentityCacheFake()
+
+	handler := NewNodeIdentityHandler(identityManager, client, cache)
+
+	id, err := handler.UseNew()
+	assert.Equal(t, identityManager.FakeIdentity2, client.RegisteredIdentity)
+	assert.Equal(t, identityManager.FakeIdentity2, id)
+	assert.Nil(t, err)
+}

identity/cache.go

@@ -2,6 +2,7 @@ package identity
 
 import (
 	"encoding/json"
+	"errors"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -15,23 +16,24 @@ type IdentityCache struct {
 	File string
 }
 
-func NewIdentityCache(dir string, jsonFile string) *IdentityCache {
+func NewIdentityCache(dir string, jsonFile string) IdentityCacheInterface {
 	return &IdentityCache{
 		File: filepath.Join(dir, jsonFile),
 	}
 }
 
 func (ic *IdentityCache) GetIdentity() (identity Identity, err error) {
-	if ic.cacheExists() {
-		cache, err := ic.readCache()
-		if err != nil {
-			return identity, err
-		}
+	if !ic.cacheExists() {
+		err = errors.New("cache file does not exist")
+		return
+	}
 
-		return cache.Identity, nil
+	cache, err := ic.readCache()
+	if err != nil {
+		return
 	}
 
-	return
+	return cache.Identity, nil
 }
 
 func (ic *IdentityCache) StoreIdentity(identity Identity) error {

identity/cache_fake.go

@@ -0,0 +1,18 @@
+package identity
+
+type identityCacheFake struct {
+	identity Identity
+}
+
+func NewIdentityCacheFake() IdentityCacheInterface {
+	return &identityCacheFake{}
+}
+
+func (icf *identityCacheFake) GetIdentity() (identity Identity, err error) {
+	return icf.identity, nil
+}
+
+func (icf *identityCacheFake) StoreIdentity(identity Identity) error {
+	icf.identity = identity
+	return nil
+}

identity/cache_interface.go

@@ -0,0 +1,6 @@
+package identity
+
+type IdentityCacheInterface interface {
+	GetIdentity() (identity Identity, err error)
+	StoreIdentity(identity Identity) error
+}

identity/cache_test.go

@@ -1,6 +1,7 @@
 package identity
 
 import (
+	"errors"
 	"github.com/stretchr/testify/assert"
 	"os"
 	"testing"
@@ -32,6 +33,16 @@ func TestIdentityCache_GetIdentity(t *testing.T) {
 	assert.Nil(t, err)
 }
 
+func TestIdentityCache_GetIdentityWithNoCache(t *testing.T) {
+	cache := IdentityCache{
+		File: "does-not-exist",
+	}
+
+	_, err := cache.GetIdentity()
+
+	assert.Equal(t, errors.New("cache file does not exist"), err)
+}
+
 func TestIdentityCache_cacheExists(t *testing.T) {
 	identity := FromAddress("0x000000000000000000000000000000000000000A")
 	cache := IdentityCache{

identity/manager_fake.go

@@ -1,26 +1,30 @@
 package identity
 
-type idmFake struct{}
+type idmFake struct {
+	FakeIdentity1 Identity
+	FakeIdentity2 Identity
+}
 
 func NewIdentityManagerFake() *idmFake {
-	return &idmFake{}
+	return &idmFake{
+		FromAddress("0x000000000000000000000000000000000000000A"),
+		FromAddress("0x000000000000000000000000000000000000bEEF"),
+	}
 }
 
 func (fakeIdm *idmFake) CreateNewIdentity(_ string) (Identity, error) {
-	id := FromAddress("0x000000000000000000000000000000000000bEEF")
-	return id, nil
+	return fakeIdm.FakeIdentity2, nil
 }
 func (fakeIdm *idmFake) GetIdentities() []Identity {
 	accountList := []Identity{
-		FromAddress("0x000000000000000000000000000000000000bEEF"),
-		FromAddress("0x000000000000000000000000000000000000bEEF"),
+		fakeIdm.FakeIdentity2,
+		fakeIdm.FakeIdentity2,
 	}
 
 	return accountList
 }
 func (fakeIdm *idmFake) GetIdentity(_ string) (Identity, error) {
-	id := FromAddress("0x000000000000000000000000000000000000000A")
-	return id, nil
+	return fakeIdm.FakeIdentity1, nil
 }
 func (fakeIdm *idmFake) HasIdentity(_ string) bool {
 	return true

server/mysterium_api_fake.go

@@ -15,7 +15,8 @@ func NewClientFake() *ClientFake {
 }
 
 type ClientFake struct {
-	proposalsMock []dto_discovery.ServiceProposal
+	RegisteredIdentity identity.Identity
+	proposalsMock      []dto_discovery.ServiceProposal
 }
 
 func (client *ClientFake) NodeRegister(proposal dto_discovery.ServiceProposal) (err error) {
@@ -26,6 +27,7 @@ func (client *ClientFake) NodeRegister(proposal dto_discovery.ServiceProposal) (
 }
 
 func (client *ClientFake) RegisterIdentity(identity identity.Identity) (err error) {
+	client.RegisteredIdentity = identity
 	log.Info(mysteriumApiLogPrefix, "Fake identity registered: ", identity)
 
 	return nil