added mutex logic to the topic subscriptions (#13)

internal/server/server.go

···
 		t = newTopic(topicName)
 	}
 
+	t.mu.Lock()
 	t.subscriptions[peer.Addr()] = newSubscriber(peer, t, s.ackDelay, s.ackTimeout, startAt)
+	t.mu.Unlock()
 
 	s.topics[topicName] = t
 }
···
 	if !ok {
 		return
 	}
-	sub, ok := t.subscriptions[peer.Addr()]
-	if !ok {
+
+	sub := t.findSubscription(peer.Addr())
+	if sub == nil {
 		return
 	}
+
 	sub.unsubscribe()
-	delete(t.subscriptions, peer.Addr())
+	t.removeSubscription(peer.Addr())
 }
 
 func (s *Server) unsubscribePeerFromAllTopics(peer *Peer) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	for _, topic := range s.topics {
-		sub, ok := topic.subscriptions[peer.Addr()]
-		if !ok {
-			continue
+	for _, t := range s.topics {
+		sub := t.findSubscription(peer.Addr())
+		if sub == nil {
+			return
 		}
+
 		sub.unsubscribe()
-		delete(topic.subscriptions, peer.Addr())
+		t.removeSubscription(peer.Addr())
 	}
 }
 

internal/server/server_test.go

···
 
 	_ = createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 
+	srv.mu.Lock()
+	defer srv.mu.Unlock()
 	assert.Len(t, srv.topics, 2)
 	assert.Len(t, srv.topics[topicA].subscriptions, 1)
 	assert.Len(t, srv.topics[topicB].subscriptions, 1)
···
 	conn := createConnectionAndSubscribe(t, []string{topicA, topicB, topicC}, Current, 0)
 
 	assert.Len(t, srv.topics, 3)
+
+	srv.mu.Lock()
 	assert.Len(t, srv.topics[topicA].subscriptions, 1)
 	assert.Len(t, srv.topics[topicB].subscriptions, 1)
 	assert.Len(t, srv.topics[topicC].subscriptions, 1)
+	srv.mu.Unlock()
 
 	topics := []string{topicA, topicB}
 
···
 	assert.Equal(t, expectedRes, resp)
 
 	assert.Len(t, srv.topics, 3)
+
+	srv.mu.Lock()
 	assert.Len(t, srv.topics[topicA].subscriptions, 0)
 	assert.Len(t, srv.topics[topicB].subscriptions, 0)
 	assert.Len(t, srv.topics[topicC].subscriptions, 1)
+	srv.mu.Unlock()
 }
 
 func TestSubscriberClosesWithoutUnsubscribing(t *testing.T) {
···
 	conn := createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 
 	assert.Len(t, srv.topics, 2)
+
+	srv.mu.Lock()
 	assert.Len(t, srv.topics[topicA].subscriptions, 1)
 	assert.Len(t, srv.topics[topicB].subscriptions, 1)
+	srv.mu.Unlock()
 
 	// close the conn
 	err := conn.Close()
···
 	time.Sleep(time.Millisecond * 100)
 
 	assert.Len(t, srv.topics, 2)
+
+	srv.mu.Lock()
 	assert.Len(t, srv.topics[topicA].subscriptions, 0)
 	assert.Len(t, srv.topics[topicB].subscriptions, 0)
+	srv.mu.Unlock()
 }
 
 func TestInvalidAction(t *testing.T) {

internal/server/topic.go

···
 
 	return nil
 }
+
+func (t *topic) findSubscription(addr net.Addr) *subscriber {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	return t.subscriptions[addr]
+}
+
+func (t *topic) removeSubscription(addr net.Addr) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	delete(t.subscriptions, addr)
+}