Skip to content
Snippets Groups Projects
Select Git revision
  • 41f485a546702500c8710a87f2906b961bbfb58e
  • release default protected
  • 11-22-implement-kv-interface-defined-in-collectiveversionedkvgo
  • hotfix/TestHostPool_UpdateNdf_AddFilter
  • XX-4719/announcementChannels
  • xx-4717/logLevel
  • jonah/noob-channel
  • master protected
  • XX-4707/tagDiskJson
  • xx-4698/notification-retry
  • hotfix/notifylockup
  • syncNodes
  • hotfix/localCB
  • XX-4677/NewChanManagerMobile
  • XX-4689/DmSync
  • duplicatePrefix
  • XX-4601/HavenInvites
  • finalizedUICallbacks
  • XX-4673/AdminKeySync
  • debugNotifID
  • anne/test
  • v4.7.5
  • v4.7.4
  • v4.7.3
  • v4.7.2
  • v4.7.1
  • v4.6.3
  • v4.6.1
  • v4.5.0
  • v4.4.4
  • v4.3.11
  • v4.3.8
  • v4.3.7
  • v4.3.6
  • v4.3.5
  • v4.2.0
  • v4.3.0
  • v4.3.4
  • v4.3.3
  • v4.3.2
  • v4.3.1
41 results

version_vars.go

Blame
  • utils_test.go 3.58 KiB
    ////////////////////////////////////////////////////////////////////////////////
    // Copyright © 2020 xx network SEZC                                           //
    //                                                                            //
    // Use of this source code is governed by a license that can be found in the  //
    // LICENSE file                                                               //
    ////////////////////////////////////////////////////////////////////////////////
    
    package broadcast
    
    import (
    	"gitlab.com/elixxir/client/cmix"
    	"gitlab.com/elixxir/client/cmix/identity/receptionID"
    	"gitlab.com/elixxir/client/cmix/message"
    	"gitlab.com/elixxir/client/cmix/rounds"
    	"gitlab.com/elixxir/primitives/format"
    	"gitlab.com/xx_network/crypto/signature/rsa"
    	"gitlab.com/xx_network/primitives/id"
    	"gitlab.com/xx_network/primitives/id/ephemeral"
    	"math/rand"
    	"sync"
    	"testing"
    	"time"
    )
    
    // newRsaPubKey generates a new random RSA public key for testing.
    func newRsaPubKey(seed int64, t *testing.T) *rsa.PublicKey {
    	prng := rand.New(rand.NewSource(seed))
    	privKey, err := rsa.GenerateKey(prng, 64)
    	if err != nil {
    		t.Errorf("Failed to generate new RSA key: %+v", err)
    	}
    
    	return privKey.GetPublic()
    }
    
    ////////////////////////////////////////////////////////////////////////////////
    // Mock cMix                                                           //
    ////////////////////////////////////////////////////////////////////////////////
    
    type mockCmixHandler struct {
    	processorMap map[id.ID]map[string][]message.Processor
    	sync.Mutex
    }
    
    func newMockCmixHandler() *mockCmixHandler {
    	return &mockCmixHandler{
    		processorMap: make(map[id.ID]map[string][]message.Processor),
    	}
    }
    
    type mockCmix struct {
    	numPrimeBytes int
    	health        bool
    	handler       *mockCmixHandler
    }
    
    func newMockCmix(handler *mockCmixHandler) *mockCmix {
    	return &mockCmix{
    		numPrimeBytes: 4096,
    		health:        true,
    		handler:       handler,
    	}
    }
    
    func (m *mockCmix) GetMaxMessageLength() int {
    	return format.NewMessage(m.numPrimeBytes).ContentsSize()
    }
    
    func (m *mockCmix) Send(recipient *id.ID, fingerprint format.Fingerprint,
    	service message.Service, payload, mac []byte, _ cmix.CMIXParams) (
    	id.Round, ephemeral.Id, error) {
    	msg := format.NewMessage(m.numPrimeBytes)
    	msg.SetContents(payload)
    	msg.SetMac(mac)
    	msg.SetKeyFP(fingerprint)
    
    	m.handler.Lock()
    	defer m.handler.Unlock()
    	for _, p := range m.handler.processorMap[*recipient][service.Tag] {
    		p.Process(msg, receptionID.EphemeralIdentity{}, rounds.Round{})
    	}
    
    	return 0, ephemeral.Id{}, nil
    }
    
    func (m *mockCmix) IsHealthy() bool {
    	return m.health
    }
    
    func (m *mockCmix) AddIdentity(id *id.ID, _ time.Time, _ bool) {
    	m.handler.Lock()
    	defer m.handler.Unlock()
    
    	if _, exists := m.handler.processorMap[*id]; exists {
    		return
    	}
    
    	m.handler.processorMap[*id] = make(map[string][]message.Processor)
    }
    
    func (m *mockCmix) AddService(clientID *id.ID, newService message.Service,
    	response message.Processor) {
    	m.handler.Lock()
    	defer m.handler.Unlock()
    
    	if _, exists := m.handler.processorMap[*clientID][newService.Tag]; !exists {
    		m.handler.processorMap[*clientID][newService.Tag] =
    			[]message.Processor{response}
    		return
    	}
    
    	m.handler.processorMap[*clientID][newService.Tag] =
    		append(m.handler.processorMap[*clientID][newService.Tag], response)
    }
    
    func (m *mockCmix) DeleteClientService(clientID *id.ID) {
    	m.handler.Lock()
    	defer m.handler.Unlock()
    
    	for tag := range m.handler.processorMap[*clientID] {
    		delete(m.handler.processorMap[*clientID], tag)
    	}
    }
    
    func (m *mockCmix) RemoveIdentity(id *id.ID) {
    	m.handler.Lock()
    	defer m.handler.Unlock()
    
    	delete(m.handler.processorMap, *id)
    }