github.com/runner-mei/ql@v1.1.0/httpfs_test.go (about) 1 // Copyright (c) 2014 ql Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package ql 6 7 import ( 8 "io" 9 "os" 10 "path" 11 "testing" 12 ) 13 14 func TestHTTP(t *testing.T) { 15 db, err := OpenMem() 16 if err != nil { 17 t.Fatal(err) 18 } 19 if _, _, err = db.Run( 20 NewRWCtx(), 21 ` 22 BEGIN TRANSACTION; 23 CREATE TABLE t (path string); 24 INSERT INTO t VALUES 25 ("/a/b/c/1"), 26 ("/a/b/c/2"), 27 ("/a/b/3"), 28 ("/a/b/4"), 29 ("/a/5"), 30 ("/a/6"), 31 ; 32 COMMIT; 33 `, 34 ); err != nil { 35 t.Fatal(err) 36 } 37 38 fs, err := db.NewHTTPFS("SELECT path, blob(path+`-c`) AS content FROM t") 39 if err != nil { 40 t.Fatal(err) 41 } 42 43 for _, nm := range []string{"/a/b/c/1", "/a/b/4", "/a/5"} { 44 f, err := fs.Open(nm) 45 if err != nil { 46 t.Fatal(err) 47 } 48 49 stat, err := f.Stat() 50 if err != nil { 51 t.Fatal(err) 52 } 53 54 b := make([]byte, 100) 55 n, err := f.Read(b) 56 if err != nil { 57 t.Fatal(nm, n, err) 58 } 59 60 g := string(b[:n]) 61 if e := nm + "-c"; g != e { 62 t.Fatal(g, e) 63 } 64 65 if g, e := stat.Name(), path.Base(nm); g != e { 66 t.Fatal(g, e) 67 } 68 69 if g, e := stat.Size(), int64(len(g)); g != e { 70 t.Fatal(g, e) 71 } 72 73 if g, e := stat.IsDir(), false; g != e { 74 t.Fatal(g, e) 75 } 76 77 b = make([]byte, 100) 78 n, err = f.Read(b) 79 if n != 0 { 80 t.Error(n) 81 } 82 83 if err != io.EOF { 84 t.Fatal(err) 85 } 86 87 if n, err := f.Seek(0, 0); err != nil || n != 0 { 88 t.Fatal(n, err) 89 } 90 91 exp := []byte(nm + "-c") 92 b = make([]byte, 1) 93 for _, e := range exp { 94 n, err := f.Read(b) 95 if n != 1 || err != nil { 96 t.Fatal(n, err) 97 } 98 99 if g := b[0]; g != e { 100 t.Fatal(g, e) 101 } 102 } 103 if n, err := f.Read(b); n != 0 || err != io.EOF { 104 t.Fatal(n, err) 105 } 106 107 if err = f.Close(); err != nil { 108 t.Fatal(err) 109 } 110 111 if n, err := f.Seek(0, 0); err != os.ErrInvalid { 112 t.Fatal(n, err) 113 } 114 } 115 116 if _, err = fs.Open("nonexistent"); err != os.ErrNotExist { 117 t.Fatal(err) 118 } 119 120 // ------------------------------------------------------------------ / 121 d, err := fs.Open("") 122 if err != nil { 123 t.Fatal(err) 124 } 125 126 stat, err := d.Stat() 127 if err != nil { 128 t.Fatal(err) 129 } 130 131 if g, e := stat.IsDir(), true; g != e { 132 t.Fatal(g, e) 133 } 134 135 list, err := d.Readdir(0) 136 if err != nil { 137 t.Fatal(err) 138 } 139 140 if g, e := len(list), 1; g != e { 141 t.Fatal(g, e) 142 } 143 144 var a bool 145 for _, v := range list { 146 switch v.IsDir() { 147 case true: 148 switch v.Name() { 149 case "a": 150 a = true 151 default: 152 t.Fatal(v.Name()) 153 } 154 default: 155 t.Fatal(v.IsDir()) 156 } 157 } 158 if !a { 159 t.Fatal(a) 160 } 161 162 // ------------------------------------------------------------------ a 163 d, err = fs.Open("a") 164 if err != nil { 165 t.Fatal(err) 166 } 167 168 stat, err = d.Stat() 169 if err != nil { 170 t.Fatal(err) 171 } 172 173 if g, e := stat.IsDir(), true; g != e { 174 t.Fatal(g, e) 175 } 176 177 list, err = d.Readdir(0) 178 if err != nil { 179 t.Fatal(err) 180 } 181 182 if g, e := len(list), 3; g != e { 183 t.Fatal(g, e) 184 } 185 186 var aB, a5, a6 bool 187 for _, v := range list { 188 switch v.IsDir() { 189 case true: 190 switch v.Name() { 191 case "b": 192 aB = true 193 default: 194 t.Fatal(v.Name()) 195 } 196 default: 197 switch v.Name() { 198 case "5": 199 a5 = true 200 case "6": 201 a6 = true 202 default: 203 t.Fatal(v.Name()) 204 } 205 } 206 } 207 if !(aB && a5 && a6) { 208 t.Fatal(aB, a5, a6) 209 } 210 211 // ----------------------------------------------------------------- a/ 212 d, err = fs.Open("a/") 213 if err != nil { 214 t.Fatal(err) 215 } 216 217 stat, err = d.Stat() 218 if err != nil { 219 t.Fatal(err) 220 } 221 222 if g, e := stat.IsDir(), true; g != e { 223 t.Fatal(g, e) 224 } 225 226 list, err = d.Readdir(0) 227 if err != nil { 228 t.Fatal(err) 229 } 230 231 if g, e := len(list), 3; g != e { 232 t.Fatal(g, e) 233 } 234 235 for _, v := range list { 236 switch v.IsDir() { 237 case true: 238 switch v.Name() { 239 case "b": 240 aB = true 241 default: 242 t.Fatal(v.Name()) 243 } 244 default: 245 switch v.Name() { 246 case "5": 247 a5 = true 248 case "6": 249 a6 = true 250 default: 251 t.Fatal(v.Name()) 252 } 253 } 254 } 255 if !(aB && a5 && a6) { 256 t.Fatal(aB, a5, a6) 257 } 258 259 // ----------------------------------------------------------------- /a 260 d, err = fs.Open("/a") 261 if err != nil { 262 t.Fatal(err) 263 } 264 265 stat, err = d.Stat() 266 if err != nil { 267 t.Fatal(err) 268 } 269 270 if g, e := stat.IsDir(), true; g != e { 271 t.Fatal(g, e) 272 } 273 274 list, err = d.Readdir(0) 275 if err != nil { 276 t.Fatal(err) 277 } 278 279 if g, e := len(list), 3; g != e { 280 t.Fatal(g, e) 281 } 282 283 for _, v := range list { 284 switch v.IsDir() { 285 case true: 286 switch v.Name() { 287 case "b": 288 aB = true 289 default: 290 t.Fatal(v.Name()) 291 } 292 default: 293 switch v.Name() { 294 case "5": 295 a5 = true 296 case "6": 297 a6 = true 298 default: 299 t.Fatal(v.Name()) 300 } 301 } 302 } 303 if !(aB && a5 && a6) { 304 t.Fatal(aB, a5, a6) 305 } 306 307 // ---------------------------------------------------------------- /a/ 308 d, err = fs.Open("/a/") 309 if err != nil { 310 t.Fatal(err) 311 } 312 313 stat, err = d.Stat() 314 if err != nil { 315 t.Fatal(err) 316 } 317 318 if g, e := stat.IsDir(), true; g != e { 319 t.Fatal(g, e) 320 } 321 322 list, err = d.Readdir(0) 323 if err != nil { 324 t.Fatal(err) 325 } 326 327 if g, e := len(list), 3; g != e { 328 t.Fatal(g, e) 329 } 330 331 for _, v := range list { 332 switch v.IsDir() { 333 case true: 334 switch v.Name() { 335 case "b": 336 aB = true 337 default: 338 t.Fatal(v.Name()) 339 } 340 default: 341 switch v.Name() { 342 case "5": 343 a5 = true 344 case "6": 345 a6 = true 346 default: 347 t.Fatal(v.Name()) 348 } 349 } 350 } 351 if !(aB && a5 && a6) { 352 t.Fatal(aB, a5, a6) 353 } 354 355 // ---------------------------------------------------------------- a/b 356 d, err = fs.Open("a/b") 357 if err != nil { 358 t.Fatal(err) 359 } 360 361 stat, err = d.Stat() 362 if err != nil { 363 t.Fatal(err) 364 } 365 366 if g, e := stat.IsDir(), true; g != e { 367 t.Fatal(g, e) 368 } 369 370 list, err = d.Readdir(0) 371 if err != nil { 372 t.Fatal(err) 373 } 374 375 if g, e := len(list), 3; g != e { 376 t.Fatal(g, e) 377 } 378 379 var aB3, aB4, aBC bool 380 for _, v := range list { 381 switch v.IsDir() { 382 case true: 383 switch v.Name() { 384 case "c": 385 aBC = true 386 default: 387 t.Fatal(v.Name()) 388 } 389 default: 390 switch v.Name() { 391 case "3": 392 aB3 = true 393 case "4": 394 aB4 = true 395 default: 396 t.Fatal(v.Name()) 397 } 398 } 399 } 400 if !(aB3 && aB4 && aBC) { 401 t.Fatal(aB4, aB4, aBC) 402 } 403 404 // --------------------------------------------------------------- a/b/ 405 d, err = fs.Open("a/b/") 406 if err != nil { 407 t.Fatal(err) 408 } 409 410 stat, err = d.Stat() 411 if err != nil { 412 t.Fatal(err) 413 } 414 415 if g, e := stat.IsDir(), true; g != e { 416 t.Fatal(g, e) 417 } 418 419 list, err = d.Readdir(0) 420 if err != nil { 421 t.Fatal(err) 422 } 423 424 if g, e := len(list), 3; g != e { 425 t.Fatal(g, e) 426 } 427 428 for _, v := range list { 429 switch v.IsDir() { 430 case true: 431 switch v.Name() { 432 case "c": 433 aBC = true 434 default: 435 t.Fatal(v.Name()) 436 } 437 default: 438 switch v.Name() { 439 case "3": 440 aB3 = true 441 case "4": 442 aB4 = true 443 default: 444 t.Fatal(v.Name()) 445 } 446 } 447 } 448 if !(aB3 && aB4 && aBC) { 449 t.Fatal(aB4, aB4, aBC) 450 } 451 452 // -------------------------------------------------------------- /a/b/ 453 d, err = fs.Open("/a/b/") 454 if err != nil { 455 t.Fatal(err) 456 } 457 458 stat, err = d.Stat() 459 if err != nil { 460 t.Fatal(err) 461 } 462 463 if g, e := stat.IsDir(), true; g != e { 464 t.Fatal(g, e) 465 } 466 467 list, err = d.Readdir(0) 468 if err != nil { 469 t.Fatal(err) 470 } 471 472 if g, e := len(list), 3; g != e { 473 t.Fatal(g, e) 474 } 475 476 for _, v := range list { 477 switch v.IsDir() { 478 case true: 479 switch v.Name() { 480 case "c": 481 aBC = true 482 default: 483 t.Fatal(v.Name()) 484 } 485 default: 486 switch v.Name() { 487 case "3": 488 aB3 = true 489 case "4": 490 aB4 = true 491 default: 492 t.Fatal(v.Name()) 493 } 494 } 495 } 496 if !(aB3 && aB4 && aBC) { 497 t.Fatal(aB4, aB4, aBC) 498 } 499 500 // --------------------------------------------------------------- /a/b 501 d, err = fs.Open("/a/b") 502 if err != nil { 503 t.Fatal(err) 504 } 505 506 stat, err = d.Stat() 507 if err != nil { 508 t.Fatal(err) 509 } 510 511 if g, e := stat.IsDir(), true; g != e { 512 t.Fatal(g, e) 513 } 514 515 list, err = d.Readdir(0) 516 if err != nil { 517 t.Fatal(err) 518 } 519 520 if g, e := len(list), 3; g != e { 521 t.Fatal(g, e) 522 } 523 524 for _, v := range list { 525 switch v.IsDir() { 526 case true: 527 switch v.Name() { 528 case "c": 529 aBC = true 530 default: 531 t.Fatal(v.Name()) 532 } 533 default: 534 switch v.Name() { 535 case "3": 536 aB3 = true 537 case "4": 538 aB4 = true 539 default: 540 t.Fatal(v.Name()) 541 } 542 } 543 } 544 if !(aB3 && aB4 && aBC) { 545 t.Fatal(aB4, aB4, aBC) 546 } 547 }