Egy devops-fejlesztő életének napja: Új kód írása egy felhasználói történethez

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

Visual Studio 2019 | Visual Studio 2022

Ez az oktatóanyag bemutatja, hogy Ön és csapata hogyan használhatja ki maximálisan a Team Foundation verziókövetés (TFVC) és a Visual Studio legújabb verzióinak előnyeit az alkalmazás létrehozásához. Az oktatóanyag példákat tartalmaz arra, hogyan használhatja a Visual Studiót és a TFVC-t a kód kivételére és frissítésére, a munka felfüggesztésére, a kód felülvizsgálatára, a módosítások beadására és egyéb feladatok elvégzésére.

Amikor egy csapat bevezeti a Visual Studiót és a TFVC-t a kód kezeléséhez, beállítja a kiszolgálót és az ügyfélgépeket, létrehoz egy hátralékot, megtervezi az iterációt, és végrehajtja az alkalmazás fejlesztésének megkezdéséhez szükséges egyéb tervezést.

A fejlesztők áttekintik a hátralékukat, és kiválasztják a feladatokat, amelyen dolgozni szeretnének. Egységteszteket írnak a fejleszteni kívánt kódhoz. A teszteket általában egy óra alatt többször is lefuttatják, fokozatosan részletesebb teszteket írnak, majd megírják az átmenő kódot. A fejlesztők gyakran beszélnek a kódfelületekről azokkal a munkatársakkal, akik az általuk írt módszert fogják használni.

A Visual Studio My Work and Code Review eszközei segítenek a fejlesztőknek a munkájuk kezelésében és a munkatársakkal való együttműködésben.

Feljegyzés

A Visual Studio My Work és a Code Review funkciói az alábbi kiadásokkal érhetők el:

• Visual Studio 2022: Visual Studio Community, Visual Studio Professional és Visual Studio Enterprise
• Visual Studio 2019: Visual Studio Professional és Visual Studio Enterprise

Munkaelemek áttekintése és felkészülés a munka megkezdésére

A csapat egyetértett abban, hogy az aktuális futam során a számla állapotának kiértékelése, a termékháttúlnapló egyik kiemelt eleme lesz. A matematikai függvények implementálása mellett dönt, amely a legfelső prioritású hátralékelem gyermekfeladata.

A Visual Studio Csapatkezelőben a Saját munka lapon húzza ezt a feladatot az Elérhető munkaelemek listából a Folyamatban lévő munka listába.

A teendőlista áttekintése és a feladatok előkészítése a munka megkezdéséhez

1. A Csapatkezelőben, ha még nem csatlakozik ahhoz a projekthez, amelyben dolgozni szeretne, csatlakozzon a projekthez.

2. A kezdőlapon válassza a Saját munka lehetőséget.

3. A Saját munka lapon húzza a feladatot az Elérhető munkaelemek listából a Folyamatban munka szakaszba.

   A feladatot az Elérhető munkaelemek listában, majd a Start gombra kattintva is kijelölheti.

Növekményes munkaterv vázlata

A kódot kis lépések sorozatában fejlesztheti ki. Minden lépés általában legfeljebb egy órát vesz igénybe, és akár 10 percet is igénybe vehet. Minden lépésben meg kell írnia egy új egységtesztet, és módosítania kell a fejlesztendő kódot, hogy az a már megírt tesztek mellett az új teszten is áthaladjon. Előfordul, hogy a kód módosítása előtt megírja az új tesztet, és néha a teszt írása előtt módosítja a kódot. Néha újrafunkálod. Vagyis csak fejlesztheti a kódot új tesztek hozzáadása nélkül. Soha nem módosít egy sikeres tesztet, kivéve, ha úgy dönt, hogy nem felel meg helyesen egy követelménynek.

Minden kis lépés végén futtatja az összes olyan egységtesztet, amely a kód ezen területén releváns. A lépés csak akkor fejeződik be, ha minden teszt befejeződik.

A teljes feladat befejezéséig ne jelentkezzen be a kódba az Azure DevOps Serveren.

A kis lépések sorozatához egy durva tervet írhat le. Tudja, hogy a későbbiek pontos részletei és sorrendje valószínűleg megváltozik munka közben. Íme az adott feladat lépéseinek kezdeti listája:

1. Hozzon létre egy tesztmetódus-csonkot, vagyis csak a metódus aláírását.
2. Egy adott tipikus eset kielégítése.
3. Tesztelje a széles tartományt. Győződjön meg arról, hogy a kód megfelelően reagál nagy értéktartományra.
4. Negatív kivétel. Kezelje a helytelen paramétereket.
5. Kódlefedettség. Győződjön meg arról, hogy az egységtesztek a kód legalább 80%-át gyakorolják.

Egyes fejlesztők megjegyzésbe írják az ilyen típusú terveket a tesztkódjukban. Mások csak memorizálják a tervüket. Hasznos lehet a lépések listájának megírása a Tevékenység munkaelem Leírás mezőjében. Ha ideiglenesen sürgősebb feladatra kell váltania, tudja, hol találja a listát, amikor vissza tud térni.

Az első egységteszt létrehozása

Először hozzon létre egy egységtesztet. Kezdje az egységtesztel, mert egy példát szeretne írni az új osztályt használó kódra.

Ez az első egységteszt a tesztelt osztálytárhoz, ezért létrehoz egy új egységtesztelési projektet.

1. Válassza az Új projekt fájlja>lehetőséget.
2. Az Új projekt létrehozása párbeszédpanelen válassza a Minden nyelv melletti nyilat, majd a C#, a Minden projekttípus melletti nyilat, majd a Tesztelés lehetőséget, majd az MSTest Test Project lehetőséget.
3. Válassza a Tovább, majd a Létrehozás lehetőséget.

A kódszerkesztőben cserélje le a UnitTest1.cs tartalmát a következő kódra. Ebben a szakaszban csak be szeretné szemléltetni, hogy az új metódusok hogyan lesznek meghívva:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Fabrikam.Math.UnitTest
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        // Demonstrates how to call the method.
        public void SignatureTest()
        {
            // Create an instance:
            var math = new Fabrikam.Math.LocalMath();

            // Get a value to calculate:
            double input = 0.0;

            // Call the method:
            double actualResult = math.SquareRoot(input);

            // Use the result:
            Assert.AreEqual(0.0, actualResult);
        }
    }
}

A példát egy tesztmetódusban kell írnia, mert a kód megírásakor azt szeretné, hogy a példa működjön.

Egységtesztelési projekt és metódusok létrehozása

Általában minden tesztelt projekthez létrehoz egy új tesztprojektet. Ha már létezik tesztprojekt, egyszerűen hozzáadhat új tesztelési módszereket és osztályokat.

Ez az oktatóanyag a Visual Studio Unit Test Frameworkt használja, de más szolgáltatók keretrendszereit is használhatja. A Test Explorer ugyanúgy működik más keretrendszerekkel, feltéve, hogy telepíti a megfelelő adaptert.

1. Hozzon létre egy tesztprojektet az előző lépések végrehajtásával. Választhat olyan nyelveket, mint a C#, az F# és a Visual Basic.

2. Adja hozzá a teszteket a megadott tesztosztályhoz. Minden egységteszt egy módszer.

   • Minden egységtesztet az TestMethod attribútumnak kell előtaggal ellátnia, és az egységtesztelési módszernek nem kell paraméterekkel rendelkeznie. Az egységtesztelési módszerhez bármilyen nevet használhat:

     [TestMethod]
     public void SignatureTest()
     {...}
     

     <TestMethod()>
     Public Sub SignatureTest()
     ...
     End Sub
     

   • Minden tesztmetódusnak meg kell hívnia az Assert osztály egy metódusát, hogy jelezze, hogy sikeres vagy sikertelen volt-e. Általában ellenőrzi, hogy egy művelet várt és tényleges eredménye megegyezik-e:

     Assert.AreEqual(expectedResult, actualResult);
     

     Assert.AreEqual(expectedResult, actualResult)
     

   • A tesztelési metódusok meghívhatnak más szokásos metódusokat is, amelyek nem rendelkeznek az TestMethod attribútummal.

   • A teszteket több osztályba is rendezheti. Minden osztálynak előtaggal kell rendelkeznie az TestClass attribútummal.

     [TestClass]
     public class UnitTest1
     { ... }
     

     <TestClass()>
     Public Class UnitTest1
     ...
     End Class
     

Az egységtesztek C++-ban való írásáról a C/C++ egységtesztjeinek írása a C++ microsoftos egységtesztelési keretrendszerével című témakörben olvashat.

Csonk létrehozása az új kódhoz

Ezután hozzon létre egy osztálytárprojektet az új kódhoz. Most már van egy projekt a fejlesztés alatt álló kódhoz, és egy projekt az egységtesztekhez. Adjon hozzá egy projekthivatkozást a tesztprojektből a fejlesztés alatt álló kódhoz.

Az új projektben hozzáadja az új osztályt és a metódus minimális verzióját, amely legalább lehetővé teszi a teszt sikeres összeállítását. Ennek leggyorsabb módja az osztály és a metódus csonkjának létrehozása a teszt meghívásából.

public double SquareRoot(double p)
{
    throw new NotImplementedException();
}

Osztályok és metódusok létrehozása tesztekből

Először hozza létre azt a projektet, amelyhez hozzá szeretné adni az új osztályt, kivéve, ha már létezik.

Osztály létrehozása

1. Helyezze a kurzort a létrehozni kívánt osztály egy példájára, LocalMathés válassza a Gyorsműveletek és újrabontások lehetőséget.
2. A helyi menüben válassza az Új típus létrehozása lehetőséget.
3. A Típus létrehozása párbeszédpanelen állítsa a Projectetaz osztálytárprojektre. Ebben a példában a Fabrikam.Math.

Metódus létrehozása

1. Helyezze a kurzort a metódus hívására, és SquareRootválassza a Gyorsműveletek és újrabontások lehetőséget.
2. A helyi menüben válassza a "SquareRoot" metódus létrehozása lehetőséget.

Az első teszt futtatása

Hozza létre és futtassa a tesztet. A teszt eredménye piros sikertelen jelzőt jelenít meg, és a teszt a sikertelen tesztek listájában jelenik meg.

A kód egyszerű módosítása:

public double SquareRoot(double p)
{
    return 0.0;
}

Futtassa újra a tesztet, és halad át.

Egységtesztek futtatása

Egységtesztek futtatása:

• Válassza az Összes teszt futtatása teszt>lehetőséget
• Vagy ha a Test Explorer meg van nyitva, válassza a Futtatás vagy az Összes teszt futtatása nézetben lehetőséget.

Ha egy teszt a Sikertelen tesztek területen jelenik meg, nyissa meg a tesztet, például kattintson duplán a nevére. Az a pont, ahol a teszt sikertelen volt, megjelenik a kódszerkesztőben.

• A tesztek teljes listájának megtekintéséhez válassza az Összes megjelenítése lehetőséget.

• A teszteredmény részleteinek megtekintéséhez válassza ki a tesztet a Test Explorerben.

• A teszt kódjára való navigáláshoz kattintson duplán a tesztre a Test Explorerben, vagy válassza a Helyi menü Teszt megnyitása parancsát.

• Egy teszt hibakereséséhez nyissa meg egy vagy több teszt helyi menüjét, majd válassza a Hibakeresés lehetőséget.

• Ha a megoldás létrehozásakor a háttérben szeretne teszteket futtatni, jelölje ki a Gépház ikon melletti nyilat, majd válassza a Tesztek futtatása buildelés után lehetőséget. A korábban sikertelen teszteket először a rendszer futtatja.

Megállapodás a felületről

A képernyő megosztásával együttműködhet olyan munkatársakkal, akik használni fogják az összetevőt. Egy munkatárs megjegyzést fűzhet hozzá, hogy sok függvény felelne meg az előző tesztnek. Magyarázd el, hogy ez a teszt csak azért volt, hogy meggyőződjön arról, hogy a függvény neve és paraméterei helyesek, és most már írhat egy tesztet, amely rögzíti a függvény fő követelményét.

Munkatársaival együttműködve írja meg a következő tesztet:

[TestMethod]
public void QuickNonZero()
{
    // Create an instance to test:
    LocalMath math = new LocalMath();

    // Create a test input and expected value:
    var expectedResult = 4.0;
    var inputValue = expectedResult * expectedResult;

    // Run the method:
    var actualResult = math.SquareRoot(inputValue);

    // Validate the result:
    var allowableError = expectedResult/1e6;
    Assert.AreEqual(expectedResult, actualResult, allowableError,
        "{0} is not within {1} of {2}", actualResult, allowableError, expectedResult);
}

Tipp.

Ehhez a függvényhez először tesztfejlesztést kell használnia, amelyben először meg kell írnia egy funkció egységtesztjét, majd a tesztnek megfelelő kódot kell írnia. Más esetekben ez a gyakorlat nem reális, ezért a kód megírása után meg kell írnia a teszteket. De nagyon fontos, hogy egységteszteket írjon, akár a kód előtt, akár utána, mert stabilan tartják a kódot.

Piros, zöld, újrabontás...

Kövessen egy ciklust, amelyben ismételten megír egy tesztet, és győződjön meg arról, hogy nem sikerül, írjon kódot a teszt sikeressé tételéhez, majd fontolja meg az újrabontást, amely a tesztek módosítása nélkül javítja a kódot.

Piros

Futtassa az összes tesztet, beleértve a létrehozott új tesztet is. Miután bármilyen tesztet írt, mindig futtassa, hogy biztosan sikertelen legyen, mielőtt megírja az átmenő kódot. Ha például elfelejt helyességeket elhelyezni az ön által írt tesztekben, a Sikertelen eredmény nézetben meggyőződhet arról, hogy a sikeres teszt eredménye helyesen jelzi, hogy egy követelmény teljesült.

Egy másik hasznos eljárás a futtatási tesztek beállítása a buildelés után. Ez a beállítás a megoldás minden létrehozásakor futtatja a teszteket a háttérben, így folyamatosan jelentést készít a kód tesztelési állapotáról. Előfordulhat, hogy ez a gyakorlat lelassítja a Visual Studio válaszát, de ez ritkán fordul elő.

Zöld

Megírja az első kísérletet a fejleszteni kívánt metódus kódjára:

public class LocalMath
{
    public double SquareRoot(double x)
    {
        double estimate = x;
        double previousEstimate = -x;
        while (System.Math.Abs(estimate - previousEstimate) > estimate / 1000)
        {
            previousEstimate = estimate;
            estimate = (estimate * estimate - x) / (2 * estimate);
        }
        return estimate;
    }

Futtassa újra a teszteket, és az összes teszt sikeres lesz.

Újrabontás

Most, hogy a kód végrehajtja a fő funkcióját, nézze meg a kódot, hogy megtalálja a jobb teljesítményre vonatkozó módszereket, vagy hogy megkönnyítse a jövőbeni módosítást. Csökkentheti a ciklusban végrehajtott számítások számát:

public class LocalMath
{
    public double SquareRoot(double x)
    {
        double estimate = x;
        double previousEstimate = -x;
        while (System.Math.Abs(estimate - previousEstimate) > estimate / 1000)
        {
            previousEstimate = estimate; 
            estimate = (estimate + x / estimate) / 2;
            //was: estimate = (estimate * estimate - x) / (2 * estimate);
        }
        return estimate;
    }

Ellenőrizze, hogy a tesztek továbbra is sikeresek-e.

Tippek

• A kód fejlesztése során végzett minden módosításnak újrabontásnak vagy bővítménynek kell lennie:

  • Az újrabontás azt jelenti, hogy nem módosítja a teszteket, mert nem ad hozzá új funkciókat.
  • A bővítmény tesztek hozzáadását és a kód módosításainak elvégzését jelenti, amelyek a meglévő és az új tesztek átadásához szükségesek.

• Ha a meglévő kódot olyan követelményekre frissíti, amelyek módosultak, akkor a régi teszteket is törli, amelyek már nem felelnek meg az aktuális követelményeknek.

• Kerülje a már elvégzett tesztek módosítását. Ehelyett adjon hozzá új teszteket. Csak olyan tesztek írása, amelyek valós követelményt képviselnek.

• Minden módosítás után futtassa a teszteket.

... és ismételje meg a

Folytassa a bővítmények és újrabontási lépések sorozatát a kis lépések listájával, mint egy durva útmutató. Nem mindig hajt végre újrabontási lépést minden bővítmény után, és néha több újrabontási lépést is elvégez egymás után. A kód minden módosítása után azonban mindig futtatja az egységteszteket.

Néha olyan tesztet ad hozzá, amely nem igényel módosítást a kódban, de ez növeli a kód helyes működésének megbízhatóságát. Például meg szeretné győződni arról, hogy a függvény számos bemeneten működik. További teszteket is írhat, például a következőt:

[TestMethod]
public void SqRtValueRange()
{
    LocalMath math = new LocalMath();
    for (double expectedResult = 1e-8;
        expectedResult < 1e+8;
        expectedResult = expectedResult * 3.2)
    {
        VerifyOneRootValue(math, expectedResult);
    }
}
private void VerifyOneRootValue(LocalMath math, double expectedResult)
{
    double input = expectedResult * expectedResult;
    double actualResult = math.SquareRoot(input);
    Assert.AreEqual(expectedResult, actualResult, expectedResult / 1e6);
}

Ez a teszt az első futtatáskor halad át.

Csak annak érdekében, hogy ez az eredmény ne legyen hiba, ideiglenesen bevezethet egy kis hibát a tesztbe, hogy sikertelen legyen. A hiba után újra kijavíthatja.

Tipp.

A teszt sikeres végrehajtása előtt mindig végezze el a sikertelen tesztet.

Kivételek

Most lépjen tovább a kivételes bemenetek tesztjeinek írására:

[TestMethod]
public void RootTestNegativeInput()
{
    LocalMath math = new LocalMath();
    try
    {
        math.SquareRoot(-10.0);
    }
    catch (ArgumentOutOfRangeException)
    {
        return;
    }
    catch
    {
        Assert.Fail("Wrong exception on negative input");
        return;
    }
    Assert.Fail("No exception on negative input");
}

Ez a teszt egy ciklusba helyezi a kódot. A Mégse gombot kell használnia a Test Explorerben. Ez 10 másodpercen belül leállítja a kódot.

Meg szeretné győződni arról, hogy a buildkiszolgálón nem lehet végtelen ciklust létrehozni. Bár a kiszolgáló időtúllépést ír elő egy teljes futtatásra, ez egy nagyon hosszú időtúllépés, és jelentős késést okozna. Ezért explicit időtúllépést adhat ehhez a teszthez:

[TestMethod, Timeout(1000)]
public void RootTestNegativeInput()
{...

A explicit időtúllépés miatt a teszt meghiúsul.

Frissítse a kódot a kivételes eset kezelésére:

public double SquareRoot(double x)
{
    if (x <= 0.0) 
    {
        throw new ArgumentOutOfRangeException();
    }

Regresszió

Az új teszt sikeres, de regresszió van. Az átvételhez használt teszt most meghiúsul:

Keresse meg és javítsa ki a hibát:

public double SquareRoot(double x)
{
    if (x < 0.0)  // not <=
    {
        throw new ArgumentOutOfRangeException();
    }

A javítás után az összes teszt a következő lesz:

Tipp.

Győződjön meg arról, hogy minden teszt megfelel a kódon végzett minden módosítás után.

Kódlefedettség

A munka során időközönként, végül pedig a kód beadása előtt szerezze be a kódlefedettségi jelentést. Ez azt mutatja, hogy a tesztek mennyi kódot gyakoroltak.

A csapat legalább 80%-os lefedettségre törekszik. Enyhítik a generált kódra vonatkozó követelményt, mert nehéz lehet magas lefedettséget elérni az ilyen típusú kódhoz.

A jó lefedettség nem garantálja, hogy az összetevő teljes funkcionalitását tesztelték, és nem garantálja, hogy a kód minden bemeneti értéktartományban működni fog. Ennek ellenére meglehetősen szoros korreláció áll fenn a kódvonalak lefedettsége és az összetevő viselkedési területének lefedettsége között. Ezért a jó lefedettség erősíti a csapat bizalmát abban, hogy a viselkedésük nagy részét tesztelik.

Kódlefedettségi jelentés lekéréséhez a Visual Studio Teszt menüjében válassza a Kódlefedettség elemzése az összes teszthez lehetőséget. Az összes teszt újra lefut.

A jelentés összegének kibontásakor az látható, hogy a fejleszteni kívánt kód teljes lefedettséggel rendelkezik. Ez nagyon kielégítő, mert a fontos pontszám a tesztelt kódra vonatkozik. A feltárt szakaszok valójában maguk a tesztek.

A Kódlefedés színezésének megjelenítése gomb összesítésével láthatja, hogy a tesztkód mely részeit nem gyakorolták. A tesztekben nem használt kód narancssárga színnel van kiemelve. Ezek a szakaszok azonban nem lényegesek a lefedettség szempontjából, mivel a tesztkódban szerepelnek, és csak hiba észlelése esetén használhatók.

Annak ellenőrzéséhez, hogy egy adott teszt eléri-e a kód adott ágait, beállíthatja a kódlefedettség színezésének megjelenítését, majd futtathatja az egyetlen tesztet a helyi menü Futtatás parancsával.

Mikor végzett?

A kódot továbbra is kis lépésekben frissítheti, amíg meg nem győződik arról, hogy:

• Az összes elérhető egységteszt sikeres.

  Egy nagyon nagy egységteszteket tartalmazó projektben nem praktikus, ha egy fejlesztő megvárja, amíg az összes fut. Ehelyett a projekt egy zárt bejelentkezési szolgáltatást működtet, amelyben az összes automatizált teszt lefut minden beadott polckészleten, mielőtt a forrásfába egyesül. A rendszer elutasítja a bejelentkezést, ha a futtatás sikertelen. Ez lehetővé teszi a fejlesztők számára, hogy minimális egységteszteket futtasson a saját gépükön, majd folytassa az egyéb munkát anélkül, hogy a build feltörésének kockázata fennállna. További információ: A módosítások ellenőrzése kapus bejelentkezési buildelési folyamat használatával.

• A kódlefedettség megfelel a csapat szabványának. A 75% egy tipikus projektkövetelmény.

• Az egységtesztek a szükséges viselkedés minden aspektusát szimulálják, beleértve a tipikus és a kivételes bemeneteket is.

• A kód könnyen érthető és bővíthető.

Ha ezek a feltételek teljesülnek, készen áll arra, hogy ellenőrizze a kódot a forráskövetésben.

A kódfejlesztés alapelvei egységtesztekkel

Alkalmazza az alábbi alapelveket a kód fejlesztése során:

• Egységteszteket fejleszthet a kóddal együtt, és gyakran futtathatja őket a fejlesztés során. Az egységtesztek az összetevő specifikációját jelölik.
• Ne módosítsa az egységteszteket, kivéve, ha a követelmények megváltoztak, vagy a tesztek helytelenek voltak. A kód funkcióinak kibővítése során fokozatosan adjon hozzá új teszteket.
• Törekedjen arra, hogy a kód legalább 75%-át lefedje a tesztek. A kódlefedettségi eredményeket időközönként és a forráskód beadása előtt tekintheti meg.
• A kóddal együtt ellenőrizze az egységteszteket, hogy a folyamatos vagy rendszeres kiszolgálói buildek futtathassák őket.
• Ahol praktikus, minden egyes funkcióhoz először írja meg az egységtesztet. Ezt a kódot a megfelelő kód fejlesztése előtt teheti meg.

A módosítások beadása

Mielőtt bejelentkezik a módosításokba, ossza meg ismét a képernyőjét a munkatársaival, hogy informálisan és interaktívan áttekinthesse a létrehozott tartalmat. A tesztek továbbra is a munkatársakkal folytatott beszélgetés középpontjában állnak, akiket elsősorban a kód működése, nem pedig a működése érdekel. Ezeknek a munkatársaknak meg kell egyezniük abban, hogy az Ön által írt szöveg megfelel az igényeiknek.

Ellenőrizze az összes elvégzett módosítást, beleértve a teszteket és a kódot is, és társítsa őket az elvégzett feladatokkal. A bejelentkezési üzenetsorok a csapat automatizált csapatépítési rendszerét várják a módosítások ellenőrzéséhez a csapat CI buildelési folyamatával. Ez a létrehozási folyamat segít a csapatnak minimalizálni a kódbázis hibáit azáltal, hogy a fejlesztői számítógépektől eltérő tiszta környezetben készíti és teszteli a hibákat, és a csapat minden módosítást végrehajt.

A build befejezésekor értesítést kap. A buildelési eredmények ablakában láthatja, hogy a build sikeres volt, és az összes teszt sikeres volt.

A módosítások beadása

1. A Csapatkezelő Saját munka lapján válassza a Bejelentkezés lehetőséget.

   

2. A Függőben lévő módosítások lapon győződjön meg arról, hogy:

   • Az összes releváns módosítás szerepel a Belefoglalt módosítások listában.
   • Az összes releváns munkaelem szerepel a kapcsolódó munkaelemek között.

3. Írjon be egy megjegyzést, amely segít a csapatnak megérteni ezeknek a módosításoknak a célját, amikor megtekintik a módosított fájlok és mappák verziókövetési előzményeit.

4. Válassza a Bejelentkezés.

   

A kód folyamatos integrálása

A folyamatos integrációs buildelési folyamat definiálásáról további információt a CI-build beállítása című témakörben talál. A buildelési folyamat beállítása után dönthet úgy, hogy értesítést kap a csapat buildjeinek eredményeiről.

További információ: Buildek futtatása, monitorozása és kezelése.

Következő lépések

A munka felfüggesztése, hiba kijavítása és kódellenőrzés végrehajtása