github.com/n1ghtfa1l/go-vnt@v0.6.4-alpha.6/swarm/api/api_test.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package api 18 19 import ( 20 "errors" 21 "fmt" 22 "io" 23 "io/ioutil" 24 "os" 25 "testing" 26 27 "github.com/vntchain/go-vnt/common" 28 "github.com/vntchain/go-vnt/log" 29 "github.com/vntchain/go-vnt/swarm/storage" 30 ) 31 32 func testApi(t *testing.T, f func(*Api)) { 33 datadir, err := ioutil.TempDir("", "bzz-test") 34 if err != nil { 35 t.Fatalf("unable to create temp dir: %v", err) 36 } 37 os.RemoveAll(datadir) 38 defer os.RemoveAll(datadir) 39 dpa, err := storage.NewLocalDPA(datadir) 40 if err != nil { 41 return 42 } 43 api := NewApi(dpa, nil) 44 dpa.Start() 45 f(api) 46 dpa.Stop() 47 } 48 49 type testResponse struct { 50 reader storage.LazySectionReader 51 *Response 52 } 53 54 func checkResponse(t *testing.T, resp *testResponse, exp *Response) { 55 56 if resp.MimeType != exp.MimeType { 57 t.Errorf("incorrect mimeType. expected '%s', got '%s'", exp.MimeType, resp.MimeType) 58 } 59 if resp.Status != exp.Status { 60 t.Errorf("incorrect status. expected '%d', got '%d'", exp.Status, resp.Status) 61 } 62 if resp.Size != exp.Size { 63 t.Errorf("incorrect size. expected '%d', got '%d'", exp.Size, resp.Size) 64 } 65 if resp.reader != nil { 66 content := make([]byte, resp.Size) 67 read, _ := resp.reader.Read(content) 68 if int64(read) != exp.Size { 69 t.Errorf("incorrect content length. expected '%d...', got '%d...'", read, exp.Size) 70 } 71 resp.Content = string(content) 72 } 73 if resp.Content != exp.Content { 74 // if !bytes.Equal(resp.Content, exp.Content) 75 t.Errorf("incorrect content. expected '%s...', got '%s...'", string(exp.Content), string(resp.Content)) 76 } 77 } 78 79 // func expResponse(content []byte, mimeType string, status int) *Response { 80 func expResponse(content string, mimeType string, status int) *Response { 81 log.Trace(fmt.Sprintf("expected content (%v): %v ", len(content), content)) 82 return &Response{mimeType, status, int64(len(content)), content} 83 } 84 85 // func testGet(t *testing.T, api *Api, bzzhash string) *testResponse { 86 func testGet(t *testing.T, api *Api, bzzhash, path string) *testResponse { 87 key := storage.Key(common.Hex2Bytes(bzzhash)) 88 reader, mimeType, status, err := api.Get(key, path) 89 if err != nil { 90 t.Fatalf("unexpected error: %v", err) 91 } 92 quitC := make(chan bool) 93 size, err := reader.Size(quitC) 94 if err != nil { 95 t.Fatalf("unexpected error: %v", err) 96 } 97 log.Trace(fmt.Sprintf("reader size: %v ", size)) 98 s := make([]byte, size) 99 _, err = reader.Read(s) 100 if err != io.EOF { 101 t.Fatalf("unexpected error: %v", err) 102 } 103 reader.Seek(0, 0) 104 return &testResponse{reader, &Response{mimeType, status, size, string(s)}} 105 // return &testResponse{reader, &Response{mimeType, status, reader.Size(), nil}} 106 } 107 108 func TestApiPut(t *testing.T) { 109 testApi(t, func(api *Api) { 110 content := "hello" 111 exp := expResponse(content, "text/plain", 0) 112 // exp := expResponse([]byte(content), "text/plain", 0) 113 key, err := api.Put(content, exp.MimeType) 114 if err != nil { 115 t.Fatalf("unexpected error: %v", err) 116 } 117 resp := testGet(t, api, key.String(), "") 118 checkResponse(t, resp, exp) 119 }) 120 } 121 122 // testResolver implements the Resolver interface and either returns the given 123 // hash if it is set, or returns a "name not found" error 124 type testResolver struct { 125 hash *common.Hash 126 } 127 128 func newTestResolver(addr string) *testResolver { 129 r := &testResolver{} 130 if addr != "" { 131 hash := common.HexToHash(addr) 132 r.hash = &hash 133 } 134 return r 135 } 136 137 func (t *testResolver) Resolve(addr string) (string, error) { 138 if t.hash == nil { 139 return "", fmt.Errorf("DNS name not found: %q", addr) 140 } 141 hash := *t.hash 142 143 return hash.Hex(), nil 144 } 145 146 // TestAPIResolve tests resolving URIs which can either contain content hashes 147 // or VNS names 148 func TestAPIResolve(t *testing.T) { 149 ensAddr := "swarm.vnt" 150 hashAddr := "1111111111111111111111111111111111111111111111111111111111111111" 151 resolvedAddr := "2222222222222222222222222222222222222222222222222222222222222222" 152 doesResolve := newTestResolver(resolvedAddr) 153 doesntResolve := newTestResolver("") 154 155 type test struct { 156 desc string 157 dns Resolver 158 addr string 159 immutable bool 160 result string 161 expectErr error 162 } 163 164 tests := []*test{ 165 { 166 desc: "DNS not configured, hash address, returns hash address", 167 dns: nil, 168 addr: hashAddr, 169 result: hashAddr, 170 }, 171 { 172 desc: "DNS not configured, VNS address, returns error", 173 dns: nil, 174 addr: ensAddr, 175 expectErr: errors.New(`no DNS to resolve name: "swarm.vnt"`), 176 }, 177 { 178 desc: "DNS configured, hash address, hash resolves, returns resolved address", 179 dns: doesResolve, 180 addr: hashAddr, 181 result: resolvedAddr, 182 }, 183 { 184 desc: "DNS configured, immutable hash address, hash resolves, returns hash address", 185 dns: doesResolve, 186 addr: hashAddr, 187 immutable: true, 188 result: hashAddr, 189 }, 190 { 191 desc: "DNS configured, hash address, hash doesn't resolve, returns hash address", 192 dns: doesntResolve, 193 addr: hashAddr, 194 result: hashAddr, 195 }, 196 { 197 desc: "DNS configured, VNS address, name resolves, returns resolved address", 198 dns: doesResolve, 199 addr: ensAddr, 200 result: resolvedAddr, 201 }, 202 { 203 desc: "DNS configured, immutable VNS address, name resolves, returns error", 204 dns: doesResolve, 205 addr: ensAddr, 206 immutable: true, 207 expectErr: errors.New(`immutable address not a content hash: "swarm.vnt"`), 208 }, 209 { 210 desc: "DNS configured, VNS address, name doesn't resolve, returns error", 211 dns: doesntResolve, 212 addr: ensAddr, 213 expectErr: errors.New(`DNS name not found: "swarm.vnt"`), 214 }, 215 } 216 for _, x := range tests { 217 t.Run(x.desc, func(t *testing.T) { 218 api := &Api{dns: x.dns} 219 uri := &URI{Addr: x.addr, Scheme: "bzz"} 220 if x.immutable { 221 uri.Scheme = "bzz-immutable" 222 } 223 res, err := api.Resolve(uri) 224 if err == nil { 225 if x.expectErr != nil { 226 t.Fatalf("expected error %q, got result %q", x.expectErr, res) 227 } 228 if res.String() != x.result { 229 t.Fatalf("expected result %q, got %q", x.result, res) 230 } 231 } else { 232 if x.expectErr == nil { 233 t.Fatalf("expected no error, got %q", err) 234 } 235 if err.Error() != x.expectErr.Error() { 236 t.Fatalf("expected error %q, got %q", x.expectErr, err) 237 } 238 } 239 }) 240 } 241 } 242 243 func TestMultiResolver(t *testing.T) { 244 doesntResolve := newTestResolver("") 245 246 vntAddr := "swarm.vnt" 247 vntHash := "0x2222222222222222222222222222222222222222222222222222222222222222" 248 vntResolve := newTestResolver(vntHash) 249 250 testAddr := "swarm.test" 251 testHash := "0x1111111111111111111111111111111111111111111111111111111111111111" 252 testResolve := newTestResolver(testHash) 253 254 tests := []struct { 255 desc string 256 r Resolver 257 addr string 258 result string 259 err error 260 }{ 261 { 262 desc: "No resolvers, returns error", 263 r: NewMultiResolver(), 264 err: NewNoResolverError(""), 265 }, 266 { 267 desc: "One default resolver, returns resolved address", 268 r: NewMultiResolver(MultiResolverOptionWithResolver(vntResolve, "")), 269 addr: vntAddr, 270 result: vntHash, 271 }, 272 { 273 desc: "Two default resolvers, returns resolved address", 274 r: NewMultiResolver( 275 MultiResolverOptionWithResolver(vntResolve, ""), 276 MultiResolverOptionWithResolver(vntResolve, ""), 277 ), 278 addr: vntAddr, 279 result: vntHash, 280 }, 281 { 282 desc: "Two default resolvers, first doesn't resolve, returns resolved address", 283 r: NewMultiResolver( 284 MultiResolverOptionWithResolver(doesntResolve, ""), 285 MultiResolverOptionWithResolver(vntResolve, ""), 286 ), 287 addr: vntAddr, 288 result: vntHash, 289 }, 290 { 291 desc: "Default resolver doesn't resolve, tld resolver resolve, returns resolved address", 292 r: NewMultiResolver( 293 MultiResolverOptionWithResolver(doesntResolve, ""), 294 MultiResolverOptionWithResolver(vntResolve, "vnt"), 295 ), 296 addr: vntAddr, 297 result: vntHash, 298 }, 299 { 300 desc: "Three TLD resolvers, third resolves, returns resolved address", 301 r: NewMultiResolver( 302 MultiResolverOptionWithResolver(doesntResolve, "vnt"), 303 MultiResolverOptionWithResolver(doesntResolve, "vnt"), 304 MultiResolverOptionWithResolver(vntResolve, "vnt"), 305 ), 306 addr: vntAddr, 307 result: vntHash, 308 }, 309 { 310 desc: "One TLD resolver doesn't resolve, returns error", 311 r: NewMultiResolver( 312 MultiResolverOptionWithResolver(doesntResolve, ""), 313 MultiResolverOptionWithResolver(vntResolve, "vnt"), 314 ), 315 addr: vntAddr, 316 result: vntHash, 317 }, 318 { 319 desc: "One defautl and one TLD resolver, all doesn't resolve, returns error", 320 r: NewMultiResolver( 321 MultiResolverOptionWithResolver(doesntResolve, ""), 322 MultiResolverOptionWithResolver(doesntResolve, "vnt"), 323 ), 324 addr: vntAddr, 325 result: vntHash, 326 err: errors.New(`DNS name not found: "swarm.vnt"`), 327 }, 328 { 329 desc: "Two TLD resolvers, both resolve, returns resolved address", 330 r: NewMultiResolver( 331 MultiResolverOptionWithResolver(vntResolve, "vnt"), 332 MultiResolverOptionWithResolver(testResolve, "test"), 333 ), 334 addr: testAddr, 335 result: testHash, 336 }, 337 { 338 desc: "One TLD resolver, no default resolver, returns error for different TLD", 339 r: NewMultiResolver( 340 MultiResolverOptionWithResolver(vntResolve, "vnt"), 341 ), 342 addr: testAddr, 343 err: NewNoResolverError("test"), 344 }, 345 } 346 for _, x := range tests { 347 t.Run(x.desc, func(t *testing.T) { 348 res, err := x.r.Resolve(x.addr) 349 if err == nil { 350 if x.err != nil { 351 t.Fatalf("expected error %q, got result %q", x.err, res) 352 } 353 if res != x.result { 354 t.Fatalf("expected result %q, got %q", x.result, res) 355 } 356 } else { 357 if x.err == nil { 358 t.Fatalf("expected no error, got %q", err) 359 } 360 if err.Error() != x.err.Error() { 361 t.Fatalf("expected error %q, got %q", x.err, err) 362 } 363 } 364 }) 365 } 366 }