More refactor to increase testability

This commit is contained in:
Samuel Hawksby-Robinson 2022-07-01 16:37:53 +01:00
parent 0e878d55d2
commit 215dbac09a
7 changed files with 243 additions and 121 deletions

View File

@ -9,8 +9,6 @@ import (
"io/ioutil"
"net/http"
"net/url"
"github.com/status-im/status-go/multiaccounts"
)
type PairingClient struct {
@ -20,10 +18,10 @@ type PairingClient struct {
certPEM []byte
privateKey *ecdsa.PrivateKey
serverMode Mode
payload *PairingPayloadManager
PayloadManager PayloadManager
}
func NewPairingClient(c *ConnectionParams, db *multiaccounts.Database) (*PairingClient, error) {
func NewPairingClient(c *ConnectionParams, config *PairingPayloadManagerConfig) (*PairingClient, error) {
u, certPem, err := c.Generate()
if err != nil {
return nil, err
@ -46,7 +44,7 @@ func NewPairingClient(c *ConnectionParams, db *multiaccounts.Database) (*Pairing
},
}
pm, err := NewPairingPayloadManager(c.privateKey, db)
pm, err := NewPairingPayloadManager(c.privateKey, config)
if err != nil {
return nil, err
}
@ -57,14 +55,10 @@ func NewPairingClient(c *ConnectionParams, db *multiaccounts.Database) (*Pairing
certPEM: certPem,
privateKey: c.privateKey,
serverMode: c.serverMode,
payload: pm,
PayloadManager: pm,
}, nil
}
func (c *PairingClient) MountPayload(data []byte) error {
return c.payload.pem.Mount(data)
}
func (c *PairingClient) PairAccount() error {
switch c.serverMode {
case Receiving:
@ -78,7 +72,7 @@ func (c *PairingClient) PairAccount() error {
func (c *PairingClient) sendAccountData() error {
c.baseAddress.Path = pairingReceive
_, err := c.Post(c.baseAddress.String(), "application/octet-stream", bytes.NewBuffer(c.payload.pem.ToSend()))
_, err := c.Post(c.baseAddress.String(), "application/octet-stream", bytes.NewBuffer(c.PayloadManager.ToSend()))
if err != nil {
return err
}
@ -98,5 +92,5 @@ func (c *PairingClient) receiveAccountData() error {
return err
}
return c.payload.pem.Receive(payload)
return c.PayloadManager.Receive(payload)
}

View File

@ -104,6 +104,44 @@ func (tpsc *TestPairingServerComponents) SetupPairingServerComponents(t *testing
tpsc.PS, err = NewPairingServer(&Config{
PK: tpsc.EphemeralPK,
Cert: &tpsc.Cert,
Hostname: tpsc.OutboundIP.String()}, nil)
Hostname: tpsc.OutboundIP.String()})
require.NoError(t, err)
}
type MockEncryptOnlyPayloadManager struct {
pem *PayloadEncryptionManager
}
func NewMockEncryptOnlyPayloadManager(pk *ecdsa.PrivateKey) (*MockEncryptOnlyPayloadManager, error) {
pem, err := NewPayloadEncryptionManager(pk)
if err != nil {
return nil, err
}
return &MockEncryptOnlyPayloadManager{
pem: pem,
}, nil
}
func (m *MockEncryptOnlyPayloadManager) Mount() error {
// Make a random payload
data := make([]byte, 32)
_, err := rand.Read(data)
if err != nil {
return err
}
return m.pem.Encrypt(data)
}
func (m *MockEncryptOnlyPayloadManager) Receive(data []byte) error {
return m.pem.Decrypt(data)
}
func (m *MockEncryptOnlyPayloadManager) ToSend() []byte {
return m.pem.ToSend()
}
func (m *MockEncryptOnlyPayloadManager) Received() []byte {
return m.pem.Received()
}

View File

@ -147,9 +147,9 @@ func handlePairingReceive(ps *PairingServer) func(w http.ResponseWriter, r *http
ps.logger.Error("ioutil.ReadAll(r.Body)", zap.Error(err))
}
err = ps.payload.pem.Receive(payload)
err = ps.PayloadManager.Receive(payload)
if err != nil {
ps.logger.Error("ps.payload.Receive(payload)", zap.Error(err))
ps.logger.Error("ps.PayloadManager.Receive(payload)", zap.Error(err))
}
}
}
@ -157,9 +157,9 @@ func handlePairingReceive(ps *PairingServer) func(w http.ResponseWriter, r *http
func handlePairingSend(ps *PairingServer) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/octet-stream")
_, err := w.Write(ps.payload.pem.ToSend())
_, err := w.Write(ps.PayloadManager.ToSend())
if err != nil {
ps.logger.Error("w.Write(ps.payload.ToSend())", zap.Error(err))
ps.logger.Error("w.Write(ps.PayloadManager.ToSend())", zap.Error(err))
}
}
}

View File

@ -19,13 +19,26 @@ import (
"github.com/status-im/status-go/protocol/protobuf"
)
type PayloadManager interface {
Mount() error
Receive(data []byte) error
ToSend() []byte
Received() []byte
}
type PairingPayloadManagerConfig struct {
DB *multiaccounts.Database
KeystorePath, KeyUID, Password string
}
// PairingPayloadManager is responsible for the whole lifecycle of a PairingPayload
type PairingPayloadManager struct {
pem *PayloadEncryptionManager
ppm *PairingPayloadMarshaller
ppr *PairingPayloadRepository
ppr PayloadRepository
}
func NewPairingPayloadManager(pk *ecdsa.PrivateKey, db *multiaccounts.Database) (*PairingPayloadManager, error) {
func NewPairingPayloadManager(pk *ecdsa.PrivateKey, config *PairingPayloadManagerConfig) (*PairingPayloadManager, error) {
pem, err := NewPayloadEncryptionManager(pk)
if err != nil {
return nil, err
@ -34,17 +47,55 @@ func NewPairingPayloadManager(pk *ecdsa.PrivateKey, db *multiaccounts.Database)
return &PairingPayloadManager{
pem: pem,
ppm: NewPairingPayloadMarshaller(),
ppr: NewPairingPayloadRepository(db),
ppr: NewPairingPayloadRepository(config),
}, nil
}
// EncryptionPayload represents the plain text and encrypted text of a Server's payload data
func (ppm *PairingPayloadManager) Mount() error {
err := ppm.ppr.LoadFromSource()
if err != nil {
return err
}
ppm.ppm.LoadPayload(ppm.ppr.GetPayload())
pb, err := ppm.ppm.MarshalToProtobuf()
if err != nil {
return err
}
return ppm.pem.Encrypt(pb)
}
func (ppm *PairingPayloadManager) Receive(data []byte) error {
err := ppm.pem.Decrypt(data)
if err != nil {
return err
}
err = ppm.ppm.UnmarshalProtobuf(ppm.pem.Received())
if err != nil {
return err
}
ppm.ppr.LoadPayload(ppm.ppm.GetPayload())
return ppm.ppr.StoreToSource()
}
func (ppm *PairingPayloadManager) ToSend() []byte {
return ppm.pem.ToSend()
}
func (ppm *PairingPayloadManager) Received() []byte {
return ppm.pem.Received()
}
// EncryptionPayload represents the plain text and encrypted text of payload data
type EncryptionPayload struct {
plain []byte
encrypted []byte
}
// PayloadEncryptionManager is responsible for encrypting and decrypting a Server's payload data
// PayloadEncryptionManager is responsible for encrypting and decrypting payload data
type PayloadEncryptionManager struct {
aesKey []byte
toSend *EncryptionPayload
@ -60,7 +111,7 @@ func NewPayloadEncryptionManager(pk *ecdsa.PrivateKey) (*PayloadEncryptionManage
return &PayloadEncryptionManager{ek, new(EncryptionPayload), new(EncryptionPayload)}, nil
}
func (pem *PayloadEncryptionManager) Mount(data []byte) error {
func (pem *PayloadEncryptionManager) Encrypt(data []byte) error {
ep, err := common.Encrypt(data, pem.aesKey, rand.Reader)
if err != nil {
return err
@ -71,7 +122,7 @@ func (pem *PayloadEncryptionManager) Mount(data []byte) error {
return nil
}
func (pem *PayloadEncryptionManager) Receive(data []byte) error {
func (pem *PayloadEncryptionManager) Decrypt(data []byte) error {
pd, err := common.Decrypt(data, pem.aesKey)
if err != nil {
return err
@ -111,10 +162,14 @@ func NewPairingPayloadMarshaller() *PairingPayloadMarshaller {
return &PairingPayloadMarshaller{PairingPayload: new(PairingPayload)}
}
func (ppm *PairingPayloadMarshaller) Load(payload *PairingPayload) {
func (ppm *PairingPayloadMarshaller) LoadPayload(payload *PairingPayload) {
ppm.PairingPayload = payload
}
func (ppm *PairingPayloadMarshaller) GetPayload() *PairingPayload {
return ppm.PairingPayload
}
func (ppm *PairingPayloadMarshaller) MarshalToProtobuf() ([]byte, error) {
return proto.Marshal(&protobuf.LocalPairingPayload{
Keys: ppm.accountKeysToProtobuf(),
@ -228,40 +283,66 @@ func (ppm *PairingPayloadMarshaller) multiaccountFromProtobuf(pbMultiAccount *pr
}
}
type PayloadHandler interface {
LoadPayload(*PairingPayload)
GetPayload() *PairingPayload
}
type PayloadRepository interface {
PayloadHandler
LoadFromSource() error
StoreToSource() error
}
// PairingPayloadRepository is responsible for loading, parsing, validating and storing PairingServer payload data
type PairingPayloadRepository struct {
*PairingPayload
multiaccountsDB *multiaccounts.Database
keystorePath, keyUID string
}
func NewPairingPayloadRepository(db *multiaccounts.Database) *PairingPayloadRepository {
return &PairingPayloadRepository{
func NewPairingPayloadRepository(config *PairingPayloadManagerConfig) *PairingPayloadRepository {
ppr := &PairingPayloadRepository{
PairingPayload: new(PairingPayload),
multiaccountsDB: db,
}
}
func (ppr *PairingPayloadRepository) Load(payload *PairingPayload) {
if config == nil {
return ppr
}
ppr.multiaccountsDB = config.DB
ppr.keystorePath = config.KeystorePath
ppr.keyUID = config.KeyUID
ppr.password = config.Password
return ppr
}
func (ppr *PairingPayloadRepository) LoadPayload(payload *PairingPayload) {
ppr.PairingPayload = payload
}
func (ppr *PairingPayloadRepository) LoadFromSource(keystorePath, keyUID, password string) error {
err := ppr.loadKeys(keystorePath)
func (ppr *PairingPayloadRepository) GetPayload() *PairingPayload {
return ppr.PairingPayload
}
func (ppr *PairingPayloadRepository) LoadFromSource() error {
err := ppr.loadKeys(ppr.keystorePath)
if err != nil {
return err
}
err = ppr.validateKeys(password)
err = ppr.validateKeys(ppr.password)
if err != nil {
return err
}
ppr.multiaccount, err = ppr.multiaccountsDB.GetAccount(keyUID)
ppr.multiaccount, err = ppr.multiaccountsDB.GetAccount(ppr.keyUID)
if err != nil {
return err
}
ppr.password = password
return nil
}
@ -305,13 +386,13 @@ func (ppr *PairingPayloadRepository) loadKeys(keyStorePath string) error {
return nil
}
func (ppr *PairingPayloadRepository) StoreToSource(keystorePath, password string) error {
err := ppr.validateKeys(password)
func (ppr *PairingPayloadRepository) StoreToSource() error {
err := ppr.validateKeys(ppr.password)
if err != nil {
return err
}
err = ppr.storeKeys(keystorePath)
err = ppr.storeKeys(ppr.keystorePath)
if err != nil {
return err
}

View File

@ -39,10 +39,8 @@ type PayloadMarshallerSuite struct {
teardown func()
db1 *multiaccounts.Database
db2 *multiaccounts.Database
keystore1 string
keystore2 string
config1 *PairingPayloadManagerConfig
config2 *PairingPayloadManagerConfig
}
func setupTestDB(t *testing.T) (*multiaccounts.Database, func()) {
@ -104,22 +102,32 @@ func getFiles(t *testing.T, keyStorePath string) map[string][]byte {
}
func (pms *PayloadMarshallerSuite) SetupTest() {
var db1td func()
var db2td func()
var kstd func()
pms.db1, db1td = setupTestDB(pms.T())
pms.db2, db2td = setupTestDB(pms.T())
pms.keystore1, pms.keystore2, kstd = makeKeystores(pms.T())
db1, db1td := setupTestDB(pms.T())
db2, db2td := setupTestDB(pms.T())
keystore1, keystore2, kstd := makeKeystores(pms.T())
pms.teardown = func() {
db1td()
db2td()
kstd()
}
initKeys(pms.T(), pms.keystore1)
err := pms.db1.SaveAccount(expected)
initKeys(pms.T(), keystore1)
err := db1.SaveAccount(expected)
pms.Require().NoError(err)
pms.config1 = &PairingPayloadManagerConfig{
DB: db1,
KeystorePath: keystore1,
KeyUID: keyUID,
Password: password,
}
pms.config2 = &PairingPayloadManagerConfig{
DB: db2,
KeystorePath: keystore2,
KeyUID: keyUID,
Password: password,
}
}
func (pms *PayloadMarshallerSuite) TearDownTest() {
@ -128,43 +136,43 @@ func (pms *PayloadMarshallerSuite) TearDownTest() {
func (pms *PayloadMarshallerSuite) TestPayloadMarshaller_LoadPayloads() {
// Make and LoadFromSource PairingPayloadRepository 1
pm := NewPairingPayloadRepository(pms.db1)
err := pm.LoadFromSource(pms.keystore1, keyUID, password)
ppr := NewPairingPayloadRepository(pms.config1)
err := ppr.LoadFromSource()
pms.Require().NoError(err)
// TEST PairingPayloadRepository 1 LoadFromSource()
pms.Require().Len(pm.keys, 2)
pms.Require().Len(pm.keys[utils.GetAccount1PKFile()], 489)
pms.Require().Len(pm.keys[utils.GetAccount2PKFile()], 489)
pms.Require().Len(ppr.keys, 2)
pms.Require().Len(ppr.keys[utils.GetAccount1PKFile()], 489)
pms.Require().Len(ppr.keys[utils.GetAccount2PKFile()], 489)
h1 := sha256.New()
h1.Write(pm.keys[utils.GetAccount1PKFile()])
h1.Write(ppr.keys[utils.GetAccount1PKFile()])
pms.Require().Exactly(account1Hash, h1.Sum(nil))
h2 := sha256.New()
h2.Write(pm.keys[utils.GetAccount2PKFile()])
h2.Write(ppr.keys[utils.GetAccount2PKFile()])
pms.Require().Exactly(account2Hash, h2.Sum(nil))
pms.Require().Exactly(expected.ColorHash, pm.multiaccount.ColorHash)
pms.Require().Exactly(expected.ColorID, pm.multiaccount.ColorID)
pms.Require().Exactly(expected.Identicon, pm.multiaccount.Identicon)
pms.Require().Exactly(expected.KeycardPairing, pm.multiaccount.KeycardPairing)
pms.Require().Exactly(expected.KeyUID, pm.multiaccount.KeyUID)
pms.Require().Exactly(expected.Name, pm.multiaccount.Name)
pms.Require().Exactly(expected.Timestamp, pm.multiaccount.Timestamp)
pms.Require().Len(pm.multiaccount.Images, 2)
pms.Require().Equal(password, pm.password)
pms.Require().Exactly(expected.ColorHash, ppr.multiaccount.ColorHash)
pms.Require().Exactly(expected.ColorID, ppr.multiaccount.ColorID)
pms.Require().Exactly(expected.Identicon, ppr.multiaccount.Identicon)
pms.Require().Exactly(expected.KeycardPairing, ppr.multiaccount.KeycardPairing)
pms.Require().Exactly(expected.KeyUID, ppr.multiaccount.KeyUID)
pms.Require().Exactly(expected.Name, ppr.multiaccount.Name)
pms.Require().Exactly(expected.Timestamp, ppr.multiaccount.Timestamp)
pms.Require().Len(ppr.multiaccount.Images, 2)
pms.Require().Equal(password, ppr.password)
}
func (pms *PayloadMarshallerSuite) TestPayloadMarshaller_MarshalToProtobuf() {
// Make and LoadFromSource PairingPayloadRepository 1
ppr := NewPairingPayloadRepository(pms.db1)
err := ppr.LoadFromSource(pms.keystore1, keyUID, password)
ppr := NewPairingPayloadRepository(pms.config1)
err := ppr.LoadFromSource()
pms.Require().NoError(err)
// Make and Load PairingPayloadMarshaller 1
ppm := NewPairingPayloadMarshaller()
ppm.Load(ppr.PairingPayload)
ppm.LoadPayload(ppr.GetPayload())
// TEST PairingPayloadMarshaller 1 MarshalToProtobuf()
pb, err := ppm.MarshalToProtobuf()
@ -178,13 +186,13 @@ func (pms *PayloadMarshallerSuite) TestPayloadMarshaller_MarshalToProtobuf() {
func (pms *PayloadMarshallerSuite) TestPayloadMarshaller_UnmarshalProtobuf() {
// Make and LoadFromSource PairingPayloadRepository 1
ppr := NewPairingPayloadRepository(pms.db1)
err := ppr.LoadFromSource(pms.keystore1, keyUID, password)
ppr := NewPairingPayloadRepository(pms.config1)
err := ppr.LoadFromSource()
pms.Require().NoError(err)
// Make and Load PairingPayloadMarshaller 1
ppm := NewPairingPayloadMarshaller()
ppm.Load(ppr.PairingPayload)
ppm.LoadPayload(ppr.GetPayload())
pb, err := ppm.MarshalToProtobuf()
pms.Require().NoError(err)
@ -226,13 +234,13 @@ func (pms *PayloadMarshallerSuite) TestPayloadMarshaller_UnmarshalProtobuf() {
func (pms *PayloadMarshallerSuite) TestPayloadMarshaller_StorePayloads() {
// Make and LoadFromSource PairingPayloadRepository 1
ppr := NewPairingPayloadRepository(pms.db1)
err := ppr.LoadFromSource(pms.keystore1, keyUID, password)
ppr := NewPairingPayloadRepository(pms.config1)
err := ppr.LoadFromSource()
pms.Require().NoError(err)
// Make and Load PairingPayloadMarshaller 1
ppm := NewPairingPayloadMarshaller()
ppm.Load(ppr.PairingPayload)
ppm.LoadPayload(ppr.PairingPayload)
pb, err := ppm.MarshalToProtobuf()
pms.Require().NoError(err)
@ -244,14 +252,14 @@ func (pms *PayloadMarshallerSuite) TestPayloadMarshaller_StorePayloads() {
pms.Require().NoError(err)
// Make and Load PairingPayloadRepository 2
ppr2 := NewPairingPayloadRepository(pms.db2)
ppr2.Load(ppm2.PairingPayload)
ppr2 := NewPairingPayloadRepository(pms.config2)
ppr2.LoadPayload(ppm2.PairingPayload)
err = ppr2.StoreToSource(pms.keystore2, password)
err = ppr2.StoreToSource()
pms.Require().NoError(err)
// TEST PairingPayloadRepository 2 StoreToSource()
keys := getFiles(pms.T(), pms.keystore2)
keys := getFiles(pms.T(), pms.config2.KeystorePath)
pms.Require().Len(keys, 2)
pms.Require().Len(keys[utils.GetAccount1PKFile()], 489)
@ -265,7 +273,7 @@ func (pms *PayloadMarshallerSuite) TestPayloadMarshaller_StorePayloads() {
h2.Write(keys[utils.GetAccount2PKFile()])
pms.Require().Exactly(account2Hash, h2.Sum(nil))
acc, err := pms.db2.GetAccount(keyUID)
acc, err := pms.config2.DB.GetAccount(keyUID)
pms.Require().NoError(err)
pms.Require().Exactly(expected.ColorHash, acc.ColorHash)

View File

@ -5,8 +5,6 @@ import (
"crypto/tls"
"fmt"
"net"
"github.com/status-im/status-go/multiaccounts"
)
type PairingServer struct {
@ -14,19 +12,23 @@ type PairingServer struct {
pk *ecdsa.PrivateKey
mode Mode
payload *PairingPayloadManager
PayloadManager PayloadManager
}
type Config struct {
// Connection fields
PK *ecdsa.PrivateKey
Cert *tls.Certificate
Hostname string
Mode Mode
// Payload management fields
*PairingPayloadManagerConfig
}
// NewPairingServer returns a *PairingServer init from the given *Config
func NewPairingServer(config *Config, db *multiaccounts.Database) (*PairingServer, error) {
pm, err := NewPairingPayloadManager(config.PK, db)
func NewPairingServer(config *Config) (*PairingServer, error) {
pm, err := NewPairingPayloadManager(config.PK, config.PairingPayloadManagerConfig)
if err != nil {
return nil, err
}
@ -37,7 +39,7 @@ func NewPairingServer(config *Config, db *multiaccounts.Database) (*PairingServe
),
pk: config.PK,
mode: config.Mode,
payload: pm}, nil
PayloadManager: pm}, nil
}
// MakeConnectionParams generates a *ConnectionParams based on the Server's current state
@ -68,10 +70,6 @@ func (s *PairingServer) MakeConnectionParams() (*ConnectionParams, error) {
return NewConnectionParams(netIP, s.port, s.pk, s.cert.Leaf.NotBefore, s.mode), nil
}
func (s *PairingServer) MountPayload(data []byte) error {
return s.payload.pem.Mount(data)
}
func (s *PairingServer) StartPairing() error {
switch s.mode {
case Receiving:

View File

@ -1,7 +1,6 @@
package server
import (
"crypto/rand"
"testing"
"time"
@ -22,6 +21,11 @@ func (s *PairingServerSuite) SetupSuite() {
}
func (s *PairingServerSuite) TestPairingServer_StartPairing() {
// Replace PairingServer.PayloadManager with a MockEncryptOnlyPayloadManager
pm, err := NewMockEncryptOnlyPayloadManager(s.EphemeralPK)
s.Require().NoError(err)
s.PS.PayloadManager = pm
modes := []Mode{
Receiving,
Sending,
@ -30,13 +34,8 @@ func (s *PairingServerSuite) TestPairingServer_StartPairing() {
for _, m := range modes {
s.PS.mode = m
// Random payload
data := make([]byte, 32)
_, err := rand.Read(data)
s.Require().NoError(err)
if m == Sending {
err := s.PS.MountPayload(data)
err := s.PS.PayloadManager.Mount()
s.Require().NoError(err)
}
@ -60,8 +59,12 @@ func (s *PairingServerSuite) TestPairingServer_StartPairing() {
c, err := NewPairingClient(ccp, nil)
s.Require().NoError(err)
// Replace PairingClient.PayloadManager with a MockEncryptOnlyPayloadManager
c.PayloadManager, err = NewMockEncryptOnlyPayloadManager(s.EphemeralPK)
s.Require().NoError(err)
if m == Receiving {
err := c.MountPayload(data)
err := c.PayloadManager.Mount()
s.Require().NoError(err)
}
@ -70,18 +73,18 @@ func (s *PairingServerSuite) TestPairingServer_StartPairing() {
switch m {
case Receiving:
s.Require().Equal(data, s.PS.payload.pem.Received())
s.Require().Equal(s.PS.payload.pem.received.encrypted, c.payload.pem.toSend.encrypted)
s.Require().Nil(s.PS.payload.pem.ToSend())
s.Require().Nil(c.payload.pem.Received())
s.Require().Equal(c.PayloadManager.(*MockEncryptOnlyPayloadManager).pem.toSend.plain, s.PS.PayloadManager.Received())
s.Require().Equal(s.PS.PayloadManager.(*MockEncryptOnlyPayloadManager).pem.received.encrypted, c.PayloadManager.(*MockEncryptOnlyPayloadManager).pem.toSend.encrypted)
s.Require().Nil(s.PS.PayloadManager.ToSend())
s.Require().Nil(c.PayloadManager.Received())
case Sending:
s.Require().Equal(c.payload.pem.Received(), data)
s.Require().Equal(c.payload.pem.received.encrypted, s.PS.payload.pem.toSend.encrypted)
s.Require().Nil(c.payload.pem.ToSend())
s.Require().Nil(s.PS.payload.pem.Received())
s.Require().Equal(c.PayloadManager.Received(), s.PS.PayloadManager.(*MockEncryptOnlyPayloadManager).pem.toSend.plain)
s.Require().Equal(c.PayloadManager.(*MockEncryptOnlyPayloadManager).pem.received.encrypted, s.PS.PayloadManager.(*MockEncryptOnlyPayloadManager).pem.toSend.encrypted)
s.Require().Nil(c.PayloadManager.ToSend())
s.Require().Nil(s.PS.PayloadManager.Received())
}
// Reset the server's PayloadEncryptionManager
s.PS.payload.pem.ResetPayload()
s.PS.PayloadManager.(*MockEncryptOnlyPayloadManager).pem.ResetPayload()
}
}