monorepo

Co-authored-by: Malte Poll <mp@edgeless.systems>
Co-authored-by: katexochen <katexochen@users.noreply.github.com>
Co-authored-by: Daniel Weiße <dw@edgeless.systems>
Co-authored-by: Thomas Tendyck <tt@edgeless.systems>
Co-authored-by: Benedict Schlueter <bs@edgeless.systems>
Co-authored-by: leongross <leon.gross@rub.de>
Co-authored-by: Moritz Eckert <m1gh7ym0@gmail.com>

cli/file/file_test.go

@@ -0,0 +1,168 @@
+package file
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/spf13/afero"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestReadJSON(t *testing.T) {
+	type testContent struct {
+		First  string
+		Second int
+	}
+	someContent := testContent{
+		First:  "first",
+		Second: 2,
+	}
+	jsonContent, err := json.MarshalIndent(someContent, "", "\t")
+	require.NoError(t, err)
+
+	testCases := map[string]struct {
+		fs          afero.Fs
+		setupFs     func(fs *afero.Afero) error
+		name        string
+		wantContent interface{}
+		wantErr     bool
+	}{
+		"successful read": {
+			fs:          afero.NewMemMapFs(),
+			name:        "test/statefile",
+			setupFs:     func(fs *afero.Afero) error { return fs.WriteFile("test/statefile", jsonContent, 0o755) },
+			wantContent: someContent,
+		},
+		"file not existent": {
+			fs:      afero.NewMemMapFs(),
+			name:    "test/statefile",
+			wantErr: true,
+		},
+		"file not json": {
+			fs:      afero.NewMemMapFs(),
+			name:    "test/statefile",
+			setupFs: func(fs *afero.Afero) error { return fs.WriteFile("test/statefile", []byte{0x1}, 0o755) },
+			wantErr: true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+			require := require.New(t)
+
+			handler := NewHandler(tc.fs)
+			if tc.setupFs != nil {
+				require.NoError(tc.setupFs(handler.fs))
+			}
+
+			resultContent := &testContent{}
+			if tc.wantErr {
+				assert.Error(handler.ReadJSON(tc.name, resultContent))
+			} else {
+				assert.NoError(handler.ReadJSON(tc.name, resultContent))
+				assert.Equal(tc.wantContent, *resultContent)
+			}
+		})
+	}
+}
+
+func TestWriteJSON(t *testing.T) {
+	type testContent struct {
+		First  string
+		Second int
+	}
+	someContent := testContent{
+		First:  "first",
+		Second: 2,
+	}
+	notMarshalableContent := struct{ Foo chan int }{Foo: make(chan int)}
+
+	testCases := map[string]struct {
+		fs        afero.Fs
+		setupFs   func(af afero.Afero) error
+		name      string
+		content   interface{}
+		overwrite bool
+		wantErr   bool
+	}{
+		"successful write": {
+			fs:      afero.NewMemMapFs(),
+			name:    "test/statefile",
+			content: someContent,
+		},
+		"successful overwrite": {
+			fs:        afero.NewMemMapFs(),
+			setupFs:   func(af afero.Afero) error { return af.WriteFile("test/statefile", []byte{}, 0o644) },
+			name:      "test/statefile",
+			content:   someContent,
+			overwrite: true,
+		},
+		"read only fs": {
+			fs:      afero.NewReadOnlyFs(afero.NewMemMapFs()),
+			name:    "test/statefile",
+			content: someContent,
+			wantErr: true,
+		},
+		"file already exists": {
+			fs:      afero.NewMemMapFs(),
+			setupFs: func(af afero.Afero) error { return af.WriteFile("test/statefile", []byte{}, 0o644) },
+			name:    "test/statefile",
+			content: someContent,
+			wantErr: true,
+		},
+		"marshal error": {
+			fs:      afero.NewMemMapFs(),
+			name:    "test/statefile",
+			content: notMarshalableContent,
+			wantErr: true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+			require := require.New(t)
+
+			handler := NewHandler(tc.fs)
+			if tc.setupFs != nil {
+				require.NoError(tc.setupFs(afero.Afero{Fs: tc.fs}))
+			}
+
+			if tc.wantErr {
+				assert.Error(handler.WriteJSON(tc.name, tc.content, tc.overwrite))
+			} else {
+				assert.NoError(handler.WriteJSON(tc.name, tc.content, tc.overwrite))
+				resultContent := &testContent{}
+				assert.NoError(handler.ReadJSON(tc.name, resultContent))
+				assert.Equal(tc.content, *resultContent)
+			}
+		})
+	}
+}
+
+func TestRemove(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+
+	fs := afero.NewMemMapFs()
+	handler := NewHandler(fs)
+	aferoHelper := afero.Afero{Fs: fs}
+	require.NoError(aferoHelper.WriteFile("a", []byte{0xa}, 0o644))
+	require.NoError(aferoHelper.WriteFile("b", []byte{0xb}, 0o644))
+	require.NoError(aferoHelper.WriteFile("c", []byte{0xc}, 0o644))
+
+	assert.NoError(handler.Remove("a"))
+	assert.NoError(handler.Remove("b"))
+	assert.NoError(handler.Remove("c"))
+
+	_, err := handler.fs.Stat("a")
+	assert.ErrorIs(err, afero.ErrFileNotFound)
+	_, err = handler.fs.Stat("b")
+	assert.ErrorIs(err, afero.ErrFileNotFound)
+	_, err = handler.fs.Stat("c")
+	assert.ErrorIs(err, afero.ErrFileNotFound)
+
+	assert.Error(handler.Remove("d"))
+}