Merge pull request 'feature/OZG-6514-anbindung-collaboration-manager' (#9)...

Merge pull request 'feature/OZG-6514-anbindung-collaboration-manager' (#9) from feature/OZG-6514-anbindung-collaboration-manager into master

Reviewed-on: https://git.ozg-sh.de/ozgcloud-app/fachstellen-proxy/pulls/9


Reviewed-by: OZGCloud <ozgcloud@mgm-tp.com>

README.md

 # Fachstellen-Proxy
 
+Der Fachstellen-Proxy nimmt HTTP Requests von der Fachstelle entgegen, mappt diese auf gRPC
+und leitet sie an den Zufi- (Fachstellenregistrierung) bzw. Collaboration-Manager
+(Fachstellenbeteiligung) weiter. Zum Protokollmapping von HTTP auf gRPC wird die Bibliothek 
+[gRPC-Gateway](https://grpc-ecosystem.github.io/grpc-gateway/) verwendet. Dadurch können
+die HTTP-Endpunkte inkl. des Mappings größtenteils automatisch aus proto-Dateien generiert werden.
+
+Requests zur Fachstellenregistrierung werden an die unter config.grpc.registration.server.url
+eingetragene URL (bzw. localhost:50052, wenn config.grpc.mock = true) weitergeleitet.
+
+Requests zur Fachstellenbeteiligung (z.B. FindVorgang) werden zunächst an den CollaborationRouter
+weitergeleitet. Das ist ein Proxy-eigener gRPC-Server, der auf localhost und dem unter
+config.grpc.collaboration.router.port eingetragenen Port läuft. Dort wird die Adresse des
+Ziel-Collaboration-Managers aus dem Requestpayload (z.B. aus der VorgangId) extrahiert. Der Port
+des Ziel-Collaboration-Managers ist konstant und wird unter config.grpc.collaboration.server.port
+festgelegt (bzw. auf 50052 gesetzt, wenn config.grpc.mock = true). Anschließend leitet der 
+CollaborationRouter die gRPC Request an die URL weiter, die aus der extrahierten Adresse und dem 
+Port zusammengesetzt wird.
+
 ## Getting Started
 
 ### Dependencies installieren
@@ -37,11 +55,19 @@ go run cmd/fachstellen-proxy/main.go
 [Config-Datei](./config/config.yml)
 
 ```
+http:
   server:
-  port: Port des HTTP Servers (int)
+    port: Port des HTTP Gateways (int)
 grpc:
-  mock: lokalen gRPC Server mocken (bool)
-  url: URL des Ziel-gRPC-Servers im host:port Format (string)
+  mock: gRPC Registration und Collaboration Server mocken (bool)
+  collaboration:
+    server:
+      port: Port des gRPC Collaboration Servers (int)
+    router: 
+      port: Port des gRPC Collaboration Routers (int)
+  registration:
+    server:
+      url: URL des gRPC Registration Servers im host:port Format (string)
 logging:
   level: "ERROR" | "WARN" | "INFO" | "DEBUG"
 ```
\ No newline at end of file

api/gateway-config.yml

@@ -3,6 +3,8 @@ config_version: 3
 
 http:
   rules:
-    - selector: de.ozgcloud.zufi.grpc.fachstelle.FachstelleRegistrationService.Register
+    - selector: de.ozgcloud.fachstellenproxy.FachstelleRegistrationService.Register
       post: /api/fachstellen
       body: "*"
+    - selector: de.ozgcloud.fachstellenproxy.CollaborationService.FindVorgang
+      get: /api/vorgang/{vorgangId}/{samlToken}

api/openapi-config.yml

+openapiOptions:
+  file:
+    - file: "fachstelleregistration.proto"
+      option:
+        info:
+          title: Fachstelleregistration Proxy API
+          license:
+            name: EUPL 1.2
+            url: https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+          version: "1.0"
+        schemes:
+          - HTTP
+          - HTTPS
+        consumes:
+          - application/json
+        produces:
+          - application/json
+        responses:
+          "400":
+            description: Returned when the request payload is not suitable.
+            schema:
+              jsonSchema:
+                type:
+                  - STRING
+    - file: "collaboration.proto"
+      option:
+        info:
+          title: Collaboration Proxy API
+          license:
+            name: EUPL 1.2
+            url: https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+          version: "1.0"
+        schemes:
+          - HTTP
+          - HTTPS
+        consumes:
+          - application/json
+        produces:
+          - application/json
+        responses:
+          "403":
+            description: Returned when the user does not have permission to access the resource.
+          "404":
+            description: Returned when the resource does not exist.
+            schema:
+              jsonSchema:
+                type:
+                  - STRING
+  service:
+    - service: de.ozgcloud.fachstellenproxy.FachstelleRegistrationService
+      option:
+        description: "Service to proxy between Fachstelle and ZufiManager in OZG-Cloud"
+    - service: de.ozgcloud.fachstellenproxy.CollaborationService
+      option:
+        description: "Service to proxy between Fachstelle and CollaborationManager in OZG-Cloud"
+  method:
+    - method: de.ozgcloud.fachstellenproxy.FachstelleRegistrationService.Register
+      option:
+        description: "Register new fachstelle"
+        summary: "Summary: Register rpc"
+        responses:
+          "200":
+            description: Returns empty response
+          "400":
+            description: Returned when the request payload is not suitable.
+          "503":
+            description: Returned when the resource is temporarily unavailable.
+    - method: de.ozgcloud.fachstellenproxy.CollaborationService.FindVorgang
+      option:
+        description: "Find vorgang by its id"
+        summary: "Summary: FindVorgang rpc"
+        responses:
+          "200":
+            description: Returns the vorgang
+          "503":
+            description: Returned when the resource is temporarily unavailable.
+          "404":
+            description: Returned when the resource does not exist.
+    - method: de.ozgcloud.fachstellenproxy.CollaborationService.GetFileContent
+      option:
+        description: "Get file content by file id"
+        summary: "Summary: GetFileContent rpc"
+        responses:
+          "200":
+            description: Returns the file content
+          "503":
+            description: Returned when the resource is temporarily unavailable.
+          "404":
+            description: Returned when the resource does not exist.
\ No newline at end of file

api/proto/collaboration.model.proto

+/*
+ * Copyright (C) 2024 Das Land Schleswig-Holstein vertreten durch den
+ * Ministerpräsidenten des Landes Schleswig-Holstein
+ * Staatskanzlei
+ * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
+ *
+ * Lizenziert unter der EUPL, Version 1.2 oder - sobald
+ * diese von der Europäischen Kommission genehmigt wurden -
+ * Folgeversionen der EUPL ("Lizenz");
+ * Sie dürfen dieses Werk ausschließlich gemäß
+ * dieser Lizenz nutzen.
+ * Eine Kopie der Lizenz finden Sie hier:
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Sofern nicht durch anwendbare Rechtsvorschriften
+ * gefordert oder in schriftlicher Form vereinbart, wird
+ * die unter der Lizenz verbreitete Software "so wie sie
+ * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
+ * ausdrücklich oder stillschweigend - verbreitet.
+ * Die sprachspezifischen Genehmigungen und Beschränkungen
+ * unter der Lizenz sind dem Lizenztext zu entnehmen.
+ */
+
+syntax = "proto3";
+
+package de.ozgcloud.fachstellenproxy;
+
+option go_package = "de.ozgcloud.fachstellenproxy";
+
+message GrpcFindVorgangRequest {
+  string vorgangId = 1;
+  string samlToken = 2;
+}
+
+message GrpcFindVorgangResponse {
+  GrpcVorgang vorgang = 1;
+}
+
+message GrpcVorgang {
+  string id = 1;
+  int64 version = 2;
+  string vorgangName = 3;
+  string vorgangNummer = 4;
+
+  GrpcVorgangHeader header = 5;
+  GrpcEingang eingang = 6;
+  GrpcCollaborationRequest collaborationRequest = 7;
+}
+
+message GrpcVorgangHeader {
+  string createdAt = 1;
+  string aktenzeichen = 2;
+}
+
+message GrpcCollaborationRequest {
+  string title = 1;
+  string text = 2;
+}
+
+message GrpcEingang {
+  GrpcAntragsteller antragsteller = 1;
+
+  GrpcFormData formData = 2;
+
+  repeated GrpcFileGroup attachments = 3;
+  repeated GrpcFile representations = 4;
+}
+
+message GrpcFileGroup {
+  string name = 1;
+  repeated GrpcFile files = 2;
+}
+
+message GrpcFile {
+  string id = 1;
+  string vendorId = 2;
+  string name = 3;
+  string contentType = 4;
+  int64 size = 5;
+}
+
+message GrpcAntragsteller {
+  string firmaName = 1;
+  string anrede = 2;
+  string nachname = 3;
+  string vorname = 4;
+  string geburtsdatum = 5;
+  string geburtsort = 7;
+  string geburtsname = 8;
+  string email = 9;
+  string telefon = 10;
+  string strasse = 11;
+  string hausnummer = 12;
+  string plz = 13;
+  string ort = 14;
+
+  GrpcFormData otherData = 15;
+}
+
+message GrpcFormData {
+  repeated GrpcSubFormData formData = 1;
+}
+
+message GrpcSubForm {
+  string name = 1;
+  string label = 2;
+  repeated GrpcSubFormData formData = 3;
+}
+
+message GrpcSubFormData {
+  oneof data {
+    GrpcFormField field = 1;
+    GrpcSubForm form = 2;
+  }
+}
+
+message GrpcFormField {
+  string name = 1;
+  string label = 2;
+  string value = 3;
+}
+
+message GrpcGetFileContentRequest {
+  string samlToken = 1;
+  string id = 2;
+}
+
+message GrpcGetFileContentResponse {
+  bytes fileContent = 1;
+}
\ No newline at end of file

api/proto/collaboration.proto

+/*
+ * Copyright (C) 2024 Das Land Schleswig-Holstein vertreten durch den
+ * Ministerpräsidenten des Landes Schleswig-Holstein
+ * Staatskanzlei
+ * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
+ *
+ * Lizenziert unter der EUPL, Version 1.2 oder - sobald
+ * diese von der Europäischen Kommission genehmigt wurden -
+ * Folgeversionen der EUPL ("Lizenz");
+ * Sie dürfen dieses Werk ausschließlich gemäß
+ * dieser Lizenz nutzen.
+ * Eine Kopie der Lizenz finden Sie hier:
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Sofern nicht durch anwendbare Rechtsvorschriften
+ * gefordert oder in schriftlicher Form vereinbart, wird
+ * die unter der Lizenz verbreitete Software "so wie sie
+ * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
+ * ausdrücklich oder stillschweigend - verbreitet.
+ * Die sprachspezifischen Genehmigungen und Beschränkungen
+ * unter der Lizenz sind dem Lizenztext zu entnehmen.
+ */
+
+syntax = "proto3";
+
+package de.ozgcloud.fachstellenproxy;
+
+import "collaboration.model.proto";
+
+option go_package = "de.ozgcloud.fachstellenproxy";
+
+service CollaborationService {
+  rpc FindVorgang(GrpcFindVorgangRequest) returns (GrpcFindVorgangResponse);
+
+  rpc GetFileContent(GrpcGetFileContentRequest) returns (stream GrpcGetFileContentResponse);
+}
\ No newline at end of file

api/proto/fachstelleregistration.model.proto

@@ -25,9 +25,9 @@
 
 syntax = "proto3";
 
-package de.ozgcloud.zufi.grpc.fachstelle;
+package de.ozgcloud.fachstellenproxy;
 
-option go_package = "de.ozgcloud.zufi.grpc.fachstelle";
+option go_package = "de.ozgcloud.fachstellenproxy";
 
 message GrpcFachstelleRegistrationRequest {
   GrpcFachstelle fachstelle = 1;

api/proto/fachstelleregistration.proto

@@ -25,11 +25,11 @@
 
 syntax = "proto3";
 
-package de.ozgcloud.zufi.grpc.fachstelle;
+package de.ozgcloud.fachstellenproxy;
 
 import "fachstelleregistration.model.proto";
 
-option go_package = "de.ozgcloud.zufi.grpc.fachstelle";
+option go_package = "de.ozgcloud.fachstellenproxy";
 
 service FachstelleRegistrationService {
   rpc Register(GrpcFachstelleRegistrationRequest) returns (GrpcFachstelleRegistrationResponse);

buf.gen.yaml

@@ -15,3 +15,8 @@ plugins:
       - grpc_api_configuration=api/gateway-config.yml
   - plugin: openapiv2
     out: gen/openapiv2
+    opt:
+      - allow_merge=true
+      - merge_file_name=openapiv2.json
+      - grpc_api_configuration=api/gateway-config.yml
+      - openapi_configuration=api/openapi-config.yml
\ No newline at end of file

cmd/fachstellen-proxy/main.go

@@ -40,5 +40,6 @@ func main() {
 		go mock.StartGrpcServer()
 	}
 
-	server.StartHttpGateway(conf)
+	go server.StartCollaborationRouter()
+	server.StartHttpGateway()
 }

config/config.yml

+http:
   server:
     port: 8082
 grpc:
   mock: true
+  collaboration:
+    router:
+      port: 50051
 logging:
   level: "INFO"
\ No newline at end of file

internal/config/config.go

@@ -41,12 +41,26 @@ const (
 )
 
 type Config struct {
+	Http struct {
 		Server struct {
-		Port int `yaml:"port" envconfig:"SERVER_PORT"`
+			Port int `yaml:"port" envconfig:"HTTP_SERVER_PORT"`
 		} `yaml:"server"`
+	} `yaml:"http"`
 	Grpc struct {
 		Mock          bool `yaml:"mock" envconfig:"GRPC_MOCK"`
-		Url  string `yaml:"url" envconfig:"GRPC_URL"`
+		Collaboration struct {
+			Server struct {
+				Port int `yaml:"port" envconfig:"GRPC_COLLABORATION_SERVER_PORT"`
+			} `yaml:"server"`
+			Router struct {
+				Port int `yaml:"port" envconfig:"GRPC_COLLABORATION_ROUTER_PORT"`
+			} `yaml:"router"`
+		} `yaml:"collaboration"`
+		Registration struct {
+			Server struct {
+				Url string `yaml:"url" envconfig:"GRPC_REGISTRATION_SERVER_URL"`
+			} `yaml:"server"`
+		} `yaml:"registration"`
 	} `yaml:"grpc"`
 	Logging struct {
 		Level string `yaml:"level" envconfig:"LOGGING_LEVEL"`
@@ -78,8 +92,8 @@ func LoadConfig(configFilePath ...string) Config {
 		log.Fatalf("FATAL: error reading env: %v", err)
 	}
 
-	if len(config.Grpc.Url) > 0 && !ValidateGrpcUrl(config.Grpc.Url) {
-		log.Fatalf("FATAL: gRPC URL is not in host:port format")
+	if len(config.Grpc.Registration.Server.Url) > 0 && !ValidateGrpcUrl(config.Grpc.Registration.Server.Url) {
+		log.Fatalf("FATAL: gRPC Registration Server URL is not in host:port format")
 	}
 
 	return config

internal/config/config_test.go

@@ -37,8 +37,10 @@ func TestLoadConfig(t *testing.T) {
 		config := LoadConfig()
 
 		expectedConfig := Config{}
-		expectedConfig.Server.Port = 8080
-		expectedConfig.Grpc.Url = "localhost:50051"
+		expectedConfig.Http.Server.Port = 8080
+		expectedConfig.Grpc.Collaboration.Server.Port = 50052
+		expectedConfig.Grpc.Collaboration.Router.Port = 50051
+		expectedConfig.Grpc.Registration.Server.Url = "localhost:50052"
 		expectedConfig.Grpc.Mock = false
 		expectedConfig.Logging.Level = "DEBUG"
 
@@ -47,8 +49,10 @@ func TestLoadConfig(t *testing.T) {
 
 	t.Run("should load config from env", func(t *testing.T) {
 		envVars := map[string]string{
-			"SERVER_PORT":   "9090",
-			"GRPC_URL":      "localhost:99999",
+			"HTTP_SERVER_PORT":               "9090",
+			"GRPC_COLLABORATION_SERVER_PORT": "50052",
+			"GRPC_COLLABORATION_ROUTER_PORT": "50051",
+			"GRPC_REGISTRATION_SERVER_URL":   "localhost:99999",
 			"LOGGING_LEVEL":                  "ERROR",
 		}
 
@@ -63,8 +67,10 @@ func TestLoadConfig(t *testing.T) {
 		}
 
 		expectedConfig := Config{}
-		expectedConfig.Server.Port = 9090
-		expectedConfig.Grpc.Url = "localhost:99999"
+		expectedConfig.Http.Server.Port = 9090
+		expectedConfig.Grpc.Collaboration.Server.Port = 50052
+		expectedConfig.Grpc.Collaboration.Router.Port = 50051
+		expectedConfig.Grpc.Registration.Server.Url = "localhost:99999"
 		expectedConfig.Grpc.Mock = false
 		expectedConfig.Logging.Level = "ERROR"
 
@@ -72,15 +78,26 @@ func TestLoadConfig(t *testing.T) {
 	})
 
 	t.Run("should overwrite config with env", func(t *testing.T) {
-		assert.NoError(t, os.Setenv("SERVER_PORT", "9090"), "Setenv SERVER_PORT should not return an error")
+		envVars := map[string]string{
+			"HTTP_SERVER_PORT":             "9090",
+			"GRPC_REGISTRATION_SERVER_URL": "localhost:99999",
+		}
+
+		for key, value := range envVars {
+			assert.NoError(t, os.Setenv(key, value), "Setenv "+key+" should not return an error")
+		}
 
 		config := LoadConfig()
 
-		assert.NoError(t, os.Unsetenv("SERVER_PORT"), "Unsetenv SERVER_PORT should not return an error")
+		for key := range envVars {
+			assert.NoError(t, os.Unsetenv(key), "Unsetenv "+key+" should not return an error")
+		}
 
 		expectedConfig := Config{}
-		expectedConfig.Server.Port = 9090
-		expectedConfig.Grpc.Url = "localhost:50051"
+		expectedConfig.Http.Server.Port = 9090
+		expectedConfig.Grpc.Collaboration.Server.Port = 50052
+		expectedConfig.Grpc.Collaboration.Router.Port = 50051
+		expectedConfig.Grpc.Registration.Server.Url = "localhost:99999"
 		expectedConfig.Grpc.Mock = false
 		expectedConfig.Logging.Level = "DEBUG"
 

internal/config/testdata/test_config.yml

+http:
   server:
     port: 8080
 grpc:
-  url: "localhost:50051"
+  collaboration:
+    server:
+      port: 50052
+    router:
+      port: 50051
+  registration:
+    server:
+      url: "localhost:50052"
 logging:
   level: "DEBUG"
\ No newline at end of file

internal/logging/logger_test.go

@@ -28,21 +28,20 @@ package logging
 import (
 	"bytes"
 	"github.com/stretchr/testify/assert"
-	"log"
 	"testing"
 )
 
-func setUpLogger(t *testing.T, level string, msg string) *bytes.Buffer {
+func logMessage(level string, msg string) *bytes.Buffer {
 	logger := GetLogger()
 
 	var buf bytes.Buffer
 	logger.BaseLogger.SetOutput(&buf)
 
-	originalFlags := log.Flags()
-	t.Cleanup(func() {
-		log.SetOutput(nil)
-		log.SetFlags(originalFlags)
-	})
+	originalFlags := logger.BaseLogger.Flags()
+	defer func() {
+		logger.BaseLogger.SetOutput(nil)
+		logger.BaseLogger.SetFlags(originalFlags)
+	}()
 
 	if level == LogLevelError {
 		logger.Error(msg)
@@ -58,25 +57,25 @@ func setUpLogger(t *testing.T, level string, msg string) *bytes.Buffer {
 }
 
 func TestError(t *testing.T) {
-	buf := setUpLogger(t, LogLevelError, "test error")
-	logOutput := buf.String()
-	assert.Contains(t, logOutput, "ERROR: test error")
+	buf := logMessage(LogLevelError, "test error")
+
+	assert.Contains(t, buf.String(), "ERROR: test error")
 }
 
 func TestWarning(t *testing.T) {
-	buf := setUpLogger(t, LogLevelWarning, "test warning")
-	logOutput := buf.String()
-	assert.Contains(t, logOutput, "WARNING: test warning")
+	buf := logMessage(LogLevelWarning, "test warning")
+
+	assert.Contains(t, buf.String(), "WARNING: test warning")
 }
 
 func TestInfo(t *testing.T) {
-	buf := setUpLogger(t, LogLevelInfo, "test info")
-	logOutput := buf.String()
-	assert.Contains(t, logOutput, "INFO: test info")
+	buf := logMessage(LogLevelInfo, "test info")
+
+	assert.Contains(t, buf.String(), "INFO: test info")
 }
 
 func TestDebug(t *testing.T) {
-	buf := setUpLogger(t, LogLevelDebug, "test debug")
-	logOutput := buf.String()
-	assert.Empty(t, logOutput)
+	buf := logMessage(LogLevelDebug, "test debug")
+
+	assert.Empty(t, buf.String())
 }

internal/logging/testdata/test_config.yml

+http:
   server:
     port: 8080
 grpc:
-  url: "localhost:50051"
+  collaboration:
+    server:
+      port: 50052
+    router:
+      port: 50051
+  registration:
+    server:
+      url: "localhost:50052"
 logging:
   level: "INFO"
\ No newline at end of file

internal/mock/grpc_server.go

@@ -32,41 +32,104 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+	"io"
 	"net"
+	"os"
+	"testing"
 )
 
-const GrpcMockPort = 50051
+const (
+	GrpcMockPort    = 50052
+	defaultFilePath = "internal/mock/testdata/dummy.pdf"
+	testFilePath    = "testdata/dummy.pdf"
+)
 
-type server struct {
+type registrationServer struct {
 	pb.UnimplementedFachstelleRegistrationServiceServer
 }
 
-func (s *server) Register(ctx context.Context, in *pb.GrpcFachstelleRegistrationRequest) (*pb.GrpcFachstelleRegistrationResponse, error) {
+func (s *registrationServer) Register(_ context.Context, in *pb.GrpcFachstelleRegistrationRequest) (*pb.GrpcFachstelleRegistrationResponse, error) {
 	if in.Fachstelle == nil {
-		return nil, status.Error(codes.InvalidArgument, "Fachstelle is missing")
+		return nil, status.Error(codes.InvalidArgument, "fachstelle is missing")
 	}
 
 	if in.Fachstelle.MukId == "conflictMukId" {
-		return nil, status.Error(codes.AlreadyExists, "Conflict mukId")
+		return nil, status.Error(codes.AlreadyExists, "conflict MukId")
 	} else if in.Fachstelle.MukId == "unavailableMukId" {
-		return nil, status.Error(codes.Unavailable, "Unavailable mukId")
+		return nil, status.Error(codes.Unavailable, "unavailable MukId")
 	} else if in.Fachstelle.MukId == "erroneousMukId" {
-		return nil, status.Error(codes.Internal, "Erroneous mukId")
+		return nil, status.Error(codes.Internal, "erroneous MukId")
 	}
 
 	return &pb.GrpcFachstelleRegistrationResponse{}, nil
 }
 
+type collaborationServer struct {
+	pb.UnimplementedCollaborationServiceServer
+}
+
+func (s *collaborationServer) FindVorgang(_ context.Context, in *pb.GrpcFindVorgangRequest) (*pb.GrpcFindVorgangResponse, error) {
+	if in.VorgangId == "" {
+		return nil, status.Error(codes.InvalidArgument, "vorgangId is missing")
+	}
+
+	if in.SamlToken == "" {
+		return nil, status.Error(codes.InvalidArgument, "samlToken is missing")
+	}
+
+	return &pb.GrpcFindVorgangResponse{Vorgang: &pb.GrpcVorgang{Id: "testVorgangId"}}, nil
+}
+
+func (s *collaborationServer) GetFileContent(in *pb.GrpcGetFileContentRequest, stream pb.CollaborationService_GetFileContentServer) error {
+	if in.Id == "" {
+		return status.Error(codes.InvalidArgument, "fileId is missing")
+	}
+
+	if in.SamlToken == "" {
+		return status.Error(codes.InvalidArgument, "samlToken is missing")
+	}
+
+	fp := defaultFilePath
+	if testing.Testing() {
+		fp = testFilePath
+	}
+
+	file, err := os.Open(fp)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	buffer := make([]byte, 1024*1024)
+	for {
+		bytesRead, err := file.Read(buffer)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		chunk := &pb.GrpcGetFileContentResponse{FileContent: buffer[:bytesRead]}
+		if err := stream.Send(chunk); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func StartGrpcServer() *grpc.Server {
 	s := grpc.NewServer()
-	pb.RegisterFachstelleRegistrationServiceServer(s, &server{})
+	pb.RegisterFachstelleRegistrationServiceServer(s, &registrationServer{})
+	pb.RegisterCollaborationServiceServer(s, &collaborationServer{})
 
 	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", GrpcMockPort))
 	if err != nil {
 		logger.Fatal("gRPC server failed to listen: %v", err)
 	}
 
-	logger.Info("gRPC server listening on port %v", GrpcMockPort)
+	logger.Info("gRPC server listening on port %d", GrpcMockPort)
 	if err := s.Serve(lis); err != nil {
 		logger.Fatal("gRPC server failed to serve: %v", err)
 	}

internal/mock/grpc_server_test.go

@@ -32,22 +32,35 @@ import (
 	"github.com/stretchr/testify/assert"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
+	"net"
 	"testing"
+	"time"
 )
 
 func TestStartGrpcServer(t *testing.T) {
+	t.Run("should start gRPC server", func(t *testing.T) {
+		SetUpGrpcServer()
+
+		conn, err := net.DialTimeout("tcp", fmt.Sprintf("localhost:%d", GrpcMockPort), 2*time.Second)
+
+		assert.NoError(t, err)
+
+		conn.Close()
+	})
+
+	t.Run("TestFachstelleRegistrationEndpoints", func(t *testing.T) {
 		setUpGrpcEnv := func() (pb.FachstelleRegistrationServiceClient, func()) {
 			SetUpGrpcServer()
 
 			conn, err := grpc.NewClient(fmt.Sprintf("localhost:%d", GrpcMockPort), grpc.WithTransportCredentials(insecure.NewCredentials()))
 			assert.NoError(t, err)
 
-		cleanup := func() {
+			cleanUp := func() {
 				conn.Close()
 			}
 			client := pb.NewFachstelleRegistrationServiceClient(conn)
 
-		return client, cleanup
+			return client, cleanUp
 		}
 
 		t.Run("should have no error", func(t *testing.T) {
@@ -69,4 +82,53 @@ func TestStartGrpcServer(t *testing.T) {
 			assert.Error(t, err)
 			assert.Nil(t, resp)
 		})
+	})
+
+	t.Run("TestCollaborationEndpoints", func(t *testing.T) {
+		setUpGrpcEnv := func() (pb.CollaborationServiceClient, func()) {
+			SetUpGrpcServer()
+
+			conn, err := grpc.NewClient(fmt.Sprintf("localhost:%d", GrpcMockPort), grpc.WithTransportCredentials(insecure.NewCredentials()))
+			assert.NoError(t, err)
+
+			cleanup := func() {
+				conn.Close()
+			}
+			client := pb.NewCollaborationServiceClient(conn)
+
+			return client, cleanup
+		}
+
+		t.Run("TestFindVorgang", func(t *testing.T) {
+			t.Run("should have no error", func(t *testing.T) {
+				client, cleanUp := setUpGrpcEnv()
+				defer cleanUp()
+
+				resp, err := client.FindVorgang(context.Background(), &pb.GrpcFindVorgangRequest{VorgangId: "testVorgangId", SamlToken: "testSamlToken"})
+
+				assert.NoError(t, err)
+				assert.NotNil(t, resp)
+			})
+
+			t.Run("should have error", func(t *testing.T) {
+				client, cleanUp := setUpGrpcEnv()
+				defer cleanUp()
+
+				resp, err := client.FindVorgang(context.Background(), &pb.GrpcFindVorgangRequest{})
+
+				assert.Error(t, err)
+				assert.Nil(t, resp)
+			})
+		})
+
+		t.Run("TestGetFileContent", func(t *testing.T) {
+			client, cleanUp := setUpGrpcEnv()
+			defer cleanUp()
+
+			resp, err := client.GetFileContent(context.Background(), &pb.GrpcGetFileContentRequest{})
+
+			assert.NoError(t, err)
+			assert.NotNil(t, resp)
+		})
+	})
 }

internal/mock/testdata/test_config.yml

+http:
   server:
     port: 8080
 grpc:
-  url: "localhost:50051"
+  collaboration:
+    server:
+      port: 50052
+    router:
+      port: 50051
+  registration:
+    server:
+      url: "localhost:50052"
 logging:
   level: "DEBUG"
\ No newline at end of file

internal/server/globals.go

 package server
 
-import "fachstellen-proxy/internal/logging"
+import (
+	"fachstellen-proxy/internal/config"
+	"fachstellen-proxy/internal/logging"
+)
 
+const (
+	GrpcAddressHeader   = "X-Grpc-Address"
+	GrpcAddressMetadata = "x-grpc-address"
+)
+
+var conf = config.LoadConfig()
 var logger = logging.GetLogger()