Add tests for relayapi http endpoints

relayapi/relayapi.go

@@ -16,9 +16,7 @@ package relayapi
 
 import (
 	"github.com/gorilla/mux"
-	federationAPI "github.com/matrix-org/dendrite/federationapi/api"
 	"github.com/matrix-org/dendrite/federationapi/producers"
-	keyserverAPI "github.com/matrix-org/dendrite/keyserver/api"
 	"github.com/matrix-org/dendrite/relayapi/api"
 	"github.com/matrix-org/dendrite/relayapi/internal"
 	"github.com/matrix-org/dendrite/relayapi/inthttp"
@@ -26,7 +24,6 @@ import (
 	"github.com/matrix-org/dendrite/relayapi/storage"
 	rsAPI "github.com/matrix-org/dendrite/roomserver/api"
 	"github.com/matrix-org/dendrite/setup/base"
-	userapi "github.com/matrix-org/dendrite/userapi/api"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/sirupsen/logrus"
 )
@@ -40,13 +37,8 @@ func AddInternalRoutes(router *mux.Router, intAPI api.RelayInternalAPI) {
 // AddPublicRoutes sets up and registers HTTP handlers on the base API muxes for the FederationAPI component.
 func AddPublicRoutes(
 	base *base.BaseDendrite,
-	userAPI userapi.UserInternalAPI,
-	fedClient *gomatrixserverlib.FederationClient,
 	keyRing gomatrixserverlib.JSONVerifier,
-	rsAPI rsAPI.FederationRoomserverAPI,
 	relayAPI api.RelayInternalAPI,
-	fedAPI federationAPI.FederationInternalAPI,
-	keyAPI keyserverAPI.FederationKeyAPI,
 ) {
 	fedCfg := &base.Cfg.FederationAPI
 

relayapi/relayapi_test.go

@@ -29,13 +29,7 @@ func TestCreateNewRelayInternalAPI(t *testing.T) {
 		base, close := testrig.CreateBaseDendrite(t, dbType)
 		defer close()
 
-		relayAPI := relayapi.NewRelayInternalAPI(
-			base,
-			nil,
-			nil,
-			nil,
-			nil,
-		)
+		relayAPI := relayapi.NewRelayInternalAPI(base, nil, nil, nil, nil)
 		assert.NotNil(t, relayAPI)
 	})
 }
@@ -51,13 +45,7 @@ func TestCreateRelayInternalInvalidDatabasePanics(t *testing.T) {
 		defer close()
 
 		assert.Panics(t, func() {
-			relayapi.NewRelayInternalAPI(
-				base,
-				nil,
-				nil,
-				nil,
-				nil,
-			)
+			relayapi.NewRelayInternalAPI(base, nil, nil, nil, nil)
 		})
 	})
 }
@@ -67,13 +55,7 @@ func TestCreateRelayInternalRoutes(t *testing.T) {
 	base.Cfg.RelayAPI.InternalAPI.Connect = config.HTTPAddress("http://localhost:8008")
 	defer close()
 
-	relayAPI := relayapi.NewRelayInternalAPI(
-		base,
-		nil,
-		nil,
-		nil,
-		nil,
-	)
+	relayAPI := relayapi.NewRelayInternalAPI(base, nil, nil, nil, nil)
 	assert.NotNil(t, relayAPI)
 
 	relayapi.AddInternalRoutes(base.InternalAPIMux, &relayAPI)
@@ -85,24 +67,17 @@ func TestCreateInvalidRelayPublicRoutesPanics(t *testing.T) {
 		defer close()
 
 		assert.Panics(t, func() {
-			relayapi.AddPublicRoutes(base, nil, nil, nil, nil, nil, nil, nil)
+			relayapi.AddPublicRoutes(base, nil, nil)
 		})
 	})
 }
 
 func TestCreateRelayPublicRoutes(t *testing.T) {
 	base, close := testrig.CreateBaseDendrite(t, test.DBTypeSQLite)
-	base.Cfg.RelayAPI.InternalAPI.Connect = config.HTTPAddress("http://localhost:8008")
 	defer close()
 
-	relayAPI := relayapi.NewRelayInternalAPI(
-		base,
-		nil,
-		nil,
-		nil,
-		nil,
-	)
+	relayAPI := relayapi.NewRelayInternalAPI(base, nil, nil, nil, nil)
 	assert.NotNil(t, relayAPI)
 
-	relayapi.AddPublicRoutes(base, nil, nil, nil, nil, &relayAPI, nil, nil)
+	relayapi.AddPublicRoutes(base, nil, &relayAPI)
 }

relayapi/routing/routing.go

@@ -29,6 +29,11 @@ import (
 	"github.com/matrix-org/util"
 )
 
+const (
+	ForwardAsyncRouteName = "ForwardAsync"
+	AsyncEventsRouteName  = "AsyncEvents"
+)
+
 // Setup registers HTTP handlers with the given ServeMux.
 // The provided publicAPIMux MUST have `UseEncodedPath()` enabled or else routes will incorrectly
 // path unescape twice (once from the router, once from MakeRelayAPI). We need to have this enabled
@@ -60,7 +65,7 @@ func Setup(
 				*userID,
 			)
 		},
-	)).Methods(http.MethodPut, http.MethodOptions)
+	)).Methods(http.MethodPut, http.MethodOptions).Name(ForwardAsyncRouteName)
 
 	v1fedmux.Handle("/async_events/{userID}", MakeRelayAPI(
 		"relay_async_events", "", cfg.Matrix.IsLocalServerName, keys,
@@ -74,7 +79,7 @@ func Setup(
 			}
 			return GetAsyncEvents(httpReq, request, relayAPI, *userID)
 		},
-	)).Methods(http.MethodGet, http.MethodOptions)
+	)).Methods(http.MethodGet, http.MethodOptions).Name(AsyncEventsRouteName)
 }
 
 // MakeRelayAPI makes an http.Handler that checks matrix relay authentication.

relayapi/routing/routing_test.go

@@ -0,0 +1,207 @@
+// Copyright 2022 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package routing_test
+
+import (
+	"crypto/ed25519"
+	"encoding/hex"
+	"encoding/json"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gorilla/mux"
+	"github.com/matrix-org/dendrite/cmd/dendrite-demo-yggdrasil/signing"
+	"github.com/matrix-org/dendrite/internal/httputil"
+	"github.com/matrix-org/dendrite/relayapi"
+	"github.com/matrix-org/dendrite/relayapi/routing"
+	"github.com/matrix-org/dendrite/setup/config"
+	"github.com/matrix-org/dendrite/test"
+	"github.com/matrix-org/dendrite/test/testrig"
+	"github.com/matrix-org/gomatrixserverlib"
+	"github.com/stretchr/testify/assert"
+)
+
+type forwardAsyncContent struct {
+	PDUs []json.RawMessage       `json:"pdus"`
+	EDUs []gomatrixserverlib.EDU `json:"edus"`
+}
+
+func TestHandleForwardAsync(t *testing.T) {
+	base, close := testrig.CreateBaseDendrite(t, test.DBTypeSQLite)
+	defer close()
+
+	fedMux := mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicFederationPathPrefix).Subrouter().UseEncodedPath()
+	cfg := config.FederationAPI{
+		Matrix: &config.Global{
+			SigningIdentity: gomatrixserverlib.SigningIdentity{
+				ServerName: "relay",
+			},
+		},
+	}
+	relayAPI := relayapi.NewRelayInternalAPI(base, nil, nil, nil, nil)
+	serverKeyAPI := &signing.YggdrasilKeys{}
+	keyRing := serverKeyAPI.KeyRing()
+	routing.Setup(fedMux, &cfg, &relayAPI, keyRing)
+
+	handler := fedMux.Get(routing.ForwardAsyncRouteName).GetHandler().ServeHTTP
+	_, sk, _ := ed25519.GenerateKey(nil)
+	keyID := signing.KeyID
+	pk := sk.Public().(ed25519.PublicKey)
+	serverName := gomatrixserverlib.ServerName(hex.EncodeToString(pk))
+	req := gomatrixserverlib.NewFederationRequest("PUT", serverName, "remote", "/forward_async/1234/@user:local")
+	content := forwardAsyncContent{}
+	err := req.SetContent(content)
+	if err != nil {
+		t.Fatalf("Error: %s", err.Error())
+	}
+	req.Sign(serverName, gomatrixserverlib.KeyID(keyID), sk)
+	httpReq, err := req.HTTPRequest()
+	if err != nil {
+		t.Fatalf("Error: %s", err.Error())
+	}
+	vars := map[string]string{"userID": "@user:local", "txnID": "1234"}
+	w := httptest.NewRecorder()
+	httpReq = mux.SetURLVars(httpReq, vars)
+	handler(w, httpReq)
+
+	res := w.Result()
+	assert.Equal(t, 200, res.StatusCode)
+}
+
+func TestHandleForwardAsyncBadUserID(t *testing.T) {
+	base, close := testrig.CreateBaseDendrite(t, test.DBTypeSQLite)
+	defer close()
+
+	fedMux := mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicFederationPathPrefix).Subrouter().UseEncodedPath()
+	cfg := config.FederationAPI{
+		Matrix: &config.Global{
+			SigningIdentity: gomatrixserverlib.SigningIdentity{
+				ServerName: "relay",
+			},
+		},
+	}
+	relayAPI := relayapi.NewRelayInternalAPI(base, nil, nil, nil, nil)
+	serverKeyAPI := &signing.YggdrasilKeys{}
+	keyRing := serverKeyAPI.KeyRing()
+	routing.Setup(fedMux, &cfg, &relayAPI, keyRing)
+
+	handler := fedMux.Get(routing.ForwardAsyncRouteName).GetHandler().ServeHTTP
+	_, sk, _ := ed25519.GenerateKey(nil)
+	keyID := signing.KeyID
+	pk := sk.Public().(ed25519.PublicKey)
+	serverName := gomatrixserverlib.ServerName(hex.EncodeToString(pk))
+	req := gomatrixserverlib.NewFederationRequest("PUT", serverName, "remote", "/forward_async/1234/user")
+	content := forwardAsyncContent{}
+	err := req.SetContent(content)
+	if err != nil {
+		t.Fatalf("Error: %s", err.Error())
+	}
+	req.Sign(serverName, gomatrixserverlib.KeyID(keyID), sk)
+	httpReq, err := req.HTTPRequest()
+	if err != nil {
+		t.Fatalf("Error: %s", err.Error())
+	}
+	vars := map[string]string{"userID": "user", "txnID": "1234"}
+	w := httptest.NewRecorder()
+	httpReq = mux.SetURLVars(httpReq, vars)
+	handler(w, httpReq)
+
+	res := w.Result()
+	assert.NotEqual(t, 200, res.StatusCode)
+}
+
+func TestHandleAsyncEvents(t *testing.T) {
+	base, close := testrig.CreateBaseDendrite(t, test.DBTypeSQLite)
+	defer close()
+
+	fedMux := mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicFederationPathPrefix).Subrouter().UseEncodedPath()
+	cfg := config.FederationAPI{
+		Matrix: &config.Global{
+			SigningIdentity: gomatrixserverlib.SigningIdentity{
+				ServerName: "relay",
+			},
+		},
+	}
+	relayAPI := relayapi.NewRelayInternalAPI(base, nil, nil, nil, nil)
+	serverKeyAPI := &signing.YggdrasilKeys{}
+	keyRing := serverKeyAPI.KeyRing()
+	routing.Setup(fedMux, &cfg, &relayAPI, keyRing)
+
+	handler := fedMux.Get(routing.AsyncEventsRouteName).GetHandler().ServeHTTP
+	_, sk, _ := ed25519.GenerateKey(nil)
+	keyID := signing.KeyID
+	pk := sk.Public().(ed25519.PublicKey)
+	serverName := gomatrixserverlib.ServerName(hex.EncodeToString(pk))
+	req := gomatrixserverlib.NewFederationRequest("GET", serverName, "remote", "/async_events/@user:local")
+	content := gomatrixserverlib.RelayEntry{EntryID: 0}
+	err := req.SetContent(content)
+	if err != nil {
+		t.Fatalf("Error: %s", err.Error())
+	}
+	req.Sign(serverName, gomatrixserverlib.KeyID(keyID), sk)
+	httpReq, err := req.HTTPRequest()
+	if err != nil {
+		t.Fatalf("Error: %s", err.Error())
+	}
+	vars := map[string]string{"userID": "@user:local"}
+	w := httptest.NewRecorder()
+	httpReq = mux.SetURLVars(httpReq, vars)
+	handler(w, httpReq)
+
+	res := w.Result()
+	assert.Equal(t, 200, res.StatusCode)
+}
+
+func TestHandleAsyncEventsBadUserID(t *testing.T) {
+	base, close := testrig.CreateBaseDendrite(t, test.DBTypeSQLite)
+	defer close()
+
+	fedMux := mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicFederationPathPrefix).Subrouter().UseEncodedPath()
+	cfg := config.FederationAPI{
+		Matrix: &config.Global{
+			SigningIdentity: gomatrixserverlib.SigningIdentity{
+				ServerName: "relay",
+			},
+		},
+	}
+	relayAPI := relayapi.NewRelayInternalAPI(base, nil, nil, nil, nil)
+	serverKeyAPI := &signing.YggdrasilKeys{}
+	keyRing := serverKeyAPI.KeyRing()
+	routing.Setup(fedMux, &cfg, &relayAPI, keyRing)
+
+	handler := fedMux.Get(routing.AsyncEventsRouteName).GetHandler().ServeHTTP
+	_, sk, _ := ed25519.GenerateKey(nil)
+	keyID := signing.KeyID
+	pk := sk.Public().(ed25519.PublicKey)
+	serverName := gomatrixserverlib.ServerName(hex.EncodeToString(pk))
+	req := gomatrixserverlib.NewFederationRequest("GET", serverName, "remote", "/async_events/user")
+	content := gomatrixserverlib.RelayEntry{EntryID: 0}
+	err := req.SetContent(content)
+	if err != nil {
+		t.Fatalf("Error: %s", err.Error())
+	}
+	req.Sign(serverName, gomatrixserverlib.KeyID(keyID), sk)
+	httpReq, err := req.HTTPRequest()
+	if err != nil {
+		t.Fatalf("Error: %s", err.Error())
+	}
+	vars := map[string]string{"userID": "user"}
+	w := httptest.NewRecorder()
+	httpReq = mux.SetURLVars(httpReq, vars)
+	handler(w, httpReq)
+
+	res := w.Result()
+	assert.NotEqual(t, 200, res.StatusCode)
+}

setup/monolith.go

@@ -75,8 +75,7 @@ func (m *Monolith) AddAllPublicRoutes(base *base.BaseDendrite) {
 		base, m.UserAPI, m.RoomserverAPI, m.KeyAPI,
 	)
 
-	// TODO : relayapi.AddPublicRoutes
 	if m.RelayAPI != nil {
-		relayapi.AddPublicRoutes(base, m.UserAPI, m.FedClient, m.KeyRing, m.RoomserverAPI, m.RelayAPI, m.FederationAPI, m.KeyAPI)
+		relayapi.AddPublicRoutes(base, m.KeyRing, m.RelayAPI)
 	}
 }