public void CanSyncSubA_ModifyTest()
{
this.Execute("/sub/a", async() =>
{
var driveItem = Utils.DriveItemPool["/sub/a1"].MemberwiseClone();
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("New content.")))
{
driveItem.Content = stream;
driveItem.FileSystemInfo.LastModifiedDateTime = DateTime.UtcNow;
/* modify file */
_logger.LogInformation("TEST: Modify file.");
await _driveHive.LocalDrive.CreateOrUpdateAsync(driveItem);
}
},
() =>
{
var hashAlgorithm = new QuickXorHash();
Assert.True(File.Exists("/sub/a".ToAbsolutePath(_driveHive.LocalDrivePath)), "File does not exist.");
Assert.True(File.Exists("/sub/a".ToAbsolutePath(_driveHive.RemoteDrivePath)), "File does not exist.");
using (var stream = File.OpenRead("/sub/a".ToAbsolutePath(_driveHive.RemoteDrivePath)))
{
var actual = Convert.ToBase64String(hashAlgorithm.ComputeHash(stream));
var expected = Convert.ToBase64String(hashAlgorithm.ComputeHash(Encoding.UTF8.GetBytes("New content.")));
Assert.True(actual == expected, "The hashes are not equal.");
}
}, syncId: 2);
}
private static DriveItem CreateDriveItem(string itemPath, int version)
{
var name = Path.GetFileName(itemPath);
var folderPath = $"{Path.GetDirectoryName(itemPath)}".NormalizeSlashes();
var hashAlgorithm = new QuickXorHash();
var lastModified = new DateTime(2019, 01, 01, version, 00, 00, DateTimeKind.Utc);
var content = $"{itemPath} v{version}".ToMemorySteam();
var hash = Convert.ToBase64String(hashAlgorithm.ComputeHash(content));
return(new DriveItem
{
File = new Microsoft.Graph.File()
{
Hashes = new Hashes()
{
QuickXorHash = hash
}
},
Name = name,
Content = content,
FileSystemInfo = new Microsoft.Graph.FileSystemInfo {
LastModifiedDateTime = lastModified
},
ParentReference = new ItemReference()
{
Path = $"{CryptoDriveConstants.PathPrefix}{folderPath}"
}
});
}
public static void CompareFiles(string fileName, string versionName, string basePath)
{
var hashAlgorithm = new QuickXorHash();
using (var stream = File.OpenRead(fileName.ToAbsolutePath(basePath)))
{
var actual = Convert.ToBase64String(hashAlgorithm.ComputeHash(stream));
var expected = Utils.DriveItemPool[versionName].QuickXorHash();
Assert.True(actual == expected, "The hashes are not equal.");
}
}
public void CanSyncDTest()
{
this.Execute("/d", () =>
{
var hashAlgorithm = new QuickXorHash();
Assert.True(File.Exists("/d".ToAbsolutePath(_driveHive.LocalDrivePath)), "File does not exist.");
Assert.True(File.Exists("/d".ToAbsolutePath(_driveHive.RemoteDrivePath)), "File does not exist.");
using (var stream = File.OpenRead("/d".ToAbsolutePath(_driveHive.LocalDrivePath)))
{
Assert.True(Convert.ToBase64String(hashAlgorithm.ComputeHash(stream)) == Utils.DriveItemPool["/d1"].QuickXorHash());
}
});
}
public bool Equals(DriveFile other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Id.Equals(other.Id, StringComparison.InvariantCultureIgnoreCase) &&
Name.Equals(other.Name, StringComparison.InvariantCultureIgnoreCase) &&
FullName.Equals(other.FullName, StringComparison.InvariantCultureIgnoreCase) &&
QuickXorHash.Equals(other.QuickXorHash, StringComparison.InvariantCultureIgnoreCase) &&
SizeInBytes == other.SizeInBytes);
}
public async Task ExecuteAsync(DriveFile driveFile)
{
string localFullName = Path.Combine(_configuration["LocalRoot"], driveFile.FullName);
FileInfo file = new FileInfo(localFullName);
if (file.Exists && file.Length == driveFile.SizeInBytes)
{
byte[] quickXorHashBytes;
await using (FileStream inputStream = new FileStream(file.FullName, FileMode.Open))
{
using HashAlgorithm algorithm = new QuickXorHash();
quickXorHashBytes = CalculateHash(inputStream, algorithm);
}
string quickXorHash = Convert.ToBase64String(quickXorHashBytes);
if (quickXorHash.Equals(driveFile.QuickXorHash, StringComparison.InvariantCultureIgnoreCase))
{
file.Delete();
}
}
}
