437 lines
19 KiB
C#
437 lines
19 KiB
C#
internal static partial class Program
|
|
{
|
|
static Task TestVaultCryptoRoundtripAsync()
|
|
{
|
|
var crypto = new VaultCryptoService();
|
|
var plaintext = "sample vault payload";
|
|
var payload = crypto.EncryptData(System.Text.Encoding.UTF8.GetBytes(plaintext), "vault-pass-123");
|
|
|
|
Assert(payload.Length == VaultCryptoService.SaltSize + VaultCryptoService.NonceSize + VaultCryptoService.TagSize + plaintext.Length, "Vault payload length should match salt+nonce+tag+ciphertext layout.");
|
|
var decrypted = crypto.DecryptData(payload, "vault-pass-123");
|
|
Assert(System.Text.Encoding.UTF8.GetString(decrypted) == plaintext, "Vault roundtrip decrypt should return original plaintext.");
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultCryptoDecryptsPythonFixtureAsync()
|
|
{
|
|
var crypto = new VaultCryptoService();
|
|
|
|
var payload = Convert.FromBase64String("AAECAwQFBgcICQoLDA0ODwABAgMEBQYHCAkKC6AErhDEMERBl7OFkG4L4oZ2JZckS0VzhxaZoVLckF7VXE+NIYXILsJ8f1I=");
|
|
var expectedPlaintext = Convert.FromBase64String("dmF1bHQgcGF5bG9hZCBleGFtcGxlCmxpbmUy");
|
|
var decrypted = crypto.DecryptData(payload, "vault-pass-123");
|
|
|
|
Assert(decrypted.SequenceEqual(expectedPlaintext), "C# decrypt should match Python-generated payload plaintext.");
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultKeyDerivationMatchesPythonAsync()
|
|
{
|
|
var crypto = new VaultCryptoService();
|
|
var salt = Enumerable.Range(0, VaultCryptoService.SaltSize).Select(i => (byte)i).ToArray();
|
|
var key = crypto.DeriveKey("vault-pass-123", salt);
|
|
var expectedKeyHex = "b29f523f28bf178f6815c6ca9ee2a588d79b3bd9a822c92a2f0dde5bc853bb52";
|
|
var actualKeyHex = Convert.ToHexString(key).ToLowerInvariant();
|
|
|
|
Assert(actualKeyHex == expectedKeyHex, "Derived key should match Python PBKDF2 fixture key.");
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultMonthlyFilenameParityAsync()
|
|
{
|
|
IVaultStorageService vaultStorage = new VaultStorageService(new VaultCryptoService());
|
|
var name = vaultStorage.GetMonthlyVaultFileName(new DateTime(2026, 2, 7));
|
|
Assert(name == "2026-02.vault", "Monthly vault filename must match yyyy-MM.vault format.");
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultLoadClearsAndExtractsAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-vault-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
Directory.CreateDirectory(dataDir);
|
|
|
|
try
|
|
{
|
|
File.WriteAllText(Path.Combine(dataDir, "old_file.md"), "stale");
|
|
|
|
var zipBytes = CreateZipBytes(new Dictionary<string, string>
|
|
{
|
|
["2026-02-01.md"] = "hello from vault"
|
|
});
|
|
var crypto = new VaultCryptoService();
|
|
var encrypted = crypto.EncryptData(zipBytes, "vault-pass-123");
|
|
File.WriteAllBytes(Path.Combine(vaultDir, "2026-02.vault"), encrypted);
|
|
|
|
IVaultStorageService storage = new VaultStorageService(crypto);
|
|
var ok = storage.LoadAllVaults("vault-pass-123", vaultDir, dataDir);
|
|
|
|
Assert(ok, "Expected vault load success with correct password.");
|
|
Assert(!File.Exists(Path.Combine(dataDir, "old_file.md")), "Data directory should be cleared before extraction.");
|
|
var extractedPath = Path.Combine(dataDir, "2026-02-01.md");
|
|
Assert(File.Exists(extractedPath), "Expected markdown file extracted from vault archive.");
|
|
Assert(File.ReadAllText(extractedPath) == "hello from vault", "Extracted file content mismatch.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultLoadWrongPasswordPreservesVaultAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-vault-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
Directory.CreateDirectory(dataDir);
|
|
|
|
try
|
|
{
|
|
var zipBytes = CreateZipBytes(new Dictionary<string, string>
|
|
{
|
|
["2026-02-01.md"] = "hello from vault"
|
|
});
|
|
var crypto = new VaultCryptoService();
|
|
var encrypted = crypto.EncryptData(zipBytes, "vault-pass-123");
|
|
var vaultPath = Path.Combine(vaultDir, "2026-02.vault");
|
|
File.WriteAllBytes(vaultPath, encrypted);
|
|
var before = File.ReadAllBytes(vaultPath);
|
|
|
|
IVaultStorageService storage = new VaultStorageService(crypto);
|
|
var ok = storage.LoadAllVaults("wrong-password", vaultDir, dataDir);
|
|
var after = File.ReadAllBytes(vaultPath);
|
|
|
|
Assert(!ok, "Expected vault load failure with wrong password.");
|
|
Assert(before.SequenceEqual(after), "Vault file bytes should remain unchanged on wrong password.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultLoadLegacyInitVaultHandlingAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-vault-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
Directory.CreateDirectory(dataDir);
|
|
|
|
try
|
|
{
|
|
var legacyPath = Path.Combine(vaultDir, "_init_vault.vault");
|
|
File.WriteAllBytes(legacyPath, [1, 2, 3, 4]);
|
|
|
|
IVaultStorageService storage = new VaultStorageService(new VaultCryptoService());
|
|
var ok = storage.LoadAllVaults("vault-pass-123", vaultDir, dataDir);
|
|
|
|
Assert(ok, "Legacy-only vault directory should still be treated as successful load state.");
|
|
Assert(!File.Exists(legacyPath), "Legacy _init_vault.vault should be removed during load.");
|
|
Assert(Directory.Exists(dataDir), "Data directory should exist after load workflow.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultCurrentMonthSaveOptimizedAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-vault-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
Directory.CreateDirectory(dataDir);
|
|
|
|
try
|
|
{
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-02-01.md"), "feb one");
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-02-18.md"), "feb two");
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-01-31.md"), "jan one");
|
|
|
|
IVaultStorageService storage = new VaultStorageService(new VaultCryptoService());
|
|
var now = new DateTime(2026, 2, 22, 12, 0, 0, DateTimeKind.Utc);
|
|
|
|
var firstSaved = storage.SaveCurrentMonthVault("vault-pass-123", vaultDir, dataDir, now);
|
|
Assert(firstSaved, "Expected first current-month save to write vault data.");
|
|
|
|
var febVaultPath = Path.Combine(vaultDir, "2026-02.vault");
|
|
var janVaultPath = Path.Combine(vaultDir, "2026-01.vault");
|
|
Assert(File.Exists(febVaultPath), "Expected current-month vault file to be created.");
|
|
Assert(!File.Exists(janVaultPath), "Current-month save should not write non-current month vault files.");
|
|
|
|
var entries = ReadVaultEntryTexts(febVaultPath, "vault-pass-123");
|
|
Assert(entries.Count == 2, "Current-month vault should include only current-month markdown files.");
|
|
Assert(entries.ContainsKey("2026-02-01.md"), "Missing first current-month entry in vault archive.");
|
|
Assert(entries.ContainsKey("2026-02-18.md"), "Missing second current-month entry in vault archive.");
|
|
Assert(!entries.ContainsKey("2026-01-31.md"), "Current-month vault must not include previous-month files.");
|
|
|
|
var beforeSkipBytes = File.ReadAllBytes(febVaultPath);
|
|
var secondSaved = storage.SaveCurrentMonthVault("vault-pass-123", vaultDir, dataDir, now);
|
|
var afterSkipBytes = File.ReadAllBytes(febVaultPath);
|
|
Assert(!secondSaved, "Expected unchanged current-month save to skip write.");
|
|
Assert(beforeSkipBytes.SequenceEqual(afterSkipBytes), "Vault bytes should remain unchanged when save is skipped.");
|
|
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-02-18.md"), "feb two changed");
|
|
var thirdSaved = storage.SaveCurrentMonthVault("vault-pass-123", vaultDir, dataDir, now);
|
|
Assert(thirdSaved, "Expected save to run after current-month file change.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultRebuildAllVaultsAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-vault-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
Directory.CreateDirectory(dataDir);
|
|
|
|
try
|
|
{
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-01-31.md"), "jan body");
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-02-01.md"), "feb body");
|
|
File.WriteAllText(Path.Combine(dataDir, "not-a-journal.md"), "should be ignored");
|
|
|
|
IVaultStorageService storage = new VaultStorageService(new VaultCryptoService());
|
|
storage.RebuildAllVaults("vault-pass-123", vaultDir, dataDir);
|
|
|
|
var janVaultPath = Path.Combine(vaultDir, "2026-01.vault");
|
|
var febVaultPath = Path.Combine(vaultDir, "2026-02.vault");
|
|
Assert(File.Exists(janVaultPath), "Expected January vault from rebuild flow.");
|
|
Assert(File.Exists(febVaultPath), "Expected February vault from rebuild flow.");
|
|
|
|
var janEntries = ReadVaultEntryTexts(janVaultPath, "vault-pass-123");
|
|
var febEntries = ReadVaultEntryTexts(febVaultPath, "vault-pass-123");
|
|
|
|
Assert(janEntries.Count == 1 && janEntries.ContainsKey("2026-01-31.md"), "January vault contents mismatch.");
|
|
Assert(febEntries.Count == 1 && febEntries.ContainsKey("2026-02-01.md"), "February vault contents mismatch.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultClearDataDirectoryAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-vault-smoke", Guid.NewGuid().ToString("N"));
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(dataDir);
|
|
Directory.CreateDirectory(Path.Combine(dataDir, "nested"));
|
|
|
|
try
|
|
{
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-02-01.md"), "decrypted content");
|
|
File.WriteAllText(Path.Combine(dataDir, "journal_cache.db"), "cache");
|
|
File.WriteAllText(Path.Combine(dataDir, "nested", "tmp.txt"), "temp");
|
|
|
|
IVaultStorageService storage = new VaultStorageService(new VaultCryptoService());
|
|
storage.ClearDataDirectory(dataDir);
|
|
|
|
Assert(Directory.Exists(dataDir), "Data directory should be recreated after cleanup.");
|
|
Assert(!Directory.EnumerateFileSystemEntries(dataDir).Any(), "Data directory should be empty after cleanup.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static async Task TestEntryVaultLoadAllEmptyAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-sidecar-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
|
|
try
|
|
{
|
|
var entry = NewEntry();
|
|
var request = JsonSerializer.Serialize(new
|
|
{
|
|
action = "vault.load_all",
|
|
payload = new
|
|
{
|
|
password = "vault-pass-123",
|
|
vaultDirectory = vaultDir,
|
|
dataDirectory = dataDir,
|
|
}
|
|
});
|
|
|
|
var response = await entry.HandleCommandAsync(request);
|
|
using var doc = JsonDocument.Parse(response);
|
|
|
|
Assert(doc.RootElement.GetProperty("ok").GetBoolean(), "Expected ok=true for empty vault directory load.");
|
|
Assert(doc.RootElement.GetProperty("data").GetBoolean(), "Expected vault.load_all data=true for empty vault directory.");
|
|
Assert(Directory.Exists(dataDir), "Expected data directory to be created by load workflow.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
}
|
|
|
|
static async Task TestEntryVaultClearDataDirectoryAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-sidecar-smoke", Guid.NewGuid().ToString("N"));
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(dataDir);
|
|
File.WriteAllText(Path.Combine(dataDir, "tmp.md"), "x");
|
|
|
|
try
|
|
{
|
|
var entry = NewEntry();
|
|
var request = JsonSerializer.Serialize(new
|
|
{
|
|
action = "vault.clear_data_directory",
|
|
payload = new
|
|
{
|
|
dataDirectory = dataDir,
|
|
}
|
|
});
|
|
|
|
var response = await entry.HandleCommandAsync(request);
|
|
using var doc = JsonDocument.Parse(response);
|
|
|
|
Assert(doc.RootElement.GetProperty("ok").GetBoolean(), "Expected ok=true for clear_data_directory.");
|
|
Assert(doc.RootElement.GetProperty("data").GetBoolean(), "Expected clear_data_directory result=true.");
|
|
Assert(Directory.Exists(dataDir), "Expected data directory to exist after clear.");
|
|
Assert(!Directory.EnumerateFileSystemEntries(dataDir).Any(), "Expected data directory to be empty after clear.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
}
|
|
|
|
static Task TestSidecarVaultCliLoadAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-sidecar-cli-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
|
|
try
|
|
{
|
|
var cli = new SidecarCli(new VaultStorageService(new VaultCryptoService()), new EntrySearchService(), new JournalConfigService());
|
|
var exitCode = cli.RunVaultCommand(["load", "--password", "vault-pass-123", "--vault-dir", vaultDir, "--data-dir", dataDir]);
|
|
|
|
Assert(exitCode == 0, "Expected vault load CLI command to succeed on empty vault directory.");
|
|
Assert(Directory.Exists(dataDir), "Expected data directory to be created by vault load CLI command.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestSidecarVaultCliSaveAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-sidecar-cli-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
Directory.CreateDirectory(dataDir);
|
|
|
|
try
|
|
{
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-02-22.md"), "entry body");
|
|
|
|
var cli = new SidecarCli(new VaultStorageService(new VaultCryptoService()), new EntrySearchService(), new JournalConfigService());
|
|
var exitCode = cli.RunVaultCommand(["save", "--password", "vault-pass-123", "--vault-dir", vaultDir, "--data-dir", dataDir]);
|
|
|
|
Assert(exitCode == 0, "Expected vault save CLI command to succeed.");
|
|
Assert(File.Exists(Path.Combine(vaultDir, "2026-02.vault")), "Expected monthly vault file to be written by save CLI command.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
static Task TestVaultCustomEntryRoundtripAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), "journal-vault-smoke", Guid.NewGuid().ToString("N"));
|
|
var vaultDir = Path.Combine(root, "vault");
|
|
var dataDir = Path.Combine(root, "data");
|
|
Directory.CreateDirectory(vaultDir);
|
|
Directory.CreateDirectory(dataDir);
|
|
|
|
try
|
|
{
|
|
// Create both date-named and custom-named entries
|
|
File.WriteAllText(Path.Combine(dataDir, "2026-02-01.md"), "date entry");
|
|
File.WriteAllText(Path.Combine(dataDir, "My Custom Entry.md"), "custom entry body");
|
|
File.WriteAllText(Path.Combine(dataDir, "Work Notes.md"), "work notes body");
|
|
|
|
// Rebuild vaults (simulates app close)
|
|
IVaultStorageService storage = new VaultStorageService(new VaultCryptoService());
|
|
storage.RebuildAllVaults("vault-pass-123", vaultDir, dataDir);
|
|
|
|
// Verify custom vault was created
|
|
var customVaultPath = Path.Combine(vaultDir, "_custom_entries.vault");
|
|
Assert(File.Exists(customVaultPath), "Expected _custom_entries.vault to be created.");
|
|
Assert(File.Exists(Path.Combine(vaultDir, "2026-02.vault")), "Expected monthly vault for date entry.");
|
|
|
|
// Clear data directory (simulates app close step 2)
|
|
storage.ClearDataDirectory(dataDir);
|
|
Assert(!Directory.EnumerateFileSystemEntries(dataDir).Any(), "Data directory should be empty after clear.");
|
|
|
|
// Load vaults (simulates app restart)
|
|
var ok = storage.LoadAllVaults("vault-pass-123", vaultDir, dataDir);
|
|
Assert(ok, "Expected vault load to succeed.");
|
|
|
|
// Verify all entries are restored
|
|
Assert(File.Exists(Path.Combine(dataDir, "2026-02-01.md")), "Date entry should be restored from vault.");
|
|
Assert(File.Exists(Path.Combine(dataDir, "My Custom Entry.md")), "Custom entry should be restored from vault.");
|
|
Assert(File.Exists(Path.Combine(dataDir, "Work Notes.md")), "Second custom entry should be restored from vault.");
|
|
Assert(File.ReadAllText(Path.Combine(dataDir, "My Custom Entry.md")) == "custom entry body", "Custom entry content mismatch.");
|
|
Assert(File.ReadAllText(Path.Combine(dataDir, "Work Notes.md")) == "work notes body", "Second custom entry content mismatch.");
|
|
}
|
|
finally
|
|
{
|
|
if (Directory.Exists(root))
|
|
Directory.Delete(root, recursive: true);
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
|