432 lines
13 KiB
Go
432 lines
13 KiB
Go
package io
|
|
|
|
import (
|
|
goio "io"
|
|
"io/fs"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestMemoryMedium_NewMemoryMedium_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
assert.NotNil(t, memoryMedium)
|
|
assert.NotNil(t, memoryMedium.fileContents)
|
|
assert.NotNil(t, memoryMedium.directories)
|
|
assert.Empty(t, memoryMedium.fileContents)
|
|
assert.Empty(t, memoryMedium.directories)
|
|
}
|
|
|
|
func TestMemoryMedium_NewFileInfo_Good(t *testing.T) {
|
|
info := NewFileInfo("app.yaml", 8, 0644, time.Unix(0, 0), false)
|
|
|
|
assert.Equal(t, "app.yaml", info.Name())
|
|
assert.Equal(t, int64(8), info.Size())
|
|
assert.Equal(t, fs.FileMode(0644), info.Mode())
|
|
assert.True(t, info.ModTime().Equal(time.Unix(0, 0)))
|
|
assert.False(t, info.IsDir())
|
|
assert.Nil(t, info.Sys())
|
|
}
|
|
|
|
func TestMemoryMedium_NewDirEntry_Good(t *testing.T) {
|
|
info := NewFileInfo("app.yaml", 8, 0644, time.Unix(0, 0), false)
|
|
entry := NewDirEntry("app.yaml", false, 0644, info)
|
|
|
|
assert.Equal(t, "app.yaml", entry.Name())
|
|
assert.False(t, entry.IsDir())
|
|
assert.Equal(t, fs.FileMode(0), entry.Type())
|
|
|
|
entryInfo, err := entry.Info()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "app.yaml", entryInfo.Name())
|
|
assert.Equal(t, int64(8), entryInfo.Size())
|
|
}
|
|
|
|
func TestMemoryMedium_Read_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["test.txt"] = "hello world"
|
|
content, err := memoryMedium.Read("test.txt")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "hello world", content)
|
|
}
|
|
|
|
func TestMemoryMedium_Read_Bad(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
_, err := memoryMedium.Read("nonexistent.txt")
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestMemoryMedium_Write_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
err := memoryMedium.Write("test.txt", "content")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "content", memoryMedium.fileContents["test.txt"])
|
|
|
|
err = memoryMedium.Write("test.txt", "new content")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "new content", memoryMedium.fileContents["test.txt"])
|
|
}
|
|
|
|
func TestMemoryMedium_WriteMode_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
|
|
err := memoryMedium.WriteMode("secure.txt", "secret", 0600)
|
|
require.NoError(t, err)
|
|
|
|
content, err := memoryMedium.Read("secure.txt")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "secret", content)
|
|
|
|
info, err := memoryMedium.Stat("secure.txt")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, fs.FileMode(0600), info.Mode())
|
|
|
|
file, err := memoryMedium.Open("secure.txt")
|
|
require.NoError(t, err)
|
|
fileInfo, err := file.Stat()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, fs.FileMode(0600), fileInfo.Mode())
|
|
}
|
|
|
|
func TestMemoryMedium_EnsureDir_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
err := memoryMedium.EnsureDir("/path/to/dir")
|
|
assert.NoError(t, err)
|
|
assert.True(t, memoryMedium.directories["/path/to/dir"])
|
|
}
|
|
|
|
func TestMemoryMedium_EnsureDir_CreatesParents_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
|
|
require.NoError(t, memoryMedium.EnsureDir("alpha/beta/gamma"))
|
|
|
|
assert.True(t, memoryMedium.IsDir("alpha"))
|
|
assert.True(t, memoryMedium.IsDir("alpha/beta"))
|
|
assert.True(t, memoryMedium.IsDir("alpha/beta/gamma"))
|
|
}
|
|
|
|
func TestMemoryMedium_IsFile_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["exists.txt"] = "content"
|
|
|
|
assert.True(t, memoryMedium.IsFile("exists.txt"))
|
|
assert.False(t, memoryMedium.IsFile("nonexistent.txt"))
|
|
}
|
|
|
|
func TestMemoryMedium_Write_CreatesParentDirectories_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
|
|
require.NoError(t, memoryMedium.Write("nested/path/file.txt", "content"))
|
|
|
|
assert.True(t, memoryMedium.Exists("nested"))
|
|
assert.True(t, memoryMedium.IsDir("nested"))
|
|
assert.True(t, memoryMedium.Exists("nested/path"))
|
|
assert.True(t, memoryMedium.IsDir("nested/path"))
|
|
}
|
|
|
|
func TestMemoryMedium_Delete_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["test.txt"] = "content"
|
|
|
|
err := memoryMedium.Delete("test.txt")
|
|
assert.NoError(t, err)
|
|
assert.False(t, memoryMedium.IsFile("test.txt"))
|
|
}
|
|
|
|
func TestMemoryMedium_Delete_NotFound_Bad(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
err := memoryMedium.Delete("nonexistent.txt")
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestMemoryMedium_Delete_DirNotEmpty_Bad(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.directories["mydir"] = true
|
|
memoryMedium.fileContents["mydir/file.txt"] = "content"
|
|
|
|
err := memoryMedium.Delete("mydir")
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestMemoryMedium_Delete_InferredDirNotEmpty_Bad(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
|
|
require.NoError(t, memoryMedium.Write("mydir/file.txt", "content"))
|
|
|
|
err := memoryMedium.Delete("mydir")
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestMemoryMedium_DeleteAll_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.directories["mydir"] = true
|
|
memoryMedium.directories["mydir/subdir"] = true
|
|
memoryMedium.fileContents["mydir/file.txt"] = "content"
|
|
memoryMedium.fileContents["mydir/subdir/nested.txt"] = "nested"
|
|
|
|
err := memoryMedium.DeleteAll("mydir")
|
|
assert.NoError(t, err)
|
|
assert.Empty(t, memoryMedium.directories)
|
|
assert.Empty(t, memoryMedium.fileContents)
|
|
}
|
|
|
|
func TestMemoryMedium_Rename_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["old.txt"] = "content"
|
|
|
|
err := memoryMedium.Rename("old.txt", "new.txt")
|
|
assert.NoError(t, err)
|
|
assert.False(t, memoryMedium.IsFile("old.txt"))
|
|
assert.True(t, memoryMedium.IsFile("new.txt"))
|
|
assert.Equal(t, "content", memoryMedium.fileContents["new.txt"])
|
|
}
|
|
|
|
func TestMemoryMedium_Rename_Dir_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.directories["olddir"] = true
|
|
memoryMedium.fileContents["olddir/file.txt"] = "content"
|
|
|
|
err := memoryMedium.Rename("olddir", "newdir")
|
|
assert.NoError(t, err)
|
|
assert.False(t, memoryMedium.directories["olddir"])
|
|
assert.True(t, memoryMedium.directories["newdir"])
|
|
assert.Equal(t, "content", memoryMedium.fileContents["newdir/file.txt"])
|
|
}
|
|
|
|
func TestMemoryMedium_Rename_InferredDir_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
require.NoError(t, memoryMedium.Write("olddir/file.txt", "content"))
|
|
|
|
require.NoError(t, memoryMedium.Rename("olddir", "newdir"))
|
|
|
|
assert.False(t, memoryMedium.Exists("olddir"))
|
|
assert.True(t, memoryMedium.Exists("newdir"))
|
|
assert.True(t, memoryMedium.IsDir("newdir"))
|
|
assert.Equal(t, "content", memoryMedium.fileContents["newdir/file.txt"])
|
|
}
|
|
|
|
func TestMemoryMedium_List_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.directories["mydir"] = true
|
|
memoryMedium.fileContents["mydir/file1.txt"] = "content1"
|
|
memoryMedium.fileContents["mydir/file2.txt"] = "content2"
|
|
memoryMedium.directories["mydir/subdir"] = true
|
|
|
|
entries, err := memoryMedium.List("mydir")
|
|
assert.NoError(t, err)
|
|
assert.Len(t, entries, 3)
|
|
assert.Equal(t, "file1.txt", entries[0].Name())
|
|
assert.Equal(t, "file2.txt", entries[1].Name())
|
|
assert.Equal(t, "subdir", entries[2].Name())
|
|
|
|
names := make(map[string]bool)
|
|
for _, entry := range entries {
|
|
names[entry.Name()] = true
|
|
}
|
|
assert.True(t, names["file1.txt"])
|
|
assert.True(t, names["file2.txt"])
|
|
assert.True(t, names["subdir"])
|
|
}
|
|
|
|
func TestMemoryMedium_Stat_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["test.txt"] = "hello world"
|
|
|
|
info, err := memoryMedium.Stat("test.txt")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "test.txt", info.Name())
|
|
assert.Equal(t, int64(11), info.Size())
|
|
assert.False(t, info.IsDir())
|
|
}
|
|
|
|
func TestMemoryMedium_Stat_Dir_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.directories["mydir"] = true
|
|
|
|
info, err := memoryMedium.Stat("mydir")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "mydir", info.Name())
|
|
assert.True(t, info.IsDir())
|
|
}
|
|
|
|
func TestMemoryMedium_Exists_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["file.txt"] = "content"
|
|
memoryMedium.directories["mydir"] = true
|
|
|
|
assert.True(t, memoryMedium.Exists("file.txt"))
|
|
assert.True(t, memoryMedium.Exists("mydir"))
|
|
assert.False(t, memoryMedium.Exists("nonexistent"))
|
|
}
|
|
|
|
func TestMemoryMedium_IsDir_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["file.txt"] = "content"
|
|
memoryMedium.directories["mydir"] = true
|
|
|
|
assert.False(t, memoryMedium.IsDir("file.txt"))
|
|
assert.True(t, memoryMedium.IsDir("mydir"))
|
|
assert.False(t, memoryMedium.IsDir("nonexistent"))
|
|
}
|
|
|
|
func TestMemoryMedium_StreamAndFSHelpers_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
require.NoError(t, memoryMedium.EnsureDir("dir"))
|
|
require.NoError(t, memoryMedium.Write("dir/file.txt", "alpha"))
|
|
|
|
statInfo, err := memoryMedium.Stat("dir/file.txt")
|
|
require.NoError(t, err)
|
|
|
|
file, err := memoryMedium.Open("dir/file.txt")
|
|
require.NoError(t, err)
|
|
|
|
info, err := file.Stat()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "file.txt", info.Name())
|
|
assert.Equal(t, int64(5), info.Size())
|
|
assert.Equal(t, fs.FileMode(0644), info.Mode())
|
|
assert.Equal(t, statInfo.ModTime(), info.ModTime())
|
|
assert.False(t, info.IsDir())
|
|
assert.Nil(t, info.Sys())
|
|
|
|
data, err := goio.ReadAll(file)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "alpha", string(data))
|
|
require.NoError(t, file.Close())
|
|
|
|
entries, err := memoryMedium.List("dir")
|
|
require.NoError(t, err)
|
|
require.Len(t, entries, 1)
|
|
assert.Equal(t, "file.txt", entries[0].Name())
|
|
assert.False(t, entries[0].IsDir())
|
|
assert.Equal(t, fs.FileMode(0), entries[0].Type())
|
|
|
|
entryInfo, err := entries[0].Info()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "file.txt", entryInfo.Name())
|
|
assert.Equal(t, int64(5), entryInfo.Size())
|
|
assert.Equal(t, fs.FileMode(0644), entryInfo.Mode())
|
|
assert.Equal(t, statInfo.ModTime(), entryInfo.ModTime())
|
|
|
|
writer, err := memoryMedium.Create("created.txt")
|
|
require.NoError(t, err)
|
|
_, err = writer.Write([]byte("created"))
|
|
require.NoError(t, err)
|
|
require.NoError(t, writer.Close())
|
|
|
|
appendWriter, err := memoryMedium.Append("created.txt")
|
|
require.NoError(t, err)
|
|
_, err = appendWriter.Write([]byte(" later"))
|
|
require.NoError(t, err)
|
|
require.NoError(t, appendWriter.Close())
|
|
|
|
reader, err := memoryMedium.ReadStream("created.txt")
|
|
require.NoError(t, err)
|
|
streamed, err := goio.ReadAll(reader)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "created later", string(streamed))
|
|
require.NoError(t, reader.Close())
|
|
|
|
writeStream, err := memoryMedium.WriteStream("streamed.txt")
|
|
require.NoError(t, err)
|
|
_, err = writeStream.Write([]byte("stream output"))
|
|
require.NoError(t, err)
|
|
require.NoError(t, writeStream.Close())
|
|
|
|
assert.Equal(t, "stream output", memoryMedium.fileContents["streamed.txt"])
|
|
statInfo, err = memoryMedium.Stat("streamed.txt")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, fs.FileMode(0644), statInfo.Mode())
|
|
assert.False(t, statInfo.ModTime().IsZero())
|
|
}
|
|
|
|
func TestIO_Read_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["test.txt"] = "hello"
|
|
content, err := Read(memoryMedium, "test.txt")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "hello", content)
|
|
}
|
|
|
|
func TestIO_Write_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
err := Write(memoryMedium, "test.txt", "hello")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "hello", memoryMedium.fileContents["test.txt"])
|
|
}
|
|
|
|
func TestIO_EnsureDir_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
err := EnsureDir(memoryMedium, "/my/dir")
|
|
assert.NoError(t, err)
|
|
assert.True(t, memoryMedium.directories["/my/dir"])
|
|
}
|
|
|
|
func TestIO_IsFile_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
memoryMedium.fileContents["exists.txt"] = "content"
|
|
|
|
assert.True(t, IsFile(memoryMedium, "exists.txt"))
|
|
assert.False(t, IsFile(memoryMedium, "nonexistent.txt"))
|
|
}
|
|
|
|
func TestIO_NewSandboxed_Good(t *testing.T) {
|
|
root := t.TempDir()
|
|
|
|
memoryMedium, err := NewSandboxed(root)
|
|
require.NoError(t, err)
|
|
|
|
require.NoError(t, memoryMedium.Write("config/app.yaml", "port: 8080"))
|
|
|
|
content, err := memoryMedium.Read("config/app.yaml")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "port: 8080", content)
|
|
assert.True(t, memoryMedium.IsDir("config"))
|
|
}
|
|
|
|
func TestIO_ReadWriteStream_Good(t *testing.T) {
|
|
memoryMedium := NewMemoryMedium()
|
|
|
|
writer, err := WriteStream(memoryMedium, "logs/run.txt")
|
|
require.NoError(t, err)
|
|
_, err = writer.Write([]byte("started"))
|
|
require.NoError(t, err)
|
|
require.NoError(t, writer.Close())
|
|
|
|
reader, err := ReadStream(memoryMedium, "logs/run.txt")
|
|
require.NoError(t, err)
|
|
data, err := goio.ReadAll(reader)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "started", string(data))
|
|
require.NoError(t, reader.Close())
|
|
}
|
|
|
|
func TestIO_Copy_Good(t *testing.T) {
|
|
source := NewMemoryMedium()
|
|
dest := NewMemoryMedium()
|
|
source.fileContents["test.txt"] = "hello"
|
|
err := Copy(source, "test.txt", dest, "test.txt")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "hello", dest.fileContents["test.txt"])
|
|
|
|
source.fileContents["original.txt"] = "content"
|
|
err = Copy(source, "original.txt", dest, "copied.txt")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "content", dest.fileContents["copied.txt"])
|
|
}
|
|
|
|
func TestIO_Copy_Bad(t *testing.T) {
|
|
source := NewMemoryMedium()
|
|
dest := NewMemoryMedium()
|
|
err := Copy(source, "nonexistent.txt", dest, "dest.txt")
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestIO_LocalGlobal_Good(t *testing.T) {
|
|
assert.NotNil(t, Local, "io.Local should be initialised")
|
|
|
|
var memoryMedium = Local
|
|
assert.NotNil(t, memoryMedium)
|
|
}
|