github.com/tetratelabs/wazero@v1.2.1/internal/filecache/file_cache_test.go (about)

     1  //go:build go1.18
     2  
     3  package filecache
     4  
     5  import (
     6  	"bytes"
     7  	"io"
     8  	"os"
     9  	"testing"
    10  
    11  	"github.com/tetratelabs/wazero/internal/testing/require"
    12  )
    13  
    14  func TestFileReadCloser_Close(t *testing.T) {
    15  	fc := newFileCache(t.TempDir())
    16  	key := Key{1, 2, 3}
    17  
    18  	err := fc.Add(key, bytes.NewReader([]byte{1, 2, 3, 4}))
    19  	require.NoError(t, err)
    20  
    21  	c, ok, err := fc.Get(key)
    22  	require.NoError(t, err)
    23  	require.True(t, ok)
    24  
    25  	// At this point, file is not closed, therefore TryLock should fail.
    26  	require.False(t, fc.mux.TryLock())
    27  
    28  	// Close, and then TryLock should succeed this time.
    29  	require.NoError(t, c.Close())
    30  	require.True(t, fc.mux.TryLock())
    31  }
    32  
    33  func TestFileCache_Add(t *testing.T) {
    34  	fc := newFileCache(t.TempDir())
    35  
    36  	t.Run("not exist", func(t *testing.T) {
    37  		content := []byte{1, 2, 3, 4, 5}
    38  		id := Key{1, 2, 3, 4, 5, 6, 7}
    39  		err := fc.Add(id, bytes.NewReader(content))
    40  		require.NoError(t, err)
    41  
    42  		// Ensures that file exists.
    43  		cached, err := os.ReadFile(fc.path(id))
    44  		require.NoError(t, err)
    45  
    46  		// Check if the saved content is the same as the given one.
    47  		require.Equal(t, content, cached)
    48  	})
    49  
    50  	t.Run("already exists", func(t *testing.T) {
    51  		content := []byte{1, 2, 3, 4, 5}
    52  
    53  		id := Key{1, 2, 3}
    54  
    55  		// Writes the pre-existing file for the same ID.
    56  		p := fc.path(id)
    57  		f, err := os.Create(p)
    58  		require.NoError(t, err)
    59  		_, err = f.Write(content)
    60  		require.NoError(t, err)
    61  		require.NoError(t, f.Close())
    62  
    63  		err = fc.Add(id, bytes.NewReader(content))
    64  		require.NoError(t, err)
    65  
    66  		// Ensures that file exists.
    67  		cached, err := os.ReadFile(fc.path(id))
    68  		require.NoError(t, err)
    69  
    70  		// Check if the saved content is the same as the given one.
    71  		require.Equal(t, content, cached)
    72  	})
    73  }
    74  
    75  func TestFileCache_Delete(t *testing.T) {
    76  	fc := newFileCache(t.TempDir())
    77  	t.Run("non-exist", func(t *testing.T) {
    78  		id := Key{0}
    79  		err := fc.Delete(id)
    80  		require.NoError(t, err)
    81  	})
    82  	t.Run("exist", func(t *testing.T) {
    83  		id := Key{1, 2, 3}
    84  		p := fc.path(id)
    85  		f, err := os.Create(p)
    86  		require.NoError(t, err)
    87  		require.NoError(t, f.Close())
    88  
    89  		// Ensures that file exists now.
    90  		f, err = os.Open(p)
    91  		require.NoError(t, err)
    92  		require.NoError(t, f.Close())
    93  
    94  		// Delete the cache.
    95  		err = fc.Delete(id)
    96  		require.NoError(t, err)
    97  
    98  		// Ensures that file no longer exists.
    99  		_, err = os.Open(p)
   100  		require.ErrorIs(t, err, os.ErrNotExist)
   101  	})
   102  }
   103  
   104  func TestFileCache_Get(t *testing.T) {
   105  	fc := newFileCache(t.TempDir())
   106  
   107  	t.Run("exist", func(t *testing.T) {
   108  		content := []byte{1, 2, 3, 4, 5}
   109  		id := Key{1, 2, 3}
   110  
   111  		// Writes the pre-existing file for the ID.
   112  		p := fc.path(id)
   113  		f, err := os.Create(p)
   114  		require.NoError(t, err)
   115  		_, err = f.Write(content)
   116  		require.NoError(t, err)
   117  		require.NoError(t, f.Close())
   118  
   119  		result, ok, err := fc.Get(id)
   120  		require.NoError(t, err)
   121  		require.True(t, ok)
   122  		defer func() {
   123  			require.NoError(t, result.Close())
   124  		}()
   125  
   126  		actual, err := io.ReadAll(result)
   127  		require.NoError(t, err)
   128  
   129  		require.Equal(t, content, actual)
   130  	})
   131  	t.Run("not exist", func(t *testing.T) {
   132  		_, ok, err := fc.Get(Key{0xf})
   133  		// Non-exist should not be error.
   134  		require.NoError(t, err)
   135  		require.False(t, ok)
   136  	})
   137  }
   138  
   139  func TestFileCache_path(t *testing.T) {
   140  	fc := &fileCache{dirPath: "/tmp/.wazero"}
   141  	actual := fc.path(Key{1, 2, 3, 4, 5})
   142  	require.Equal(t, "/tmp/.wazero/0102030405000000000000000000000000000000000000000000000000000000", actual)
   143  }