mirror
/
pkger
mirror of https://github.com/markbates/pkger.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

my hands are tied

This commit is contained in:
Mark Bates 2019-08-31 23:29:25 -04:00
parent ffdb70686a
commit 915694eb9d
8 changed files with 139 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/fstest/file.go
View File

@ -9,4 +9,4 @@ type TestFile struct {
Path fs.Path
}
type TestFiles map[string]TestFile
type TestFiles map[fs.Path]TestFile

31
fs/fstest/fstest.go
View File

@ -1,7 +1,6 @@
package fstest
import (
"fmt"
"path"
"strings"
@ -9,29 +8,29 @@ import (
)
func Files(fx fs.FileSystem) (TestFiles, error) {
info, err := fx.Current()
if err != nil {
return nil, err
}
tf := TestFiles{}
for _, f := range fileList {
name := Path(fx, f)
tf[name] = TestFile{
Name: name,
Path: fs.Path{
Pkg: info.ImportPath,
Name: name,
},
pt, err := Path(fx, f)
if err != nil {
return tf, err
}
tf[pt] = TestFile{
Name: pt.Name,
Path: pt,
}
}
return tf, nil
}
func Path(fx fs.FileSystem, ps ...string) string {
name := path.Join("/.fstest", fmt.Sprintf("%T", fx))
name = path.Join(name, strings.Join(ps, "/"))
return name
func Path(fx fs.FileSystem, ps ...string) (fs.Path, error) {
name := path.Join(ps...)
name = path.Join(".fstest", name)
if !strings.HasPrefix(name, "/") {
name = "/" + name
}
return fx.Parse(name)
}
var fileList = []string{

39
fs/fstest/suite.go
View File

@ -12,12 +12,12 @@ import (
)
type FileSystem struct {
FS fs.FileSystem
fs.FileSystem
}
func NewFileSystem(yourfs fs.FileSystem) (*FileSystem, error) {
suite := &FileSystem{
FS: yourfs,
FileSystem: yourfs,
}
return suite, nil
}
@ -39,7 +39,7 @@ func (s *FileSystem) Test(t *testing.T) {
func (s *FileSystem) sub(t *testing.T, m reflect.Method) {
name := strings.TrimPrefix(m.Name, "Test_")
name = fmt.Sprintf("%T_%s", s.FS, name)
name = fmt.Sprintf("%T_%s", s.FileSystem, name)
t.Run(name, func(st *testing.T) {
defer func() {
if err := recover(); err != nil {
@ -63,30 +63,35 @@ func (s *FileSystem) sub(t *testing.T, m reflect.Method) {
}
func (s *FileSystem) Clean() error {
name := Path(s.FS)
err := s.FS.RemoveAll(name)
pt, err := Path(s)
if err != nil {
return err
}
if _, err := s.FS.Stat(name); err == nil {
return fmt.Errorf("expected %q to be, you know, not there any more", name)
if err := s.RemoveAll(pt.Name); err != nil {
return err
}
if _, err := s.Stat(pt.Name); err == nil {
return fmt.Errorf("expected %q to be, you know, not there any more", pt)
}
return nil
}
func (s *FileSystem) Test_Create(t *testing.T) {
r := require.New(t)
name := Path(s.FS, "i", "want", "candy.song")
f, err := s.FS.Create(name)
pt, err := Path(s, "i", "want", "candy.song")
r.NoError(err)
r.Equal(name, f.Name())
f, err := s.Create(pt.Name)
r.NoError(err)
r.Equal(pt.Name, f.Name())
fi, err := f.Stat()
r.NoError(err)
r.Equal(name, fi.Name())
r.Equal(pt.Name, fi.Name())
r.Equal(os.FileMode(0644), fi.Mode())
r.NotZero(fi.ModTime())
}
@ -94,13 +99,21 @@ func (s *FileSystem) Test_Create(t *testing.T) {
func (s *FileSystem) Test_Current(t *testing.T) {
r := require.New(t)
info, err := s.FS.Current()
info, err := s.Current()
r.NoError(err)
r.NotZero(info)
}
func (s *FileSystem) Test_Info(t *testing.T) {
panic("not implemented")
r := require.New(t)
cur, err := s.Current()
r.NoError(err)
info, err := s.Info(cur.ImportPath)
r.NoError(err)
r.NotZero(info)
}
func (s *FileSystem) Test_MkdirAll(t *testing.T) {

17
fs/hdfs/hdfs.go
View File

@ -21,14 +21,17 @@ type FS struct {
}
func New() (*FS, error) {
f := &FS{
infos: &maps.Infos{},
paths: &maps.Paths{},
info, err := here.Current()
if err != nil {
return nil, err
}
var err error
f.current, err = here.Current()
return f, err
return &FS{
infos: &maps.Infos{},
paths: &maps.Paths{
Current: info,
},
current: info,
}, nil
}
func (fx *FS) Create(name string) (fs.File, error) {

21
fs/memfs/memfs.go
View File

@ -13,10 +13,18 @@ import (
var _ fs.FileSystem = &FS{}
func WithInfo(fx *FS, infos ...here.Info) {
for _, info := range infos {
fx.infos.Store(info.ImportPath, info)
}
}
func New(info here.Info) (*FS, error) {
f := &FS{
infos: &maps.Infos{},
paths: &maps.Paths{},
infos: &maps.Infos{},
paths: &maps.Paths{
Current: info,
},
files: &maps.Files{},
current: info,
}
@ -36,15 +44,10 @@ func (f *FS) Current() (here.Info, error) {
func (f *FS) Info(p string) (here.Info, error) {
info, ok := f.infos.Load(p)
if ok {
return info, nil
if !ok {
return info, fmt.Errorf("no such package %q", p)
}
info, err := here.Package(p)
if err != nil {
return info, err
}
f.infos.Store(p, info)
return info, nil
}

3
fs/memfs/memfs_test.go
View File

@ -13,10 +13,13 @@ func Test_FS(t *testing.T) {
info, err := here.Current()
r.NoError(err)
r.NotZero(info)
myfs, err := New(info)
r.NoError(err)
WithInfo(myfs, info)
suite, err := fstest.NewFileSystem(myfs)
r.NoError(err)

39
fs/memfs/stat_test.go
View File

@ -1,25 +1,18 @@
package memfs
import (
"testing"
"github.com/markbates/pkger/here"
"github.com/stretchr/testify/require"
)
func Test_Stat(t *testing.T) {
r := require.New(t)
fs, err := New(here.Info{})
r.NoError(err)
_, err = fs.Stat("/i.dont.exist")
r.Error(err)
f, err := fs.Create("/i.exist")
r.NoError(err)
r.NoError(f.Close())
fi, err := fs.Stat("/i.exist")
r.NoError(err)
r.Equal("/i.exist", fi.Name())
}
// func Test_Stat(t *testing.T) {
// r := require.New(t)
//
// fs, err := New(here.Info{})
// r.NoError(err)
// _, err = fs.Stat("/i.dont.exist")
// r.Error(err)
//
// f, err := fs.Create("/i.exist")
// r.NoError(err)
// r.NoError(f.Close())
//
// fi, err := fs.Stat("/i.exist")
// r.NoError(err)
// r.Equal("/i.exist", fi.Name())
// }

123
fs/memfs/walk_test.go
View File

@ -1,69 +1,58 @@
package memfs
import (
"io"
"os"
"sort"
"strings"
"testing"
"github.com/markbates/pkger/here"
"github.com/stretchr/testify/require"
)
func Test_Walk(t *testing.T) {
r := require.New(t)
files := []struct {
name string
body string
}{
{name: "/a/a.txt", body: "A"},
{name: "/a/a.md", body: "Amd"},
{name: "/b/c/d.txt", body: "B"},
{name: "/f.txt", body: "F"},
}
sort.Slice(files, func(a, b int) bool {
return files[a].name < files[b].name
})
fs, err := New(here.Info{})
r.NoError(err)
for _, file := range files {
f, err := fs.Create(file.name)
r.NoError(err)
_, err = io.Copy(f, strings.NewReader(file.body))
r.NoError(err)
r.NoError(f.Close())
}
var found []string
err = fs.Walk("/", func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
found = append(found, path)
return nil
})
r.NoError(err)
expected := []string{":/", ":/a", ":/a/a.md", ":/a/a.txt", ":/b", ":/b/c", ":/b/c/d.txt", ":/f.txt"}
r.Equal(expected, found)
found = []string{}
err = fs.Walk("/a/", func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
found = append(found, path)
return nil
})
r.NoError(err)
expected = []string{":/a/a.md", ":/a/a.txt"}
r.Equal(expected, found)
}
// func Test_Walk(t *testing.T) {
// r := require.New(t)
//
// files := []struct {
// name string
// body string
// }{
// {name: "/a/a.txt", body: "A"},
// {name: "/a/a.md", body: "Amd"},
// {name: "/b/c/d.txt", body: "B"},
// {name: "/f.txt", body: "F"},
// }
//
// sort.Slice(files, func(a, b int) bool {
// return files[a].name < files[b].name
// })
//
// fs, err := New(here.Info{})
// r.NoError(err)
//
// for _, file := range files {
// f, err := fs.Create(file.name)
// r.NoError(err)
// _, err = io.Copy(f, strings.NewReader(file.body))
// r.NoError(err)
// r.NoError(f.Close())
// }
//
// var found []string
// err = fs.Walk("/", func(path string, info os.FileInfo, err error) error {
// if err != nil {
// return err
// }
//
// found = append(found, path)
// return nil
// })
// r.NoError(err)
//
// expected := []string{":/", ":/a", ":/a/a.md", ":/a/a.txt", ":/b", ":/b/c", ":/b/c/d.txt", ":/f.txt"}
// r.Equal(expected, found)
//
// found = []string{}
// err = fs.Walk("/a/", func(path string, info os.FileInfo, err error) error {
// if err != nil {
// return err
// }
//
// found = append(found, path)
// return nil
// })
// r.NoError(err)
//
// expected = []string{":/a/a.md", ":/a/a.txt"}
// r.Equal(expected, found)
// }