test_test.go

Documentation: github.com/shurcooL/vfsgen/test

     1  package test_test
     2  
     3  import (
     4  	"fmt"
     5  	"io"
     6  	"log"
     7  	"net/http"
     8  	"os"
     9  
    10  	"github.com/shurcooL/httpfs/vfsutil"
    11  	"github.com/shurcooL/httpgzip"
    12  )
    13  
    14  //go:generate go run test_gen.go
    15  
    16  // Basic functionality test.
    17  func Example_basic() {
    18  	var fs http.FileSystem = assets
    19  
    20  	walkFn := func(path string, fi os.FileInfo, err error) error {
    21  		if err != nil {
    22  			log.Printf("can't stat file %s: %v\n", path, err)
    23  			return nil
    24  		}
    25  
    26  		fmt.Println(path)
    27  		if fi.IsDir() {
    28  			return nil
    29  		}
    30  
    31  		b, err := vfsutil.ReadFile(fs, path)
    32  		fmt.Printf("%q %v\n", string(b), err)
    33  		return nil
    34  	}
    35  
    36  	err := vfsutil.Walk(fs, "/", walkFn)
    37  	if err != nil {
    38  		panic(err)
    39  	}
    40  
    41  	// Output:
    42  	// /
    43  	// /folderA
    44  	// /folderA/file1.txt
    45  	// "Stuff in /folderA/file1.txt." <nil>
    46  	// /folderA/file2.txt
    47  	// "Stuff in /folderA/file2.txt." <nil>
    48  	// /folderB
    49  	// /folderB/folderC
    50  	// /folderB/folderC/file3.txt
    51  	// "Stuff in /folderB/folderC/file3.txt." <nil>
    52  	// /not-worth-compressing-file.txt
    53  	// "Its normal contents are here." <nil>
    54  	// /sample-file.txt
    55  	// "This file compresses well. Blaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah!" <nil>
    56  }
    57  
    58  func Example_compressed() {
    59  	// Compressed file system.
    60  	var fs http.FileSystem = assets
    61  
    62  	walkFn := func(path string, fi os.FileInfo, err error) error {
    63  		if err != nil {
    64  			log.Printf("can't stat file %s: %v\n", path, err)
    65  			return nil
    66  		}
    67  
    68  		fmt.Println(path)
    69  		if fi.IsDir() {
    70  			return nil
    71  		}
    72  
    73  		f, err := fs.Open(path)
    74  		if err != nil {
    75  			fmt.Printf("fs.Open(%q): %v\n", path, err)
    76  			return nil
    77  		}
    78  		defer f.Close()
    79  
    80  		b, err := io.ReadAll(f)
    81  		fmt.Printf("%q %v\n", string(b), err)
    82  
    83  		if gzipFile, ok := f.(httpgzip.GzipByter); ok {
    84  			b := gzipFile.GzipBytes()
    85  			fmt.Printf("%q\n", string(b))
    86  		} else {
    87  			fmt.Println("<not compressed>")
    88  		}
    89  		return nil
    90  	}
    91  
    92  	err := vfsutil.Walk(fs, "/", walkFn)
    93  	if err != nil {
    94  		panic(err)
    95  	}
    96  
    97  	// Output:
    98  	// /
    99  	// /folderA
   100  	// /folderA/file1.txt
   101  	// "Stuff in /folderA/file1.txt." <nil>
   102  	// <not compressed>
   103  	// /folderA/file2.txt
   104  	// "Stuff in /folderA/file2.txt." <nil>
   105  	// <not compressed>
   106  	// /folderB
   107  	// /folderB/folderC
   108  	// /folderB/folderC/file3.txt
   109  	// "Stuff in /folderB/folderC/file3.txt." <nil>
   110  	// <not compressed>
   111  	// /not-worth-compressing-file.txt
   112  	// "Its normal contents are here." <nil>
   113  	// <not compressed>
   114  	// /sample-file.txt
   115  	// "This file compresses well. Blaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah!" <nil>
   116  	// "\x1f\x8b\b\x00\x00\x00\x00\x00\x02\xff\n\xc9\xc8,VH\xcb\xccIUH\xce\xcf-(J-.N-V(O\xcd\xc9\xd1Sp\xcaI\x1c\xd4 C\x11\x10\x00\x00\xff\xff\xe7G\x81:\xbd\x00\x00\x00"
   117  }
   118  
   119  func Example_readTwoOpenedCompressedFiles() {
   120  	var fs http.FileSystem = assets
   121  
   122  	f0, err := fs.Open("/sample-file.txt")
   123  	if err != nil {
   124  		panic(err)
   125  	}
   126  	defer f0.Close()
   127  	_ = f0.(httpgzip.GzipByter)
   128  	f1, err := fs.Open("/sample-file.txt")
   129  	if err != nil {
   130  		panic(err)
   131  	}
   132  	defer f1.Close()
   133  	_ = f1.(httpgzip.GzipByter)
   134  
   135  	_, err = io.CopyN(os.Stdout, f0, 9)
   136  	if err != nil {
   137  		panic(err)
   138  	}
   139  	_, err = io.CopyN(os.Stdout, f1, 9)
   140  	if err != nil {
   141  		panic(err)
   142  	}
   143  
   144  	// Output:
   145  	// This fileThis file
   146  }
   147  
   148  func Example_readTwoOpenedUncompressedFiles() {
   149  	var fs http.FileSystem = assets
   150  
   151  	f0, err := fs.Open("/not-worth-compressing-file.txt")
   152  	if err != nil {
   153  		panic(err)
   154  	}
   155  	defer f0.Close()
   156  	_ = f0.(httpgzip.NotWorthGzipCompressing)
   157  	f1, err := fs.Open("/not-worth-compressing-file.txt")
   158  	if err != nil {
   159  		panic(err)
   160  	}
   161  	defer f1.Close()
   162  	_ = f1.(httpgzip.NotWorthGzipCompressing)
   163  
   164  	_, err = io.CopyN(os.Stdout, f0, 9)
   165  	if err != nil {
   166  		panic(err)
   167  	}
   168  	_, err = io.CopyN(os.Stdout, f1, 9)
   169  	if err != nil {
   170  		panic(err)
   171  	}
   172  
   173  	// Output:
   174  	// Its normaIts norma
   175  }
   176  
   177  func Example_modTime() {
   178  	var fs http.FileSystem = assets
   179  
   180  	f, err := fs.Open("/sample-file.txt")
   181  	if err != nil {
   182  		panic(err)
   183  	}
   184  	defer f.Close()
   185  
   186  	fi, err := f.Stat()
   187  	if err != nil {
   188  		panic(err)
   189  	}
   190  
   191  	fmt.Println(fi.ModTime())
   192  
   193  	// Output:
   194  	// 0001-01-01 00:00:00 +0000 UTC
   195  }
   196  
   197  func Example_seek() {
   198  	var fs http.FileSystem = assets
   199  
   200  	f, err := fs.Open("/sample-file.txt")
   201  	if err != nil {
   202  		panic(err)
   203  	}
   204  	defer f.Close()
   205  
   206  	_, err = io.CopyN(os.Stdout, f, 5)
   207  	if err != nil {
   208  		panic(err)
   209  	}
   210  	_, err = f.Seek(22, io.SeekCurrent)
   211  	if err != nil {
   212  		panic(err)
   213  	}
   214  	_, err = io.CopyN(os.Stdout, f, 10)
   215  	if err != nil {
   216  		panic(err)
   217  	}
   218  	fmt.Print("...")
   219  	_, err = f.Seek(-4, io.SeekEnd)
   220  	if err != nil {
   221  		panic(err)
   222  	}
   223  	_, err = io.Copy(os.Stdout, f)
   224  	if err != nil {
   225  		panic(err)
   226  	}
   227  	_, err = f.Seek(3, io.SeekStart)
   228  	if err != nil {
   229  		panic(err)
   230  	}
   231  	_, err = f.Seek(1, io.SeekCurrent)
   232  	if err != nil {
   233  		panic(err)
   234  	}
   235  	_, err = io.CopyN(os.Stdout, f, 22)
   236  	if err != nil {
   237  		panic(err)
   238  	}
   239  
   240  	// Output:
   241  	// This Blaaaaaaaa...aah! file compresses well.
   242  }
   243  
   244  type fisStringer []os.FileInfo
   245  
   246  func (fis fisStringer) String() string {
   247  	var s = "[ "
   248  	for _, fi := range fis {
   249  		s += fi.Name() + " "
   250  	}
   251  	return s + "]"
   252  }
   253  
   254  func Example_seekDir1() {
   255  	var fs http.FileSystem = assets
   256  
   257  	f, err := fs.Open("/")
   258  	if err != nil {
   259  		panic(err)
   260  	}
   261  	defer f.Close()
   262  
   263  	fis, err := f.Readdir(0)
   264  	fmt.Println(fisStringer(fis), err)
   265  
   266  	// Output:
   267  	// [ folderA folderB not-worth-compressing-file.txt sample-file.txt ] <nil>
   268  }
   269  
   270  func Example_seekDir2() {
   271  	var fs http.FileSystem = assets
   272  
   273  	f, err := fs.Open("/")
   274  	if err != nil {
   275  		panic(err)
   276  	}
   277  	defer f.Close()
   278  
   279  	fis, err := f.Readdir(2)
   280  	fmt.Println(fisStringer(fis), err)
   281  	fis, err = f.Readdir(1)
   282  	fmt.Println(fisStringer(fis), err)
   283  	_, err = f.Seek(0, io.SeekStart)
   284  	fmt.Println(err)
   285  	fis, err = f.Readdir(2)
   286  	fmt.Println(fisStringer(fis), err)
   287  	_, err = f.Seek(0, io.SeekStart)
   288  	fmt.Println(err)
   289  	fis, err = f.Readdir(1)
   290  	fmt.Println(fisStringer(fis), err)
   291  	fis, err = f.Readdir(10)
   292  	fmt.Println(fisStringer(fis), err)
   293  	fis, err = f.Readdir(10)
   294  	fmt.Println(fisStringer(fis), err)
   295  
   296  	// Output:
   297  	// [ folderA folderB ] <nil>
   298  	// [ not-worth-compressing-file.txt ] <nil>
   299  	// <nil>
   300  	// [ folderA folderB ] <nil>
   301  	// <nil>
   302  	// [ folderA ] <nil>
   303  	// [ folderB not-worth-compressing-file.txt sample-file.txt ] <nil>
   304  	// [ ] EOF
   305  }
   306  
   307  func Example_notExist() {
   308  	var fs http.FileSystem = assets
   309  
   310  	_, err := fs.Open("/does-not-exist")
   311  	fmt.Println("os.IsNotExist:", os.IsNotExist(err))
   312  	fmt.Println(err)
   313  
   314  	// Output:
   315  	// os.IsNotExist: true
   316  	// open /does-not-exist: file does not exist
   317  }
   318  
   319  func Example_pathCleaned() {
   320  	var fs http.FileSystem = assets
   321  
   322  	f, err := fs.Open("//folderB/../folderA/file1.txt")
   323  	if err != nil {
   324  		panic(err)
   325  	}
   326  	defer f.Close()
   327  
   328  	fi, err := f.Stat()
   329  	if err != nil {
   330  		panic(err)
   331  	}
   332  	fmt.Println(fi.Name())
   333  
   334  	b, err := io.ReadAll(f)
   335  	fmt.Printf("%q %v\n", string(b), err)
   336  
   337  	// Output:
   338  	// file1.txt
   339  	// "Stuff in /folderA/file1.txt." <nil>
   340  }
   341
View as plain text