Any time ago I came across a tweet that has become familiar to use a new test framework opensorsny Fixie and very pleased with it. So, I steady decided to fix all the tests in my task for a other engine. After this, I just could not stand aside and not even out await at what sort of animal it was and why it so pleased others.

Next, I want to cave in you an overview of the framework, its capabilities, and to understand whether this is a new tidings in testing, IT is deserving taking a closer look at it or you fundament pass by and forget.

American Samoa said on the internet site itself, Fixie - Ceremonious Examination for .NET. Those. testing by agreement. Agreements here mean what we are generally habitual to - all trading operations are performed on the basis of an "viva" agreement, a gentleman's denotative convention. The closest example is scaffolding. This is when we agreed, for example, that test classes curb the word Try out, or that test classes should equal exoteric and not return anything. Then much classes wish be constituted as test classes. And no attributes and all that jazz. Just classes and methods.

At first sight, all this looks good and true pleases. Information technology turns out that it is exclusive necessary to correctly name methods and classes and on that point will be happiness. Concurrently, you can train the team to call the tryout classes as they should, rather than an arbitrary combination of words, in some manner related to the topic of the tested form.

Installation and first test

By default, Fixie is configured so that test classes are everything that ends in Tests . Test methods - everything that is inside these classes does not return a value. Those. on paper and, in fact, in practice, this code will already equal recognized as a trial:

          public class SuperHeroTests {     public void NameShouldBeFilled() {         volt-ampere superHero = new SuperHero();         superHero.Name                  .Should()                  .NotBeEmpty();     } }

Before moving on, it is Worth expression few language about the installation, and what is necessary for Fixie to act. The nuget command to install the framework itself. But this does not end there. The framework does not provide a constitutional way for penning data checks in a test. To use them, you need to use one of the third-political party solutions:

Fluentassertions
Should
Shouldly
Something other from this subject.

It is still installed using NuGet. In the example above, the FluentAssertion package was used, since I in person like information technology more and there is essentially no big difference compared to other options.

That's all, and you can happily and cheerfully write code. If you ingest simply started your journey in development and testing in particular. If you are an toughened person, then umpteen questions arise, how this thing is set functioning and how convenient it is to operate tests.

Integration

Speaking of running tests. The author honestly admits that he needed to run tests from the console and therefore he did the integration with the studio last. There is a plugin for ReSharper, but it is for versions from 8.1 to 8.3, i.e. with the new version you are a proletarian. For the sake of tests, I did not want to roll back to version 8, so I can't say how comfortable IT is.

Integration with the studio apartment is carried away at the spirit level of detecting tests and running them. Those. there will be no highlighting in the editor. Means special test icons. Here, in my belief, lies the potential place of error

. Lambs. It's not so problematic to stamp up in the word "Tests", which testament contribute to skipping tests. Visually, they do not excel. In fairness, I moldiness say that such a situation is rare and improbable if you use the right tools of the studio and run non all the tests in bulk, but, for example, only those that have not been run before. In general, we can relate to the youthfulness of the framework and the relative uncertainty and, as a result, the lack of many tools. Ready non to return to the topic of detecting tests and generating results doubly, the documentation tells U.S.A that Fixie canful bring fort reports in the style of NUnit and xUnit, which will greatly facilitate the lives of those with a normal CI.

Tuning

The main strong suit of the framework is the ability to flexibly configure how your tests will be identified, how to run and how to validate, and then on. By default, nothing comes with the frame. However, the repository contains many diverse examples .

To bring i things many interesting, let's dig a bit spot into how to custom-make the framework to your necessarily. For lesson, how to pronounce what other classes should be identified as trial run classes.

All settings occur in the constructor of the class inherited from the Convention.

          public class CustomConvention   : Formula {     public CustomConvention  () {     } }

By default, the settings look something like this:

          public course of study DefaultConvention   : Convention {     public DefaultConvention  () {         Classes             .NameEndsWith("Tests");         Methods             .Where(method => method.IsVoid());     } }

The code says that the test classes should conclusion with Tests and that the essa method will be all that returns null. Generally valid.

I try to stand by to the principle when a test separate begins with the word When, and tests with the words Then . It turns out a moderately coherent picture in the mental testing runner and when composition tests you already know what you are examination, i.e. you just motivation to think about the personal effects for the test. An added incentive is that the trial classes are shortsighted and the responsibility between the tests is not amalgamated.

Naturally, any rule exclusively indicates a direction, and is non a dogma. "A Foolish Consistency is the Hobgoblin of Little Minds" - so you should ever make up guided by common sense.

Look my inclination of tests, I take in that not all classes destruction with the intelligence Tests or begin with When .

There is atomic number 102 strict naming social organization in tests, in the sense that tests should begin with the articulate Should, for example. But in my opinion, reading the tests perfectly understands what is happening there. This I enjoin based happening experience. This project has been creeping for 3-4 years with varied success and all time I rapidly and successfully commend what has been done and what inevitably to Be done. This is just some kind of outlet when paperwork gets too much.

Therein naming mode, I'm scared (and lazy) to specialise keywords away which run classes leave live distinct. In addition, the When ... Then ... approach in practice agency that there is a tuning method that runs at the rootage of each test and in the test itself either checks the results or for some reason influences the created object. Those. IT will equal necessary to explicitly patsy, or peg down the tuning method (Apparatus).

For effectuation, I can expressly call the configuration method in each examination. For example, like this:

          unexclusive class SuperHeroTests {     public vacuum NameShouldBeFilled() {         SetUpEnvironment();         var superHero = new SuperHero();         superHero.Name                  .Should()                  .NotBeEmpty();     } }

Of feed, in real life, you need to write something more informative than SetUpEnvironment (), but the idea is clear. With much an implementation, there will embody form variables that will retain their values between tests - which can easy lead to drug-addicted tests if I forget to indite an initialisation twine in some mental testing.

Fixie offers a solution for this situation. Here information technology is:

          public class DefaultConvention   : Conventionality {     public DefaultConvention  () {         Classes             .NameEndsWith("Tests");         Methods             .Where(method => method.IsVoid());         CaseExecution             .Wrap();     } } public class HeroUniverseSetup : CaseBehavior {     public void Execute(Case context of use, Action next) {         // реализация     } }

Those. IT is necessary to implement the CaseBehavior successor and there to record everything that is requisite. The documentation says execution

CaseBehavior = [Apparatus] / [TearDown]
FixtureExecution = [FixtureSetUp] / [FixtureTearDown]

Well, but even and so, in this approach I envision that I need to create many variants of "DefaultConvention" and prescribe the initialisation logic away from the test, and at startup you won't equal roll in the hay that such a context of use exists.

It is well-to-do to demonstrate this. Let DefaultConvention be as in the lesson above, then when the category starts

          public class SuperHeroTests {     public void NameShouldBeFilled() {         var superHero = new SuperHero();         superHero.Epithet                  .Should()                  .NotBeEmpty();     } }

Nothing tells me in that respect is SetUp / TearDown.

MAGIC!!! This is generally interesting, just not in that sheath. I would not want to imagine such magical on the project. This completely contradicts the fact that the tests must be transparent. Even if I write an extension for CaseBehavior in the same sort out , this is not a solution, since it will not be very obvious where to look for the class in which it will every last make up configured. Engaging in aeonian copy-glue is also not an option.

Compare:

          public class DefaultConvention   : Convention {     public DefaultConvention  () {         Classes 	     .InTheSameNamespaceAs(typeof(DefaultConvention))             .NameEndsWith("Tests");         Methods             .Where(method acting => method acting.IsVoid());         CaseExecution             .Wind();     } } public class HeroUniverseSetup : CaseBehavior {     unexclusive nullif Execute(Causa context, Action next) {         // реализация     } } public class SuperHeroTests {     public void NameShouldBeFilled() {         var superHero = brand-new SuperHero();         superHero.Name                  .Should()                  .NotBeEmpty();     } }

Against:

          [TestFixture] state-supported separate SuperHeroTests {     [Apparatus]     public void Init() {         // реализация     }     [Test]     exoteric nihility NameShouldBeFilled() {         var superHero = new SuperHero();         superHero.Name                  .Should()                  .NotBeEmpty();     } }

The code lines will somehow be smaller in the case of NUnit, and SetUp from the class testament not be lost in the project.

Maybe I am biased and incorrectly writing tests, but ... something I'm not sure about. I haven't seen a bunch of articles about how SetUp is hellish. Those. you can bring everything relevant of absurdness and do initialization in SetUp of half the project, but this is a unusual matter.

However, in that location is a solution to this case. You can utilization ego-written attributes to identify the rightist parts of the test, tests, and classes. Those. You butt in full emulate NUnit, xUnit in your design.

Using Attributes You Can Make

category backing
parameterized tests
tests running in strict order
whol that comes to creative thinker

Hera is a small example of creating categories and launching them.

          public division CustomConvention : Convention {     semipublic CustomConvention()     {         var desiredCategories = Options["include"].ToArray();         volt-ampere shouldRunAll = !desiredCategories.Any();         Classes             .InTheSameNamespaceAs(typeof(CustomConvention))             .NameEndsWith("Tests");         Methods             .Where(method => method acting.IsVoid())             .Where(method acting => shouldRunAll || MethodHasAnyDesiredCategory(method, desiredCategories));         if (!shouldRunAll)         {             Console.WriteLine("Categories: " + string.Join(", ", desiredCategories));             Console.WriteLine();         }     }     static bool MethodHasAnyDesiredCategory(MethodInfo method, twine[] desiredCategories)     {         return Categories(method).Any(testCategory => desiredCategories.Contains(testCategory.Bring up));     }     static CategoryAttribute[] Categories(MethodInfo method)     {         take method.GetCustomAttributes(true).ToArray();     } }

And running the tests contingent on the class:
Fixie.Soothe.exe path / to / your / test / project.dll --admit CategoryA

My determination

You can aver a circle more some Fixie, apply examples of solving bound problems, simply there is already a first impression. Therefore, it is worth curving.

It turns out that Fixie is a metaframe for testing. You are freeborn to material body whatsoever rules and opportunities for testing, spell they are built quite an only, to be honest. The only question is expediency. Is it incumbent to serve all this? A little scary, of course, is the want of keep for R #, and the fact that I do not construe that the test is really a tryout, and it was recognized by the frame. In yield I would not use it, but for dwelling house use and as a promising tool - Fixie is very interesting. Leastways, I will definitely commend him if there is any interesting and particular examination task that will glucinium difficult to solve using standard NUnit tools.