Write Test For GetUserDropdownWorkspaces

db/config.go

@@ -10,6 +10,16 @@ import (
 	"gorm.io/gorm"
 )
 
+type configHandler struct {
+	db Database
+}
+
+func NewConfigHandler(database Database) *configHandler {
+	return &configHandler{
+		db: database,
+	}
+}
+
 type database struct {
 	db                 *gorm.DB
 	getWorkspaceByUuid func(uuid string) Workspace
@@ -389,6 +399,17 @@ func (db database) UserHasAccess(pubKeyFromAuth string, uuid string, role string
 	return true
 }
 
+func (ch configHandler) UserHasAccess(pubKeyFromAuth string, uuid string, role string) bool {
+	org := ch.db.GetWorkspaceByUuid(uuid)
+	var hasRole bool = false
+	if pubKeyFromAuth != org.OwnerPubKey {
+		userRoles := ch.db.GetUserRoles(uuid, pubKeyFromAuth)
+		hasRole = RolesCheck(userRoles, role)
+		return hasRole
+	}
+	return true
+}
+
 func (db database) UserHasManageBountyRoles(pubKeyFromAuth string, uuid string) bool {
 	var manageRolesCount = len(ManageBountiesGroup)
 	org := db.getWorkspaceByUuid(uuid)

db/db.go

@@ -1394,6 +1394,16 @@ func (db database) GetPerson(id uint) Person {
 	return m
 }
 
+func (db database) DeleteWorkSpaceAllData() error {
+	tables := []string{"workspace_user_roles", "workspaces"}
+	for _, table := range tables {
+		if err := db.db.Exec("DELETE FROM " + table).Error; err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (db database) GetPersonByPubkey(pubkey string) Person {
 	m := Person{}
 	db.db.Where("owner_pub_key = ? AND (deleted = false OR deleted is null)", pubkey).Find(&m)

handlers/workspaces.go

@@ -21,17 +21,20 @@ type workspaceHandler struct {
 	generateBountyHandler    func(bounties []db.NewBounty) []db.BountyResponse
 	getLightningInvoice      func(payment_request string) (db.InvoiceResult, db.InvoiceError)
 	userHasAccess            func(pubKeyFromAuth string, uuid string, role string) bool
+	configUserHasAccess      func(pubKeyFromAuth string, uuid string, role string) bool
 	userHasManageBountyRoles func(pubKeyFromAuth string, uuid string) bool
 }
 
 func NewWorkspaceHandler(database db.Database) *workspaceHandler {
 	bHandler := NewBountyHandler(http.DefaultClient, database)
 	dbConf := db.NewDatabaseConfig(&gorm.DB{})
+	configHandler := db.NewConfigHandler(database)
 	return &workspaceHandler{
 		db:                       database,
 		generateBountyHandler:    bHandler.GenerateBountyResponse,
 		getLightningInvoice:      bHandler.GetLightningInvoice,
 		userHasAccess:            dbConf.UserHasAccess,
+		configUserHasAccess:      configHandler.UserHasAccess,
 		userHasManageBountyRoles: dbConf.UserHasManageBountyRoles,
 	}
 }
@@ -454,7 +457,7 @@ func (oh *workspaceHandler) GetUserRoles(w http.ResponseWriter, r *http.Request)
 	json.NewEncoder(w).Encode(userRoles)
 }
 
-func GetUserWorkspaces(w http.ResponseWriter, r *http.Request) {
+func (oh *workspaceHandler) GetUserWorkspaces(w http.ResponseWriter, r *http.Request) {
 	userIdParam := chi.URLParam(r, "userId")
 	userId, _ := utils.ConvertStringToUint(userIdParam)
 
@@ -464,9 +467,9 @@ func GetUserWorkspaces(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	user := db.DB.GetPerson(userId)
+	user := oh.db.GetPerson(userId)
 	// get the user workspaces
-	workspaces := GetAllUserWorkspaces(user.OwnerPubKey)
+	workspaces := oh.GetAllUserWorkspaces(user.OwnerPubKey)
 
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(workspaces)
@@ -482,23 +485,23 @@ func (oh *workspaceHandler) GetUserDropdownWorkspaces(w http.ResponseWriter, r *
 		return
 	}
 
-	user := db.DB.GetPerson(userId)
+	user := oh.db.GetPerson(userId)
 
 	// get the workspaces created by the user, then get all the workspaces
 	// the user has been added to, loop through to get the workspace
-	workspaces := GetCreatedWorkspaces(user.OwnerPubKey)
-	assignedWorkspaces := db.DB.GetUserAssignedWorkspaces(user.OwnerPubKey)
+	workspaces := oh.GetCreatedWorkspaces(user.OwnerPubKey)
+	assignedWorkspaces := oh.db.GetUserAssignedWorkspaces(user.OwnerPubKey)
 	for _, value := range assignedWorkspaces {
 		uuid := value.WorkspaceUuid
-		workspace := db.DB.GetWorkspaceByUuid(uuid)
-		bountyCount := db.DB.GetWorkspaceBountyCount(uuid)
-		hasRole := db.UserHasAccess(user.OwnerPubKey, uuid, db.ViewReport)
+		workspace := oh.db.GetWorkspaceByUuid(uuid)
+		bountyCount := oh.db.GetWorkspaceBountyCount(uuid)
+		hasRole := oh.configUserHasAccess(user.OwnerPubKey, uuid, db.ViewReport)
 		hasBountyRoles := oh.userHasManageBountyRoles(user.OwnerPubKey, uuid)
 
 		// don't add deleted workspaces to the list
 		if !workspace.Deleted && hasBountyRoles {
 			if hasRole {
-				budget := db.DB.GetWorkspaceBudget(uuid)
+				budget := oh.db.GetWorkspaceBudget(uuid)
 				workspace.Budget = budget.TotalBudget
 			} else {
 				workspace.Budget = 0
@@ -512,16 +515,16 @@ func (oh *workspaceHandler) GetUserDropdownWorkspaces(w http.ResponseWriter, r *
 	json.NewEncoder(w).Encode(workspaces)
 }
 
-func GetCreatedWorkspaces(pubkey string) []db.Workspace {
-	workspaces := db.DB.GetUserCreatedWorkspaces(pubkey)
+func (oh *workspaceHandler) GetCreatedWorkspaces(pubkey string) []db.Workspace {
+	workspaces := oh.db.GetUserCreatedWorkspaces(pubkey)
 	// add bounty count to the workspace
 	for index, value := range workspaces {
 		uuid := value.Uuid
-		bountyCount := db.DB.GetWorkspaceBountyCount(uuid)
-		hasRole := db.UserHasAccess(pubkey, uuid, db.ViewReport)
+		bountyCount := oh.db.GetWorkspaceBountyCount(uuid)
+		hasRole := oh.configUserHasAccess(pubkey, uuid, db.ViewReport)
 
 		if hasRole {
-			budget := db.DB.GetWorkspaceBudget(uuid)
+			budget := oh.db.GetWorkspaceBudget(uuid)
 			workspaces[index].Budget = budget.TotalBudget
 		} else {
 			workspaces[index].Budget = 0
@@ -687,7 +690,7 @@ func (oh *workspaceHandler) PollUserWorkspacesBudget(w http.ResponseWriter, r *h
 	}
 
 	// get the user workspaces
-	workspaces := GetAllUserWorkspaces(pubKeyFromAuth)
+	workspaces := oh.GetAllUserWorkspaces(pubKeyFromAuth)
 	// loop through the worksppaces and get each workspace invoice
 	for _, space := range workspaces {
 		// get all workspace invoice
@@ -737,7 +740,7 @@ func GetInvoicesCount(w http.ResponseWriter, r *http.Request) {
 	json.NewEncoder(w).Encode(invoiceCount)
 }
 
-func GetAllUserInvoicesCount(w http.ResponseWriter, r *http.Request) {
+func (oh *workspaceHandler) GetAllUserInvoicesCount(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	pubKeyFromAuth, _ := ctx.Value(auth.ContextKey).(string)
 
@@ -748,9 +751,9 @@ func GetAllUserInvoicesCount(w http.ResponseWriter, r *http.Request) {
 	}
 
 	allCount := int64(0)
-	workspaces := GetAllUserWorkspaces(pubKeyFromAuth)
+	workspaces := oh.GetAllUserWorkspaces(pubKeyFromAuth)
 	for _, space := range workspaces {
-		invoiceCount := db.DB.GetWorkspaceInvoicesCount(space.Uuid)
+		invoiceCount := oh.db.GetWorkspaceInvoicesCount(space.Uuid)
 		allCount += invoiceCount
 	}
 	w.WriteHeader(http.StatusOK)
@@ -995,20 +998,20 @@ func (oh *workspaceHandler) GetFeaturesByWorkspaceUuid(w http.ResponseWriter, r
 	json.NewEncoder(w).Encode(workspaceFeatures)
 }
 
-func GetAllUserWorkspaces(pubkey string) []db.Workspace {
+func (oh *workspaceHandler) GetAllUserWorkspaces(pubkey string) []db.Workspace {
 	// get the workspaces created by the user, then get all the workspaces
 	// the user has been added to, loop through to get the workspace
-	workspaces := GetCreatedWorkspaces(pubkey)
-	assignedWorkspaces := db.DB.GetUserAssignedWorkspaces(pubkey)
+	workspaces := oh.GetCreatedWorkspaces(pubkey)
+	assignedWorkspaces := oh.db.GetUserAssignedWorkspaces(pubkey)
 	for _, value := range assignedWorkspaces {
 		uuid := value.WorkspaceUuid
-		workspace := db.DB.GetWorkspaceByUuid(uuid)
-		bountyCount := db.DB.GetWorkspaceBountyCount(uuid)
-		hasRole := db.UserHasAccess(pubkey, uuid, db.ViewReport)
+		workspace := oh.db.GetWorkspaceByUuid(uuid)
+		bountyCount := oh.db.GetWorkspaceBountyCount(uuid)
+		hasRole := oh.configUserHasAccess(pubkey, uuid, db.ViewReport)
 		// don't add deleted workspaces to the list
 		if !workspace.Deleted {
 			if hasRole {
-				budget := db.DB.GetWorkspaceBudget(uuid)
+				budget := oh.db.GetWorkspaceBudget(uuid)
 				workspace.Budget = budget.TotalBudget
 			} else {
 				workspace.Budget = 0

handlers/workspaces_test.go

@@ -8,6 +8,7 @@ import (
 	"math/rand"
 	"net/http"
 	"net/http/httptest"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -1200,7 +1201,83 @@ func TestGetWorkspaceUsers(t *testing.T) {
 }
 
 func TestGetUserDropdownWorkspaces(t *testing.T) {
+	teardownSuite := SetupSuite(t)
+	defer teardownSuite(t)
+
+	db.TestDB.DeleteWorkSpaceAllData()
+
+	oHandler := NewWorkspaceHandler(db.TestDB)
+
+	person := db.Person{
+		Uuid:        uuid.New().String(),
+		OwnerAlias:  "test-alias",
+		UniqueName:  "test-unique-name",
+		OwnerPubKey: "test-pubkey",
+		PriceToMeet: 0,
+		Description: "test-description",
+	}
+	person2 := db.Person{
+		Uuid:        uuid.New().String(),
+		OwnerAlias:  "test-alias2",
+		UniqueName:  "test-unique-name2",
+		OwnerPubKey: "test-pubkey2",
+		PriceToMeet: 0,
+		Description: "test-description2",
+	}
+	db.TestDB.CreateOrEditPerson(person)
+	db.TestDB.CreateOrEditPerson(person2)
+
+	workspace := db.Workspace{
+		Uuid:        uuid.New().String(),
+		Name:        "test-workspace" + uuid.New().String(),
+		OwnerPubKey: person2.OwnerPubKey,
+		Github:      "https://github.com/test",
+		Website:     "https://www.testwebsite.com",
+		Description: "test-description",
+	}
+	db.TestDB.CreateOrEditWorkspace(workspace)
+	workspace = db.TestDB.GetWorkspaceByUuid(workspace.Uuid)
+	ctx := context.WithValue(context.Background(), auth.ContextKey, workspace.OwnerPubKey)
 
+	roles := []db.WorkspaceUserRoles{
+		{WorkspaceUuid: workspace.Uuid, OwnerPubKey: person2.OwnerPubKey, Role: "ADD BOUNTY"},
+		{WorkspaceUuid: workspace.Uuid, OwnerPubKey: person2.OwnerPubKey, Role: "UPDATE BOUNTY"},
+		{WorkspaceUuid: workspace.Uuid, OwnerPubKey: person2.OwnerPubKey, Role: "DELETE BOUNTY"},
+		{WorkspaceUuid: workspace.Uuid, OwnerPubKey: person2.OwnerPubKey, Role: "PAY BOUNTY"},
+		{WorkspaceUuid: workspace.Uuid, OwnerPubKey: person2.OwnerPubKey, Role: "VIEW REPORT"},
+	}
+	db.TestDB.CreateUserRoles(roles, workspace.Uuid, person2.OwnerPubKey)
+
+	dbPerson := db.TestDB.GetPersonByUuid(person2.Uuid)
+
+	t.Run("should return user dropdown workspaces", func(t *testing.T) {
+		rr := httptest.NewRecorder()
+		rctx := chi.NewRouteContext()
+		rctx.URLParams.Add("userId", strconv.Itoa(int(dbPerson.ID)))
+		req, err := http.NewRequestWithContext(context.WithValue(ctx, chi.RouteCtxKey, rctx), http.MethodGet, "/user/dropdown/"+strconv.Itoa(int(dbPerson.ID)), nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		handler := http.HandlerFunc(oHandler.GetUserDropdownWorkspaces)
+		handler.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusOK, rr.Code)
+
+		var responseWorkspaces []db.Workspace
+		err = json.Unmarshal(rr.Body.Bytes(), &responseWorkspaces)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.NotEmpty(t, responseWorkspaces)
+		assert.Equal(t, workspace.Uuid, responseWorkspaces[0].Uuid)
+		assert.Equal(t, workspace.Name, responseWorkspaces[0].Name)
+		assert.Equal(t, workspace.OwnerPubKey, responseWorkspaces[0].OwnerPubKey)
+		assert.Equal(t, workspace.Github, responseWorkspaces[0].Github)
+		assert.Equal(t, workspace.Website, responseWorkspaces[0].Website)
+		assert.Equal(t, workspace.Description, responseWorkspaces[0].Description)
+	})
 }
 
 func TestCreateOrEditWorkspaceRepository(t *testing.T) {

routes/workspaces.go

@@ -18,7 +18,7 @@ func WorkspaceRoutes() chi.Router {
 		r.Get("/users/{uuid}/count", handlers.GetWorkspaceUsersCount)
 		r.Get("/bounties/{uuid}", workspaceHandlers.GetWorkspaceBounties)
 		r.Get("/bounties/{uuid}/count", workspaceHandlers.GetWorkspaceBountiesCount)
-		r.Get("/user/{userId}", handlers.GetUserWorkspaces)
+		r.Get("/user/{userId}", workspaceHandlers.GetUserWorkspaces)
 		r.Get("/user/dropdown/{userId}", workspaceHandlers.GetUserDropdownWorkspaces)
 	})
 	r.Group(func(r chi.Router) {
@@ -38,7 +38,7 @@ func WorkspaceRoutes() chi.Router {
 		r.Get("/poll/invoices/{uuid}", workspaceHandlers.PollBudgetInvoices)
 		r.Get("/poll/user/invoices", workspaceHandlers.PollUserWorkspacesBudget)
 		r.Get("/invoices/count/{uuid}", handlers.GetInvoicesCount)
-		r.Get("/user/invoices/count", handlers.GetAllUserInvoicesCount)
+		r.Get("/user/invoices/count", workspaceHandlers.GetAllUserInvoicesCount)
 		r.Delete("/delete/{uuid}", workspaceHandlers.DeleteWorkspace)
 
 		r.Post("/mission", workspaceHandlers.UpdateWorkspace)