swarm/storage: Cleanup and code comments

swarm/storage/resource_test.go

@@ -24,16 +24,16 @@ import (
 	"github.com/ethereum/go-ethereum/contracts/ens/contract"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/crypto/sha3"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
 var (
+	hasher            = MakeHashFunc("SHA3")()
 	zeroAddr          = common.Address{}
-	blockCount = uint64(4200)
+	startBlock        = uint64(4200)
+	resourceFrequency = uint64(42)
 	cleanF            func()
-	hashfunc   = sha3.NewKeccak256()
 	domainName        = "føø.bar"
 )
 
@@ -55,6 +55,7 @@ func (f *fakeBackend) Commit() {
 	f.blocknumber++
 }
 
+// for faking the rpc service, since we don't need the whole node stack
 type FakeRPC struct {
 	backend *fakeBackend
 }
@@ -63,7 +64,8 @@ func (r *FakeRPC) BlockNumber() (string, error) {
 	return strconv.FormatUint(r.backend.blocknumber, 10), nil
 }
 
-func TestResourceValidContent(t *testing.T) {
+// check that signature address matches update signer address
+func TestResourceSignature(t *testing.T) {
 
 	// privkey for signing updates
 	privkey, err := crypto.GenerateKey()
@@ -71,19 +73,20 @@ func TestResourceValidContent(t *testing.T) {
 		return
 	}
 
+	// set up rpc and create resourcehandler
 	rh, _, err, teardownTest := setupTest(privkey, nil, zeroAddr)
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// create a new resource
-	validname, err := idna.ToASCII("føø.bar")
+	validname, err := idna.ToASCII(domainName)
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// generate a hash for block 4200 version 1
-	key := rh.resourceHash(ens.EnsNode(validname), 4200, 1)
+	key := rh.resourceHash(ens.EnsNode(validname), 1, 1)
 	chunk := NewChunk(key, nil)
 
 	// generate some bogus data for the chunk and sign it
@@ -92,7 +95,6 @@ func TestResourceValidContent(t *testing.T) {
 	if err != nil {
 		teardownTest(t, err)
 	}
-	hasher := MakeHashFunc("SHA3")()
 	hasher.Reset()
 	hasher.Write(data)
 	datahash := hasher.Sum(nil)
@@ -121,6 +123,7 @@ func TestResourceValidContent(t *testing.T) {
 	teardownTest(t, nil)
 }
 
+// determine resource update metadata from chunk data
 func TestResourceReverseLookup(t *testing.T) {
 
 	// privkey for signing updates
@@ -129,8 +132,9 @@ func TestResourceReverseLookup(t *testing.T) {
 		return
 	}
 
+	// make fake backend, set up rpc and create resourcehandler
 	backend := &fakeBackend{
-		blocknumber: 4200,
+		blocknumber: startBlock,
 	}
 	rh, _, err, teardownTest := setupTest(privkey, backend, zeroAddr)
 	if err != nil {
@@ -138,17 +142,15 @@ func TestResourceReverseLookup(t *testing.T) {
 	}
 
 	// create a new resource
-	resourcename := "føø.bar"
+	rsrc, err := rh.NewResource(domainName, resourceFrequency)
-	resourcefrequency := uint64(42)
-	rsrc, err := rh.NewResource(resourcename, resourcefrequency)
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// update data
-	fwdBlocks(int(resourcefrequency+1), backend)
+	fwdBlocks(int(resourceFrequency+1), backend)
 	data := []byte("foo")
-	resourcekey, err := rh.Update(resourcename, data)
+	resourcekey, err := rh.Update(domainName, data)
 	if err != nil {
 		teardownTest(t, err)
 	}
@@ -182,6 +184,7 @@ func TestResourceReverseLookup(t *testing.T) {
 	}
 }
 
+// make updates and retrieve them based on periods and versions
 func TestResourceHandler(t *testing.T) {
 
 	// privkey for signing updates
@@ -190,8 +193,9 @@ func TestResourceHandler(t *testing.T) {
 		return
 	}
 
+	// make fake backend, set up rpc and create resourcehandler
 	backend := &fakeBackend{
-		blocknumber: 4200,
+		blocknumber: startBlock,
 	}
 	rh, datadir, err, teardownTest := setupTest(privkey, backend, zeroAddr)
 	if err != nil {
@@ -199,13 +203,11 @@ func TestResourceHandler(t *testing.T) {
 	}
 
 	// create a new resource
-	resourcename := "føø.bar"
+	resourcevalidname, err := idna.ToASCII(domainName)
-	resourcevalidname, err := idna.ToASCII(resourcename)
 	if err != nil {
 		teardownTest(t, err)
 	}
-	resourcefrequency := uint64(42)
+	_, err = rh.NewResource(domainName, resourceFrequency)
-	_, err = rh.NewResource(resourcename, resourcefrequency)
 	if err != nil {
 		teardownTest(t, err)
 	}
@@ -224,39 +226,35 @@ func TestResourceHandler(t *testing.T) {
 	if startblocknumber != backend.blocknumber {
 		teardownTest(t, fmt.Errorf("stored block number %d does not match provided block number %d", startblocknumber, backend.blocknumber))
 	}
-	if chunkfrequency != resourcefrequency {
+	if chunkfrequency != resourceFrequency {
-		teardownTest(t, fmt.Errorf("stored frequency %d does not match provided frequency %d", chunkfrequency, resourcefrequency))
+		teardownTest(t, fmt.Errorf("stored frequency %d does not match provided frequency %d", chunkfrequency, resourceFrequency))
 	}
 
 	// update halfway to first period
 	resourcekey := make(map[string]Key)
-	//blockCount = startblocknumber + (resourcefrequency / 2)
+	fwdBlocks(int(resourceFrequency/2), backend)
-	fwdBlocks(int(resourcefrequency/2), backend)
+	resourcekey["blinky"], err = rh.Update(domainName, []byte("blinky"))
-	resourcekey["blinky"], err = rh.Update(resourcename, []byte("blinky"))
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// update on first period
-	//blockCount = startblocknumber + resourcefrequency
+	fwdBlocks(int(resourceFrequency/2), backend)
-	fwdBlocks(int(resourcefrequency/2), backend)
+	resourcekey["pinky"], err = rh.Update(domainName, []byte("pinky"))
-	resourcekey["pinky"], err = rh.Update(resourcename, []byte("pinky"))
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// update on second period
-	//blockCount = startblocknumber + (resourcefrequency * 2)
+	fwdBlocks(int(resourceFrequency), backend)
-	fwdBlocks(int(resourcefrequency), backend)
+	resourcekey["inky"], err = rh.Update(domainName, []byte("inky"))
-	resourcekey["inky"], err = rh.Update(resourcename, []byte("inky"))
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// update just after second period
-	//blockCount = startblocknumber + (resourcefrequency * 2) + 1
 	fwdBlocks(1, backend)
-	resourcekey["clyde"], err = rh.Update(resourcename, []byte("clyde"))
+	resourcekey["clyde"], err = rh.Update(domainName, []byte("clyde"))
 	if err != nil {
 		teardownTest(t, err)
 	}
@@ -264,28 +262,27 @@ func TestResourceHandler(t *testing.T) {
 	rh.Close()
 
 	// check we can retrieve the updates after close
-	// it will match on second iteration startblocknumber + (resourcefrequency * 3)
+	// it will match on second iteration startblocknumber + (resourceFrequency * 3)
-	blockCount = startblocknumber + (resourcefrequency * 4)
+	fwdBlocks(int(resourceFrequency*2)-1, backend)
-	fwdBlocks(int(resourcefrequency*2)-1, backend)
 
 	rh2, err := NewRawResourceHandler(privkey, datadir, &testCloudStore{}, rawrh.rpcClient, nil)
-	_, err = rh2.LookupLatest(resourcename, true)
+	_, err = rh2.LookupLatest(domainName, true)
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// last update should be "clyde", version two, blockheight startblocknumber + (resourcefrequency * 3)
-	if !bytes.Equal(rh2.resources[resourcename].data, []byte("clyde")) {
+	if !bytes.Equal(rh2.resources[domainName].data, []byte("clyde")) {
-		teardownTest(t, fmt.Errorf("resource data was %v, expected %v", rh2.resources[resourcename].data, []byte("clyde")))
+		teardownTest(t, fmt.Errorf("resource data was %v, expected %v", rh2.resources[domainName].data, []byte("clyde")))
 	}
-	if rh2.resources[resourcename].version != 2 {
+	if rh2.resources[domainName].version != 2 {
-		teardownTest(t, fmt.Errorf("resource version was %d, expected 2", rh2.resources[resourcename].version))
+		teardownTest(t, fmt.Errorf("resource version was %d, expected 2", rh2.resources[domainName].version))
 	}
-	if rh2.resources[resourcename].lastPeriod != 3 {
+	if rh2.resources[domainName].lastPeriod != 3 {
-		teardownTest(t, fmt.Errorf("resource period was %d, expected 3", rh2.resources[resourcename].lastPeriod))
+		teardownTest(t, fmt.Errorf("resource period was %d, expected 3", rh2.resources[domainName].lastPeriod))
 	}
 
-	rsrc, err := NewResource(resourcename, startblocknumber, resourcefrequency, rh2.nameHashFunc)
+	rsrc, err := NewResource(domainName, startblocknumber, resourceFrequency, rh2.nameHashFunc)
 	if err != nil {
 		teardownTest(t, err)
 	}
@@ -295,50 +292,51 @@ func TestResourceHandler(t *testing.T) {
 	}
 
 	// latest block, latest version
-	resource, err := rh2.LookupLatest(resourcename, false) // if key is specified, refresh is implicit
+	resource, err := rh2.LookupLatest(domainName, false) // if key is specified, refresh is implicit
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// check data
 	if !bytes.Equal(resource.data, []byte("clyde")) {
-		teardownTest(t, fmt.Errorf("resource data (latest) was %v, expected %v", rh2.resources[resourcename].data, []byte("clyde")))
+		teardownTest(t, fmt.Errorf("resource data (latest) was %v, expected %v", rh2.resources[domainName].data, []byte("clyde")))
 	}
 
 	// specific block, latest version
-	resource, err = rh2.LookupHistorical(resourcename, 3, true)
+	resource, err = rh2.LookupHistorical(domainName, 3, true)
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// check data
 	if !bytes.Equal(resource.data, []byte("clyde")) {
-		teardownTest(t, fmt.Errorf("resource data (historical) was %v, expected %v", rh2.resources[resourcename].data, []byte("clyde")))
+		teardownTest(t, fmt.Errorf("resource data (historical) was %v, expected %v", rh2.resources[domainName].data, []byte("clyde")))
 	}
 
 	// specific block, specific version
-	resource, err = rh2.LookupVersion(resourcename, 3, 1, true)
+	resource, err = rh2.LookupVersion(domainName, 3, 1, true)
 	if err != nil {
 		teardownTest(t, err)
 	}
 
 	// check data
 	if !bytes.Equal(resource.data, []byte("inky")) {
-		teardownTest(t, fmt.Errorf("resource data (historical) was %v, expected %v", rh2.resources[resourcename].data, []byte("inky")))
+		teardownTest(t, fmt.Errorf("resource data (historical) was %v, expected %v", rh2.resources[domainName].data, []byte("inky")))
 	}
 	teardownTest(t, nil)
 
 }
 
+// create ENS enabled resource update, with and without valid owner
 func TestResourceENSNew(t *testing.T) {
 
-	// privkey for ens owner
+	// privkey for signing updates
 	privkey, err := crypto.GenerateKey()
 	if err != nil {
 		return
 	}
 
-	// privkey for signing updates
+	// privkey for checking wrong owner
 	privkeytwo, err := crypto.GenerateKey()
 	if err != nil {
 		return
@@ -351,6 +349,7 @@ func TestResourceENSNew(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	// set up rpc and create resourcehandler with ENS sim backend
 	rh, _, err, teardownTest := setupTest(privkey, contractbackend, addr)
 	if err != nil {
 		teardownTest(t, err)
@@ -381,6 +380,7 @@ func fwdBlocks(count int, backend *fakeBackend) {
 	}
 }
 
+// create rpc and resourcehandler
 func setupTest(privkey *ecdsa.PrivateKey, contractbackend bind.ContractBackend, ensaddr common.Address) (rh ResourceHandler, datadir string, err error, teardown func(*testing.T, error)) {
 
 	var fsClean func()
@@ -453,12 +453,13 @@ func setupENS(privkey *ecdsa.PrivateKey, sub string, top string) (common.Address
 	// create the domain hash values to pass to the ENS contract methods
 	var tophash [32]byte
 	var subhash [32]byte
-	hashfunc.Reset()
+
-	hashfunc.Write([]byte(top))
+	hasher.Reset()
-	copy(tophash[:], hashfunc.Sum(nil))
+	hasher.Write([]byte(top))
-	hashfunc.Reset()
+	copy(tophash[:], hasher.Sum(nil))
-	hashfunc.Write([]byte(sub))
+	hasher.Reset()
-	copy(subhash[:], hashfunc.Sum(nil))
+	hasher.Write([]byte(sub))
+	copy(subhash[:], hasher.Sum(nil))
 
 	// private key -> address is owner of domain
 	addr := crypto.PubkeyToAddress(privkey.PublicKey)