On m'a demandé d'aider à coder un certain nombre de tests d'unité MS pour un certain nombre de mappages d'objet à objet. Quelqu'un peut-il conseiller quel niveau de test est approprié pour tester la fonctionnalité de cartographie?Test de l'objet sur les mappages d'objet
Ci-dessous figure un exemple de code (non production).
public class Foo
{
public enum FooType
{
Active, Deleted, Open, Closed
}
public bool IsConditionMet { get; set; }
public FooType SimpleType { get; set; }
}
public class Bar
{
public string SomeCondition { get; set; }
public string SomeAbbreviatedType { get; set; }
}
public static class BarMapper
{
// sample to mapping code
public static Foo Map(Bar bar)
{
var foo = new Foo
{
IsConditionMet = bar.SomeCondition.Equals("y", StringComparison.OrdinalIgnoreCase)
};
// this is sample code and not used in production
switch (bar.SomeAbbreviatedType)
{
case "A":
foo.SimpleType = Foo.FooType.Active;
break;
case "D":
foo.SimpleType = Foo.FooType.Deleted;
break;
case "O":
foo.SimpleType = Foo.FooType.Open;
break;
case "C":
foo.SimpleType = Foo.FooType.Closed;
break;
}
return foo;
}
}
Je ne suis pas à la recherche d'une définition d'un test unitaire, la façon d'écrire un ou une explication sur TDD, mais en particulier la recherche d'un exemple de ce que l'unité des tests que vous écririez donné l'exemple ci-dessus.
Remarque: Malheureusement, en raison de la nature des données sources, l'utilisation d'un framework de cartographie tel que AutoMapper n'ajoutera aucune valeur au projet.
Mise à jour: Ceci est mon exemple sur le niveau de test approprié.
[TestMethod]
public void IsMappingToIsConditionMetCorrect()
{
var fooIsConditionMetShouldBeTrue = BarMapper.Map(new Bar { SomeCondition = "Y" });
var fooIsConditionMetShouldBeFalse = BarMapper.Map(new Bar { SomeCondition = "N" });
var fooIsConditionMetShouldBeFalse_BecauseSomeConditionIsInvalid = BarMapper.Map(new Bar { SomeCondition = "SOMETHING" });
Assert.IsTrue(fooIsConditionMetShouldBeTrue);
Assert.IsFalse(fooIsConditionMetShouldBeFalse);
Assert.IsFalse(fooIsConditionMetShouldBeFalse_BecauseSomeConditionIsInvalid);
}
[TestMethod]
public void TestsCanBuild()
{
var fooAbbreviatedTypeShouldBeA = BarMapper.Map(new Bar { SomeAbbreviatedType = "A" });
var fooAbbreviatedTypeShouldBeD = BarMapper.Map(new Bar { SomeAbbreviatedType = "D" });
var fooAbbreviatedTypeShouldBeO = BarMapper.Map(new Bar { SomeAbbreviatedType = "O" });
var fooAbbreviatedTypeShouldBeC = BarMapper.Map(new Bar { SomeAbbreviatedType = "C" });
Assert.AreSame(Foo.FooType.Active, fooAbbreviatedTypeShouldBeA);
Assert.AreSame(Foo.FooType.Deleted, fooAbbreviatedTypeShouldBeD);
Assert.AreSame(Foo.FooType.Open, fooAbbreviatedTypeShouldBeO);
Assert.AreSame(Foo.FooType.Closed, fooAbbreviatedTypeShouldBeC);
// TODO: test for an incorrect "SomeAbbreviatedType" property value
}
Merci d'avoir confirmé mon approche – Kane