services/datamanager/collection/collection_test.go

   1 package collection
   2
   3 import (
   4         "git.curoverse.com/arvados.git/sdk/go/blockdigest"
   5         "reflect"
   6         "testing"
   7 )
   8
   9 // This captures the result we expect from
  10 // ReadCollections.Summarize().  Because CollectionUuidToIndex is
  11 // indeterminate, we replace BlockToCollectionIndices with
  12 // BlockToCollectionUuids.
  13 type ExpectedSummary struct {
  14         OwnerToCollectionSize  map[string]int
  15         BlockToReplication     map[blockdigest.BlockDigest]int
  16         BlockToCollectionUuids map[blockdigest.BlockDigest][]string
  17 }
  18
  19 func CompareSummarizedReadCollections(t *testing.T,
  20         summarized ReadCollections,
  21         expected ExpectedSummary) {
  22
  23         if !reflect.DeepEqual(summarized.OwnerToCollectionSize,
  24                 expected.OwnerToCollectionSize) {
  25                 t.Fatalf("Expected summarized OwnerToCollectionSize to look like %+v but instead it is %+v",
  26                         expected.OwnerToCollectionSize,
  27                         summarized.OwnerToCollectionSize)
  28         }
  29
  30         if !reflect.DeepEqual(summarized.BlockToReplication,
  31                 expected.BlockToReplication) {
  32                 t.Fatalf("Expected summarized BlockToReplication to look like %+v but instead it is %+v",
  33                         expected.BlockToReplication,
  34                         summarized.BlockToReplication)
  35         }
  36
  37         summarizedBlockToCollectionUuids :=
  38                 make(map[blockdigest.BlockDigest]map[string]struct{})
  39         for digest, indices := range summarized.BlockToCollectionIndices {
  40                 uuidSet := make(map[string]struct{})
  41                 summarizedBlockToCollectionUuids[digest] = uuidSet
  42                 for _, index := range indices {
  43                         uuidSet[summarized.CollectionIndexToUuid[index]] = struct{}{}
  44                 }
  45         }
  46
  47         expectedBlockToCollectionUuids :=
  48                 make(map[blockdigest.BlockDigest]map[string]struct{})
  49         for digest, uuidSlice := range expected.BlockToCollectionUuids {
  50                 uuidSet := make(map[string]struct{})
  51                 expectedBlockToCollectionUuids[digest] = uuidSet
  52                 for _, uuid := range uuidSlice {
  53                         uuidSet[uuid] = struct{}{}
  54                 }
  55         }
  56
  57         if !reflect.DeepEqual(summarizedBlockToCollectionUuids,
  58                 expectedBlockToCollectionUuids) {
  59                 t.Fatalf("Expected summarized BlockToCollectionUuids to look like %+v but instead it is %+v", expectedBlockToCollectionUuids, summarizedBlockToCollectionUuids)
  60         }
  61 }
  62
  63 func TestSummarizeSimple(t *testing.T) {
  64         rc := MakeTestReadCollections([]TestCollectionSpec{TestCollectionSpec{
  65                 ReplicationLevel: 5,
  66                 Blocks:           []int{1, 2},
  67         }})
  68
  69         rc.Summarize(nil)
  70
  71         c := rc.UuidToCollection["col0"]
  72
  73         blockDigest1 := blockdigest.MakeTestBlockDigest(1)
  74         blockDigest2 := blockdigest.MakeTestBlockDigest(2)
  75
  76         expected := ExpectedSummary{
  77                 OwnerToCollectionSize:  map[string]int{c.OwnerUuid: c.TotalSize},
  78                 BlockToReplication:     map[blockdigest.BlockDigest]int{blockDigest1: 5, blockDigest2: 5},
  79                 BlockToCollectionUuids: map[blockdigest.BlockDigest][]string{blockDigest1: []string{c.Uuid}, blockDigest2: []string{c.Uuid}},
  80         }
  81
  82         CompareSummarizedReadCollections(t, rc, expected)
  83 }
  84
  85 func TestSummarizeOverlapping(t *testing.T) {
  86         rc := MakeTestReadCollections([]TestCollectionSpec{
  87                 TestCollectionSpec{
  88                         ReplicationLevel: 5,
  89                         Blocks:           []int{1, 2},
  90                 },
  91                 TestCollectionSpec{
  92                         ReplicationLevel: 8,
  93                         Blocks:           []int{2, 3},
  94                 },
  95         })
  96
  97         rc.Summarize(nil)
  98
  99         c0 := rc.UuidToCollection["col0"]
 100         c1 := rc.UuidToCollection["col1"]
 101
 102         blockDigest1 := blockdigest.MakeTestBlockDigest(1)
 103         blockDigest2 := blockdigest.MakeTestBlockDigest(2)
 104         blockDigest3 := blockdigest.MakeTestBlockDigest(3)
 105
 106         expected := ExpectedSummary{
 107                 OwnerToCollectionSize: map[string]int{
 108                         c0.OwnerUuid: c0.TotalSize,
 109                         c1.OwnerUuid: c1.TotalSize,
 110                 },
 111                 BlockToReplication: map[blockdigest.BlockDigest]int{
 112                         blockDigest1: 5,
 113                         blockDigest2: 8,
 114                         blockDigest3: 8,
 115                 },
 116                 BlockToCollectionUuids: map[blockdigest.BlockDigest][]string{
 117                         blockDigest1: []string{c0.Uuid},
 118                         blockDigest2: []string{c0.Uuid, c1.Uuid},
 119                         blockDigest3: []string{c1.Uuid},
 120                 },
 121         }
 122
 123         CompareSummarizedReadCollections(t, rc, expected)
 124 }