CNS-231 unitests tests and fixes

testutil/keeper/keepers_init.go

@@ -21,6 +21,8 @@ import (
 	"github.com/lavanet/lava/x/pairing"
 	pairingkeeper "github.com/lavanet/lava/x/pairing/keeper"
 	pairingtypes "github.com/lavanet/lava/x/pairing/types"
+	projectskeeper "github.com/lavanet/lava/x/projects/keeper"
+	projectstypes "github.com/lavanet/lava/x/projects/types"
 	"github.com/lavanet/lava/x/spec"
 	speckeeper "github.com/lavanet/lava/x/spec/keeper"
 	spectypes "github.com/lavanet/lava/x/spec/types"
@@ -43,6 +45,7 @@ type Keepers struct {
 	Spec          speckeeper.Keeper
 	Pairing       pairingkeeper.Keeper
 	Conflict      conflictkeeper.Keeper
+	Projects      projectskeeper.Keeper
 	BankKeeper    mockBankKeeper
 	AccountKeeper mockAccountKeeper
 	ParamsKeeper  paramskeeper.Keeper
@@ -54,6 +57,7 @@ type Servers struct {
 	SpecServer     spectypes.MsgServer
 	PairingServer  pairingtypes.MsgServer
 	ConflictServer conflicttypes.MsgServer
+	ProjecttServer projectstypes.MsgServer
 }
 
 func SimulateParamChange(ctx sdk.Context, paramKeeper paramskeeper.Keeper, subspace string, key string, value string) (err error) {
@@ -94,6 +98,11 @@ func InitAllKeepers(t testing.TB) (*Servers, *Keepers, context.Context) {
 	stateStore.MountStoreWithDB(conflictStoreKey, sdk.StoreTypeIAVL, db)
 	stateStore.MountStoreWithDB(conflictMemStoreKey, sdk.StoreTypeMemory, nil)
 
+	projectsStoreKey := sdk.NewKVStoreKey(projectstypes.StoreKey)
+	projectsMemStoreKey := storetypes.NewMemoryStoreKey(projectstypes.MemStoreKey)
+	stateStore.MountStoreWithDB(projectsStoreKey, sdk.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(projectsMemStoreKey, sdk.StoreTypeMemory, nil)
+
 	require.NoError(t, stateStore.LoadLatestVersion())
 
 	paramsKeeper := paramskeeper.NewKeeper(cdc, pairingtypes.Amino, paramsStoreKey, tkey)
@@ -108,6 +117,8 @@ func InitAllKeepers(t testing.TB) (*Servers, *Keepers, context.Context) {
 
 	specparamsSubspace, _ := paramsKeeper.GetSubspace(spectypes.ModuleName)
 
+	projectsparamsSubspace, _ := paramsKeeper.GetSubspace(projectstypes.ModuleName)
+
 	conflictparamsSubspace := paramstypes.NewSubspace(cdc,
 		conflicttypes.Amino,
 		conflictStoreKey,
@@ -119,6 +130,7 @@ func InitAllKeepers(t testing.TB) (*Servers, *Keepers, context.Context) {
 	ks.AccountKeeper = mockAccountKeeper{}
 	ks.BankKeeper = mockBankKeeper{balance: make(map[string]sdk.Coins)}
 	ks.Spec = *speckeeper.NewKeeper(cdc, specStoreKey, specMemStoreKey, specparamsSubspace)
+	ks.Projects = *projectskeeper.NewKeeper(cdc, projectsStoreKey, projectsMemStoreKey, projectsparamsSubspace)
 	ks.Epochstorage = *epochstoragekeeper.NewKeeper(cdc, epochStoreKey, epochMemStoreKey, epochparamsSubspace, &ks.BankKeeper, &ks.AccountKeeper, ks.Spec)
 	ks.Pairing = *pairingkeeper.NewKeeper(cdc, pairingStoreKey, pairingMemStoreKey, pairingparamsSubspace, &ks.BankKeeper, &ks.AccountKeeper, ks.Spec, &ks.Epochstorage)
 	ks.ParamsKeeper = paramsKeeper
@@ -132,6 +144,7 @@ func InitAllKeepers(t testing.TB) (*Servers, *Keepers, context.Context) {
 	ks.Spec.SetParams(ctx, spectypes.DefaultParams())
 	ks.Epochstorage.SetParams(ctx, epochstoragetypes.DefaultParams())
 	ks.Conflict.SetParams(ctx, conflicttypes.DefaultParams())
+	ks.Projects.SetParams(ctx, projectstypes.DefaultParams())
 
 	ks.Epochstorage.PushFixatedParams(ctx, 0, 0)
 
@@ -140,6 +153,7 @@ func InitAllKeepers(t testing.TB) (*Servers, *Keepers, context.Context) {
 	ss.SpecServer = speckeeper.NewMsgServerImpl(ks.Spec)
 	ss.PairingServer = pairingkeeper.NewMsgServerImpl(ks.Pairing)
 	ss.ConflictServer = conflictkeeper.NewMsgServerImpl(ks.Conflict)
+	ss.ProjecttServer = projectskeeper.NewMsgServerImpl(ks.Projects)
 
 	core.SetEnvironment(&core.Environment{BlockStore: &ks.BlockStore})
 

x/projects/keeper/creation.go

@@ -35,14 +35,14 @@ func (k Keeper) CreateEmptyProject(ctx sdk.Context, subscriptionAddress string,
 		return utils.LavaError(ctx, ctx.Logger(), "CreateEmptyProject_already_exist", map[string]string{"subscription": subscriptionAddress}, "project already exist for the current subscription with the same name")
 	}
 
-	project.ProjectKeys = append(project.ProjectKeys, types.ProjectKey{Key: adminAddress, Types: []types.ProjectKey_KEY_TYPE{types.ProjectKey_ADMIN}})
+	project.AppendKey(types.ProjectKey{Key: adminAddress, Types: []types.ProjectKey_KEY_TYPE{types.ProjectKey_ADMIN}})
 
 	var projectID types.ProtoString
 	err = k.developerKeysFS.FindEntry(ctx, adminAddress, uint64(ctx.BlockHeight()), &projectID)
 	// a developer key with this address is not registered, add it to the developer keys list
-	if err == nil {
+	if err != nil {
 		projectID.String_ = project.Index
-		err = k.developerKeysFS.AppendEntry(ctx, project.Index, uint64(ctx.BlockHeight()), &projectID)
+		err = k.developerKeysFS.AppendEntry(ctx, adminAddress, uint64(ctx.BlockHeight()), &projectID)
 		if err != nil {
 			return err
 		}

x/projects/keeper/msg_server_add_project_keys.go

@@ -21,24 +21,26 @@ func (k msgServer) AddProjectKeys(goCtx context.Context, msg *types.MsgAddProjec
 	}
 
 	// check if the admin key is valid
-	if !project.IsKeyType(adminKey, types.ProjectKey_ADMIN) || project.Subscription != adminKey {
+	if !project.IsKeyType(adminKey, types.ProjectKey_ADMIN) && project.Subscription != adminKey {
 		return nil, utils.LavaError(ctx, ctx.Logger(), "AddProjectKeys_not_admin", map[string]string{"project": projectID}, "the requesting key is not admin key")
 	}
 
 	// check that those keys are unique for developers
 	for _, projectKey := range projectKeys {
-		if projectKey.IsKeyType(types.ProjectKey_DEVELOPER) {
-			// if the key is a developer key add it to the map of developer keys
-			var projectIDstring types.ProtoString
-			err = k.developerKeysFS.FindEntry(ctx, projectKey.Key, uint64(ctx.BlockHeight()), &projectIDstring)
-			if err == nil {
-				projectIDstring.String_ = project.Index
-				err = k.developerKeysFS.AppendEntry(ctx, project.Index, uint64(ctx.BlockHeight()), &projectIDstring)
-				if err != nil {
-					return nil, utils.LavaError(ctx, ctx.Logger(), "AddProjectKeys_used_key", map[string]string{"project": projectID, "developerKey": projectKey.Key, "err": err.Error()}, "the requesting key is not admin key")
-				}
+		// check if this key is registered as a developer key
+		var projectIDstring types.ProtoString
+		err = k.developerKeysFS.FindEntry(ctx, projectKey.Key, uint64(ctx.BlockHeight()), &projectIDstring)
+
+		// not registered
+		if err != nil {
+			projectIDstring.String_ = project.Index
+			err = k.developerKeysFS.AppendEntry(ctx, projectKey.Key, uint64(ctx.BlockHeight()), &projectIDstring)
+			if err != nil {
+				return nil, utils.LavaError(ctx, ctx.Logger(), "AddProjectKeys_used_key", map[string]string{"project": projectID, "developerKey": projectKey.Key, "err": err.Error()}, "failed to register key")
 			}
 		}
+
+		project.AppendKey(projectKey)
 	}
 
 	err = k.projectsFS.AppendEntry(ctx, projectID, uint64(ctx.BlockHeight()), &project)

x/projects/keeper/project_test.go

@@ -0,0 +1,132 @@
+package keeper_test
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/lavanet/lava/testutil/common"
+	testkeeper "github.com/lavanet/lava/testutil/keeper"
+	"github.com/lavanet/lava/x/projects/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCreateDefaultProject(t *testing.T) {
+	_, keepers, ctx := testkeeper.InitAllKeepers(t)
+
+	subAccount := common.CreateNewAccount(ctx, *keepers, 10000)
+	err := keepers.Projects.CreateDefaultProject(sdk.UnwrapSDKContext(ctx), subAccount.Addr.String())
+	require.Nil(t, err)
+
+	// subscription key is a developer in the default project
+	response1, err := keepers.Projects.ShowDevelopersProject(ctx, &types.QueryShowDevelopersProjectRequest{Developer: subAccount.Addr.String()})
+	require.Nil(t, err)
+
+	testkeeper.AdvanceEpoch(ctx, keepers)
+
+	response2, err := keepers.Projects.ShowProject(ctx, &types.QueryShowProjectRequest{Project: response1.Project.Index})
+	require.Nil(t, err)
+
+	require.Equal(t, response2.Project, response1.Project)
+}
+
+func TestCreateProject(t *testing.T) {
+	_, keepers, ctx := testkeeper.InitAllKeepers(t)
+
+	projectName := "mockname"
+	subAccount := common.CreateNewAccount(ctx, *keepers, 10000)
+	adminAcc := common.CreateNewAccount(ctx, *keepers, 10000)
+	err := keepers.Projects.CreateEmptyProject(sdk.UnwrapSDKContext(ctx), subAccount.Addr.String(), projectName, adminAcc.Addr.String(), false)
+	require.Nil(t, err)
+
+	testkeeper.AdvanceEpoch(ctx, keepers)
+
+	// create another project with the same name, should fail as this is unique
+	err = keepers.Projects.CreateEmptyProject(sdk.UnwrapSDKContext(ctx), subAccount.Addr.String(), projectName, adminAcc.Addr.String(), false)
+	require.NotNil(t, err)
+
+	// subscription key is not a developer
+	response1, err := keepers.Projects.ShowDevelopersProject(ctx, &types.QueryShowDevelopersProjectRequest{Developer: subAccount.Addr.String()})
+	require.NotNil(t, err)
+
+	response1, err = keepers.Projects.ShowDevelopersProject(ctx, &types.QueryShowDevelopersProjectRequest{Developer: adminAcc.Addr.String()})
+	require.Nil(t, err)
+
+	response2, err := keepers.Projects.ShowProject(ctx, &types.QueryShowProjectRequest{Project: response1.Project.Index})
+	require.Nil(t, err)
+
+	require.Equal(t, response2.Project, response1.Project)
+
+	require.Equal(t, len(response2.Project.ProjectKeys), 1)
+	require.Equal(t, response2.Project.ProjectKeys[0].Key, adminAcc.Addr.String())
+	require.Equal(t, len(response2.Project.ProjectKeys[0].Types), 1)
+	require.Equal(t, response2.Project.ProjectKeys[0].Types[0], types.ProjectKey_ADMIN)
+}
+
+func TestAddKeys(t *testing.T) {
+	servers, keepers, ctx := testkeeper.InitAllKeepers(t)
+
+	projectName := "mockname"
+	subAccount := common.CreateNewAccount(ctx, *keepers, 10000)
+	adminAcc := common.CreateNewAccount(ctx, *keepers, 10000)
+	developerAcc := common.CreateNewAccount(ctx, *keepers, 10000)
+	err := keepers.Projects.CreateEmptyProject(sdk.UnwrapSDKContext(ctx), subAccount.Addr.String(), projectName, adminAcc.Addr.String(), false)
+	require.Nil(t, err)
+
+	testkeeper.AdvanceEpoch(ctx, keepers)
+
+	// subscription key is not a developer
+	projectRes, err := keepers.Projects.ShowDevelopersProject(ctx, &types.QueryShowDevelopersProjectRequest{Developer: adminAcc.Addr.String()})
+	require.Nil(t, err)
+
+	project := projectRes.Project
+	pk := types.ProjectKey{Key: developerAcc.Addr.String(), Types: []types.ProjectKey_KEY_TYPE{types.ProjectKey_ADMIN}}
+	// try adding myself as admin, should fail
+	_, err = servers.ProjecttServer.AddProjectKeys(ctx, &types.MsgAddProjectKeys{Creator: developerAcc.Addr.String(), Project: project.Index, ProjectKeys: []types.ProjectKey{pk}})
+	require.NotNil(t, err)
+
+	// admin key adding as developer
+	pk = types.ProjectKey{Key: developerAcc.Addr.String(), Types: []types.ProjectKey_KEY_TYPE{types.ProjectKey_DEVELOPER}}
+	_, err = servers.ProjecttServer.AddProjectKeys(ctx, &types.MsgAddProjectKeys{Creator: adminAcc.Addr.String(), Project: project.Index, ProjectKeys: []types.ProjectKey{pk}})
+	require.Nil(t, err)
+
+	// developer tries to add admin
+	pk = types.ProjectKey{Key: developerAcc.Addr.String(), Types: []types.ProjectKey_KEY_TYPE{types.ProjectKey_ADMIN}}
+	_, err = servers.ProjecttServer.AddProjectKeys(ctx, &types.MsgAddProjectKeys{Creator: developerAcc.Addr.String(), Project: project.Index, ProjectKeys: []types.ProjectKey{pk}})
+	require.NotNil(t, err)
+
+	// admin adding admin
+	pk = types.ProjectKey{Key: developerAcc.Addr.String(), Types: []types.ProjectKey_KEY_TYPE{types.ProjectKey_ADMIN}}
+	_, err = servers.ProjecttServer.AddProjectKeys(ctx, &types.MsgAddProjectKeys{Creator: adminAcc.Addr.String(), Project: project.Index, ProjectKeys: []types.ProjectKey{pk}})
+	require.Nil(t, err)
+
+	// new admin adding another developer
+	developerAcc2 := common.CreateNewAccount(ctx, *keepers, 10000)
+	pk = types.ProjectKey{Key: developerAcc2.Addr.String(), Types: []types.ProjectKey_KEY_TYPE{types.ProjectKey_ADMIN}}
+	_, err = servers.ProjecttServer.AddProjectKeys(ctx, &types.MsgAddProjectKeys{Creator: developerAcc.Addr.String(), Project: project.Index, ProjectKeys: []types.ProjectKey{pk}})
+	require.Nil(t, err)
+
+	// fetch project with new developer
+	projectRes, err = keepers.Projects.ShowDevelopersProject(ctx, &types.QueryShowDevelopersProjectRequest{Developer: developerAcc2.Addr.String()})
+	require.Nil(t, err)
+}
+
+func TestAddAdminInTwoProjects(t *testing.T) {
+	_, keepers, ctx := testkeeper.InitAllKeepers(t)
+	// he should be a developer only in the first project
+	projectName1 := "mockname1"
+	projectName2 := "mockname2"
+
+	subAccount := common.CreateNewAccount(ctx, *keepers, 10000)
+	adminAcc := common.CreateNewAccount(ctx, *keepers, 10000)
+	err := keepers.Projects.CreateEmptyProject(sdk.UnwrapSDKContext(ctx), subAccount.Addr.String(), projectName1, adminAcc.Addr.String(), false)
+	require.Nil(t, err)
+
+	err = keepers.Projects.CreateEmptyProject(sdk.UnwrapSDKContext(ctx), subAccount.Addr.String(), projectName2, adminAcc.Addr.String(), false)
+	require.Nil(t, err)
+
+	testkeeper.AdvanceEpoch(ctx, keepers)
+
+	response, err := keepers.Projects.ShowDevelopersProject(ctx, &types.QueryShowDevelopersProjectRequest{Developer: adminAcc.Addr.String()})
+	require.Nil(t, err)
+	require.Equal(t, response.Project.Index, types.ProjectIndex(subAccount.Addr.String(), projectName1))
+}

x/projects/types/project.go

@@ -47,6 +47,16 @@ func (projectKey *ProjectKey) AppendType(typesToAdd []ProjectKey_KEY_TYPE) {
 	}
 }
 
+func (project *Project) AppendKey(keyToAdd ProjectKey) {
+	for i := 0; i < len(project.ProjectKeys); i++ {
+		if project.ProjectKeys[i].Key == keyToAdd.Key {
+			project.ProjectKeys[i].AppendType(keyToAdd.Types)
+			return
+		}
+	}
+	project.ProjectKeys = append(project.ProjectKeys, keyToAdd)
+}
+
 func (project *Project) IsKeyType(projectKey string, keyTypeToCheck ProjectKey_KEY_TYPE) bool {
 	return project.GetKey(projectKey).IsKeyType(keyTypeToCheck)
 }