github.com/holochain/holochain-proto@v0.1.0-alpha-26.0.20200915073418-5c83169c9b5b/test_data.go (about)

     1  package holochain
     2  
     3  import (
     4  	"crypto/rand"
     5  	"encoding/base64"
     6  	. "github.com/holochain/holochain-proto/hash"
     7  	mrand "math/rand"
     8  	"time"
     9  )
    10  
    11  // GenerateRandomBytes returns securely generated random bytes.
    12  // It will return an error if the system's secure random
    13  // number generator fails to function correctly, in which
    14  // case the caller should not continue.
    15  // @see https://blog.questionable.services/article/generating-secure-random-numbers-crypto-rand/
    16  func generateRandomBytes(n int) ([]byte, error) {
    17  	b := make([]byte, n)
    18  	_, err := rand.Read(b)
    19  	// Note that err == nil only if we read len(b) bytes.
    20  	if err != nil {
    21  		return nil, err
    22  	}
    23  
    24  	return b, nil
    25  }
    26  
    27  // GenerateRandomString returns a URL-safe, base64 encoded
    28  // securely generated random string.
    29  // It will return an error if the system's secure random
    30  // number generator fails to function correctly, in which
    31  // case the caller should not continue.
    32  // @see https://blog.questionable.services/article/generating-secure-random-numbers-crypto-rand/
    33  func generateRandomString(s int) (string, error) {
    34  	b, err := generateRandomBytes(s)
    35  	return base64.URLEncoding.EncodeToString(b), err
    36  }
    37  
    38  // Generate a random Hash string for testing
    39  func genTestStringHash() (hash Hash, err error) {
    40  	mt := setupMultiNodeTesting(1)
    41  	defer mt.cleanupMultiNodeTesting()
    42  
    43  	h := mt.nodes[0]
    44  
    45  	randBytes, err := generateRandomBytes(32)
    46  	hash, err = Sum(h.hashSpec, randBytes)
    47  
    48  	return
    49  }
    50  
    51  // Generate a random string for testing
    52  func genTestString() (s string, err error) {
    53  	h, err := genTestStringHash()
    54  	s = h.String()
    55  	return
    56  }
    57  
    58  // Generate a random Header for testing
    59  func genTestHeader() (header *Header, err error) {
    60  	hashSpec, privKey, now := chainTestSetup()
    61  	headerType, err := genTestString()
    62  	entryString, err := genTestString()
    63  	entry := &GobEntry{C: entryString}
    64  	prevHash, err := genTestStringHash()
    65  	prevType, err := genTestStringHash()
    66  	change, err := genTestStringHash()
    67  
    68  	_, header, err = newHeader(hashSpec, now, headerType, entry, privKey, prevHash, prevType, change)
    69  
    70  	return
    71  }
    72  
    73  func genTestMigrateEntry() (entry MigrateEntry, err error) {
    74  	dnaHash, err := genTestStringHash()
    75  	key, err := genTestStringHash()
    76  	data, err := genTestString()
    77  
    78  	// Note that the k/v order here is different from the resulting JSON.
    79  	// This is deliberate to test that k/v order in code does not influence data
    80  	// output at runtime.
    81  	entry = MigrateEntry{
    82  		Key:     key,
    83  		DNAHash: dnaHash,
    84  		Type:    MigrateEntryTypeOpen,
    85  		Data:    data,
    86  	}
    87  	return
    88  }
    89  
    90  func randomSliceItem(slice []string) string {
    91  	s := mrand.NewSource(time.Now().Unix())
    92  	r := mrand.New(s)
    93  	return slice[r.Intn(len(slice))]
    94  }