| // Copyright 2025 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package oswrapper |
| |
| import ( |
| "io" |
| "io/fs" |
| "os" |
| "regexp" |
| "sort" |
| "testing" |
| "time" |
| |
| "github.com/stretchr/testify/require" |
| ) |
| |
| func TestMemMapOSWrapper_UsableAsOsWrapper(t *testing.T) { |
| f := func(osWrapper OSWrapper) { |
| _ = osWrapper.Environ() |
| } |
| |
| wrapper := CreateMemMapOSWrapper() |
| f(wrapper) |
| } |
| |
| func TestMemMapOSWrapper_Environ(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| environ := wrapper.Environ() |
| require.Equal(t, []string{}, environ) |
| |
| wrapper.MemMapEnvironProvider.Environment = map[string]string{ |
| "HOME": "/tmp", |
| "PWD": "/local", |
| } |
| environ = wrapper.Environ() |
| require.Equal(t, []string{"HOME=/tmp", "PWD=/local"}, environ) |
| } |
| |
| func TestMemMapOSWrapper_Getenv(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| require.Empty(t, wrapper.Getenv("HOME")) |
| |
| wrapper.MemMapEnvironProvider.Environment = map[string]string{ |
| "HOME": "/tmp", |
| } |
| require.Equal(t, "/tmp", wrapper.Getenv("HOME")) |
| } |
| |
| func TestMemMapOSWrapper_Getwd(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| wd, err := wrapper.Getwd() |
| require.NoErrorf(t, err, "Failed to get wd: %v", err) |
| require.Equal(t, "/", wd) |
| |
| wrapper.MemMapEnvironProvider.Environment = map[string]string{ |
| "PWD": "/local", |
| } |
| wd, err = wrapper.Getwd() |
| require.NoErrorf(t, err, "Failed to get wd: %v", err) |
| require.Equal(t, "/local", wd) |
| } |
| |
| func TestMemMapOSWrapper_UserHomeDir(t *testing.T) { |
| tests := []struct { |
| name string |
| environment map[string]string |
| want string |
| }{ |
| { |
| name: "Default", |
| environment: map[string]string{}, |
| want: "/", |
| }, |
| { |
| name: "POSIX", |
| environment: map[string]string{ |
| "HOME": "/posix", |
| "USERPROFILE": "/windows", |
| }, |
| want: "/posix", |
| }, |
| { |
| name: "Windows", |
| environment: map[string]string{ |
| "USERPROFILE": "/windows", |
| }, |
| want: "/windows", |
| }, |
| } |
| for _, testCase := range tests { |
| t.Run(testCase.name, func(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| wrapper.MemMapEnvironProvider.Environment = testCase.environment |
| home, err := wrapper.UserHomeDir() |
| require.NoErrorf(t, err, "Failed to get home dir: %v", err) |
| require.Equal(t, testCase.want, home) |
| }) |
| } |
| } |
| |
| func TestMemMapOSWrapper_Open_Nonexistent(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| _, err := wrapper.Open("/foo.txt") |
| require.ErrorContains(t, err, "open /foo.txt: file does not exist") |
| } |
| |
| func TestMemMapOSWrapper_OpenFile_Nonexistent(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| _, err := wrapper.OpenFile("/foo.txt", os.O_RDONLY, 0o700) |
| require.ErrorContains(t, err, "open /foo.txt: file does not exist") |
| } |
| |
| func TestMemMapOSWrapper_ReadFile_Nonexistent(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| _, err := wrapper.ReadFile("/foo.txt") |
| require.ErrorContains(t, err, "open /foo.txt: file does not exist") |
| } |
| |
| func TestMemMapOSWrapper_Stat_Nonexistent(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| _, err := wrapper.Stat("/foo.txt") |
| require.ErrorContains(t, err, "open /foo.txt: file does not exist") |
| } |
| |
| func TestMemMapOSWrapper_Stat_EmptyString(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| _, err := wrapper.Stat("") |
| require.ErrorContains(t, err, "no such file or directory") |
| } |
| |
| func TestMemMapOSWrapper_Walk_Nonexistent(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| |
| walkfunc := func(root string, info fs.FileInfo, err error) error { |
| require.Equal(t, "/nonexistent", root) |
| require.Nil(t, info) |
| require.ErrorContains(t, err, "open /nonexistent: file does not exist") |
| return err |
| } |
| |
| err := wrapper.Walk("/nonexistent", walkfunc) |
| require.ErrorContains(t, err, "open /nonexistent: file does not exist") |
| } |
| |
| func TestMemMapOSWrapper_WriteFile_Open(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| err := wrapper.WriteFile("/foo.txt", []byte("content"), 0o700) |
| require.NoErrorf(t, err, "Failed to write file: %v", err) |
| |
| file, err := wrapper.Open("/foo.txt") |
| require.NoErrorf(t, err, "Failed to open file: %v", err) |
| buffer := make([]byte, 7) |
| bytesRead, err := file.Read(buffer) |
| require.NoErrorf(t, err, "Failed to read from file: %v", err) |
| require.Equal(t, []byte("content"), buffer) |
| require.Equal(t, 7, bytesRead) |
| bytesRead, err = file.Read(buffer) |
| require.Error(t, io.EOF, "Did not get EOF") |
| require.Equal(t, 0, bytesRead) |
| } |
| |
| func TestMemMapOSWrapper_Create_Walk_NonexistentDirectory(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| _, err := wrapper.Create("/parent/foo.txt") |
| require.NoErrorf(t, err, "Got error creating file without parent dir: %v", err) |
| |
| type input struct { |
| root string |
| info fs.FileInfo |
| err error |
| } |
| inputs := []input{} |
| |
| walkfunc := func(root string, info fs.FileInfo, err error) error { |
| inputs = append(inputs, input{root: root, info: info, err: err}) |
| return err |
| } |
| |
| err = wrapper.Walk("/parent", walkfunc) |
| require.NoErrorf(t, err, "Got error walking: %v", err) |
| require.Len(t, inputs, 2) |
| require.Equal(t, "/parent", inputs[0].root) |
| require.True(t, inputs[0].info.IsDir()) |
| require.Equal(t, "/parent/foo.txt", inputs[1].root) |
| require.False(t, inputs[1].info.IsDir()) |
| } |
| |
| func TestMemMapOSWrapper_Create_ReadFile(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| file, err := wrapper.Create("/foo.txt") |
| require.NoErrorf(t, err, "Failed to create file: %v", err) |
| |
| bytesWritten, err := file.Write([]byte("asdf")) |
| require.NoErrorf(t, err, "Failed to write to file: %v", err) |
| require.Equal(t, 4, bytesWritten) |
| |
| contents, err := wrapper.ReadFile("/foo.txt") |
| require.NoErrorf(t, err, "Failed to read file: %v", err) |
| require.Equal(t, []byte("asdf"), contents) |
| } |
| |
| func TestMemMapOSWrapper_ReadDir_NonExistent(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| _, err := wrapper.ReadDir("/nonexistent") |
| require.Error(t, err) |
| require.ErrorContains(t, err, "open /nonexistent: file does not exist") |
| } |
| |
| func TestMemMapOSWrapper_ReadDir_PathIsFile(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| require.NoError(t, wrapper.WriteFile("/myfile", []byte("content"), 0644)) |
| _, err := wrapper.ReadDir("/myfile") |
| require.Error(t, err) |
| require.ErrorContains(t, err, "not a dir") |
| } |
| |
| func TestMemMapOSWrapper_ReadDir_EmptyDir(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| require.NoError(t, wrapper.Mkdir("/mydir", 0755)) |
| entries, err := wrapper.ReadDir("/mydir") |
| require.NoError(t, err) |
| require.Empty(t, entries) |
| } |
| |
| func TestMemMapOSWrapper_ReadDir_MixedContent(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| require.NoError(t, wrapper.MkdirAll("/mydir/b_subdir", 0755)) |
| require.NoError(t, wrapper.WriteFile("/mydir/z_file.txt", nil, 0644)) |
| require.NoError(t, wrapper.WriteFile("/mydir/a_file.txt", nil, 0644)) |
| |
| entries, err := wrapper.ReadDir("/mydir") |
| require.NoError(t, err) |
| |
| gotNames := []string{} |
| for _, entry := range entries { |
| gotNames = append(gotNames, entry.Name()) |
| } |
| sort.Strings(gotNames) |
| expectedNames := []string{"a_file.txt", "b_subdir", "z_file.txt"} |
| require.Equal(t, expectedNames, gotNames, "directory entries do not match") |
| } |
| |
| func TestMemMapOSWrapper_Mkdir_Exists(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| err := wrapper.Mkdir("/parent", 0o700) |
| require.NoErrorf(t, err, "Got error creating directory: %v", err) |
| err = wrapper.Mkdir("/parent", 0o700) |
| require.ErrorContains(t, err, "mkdir /parent: file already exists") |
| } |
| |
| func TestMemMapOSWrapper_Mkdir_MkdirAll(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| err := wrapper.Mkdir("/parent", 0o700) |
| require.NoErrorf(t, err, "Error creating parent: %v", err) |
| |
| err = wrapper.MkdirAll("/parent/child/grandchild", 0o600) |
| require.NoErrorf(t, err, "Error creating grandchild: %v", err) |
| |
| type input struct { |
| root string |
| info fs.FileInfo |
| err error |
| } |
| inputs := []input{} |
| |
| walkfunc := func(root string, info fs.FileInfo, err error) error { |
| inputs = append(inputs, input{root: root, info: info, err: err}) |
| return err |
| } |
| |
| err = wrapper.Walk("/parent", walkfunc) |
| require.NoErrorf(t, err, "Got error walking: %v", err) |
| require.Len(t, inputs, 3) |
| |
| require.Equal(t, "/parent", inputs[0].root) |
| require.True(t, inputs[0].info.IsDir()) |
| require.Equal(t, os.FileMode(0o700)|fs.ModeDir, inputs[0].info.Mode()) |
| |
| require.Equal(t, "/parent/child", inputs[1].root) |
| require.True(t, inputs[1].info.IsDir()) |
| require.Equal(t, os.FileMode(0o600)|fs.ModeDir, inputs[1].info.Mode()) |
| |
| require.Equal(t, "/parent/child/grandchild", inputs[2].root) |
| require.True(t, inputs[2].info.IsDir()) |
| require.Equal(t, os.FileMode(0o600)|fs.ModeDir, inputs[2].info.Mode()) |
| } |
| |
| func TestMemMapOSWrapper_MkdirAll_Exists(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| err := wrapper.MkdirAll("/parent", 0o700) |
| require.NoErrorf(t, err, "Got error creating directory: %v", err) |
| err = wrapper.MkdirAll("/parent", 0o700) |
| require.NoErrorf(t, err, "Got error creating directory second time: %v", err) |
| } |
| |
| func TestMemMapOSWrapper_MkdirTemp(t *testing.T) { |
| tests := []struct { |
| name string |
| pattern string |
| re string |
| }{ |
| { |
| name: "Default behavior", |
| pattern: "tempdir", |
| re: "/tmp/tempdir\\d+", |
| }, |
| { |
| name: "Single star front", |
| pattern: "*tempdir", |
| re: "/tmp/\\d+tempdir", |
| }, |
| { |
| name: "Single star middle", |
| pattern: "temp*dir", |
| re: "/tmp/temp\\d+dir", |
| }, |
| { |
| name: "Multiple stars", |
| pattern: "temp*dir*", |
| re: "/tmp/temp\\*dir\\d+", |
| }, |
| } |
| |
| for _, testCase := range tests { |
| t.Run(testCase.name, func(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| dir, err := wrapper.MkdirTemp("/tmp", testCase.pattern) |
| require.NoErrorf(t, err, "Error creating temporary directory: %v", err) |
| |
| re, err := regexp.Compile(testCase.re) |
| require.NoErrorf(t, err, "Error compiling regexp: %s", err) |
| require.True(t, re.Match([]byte(dir))) |
| }) |
| } |
| } |
| |
| func TestMemMapOSWrapper_Remove(t *testing.T) { |
| tests := []struct { |
| name string |
| filesToCreate []string |
| dirsToCreate []string |
| toRemove string |
| wantErr bool |
| wantErrMsg string |
| }{ |
| { |
| name: "Non-existent", |
| toRemove: "/foo.txt", |
| wantErr: true, |
| wantErrMsg: "remove /foo.txt: file does not exist", |
| }, |
| { |
| name: "File", |
| filesToCreate: []string{"/foo.txt"}, |
| toRemove: "/foo.txt", |
| }, |
| { |
| name: "Empty dir", |
| dirsToCreate: []string{"/foo"}, |
| toRemove: "/foo", |
| }, |
| { |
| // This differs from the real os implementation, as removing a non-empty |
| // dir is supposed to fail. |
| name: "Non-empty dir", |
| dirsToCreate: []string{"/foo/bar"}, |
| toRemove: "/foo", |
| }, |
| } |
| |
| for _, testCase := range tests { |
| t.Run(testCase.name, func(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| for _, f := range testCase.filesToCreate { |
| _, err := wrapper.Create(f) |
| require.NoErrorf(t, err, "Failed to create file: %v", err) |
| } |
| for _, d := range testCase.dirsToCreate { |
| err := wrapper.MkdirAll(d, 0o700) |
| require.NoErrorf(t, err, "Failed to create directory: %v", err) |
| } |
| err := wrapper.Remove(testCase.toRemove) |
| if testCase.wantErr { |
| require.ErrorContains(t, err, testCase.wantErrMsg) |
| } else { |
| require.NoErrorf(t, err, "Got unexpected error: %v") |
| } |
| |
| // Make sure things were actually deleted. |
| walkfunc := func(root string, info fs.FileInfo, err error) error { |
| require.Equal(t, "/", root) |
| return err |
| } |
| |
| err = wrapper.Walk("/", walkfunc) |
| require.NoErrorf(t, err, "Error walking: %v", err) |
| }) |
| } |
| } |
| |
| func TestMemMapOSWrapper_RemoveAll(t *testing.T) { |
| tests := []struct { |
| name string |
| filesToCreate []string |
| dirsToCreate []string |
| toRemove string |
| }{ |
| { |
| name: "Non-existent", |
| toRemove: "/foo.txt", |
| }, |
| { |
| name: "File", |
| filesToCreate: []string{"/foo.txt"}, |
| toRemove: "/foo.txt", |
| }, |
| { |
| name: "Empty dir", |
| dirsToCreate: []string{"/foo"}, |
| toRemove: "/foo", |
| }, |
| { |
| // This differs from the real os implementation, as removing a non-empty |
| // dir is supposed to fail. |
| name: "Non-empty dir", |
| dirsToCreate: []string{"/foo/bar"}, |
| toRemove: "/foo", |
| }, |
| } |
| |
| for _, testCase := range tests { |
| t.Run(testCase.name, func(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| for _, f := range testCase.filesToCreate { |
| _, err := wrapper.Create(f) |
| require.NoErrorf(t, err, "Failed to create file: %v", err) |
| } |
| for _, d := range testCase.dirsToCreate { |
| err := wrapper.MkdirAll(d, 0o700) |
| require.NoErrorf(t, err, "Failed to create directory: %v", err) |
| } |
| err := wrapper.RemoveAll(testCase.toRemove) |
| require.NoErrorf(t, err, "Got unexpected error: %v") |
| |
| // Make sure things were actually deleted. |
| walkfunc := func(root string, info fs.FileInfo, err error) error { |
| require.Equal(t, "/", root) |
| return err |
| } |
| |
| err = wrapper.Walk("/", walkfunc) |
| require.NoErrorf(t, err, "Error walking: %v", err) |
| }) |
| } |
| } |
| |
| func TestMemMapOSWrapper_WriteFile_OpenFile(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| err := wrapper.WriteFile("/foo.txt", []byte("content"), 0o700) |
| require.NoErrorf(t, err, "Failed to write file: %v", err) |
| |
| file, err := wrapper.OpenFile("/foo.txt", os.O_RDONLY, 0o700) |
| require.NoErrorf(t, err, "Failed to open file: %v", err) |
| buffer := make([]byte, 7) |
| bytesRead, err := file.Read(buffer) |
| require.NoErrorf(t, err, "Failed to read from file: %v", err) |
| require.Equal(t, []byte("content"), buffer) |
| require.Equal(t, 7, bytesRead) |
| bytesRead, err = file.Read(buffer) |
| require.Errorf(t, io.EOF, "Did not get EOF: %v", err) |
| require.Equal(t, 0, bytesRead) |
| } |
| |
| func TestMemMapOSWrapper_WriteFile_ReadFile(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| err := wrapper.WriteFile("/foo.txt", []byte("content"), 0o700) |
| require.NoErrorf(t, err, "Failed to write file: %v", err) |
| |
| contents, err := wrapper.ReadFile("/foo.txt") |
| require.NoErrorf(t, err, "Failed to read file: %v", err) |
| require.Equal(t, []byte("content"), contents) |
| } |
| |
| func TestMemMapOSWrapper_WriteFile_Stat(t *testing.T) { |
| wrapper := CreateMemMapOSWrapper() |
| approxWriteTime := time.Now() |
| err := wrapper.WriteFile("/foo.txt", []byte("content"), 0o700) |
| require.NoErrorf(t, err, "Failed to write file: %v", err) |
| |
| fileInfo, err := wrapper.Stat("/foo.txt") |
| require.NoErrorf(t, err, "Got error stat-ing file: %v", err) |
| require.Equal(t, "foo.txt", fileInfo.Name()) |
| require.Equal(t, int64(7), fileInfo.Size()) |
| require.Equal(t, os.FileMode(0o700), fileInfo.Mode()) |
| // Assert that the actual mod time is within 10ms of when we requested the |
| // write. |
| require.LessOrEqual(t, fileInfo.ModTime().UnixMilli()-approxWriteTime.UnixMilli(), int64(10)) |
| require.False(t, fileInfo.IsDir()) |
| } |
