zipfs_test.go

Documentation: golang.org/x/tools/godoc/vfs/zipfs

     1  // Copyright 2015 The Go 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.package zipfs
     4  package zipfs
     5  
     6  import (
     7  	"archive/zip"
     8  	"bytes"
     9  	"fmt"
    10  	"io"
    11  	"os"
    12  	"reflect"
    13  	"testing"
    14  
    15  	"golang.org/x/tools/godoc/vfs"
    16  )
    17  
    18  var (
    19  
    20  	// files to use to build zip used by zipfs in testing; maps path : contents
    21  	files = map[string]string{"foo": "foo", "bar/baz": "baz", "a/b/c": "c"}
    22  
    23  	// expected info for each entry in a file system described by files
    24  	tests = []struct {
    25  		Path      string
    26  		IsDir     bool
    27  		IsRegular bool
    28  		Name      string
    29  		Contents  string
    30  		Files     map[string]bool
    31  	}{
    32  		{"/", true, false, "", "", map[string]bool{"foo": true, "bar": true, "a": true}},
    33  		{"//", true, false, "", "", map[string]bool{"foo": true, "bar": true, "a": true}},
    34  		{"/foo", false, true, "foo", "foo", nil},
    35  		{"/foo/", false, true, "foo", "foo", nil},
    36  		{"/foo//", false, true, "foo", "foo", nil},
    37  		{"/bar", true, false, "bar", "", map[string]bool{"baz": true}},
    38  		{"/bar/", true, false, "bar", "", map[string]bool{"baz": true}},
    39  		{"/bar/baz", false, true, "baz", "baz", nil},
    40  		{"//bar//baz", false, true, "baz", "baz", nil},
    41  		{"/a/b", true, false, "b", "", map[string]bool{"c": true}},
    42  	}
    43  
    44  	// to be initialized in setup()
    45  	fs        vfs.FileSystem
    46  	statFuncs []statFunc
    47  )
    48  
    49  type statFunc struct {
    50  	Name string
    51  	Func func(string) (os.FileInfo, error)
    52  }
    53  
    54  func TestMain(t *testing.M) {
    55  	if err := setup(); err != nil {
    56  		fmt.Fprintf(os.Stderr, "Error setting up zipfs testing state: %v.\n", err)
    57  		os.Exit(1)
    58  	}
    59  	os.Exit(t.Run())
    60  }
    61  
    62  // setups state each of the tests uses
    63  func setup() error {
    64  	// create zipfs
    65  	b := new(bytes.Buffer)
    66  	zw := zip.NewWriter(b)
    67  	for file, contents := range files {
    68  		w, err := zw.Create(file)
    69  		if err != nil {
    70  			return err
    71  		}
    72  		_, err = io.WriteString(w, contents)
    73  		if err != nil {
    74  			return err
    75  		}
    76  	}
    77  	zw.Close()
    78  	zr, err := zip.NewReader(bytes.NewReader(b.Bytes()), int64(b.Len()))
    79  	if err != nil {
    80  		return err
    81  	}
    82  	rc := &zip.ReadCloser{
    83  		Reader: *zr,
    84  	}
    85  	fs = New(rc, "foo")
    86  
    87  	// pull out different stat functions
    88  	statFuncs = []statFunc{
    89  		{"Stat", fs.Stat},
    90  		{"Lstat", fs.Lstat},
    91  	}
    92  
    93  	return nil
    94  }
    95  
    96  func TestZipFSReadDir(t *testing.T) {
    97  	for _, test := range tests {
    98  		if test.IsDir {
    99  			infos, err := fs.ReadDir(test.Path)
   100  			if err != nil {
   101  				t.Errorf("Failed to read directory %v\n", test.Path)
   102  				continue
   103  			}
   104  			got := make(map[string]bool)
   105  			for _, info := range infos {
   106  				got[info.Name()] = true
   107  			}
   108  			if want := test.Files; !reflect.DeepEqual(got, want) {
   109  				t.Errorf("ReadDir %v got %v\nwanted %v\n", test.Path, got, want)
   110  			}
   111  		}
   112  	}
   113  }
   114  
   115  func TestZipFSStatFuncs(t *testing.T) {
   116  	for _, test := range tests {
   117  		for _, statFunc := range statFuncs {
   118  
   119  			// test can stat
   120  			info, err := statFunc.Func(test.Path)
   121  			if err != nil {
   122  				t.Errorf("Unexpected error using %v for %v: %v\n", statFunc.Name, test.Path, err)
   123  				continue
   124  			}
   125  
   126  			// test info.Name()
   127  			if got, want := info.Name(), test.Name; got != want {
   128  				t.Errorf("Using %v for %v info.Name() got %v wanted %v\n", statFunc.Name, test.Path, got, want)
   129  			}
   130  			// test info.IsDir()
   131  			if got, want := info.IsDir(), test.IsDir; got != want {
   132  				t.Errorf("Using %v for %v info.IsDir() got %v wanted %v\n", statFunc.Name, test.Path, got, want)
   133  			}
   134  			// test info.Mode().IsDir()
   135  			if got, want := info.Mode().IsDir(), test.IsDir; got != want {
   136  				t.Errorf("Using %v for %v info.Mode().IsDir() got %v wanted %v\n", statFunc.Name, test.Path, got, want)
   137  			}
   138  			// test info.Mode().IsRegular()
   139  			if got, want := info.Mode().IsRegular(), test.IsRegular; got != want {
   140  				t.Errorf("Using %v for %v info.Mode().IsRegular() got %v wanted %v\n", statFunc.Name, test.Path, got, want)
   141  			}
   142  			// test info.Size()
   143  			if test.IsRegular {
   144  				if got, want := info.Size(), int64(len(test.Contents)); got != want {
   145  					t.Errorf("Using %v for %v inf.Size() got %v wanted %v", statFunc.Name, test.Path, got, want)
   146  				}
   147  			}
   148  		}
   149  	}
   150  }
   151  
   152  func TestZipFSNotExist(t *testing.T) {
   153  	_, err := fs.Open("/does-not-exist")
   154  	if err == nil {
   155  		t.Fatalf("Expected an error.\n")
   156  	}
   157  	if !os.IsNotExist(err) {
   158  		t.Errorf("Expected an error satisfying os.IsNotExist: %v\n", err)
   159  	}
   160  }
   161  
   162  func TestZipFSOpenSeek(t *testing.T) {
   163  	for _, test := range tests {
   164  		if test.IsRegular {
   165  
   166  			// test Open()
   167  			f, err := fs.Open(test.Path)
   168  			if err != nil {
   169  				t.Error(err)
   170  				return
   171  			}
   172  			defer f.Close()
   173  
   174  			// test Seek() multiple times
   175  			for i := 0; i < 3; i++ {
   176  				all, err := io.ReadAll(f)
   177  				if err != nil {
   178  					t.Error(err)
   179  					return
   180  				}
   181  				if got, want := string(all), test.Contents; got != want {
   182  					t.Errorf("File contents for %v got %v wanted %v\n", test.Path, got, want)
   183  				}
   184  				f.Seek(0, 0)
   185  			}
   186  		}
   187  	}
   188  }
   189  
   190  func TestRootType(t *testing.T) {
   191  	tests := []struct {
   192  		path   string
   193  		fsType vfs.RootType
   194  	}{
   195  		{"/src/net/http", vfs.RootTypeGoRoot},
   196  		{"/src/badpath", ""},
   197  		{"/", vfs.RootTypeGoRoot},
   198  	}
   199  
   200  	for _, item := range tests {
   201  		if fs.RootType(item.path) != item.fsType {
   202  			t.Errorf("unexpected fsType. Expected- %v, Got- %v", item.fsType, fs.RootType(item.path))
   203  		}
   204  	}
   205  }
   206
View as plain text