up

internal/app/games_permissions_test.go

@@ -0,0 +1,96 @@
+package app
+
+import (
+	"context"
+	"reflect"
+	"testing"
+	"time"
+
+	"evening_detective_server/internal/modules/processor_jwt"
+	"evening_detective_server/internal/services/game_model"
+	main "evening_detective_server/proto"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+func TestGameReadAccess(t *testing.T) {
+	for _, tc := range []struct {
+		name                string
+		venue               bool
+		roles               []string
+		allowed, restricted bool
+	}{
+		{"developer venue", true, []string{"developer"}, true, true},
+		{"developer prod", false, []string{"developer"}, false, false},
+		{"user venue", true, []string{"user"}, false, false},
+		{"developer organizer", true, []string{"developer", "organizer"}, true, false},
+		{"developer author", true, []string{"developer", "author"}, true, false},
+		{"admin prod", false, []string{"admin"}, true, false},
+		{"organizer prod", false, []string{"organizer"}, true, false},
+		{"author prod", false, []string{"author"}, true, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			allowed, restricted := gameReadAccess(&processor_jwt.JWTClaims{Roles: tc.roles}, tc.venue)
+			if allowed != tc.allowed || restricted != tc.restricted {
+				t.Fatalf("access = %v, %v", allowed, restricted)
+			}
+		})
+	}
+}
+
+func TestGameSummaryExcludesPrivateFields(t *testing.T) {
+	for _, location := range []*string{nil, ptrGameLocation("venue")} {
+		t.Run("summary", func(t *testing.T) {
+			game := &game_model.Game{ID: 7, Name: "name", Description: "description", Format: "offline", Location: location, StartAt: time.Unix(123, 0), Status: "started"}
+			// Populate every non-summary field to catch accidental exposure when the model grows.
+			value := reflect.ValueOf(game).Elem()
+			for i := 0; i < value.NumField(); i++ {
+				field := value.Field(i)
+				if field.Kind() == reflect.Pointer && field.IsNil() && value.Type().Field(i).Name != "Location" {
+					field.Set(reflect.New(field.Type().Elem()))
+				}
+				if field.Kind() == reflect.Slice {
+					field.Set(reflect.MakeSlice(field.Type(), 1, 1))
+				}
+			}
+			want := &main.Game{ID: 7, Name: "name", Description: "description", Format: "offline", StartAt: timestamppb.New(game.StartAt), Status: "started"}
+			if location != nil {
+				want.Location = *location
+			}
+			if !proto.Equal(mapGameSummary(game), want) {
+				t.Fatal("summary exposes private fields or loses public fields")
+			}
+		})
+	}
+}
+
+func ptrGameLocation(value string) *string { return &value }
+
+func TestDeveloperCannotManageGames(t *testing.T) {
+	s := &server{}
+	ctx := processor_jwt.ContextWithClaims(context.Background(), &processor_jwt.JWTClaims{Roles: []string{"developer"}})
+	for _, tc := range []struct {
+		name string
+		call func() error
+	}{
+		{"add", func() error { _, err := s.AddGame(ctx, &main.AddGameReq{}); return err }},
+		{"update", func() error { _, err := s.UpdateGame(ctx, &main.UpdateGameReq{}); return err }},
+		{"delete", func() error { _, err := s.DeleteGame(ctx, &main.DeleteGameReq{}); return err }},
+		{"start", func() error { _, err := s.StartGame(ctx, &main.StartGameReq{}); return err }},
+		{"pause", func() error { _, err := s.PauseGame(ctx, &main.PauseGameReq{}); return err }},
+		{"play", func() error { _, err := s.PlayGame(ctx, &main.PlayGameReq{}); return err }},
+		{"finish", func() error { _, err := s.FinishGame(ctx, &main.FinishGameReq{}); return err }},
+		{"reset", func() error { _, err := s.ResetGame(ctx, &main.ResetGameReq{}); return err }},
+		{"answers", func() error { _, err := s.GetGameAnswers(ctx, &main.GetGameAnswersReq{}); return err }},
+		{"results", func() error { _, err := s.GetGameResults(ctx, &main.GetGameResultsReq{}); return err }},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if err := tc.call(); status.Code(err) != codes.PermissionDenied {
+				t.Fatal(err)
+			}
+		})
+	}
+}