public void ReturnsTrueForARecordFieldArrayProperty()
{
var arrayProperty = typeof(TestDBCRecordWithArray).GetProperties()
.First(p => p.Name == nameof(TestDBCRecordWithArray.ArrayField));
Assert.True(DBCInspector.IsPropertyFieldArray(arrayProperty));
}
public void ReturnsFalseForMovedFieldButNotInTheSpecifiedVersion()
{
var movedProperty = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithSingleMovedField))
.First(p => p.Name == nameof(TestDBCRecordWithSingleMovedField.FieldC));
Assert.IsFalse(DBCInspector.HasPropertyMovedInVersion(WarcraftVersion.Classic, movedProperty));
}
public void ThrowsIfPropertyHasNotMoved()
{
var movedPropertyButNotInVersion = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithSingleMovedFieldMultipleVersions))
.First(p => p.Name == nameof(TestDBCRecordWithSingleMovedFieldMultipleVersions.FieldC));
Assert.Throws <ArgumentException>(() => DBCInspector.GetMostRecentPropertyMove(WarcraftVersion.Classic, movedPropertyButNotInVersion));
}
public void OnAPropertyThatIsNotAForeignKeyThrows()
{
var otherProperty = typeof(TestDBCRecord).GetProperties()
.First(p => p.Name == nameof(TestDBCRecord.TestSimpleField));
Assert.Throws <ArgumentException>(() => DBCInspector.GetForeignKeyInfo(otherProperty));
}
public void OnAPropertyWithoutTheForeignKeyInfoAttributeThrows()
{
var invalidForeignKeyProperty = typeof(TestDBCRecordInvalidForeignKeyField).GetProperties()
.First(p => p.Name == nameof(TestDBCRecordInvalidForeignKeyField.TestForeignKeyFieldMissingInfo));
Assert.Throws <InvalidDataException>(() => DBCInspector.GetForeignKeyInfo(invalidForeignKeyProperty));
}
public void ReturnsFalseForNotMovedField()
{
var notMovedProperty = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithSingleMovedField))
.First(p => p.Name == nameof(TestDBCRecordWithSingleMovedField.FieldA));
Assert.IsFalse(DBCInspector.HasPropertyMovedInVersion(WarcraftVersion.BurningCrusade, notMovedProperty));
}
public void AssignsCorrectChainsMultiVersion()
{
var orderer = new FieldOrderer
(
WarcraftVersion.Wrath,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.Wrath, typeof(TestDBCRecordWithMultipleMovedFields))
.ToList()
);
var propertyA = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithMultipleMovedFields))
.First(p => p.Name == nameof(TestDBCRecordWithMultipleMovedFields.FieldA));
var propertyC = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithMultipleMovedFields))
.First(p => p.Name == nameof(TestDBCRecordWithMultipleMovedFields.FieldC));
var propertyD = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithMultipleMovedFields))
.First(p => p.Name == nameof(TestDBCRecordWithMultipleMovedFields.FieldD));
var propertyE = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithMultipleMovedFields))
.First(p => p.Name == nameof(TestDBCRecordWithMultipleMovedFields.FieldE));
Assert.That(orderer.PrecedenceChains[propertyA].Select(p => p.Name), Is.EquivalentTo(MultiMoveBCDependencyChainFieldA));
Assert.That(orderer.PrecedenceChains[propertyC].Select(p => p.Name), Is.EquivalentTo(MultiMoveBCDependencyChainFieldC));
Assert.That(orderer.PrecedenceChains[propertyD].Select(p => p.Name), Is.EquivalentTo(MultiMoveWrathDependencyChainFieldD));
Assert.That(orderer.PrecedenceChains[propertyE].Select(p => p.Name), Is.EquivalentTo(MultiMoveBCDependencyChainFieldE));
}
public void ThrowsForAnUnmarkedProperty()
{
var simpleProperty = typeof(TestDBCRecordWithArray).GetProperties()
.First(p => p.Name == nameof(TestDBCRecordWithArray.SimpleField));
Assert.Throws <ArgumentException>(() => DBCInspector.GetVersionRelevantPropertyFieldArrayAttribute(WarcraftVersion.Classic, simpleProperty));
}
public void ReturnsFalseForAnUnmarkedProperty()
{
var arrayProperty = typeof(TestDBCRecord).GetProperties()
.First(p => p.Name == nameof(TestDBCRecord.TestNotRecordField));
Assert.False(DBCInspector.IsPropertyFieldArray(arrayProperty));
}
public void IncludesArrayFields()
{
var recordProperties = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithArray));
var recordPropertyNames = recordProperties.Select(p => p.Name);
Assert.That(recordPropertyNames, Is.EquivalentTo(TestRecordWithArrayPropertyNames));
}
public void IncludesArrayFieldsWhenMultipleVersionsArePresent()
{
var recordProperties = DBCInspector.GetVersionRelevantProperties(WarcraftVersion.Classic, typeof(TestDBCRecordWithVersionedArray));
var recordPropertyNames = recordProperties.Select(p => p.Name);
Assert.That(recordPropertyNames, Is.EquivalentTo(VersionedArrayRecordNames));
}
public void GetsAValidPropertySet()
{
var recordProperties = DBCInspector.GetRecordProperties(typeof(TestDBCRecord));
var recordPropertyNames = recordProperties.Select(p => p.Name);
Assert.That(recordPropertyNames, Is.EquivalentTo(TestRecordPropertyNames));
}
public void GetsAValidVersionedPropertySetForRemovedProperties()
{
var recordProperties = DBCInspector.GetVersionRelevantProperties(WarcraftVersion.Cataclysm, typeof(TestDBCRecord));
var recordPropertyNames = recordProperties.Select(p => p.Name);
Assert.That(recordPropertyNames, Is.EquivalentTo(TestRecordCataPropertyNames));
}
public void ReturnsCorrectSizeOnVersionedRecords()
{
long recordSizeClassic = DBCInspector.GetRecordSize(WarcraftVersion.Classic, typeof(TestDBCRecord));
long recordSizeWrath = DBCInspector.GetRecordSize(WarcraftVersion.Wrath, typeof(TestDBCRecord));
long recordSizeCata = DBCInspector.GetRecordSize(WarcraftVersion.Cataclysm, typeof(TestDBCRecord));
Assert.AreEqual(16, recordSizeClassic);
Assert.AreEqual(20, recordSizeWrath);
Assert.AreEqual(16, recordSizeCata);
}
public void OnAValidForeignKeyPropertyReturnsValidData()
{
var foreignKeyProperty = typeof(TestDBCRecord).GetProperties()
.First(p => p.Name == nameof(TestDBCRecord.TestForeignKeyField));
var foreignKeyInfo = DBCInspector.GetForeignKeyInfo(foreignKeyProperty);
Assert.AreEqual(DatabaseName.AnimationData, foreignKeyInfo.Database);
Assert.AreEqual(nameof(AnimationDataRecord.ID), foreignKeyInfo.Field);
}
public void ReturnsCorrectCountOnRecordsOnVersionedRecords()
{
long propCountClassic = DBCInspector.GetPropertyCount(WarcraftVersion.Classic, typeof(TestDBCRecord));
long propCountWrath = DBCInspector.GetPropertyCount(WarcraftVersion.Wrath, typeof(TestDBCRecord));
long propCountCata = DBCInspector.GetPropertyCount(WarcraftVersion.Cataclysm, typeof(TestDBCRecord));
Assert.AreEqual(4, propCountClassic);
Assert.AreEqual(5, propCountWrath);
Assert.AreEqual(4, propCountCata);
}
public void ReturnsCorrectPropertiesForSingleField()
{
var recordProperties = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithSingleMovedField)).ToList();
var movedPropertiesClassic = DBCInspector.GetMovedProperties(WarcraftVersion.Classic, recordProperties).Select(p => p.Key.Name);
var movedPropertiesBC = DBCInspector.GetMovedProperties(WarcraftVersion.BurningCrusade, recordProperties).Select(p => p.Key.Name);
Assert.That(movedPropertiesClassic, Is.Empty);
Assert.That(movedPropertiesBC, Is.EquivalentTo(SingleMovedFieldRecordNamesMovingFields));
}
public void ReturnsCorrectAttributeForSingleVersionMove()
{
var movedProperty = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithSingleMovedField))
.First(p => p.Name == nameof(TestDBCRecordWithSingleMovedField.FieldC));
var attribute = DBCInspector.GetMostRecentPropertyMove(WarcraftVersion.BurningCrusade, movedProperty);
Assert.AreEqual(WarcraftVersion.BurningCrusade, attribute.MovedIn);
Assert.AreEqual(nameof(DBCRecord.ID), attribute.ComesAfter);
}
public void DoesNotThrowWhenThereAreNoCyclicalDependencies()
{
var orderer = new FieldOrderer
(
WarcraftVersion.BurningCrusade,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.BurningCrusade, typeof(TestDBCRecordWithMultipleMovedFields))
.ToList()
);
Assert.DoesNotThrow(() => orderer.ReorderProperties());
}
public void ThrowsWhenThereAreCyclicalDependencies()
{
var orderer = new FieldOrderer
(
WarcraftVersion.BurningCrusade,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.BurningCrusade, typeof(TestDBCRecordWithInvalidReentrantMovedFields))
.ToList()
);
Assert.Throws <InvalidOperationException>(() => orderer.ReorderProperties());
}
public void ReturnsCorrectOrderForMultiMove()
{
var orderer = new FieldOrderer
(
WarcraftVersion.BurningCrusade,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.BurningCrusade, typeof(TestDBCRecordWithMultipleMovedFields))
.ToList()
);
Assert.That(orderer.ReorderProperties().Select(p => p.Name), Is.EquivalentTo(MultiMovedFieldsBCAfterMove));
}
public void ReturnsAValidAttributeForAMarkedProperty()
{
var arrayProperty = typeof(TestDBCRecordWithArray).GetProperties()
.First(p => p.Name == nameof(TestDBCRecordWithArray.ArrayField));
RecordFieldAttribute attribute = null;
Assert.DoesNotThrow(() => attribute = DBCInspector.GetVersionRelevantPropertyFieldArrayAttribute(WarcraftVersion.Classic, arrayProperty));
Assert.AreEqual(WarcraftVersion.Classic, attribute.IntroducedIn);
}
public void ReturnsTrueForForeignKeyPropertiesAndViceVersa()
{
var foreignKeyProperty = typeof(TestDBCRecord).GetProperties()
.First(p => p.Name == nameof(TestDBCRecord.TestForeignKeyField));
var otherProperty = typeof(TestDBCRecord).GetProperties()
.First(p => p.Name == nameof(TestDBCRecord.TestSimpleField));
Assert.True(DBCInspector.IsPropertyForeignKey(foreignKeyProperty));
Assert.False(DBCInspector.IsPropertyForeignKey(otherProperty));
}
public void AssignsMovingProperties()
{
var orderer = new FieldOrderer
(
WarcraftVersion.BurningCrusade,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.BurningCrusade, typeof(TestDBCRecordWithSingleMovedField))
.ToList()
);
var assignedPropertyNames = orderer.MovingProperties.Select(p => p.Key.Name);
Assert.That(assignedPropertyNames, Is.EquivalentTo(SingleMovedFieldRecordNamesMovingFields));
}
public void AssignsOriginalProperties()
{
var orderer = new FieldOrderer
(
WarcraftVersion.Classic,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.Classic, typeof(TestDBCRecordWithSingleMovedField))
.ToList()
);
var assignedPropertyNames = orderer.OriginalProperties.Select(p => p.Name);
Assert.That(assignedPropertyNames, Is.EquivalentTo(SingleMovedFieldNamesBeforeMove));
}
public void ReturnsFalseForNonMoved()
{
var orderer = new FieldOrderer
(
WarcraftVersion.BurningCrusade,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.BurningCrusade, typeof(TestDBCRecordWithInvalidReentrantMovedFields))
.ToList()
);
var propertyB = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithInvalidReentrantMovedFields))
.First(p => p.Name == nameof(TestDBCRecordWithInvalidReentrantMovedFields.FieldB));
Assert.IsFalse(orderer.HasCyclicMoveDependency(propertyB));
}
public void GetsCorrectChainForMultiVersionMove()
{
var orderer = new FieldOrderer
(
WarcraftVersion.Wrath,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.Wrath, typeof(TestDBCRecordWithMultipleMovedFields))
.ToList()
);
var movedProperty = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithMultipleMovedFields))
.First(p => p.Name == nameof(TestDBCRecordWithMultipleMovedFields.FieldD));
var moveAttribute = DBCInspector.GetMostRecentPropertyMove(WarcraftVersion.Wrath, movedProperty);
var chain = orderer.GetPrecendenceChain(moveAttribute, new List <PropertyInfo>()).Select(p => p.Name);
Assert.That(MultiVersionDependencyChainFieldE, Is.EquivalentTo(chain));
}
public void GetsCorrectChainForSimpleMove()
{
var orderer = new FieldOrderer
(
WarcraftVersion.BurningCrusade,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.BurningCrusade, typeof(TestDBCRecordWithSingleMovedField))
.ToList()
);
var movedProperty = DBCInspector.GetRecordProperties(typeof(TestDBCRecordWithSingleMovedField))
.First(p => p.Name == nameof(TestDBCRecordWithSingleMovedField.FieldC));
var moveAttribute = DBCInspector.GetMostRecentPropertyMove(WarcraftVersion.BurningCrusade, movedProperty);
var chain = orderer.GetPrecendenceChain(moveAttribute, new List <PropertyInfo>()).Select(p => p.Name);
Assert.That(SimpleMoveDependencyChainFieldC, Is.EquivalentTo(chain));
}
public void ReturnsCorrectAttributeForPropertyWithMultipleAttributes()
{
var arrayProperty = typeof(TestDBCRecordWithVersionedArray).GetProperties()
.First(p => p.Name == nameof(TestDBCRecordWithVersionedArray.VersionedArray));
var classicAttribute =
DBCInspector.GetVersionRelevantPropertyFieldArrayAttribute(WarcraftVersion.Classic, arrayProperty);
var wrathAttribute =
DBCInspector.GetVersionRelevantPropertyFieldArrayAttribute(WarcraftVersion.Wrath, arrayProperty);
var cataAttribute =
DBCInspector.GetVersionRelevantPropertyFieldArrayAttribute(WarcraftVersion.Cataclysm, arrayProperty);
Assert.AreEqual(2, classicAttribute.Count);
Assert.AreEqual(4, wrathAttribute.Count);
Assert.AreEqual(6, cataAttribute.Count);
}
public void ReturnsCorrectOrderForMultiVersionMove()
{
var ordererBC = new FieldOrderer
(
WarcraftVersion.BurningCrusade,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.BurningCrusade, typeof(TestDBCRecordWithSingleMovedFieldMultipleVersions))
.ToList()
);
var ordererWrath = new FieldOrderer
(
WarcraftVersion.Wrath,
DBCInspector.GetVersionRelevantProperties(WarcraftVersion.Wrath, typeof(TestDBCRecordWithSingleMovedFieldMultipleVersions))
.ToList()
);
Assert.That(ordererBC.ReorderProperties().Select(p => p.Name), Is.EquivalentTo(SingleMovedFieldBCAfterMove));
Assert.That(ordererWrath.ReorderProperties().Select(p => p.Name), Is.EquivalentTo(SingleMovedFieldWrathAfterMove));
}
