wismna/modernkeepass
1
0
Fork 0
mirror of https://github.com/wismna/ModernKeePass.git synced 2025-10-03 15:40:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

Create DB works correctly

Browse Source 
Sample data moved to application
Tests updated (still not working - splat)
WIP
This commit is contained in:
Geoffroy BONNEVILLE
2020-04-07 17:29:03 +02:00
parent 1fa799bdf8
commit 4863eb9fae
20 changed files with 205 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
ModernKeePass.KeePassDatabaseTests/AutomapperProfilesTest.cs
View File

@@ -33,8 +33,13 @@ namespace ModernKeePass.KeePassDatabaseTests
var pwEntry = new PwEntry(true, true)
{
ExpiryTime = DateTime.Now,
BackgroundColor = Color.White,
ForegroundColor = Color.Black
ParentGroup =
{
Uuid = new PwUuid(true),
Name = "Parent Group"
}
//BackgroundColor = Color.White,
//ForegroundColor = Color.Black
};
pwEntry.Strings.Set(PwDefs.TitleField, new ProtectedString(true, "Test"));
pwEntry.Strings.Set(PwDefs.UserNameField, new ProtectedString(true, "toto"));
@@ -46,8 +51,11 @@ namespace ModernKeePass.KeePassDatabaseTests
var entry = _mapper.Map<PwEntry, EntryEntity>(pwEntry);
Assert.That(entry.ExpirationDate, Is.Not.EqualTo(default(DateTimeOffset)));
Assert.That(entry.BackgroundColor, Is.EqualTo(Color.White));
Assert.That(entry.ForegroundColor, Is.EqualTo(Color.Black));
//Assert.That(entry.BackgroundColor, Is.EqualTo(Color.White));
//Assert.That(entry.ForegroundColor, Is.EqualTo(Color.Black));
Assert.That(entry.ParentId, Is.Not.EqualTo(PwUuid.Zero.ToHexString()));
Assert.That(entry.ParentName, Is.EqualTo("Parent Group"));
Assert.That(entry.UserName, Is.EqualTo("toto"));
Assert.That(entry.Name, Is.EqualTo("Test"));
Assert.That(entry.UserName, Is.EqualTo("toto"));
Assert.That(entry.Password, Is.EqualTo("password"));
@@ -69,8 +77,8 @@ namespace ModernKeePass.KeePassDatabaseTests
Url = new Uri("http://google.com"),
Notes = "blabla",
ExpirationDate = DateTimeOffset.Now,
BackgroundColor = Color.White,
ForegroundColor = Color.Black,
//BackgroundColor = Color.White,
//ForegroundColor = Color.Black,
AdditionalFields = new Dictionary<string, string> {
{
"additional", "custom"
@@ -82,8 +90,8 @@ namespace ModernKeePass.KeePassDatabaseTests
_mapper.Map(entry, pwEntry);
Assert.That(pwEntry.ExpiryTime, Is.Not.EqualTo(default(DateTime)));
Assert.That(pwEntry.BackgroundColor, Is.EqualTo(Color.White));
Assert.That(pwEntry.ForegroundColor, Is.EqualTo(Color.Black));
//Assert.That(pwEntry.BackgroundColor, Is.EqualTo(Color.White));
//Assert.That(pwEntry.ForegroundColor, Is.EqualTo(Color.Black));
Assert.That(pwEntry.Strings.GetSafe(PwDefs.TitleField).ReadString(), Is.EqualTo("Test"));
Assert.That(pwEntry.Strings.GetSafe(PwDefs.UserNameField).ReadString(), Is.EqualTo("toto"));
Assert.That(pwEntry.Strings.GetSafe(PwDefs.PasswordField).ReadString(), Is.EqualTo("password"));

102
ModernKeePass.KeePassDatabaseTests/KeePassDatabaseClientTests.cs
View File

@@ -9,7 +9,6 @@ using ModernKeePass.Domain.Interfaces;
using ModernKeePass.Infrastructure.KeePass;
using NSubstitute;
using NUnit.Framework;
using FileInfo = ModernKeePass.Domain.Dtos.FileInfo;
namespace ModernKeePass.KeePassDatabaseTests
{
@@ -17,106 +16,99 @@ namespace ModernKeePass.KeePassDatabaseTests
public class DatabaseTests
{
private IDatabaseProxy _database;
private FileInfo _fileInfo;
private IFileProxy _fileProxy;
private readonly Credentials _credentials = new Credentials
{
Password = "test"
};
[SetUp]
public void SetUp()
{
var dateTime = Substitute.For<IDateTime>();
var fileProxy = Substitute.For<IFileProxy>();
fileProxy.OpenBinaryFile(Arg.Any<string>()).Returns(async parameters =>
_fileProxy = Substitute.For<IFileProxy>();
_fileProxy.OpenBinaryFile(Arg.Any<string>()).Returns(async parameters =>
{
await using var stream = File.Open((string) parameters[0], FileMode.OpenOrCreate);
var contents = new byte[stream.Length];
await stream.ReadAsync(contents, 0, (int) stream.Length);
return contents;
});
fileProxy.WriteBinaryContentsToFile(Arg.Any<string>(), Arg.Any<byte[]>()).Returns(async parameters =>
_fileProxy.WriteBinaryContentsToFile(Arg.Any<string>(), Arg.Any<byte[]>()).Returns(async parameters =>
{
await using var stream = File.Open((string)parameters[0], FileMode.OpenOrCreate);
var contents = (byte[]) parameters[1];
await stream.WriteAsync(contents, 0, contents.Length);
});
var mapper = new Mapper(new MapperConfiguration(cfg => { cfg.AddProfile(typeof(EntryMappingProfile)); }));
_database = new KeePassDatabaseClient(fileProxy, mapper, dateTime);
_database = new KeePassDatabaseClient(mapper, dateTime);
}
[TearDown]
public void TearDown()
{
_database.CloseDatabase();
if (!string.IsNullOrEmpty(_fileInfo?.Path)) File.Delete(_fileInfo.Path);
//if (!string.IsNullOrEmpty(_fileInfo?.Path)) File.Delete(_fileInfo.Path);
}
[Test]
public async Task TestOpen()
{
var fileInfo = new FileInfo
{
Path = Path.Combine(Directory.GetCurrentDirectory(), "Data", "TestDatabase.kdbx")
};
var file = await _fileProxy.OpenBinaryFile(Path.Combine(Directory.GetCurrentDirectory(), "Data", "TestDatabase.kdbx"));
var rootGroup = await _database.Open(fileInfo, _credentials);
Assert.That(rootGroup.Name, Is.EqualTo("TestDatabase"));
Assert.That(rootGroup.Entries.Count(), Is.EqualTo(2));
await _database.Open(file, _credentials);
var rootGroup = _database.GetGroup(_database.RootGroupId);
Assert.That(_database.Name, Is.EqualTo("TestDatabase"));
Assert.That(rootGroup.Entries.Count, Is.EqualTo(2));
}
[Test]
public async Task TestCreateAndSave()
{
_fileInfo = new FileInfo
{
Path = Path.Combine(Path.GetTempPath(), "NewDatabase.kdbx")
};
var path = Path.Combine(Path.GetTempPath(), "NewDatabase.kdbx");
var newFile = await _fileProxy.OpenBinaryFile(path);
await _database.Create(_fileInfo, _credentials);
await _database.SaveDatabase();
await _database.Create(newFile, _credentials);
var result = await _database.SaveDatabase();
await _fileProxy.WriteBinaryContentsToFile(path, result);
_database.CloseDatabase();
Assert.DoesNotThrowAsync(async () => { await _database.Open(_fileInfo, _credentials); });
Assert.DoesNotThrowAsync(async () => { await _database.Open(newFile, _credentials); });
}
[Test]
public async Task TestSaveAs()
{
var originalFileInfo = new FileInfo
{
Path = Path.Combine(Directory.GetCurrentDirectory(), "Data", "TestDatabase.kdbx")
};
_fileInfo = new FileInfo
{
Path = Path.Combine(Path.GetTempPath(), "SavedDatabase.kdbx")
};
var currentPath = Path.Combine(Path.GetTempPath(), "SavedDatabase.kdbx");
var originalFile = await _fileProxy.OpenBinaryFile(Path.Combine(Directory.GetCurrentDirectory(), "Data", "TestDatabase.kdbx"));
var currentFile = await _fileProxy.OpenBinaryFile(currentPath);
await _database.Open(originalFile, _credentials);
await _database.Open(originalFileInfo, _credentials);
await _database.SaveDatabase(_fileInfo.Path);
var result = await _database.SaveDatabase(currentFile);
await _fileProxy.WriteBinaryContentsToFile(currentPath, result);
_database.CloseDatabase();
Assert.DoesNotThrowAsync(async () => { await _database.Open(_fileInfo, _credentials); });
Assert.DoesNotThrowAsync(async () => { await _database.Open(currentFile, _credentials); });
}
[Test]
public async Task TestAddGroup()
{
var originalFileInfo = new FileInfo
{
Path = Path.Combine(Directory.GetCurrentDirectory(), "Data", "TestDatabase.kdbx")
};
_fileInfo = new FileInfo
{
Path = Path.Combine(Path.GetTempPath(), "SavedDatabase.kdbx")
};
var currentPath = Path.Combine(Path.GetTempPath(), "SavedDatabase.kdbx");
var originalFile = await _fileProxy.OpenBinaryFile(Path.Combine(Directory.GetCurrentDirectory(), "Data", "TestDatabase.kdbx"));
var currentFile = await _fileProxy.OpenBinaryFile(currentPath);
var newGroup = new GroupEntity {Name = "New Group Test"};
await _database.Open(originalFile, _credentials);
var rootGroup = await _database.Open(originalFileInfo, _credentials);
await _database.AddGroup(rootGroup.Id, newGroup.Id);
await _database.SaveDatabase(_fileInfo.Path);
await _database.AddGroup(_database.RootGroupId, newGroup.Id);
var result = await _database.SaveDatabase(currentFile);
await _fileProxy.WriteBinaryContentsToFile(currentPath, result);
_database.CloseDatabase();
rootGroup = await _database.Open(_fileInfo, _credentials);
await _database.Open(currentFile, _credentials);
var rootGroup = _database.GetGroup(_database.RootGroupId);
Assert.That(newGroup.Id, Is.Not.Empty);
Assert.That(rootGroup.SubGroups.Count, Is.EqualTo(7));
@@ -126,24 +118,22 @@ namespace ModernKeePass.KeePassDatabaseTests
[Test]
public async Task TestAddEntry()
{
var originalFileInfo = new FileInfo
{
Path = Path.Combine(Directory.GetCurrentDirectory(), "Data", "TestDatabase.kdbx")
};
_fileInfo = new FileInfo
{
Path = Path.Combine(Path.GetTempPath(), "SavedDatabase.kdbx")
};
var currentPath = Path.Combine(Path.GetTempPath(), "SavedDatabase.kdbx");
var newEntry = new EntryEntity
{
Name = "New Entry Test"
};
var originalFile = await _fileProxy.OpenBinaryFile(Path.Combine(Directory.GetCurrentDirectory(), "Data", "TestDatabase.kdbx"));
var currentFile = await _fileProxy.OpenBinaryFile(currentPath);
await _database.Open(originalFile, _credentials);
var rootGroup = await _database.Open(originalFileInfo, _credentials);
await _database.AddEntry(rootGroup.Id, newEntry.Id);
await _database.SaveDatabase(_fileInfo.Path);
await _database.AddEntry(_database.RootGroupId, newEntry.Id);
var result = await _database.SaveDatabase(currentFile);
await _fileProxy.WriteBinaryContentsToFile(currentPath, result);
_database.CloseDatabase();
rootGroup = await _database.Open(_fileInfo, _credentials);
await _database.Open(currentFile, _credentials);
var rootGroup = _database.GetGroup(_database.RootGroupId);
Assert.That(newEntry.Id, Is.Not.Empty);
Assert.That(rootGroup.Entries.Count, Is.EqualTo(3));