Merge branch 'XX-4120/joinedChannelTests' into 'channelsImpl'

XX-4120 / joinedChannel Tests

See merge request !359

bindings/broadcast.go

@@ -103,7 +103,7 @@ func NewBroadcastChannel(cmixId int, channelDefinition []byte) (*Channel, error)
 		return nil, errors.WithMessage(err, "Failed to load public key")
 	}
 
-	ch, err := broadcast.NewBroadcastChannel(cryptoBroadcast.Channel{
+	ch, err := broadcast.NewBroadcastChannel(&cryptoBroadcast.Channel{
 		ReceptionID: channelID,
 		Name:        def.Name,
 		Description: def.Description,

broadcast/asymmetric_test.go

@@ -62,7 +62,7 @@ func Test_asymmetricClient_Smoke(t *testing.T) {
 	if err != nil {
 		t.Errorf("Failed to create channel ID: %+v", err)
 	}
-	channel := crypto.Channel{
+	channel := &crypto.Channel{
 		ReceptionID: cid,
 		Name:        cname,
 		Description: cdesc,

broadcast/client.go

@@ -19,15 +19,15 @@ import (
 
 // broadcastClient implements the Channel interface for sending/receiving asymmetric or symmetric broadcast messages
 type broadcastClient struct {
-	channel crypto.Channel
+	channel *crypto.Channel
 	net     Client
 	rng     *fastRNG.StreamGenerator
 }
 
-type NewBroadcastChannelFunc func(channel crypto.Channel, net Client, rng *fastRNG.StreamGenerator) (Channel, error)
+type NewBroadcastChannelFunc func(channel *crypto.Channel, net Client, rng *fastRNG.StreamGenerator) (Channel, error)
 
 // NewBroadcastChannel creates a channel interface based on crypto.Channel, accepts net client connection & callback for received messages
-func NewBroadcastChannel(channel crypto.Channel, net Client, rng *fastRNG.StreamGenerator) (Channel, error) {
+func NewBroadcastChannel(channel *crypto.Channel, net Client, rng *fastRNG.StreamGenerator) (Channel, error) {
 	bc := &broadcastClient{
 		channel: channel,
 		net:     net,
@@ -60,7 +60,7 @@ func (bc *broadcastClient) RegisterListener(listenerCb ListenerFunc, method Meth
 	}
 
 	p := &processor{
-		c:      &bc.channel,
+		c:      bc.channel,
 		cb:     listenerCb,
 		method: method,
 	}
@@ -84,14 +84,16 @@ func (bc *broadcastClient) Stop() {
 	bc.net.DeleteClientService(bc.channel.ReceptionID)
 }
 
-// Get returns the underlying crypto.Channel object
-func (bc *broadcastClient) Get() crypto.Channel {
+// Get returns the underlying crypto.Channel object.
+func (bc *broadcastClient) Get() *crypto.Channel {
 	return bc.channel
 }
 
-// verifyID generates a symmetric ID based on the info in the channel & compares it to the one passed in
+// verifyID generates a symmetric ID based on the info in the channel and
+// compares it to the one passed in.
 func (bc *broadcastClient) verifyID() bool {
-	gen, err := crypto.NewChannelID(bc.channel.Name, bc.channel.Description, bc.channel.Salt, rsa.CreatePublicKeyPem(bc.channel.RsaPubKey))
+	gen, err := crypto.NewChannelID(bc.channel.Name, bc.channel.Description,
+		bc.channel.Salt, rsa.CreatePublicKeyPem(bc.channel.RsaPubKey))
 	if err != nil {
 		jww.FATAL.Panicf("[verifyID] Failed to generate verified channel ID")
 		return false

broadcast/interface.go

@@ -19,8 +19,8 @@ import (
 	"time"
 )
 
-// ListenerFunc is registered when creating a new broadcasting channel
-// and receives all new broadcast messages for the channel.
+// ListenerFunc is registered when creating a new broadcasting channel and
+// receives all new broadcast messages for the channel.
 type ListenerFunc func(payload []byte,
 	receptionID receptionID.EphemeralIdentity, round rounds.Round)
 
@@ -34,7 +34,7 @@ type Channel interface {
 	MaxAsymmetricPayloadSize() int
 
 	// Get returns the underlying crypto.Channel
-	Get() crypto.Channel
+	Get() *crypto.Channel
 
 	// Broadcast broadcasts the payload to the channel. The payload size must be
 	// equal to MaxPayloadSize.

broadcast/symmetric_test.go

@@ -44,7 +44,7 @@ func Test_symmetricClient_Smoke(t *testing.T) {
 	if err != nil {
 		t.Errorf("Failed to create channel ID: %+v", err)
 	}
-	channel := crypto.Channel{
+	channel := &crypto.Channel{
 		ReceptionID: cid,
 		Name:        cname,
 		Description: cdesc,

channels/eventModel.go

@@ -26,7 +26,7 @@ var (
 // system passed an object which adheres to in order to get events on the channel
 type EventModel interface {
 	// JoinChannel is called whenever a channel is joined locally
-	JoinChannel(channel cryptoBroadcast.Channel)
+	JoinChannel(channel *cryptoBroadcast.Channel)
 
 	// LeaveChannel is called whenever a channel is left locally
 	LeaveChannel(channelID *id.ID)

channels/eventModel_test.go

@@ -30,7 +30,7 @@ type MockEvent struct {
 	eventReceive
 }
 
-func (*MockEvent) JoinChannel(channel cryptoBroadcast.Channel) {}
+func (*MockEvent) JoinChannel(channel *cryptoBroadcast.Channel) {}
 func (*MockEvent) LeaveChannel(channelID *id.ID)                {}
 func (m *MockEvent) ReceiveMessage(channelID *id.ID, messageID cryptoChannel.MessageID,
 	senderUsername string, text string,

channels/joinedChannel.go

@@ -48,10 +48,9 @@ func (m *manager) storeUnsafe() error {
 // loadChannels loads all currently joined channels from disk and registers them
 // for message reception.
 func (m *manager) loadChannels() {
-
 	obj, err := m.kv.Get(joinedChannelsKey, joinedChannelsVersion)
 	if !m.kv.Exists(err) {
-		m.channels = make(map[*id.ID]*joinedChannel)
+		m.channels = make(map[id.ID]*joinedChannel)
 		return
 	} else if err != nil {
 		jww.FATAL.Panicf("Failed to load channels: %+v", err)
@@ -62,7 +61,7 @@ func (m *manager) loadChannels() {
 		jww.FATAL.Panicf("Failed to load channels: %+v", err)
 	}
 
-	chMap := make(map[*id.ID]*joinedChannel)
+	chMap := make(map[id.ID]*joinedChannel)
 
 	for i := range chList {
 		jc, err := loadJoinedChannel(
@@ -70,17 +69,17 @@ func (m *manager) loadChannels() {
 		if err != nil {
 			jww.FATAL.Panicf("Failed to load channel %s: %+v", chList[i], err)
 		}
-		chMap[chList[i]] = jc
+		chMap[*chList[i]] = jc
 	}
 
 	m.channels = chMap
 }
 
 // addChannel adds a channel.
-func (m *manager) addChannel(channel cryptoBroadcast.Channel) error {
+func (m *manager) addChannel(channel *cryptoBroadcast.Channel) error {
 	m.mux.Lock()
 	defer m.mux.Unlock()
-	if _, exists := m.channels[channel.ReceptionID]; exists {
+	if _, exists := m.channels[*channel.ReceptionID]; exists {
 		return ChannelAlreadyExistsErr
 	}
 
@@ -89,6 +88,19 @@ func (m *manager) addChannel(channel cryptoBroadcast.Channel) error {
 		return err
 	}
 
+	jc := &joinedChannel{b}
+	if err = jc.Store(m.kv); err != nil {
+		go b.Stop()
+		return err
+	}
+
+	m.channels[*jc.broadcast.Get().ReceptionID] = jc
+
+	if err = m.storeUnsafe(); err != nil {
+		go b.Stop()
+		return err
+	}
+
 	// Connect to listeners
 	err = b.RegisterListener((&userListener{
 		name:    m.name,
@@ -107,17 +119,6 @@ func (m *manager) addChannel(channel cryptoBroadcast.Channel) error {
 		return err
 	}
 
-	jc := &joinedChannel{b}
-	if err = jc.Store(m.kv); err != nil {
-		go b.Stop()
-		return err
-	}
-
-	if err = m.storeUnsafe(); err != nil {
-		go b.Stop()
-		return err
-	}
-
 	return nil
 }
 
@@ -128,16 +129,21 @@ func (m *manager) removeChannel(channelID *id.ID) error {
 	m.mux.Lock()
 	defer m.mux.Unlock()
 
-	ch, exists := m.channels[channelID]
+	ch, exists := m.channels[*channelID]
 	if !exists {
 		return ChannelDoesNotExistsErr
 	}
 
 	ch.broadcast.Stop()
 
-	delete(m.channels, channelID)
+	delete(m.channels, *channelID)
 
-	return nil
+	err := m.storeUnsafe()
+	if err != nil {
+		return err
+	}
+
+	return ch.delete(m.kv)
 }
 
 // getChannel returns the given channel. Returns ChannelDoesNotExistsErr error
@@ -146,7 +152,7 @@ func (m *manager) getChannel(channelID *id.ID) (*joinedChannel, error) {
 	m.mux.RLock()
 	defer m.mux.RUnlock()
 
-	jc, exists := m.channels[channelID]
+	jc, exists := m.channels[*channelID]
 	if !exists {
 		return nil, ChannelDoesNotExistsErr
 	}
@@ -168,7 +174,7 @@ func (m *manager) getChannels() []*id.ID {
 func (m *manager) getChannelsUnsafe() []*id.ID {
 	list := make([]*id.ID, 0, len(m.channels))
 	for chID := range m.channels {
-		list = append(list, chID)
+		list = append(list, chID.DeepCopy())
 	}
 	return list
 }
@@ -181,12 +187,12 @@ type joinedChannel struct {
 
 // joinedChannelDisk is the representation of joinedChannel for storage.
 type joinedChannelDisk struct {
-	broadcast cryptoBroadcast.Channel
+	Broadcast *cryptoBroadcast.Channel
 }
 
 // Store writes the given channel to a unique storage location within the EKV.
 func (jc *joinedChannel) Store(kv *versioned.KV) error {
-	jcd := joinedChannelDisk{broadcast: jc.broadcast.Get()}
+	jcd := joinedChannelDisk{jc.broadcast.Get()}
 	data, err := json.Marshal(&jcd)
 	if err != nil {
 		return err
@@ -198,8 +204,8 @@ func (jc *joinedChannel) Store(kv *versioned.KV) error {
 		Data:      data,
 	}
 
-	return kv.Set(makeJoinedChannelKey(
-		jc.broadcast.Get().ReceptionID), joinedChannelVersion, obj)
+	return kv.Set(makeJoinedChannelKey(jc.broadcast.Get().ReceptionID),
+		joinedChannelVersion, obj)
 }
 
 // loadJoinedChannel loads a given channel from ekv storage.
@@ -217,14 +223,14 @@ func loadJoinedChannel(chId *id.ID, kv *versioned.KV, net broadcast.Client,
 	if err != nil {
 		return nil, err
 	}
-	b, err := broadcastMaker(jcd.broadcast, net, rngGen)
+	b, err := broadcastMaker(jcd.Broadcast, net, rngGen)
 	if err != nil {
 		return nil, err
 	}
 
 	err = b.RegisterListener((&userListener{
 		name:    name,
-		chID:    jcd.broadcast.ReceptionID,
+		chID:    jcd.Broadcast.ReceptionID,
 		trigger: e.triggerEvent,
 	}).Listen, broadcast.Symmetric)
 	if err != nil {
@@ -232,7 +238,7 @@ func loadJoinedChannel(chId *id.ID, kv *versioned.KV, net broadcast.Client,
 	}
 
 	err = b.RegisterListener((&adminListener{
-		chID:    jcd.broadcast.ReceptionID,
+		chID:    jcd.Broadcast.ReceptionID,
 		trigger: e.triggerAdminEvent,
 	}).Listen, broadcast.Asymmetric)
 	if err != nil {
@@ -243,6 +249,12 @@ func loadJoinedChannel(chId *id.ID, kv *versioned.KV, net broadcast.Client,
 	return jc, nil
 }
 
+// delete removes the channel from the kv.
+func (jc *joinedChannel) delete(kv *versioned.KV) error {
+	return kv.Delete(makeJoinedChannelKey(jc.broadcast.Get().ReceptionID),
+		joinedChannelVersion)
+}
+
 func makeJoinedChannelKey(chId *id.ID) string {
 	return joinedChannelKey + chId.HexEncode()
 }

channels/joinedChannel_test.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 xx network SEZC                                           //
+//                                                                            //
+// Use of this source code is governed by a license that can be found in the  //
+// LICENSE file                                                               //
+////////////////////////////////////////////////////////////////////////////////
+
+package channels
+
+import (
+	"bytes"
+	"encoding/binary"
+	"gitlab.com/elixxir/client/broadcast"
+	"gitlab.com/elixxir/client/storage/versioned"
+	cryptoBroadcast "gitlab.com/elixxir/crypto/broadcast"
+	"gitlab.com/elixxir/crypto/cmix"
+	"gitlab.com/elixxir/crypto/fastRNG"
+	"gitlab.com/elixxir/ekv"
+	"gitlab.com/xx_network/crypto/csprng"
+	"gitlab.com/xx_network/crypto/signature/rsa"
+	"gitlab.com/xx_network/primitives/id"
+	"reflect"
+	"sort"
+	"strconv"
+	"testing"
+)
+
+// Tests that manager.store stores the channel list in the ekv.
+func Test_manager_store(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	for i := 0; i < 10; i++ {
+		ch, _, err := newTestChannel("name_"+strconv.Itoa(i),
+			"description_"+strconv.Itoa(i), m.rng.GetStream())
+		if err != nil {
+			t.Errorf("Failed to create new channel %d: %+v", i, err)
+		}
+
+		b, err := broadcast.NewBroadcastChannel(ch, m.client, m.rng)
+		if err != nil {
+			t.Errorf("Failed to make new broadcast channel: %+v", err)
+		}
+
+		m.channels[*ch.ReceptionID] = &joinedChannel{b}
+	}
+
+	err := m.store()
+	if err != nil {
+		t.Errorf("Error storing channels: %+v", err)
+	}
+
+	_, err = m.kv.Get(joinedChannelsKey, joinedChannelsVersion)
+	if !ekv.Exists(err) {
+		t.Errorf("channel list not found in KV: %+v", err)
+	}
+}
+
+// Tests that the manager.loadChannels loads all the expected channels from the
+// ekv.
+func Test_manager_loadChannels(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	expected := make([]*joinedChannel, 10)
+
+	for i := range expected {
+		ch, _, err := newTestChannel("name_"+strconv.Itoa(i),
+			"description_"+strconv.Itoa(i), m.rng.GetStream())
+		if err != nil {
+			t.Errorf("Failed to create new channel %d: %+v", i, err)
+		}
+
+		b, err := broadcast.NewBroadcastChannel(ch, m.client, m.rng)
+		if err != nil {
+			t.Errorf("Failed to make new broadcast channel: %+v", err)
+		}
+
+		jc := &joinedChannel{b}
+		if err = jc.Store(m.kv); err != nil {
+			t.Errorf("Failed to store joinedChannel %d: %+v", i, err)
+		}
+
+		chID := *ch.ReceptionID
+		m.channels[chID] = jc
+		expected[i] = jc
+	}
+
+	err := m.store()
+	if err != nil {
+		t.Errorf("Error storing channels: %+v", err)
+	}
+
+	newManager := &manager{
+		channels:       make(map[id.ID]*joinedChannel),
+		kv:             m.kv,
+		client:         m.client,
+		rng:            m.rng,
+		broadcastMaker: m.broadcastMaker,
+	}
+
+	newManager.loadChannels()
+
+	for chID, loadedCh := range newManager.channels {
+		ch, exists := m.channels[chID]
+		if !exists {
+			t.Errorf("Channel %s does not exist.", &chID)
+		}
+
+		if !reflect.DeepEqual(ch.broadcast, loadedCh.broadcast) {
+			t.Errorf("Channel %s does not match loaded channel."+
+				"\nexpected: %+v\nreceived: %+v", &chID, ch.broadcast, loadedCh.broadcast)
+		}
+	}
+}
+
+// Tests that manager.addChannel adds the channel to the map and stores it in
+// the kv.
+func Test_manager_addChannel(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	err = m.addChannel(ch)
+	if err != nil {
+		t.Errorf("Failed to add new channel: %+v", err)
+	}
+
+	if _, exists := m.channels[*ch.ReceptionID]; !exists {
+		t.Errorf("Channel %s not added to channel map.", ch.Name)
+	}
+
+	_, err = m.kv.Get(makeJoinedChannelKey(ch.ReceptionID), joinedChannelVersion)
+	if err != nil {
+		t.Errorf("Failed to get joinedChannel from kv: %+v", err)
+	}
+
+	_, err = m.kv.Get(joinedChannelsKey, joinedChannelsVersion)
+	if err != nil {
+		t.Errorf("Failed to get channels from kv: %+v", err)
+	}
+}
+
+// Error path: tests that manager.addChannel returns ChannelAlreadyExistsErr
+// when the channel was already added.
+func Test_manager_addChannel_ChannelAlreadyExistsErr(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	err = m.addChannel(ch)
+	if err != nil {
+		t.Errorf("Failed to add new channel: %+v", err)
+	}
+
+	err = m.addChannel(ch)
+	if err == nil || err != ChannelAlreadyExistsErr {
+		t.Errorf("Received incorrect error when adding a channel that already "+
+			"exists.\nexpected: %s\nreceived: %+v", ChannelAlreadyExistsErr, err)
+	}
+}
+
+// Tests the manager.removeChannel deletes the channel from the map.
+func Test_manager_removeChannel(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	err = m.addChannel(ch)
+	if err != nil {
+		t.Errorf("Failed to add new channel: %+v", err)
+	}
+
+	err = m.removeChannel(ch.ReceptionID)
+	if err != nil {
+		t.Errorf("Error removing channel: %+v", err)
+	}
+
+	if _, exists := m.channels[*ch.ReceptionID]; exists {
+		t.Errorf("Channel %s was not remove from the channel map.", ch.Name)
+	}
+
+	_, err = m.kv.Get(makeJoinedChannelKey(ch.ReceptionID), joinedChannelVersion)
+	if ekv.Exists(err) {
+		t.Errorf("joinedChannel not removed from kv: %+v", err)
+	}
+}
+
+// Error path: tests that manager.removeChannel returns ChannelDoesNotExistsErr
+// when the channel was never added.
+func Test_manager_removeChannel_ChannelDoesNotExistsErr(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	err = m.removeChannel(ch.ReceptionID)
+	if err == nil || err != ChannelDoesNotExistsErr {
+		t.Errorf("Received incorrect error when removing a channel that does "+
+			"not exists.\nexpected: %s\nreceived: %+v",
+			ChannelDoesNotExistsErr, err)
+	}
+}
+
+// Tests the manager.getChannel returns the expected channel.
+func Test_manager_getChannel(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	err = m.addChannel(ch)
+	if err != nil {
+		t.Errorf("Failed to add new channel: %+v", err)
+	}
+
+	jc, err := m.getChannel(ch.ReceptionID)
+	if err != nil {
+		t.Errorf("Error getting channel: %+v", err)
+	}
+
+	if !reflect.DeepEqual(ch, jc.broadcast.Get()) {
+		t.Errorf("Received unexpected channel.\nexpected: %+v\nreceived: %+v",
+			ch, jc.broadcast.Get())
+	}
+}
+
+// Error path: tests that manager.getChannel returns ChannelDoesNotExistsErr
+// when the channel was never added.
+func Test_manager_getChannel_ChannelDoesNotExistsErr(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	_, err = m.getChannel(ch.ReceptionID)
+	if err == nil || err != ChannelDoesNotExistsErr {
+		t.Errorf("Received incorrect error when getting a channel that does "+
+			"not exists.\nexpected: %s\nreceived: %+v",
+			ChannelDoesNotExistsErr, err)
+	}
+}
+
+// Tests that manager.getChannels returns all the channels that were added to
+// the map.
+func Test_manager_getChannels(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	expected := make([]*id.ID, 10)
+
+	for i := range expected {
+		ch, _, err := newTestChannel("name_"+strconv.Itoa(i),
+			"description_"+strconv.Itoa(i), m.rng.GetStream())
+		if err != nil {
+			t.Errorf("Failed to create new channel %d: %+v", i, err)
+		}
+		expected[i] = ch.ReceptionID
+
+		err = m.addChannel(ch)
+		if err != nil {
+			t.Errorf("Failed to add new channel %d: %+v", i, err)
+		}
+	}
+
+	channelIDs := m.getChannelsUnsafe()
+
+	sort.SliceStable(expected, func(i, j int) bool {
+		return bytes.Compare(expected[i][:], expected[j][:]) == -1
+	})
+	sort.SliceStable(channelIDs, func(i, j int) bool {
+		return bytes.Compare(channelIDs[i][:], channelIDs[j][:]) == -1
+	})
+
+	if !reflect.DeepEqual(expected, channelIDs) {
+		t.Errorf("ID list does not match expected.\nexpected: %v\nreceived: %v",
+			expected, channelIDs)
+	}
+}
+
+// Tests that joinedChannel.Store saves the joinedChannel to the expected place
+// in the ekv.
+func Test_joinedChannel_Store(t *testing.T) {
+	kv := versioned.NewKV(ekv.MakeMemstore())
+	rng := fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG)
+	ch, _, err := newTestChannel("name", "description", rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	b, err := broadcast.NewBroadcastChannel(ch, new(mockBroadcastClient), rng)
+	if err != nil {
+		t.Errorf("Failed to create new broadcast channel: %+v", err)
+	}
+
+	jc := &joinedChannel{b}
+
+	err = jc.Store(kv)
+	if err != nil {
+		t.Errorf("Error storing joinedChannel: %+v", err)
+	}
+
+	_, err = kv.Get(makeJoinedChannelKey(ch.ReceptionID), joinedChannelVersion)
+	if !ekv.Exists(err) {
+		t.Errorf("joinedChannel not found in KV: %+v", err)
+	}
+}
+
+// Tests that loadJoinedChannel returns a joinedChannel from storage that
+// matches the original.
+func Test_loadJoinedChannel(t *testing.T) {
+	m := NewManager(versioned.NewKV(ekv.MakeMemstore()),
+		new(mockBroadcastClient),
+		fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG),
+		new(mockNameService), new(mockEventModel)).(*manager)
+
+	ch, _, err := newTestChannel("name", "description", m.rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	err = m.addChannel(ch)
+	if err != nil {
+		t.Errorf("Failed to add channel: %+v", err)
+	}
+
+	loadedJc, err := loadJoinedChannel(ch.ReceptionID, m.kv, m.client, m.rng,
+		m.name, m.events, m.broadcastMaker)
+	if err != nil {
+		t.Errorf("Failed to load joinedChannel: %+v", err)
+	}
+
+	if !reflect.DeepEqual(ch, loadedJc.broadcast.Get()) {
+		t.Errorf("Loaded joinedChannel does not match original."+
+			"\nexpected: %+v\nreceived: %+v", ch, loadedJc.broadcast.Get())
+	}
+}
+
+// Tests that joinedChannel.delete deletes the stored joinedChannel from the
+// ekv.
+func Test_joinedChannel_delete(t *testing.T) {
+	kv := versioned.NewKV(ekv.MakeMemstore())
+	rng := fastRNG.NewStreamGenerator(1, 1, csprng.NewSystemRNG)
+	ch, _, err := newTestChannel("name", "description", rng.GetStream())
+	if err != nil {
+		t.Errorf("Failed to create new channel: %+v", err)
+	}
+
+	b, err := broadcast.NewBroadcastChannel(ch, new(mockBroadcastClient), rng)
+	if err != nil {
+		t.Errorf("Failed to create new broadcast channel: %+v", err)
+	}
+
+	jc := &joinedChannel{b}
+
+	err = jc.Store(kv)
+	if err != nil {
+		t.Errorf("Error storing joinedChannel: %+v", err)
+	}
+
+	err = jc.delete(kv)
+	if err != nil {
+		t.Errorf("Error deleting joinedChannel: %+v", err)
+	}
+
+	_, err = kv.Get(makeJoinedChannelKey(ch.ReceptionID), joinedChannelVersion)
+	if ekv.Exists(err) {
+		t.Errorf("joinedChannel found in KV: %+v", err)
+	}
+}
+
+// Consistency test of makeJoinedChannelKey.
+func Test_makeJoinedChannelKey_Consistency(t *testing.T) {
+	values := map[*id.ID]string{
+		id.NewIdFromUInt(0, id.User, t): "JoinedChannelKey-0x0000000000000000000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(1, id.User, t): "JoinedChannelKey-0x0000000000000001000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(2, id.User, t): "JoinedChannelKey-0x0000000000000002000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(3, id.User, t): "JoinedChannelKey-0x0000000000000003000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(4, id.User, t): "JoinedChannelKey-0x0000000000000004000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(5, id.User, t): "JoinedChannelKey-0x0000000000000005000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(6, id.User, t): "JoinedChannelKey-0x0000000000000006000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(7, id.User, t): "JoinedChannelKey-0x0000000000000007000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(8, id.User, t): "JoinedChannelKey-0x0000000000000008000000000000000000000000000000000000000000000000",
+		id.NewIdFromUInt(9, id.User, t): "JoinedChannelKey-0x0000000000000009000000000000000000000000000000000000000000000000",
+	}
+
+	for chID, expected := range values {
+		key := makeJoinedChannelKey(chID)
+
+		if expected != key {
+			t.Errorf("Unexpected key for ID %d.\nexpected: %s\nreceived: %s",
+				binary.BigEndian.Uint64(chID[:8]), expected, key)
+		}
+	}
+
+}
+
+// newTestChannel creates a new cryptoBroadcast.Channel in the same way that
+// cryptoBroadcast.NewChannel does but with a smaller RSA key and salt to make
+// tests run quicker.
+func newTestChannel(name, description string, rng csprng.Source) (
+	*cryptoBroadcast.Channel, *rsa.PrivateKey, error) {
+	// Uses 128 bits instead of 4096 bits
+	pk, err := rsa.GenerateKey(rng, 128)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Uses 16 bits instead of 512 bits
+	salt := cmix.NewSalt(rng, 16)
+
+	channelID, err := cryptoBroadcast.NewChannelID(
+		name, description, salt, rsa.CreatePublicKeyPem(pk.GetPublic()))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &cryptoBroadcast.Channel{
+		ReceptionID: channelID,
+		Name:        name,
+		Description: description,
+		Salt:        salt,
+		RsaPubKey:   pk.GetPublic(),
+	}, pk, nil
+}

channels/manager.go

@@ -11,7 +11,7 @@ import (
 
 type manager struct {
 	// List of all channels
-	channels map[*id.ID]*joinedChannel
+	channels map[id.ID]*joinedChannel
 	mux      sync.RWMutex
 
 	// External references
@@ -53,7 +53,7 @@ func NewManager(kv *versioned.KV, client broadcast.Client,
 
 // JoinChannel joins the given channel. It will fail if the channel has already
 // been joined.
-func (m *manager) JoinChannel(channel cryptoBroadcast.Channel) error {
+func (m *manager) JoinChannel(channel *cryptoBroadcast.Channel) error {
 	err := m.addChannel(channel)
 	if err != nil {
 		return err

channels/send_test.go

@@ -31,8 +31,8 @@ func (m *mockBroadcastChannel) MaxAsymmetricPayloadSize() int {
 	return 123
 }
 
-func (m *mockBroadcastChannel) Get() cryptoBroadcast.Channel {
-	return cryptoBroadcast.Channel{}
+func (m *mockBroadcastChannel) Get() *cryptoBroadcast.Channel {
+	return &cryptoBroadcast.Channel{}
 }
 
 func (m *mockBroadcastChannel) Broadcast(payload []byte, cMixParams cmix.CMIXParams) (
@@ -123,7 +123,7 @@ func (m *mockNameService) ValidateChannelMessage(username string, lease time.Tim
 
 type mockEventModel struct{}
 
-func (m *mockEventModel) JoinChannel(channel cryptoBroadcast.Channel) {}
+func (m *mockEventModel) JoinChannel(channel *cryptoBroadcast.Channel) {}
 
 func (m *mockEventModel) LeaveChannel(channelID *id.ID) {}
 
@@ -164,7 +164,7 @@ func TestSendGeneric(t *testing.T) {
 	validUntil := time.Hour
 	params := new(cmix.CMIXParams)
 
-	m.channels[channelID] = &joinedChannel{
+	m.channels[*channelID] = &joinedChannel{
 		broadcast: &mockBroadcastChannel{},
 	}