Feat peer groups (#304)

* feat(management): add groups

* squash

* feat(management): add handlers for groups

* feat(management): add handlers for groups

* chore(management): add tests for the get group of the management

* chore(management): add tests for save group

management/server/http/handler/groups.go

@@ -0,0 +1,135 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/netbirdio/netbird/management/server"
+	"github.com/netbirdio/netbird/management/server/jwtclaims"
+	"github.com/rs/xid"
+
+	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+)
+
+// Groups is a handler that returns groups of the account
+type Groups struct {
+	accountManager server.AccountManager
+	authAudience   string
+	jwtExtractor   jwtclaims.ClaimsExtractor
+}
+
+// GroupResponse is a response sent to the client
+type GroupResponse struct {
+	ID    string
+	Name  string
+	Peers []string
+}
+
+func NewGroups(accountManager server.AccountManager, authAudience string) *Groups {
+	return &Groups{
+		accountManager: accountManager,
+		authAudience:   authAudience,
+		jwtExtractor:   *jwtclaims.NewClaimsExtractor(nil),
+	}
+}
+
+// GetAllGroupsHandler list for the account
+func (h *Groups) GetAllGroupsHandler(w http.ResponseWriter, r *http.Request) {
+	account, err := h.getGroupAccount(r)
+	if err != nil {
+		log.Error(err)
+		http.Redirect(w, r, "/", http.StatusInternalServerError)
+		return
+	}
+
+	writeJSONObject(w, account.Groups)
+}
+
+func (h *Groups) CreateOrUpdateGroupHandler(w http.ResponseWriter, r *http.Request) {
+	account, err := h.getGroupAccount(r)
+	if err != nil {
+		http.Redirect(w, r, "/", http.StatusInternalServerError)
+		return
+	}
+
+	var req server.Group
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if r.Method == http.MethodPost {
+		req.ID = xid.New().String()
+	}
+
+	if err := h.accountManager.SaveGroup(account.Id, &req); err != nil {
+		log.Errorf("failed updating group %s under account %s %v", req.ID, account.Id, err)
+		http.Redirect(w, r, "/", http.StatusInternalServerError)
+		return
+	}
+
+	writeJSONObject(w, &req)
+}
+
+func (h *Groups) DeleteGroupHandler(w http.ResponseWriter, r *http.Request) {
+	account, err := h.getGroupAccount(r)
+	if err != nil {
+		http.Redirect(w, r, "/", http.StatusInternalServerError)
+		return
+	}
+	aID := account.Id
+
+	gID := mux.Vars(r)["id"]
+	if len(gID) == 0 {
+		http.Error(w, "invalid group ID", http.StatusBadRequest)
+		return
+	}
+
+	if err := h.accountManager.DeleteGroup(aID, gID); err != nil {
+		log.Errorf("failed delete group %s under account %s %v", gID, aID, err)
+		http.Redirect(w, r, "/", http.StatusInternalServerError)
+		return
+	}
+
+	writeJSONObject(w, "")
+}
+
+func (h *Groups) GetGroupHandler(w http.ResponseWriter, r *http.Request) {
+	account, err := h.getGroupAccount(r)
+	if err != nil {
+		http.Redirect(w, r, "/", http.StatusInternalServerError)
+		return
+	}
+
+	switch r.Method {
+	case http.MethodGet:
+		groupID := mux.Vars(r)["id"]
+		if len(groupID) == 0 {
+			http.Error(w, "invalid group ID", http.StatusBadRequest)
+			return
+		}
+
+		group, err := h.accountManager.GetGroup(account.Id, groupID)
+		if err != nil {
+			http.Error(w, "group not found", http.StatusNotFound)
+			return
+		}
+
+		writeJSONObject(w, group)
+	default:
+		http.Error(w, "", http.StatusNotFound)
+	}
+}
+
+func (h *Groups) getGroupAccount(r *http.Request) (*server.Account, error) {
+	jwtClaims := h.jwtExtractor.ExtractClaimsFromRequestContext(r, h.authAudience)
+
+	account, err := h.accountManager.GetAccountWithAuthorizationClaims(jwtClaims)
+	if err != nil {
+		return nil, fmt.Errorf("failed getting account of a user %s: %v", jwtClaims.UserId, err)
+	}
+
+	return account, nil
+}

management/server/http/handler/groups_test.go

@@ -0,0 +1,202 @@
+package handler
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gorilla/mux"
+	"github.com/netbirdio/netbird/management/server/jwtclaims"
+
+	"github.com/magiconair/properties/assert"
+	"github.com/netbirdio/netbird/management/server"
+	"github.com/netbirdio/netbird/management/server/mock_server"
+)
+
+func initGroupTestData(groups ...*server.Group) *Groups {
+	return &Groups{
+		accountManager: &mock_server.MockAccountManager{
+			SaveGroupFunc: func(accountID string, group *server.Group) error {
+				if !strings.HasPrefix(group.ID, "id-") {
+					group.ID = "id-was-set"
+				}
+				return nil
+			},
+			GetGroupFunc: func(_, groupID string) (*server.Group, error) {
+				if groupID != "idofthegroup" {
+					return nil, fmt.Errorf("not found")
+				}
+				return &server.Group{
+					ID:   "idofthegroup",
+					Name: "Group",
+				}, nil
+			},
+			GetAccountWithAuthorizationClaimsFunc: func(claims jwtclaims.AuthorizationClaims) (*server.Account, error) {
+				return &server.Account{
+					Id:     claims.AccountId,
+					Domain: "hotmail.com",
+				}, nil
+			},
+		},
+		authAudience: "",
+		jwtExtractor: jwtclaims.ClaimsExtractor{
+			ExtractClaimsFromRequestContext: func(r *http.Request, authAudiance string) jwtclaims.AuthorizationClaims {
+				return jwtclaims.AuthorizationClaims{
+					UserId:    "test_user",
+					Domain:    "hotmail.com",
+					AccountId: "test_id",
+				}
+			},
+		},
+	}
+}
+
+func TestGetGroup(t *testing.T) {
+	tt := []struct {
+		name           string
+		expectedStatus int
+		expectedBody   bool
+		requestType    string
+		requestPath    string
+		requestBody    io.Reader
+	}{
+		{
+			name:           "GetGroup OK",
+			expectedBody:   true,
+			requestType:    http.MethodGet,
+			requestPath:    "/api/groups/idofthegroup",
+			expectedStatus: http.StatusOK,
+		},
+		{
+			name:           "GetGroup not found",
+			requestType:    http.MethodGet,
+			requestPath:    "/api/groups/notexists",
+			expectedStatus: http.StatusNotFound,
+		},
+	}
+
+	group := &server.Group{
+		ID:   "idofthegroup",
+		Name: "Group",
+	}
+
+	p := initGroupTestData(group)
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			recorder := httptest.NewRecorder()
+			req := httptest.NewRequest(tc.requestType, tc.requestPath, tc.requestBody)
+
+			router := mux.NewRouter()
+			router.HandleFunc("/api/groups/{id}", p.GetGroupHandler).Methods("GET")
+			router.ServeHTTP(recorder, req)
+
+			res := recorder.Result()
+			defer res.Body.Close()
+
+			if status := recorder.Code; status != tc.expectedStatus {
+				t.Errorf("handler returned wrong status code: got %v want %v",
+					status, tc.expectedStatus)
+				return
+			}
+
+			if !tc.expectedBody {
+				return
+			}
+
+			content, err := io.ReadAll(res.Body)
+			if err != nil {
+				t.Fatalf("I don't know what I expected; %v", err)
+			}
+
+			got := &server.Group{}
+			if err = json.Unmarshal(content, &got); err != nil {
+				t.Fatalf("Sent content is not in correct json format; %v", err)
+			}
+
+			assert.Equal(t, got.ID, group.ID)
+			assert.Equal(t, got.Name, group.Name)
+		})
+	}
+}
+
+func TestSaveGroup(t *testing.T) {
+	tt := []struct {
+		name           string
+		expectedStatus int
+		expectedBody   bool
+		expectedGroup  *server.Group
+		requestType    string
+		requestPath    string
+		requestBody    io.Reader
+	}{
+		{
+			name:        "SaveGroup POST OK",
+			requestType: http.MethodPost,
+			requestPath: "/api/groups",
+			requestBody: bytes.NewBuffer(
+				[]byte(`{"Name":"Default POSTed Group"}`)),
+			expectedStatus: http.StatusOK,
+			expectedBody:   true,
+			expectedGroup: &server.Group{
+				ID:   "id-was-set",
+				Name: "Default POSTed Group",
+			},
+		},
+		{
+			name:        "SaveGroup PUT OK",
+			requestType: http.MethodPut,
+			requestPath: "/api/groups",
+			requestBody: bytes.NewBuffer(
+				[]byte(`{"ID":"id-existed","Name":"Default POSTed Group"}`)),
+			expectedStatus: http.StatusOK,
+			expectedGroup: &server.Group{
+				ID:   "id-existed",
+				Name: "Default POSTed Group",
+			},
+		},
+	}
+
+	p := initGroupTestData()
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			recorder := httptest.NewRecorder()
+			req := httptest.NewRequest(tc.requestType, tc.requestPath, tc.requestBody)
+
+			router := mux.NewRouter()
+			router.HandleFunc("/api/groups", p.CreateOrUpdateGroupHandler).Methods("PUT", "POST")
+			router.ServeHTTP(recorder, req)
+
+			res := recorder.Result()
+			defer res.Body.Close()
+
+			content, err := io.ReadAll(res.Body)
+			if err != nil {
+				t.Fatalf("I don't know what I expected; %v", err)
+			}
+
+			if status := recorder.Code; status != tc.expectedStatus {
+				t.Errorf("handler returned wrong status code: got %v want %v, content: %s",
+					status, tc.expectedStatus, string(content))
+				return
+			}
+
+			if !tc.expectedBody {
+				return
+			}
+
+			got := &server.Group{}
+			if err = json.Unmarshal(content, &got); err != nil {
+				t.Fatalf("Sent content is not in correct json format; %v", err)
+			}
+
+			assert.Equal(t, got, tc.expectedGroup)
+		})
+	}
+}

management/server/http/handler/peers_test.go

@@ -2,13 +2,14 @@ package handler
 
 import (
 	"encoding/json"
-	"github.com/netbirdio/netbird/management/server/jwtclaims"
 	"io"
 	"net"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
+	"github.com/netbirdio/netbird/management/server/jwtclaims"
+
 	"github.com/magiconair/properties/assert"
 	"github.com/netbirdio/netbird/management/server"
 	"github.com/netbirdio/netbird/management/server/mock_server"
@@ -43,14 +44,19 @@ func initTestMetaData(peer ...*server.Peer) *Peers {
 // Tests the GetPeers endpoint reachable in the route /api/peers
 // Use the metadata generated by initTestMetaData() to check for values
 func TestGetPeers(t *testing.T) {
-	var tt = []struct {
+	tt := []struct {
 		name           string
 		expectedStatus int
 		requestType    string
 		requestPath    string
 		requestBody    io.Reader
 	}{
-		{name: "GetPeersMetaData", requestType: http.MethodGet, requestPath: "/api/peers/", expectedStatus: http.StatusOK},
+		{
+			name:           "GetPeersMetaData",
+			requestType:    http.MethodGet,
+			requestPath:    "/api/peers/",
+			expectedStatus: http.StatusOK,
+		},
 	}
 
 	rr := httptest.NewRecorder()