Implementing Galadriel Server Management Handlers API

pkg/common/http/http.go

@@ -9,20 +9,20 @@ import (
 )
 
 // WriteResponse parses a struct into a json and writes in the response
-func WriteResponse(ctx echo.Context, body interface{}) error {
+func WriteResponse(ctx echo.Context, code int, body interface{}) error {
 	if body == nil {
 		return errors.New("body is required")
 	}
 
-	if err := ctx.JSON(http.StatusOK, body); err != nil {
+	if err := ctx.JSON(code, body); err != nil {
 		return fmt.Errorf("failed to write response body: %v", err)
 	}
 
 	return nil
 }
 
-// BodylessResponse wraps error echo body-less responses.
-func BodylessResponse(ctx echo.Context) error {
+// BodilessResponse wraps error echo body-less responses.
+func BodilessResponse(ctx echo.Context, code int) error {
 	if err := ctx.NoContent(http.StatusOK); err != nil {
 		return fmt.Errorf("failed to respond without body: %v", err)
 	}

pkg/common/http/http_test.go

@@ -34,21 +34,22 @@ func Setup() *HTTPSetup {
 func TestWriteResponse(t *testing.T) {
 	t.Run("Error when nil body is passed", func(t *testing.T) {
 		setup := Setup()
-		err := WriteResponse(setup.EchoContext, nil)
+		err := WriteResponse(setup.EchoContext, 0, nil)
 		assert.EqualError(t, err, "body is required")
 		assert.Empty(t, setup.Recorder.Body)
 	})
 
 	t.Run("No error when an empty body is passed", func(t *testing.T) {
 		setup := Setup()
-		err := WriteResponse(setup.EchoContext, TestBody{})
+		err := WriteResponse(setup.EchoContext, http.StatusOK, TestBody{})
 		assert.NoError(t, err)
+		assert.Equal(t, http.StatusOK, setup.Recorder.Code)
 	})
 
 	t.Run("Ensuring that the body is being full filled with the entity", func(t *testing.T) {
 		expectedResponseBody := TestBody{Name: "teste"}
 		setup := Setup()
-		err := WriteResponse(setup.EchoContext, expectedResponseBody)
+		err := WriteResponse(setup.EchoContext, http.StatusOK, expectedResponseBody)
 		assert.NoError(t, err)
 
 		responseBody := TestBody{}
@@ -60,10 +61,10 @@ func TestWriteResponse(t *testing.T) {
 	})
 }
 
-func TestBodylessResponse(t *testing.T) {
+func TestBodilessResponse(t *testing.T) {
 	t.Run("Ensuring that the body is empty", func(t *testing.T) {
 		setup := Setup()
-		err := BodylessResponse(setup.EchoContext)
+		err := BodilessResponse(setup.EchoContext, http.StatusOK)
 		assert.NoError(t, err)
 
 		assert.NoError(t, err)
@@ -75,7 +76,7 @@ func TestBodylessResponse(t *testing.T) {
 func TestFromBody(t *testing.T) {
 	t.Run("Ensuring that the body is empty", func(t *testing.T) {
 		setup := Setup()
-		err := BodylessResponse(setup.EchoContext)
+		err := BodilessResponse(setup.EchoContext, http.StatusOK)
 		assert.NoError(t, err)
 
 		assert.NoError(t, err)

pkg/server/datastore/fakedatabase.go

@@ -41,14 +41,15 @@ func (db *FakeDatabase) CreateOrUpdateTrustDomain(ctx context.Context, req *enti
 		return nil, err
 	}
 
-	req.ID = uuid.NullUUID{
-		UUID:  uuid.New(),
-		Valid: true,
+	if !req.ID.Valid {
+		req.ID = uuid.NullUUID{
+			UUID:  uuid.New(),
+			Valid: true,
+		}
+		req.CreatedAt = time.Now()
 	}
 
-	req.CreatedAt = time.Now()
 	req.UpdatedAt = time.Now()
-
 	db.trustDomains[req.ID.UUID] = req
 
 	return req, nil
@@ -133,14 +134,15 @@ func (db *FakeDatabase) CreateOrUpdateBundle(ctx context.Context, req *entity.Bu
 		return nil, err
 	}
 
-	req.ID = uuid.NullUUID{
-		UUID:  uuid.New(),
-		Valid: true,
+	if !req.ID.Valid {
+		req.ID = uuid.NullUUID{
+			UUID:  uuid.New(),
+			Valid: true,
+		}
+		req.CreatedAt = time.Now()
 	}
 
-	req.CreatedAt = time.Now()
 	req.UpdatedAt = time.Now()
-
 	db.bundles[req.ID.UUID] = req
 
 	return req, nil
@@ -354,7 +356,18 @@ func (db *FakeDatabase) CreateOrUpdateRelationship(ctx context.Context, req *ent
 		return nil, err
 	}
 
-	return nil, nil
+	if !req.ID.Valid {
+		req.ID = uuid.NullUUID{
+			Valid: true,
+			UUID:  uuid.New(),
+		}
+		req.CreatedAt = time.Now()
+	}
+
+	req.UpdatedAt = time.Now()
+	db.relationships[req.ID.UUID] = req
+
+	return req, nil
 }
 
 func (db *FakeDatabase) FindRelationshipByID(ctx context.Context, relationshipID uuid.UUID) (*entity.Relationship, error) {
@@ -431,6 +444,28 @@ func (db *FakeDatabase) DeleteRelationship(ctx context.Context, relationshipID u
 	return nil
 }
 
+// WithRelationships overrides all relationships
+func (db *FakeDatabase) WithRelationships(relationships ...*entity.Relationship) {
+	db.mutex.Lock()
+	defer db.mutex.Unlock()
+
+	db.relationships = make(map[uuid.UUID]*entity.Relationship)
+	for _, r := range relationships {
+		db.relationships[r.ID.UUID] = r
+	}
+}
+
+// WithRelationships overrides all trust domains
+func (db *FakeDatabase) WithTrustDomains(trustDomains ...*entity.TrustDomain) {
+	db.mutex.Lock()
+	defer db.mutex.Unlock()
+
+	db.trustDomains = make(map[uuid.UUID]*entity.TrustDomain)
+	for _, td := range trustDomains {
+		db.trustDomains[td.ID.UUID] = td
+	}
+}
+
 func (db *FakeDatabase) SetNextError(err error) {
 	db.mutex.Lock()
 	defer db.mutex.Unlock()

pkg/server/endpoints/auth_test.go

@@ -46,8 +46,8 @@ func SetupMiddleware() *AuthNTestSetup {
 	}
 }
 
-func SetupToken(t *testing.T, ds datastore.Datastore, token string, tdID uuid.UUID) *entity.JoinToken {
-	td, err := spiffeid.TrustDomainFromString(testTrustDomain)
+func SetupToken(t *testing.T, ds datastore.Datastore, tdID uuid.UUID, token, tdName string) *entity.JoinToken {
+	td, err := spiffeid.TrustDomainFromString(tdName)
 	assert.NoError(t, err)
 
 	jt := &entity.JoinToken{
@@ -67,7 +67,7 @@ func TestAuthenticate(t *testing.T) {
 	t.Run("Authorized tokens must be able to pass authn verification", func(t *testing.T) {
 		authnSetup := SetupMiddleware()
 		token := GenerateSecureToken(10)
-		SetupToken(t, authnSetup.FakeDatabase, token, uuid.New())
+		SetupToken(t, authnSetup.FakeDatabase, uuid.New(), token, td1)
 
 		authorized, err := authnSetup.Middleware.Authenticate(token, authnSetup.EchoCtx)
 		assert.NoError(t, err)

pkg/server/endpoints/const_test.go

@@ -1,5 +1,7 @@
 package endpoints
 
 const (
-	testTrustDomain = "test.com"
+	td1 = "test1.com"
+	td2 = "test2.com"
+	td3 = "test3.com"
 )

pkg/server/endpoints/harvester.go

@@ -116,7 +116,7 @@ func (h HarvesterAPIHandlers) BundlePut(ctx echo.Context, trustDomainName api.Tr
 		return h.handleErrorAndLog(err, http.StatusInternalServerError)
 	}
 
-	if err = chttp.BodylessResponse(ctx); err != nil {
+	if err = chttp.BodilessResponse(ctx, http.StatusOK); err != nil {
 		return h.handleErrorAndLog(err, http.StatusInternalServerError)
 	}
 

pkg/server/endpoints/harvester_test.go

@@ -3,6 +3,7 @@ package endpoints
 import (
 	"context"
 	"encoding/json"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -23,9 +24,16 @@ type HarvesterTestSetup struct {
 	Recorder *httptest.ResponseRecorder
 }
 
-func NewHarvesterTestSetup(method, url, body string) *HarvesterTestSetup {
+func NewHarvesterTestSetup(t *testing.T, method, url string, body interface{}) *HarvesterTestSetup {
+	var bodyReader io.Reader
+	if body != nil {
+		bodyStr, err := json.Marshal(body)
+		assert.NoError(t, err)
+		bodyReader = strings.NewReader(string(bodyStr))
+	}
+
 	e := echo.New()
-	req := httptest.NewRequest(method, url, strings.NewReader(body))
+	req := httptest.NewRequest(method, url, bodyReader)
 	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
 	rec := httptest.NewRecorder()
 	fakeDB := datastore.NewFakeDB()
@@ -39,7 +47,7 @@ func NewHarvesterTestSetup(method, url, body string) *HarvesterTestSetup {
 }
 
 func SetupTrustDomain(t *testing.T, ds datastore.Datastore) (*entity.TrustDomain, error) {
-	td, err := spiffeid.TrustDomainFromString(testTrustDomain)
+	td, err := spiffeid.TrustDomainFromString(td1)
 	assert.NoError(t, err)
 
 	tdEntity := &entity.TrustDomain{
@@ -67,18 +75,15 @@ func TestTCPBundleSync(t *testing.T) {
 }
 
 func TestTCPBundlePut(t *testing.T) {
-	t.Run("Succesfully register bundles for a trust domain", func(t *testing.T) {
+	t.Run("Successfully register bundles for a trust domain", func(t *testing.T) {
 		bundlePut := harvester.BundlePut{
 			Signature:          "",
 			SigningCertificate: "",
 			TrustBundle:        "a new bundle",
-			TrustDomain:        testTrustDomain,
+			TrustDomain:        td1,
 		}
 
-		body, err := json.Marshal(bundlePut)
-		assert.NoError(t, err)
-
-		harvesterTestSetup := NewHarvesterTestSetup(http.MethodPut, "/trust-domain/:trustDomainName/bundles", string(body))
+		harvesterTestSetup := NewHarvesterTestSetup(t, http.MethodPut, "/trust-domain/:trustDomainName/bundles", bundlePut)
 		echoCtx := harvesterTestSetup.EchoCtx
 
 		// Creating Trust Domain
@@ -87,12 +92,12 @@ func TestTCPBundlePut(t *testing.T) {
 
 		// Creating Auth token to bypass AuthN layer
 		token := GenerateSecureToken(10)
-		jt := SetupToken(t, harvesterTestSetup.Handler.Datastore, token, td.ID.UUID)
+		jt := SetupToken(t, harvesterTestSetup.Handler.Datastore, td.ID.UUID, token, td.Name.String())
 		assert.NoError(t, err)
 		echoCtx.Set(tokenKey, jt)
 
 		// Test Main Objective
-		err = harvesterTestSetup.Handler.BundlePut(echoCtx, testTrustDomain)
+		err = harvesterTestSetup.Handler.BundlePut(echoCtx, td1)
 		assert.NoError(t, err)
 
 		recorder := harvesterTestSetup.Recorder