private static void DeserializeTemplate(DataStorage dataStorage, ID templateId, string serializationFolderName)
{
var filePath = templateId.FindFilePath(serializationFolderName);
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
{
return;
}
var dsDbTemplate = new DsDbTemplate(templateId, serializationFolderName);
dataStorage.AddFakeItem(dsDbTemplate);
// Deserialize base templates
var baseTemplatesField = dsDbTemplate.Fields.FirstOrDefault(f => f.ID == FieldIDs.BaseTemplate);
if (baseTemplatesField == null || string.IsNullOrWhiteSpace(baseTemplatesField.Value))
{
return;
}
foreach (var baseTemplateId in baseTemplatesField.Value.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries)
.Where(ID.IsID)
.Select(ID.Parse)
.Where(baseTemplateId => dataStorage.GetFakeItem(baseTemplateId) == null))
{
DeserializeTemplate(dataStorage, baseTemplateId, dsDbTemplate.SerializationFolderName);
}
}
protected virtual void SetDataStorage(object obj, DataStorage dataStorage)
{
var rds = obj as IRequireDataStorage;
if (rds != null)
{
rds.SetDataStorage(dataStorage);
}
}
public AddDbItemArgs(DbItem item, DataStorage dataStorage)
{
Assert.ArgumentNotNull(item, "item");
Assert.ArgumentNotNull(dataStorage, "dataStorage");
this.item = item;
this.dataStorage = dataStorage;
}
public FakeDataProviderTest()
{
var database = Database.GetDatabase("master");
this.dataStorage = Substitute.For<DataStorage>(database);
this.dataProvider = new FakeDataProvider(this.dataStorage);
ReflectionUtil.CallMethod(database, "AddDataProvider", new object[] { this.dataProvider });
}
public DsItemLoadingArgs(IDsDbItem dsDbItem, DataStorage dataStorage)
{
Assert.ArgumentNotNull(dsDbItem, "dsDbItem");
Assert.ArgumentNotNull(dataStorage, "dataStorage");
this.dsDbItem = dsDbItem;
this.dataStorage = dataStorage;
}
protected CommandTestBase()
{
this.database = Database.GetDatabase("master");
this.dataStorage = Substitute.For<DataStorage>(this.database);
this.innerCommand = Substitute.For<DataEngineCommand>(this.dataStorage);
this.innerCommand.DataStorage.Returns(this.dataStorage);
}
public void DoExecuteThrowsNotSupportedException(Type command, DataStorage dataStorage)
{
var sut = ReflectionUtil.CreateObject(command, new object[] { dataStorage });
Action action = () => ReflectionUtil.CallMethod(sut, "CreateInstance");
action.ShouldThrow<TargetInvocationException>().WithInnerException<NotSupportedException>();
}
public DataStorageSwitcher(DataStorage objectToSwitchTo)
{
Assert.IsNotNull(objectToSwitchTo, "objectToSwitchTo");
this.databaseName = objectToSwitchTo.Database.Name;
Enter(this.databaseName, objectToSwitchTo);
}
public FakeDataProviderTest()
{
var database = Database.GetDatabase("master");
this.dataStorage = new DataStorage(database);
this.dataStorage.FakeItems.Clear();
this.dataProvider = new FakeDataProvider(this.dataStorage);
ReflectionUtil.CallMethod(database, "AddDataProvider", new object[] { this.dataProvider });
}
public ItemCreatorTest()
{
this.database = Database.GetDatabase("master");
this.dataStorage = Substitute.For<DataStorage>(this.database);
this.destination = ItemHelper.CreateInstance(this.database);
this.dataStorage.GetFakeItem(this.destination.ID).Returns(new DbItem("destination"));
this.dataStorage.GetFieldList(this.templateId, Arg.Any<string>()).Returns(new FieldList());
this.itemCreator = new ItemCreator(this.dataStorage);
}
/// <summary>
/// Initializes a new instance of the <see cref="Db"/> class with the specified database.
/// </summary>
/// <param name="databaseName">The database name.</param>
public Db(string databaseName)
{
Assert.ArgumentNotNullOrEmpty(databaseName, "databaseName");
this.database = Database.GetDatabase(databaseName);
this.dataStorage = new DataStorage(this.database);
this.dataStorageSwitcher = new DataStorageSwitcher(this.dataStorage);
this.databaseSwitcher = new DatabaseSwitcher(this.database);
var args = new InitDbArgs(this.database, this.dataStorage);
CorePipeline.Run("initFakeDb", args);
}
public Db(string databaseName)
{
this.database = Database.GetDatabase(databaseName);
this.dataStorage = new DataStorage(this.database);
var config = Factory.GetConfiguration();
this.configuration = new DbConfiguration(config);
this.pipelineWatcher = new PipelineWatcher(config);
var args = new InitDbArgs(this.database, this.dataStorage);
CorePipeline.Run("initFakeDb", args);
}
protected virtual void SetDataStorage(object obj, DataStorage dataStorage)
{
var rds = obj as IRequireDataStorage;
if (rds != null)
{
rds.SetDataStorage(dataStorage);
}
else
{
// we should know if it happens
throw new System.Exception(obj.GetType().FullName);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Db"/> class with the specified database.
/// </summary>
/// <param name="databaseName">The database name.</param>
public Db(string databaseName)
{
Assert.ArgumentNotNullOrEmpty(databaseName, "databaseName");
this.database = Database.GetDatabase(databaseName);
this.dataStorage = new DataStorage(this.database);
this.dataStorageSwitcher = new DataStorageSwitcher(this.dataStorage);
this.databaseSwitcher = new DatabaseSwitcher(this.database);
this.databaseLanguages = new Stack<Switcher<DbLanguages>>();
this.databaseLanguages.Push(
new Switcher<DbLanguages>(
new DbLanguages(Language.Parse("en"))));
var args = new InitDbArgs(this.database, this.dataStorage);
CorePipeline.Run("initFakeDb", args);
}
protected virtual bool ResolveTemplate(DbItem item, DataStorage dataStorage)
{
if (item.TemplateID == TemplateIDs.Template)
{
return true;
}
if (item.TemplateID == TemplateIDs.BranchTemplate)
{
return true;
}
if (this.ResolveBranch(item, dataStorage))
{
return true;
}
if (dataStorage.GetFakeTemplate(item.TemplateID) != null)
{
return true;
}
if (!ID.IsNullOrEmpty(item.TemplateID))
{
return false;
}
var fingerprint = string.Concat(item.Fields.Select(f => f.Name));
// find an item with a generated template that has a matching fields set
var sourceItem = dataStorage.GetFakeItems()
.Where(si => si.TemplateID != TemplateIDs.Template)
.Where(si => dataStorage.GetFakeTemplate(si.TemplateID) != null)
.Where(si => dataStorage.GetFakeTemplate(si.TemplateID).Generated)
.FirstOrDefault(si => string.Concat(si.Fields.Select(f => f.Name)) == fingerprint);
if (sourceItem == null)
{
return false;
}
// reuse the template
item.TemplateID = sourceItem.TemplateID;
return true;
}
public AddDbItemArgs(DbItem item, DataStorage dataStorage) : this(item, dataStorage, Language.Current)
{
}
public DataStorageTest()
{
this.dataStorage = new DataStorage(Database.GetDatabase("master"));
}
public ItemCreator(DataStorage dataStorage)
{
this.dataStorage = dataStorage;
}
public void SetDataStorage(DataStorage dataStorage)
{
Assert.ArgumentNotNull(dataStorage, "dataStorage");
this.DataStorage = dataStorage;
}
public InitDataEngineCommandsTest()
{
this.database = Database.GetDatabase("master");
this.dataStorage = Substitute.For<DataStorage>(this.database);
}
public void ShouldSetDataStorage()
{
// arrange
var ds = new DataStorage(Database.GetDatabase("master"));
// act
this.dataProvider.SetDataStorage(ds);
// assert
this.dataProvider.DataStorage.Should().Be(ds);
}
internal FakeDataProvider(DataStorage dataStorage)
: this()
{
this.dataStorage.Value = dataStorage;
}
void IRequireDataStorage.SetDataStorage(DataStorage dataStorage)
{
Assert.ArgumentNotNull(dataStorage, "storage");
this.storage = dataStorage;
}
public CreateTemplateTest()
{
this.dataStorage = Substitute.For<DataStorage>(Database.GetDatabase("master"));
this.processor = new CreateTemplate();
}
public virtual void SetDataStorage(DataStorage dataStorage)
{
this.dataStorage.Value = dataStorage;
}
internal FakeDataProvider(DataStorage dataStorage)
{
this.dataStorage = dataStorage;
}
public FakeDataProvider(DataStorage dataStorage)
{
this.dataStorage = dataStorage;
}
public void SetDataStorage(DataStorage dataStorage)
{
this.dataStorage = dataStorage;
}
public InitDbArgs(Database database, DataStorage dataStorage)
{
this.Database = database;
this.DataStorage = dataStorage;
}
protected virtual bool ResolveBranch(DbItem item, DataStorage dataStorage)
{
if (item.ParentID == ItemIDs.BranchesRoot && ID.IsNullOrEmpty(item.TemplateID))
{
item.TemplateID = TemplateIDs.BranchTemplate;
return true;
}
if (ID.IsNullOrEmpty(item.TemplateID))
{
return false;
}
var branchItem = dataStorage.GetFakeItem(item.TemplateID);
if (branchItem == null)
{
return false;
}
if (branchItem.TemplateID != TemplateIDs.BranchTemplate)
{
return false;
}
item.BranchId = branchItem.ID;
item.TemplateID = ID.NewID;
return false;
}
