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  }