private void DeleteBinaryPropertyTest(string fileContent, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var testRoot = CreateTestRoot();
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(fileContent));
file.Save();
var fileId = file.Id;
file = Node.Load <File>(fileId);
// action
file.Binary = null;
file.Save();
// assert
var dbFiles = BlobStoragePlatform.LoadDbFiles(file.VersionId);
Assert.AreEqual(0, dbFiles.Length);
}
}
private DbFile UpdateByChunksTest(string initialContent, string updatedText, int sizeLimit, int chunkSize)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var testRoot = CreateTestRoot();
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(initialContent));
file.Save();
var fileId = file.Id;
var chunks = SplitFile(updatedText, chunkSize, out var fullSize);
file = Node.Load <File>(fileId);
file.Save(SavingMode.StartMultistepSave);
var token = BinaryData.StartChunk(fileId, fullSize);
var offset = 0;
foreach (var chunk in chunks)
{
BinaryData.WriteChunk(fileId, token, fullSize, chunk, offset);
offset += chunkSize;
}
BinaryData.CommitChunk(fileId, token, fullSize);
file = Node.Load <File>(fileId);
file.FinalizeContent();
// assert
var dbFiles = BlobStoragePlatform.LoadDbFiles(file.VersionId);
Assert.AreEqual(1, dbFiles.Length);
var dbFile = dbFiles[0];
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, updatedText, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFile.BlobProvider);
Assert.IsNotNull(dbFile.BlobProviderData);
}
else
{
Assert.IsNull(dbFile.BlobProvider);
Assert.IsNull(dbFile.BlobProviderData);
}
Assert.AreEqual(false, dbFile.IsDeleted);
Assert.AreEqual(false, dbFile.Staging);
Assert.AreEqual(0, dbFile.StagingVersionId);
Assert.AreEqual(0, dbFile.StagingPropertyTypeId);
Assert.AreEqual(fullSize, dbFile.Size);
return(dbFile);
}
}
private void DeleteTest(string fileContent, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var propertyTypeId = PropertyType.GetByName("Binary").Id;
var external = NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, fileContent, sizeLimit);
var testRoot = CreateTestRoot();
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(fileContent));
file.Save();
var fileId = file.Binary.FileId;
// memorize blob storage context for further check
var ctx = BlobStorage.GetBlobStorageContextAsync(file.Binary.FileId, false,
file.VersionId, propertyTypeId, CancellationToken.None).GetAwaiter().GetResult();
BlobStoragePlatform.UpdateFileCreationDate(file.Binary.FileId, DateTime.UtcNow.AddDays(-1));
// Action #1
file.ForceDelete();
// Assert #1
var dbFile = BlobStoragePlatform.LoadDbFile(fileId);
Assert.IsNotNull(dbFile);
Assert.AreEqual(false, dbFile.IsDeleted);
Assert.IsFalse(IsDeleted(ctx, external));
// Action #2
BlobStorage.CleanupFilesSetFlagAsync(CancellationToken.None)
.GetAwaiter().GetResult();
// Assert #2
dbFile = BlobStoragePlatform.LoadDbFile(fileId);
Assert.IsNotNull(dbFile);
Assert.AreEqual(true, dbFile.IsDeleted);
Assert.IsFalse(IsDeleted(ctx, external));
// Action #3
var _ = BlobStorage.CleanupFilesAsync(CancellationToken.None)
.GetAwaiter().GetResult();
// Assert #3
dbFile = BlobStoragePlatform.LoadDbFile(fileId);
Assert.IsNull(dbFile);
Assert.IsTrue(IsDeleted(ctx, external));
}
}
private void BinaryCacheEntityTest(string fileContent, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var testRoot = CreateTestRoot();
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(fileContent));
file.Save();
var versionId = file.VersionId;
var binaryPropertyId = file.Binary.Id;
var fileId = file.Binary.FileId;
var propertyTypeId = PropertyType.GetByName("Binary").Id;
// action
var binaryCacheEntity = BlobStorage.LoadBinaryCacheEntityAsync(
file.VersionId, propertyTypeId, CancellationToken.None).GetAwaiter().GetResult();
// assert
Assert.AreEqual(binaryPropertyId, binaryCacheEntity.BinaryPropertyId);
Assert.AreEqual(fileId, binaryCacheEntity.FileId);
Assert.AreEqual(fileContent.Length + 3, binaryCacheEntity.Length);
Assert.AreEqual(versionId, binaryCacheEntity.Context.VersionId);
Assert.AreEqual(propertyTypeId, binaryCacheEntity.Context.PropertyTypeId);
Assert.AreEqual(fileId, binaryCacheEntity.Context.FileId);
Assert.AreEqual(fileContent.Length + 3, binaryCacheEntity.Context.Length);
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, fileContent, sizeLimit))
{
Assert.IsTrue(binaryCacheEntity.Context.Provider.GetType() == BlobStoragePlatform.ExpectedExternalBlobProviderType);
Assert.IsTrue(binaryCacheEntity.Context.BlobProviderData.GetType() == BlobStoragePlatform.ExpectedBlobProviderDataType);
Assert.AreEqual(fileContent, GetStringFromBytes(BlobStoragePlatform.GetExternalData(binaryCacheEntity.Context)));
}
else
{
Assert.AreEqual(fileContent, GetStringFromBytes(binaryCacheEntity.RawData));
}
}
}
public void TestCase_DeletionPolicy_BackgroundImmediately()
{
IntegrationTest((sandbox) =>
{
var dp = DataStore.DataProvider;
var tdp = Providers.Instance.GetProvider <ITestingDataProvider>();
var countsBefore = GetDbObjectCountsAsync(null, dp, tdp).ConfigureAwait(false).GetAwaiter().GetResult();
using (BlobStoragePlatform.SwindleWaitingBetweenCleanupFiles(10))
{
using (new BlobDeletionPolicySwindler(BlobDeletionPolicy.BackgroundImmediately))
DeletionPolicy_TheTest();
var countsAfter = GetDbObjectCountsAsync(null, dp, tdp).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.AreEqual(countsBefore.AllCountsExceptFiles, countsAfter.AllCountsExceptFiles);
Assert.AreNotEqual(countsBefore.Files, countsAfter.Files);
Thread.Sleep(500);
countsAfter = GetDbObjectCountsAsync(null, dp, tdp).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.AreEqual(countsBefore.Files, countsAfter.Files);
}
});
}
private void AssertRawData(DbFile dbFile, bool useChunk, string expectedText)
{
byte[][] data = BlobStoragePlatform.GetRawData(dbFile.FileId);
if (dbFile.Size == 0L)
{
Assert.AreEqual(0, data.Length);
}
else if (useChunk && dbFile.BlobProvider == null)
{
Assert.AreEqual(1, data.Length);
}
else if (useChunk && dbFile.BlobProvider != null)
{
Assert.AreNotEqual(1, data.Length);
}
else
{
Assert.AreEqual(1, data.Length);
}
var length = data.Select(d => d.Length).Sum();
var buffer = new byte[length];
var offset = 0;
foreach (var item in data)
{
Array.Copy(item, 0, buffer, offset, item.Length);
offset += item.Length;
}
string actualText;
using (var stream = new IO.MemoryStream(buffer))
actualText = RepositoryTools.GetStreamString(stream);
Assert.AreEqual(expectedText, actualText);
}
private DbFile CreateFileTest(Node testRoot, string fileContent, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(fileContent));
// action
file.Save();
// assert
var dbFiles = BlobStoragePlatform.LoadDbFiles(file.VersionId);
Assert.AreEqual(1, dbFiles.Length);
var dbFile = dbFiles[0];
if (NeedExternal(BlobStoragePlatform.ExpectedExternalBlobProviderType, fileContent, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFile.BlobProvider);
Assert.IsNotNull(dbFile.BlobProviderData);
}
else
{
Assert.IsNull(dbFile.BlobProvider);
Assert.IsNull(dbFile.BlobProviderData);
}
Assert.AreEqual(false, dbFile.IsDeleted);
Assert.AreEqual(false, dbFile.Staging);
Assert.AreEqual(0, dbFile.StagingVersionId);
Assert.AreEqual(0, dbFile.StagingPropertyTypeId);
Assert.AreEqual(fileContent.Length + 3, dbFile.Size);
return(dbFile);
}
}
private bool IsDeleted(BlobStorageContext context, bool external)
{
return(external
? BlobStoragePlatform.GetExternalData(context) == null
: BlobStoragePlatform.LoadDbFile(context.FileId) == null);
}
private DbFile[] CopyFileRowTest(string initialContent, string updatedText, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var testRoot = CreateTestRoot();
var target = new SystemFolder(testRoot)
{
Name = "Target"
};
target.Save();
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(initialContent));
file.Save();
// action
file.CopyTo(target);
// assert
var copy = Node.Load <File>(RepositoryPath.Combine(target.Path, file.Name));
Assert.AreNotEqual(file.Id, copy.Id);
Assert.AreNotEqual(file.VersionId, copy.VersionId);
Assert.AreEqual(file.Binary.FileId, copy.Binary.FileId);
// action 2
copy.Binary.SetStream(RepositoryTools.GetStreamFromString(updatedText));
copy.Save();
// assert 2
Assert.AreNotEqual(file.Binary.FileId, copy.Binary.FileId);
var dbFiles = new DbFile[2];
var loadedDbFiles = BlobStoragePlatform.LoadDbFiles(file.VersionId);
Assert.AreEqual(1, loadedDbFiles.Length);
dbFiles[0] = loadedDbFiles[0];
loadedDbFiles = BlobStoragePlatform.LoadDbFiles(copy.VersionId);
Assert.AreEqual(1, loadedDbFiles.Length);
dbFiles[1] = loadedDbFiles[0];
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, initialContent, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFiles[0].BlobProvider);
Assert.IsNotNull(dbFiles[0].BlobProviderData);
}
else
{
Assert.IsNull(dbFiles[0].BlobProvider);
Assert.IsNull(dbFiles[0].BlobProviderData);
}
Assert.AreEqual(false, dbFiles[0].IsDeleted);
Assert.AreEqual(false, dbFiles[0].Staging);
Assert.AreEqual(0, dbFiles[0].StagingVersionId);
Assert.AreEqual(0, dbFiles[0].StagingPropertyTypeId);
Assert.AreEqual(initialContent.Length + 3, dbFiles[0].Size);
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, updatedText, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFiles[1].BlobProvider);
Assert.IsNotNull(dbFiles[1].BlobProviderData);
}
else
{
Assert.IsNull(dbFiles[1].BlobProvider);
Assert.IsNull(dbFiles[1].BlobProviderData);
}
Assert.AreEqual(false, dbFiles[1].IsDeleted);
Assert.AreEqual(false, dbFiles[1].Staging);
Assert.AreEqual(0, dbFiles[1].StagingVersionId);
Assert.AreEqual(0, dbFiles[1].StagingPropertyTypeId);
Assert.AreEqual(updatedText.Length + 3, dbFiles[1].Size);
return(dbFiles);
}
}
private DbFile UpdateFileTest(Node testRoot, string initialContent, string updatedContent, int sizeLimit)
{
using (new SystemAccount())
using (new SizeLimitSwindler(this, sizeLimit))
{
var file = new File(testRoot)
{
Name = "File1.file"
};
file.Binary.SetStream(RepositoryTools.GetStreamFromString(initialContent));
file.Save();
var fileId = file.Id;
var blobProviderBefore = file.Binary.BlobProvider;
var fileRowIdBefore = file.Binary.FileId;
file = Node.Load <File>(fileId);
file.Binary.SetStream(RepositoryTools.GetStreamFromString(updatedContent));
// action
file.Save();
// assert
var blobProviderAfter = file.Binary.BlobProvider;
var fileRowIdAfter = file.Binary.FileId;
// if blob provider before and after is built-in, the existing file row is updated, else re-created.
if (blobProviderAfter == null && blobProviderBefore == null)
{
Assert.AreEqual(fileRowIdBefore, fileRowIdAfter);
}
else
{
Assert.AreNotEqual(fileRowIdBefore, fileRowIdAfter);
}
var dbFiles = BlobStoragePlatform.LoadDbFiles(file.VersionId);
Assert.AreEqual(1, dbFiles.Length);
var dbFile = dbFiles[0];
//Assert.AreNotEqual(initialBlobId, file.Binary.FileId);
if (NeedExternal(BlobStoragePlatform.ExpectedBlobProviderDataType, updatedContent, sizeLimit))
{
Assert.AreEqual(BlobStoragePlatform.ExpectedExternalBlobProviderType.FullName, dbFile.BlobProvider);
Assert.IsNotNull(dbFile.BlobProviderData);
}
else
{
Assert.IsNull(dbFile.BlobProvider);
Assert.IsNull(dbFile.BlobProviderData);
}
Assert.AreEqual(false, dbFile.IsDeleted);
Assert.AreEqual(false, dbFile.Staging);
Assert.AreEqual(0, dbFile.StagingVersionId);
Assert.AreEqual(0, dbFile.StagingPropertyTypeId);
if (updatedContent.Length == 0)
{
Assert.AreEqual(0, dbFile.Size);
}
else
{
Assert.AreEqual(updatedContent.Length + 3, dbFile.Size);
}
return(dbFile);
}
}
