6260: so many golint complaints!!

[arvados.git] / services / datamanager / collection / collection_test.go

diff --git a/services/datamanager/collection/collection_test.go b/services/datamanager/collection/collection_test.go
index d42b2c95dc9459095fb318866529e7e48a752105..07c82e1abc0b5581c523683b4947e7d094f7c9cd 100644 (file)
--- a/services/datamanager/collection/collection_test.go
+++ b/services/datamanager/collection/collection_test.go
@@ -2,50 +2,51 @@ package collection
 
 import (
        "git.curoverse.com/arvados.git/sdk/go/blockdigest"
-       "reflect"
+       . "gopkg.in/check.v1"
        "testing"
 )
 
+// Gocheck boilerplate
+func Test(t *testing.T) {
+       TestingT(t)
+}
+
+type MySuite struct{}
+
+var _ = Suite(&MySuite{})
+
 // This captures the result we expect from
-// ReadCollections.Summarize().  Because CollectionUuidToIndex is
+// ReadCollections.Summarize().  Because CollectionUUIDToIndex is
 // indeterminate, we replace BlockToCollectionIndices with
 // BlockToCollectionUuids.
 type ExpectedSummary struct {
-       OwnerToCollectionSize  map[string]int
-       BlockToReplication     map[blockdigest.BlockDigest]int
-       BlockToCollectionUuids map[blockdigest.BlockDigest][]string
+       OwnerToCollectionSize     map[string]int
+       BlockToDesiredReplication map[blockdigest.DigestWithSize]int
+       BlockToCollectionUuids    map[blockdigest.DigestWithSize][]string
 }
 
-func CompareSummarizedReadCollections(t *testing.T,
+func CompareSummarizedReadCollections(c *C,
        summarized ReadCollections,
        expected ExpectedSummary) {
 
-       if !reflect.DeepEqual(summarized.OwnerToCollectionSize,
-               expected.OwnerToCollectionSize) {
-               t.Fatalf("Expected summarized OwnerToCollectionSize to look like %+v but instead it is %+v",
-                       expected.OwnerToCollectionSize,
-                       summarized.OwnerToCollectionSize)
-       }
+       c.Assert(summarized.OwnerToCollectionSize, DeepEquals,
+               expected.OwnerToCollectionSize)
 
-       if !reflect.DeepEqual(summarized.BlockToReplication,
-               expected.BlockToReplication) {
-               t.Fatalf("Expected summarized BlockToReplication to look like %+v but instead it is %+v",
-                       expected.BlockToReplication,
-                       summarized.BlockToReplication)
-       }
+       c.Assert(summarized.BlockToDesiredReplication, DeepEquals,
+               expected.BlockToDesiredReplication)
 
        summarizedBlockToCollectionUuids :=
-               make(map[blockdigest.BlockDigest]map[string]struct{})
+               make(map[blockdigest.DigestWithSize]map[string]struct{})
        for digest, indices := range summarized.BlockToCollectionIndices {
                uuidSet := make(map[string]struct{})
                summarizedBlockToCollectionUuids[digest] = uuidSet
                for _, index := range indices {
-                       uuidSet[summarized.CollectionIndexToUuid[index]] = struct{}{}
+                       uuidSet[summarized.CollectionIndexToUUID[index]] = struct{}{}
                }
        }
 
        expectedBlockToCollectionUuids :=
-               make(map[blockdigest.BlockDigest]map[string]struct{})
+               make(map[blockdigest.DigestWithSize]map[string]struct{})
        for digest, uuidSlice := range expected.BlockToCollectionUuids {
                uuidSet := make(map[string]struct{})
                expectedBlockToCollectionUuids[digest] = uuidSet
@@ -54,13 +55,11 @@ func CompareSummarizedReadCollections(t *testing.T,
                }
        }
 
-       if !reflect.DeepEqual(summarizedBlockToCollectionUuids,
-               expectedBlockToCollectionUuids) {
-               t.Fatalf("Expected summarized BlockToCollectionUuids to look like %+v but instead it is %+v", expectedBlockToCollectionUuids, summarizedBlockToCollectionUuids)
-       }
+       c.Assert(summarizedBlockToCollectionUuids, DeepEquals,
+               expectedBlockToCollectionUuids)
 }
 
-func TestSummarizeSimple(t *testing.T) {
+func (s *MySuite) TestSummarizeSimple(checker *C) {
        rc := MakeTestReadCollections([]TestCollectionSpec{TestCollectionSpec{
                ReplicationLevel: 5,
                Blocks:           []int{1, 2},
@@ -68,21 +67,21 @@ func TestSummarizeSimple(t *testing.T) {
 
        rc.Summarize(nil)
 
-       c := rc.UuidToCollection["col0"]
+       c := rc.UUIDToCollection["col0"]
 
-       blockDigest1 := blockdigest.MakeTestBlockDigest(1)
-       blockDigest2 := blockdigest.MakeTestBlockDigest(2)
+       blockDigest1 := blockdigest.MakeTestDigestWithSize(1)
+       blockDigest2 := blockdigest.MakeTestDigestWithSize(2)
 
        expected := ExpectedSummary{
-               OwnerToCollectionSize:  map[string]int{c.OwnerUuid: c.TotalSize},
-               BlockToReplication:     map[blockdigest.BlockDigest]int{blockDigest1: 5, blockDigest2: 5},
-               BlockToCollectionUuids: map[blockdigest.BlockDigest][]string{blockDigest1: []string{c.Uuid}, blockDigest2: []string{c.Uuid}},
+               OwnerToCollectionSize:     map[string]int{c.OwnerUUID: c.TotalSize},
+               BlockToDesiredReplication: map[blockdigest.DigestWithSize]int{blockDigest1: 5, blockDigest2: 5},
+               BlockToCollectionUuids:    map[blockdigest.DigestWithSize][]string{blockDigest1: []string{c.UUID}, blockDigest2: []string{c.UUID}},
        }
 
-       CompareSummarizedReadCollections(t, rc, expected)
+       CompareSummarizedReadCollections(checker, rc, expected)
 }
 
-func TestSummarizeOverlapping(t *testing.T) {
+func (s *MySuite) TestSummarizeOverlapping(checker *C) {
        rc := MakeTestReadCollections([]TestCollectionSpec{
                TestCollectionSpec{
                        ReplicationLevel: 5,
@@ -96,29 +95,29 @@ func TestSummarizeOverlapping(t *testing.T) {
 
        rc.Summarize(nil)
 
-       c0 := rc.UuidToCollection["col0"]
-       c1 := rc.UuidToCollection["col1"]
+       c0 := rc.UUIDToCollection["col0"]
+       c1 := rc.UUIDToCollection["col1"]
 
-       blockDigest1 := blockdigest.MakeTestBlockDigest(1)
-       blockDigest2 := blockdigest.MakeTestBlockDigest(2)
-       blockDigest3 := blockdigest.MakeTestBlockDigest(3)
+       blockDigest1 := blockdigest.MakeTestDigestWithSize(1)
+       blockDigest2 := blockdigest.MakeTestDigestWithSize(2)
+       blockDigest3 := blockdigest.MakeTestDigestWithSize(3)
 
        expected := ExpectedSummary{
                OwnerToCollectionSize: map[string]int{
-                       c0.OwnerUuid: c0.TotalSize,
-                       c1.OwnerUuid: c1.TotalSize,
+                       c0.OwnerUUID: c0.TotalSize,
+                       c1.OwnerUUID: c1.TotalSize,
                },
-               BlockToReplication: map[blockdigest.BlockDigest]int{
+               BlockToDesiredReplication: map[blockdigest.DigestWithSize]int{
                        blockDigest1: 5,
                        blockDigest2: 8,
                        blockDigest3: 8,
                },
-               BlockToCollectionUuids: map[blockdigest.BlockDigest][]string{
-                       blockDigest1: []string{c0.Uuid},
-                       blockDigest2: []string{c0.Uuid, c1.Uuid},
-                       blockDigest3: []string{c1.Uuid},
+               BlockToCollectionUuids: map[blockdigest.DigestWithSize][]string{
+                       blockDigest1: []string{c0.UUID},
+                       blockDigest2: []string{c0.UUID, c1.UUID},
+                       blockDigest3: []string{c1.UUID},
                },
        }
 
-       CompareSummarizedReadCollections(t, rc, expected)
+       CompareSummarizedReadCollections(checker, rc, expected)
 }