Initial project import

tools/v/vlib/veb/assets/assets_test.v

@@ -0,0 +1,191 @@
+import veb.assets
+import os
+
+const base_cache_dir = os.join_path(os.vtmp_dir(), 'veb_assets_test_cache')
+
+fn testsuite_begin() {
+	os.mkdir_all(base_cache_dir) or {}
+}
+
+fn testsuite_end() {
+	os.rmdir_all(base_cache_dir) or {}
+}
+
+// clean_cache_dir used before and after tests that write to a cache directory.
+// Because of parallel compilation and therefore test running,
+// unique cache dirs are needed per test function.
+fn clean_cache_dir(dir string) {
+	os.rmdir_all(dir) or {}
+}
+
+fn cache_dir(test_name string) string {
+	return os.join_path(base_cache_dir, test_name)
+}
+
+fn get_test_file_path(file string) string {
+	path := os.join_path(base_cache_dir, file)
+	os.rm(path) or {}
+	os.write_file(path, get_test_file_contents(file)) or { panic(err) }
+	return path
+}
+
+fn get_test_file_contents(file string) string {
+	contents := match file {
+		'test1.js' { '{"one": 1}\n' }
+		'test2.js' { '{"two": 2}\n' }
+		'test1.css' { '.one {\n\tcolor: #336699;\n}\n' }
+		'test2.css' { '.two {\n\tcolor: #996633;\n}\n' }
+		else { 'wibble\n' }
+	}
+
+	return contents
+}
+
+fn test_add() {
+	mut am := assets.AssetManager{}
+
+	mut errored := false
+	am.add(.css, 'test.css', 'test.css') or { errored = true }
+	assert errored == true, 'am.add should error'
+
+	errored = false
+	am.add(.css, get_test_file_path('test1.css'), 'included.css') or {
+		eprintln(err)
+		errored = true
+	}
+	assert errored == false, 'am.add should not error'
+
+	css_assets := am.get_assets(.css)
+	assert css_assets.len == 1
+	assert css_assets[0].file_path == get_test_file_path('test1.css')
+	assert css_assets[0].include_name == 'included.css'
+}
+
+fn test_add_minify_missing_cache_dir() {
+	mut am := assets.AssetManager{
+		minify: true
+	}
+	mut errored := false
+	am.add(.js, get_test_file_path('test1.css'), 'included.js') or {
+		assert err.msg() == 'cannot minify asset: cache directory is not valid'
+		errored = true
+	}
+
+	assert errored == true, 'am.add should return an error'
+}
+
+fn test_add_minified() {
+	mut am := assets.AssetManager{
+		minify:    true
+		cache_dir: cache_dir('test_add_minified')
+	}
+	clean_cache_dir(am.cache_dir)
+
+	am.add(.js, get_test_file_path('test1.js'), 'included.js')!
+
+	js_assets := am.get_assets(.js)
+	assert js_assets.len == 1
+	assert js_assets[0].file_path.starts_with(am.cache_dir) == true
+}
+
+fn test_combine() {
+	mut am := assets.AssetManager{
+		cache_dir: cache_dir('test_combine')
+	}
+	clean_cache_dir(am.cache_dir)
+
+	am.add(.css, get_test_file_path('test1.css'), 'test1.css')!
+	am.add(.css, get_test_file_path('test2.css'), 'test2.css')!
+
+	combined_path := am.combine(.css)!
+	combined := os.read_file(combined_path)!
+
+	expected := get_test_file_contents('test1.css') + '\n' + get_test_file_contents('test2.css') +
+		'\n'
+	assert combined == expected
+}
+
+fn test_combine_minified() {
+	// minify test is simple for now, because assets are not properly minified yet
+	mut am := assets.AssetManager{
+		cache_dir: cache_dir('test_combine_minified')
+		minify:    true
+	}
+	clean_cache_dir(am.cache_dir)
+
+	am.add(.css, get_test_file_path('test1.css'), 'test1.css')!
+	am.add(.css, get_test_file_path('test2.css'), 'test2.css')!
+
+	combined_path := am.combine(.css)!
+	combined := os.read_file(combined_path)!
+
+	// minified version should be 2 lines + one extra newline
+	assert combined.split('\n').len == 3
+}
+
+fn test_minify_cache_last_modified() {
+	mut am := assets.AssetManager{
+		minify:    true
+		cache_dir: cache_dir('test_cache_last_modified')
+	}
+	clean_cache_dir(am.cache_dir)
+
+	// first we write the file and add it
+	am.add(.js, get_test_file_path('test1.js'), 'included.js')!
+	mut js_assets := am.get_assets(.js)
+	assert js_assets.len == 1
+	old_cached_path := js_assets[0].file_path
+
+	// then we only add the file, the file is not modified so the "last modified is the same".
+	// we expect that the asset manager doesn't cache a minified file if it hasn't been changed
+	// the last time it was added
+	am.add(.js, os.join_path(base_cache_dir, 'test1.js'), 'included.js')!
+
+	js_assets = am.get_assets(.js)
+	// check if the file isn't added twice
+	assert js_assets.len == 1
+	// if the file path was not modified, veb.assets didn't overwrite the file
+	assert js_assets[0].file_path == old_cached_path
+}
+
+fn test_cleanup_cache() {
+	mut am := assets.AssetManager{
+		minify:    true
+		cache_dir: cache_dir('test_cleanup_cache')
+	}
+	clean_cache_dir(am.cache_dir)
+	// manually make the cache dir
+	os.mkdir_all(am.cache_dir) or {}
+
+	// write a file to the cache dir isn't added to the asset manager to represent
+	// a previously cached file
+	path1 := os.join_path(am.cache_dir, 'test1.css')
+	os.write_file(path1, 'h1 { color: red; }')!
+	assert os.exists(path1) == true
+
+	// add a file to the asset manager and write it
+	am.add(.css, get_test_file_path('test2.css'), 'test2.css')!
+	css_assets := am.get_assets(.css)
+	// get the cached path
+	assert css_assets.len == 1
+	path2 := css_assets[0].file_path
+	assert os.exists(path2) == true
+
+	am.cleanup_cache()!
+
+	// the first asset wasn't added to the asset manager, so it should not exist
+	assert os.exists(path1) == false
+	assert os.exists(path2) == true
+}
+
+fn test_include() {
+	mut am := assets.AssetManager{}
+
+	css_path := get_test_file_path('test1.css')
+	js_path := get_test_file_path('test1.js')
+	am.add(.css, css_path, 'other.css')!
+	am.add(.js, js_path, 'js/test.js')!
+
+	assert am.include(.css, 'other.css') == '<link rel="stylesheet" href="${css_path}">'
+	assert am.include(.js, 'js/test.js') == '<script src="${js_path}"></script>'
+}