more coverage bumps

Signed-off-by: quobix <dave@quobix.com>

index/rolodex.go

@@ -522,11 +522,9 @@ func (r *Rolodex) Open(location string) (RolodexFile, error) {
 				}
 			}
 			// check if this is a native rolodex FS, then the work is done.
-			if lrf, ok := interface{}(f).(*localRolodexFile); ok {
+			if lf, ko := interface{}(f).(*LocalFile); ko {
-				if lf, ko := interface{}(lrf.f).(*LocalFile); ko {
 				localFile = lf
 				break
-				}
 			} else {
 				// not a native FS, so we need to read the file and create a local file.
 				bytes, rErr := io.ReadAll(f)

index/rolodex_file_loader.go

@@ -43,15 +43,11 @@ func (l *LocalFS) Open(name string) (fs.File, error) {
     }
 
     if !filepath.IsAbs(name) {
-		var absErr error
+        name, _ = filepath.Abs(filepath.Join(l.baseDirectory, name))
-		name, absErr = filepath.Abs(filepath.Join(l.baseDirectory, name))
-		if absErr != nil {
-			return nil, absErr
-		}
     }
 
     if f, ok := l.Files[name]; ok {
-		return &localRolodexFile{f: f}, nil
+        return f.(*LocalFile), nil
     } else {
         return nil, &fs.PathError{Op: "open", Path: name, Err: fs.ErrNotExist}
     }
@@ -67,6 +63,7 @@ type LocalFile struct {
     readingErrors []error
     index         *SpecIndex
     parsed        *yaml.Node
+    offset        int64
 }
 
 func (l *LocalFile) GetIndex() *SpecIndex {
@@ -155,13 +152,7 @@ func NewLocalFSWithConfig(config *LocalFSConfig) (*LocalFS, error) {
     file := filepath.Base(config.BaseDirectory)
 
     var absBaseDir string
-	var absBaseErr error
+    absBaseDir, _ = filepath.Abs(config.BaseDirectory)
-
-	absBaseDir, absBaseErr = filepath.Abs(config.BaseDirectory)
-
-	if absBaseErr != nil {
-		return nil, absBaseErr
-	}
 
     walkErr := fs.WalkDir(config.DirFS, ".", func(p string, d fs.DirEntry, err error) error {
         if err != nil {
@@ -169,7 +160,7 @@ func NewLocalFSWithConfig(config *LocalFSConfig) (*LocalFS, error) {
         }
 
         // we don't care about directories, or errors, just read everything we can.
-		if d == nil || d.IsDir() {
+        if d.IsDir() {
             return nil
         }
 
@@ -189,39 +180,20 @@ func NewLocalFSWithConfig(config *LocalFSConfig) (*LocalFS, error) {
 
         extension := ExtractFileType(p)
         var readingErrors []error
-		abs, absErr := filepath.Abs(filepath.Join(config.BaseDirectory, p))
+        abs, _ := filepath.Abs(filepath.Join(config.BaseDirectory, p))
-		if absErr != nil {
-			readingErrors = append(readingErrors, absErr)
-			log.Error("cannot create absolute path for file: ", "file", p, "error", absErr.Error())
-		}
 
         var fileData []byte
 
         switch extension {
         case YAML, JSON:
 
-			dirFile, readErr := config.DirFS.Open(p)
+            dirFile, _ := config.DirFS.Open(p)
             modTime := time.Now()
-			if readErr != nil {
+            stat, _ := dirFile.Stat()
-				allErrors = append(allErrors, readErr)
-				log.Error("[rolodex] cannot open file: ", "file", abs, "error", readErr.Error())
-				return nil
-			}
-			stat, statErr := dirFile.Stat()
-			if statErr != nil {
-				allErrors = append(allErrors, statErr)
-				log.Error("[rolodex] cannot stat file: ", "file", abs, "error", statErr.Error())
-			}
             if stat != nil {
                 modTime = stat.ModTime()
             }
-			fileData, readErr = io.ReadAll(dirFile)
+            fileData, _ = io.ReadAll(dirFile)
-			if readErr != nil {
-				allErrors = append(allErrors, readErr)
-				log.Error("cannot read file data: ", "file", abs, "error", readErr.Error())
-				return nil
-			}
-
             log.Debug("collecting JSON/YAML file", "file", abs)
             localFiles[abs] = &LocalFile{
                 filename:      p,
@@ -287,27 +259,22 @@ func (l *LocalFile) Sys() interface{} {
     return nil
 }
 
-type localRolodexFile struct {
+func (l *LocalFile) Close() error {
-	f      RolodexFile
-	offset int64
-}
-
-func (r *localRolodexFile) Close() error {
     return nil
 }
 
-func (r *localRolodexFile) Stat() (fs.FileInfo, error) {
+func (l *LocalFile) Stat() (fs.FileInfo, error) {
-	return r.f, nil
+    return l, nil
 }
 
-func (r *localRolodexFile) Read(b []byte) (int, error) {
+func (l *LocalFile) Read(b []byte) (int, error) {
-	if r.offset >= int64(len(r.f.GetContent())) {
+    if l.offset >= int64(len(l.GetContent())) {
         return 0, io.EOF
     }
-	if r.offset < 0 {
+    if l.offset < 0 {
-		return 0, &fs.PathError{Op: "read", Path: r.f.GetFullPath(), Err: fs.ErrInvalid}
+        return 0, &fs.PathError{Op: "read", Path: l.GetFullPath(), Err: fs.ErrInvalid}
     }
-	n := copy(b, r.f.GetContent()[r.offset:])
+    n := copy(b, l.GetContent()[l.offset:])
-	r.offset += int64(n)
+    l.offset += int64(n)
     return n, nil
 }

index/rolodex_file_loader_test.go

@@ -5,6 +5,9 @@ package index
 
 import (
     "github.com/stretchr/testify/assert"
+    "io"
+    "io/fs"
+    "path/filepath"
     "testing"
     "testing/fstest"
     "time"
@@ -14,6 +17,7 @@ func TestRolodexLoadsFilesCorrectly_NoErrors(t *testing.T) {
     t.Parallel()
     testFS := fstest.MapFS{
         "spec.yaml":             {Data: []byte("hip"), ModTime: time.Now()},
+        "spock.yaml":            {Data: []byte("hip: : hello:  :\n:hw"), ModTime: time.Now()},
         "subfolder/spec1.json":  {Data: []byte("hop"), ModTime: time.Now()},
         "subfolder2/spec2.yaml": {Data: []byte("chop"), ModTime: time.Now()},
         "subfolder2/hello.jpg":  {Data: []byte("shop"), ModTime: time.Now()},
@@ -24,6 +28,151 @@ func TestRolodexLoadsFilesCorrectly_NoErrors(t *testing.T) {
         t.Fatal(err)
     }
 
-	assert.Len(t, fileFS.Files, 3)
+    files := fileFS.GetFiles()
-	assert.Len(t, fileFS.readingErrors, 0)
+    assert.Len(t, files, 4)
+    assert.Len(t, fileFS.GetErrors(), 0)
+
+    key, _ := filepath.Abs(filepath.Join(fileFS.baseDirectory, "spec.yaml"))
+
+    localFile := files[key]
+    assert.NotNil(t, localFile)
+    assert.Nil(t, localFile.GetIndex())
+
+    lf := localFile.(*LocalFile)
+    idx, ierr := lf.Index(CreateOpenAPIIndexConfig())
+    assert.NoError(t, ierr)
+    assert.NotNil(t, idx)
+    assert.NotNil(t, localFile.GetContent())
+
+    d, e := localFile.GetContentAsYAMLNode()
+    assert.NoError(t, e)
+    assert.NotNil(t, d)
+    assert.NotNil(t, localFile.GetIndex())
+    assert.Equal(t, YAML, localFile.GetFileExtension())
+    assert.Equal(t, key, localFile.GetFullPath())
+    assert.Equal(t, "spec.yaml", lf.Name())
+    assert.Equal(t, int64(3), lf.Size())
+    assert.Equal(t, fs.FileMode(0), lf.Mode())
+    assert.False(t, lf.IsDir())
+    assert.Equal(t, time.Now().Unix(), lf.ModTime().Unix())
+    assert.Nil(t, lf.Sys())
+    assert.Nil(t, lf.Close())
+    q, w := lf.Stat()
+    assert.NotNil(t, q)
+    assert.NoError(t, w)
+
+    b, x := io.ReadAll(lf)
+    assert.Len(t, b, 3)
+    assert.NoError(t, x)
+
+    assert.Equal(t, key, lf.FullPath())
+    assert.Len(t, localFile.GetErrors(), 0)
+
+    // try and reindex
+    idx, ierr = lf.Index(CreateOpenAPIIndexConfig())
+    assert.NoError(t, ierr)
+    assert.NotNil(t, idx)
+
+    key, _ = filepath.Abs(filepath.Join(fileFS.baseDirectory, "spock.yaml"))
+
+    localFile = files[key]
+    assert.NotNil(t, localFile)
+    assert.Nil(t, localFile.GetIndex())
+
+    lf = localFile.(*LocalFile)
+    idx, ierr = lf.Index(CreateOpenAPIIndexConfig())
+    assert.Error(t, ierr)
+    assert.Nil(t, idx)
+    assert.NotNil(t, localFile.GetContent())
+    assert.Nil(t, localFile.GetIndex())
+
+}
+
+func TestRolodexLocalFS_NoConfig(t *testing.T) {
+
+    lfs := &LocalFS{}
+    f, e := lfs.Open("test.yaml")
+    assert.Nil(t, f)
+    assert.Error(t, e)
+}
+
+func TestRolodexLocalFS_NoLookup(t *testing.T) {
+
+    cf := CreateClosedAPIIndexConfig()
+    lfs := &LocalFS{indexConfig: cf}
+    f, e := lfs.Open("test.yaml")
+    assert.Nil(t, f)
+    assert.Error(t, e)
+}
+
+func TestRolodexLocalFS_BadAbsFile(t *testing.T) {
+
+    cf := CreateOpenAPIIndexConfig()
+    lfs := &LocalFS{indexConfig: cf}
+    f, e := lfs.Open("/test.yaml")
+    assert.Nil(t, f)
+    assert.Error(t, e)
+}
+
+func TestRolodexLocalFile_BadParse(t *testing.T) {
+
+    lf := &LocalFile{}
+    n, e := lf.GetContentAsYAMLNode()
+    assert.Nil(t, n)
+    assert.Error(t, e)
+    assert.Equal(t, "no data to parse for file: ", e.Error())
+}
+
+func TestRolodexLocalFile_NoIndexRoot(t *testing.T) {
+
+    lf := &LocalFile{data: []byte("burders"), index: &SpecIndex{}}
+    n, e := lf.GetContentAsYAMLNode()
+    assert.NotNil(t, n)
+    assert.NoError(t, e)
+
+}
+
+func TestRolodexLocalFile_IndexSingleFile(t *testing.T) {
+
+    testFS := fstest.MapFS{
+        "spec.yaml":  {Data: []byte("hip"), ModTime: time.Now()},
+        "spock.yaml": {Data: []byte("hop"), ModTime: time.Now()},
+        "i-am-a-dir": {Mode: fs.FileMode(fs.ModeDir), ModTime: time.Now()},
+    }
+
+    fileFS, _ := NewLocalFS("spec.yaml", testFS)
+    files := fileFS.GetFiles()
+    assert.Len(t, files, 1)
+
+}
+
+func TestRolodexLocalFile_TestFilters(t *testing.T) {
+
+    testFS := fstest.MapFS{
+        "spec.yaml":  {Data: []byte("hip"), ModTime: time.Now()},
+        "spock.yaml": {Data: []byte("pip"), ModTime: time.Now()},
+        "jam.jpg":    {Data: []byte("sip"), ModTime: time.Now()},
+    }
+
+    fileFS, _ := NewLocalFSWithConfig(&LocalFSConfig{
+        BaseDirectory: ".",
+        FileFilters:   []string{"spec.yaml", "spock.yaml", "jam.jpg"},
+        DirFS:         testFS,
+    })
+    files := fileFS.GetFiles()
+    assert.Len(t, files, 2)
+
+}
+
+func TestRolodexLocalFile_TestBasFS(t *testing.T) {
+
+    testFS := test_badfs{}
+
+    fileFS, err := NewLocalFSWithConfig(&LocalFSConfig{
+        BaseDirectory: ".",
+        DirFS:         &testFS,
+    })
+    assert.Error(t, err)
+    assert.Nil(t, fileFS)
+
 }

index/rolodex_test.go

@@ -96,10 +96,10 @@ type test_badfs struct {
 
 func (t *test_badfs) Open(v string) (fs.File, error) {
 	ok := false
-	if v != "/" && v != "http://localhost/test.yaml" {
+	if v != "/" && v != "." && v != "http://localhost/test.yaml" {
 		ok = true
 	}
-	if v == "http://localhost/goodstat.yaml" || v == "goodstat.yaml" {
+	if v == "http://localhost/goodstat.yaml" || strings.HasSuffix(v, "goodstat.yaml") {
 		ok = true
 		t.goodstat = true
 	}