github.com/zignig/go-ipfs@v0.0.0-20141111235910-c9e5fdf55a52/unixfs/io/dagmodifier_test.go (about) 1 package io 2 3 import ( 4 "fmt" 5 "io" 6 "io/ioutil" 7 "testing" 8 9 bs "github.com/jbenet/go-ipfs/blockservice" 10 imp "github.com/jbenet/go-ipfs/importer" 11 "github.com/jbenet/go-ipfs/importer/chunk" 12 mdag "github.com/jbenet/go-ipfs/merkledag" 13 ft "github.com/jbenet/go-ipfs/unixfs" 14 u "github.com/jbenet/go-ipfs/util" 15 16 ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore" 17 logging "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-logging" 18 ) 19 20 func getMockDagServ(t *testing.T) mdag.DAGService { 21 dstore := ds.NewMapDatastore() 22 bserv, err := bs.NewBlockService(dstore, nil) 23 if err != nil { 24 t.Fatal(err) 25 } 26 return mdag.NewDAGService(bserv) 27 } 28 29 func getNode(t *testing.T, dserv mdag.DAGService, size int64) ([]byte, *mdag.Node) { 30 in := io.LimitReader(u.NewTimeSeededRand(), size) 31 node, err := imp.BuildDagFromReader(in, dserv, nil, &chunk.SizeSplitter{500}) 32 if err != nil { 33 t.Fatal(err) 34 } 35 36 dr, err := NewDagReader(node, dserv) 37 if err != nil { 38 t.Fatal(err) 39 } 40 41 b, err := ioutil.ReadAll(dr) 42 if err != nil { 43 t.Fatal(err) 44 } 45 46 return b, node 47 } 48 49 func testModWrite(t *testing.T, beg, size uint64, orig []byte, dm *DagModifier) []byte { 50 newdata := make([]byte, size) 51 r := u.NewTimeSeededRand() 52 r.Read(newdata) 53 54 if size+beg > uint64(len(orig)) { 55 orig = append(orig, make([]byte, (size+beg)-uint64(len(orig)))...) 56 } 57 copy(orig[beg:], newdata) 58 59 nmod, err := dm.WriteAt(newdata, uint64(beg)) 60 if err != nil { 61 t.Fatal(err) 62 } 63 64 if nmod != int(size) { 65 t.Fatalf("Mod length not correct! %d != %d", nmod, size) 66 } 67 68 nd, err := dm.GetNode() 69 if err != nil { 70 t.Fatal(err) 71 } 72 73 rd, err := NewDagReader(nd, dm.dagserv) 74 if err != nil { 75 t.Fatal(err) 76 } 77 78 after, err := ioutil.ReadAll(rd) 79 if err != nil { 80 t.Fatal(err) 81 } 82 83 err = arrComp(after, orig) 84 if err != nil { 85 t.Fatal(err) 86 } 87 return orig 88 } 89 90 func TestDagModifierBasic(t *testing.T) { 91 logging.SetLevel(logging.CRITICAL, "blockservice") 92 logging.SetLevel(logging.CRITICAL, "merkledag") 93 dserv := getMockDagServ(t) 94 b, n := getNode(t, dserv, 50000) 95 96 dagmod, err := NewDagModifier(n, dserv, &chunk.SizeSplitter{Size: 512}) 97 if err != nil { 98 t.Fatal(err) 99 } 100 101 // Within zero block 102 beg := uint64(15) 103 length := uint64(60) 104 105 t.Log("Testing mod within zero block") 106 b = testModWrite(t, beg, length, b, dagmod) 107 108 // Within bounds of existing file 109 beg = 1000 110 length = 4000 111 t.Log("Testing mod within bounds of existing file.") 112 b = testModWrite(t, beg, length, b, dagmod) 113 114 // Extend bounds 115 beg = 49500 116 length = 4000 117 118 t.Log("Testing mod that extends file.") 119 b = testModWrite(t, beg, length, b, dagmod) 120 121 // "Append" 122 beg = uint64(len(b)) 123 length = 3000 124 b = testModWrite(t, beg, length, b, dagmod) 125 126 // Verify reported length 127 node, err := dagmod.GetNode() 128 if err != nil { 129 t.Fatal(err) 130 } 131 132 size, err := ft.DataSize(node.Data) 133 if err != nil { 134 t.Fatal(err) 135 } 136 137 expected := uint64(50000 + 3500 + 3000) 138 if size != expected { 139 t.Fatalf("Final reported size is incorrect [%d != %d]", size, expected) 140 } 141 } 142 143 func TestMultiWrite(t *testing.T) { 144 dserv := getMockDagServ(t) 145 _, n := getNode(t, dserv, 0) 146 147 dagmod, err := NewDagModifier(n, dserv, &chunk.SizeSplitter{Size: 512}) 148 if err != nil { 149 t.Fatal(err) 150 } 151 152 data := make([]byte, 4000) 153 u.NewTimeSeededRand().Read(data) 154 155 for i := 0; i < len(data); i++ { 156 n, err := dagmod.WriteAt(data[i:i+1], uint64(i)) 157 if err != nil { 158 t.Fatal(err) 159 } 160 if n != 1 { 161 t.Fatal("Somehow wrote the wrong number of bytes! (n != 1)") 162 } 163 } 164 nd, err := dagmod.GetNode() 165 if err != nil { 166 t.Fatal(err) 167 } 168 169 read, err := NewDagReader(nd, dserv) 170 if err != nil { 171 t.Fatal(err) 172 } 173 rbuf, err := ioutil.ReadAll(read) 174 if err != nil { 175 t.Fatal(err) 176 } 177 178 err = arrComp(rbuf, data) 179 if err != nil { 180 t.Fatal(err) 181 } 182 } 183 184 func TestMultiWriteCoal(t *testing.T) { 185 dserv := getMockDagServ(t) 186 _, n := getNode(t, dserv, 0) 187 188 dagmod, err := NewDagModifier(n, dserv, &chunk.SizeSplitter{Size: 512}) 189 if err != nil { 190 t.Fatal(err) 191 } 192 193 data := make([]byte, 4000) 194 u.NewTimeSeededRand().Read(data) 195 196 for i := 0; i < len(data); i++ { 197 n, err := dagmod.WriteAt(data[:i+1], 0) 198 if err != nil { 199 t.Fatal(err) 200 } 201 if n != i+1 { 202 t.Fatal("Somehow wrote the wrong number of bytes! (n != 1)") 203 } 204 } 205 nd, err := dagmod.GetNode() 206 if err != nil { 207 t.Fatal(err) 208 } 209 210 read, err := NewDagReader(nd, dserv) 211 if err != nil { 212 t.Fatal(err) 213 } 214 rbuf, err := ioutil.ReadAll(read) 215 if err != nil { 216 t.Fatal(err) 217 } 218 219 err = arrComp(rbuf, data) 220 if err != nil { 221 t.Fatal(err) 222 } 223 } 224 225 func arrComp(a, b []byte) error { 226 if len(a) != len(b) { 227 return fmt.Errorf("Arrays differ in length. %d != %d", len(a), len(b)) 228 } 229 for i, v := range a { 230 if v != b[i] { 231 return fmt.Errorf("Arrays differ at index: %d", i) 232 } 233 } 234 return nil 235 }