Jakie są popularne konwencje nazewnictwa testów jednostkowych? [zamknięte]

Warto też przeczytać: strukturyzacja testów jednostkowych

Struktura ma klasę testową dla każdej badanej klasy. To nic niezwykłego. Ale to, co było dla mnie niezwykłe, to to, że miał zagnieżdżoną klasę dla każdej testowanej metody.

Np.

using Xunit;

public class TitleizerFacts
{
    public class TheTitleizerMethod
    {
        [Fact]
        public void NullName_ReturnsDefaultTitle()
        {
            // Test code
        }

        [Fact]
        public void Name_AppendsTitle()
        {
            // Test code
        }
    }

    public class TheKnightifyMethod
    {
        [Fact]
        public void NullName_ReturnsDefaultTitle()
        {
            // Test code
        }

        [Fact]
        public void MaleNames_AppendsSir()
        {
            // Test code
        }

        [Fact]
        public void FemaleNames_AppendsDame()
        {
            // Test code
        }
    }
}

A oto dlaczego:

Po pierwsze, to dobry sposób na zorganizowanie testów. Wszystkie testy (lub fakty) dla metody są grupowane razem. Na przykład, jeśli używasz CTRL + M, CTRL + O skrót do zwijania ciał metod, można łatwo zeskanuj testy i odczytaj je jak specyfikację kodu.

MethodName_StateUnderTest_Expectedbehavior

Więc być może dostosuj się do:

StateUnderTest_ExpectedBehavior

Ponieważ każdy test będzie już w zagnieżdżonej klasie

Zazwyczaj używam konwencji MethodName_DoesWhat_WhenTheseConditions więc na przykład:

Sum_ThrowsException_WhenNegativeNumberAs1stParam

Jednak to, co widzę, to aby nazwa testu była zgodna ze strukturą testów jednostkowych

• zorganizować
• Act
• Assert

, który również jest zgodny ze składnią BDD / Gherkin z:

• Given
• Kiedy
• Then

Co oznaczałoby nazwę testu w sposób: UnderTheseTestConditions_WhenIDoThis_ThenIGetThis

Więc do twojego przykładu:

WhenNegativeNumberAs1stParam_Sum_ThrowsAnException

Jakkolwiek wiele robię preferuj umieszczenie nazwy metody, która jest testowana jako pierwsza, ponieważ wtedy testy mogą być ułożone alfabetycznie lub wyświetlane Alfabetycznie w rozwijanym oknie programu VisStudio, a wszystkie testy dla 1 Metody są pogrupowane razem.

W każdym razie, Lubię rozdzielać główne sekcje nazwy testu z podkreślnikami, w przeciwieństwie do każdego słowa , ponieważ myślę, że ułatwia to czytanie i uzyskanie punktu testu w poprzek.

Nazywam moje metody testowe tak jak inne metody używając "PascalCasing" bez podkreślników lub separatorów. Zostawiam postfix Test dla metody, ponieważ nie dodaje żadnej wartości. To, że metoda jest metodą badawczą, wskazuje atrybut TestMethod .

[TestMethod]
public void CanCountAllItems() {
  // Test the total count of items in collection.
}

Ze względu na fakt, że każda klasa testowa powinna testować tylko jedną inną klasę, pomijam nazwę klasy z nazwy metody. Nazwa klasy, która zawiera metody testowe, jest nazwana tak, jak Klasa testowane z postfixem "testy".

[TestClass]
public class SuperCollectionTests(){
    // Any test methods that test the class SuperCollection
}

Dla metod, które sprawdzają wyjątki lub działania, które nie są możliwe, dodaję przedrostek metody testowej ze słowem Cannot .

[TestMethod]
[ExpectedException(typeOf(ArgumentException))]
public void CannotAddSameObjectAgain() {
  // Cannot add the same object again to the collection.
}

Pierwszy zestaw nazw jest dla mnie bardziej czytelny, ponieważ CamelCasing oddziela słowa, a podbarki oddziela część schematu nazewnictwa.

Zwykle umieszczam gdzieś "Test", albo w nazwie funkcji, albo w otaczającej przestrzeni nazw lub klasie.

Dopóki stosujesz jedną praktykę, to nie ma znaczenia. Generalnie piszę pojedynczy test jednostkowy dla metody, która obejmuje wszystkie odmiany metody (mam proste metody;), a następnie piszę bardziej złożone zestawy testów dla metod, które tego wymagają. Moja struktura nazewnictwa jest więc zwykle testowa(holdover z JUnit 3).

Używam przedrostka 'T' dla testowych przestrzeni nazw, klas i metod.

Staram się być schludny i tworzyć foldery replikujące przestrzenie nazw, a następnie tworzyć folder testów lub oddzielny projekt dla testów i replikować strukturę produkcji dla podstawowych testów:

AProj
   Objects
      AnObj
         AProp
   Misc
      Functions
         AFunc
   Tests
      TObjects
         TAnObj
            TAnObjsAreEqualUnderCondition
      TMisc
         TFunctions
            TFuncBehavesUnderCondition

Łatwo widzę, że coś jest testem, wiem dokładnie, do jakiego oryginalnego kodu się odnosi, (jeśli nie możesz tego rozgryźć, to test i tak jest zbyt zawiły).

Wygląda jak interfejsy konwencja nazewnictwa, (mam na myśli, nie mylić z rzeczami zaczynającymi się od "I" , ani nie będzie z "T").

Łatwo jest skompilować z testami lub bez nich.

To i tak jest dobre w teorii i działa całkiem dobrze dla małych projektów.