Remove authorization from Unsubscribe request

Author: exanubes

e2e/e2e_test.go

@@ -5,6 +5,7 @@ package e2e_test
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"testing"
@@ -144,6 +145,60 @@ func TestAppSyncAuthorizers(t *testing.T) {
 	}
 }
 
+func TestSuccessfulUnsubscribe(t *testing.T) {
+	http_endpoint := require_env(t, "APPSYNC_E2E_HTTP_ENDPOINT")
+	ws_endpoint := require_env(t, "APPSYNC_E2E_WS_ENDPOINT")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	defer cancel()
+
+	authz, err := authorizer.ApiKey(authorizer.ApiKeyAuthorizerConfig{
+		ApiKey:   require_env(t, "APPSYNC_E2E_API_KEY"),
+		Endpoint: http_endpoint,
+	})
+	if err != nil {
+		t.Fatalf("create authorizer: %v", err)
+	}
+
+	client, err := appsync.Connect(ctx, appsync.ConnectionOptions{
+		Endpoint:     ws_endpoint,
+		Subprotocols: []string{appsync.ProtocolEvents},
+		Authorizer:   authz,
+	})
+	if err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer func() {
+		close_ctx, close_cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer close_cancel()
+		if err := client.Close(close_ctx); err != nil {
+			t.Logf("client close: %v", err)
+		}
+	}()
+
+	namespace := require_env(t, "APPSYNC_E2E_NS_API_KEY")
+	channel := fmt.Sprintf("%s/test-%d", namespace, time.Now().UnixNano())
+
+	sub, err := client.Subscribe(ctx, appsync.SubscribeCommandInput{
+		Channel: channel,
+	})
+	if err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+
+	close_ctx, close_cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer close_cancel()
+
+	if err := sub.Close(close_ctx); err != nil {
+		t.Fatalf("unsubscribe: %v", err)
+	}
+
+	_, err = sub.Next(ctx)
+	if !errors.Is(err, appsync.ErrSubscriptionClosed) {
+		t.Fatalf("expected ErrSubscriptionClosed after unsubscribe, got: %v", err)
+	}
+}
+
 func TestInvalidApiKeyCannotConnect(t *testing.T) {
 	http_endpoint := require_env(t, "APPSYNC_E2E_HTTP_ENDPOINT")
 	ws_endpoint := require_env(t, "APPSYNC_E2E_WS_ENDPOINT")

internal/app/services/subscription/unsubscribe.go

@@ -9,19 +9,16 @@ import (
 type UnsubscribeService struct {
 	subscriptions UnsubscribeRegistry
 	writer        app.SendMessageService
-	authorizer    app.RequestAuthorizer
 	frame         FrameFactory
 }
 
 func NewUnsubscribeService(
 	subscriptions UnsubscribeRegistry,
 	writer app.SendMessageService,
-	authorizer app.RequestAuthorizer,
 	frame FrameFactory,
 ) *UnsubscribeService {
 	return &UnsubscribeService{
 		frame:         frame,
-		authorizer:    authorizer,
 		writer:        writer,
 		subscriptions: subscriptions,
 	}
@@ -39,16 +36,10 @@ func (service UnsubscribeService) Unsubscribe(ctx context.Context, subscription_
 		return app.ErrSubscriptionClosed
 	}
 
-	signature, err := service.authorizer.Authorize(ctx, app.AuthorizeCommandInput{})
-	if err != nil {
-		return err
-	}
-
 	frame.WithType(protocol.TypeUnsubscribe).
-		WithSignature(signature).
 		WithID(subscription_id)
 
-	err = service.writer.Send(ctx, frame.Build())
+	err := service.writer.Send(ctx, frame.Build())
 
 	if err != nil {
 		return err

internal/app/services/subscription/unsubscribe_test.go

@@ -19,15 +19,6 @@ type mock_unsubscribe_registry struct {
 func (m *mock_unsubscribe_registry) Get(_ string) *subscription.Subscription { return m.sub }
 func (m *mock_unsubscribe_registry) Remove(id string)                        { m.removed = id }
 
-type mock_authorizer struct {
-	signature app.Signature
-	err       error
-}
-
-func (m *mock_authorizer) Authorize(_ context.Context, _ app.AuthorizeCommandInput) (app.Signature, error) {
-	return m.signature, m.err
-}
-
 type mock_sender struct {
 	err    error
 	called bool
@@ -45,19 +36,15 @@ func (m mock_frame) Encode() (app.Payload, error) { return nil, nil }
 
 type mock_frame_builder struct {
 	frame_type string
-	signature  app.Signature
 	id         string
 }
 
-func (m *mock_frame_builder) WithPayload(_ app.Payload) app.FrameBuilder { return m }
-func (m *mock_frame_builder) WithChannel(_ string) app.FrameBuilder      { return m }
-func (m *mock_frame_builder) WithSignature(s app.Signature) app.FrameBuilder {
-	m.signature = s
-	return m
-}
-func (m *mock_frame_builder) WithType(t string) app.FrameBuilder { m.frame_type = t; return m }
-func (m *mock_frame_builder) WithID(id string) app.FrameBuilder  { m.id = id; return m }
-func (m *mock_frame_builder) Build() app.Frame                   { return mock_frame{} }
+func (m *mock_frame_builder) WithPayload(_ app.Payload) app.FrameBuilder     { return m }
+func (m *mock_frame_builder) WithChannel(_ string) app.FrameBuilder          { return m }
+func (m *mock_frame_builder) WithSignature(s app.Signature) app.FrameBuilder { return m }
+func (m *mock_frame_builder) WithType(t string) app.FrameBuilder             { m.frame_type = t; return m }
+func (m *mock_frame_builder) WithID(id string) app.FrameBuilder              { m.id = id; return m }
+func (m *mock_frame_builder) Build() app.Frame                               { return mock_frame{} }
 
 type mock_frame_factory struct {
 	builder *mock_frame_builder
@@ -79,14 +66,11 @@ func inactive_subscription() *subscription.Subscription {
 func TestUnsubscribe(t *testing.T) {
 	const subscriptionId = "sub-id"
 
-	auth_err := errors.New("auth failed")
 	send_err := errors.New("send failed")
-	signature := app.Signature{"Authorization": "sig-value"}
 
 	tests := []struct {
 		name        string
 		registry    *mock_unsubscribe_registry
-		authorizer  *mock_authorizer
 		sender      *mock_sender
 		expect_err  error
 		expect_send bool
@@ -95,28 +79,18 @@ func TestUnsubscribe(t *testing.T) {
 		{
 			name:       "subscription not found",
 			registry:   &mock_unsubscribe_registry{sub: nil},
-			authorizer: &mock_authorizer{},
 			sender:     &mock_sender{},
 			expect_err: app.ErrSubscriptionClosed,
 		},
 		{
 			name:       "inactive subscription",
 			registry:   &mock_unsubscribe_registry{sub: inactive_subscription()},
-			authorizer: &mock_authorizer{},
 			sender:     &mock_sender{},
 			expect_err: app.ErrSubscriptionClosed,
 		},
-		{
-			name:       "authorize error stops execution",
-			registry:   &mock_unsubscribe_registry{sub: active_subscription()},
-			authorizer: &mock_authorizer{err: auth_err},
-			sender:     &mock_sender{},
-			expect_err: auth_err,
-		},
 		{
 			name:        "send error does not clean up",
 			registry:    &mock_unsubscribe_registry{sub: active_subscription()},
-			authorizer:  &mock_authorizer{signature: signature},
 			sender:      &mock_sender{err: send_err},
 			expect_err:  send_err,
 			expect_send: true,
@@ -127,11 +101,6 @@ func TestUnsubscribe(t *testing.T) {
 				if frame.id != subscriptionId {
 					t.Errorf("frame.id = %q, want %q", frame.id, subscriptionId)
 				}
-				for k, v := range signature {
-					if frame.signature[k] != v {
-						t.Errorf("frame.signature[%q] = %q, want %q", k, frame.signature[k], v)
-					}
-				}
 				if !registry.sub.Active() {
 					t.Error("subscription should remain active when send fails")
 				}
@@ -143,7 +112,6 @@ func TestUnsubscribe(t *testing.T) {
 		{
 			name:        "success",
 			registry:    &mock_unsubscribe_registry{sub: active_subscription()},
-			authorizer:  &mock_authorizer{signature: signature},
 			sender:      &mock_sender{},
 			expect_send: true,
 			verify: func(t *testing.T, frame *mock_frame_builder, registry *mock_unsubscribe_registry) {
@@ -153,11 +121,7 @@ func TestUnsubscribe(t *testing.T) {
 				if frame.id != subscriptionId {
 					t.Errorf("frame.id = %q, want %q", frame.id, subscriptionId)
 				}
-				for k, v := range signature {
-					if frame.signature[k] != v {
-						t.Errorf("frame.signature[%q] = %q, want %q", k, frame.signature[k], v)
-					}
-				}
+
 				if registry.sub.Active() {
 					t.Error("subscription should be closed after successful unsubscribe")
 				}
@@ -172,7 +136,7 @@ func TestUnsubscribe(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			frame := &mock_frame_builder{}
 			factory := &mock_frame_factory{builder: frame}
-			service := sub_service.NewUnsubscribeService(tt.registry, tt.sender, tt.authorizer, factory)
+			service := sub_service.NewUnsubscribeService(tt.registry, tt.sender, factory)
 
 			err := service.Unsubscribe(context.Background(), subscriptionId)
 

internal/composition/usecases.go

@@ -37,9 +37,9 @@ func NewUseCases(authorizer app.RequestAuthorizer,
 	subscriptions_registry := subscription.NewRegistry()
 	create_subscription_service := sub_service.NewCreateSubscriptionService(subscriptions_registry, subscription_backpressure)
 	send_request_service := request.NewSendRequestService(egress, pending)
-	unsubscribe_service := sub_service.NewUnsubscribeService(subscriptions_registry,
+	unsubscribe_service := sub_service.NewUnsubscribeService(
+		subscriptions_registry,
 		send_request_service,
-		authorizer,
 		events.FrameBuilderFactory{},
 	)