agila_open_tool/tools/v/vlib/io/fs/fs_test.v

module fs

import io
import os

struct MockInfo {
	name_     string
	size_     u64
	mode_     os.FileMode
	mod_time_ i64
}

fn (info MockInfo) name() string {
	return info.name_
}

fn (info MockInfo) size() u64 {
	return info.size_
}

fn (info MockInfo) mode() os.FileMode {
	return info.mode_
}

fn (info MockInfo) mod_time() i64 {
	return info.mod_time_
}

fn (info MockInfo) is_dir() bool {
	return info.mode_.typ == .directory
}

struct MockFile {
	data  []u8
	info_ MockInfo
mut:
	offset  int
	entries []DirEntry
}

fn (mut file MockFile) read(mut buf []u8) !int {
	if file.offset >= file.data.len {
		return io.Eof{}
	}
	read := copy(mut buf, file.data[file.offset..])
	file.offset += read
	return read
}

fn (file MockFile) stat() !FileInfo {
	return file.info_
}

fn (mut file MockFile) close() {}

fn (mut file MockFile) read_dir(n int) ![]DirEntry {
	if n <= 0 || n >= file.entries.len {
		return file.entries.clone()
	}
	return file.entries[..n].clone()
}

struct FallbackFS {}

fn (filesystem FallbackFS) open(name string) !File {
	match name {
		'notes.txt' {
			return File(MockFile{
				data:  'fallback'.bytes()
				info_: MockInfo{
					name_:     'notes.txt'
					size_:     u64('fallback'.len)
					mode_:     os.FileMode{
						typ: .regular
					}
					mod_time_: 101
				}
			})
		}
		'dir' {
			return File(MockFile{
				info_:   MockInfo{
					name_: 'dir'
					mode_: os.FileMode{
						typ: .directory
					}
				}
				entries: [
					file_info_to_dir_entry(MockInfo{
						name_: 'b.txt'
						mode_: os.FileMode{
							typ: .regular
						}
					}),
					file_info_to_dir_entry(MockInfo{
						name_: 'a.txt'
						mode_: os.FileMode{
							typ: .regular
						}
					}),
				]
			})
		}
		else {
			return error('missing ${name}')
		}
	}
}

struct OptimizedFS {}

fn (filesystem OptimizedFS) open(name string) !File {
	return error('unexpected open for ${name}')
}

fn (filesystem OptimizedFS) read_file(name string) ![]u8 {
	return 'optimized'.bytes()
}

fn (filesystem OptimizedFS) read_dir(name string) ![]DirEntry {
	return [
		file_info_to_dir_entry(MockInfo{
			name_: 'z.txt'
			mode_: os.FileMode{
				typ: .regular
			}
		}),
		file_info_to_dir_entry(MockInfo{
			name_: 'm.txt'
			mode_: os.FileMode{
				typ: .regular
			}
		}),
	]
}

fn (filesystem OptimizedFS) stat(name string) !FileInfo {
	return MockInfo{
		name_:     name
		size_:     42
		mode_:     os.FileMode{
			typ: .regular
		}
		mod_time_: 202
	}
}

fn entry_names(entries []DirEntry) []string {
	mut names := []string{cap: entries.len}
	for entry in entries {
		names << entry.name()
	}
	return names
}

fn test_valid_path() {
	assert valid_path('.')
	assert valid_path('alpha')
	assert valid_path('alpha/beta')
	assert valid_path(r'alpha\beta')
	assert !valid_path('')
	assert !valid_path('/alpha')
	assert !valid_path('alpha/')
	assert !valid_path('alpha//beta')
	assert !valid_path('alpha/./beta')
	assert !valid_path('alpha/../beta')
}

fn test_file_info_to_dir_entry() {
	info := MockInfo{
		name_:     'subdir'
		size_:     12
		mode_:     os.FileMode{
			typ: .directory
		}
		mod_time_: 303
	}
	entry := file_info_to_dir_entry(info)
	assert entry.name() == 'subdir'
	assert entry.is_dir()
	assert entry.typ() == .directory
	assert entry.info()!.mod_time() == 303
}

fn test_read_file_uses_open_fallback() {
	data := read_file(FallbackFS{}, 'notes.txt')!
	assert data == 'fallback'.bytes()
}

fn test_read_file_uses_read_file_fs_when_available() {
	data := read_file(OptimizedFS{}, 'notes.txt')!
	assert data == 'optimized'.bytes()
}

fn test_read_dir_uses_open_fallback_and_sorts() {
	entries := read_dir(FallbackFS{}, 'dir')!
	assert entry_names(entries) == ['a.txt', 'b.txt']
}

fn test_read_dir_uses_read_dir_fs_when_available() {
	entries := read_dir(OptimizedFS{}, 'dir')!
	assert entry_names(entries) == ['m.txt', 'z.txt']
}

fn test_stat_uses_open_fallback() {
	info := stat(FallbackFS{}, 'notes.txt')!
	assert info.name() == 'notes.txt'
	assert info.size() == u64('fallback'.len)
}

fn test_stat_uses_stat_fs_when_available() {
	info := stat(OptimizedFS{}, 'notes.txt')!
	assert info.name() == 'notes.txt'
	assert info.size() == 42
	assert info.mod_time() == 202
}