Stress Test for evoting

stress_test.go

package service

import (
	"fmt"
	"testing"
	"time"

	"github.com/dedis/cothority"
	"github.com/dedis/kyber"
	"github.com/dedis/kyber/util/key"
	"github.com/dedis/onet"

	"github.com/stretchr/testify/require"

	"github.com/dedis/cothority/evoting"
	"github.com/dedis/cothority/evoting/lib"
	"github.com/dedis/cothority/skipchain"
)

func TestStress(t *testing.T) {
	local := onet.NewLocalTest(cothority.Suite)
	defer local.CloseAll()

	idAdmin := uint32(111111)

	voters := []uint32{}
	for i := 100000; i < 1000000; i++ {
		voters = append(voters, uint32(i))
	}

	candidates := []uint32{}
	for i := 1; i <= 7; i++ {
		candidates = append(candidates, uint32(i))
	}

	nodeKP := key.NewKeyPair(cothority.Suite)

	nodes, roster, _ := local.GenBigTree(3, 3, 1, true)
	s0 := local.GetServices(nodes, serviceID)[0].(*Service)

	// Creating master skipchain
	replyLink, err := s0.Link(&evoting.Link{
		Pin:    s0.pin,
		Roster: roster,
		Key:    nodeKP.Public,
		Admins: []uint32{idAdmin},
	})
	require.Nil(t, err)

	signature, err := generateSignature(nodeKP.Private, replyLink.ID, idAdmin)
	require.Nil(t, err)

	// Create a new election
	_, err = s0.Open(&evoting.Open{
		ID: replyLink.ID,
		Election: &lib.Election{
			Creator:    idAdmin,
			Candidates: candidates,
			Users:      voters,
			Roster:     roster,
			End:        time.Now().Unix() + 86400,
		},
		User:      idAdmin,
		Signature: signature,
	})
	require.Nil(t, err)

	done := make(chan string)
	for i := 100000; i < 100200; i += 2 {
		go simulate(&SimulateConfig{
			User:    uint32(i),
			Master:  replyLink.ID,
			Private: nodeKP.Private,
			Roster:  roster,
			Done:    done,
		})
		go simulate(&SimulateConfig{
			User:    uint32(i + 1),
			Master:  replyLink.ID,
			Private: nodeKP.Private,
			Roster:  roster,
			Done:    done,
		})
		time.Sleep(time.Second)
	}

	for i := 0; i < 200; i++ {
		fmt.Println(<-done)
	}
}

type SimulateConfig struct {
	User    uint32
	Master  skipchain.SkipBlockID
	Private kyber.Scalar
	Roster  *onet.Roster
	Done    chan string
}

func simulate(config *SimulateConfig) {
	client := onet.NewClient(cothority.Suite, evoting.ServiceName)
	now := time.Now()
	fmt.Println("Simulating user", config.User)
	sciperToBuf := func(sciper uint32) []byte {
		return []byte{byte(sciper & 0xff), byte((sciper >> 8) & 0xff), byte((sciper >> 16) & 0xff)}
	}

	// Get elections
	sig, err := generateSignature(config.Private, config.Master, config.User)
	if err != nil {
		fmt.Println(err)
		config.Done <- fmt.Sprintf("%d failed: error generating sig", config.User)
		return
	}
	request := &evoting.GetElections{
		User:      config.User,
		Master:    config.Master,
		Stage:     0,
		Signature: sig,
	}
	electionReply := &evoting.GetElectionsReply{}
	if err = client.SendProtobuf(config.Roster.List[0], request, electionReply); err != nil {
		fmt.Println(err)
		config.Done <- fmt.Sprintf("%d failed: error fetching elections", config.User)
		return
	}
	lastElection := electionReply.Elections[len(electionReply.Elections)-1]

	// Cast Ballot
	k, c := lib.Encrypt(lastElection.Key, sciperToBuf(uint32(3)))
	ballot := &lib.Ballot{
		User:  config.User,
		Alpha: k,
		Beta:  c,
	}
	castRequest := &evoting.Cast{
		ID:        lastElection.ID,
		Ballot:    ballot,
		User:      config.User,
		Signature: sig,
	}
	reply := &evoting.CastReply{}
	if err = client.SendProtobuf(config.Roster.List[0], castRequest, reply); err != nil {
		fmt.Println(err)
		config.Done <- fmt.Sprintf("%d failed: error casting ballot", config.User)
		return
	}
	config.Done <- fmt.Sprintf("%d took %s", config.User, time.Since(now))
}