L'approche de tests par propriétés est une alternative aux techniques de tests basés sur des exemples. Cette approche est conçue pour tester les aspects d'une propriété qui doit toujours être vraie. Ceci permet de couvrir un grand éventail de valeurs d'entrées programmatiquement et de tester celles-ci en un seul test. Contrairement aux tests basés sur des exemples où l'on doit faire un test pour chaque exemple. Nous couvrirons les outils requis pour débuter à utiliser les tests par propriété. Nous construirons ensemble une suite de tests afin de démontrer la puissance de cette approche dans un cas réel.

1. Property-based
Testing

2. Having over 10 years of experience with
Microsoft Technologies, Miguel has many
specializations, including C#, F#, Azure, and
DevOps practices.
MSDEVMTL co-organizer
Director of engineering at Nexus Innovations
https://blog.miguelbernard.com
https://www.linkedin.com/in/miguelbernard/
@MiguelBernard88
https://github.com/mbernard

3. State of unit testing

4. // Given
var input = 3;
// When
var result =
Calculator.Calculate(input);
// Then
Assert.Equal(0, result);

5. // Given
var input = 3;
// When
var result =
Calculator.Calculate(input);
// Then
Assert.Equal(5, result);

6. // Given
var input = 3;
// When
var result =
Calculator.Calculate(input);
// Then
Assert.Equal(5, result);

7. // Given
var input = 3;
// When
var result =
Calculator.Calculate(input);
// Then
Assert.Equal(3, result);

15. How many
tests are
enough?

16. I thought I was happy…

17. Problems with example-based tests (EBT)
DON’T SCALE DON’T HELP YOU TO
FIND EDGE CASES
BRITTLE
DON’T EXPLAIN
WHAT WAS THE
REQUIREMENT
OFTEN SPECIFIC TO
AN
IMPLEMENTATION

18. What’s Property-based testing?

19. What it’s not
•
•
•
•
•
•
More like

20. Property

21. Property-based test
(PBT)

22. Example with
ADD()

23. Commutativity
2+3 = 3+2 2-3 != 3-2 2*3 = 3*2

24. Associativity
Add(input1, input2)
Add(input2, input3)
(2+3)+4 = 2+(3+4) (2-3)-4 != 2-(3-4) (2*3)*4 = 2*(3*4)

25. Identity
2+0 = 2 2-0 = 2 2*0 != 2

26. Recap

27. Haaaa, so properties
are for math stuff

28. Common patterns

29. Different paths,
same result

30. Full circle

31. Constance

32. Execute twice
gets same
result
(Idempotence)

33. Hard to find,
easy to validate

34. Oracle

35. PBTs advantages
General, and thus are less brittle
Provide a better and more concise description of requirements than a bunch of examples
1 PBT can replace many, many, example-based tests
Reveal overlooked edge cases
Force you to think
Ensure deep understanding of requirements
More thinking = less typing
Force you to have a clean design

36. Why don’t we use
PBTs already then?

37. no kidding it’s really hard
• EBTs are still good for a lot of things
• Test known corner cases
• Regression
• Easier to understand for newcomers

38. Demo

39. The Diamond Kata
Given a letter, print a diamond starting with ‘A’ with the
supplied letter at the widest point.

40. public class Diamond
{
public static IEnumerable<string> Generate(char c)
{
yield return "A";
}
}

41. First NuGet

42. 1. Non-Empty

43. [Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property NotEmpty(char c)
{
return Diamond.Generate(c)
.All(s => s != string.Empty)
.ToProperty();
}

44. public static class LetterGenerator
{
public static Arbitrary<char> Generate() =>
Arb.Default.Char().Filter(c => c >= 'A' && c <= 'Z');
}

45. 2. First line contains A
3. Last line contains A

46. [Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property FirstLineContainsA(char c)
{
return Diamond.Generate(c)
.First().Contains('A’)
.ToProperty();
}
[Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property LastLineContainsA(char c)
{
return Diamond.Generate(c)
.Last().Contains('A’)
.ToProperty();
}

47. 4. Height equals Width

48. [Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property DiamondWidthEqualsHeight(char c)
{
var diamond = Diamond.Generate(c).ToList();
return diamond.All(row => row.Length == diamond.Count)
.ToProperty();
}

49. 5. Outside space
padding is
symmetric on each
side of a row

50. [Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property SpacesPerRowAreSymmetric(char c)
{
return Diamond.Generate(c)
.All(row =>
CountLeadingSpaces(row) == CountTrailingSpaces(row))
.ToProperty();
}

51. 6. Symmetric
around horizontal
axis

52. [Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property SymmetricAroundHorizontalAxis(char c)
{
var diamond = Diamond.Generate(c).ToArray();
var half = diamond.Length / 2;
var topHalf = diamond[..half];
var bottomHalf = diamond[(half + 1)..];
return topHalf.Reverse()
.SequenceEqual(bottomHalf)
.ToProperty();
}

53. 7. Symmetric
around vertical axis

54. [Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property SymmetricAroundVerticalAxis(char c)
{
return Diamond.Generate(c).ToArray()
.All(row =>
{
var half = row.Length / 2;
var firstHalf = row[..half];
var secondHalf = row[(half + 1)..];
return firstHalf.Reverse().SequenceEqual(secondHalf);
}).ToProperty();
}

55. 8. Input letter row
contains no outside
padding spaces

56. [Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property InputLetterRowContainsNoOutsidePaddingSpaces
(char c)
{
var inputLetterRow = Diamond.Generate(c)
.ToArray()
.First(x => GetCharInRow(x) == c);
return (inputLetterRow[0] != ' ' && inputLetterRow[^1] != ' ')
.ToProperty();
}

57. First failure :’(

58. private static IEnumerable<string> Generate(char c)
{
yield return " A ";
yield return $"{c} {c}";
yield return " A ";
}

59. Works…. Most of the time

60. private static IEnumerable<string> Generate3(char c)
{
if (c == 'A')
{
yield return "A";
}
else
{
yield return " A ";
yield return $"{c} {c}";
yield return " A ";
}
}

61. Rock on!

62. 9. Rows contain
letters in ascending
then descending
order

63. [Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property RowsContainCorrectLetterInCorrectOrder
(char c)
{
var expected = new List<char>();
for (var i = 'A'; i < c; i++) expected.Add(i);
for (var i = c; i >= 'A'; i--) expected.Add(i);
var actual = Diamond.Generate(c).ToList()
.Select(GetCharInRow);
return actual.SequenceEqual(expected).ToProperty();
}

64. Recap
Few simple tests (10 tests, ~4-5 lines / test)
No need to change the tests when changing the implementation
Makes it easier to do TDD

65. Questions?

66. Resources
https://github.com/mbernard/property
-based-testing