Always unsubscribe from the internal channel on Connection#close

A connection subscribes to its internal channel unconditionally during
#initialize (via subscribe_to_internal_channel), but #close only tore
that subscription down inside the `if channels_to_close` branch. A
connection that opened but never subscribed to a user channel therefore
left its `cable_internal/<id>` subscription dangling on the backend after
disconnecting — a small but real leak.

Move unsubscribe_from_internal_channel out of that branch so it always
runs on close, mirroring the unconditional subscribe in #initialize. The
method is already guarded by `internal_identifier.presence` and is a
no-op on the backend when not subscribed, so calling it unconditionally
is safe.

Adds a regression spec that spies on the internal-channel hooks to assert
#close tears the subscription down even with no user-channel subscriptions.

Fixes #109

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BMW1EsdCMExBhm3tg7TQhs

Author: russ

spec/cable/connection_spec.cr

@@ -198,6 +198,28 @@ describe Cable::Connection do
     end
   end
 
+  # Regression test for #109: a connection that opens but never subscribes to a
+  # user channel still subscribes to its internal channel during initialize. On
+  # close it must unsubscribe from that internal channel, otherwise the
+  # subscription leaks on the backend. We spy on the internal-channel hooks so
+  # the test exercises Connection#close's control flow directly, without
+  # swapping the global server backend (which destabilizes other specs).
+  describe "when a connection closes without ever subscribing to a channel" do
+    it "still unsubscribes from the internal channel (no leak)" do
+      socket = DummySocket.new(IO::Memory.new)
+      connection = InternalChannelSpyConnection.new(builds_request(token: "98"), socket)
+
+      # initialize subscribes to the internal channel, even with no user channels
+      connection.internal_subscribes.should eq(["cable_internal/98"])
+      connection.internal_unsubscribes.should be_empty
+
+      connection.close
+
+      # close must tear that subscription down to avoid leaking it on the backend
+      connection.internal_unsubscribes.should eq(["cable_internal/98"])
+    end
+  end
+
   describe "#message" do
     it "ignore a message for a non valid channel" do
       connect do |connection, socket|
@@ -604,6 +626,32 @@ private class UnauthorizedConnectionTest < Cable::Connection
   end
 end
 
+# Records calls to the internal-channel hooks instead of hitting the backend,
+# so #close's teardown can be asserted without touching the global server.
+private class InternalChannelSpyConnection < Cable::Connection
+  identified_by :identifier
+
+  getter internal_subscribes = [] of String
+  getter internal_unsubscribes = [] of String
+
+  def connect
+    if tk = token
+      self.identifier = tk
+    end
+  end
+
+  def broadcast_to(channel, message)
+  end
+
+  private def subscribe_to_internal_channel
+    internal_subscribes << internal_channel
+  end
+
+  private def unsubscribe_from_internal_channel
+    internal_unsubscribes << internal_channel
+  end
+end
+
 # Simulates the failure mode in issue #105: the backend's underlying connection
 # is dead, so any subscribe call (including the one done during Connection#initialize)
 # raises IO::Error.

src/cable/connection.cr

@@ -97,9 +97,16 @@ module Cable
         rescue e : IO::Error
           Cable.settings.on_error.call(e, "IO::Error: #{e.message} -> #{self.class.name}#close", self)
         end
-        unsubscribe_from_internal_channel
       end
 
+      # Always tear down the internal channel subscription. It is set up
+      # unconditionally in #initialize (via subscribe_to_internal_channel), so
+      # it must be torn down unconditionally here too. Otherwise a connection
+      # that never subscribed to a user channel (so channels_to_close is nil)
+      # would leave its `cable_internal/<id>` subscription dangling on the
+      # backend after disconnect. Fixes #109.
+      unsubscribe_from_internal_channel
+
       return true if closed?
 
       Cable::Logger.info { "Terminating connection #{connection_identifier}" }