grpc_server_test.go

/*
 * Copyright (C) 2023-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.
 */

package mock

import (
	"context"
	pb "fachstellen-proxy/gen/go"
	"fmt"
	"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() {
				conn.Close()
			}
			client := pb.NewFachstelleRegistrationServiceClient(conn)

			return client, cleanUp
		}

		t.Run("should have no error", func(t *testing.T) {
			client, cleanUp := setUpGrpcEnv()
			defer cleanUp()

			resp, err := client.Register(context.Background(), &pb.GrpcFachstelleRegistrationRequest{MukId: "testMukId"})

			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.Register(context.Background(), &pb.GrpcFachstelleRegistrationRequest{})

			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)
		})
	})
}