Jak skonfigurować CI/CD za pomocą GitHub Actions w projekcie C#

GitHub Actions to narzędzie, które umożliwia automatyzację procesów CI/CD (Continuous Integration i Continuous Delivery) w projektach programistycznych. W tym rozdziale przyjrzymy się, jak skonfigurować takie procesy dla projektu C#, używając GitHub Actions. Dzięki temu będziemy mogli zautomatyzować budowanie, testowanie i wdrażanie aplikacji przy każdej zmianie w kodzie, co zapewni nam szybszy cykl wydania i lepszą jakość oprogramowania.

Podstawy konfiguracji workflow w GitHub Actions

Workflow to zestaw czynności, które są wykonywane na podstawie określonych zdarzeń. Na przykład, workflow może uruchomić proces budowania aplikacji za każdym razem, gdy kod zostanie wprowadzony do głównej gałęzi projektu. W tym przypadku workflow będzie działać po każdym "push" do gałęzi main, jak również przy otwieraniu, synchronizowaniu lub ponownym otwieraniu pull requesta skierowanego na gałąź main.

Definiowanie warunków wyzwalających

Pierwszym krokiem w konfiguracji workflow jest określenie warunków wyzwalających, które decydują o tym, kiedy workflow powinien zostać uruchomiony. W przykładzie poniżej workflow uruchamia się, gdy zachodzi jedno z dwóch zdarzeń: push na gałąź main lub otwarcie, synchronizacja bądź ponowne otwarcie pull requesta, który kieruje zmiany do tej samej gałęzi.

yaml
Copy code
on:

  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

Określenie zadań i środowiska wykonawczego

Każde workflow składa się z tzw. jobs, czyli zadań, które muszą zostać wykonane. W przypadku projektu C# jednym z najczęściej używanych środowisk wykonawczych jest Windows, ponieważ wiele aplikacji .NET Core i .NET 5+ wymaga tego systemu operacyjnego do poprawnego działania. W związku z tym konfigurujemy zadanie do uruchomienia na najnowszym środowisku Windows.

yaml
Copy code
jobs:

  build:
    runs-on: windows-latest

Kroki wykonania zadania

Każde zadanie składa się z zestawu kroków, które są wykonywane w określonej kolejności. Poniżej znajduje się szczegółowy opis kroków, które muszą zostać wykonane, aby zbudować i przetestować aplikację C#.

1. Checkout kodu
   Pierwszym krokiem jest pobranie kodu z repozytorium, aby kolejne kroki mogły go wykorzystać. Do tego celu używamy akcji actions/checkout@v2, która klonuje nasze repozytorium do środowiska wykonawczego.

yaml
Copy code
- name: Checkout code
  uses: actions/checkout@v2

2. Konfiguracja .NET
   Kolejnym krokiem jest ustawienie odpowiedniej wersji .NET w środowisku wykonawczym. W tym przypadku korzystamy z wersji 3.1.x, ale ta wersja powinna być dostosowana do wymagań konkretnego projektu.

yaml
Copy code
- name: Setup .NET

  uses: actions/setup-dotnet@v1
  with:
    dotnet-version: '3.1.x'

3. Budowanie aplikacji
   Następnie, przy pomocy komendy dotnet build, kompilujemy naszą aplikację. Flaga --configuration Release zapewnia, że kompilacja jest zoptymalizowana pod kątem wydajności i przygotowana do wersji produkcyjnej.

yaml
Copy code
- name: Build

  run: dotnet build --configuration Release

4. Testowanie aplikacji
   Ostatnim krokiem w tym przykładzie jest uruchomienie testów jednostkowych. Ważne jest, aby w tym przypadku nie przeprowadzać ponownej kompilacji aplikacji, dlatego dodajemy flagę --no-build. Opcja --verbosity normal zapewnia, że w logach wyświetlane są tylko najistotniejsze informacje.

yaml
Copy code
- name: Test

  run: dotnet test --no-build --verbosity normal

Zakończenie procesu CI

Generowanie pliku GitHub Actions w Visual Studio

Jeśli używasz Visual Studio, możesz łatwo wygenerować plik workflow GitHub Actions dla swojego projektu. Wystarczy kliknąć prawym przyciskiem myszy na projekt, wybrać opcję Publish i skonfigurować odpowiednie opcje dla Twojego środowiska. Visual Studio automatycznie wygeneruje plik YAML, który będzie zawierał wszystkie niezbędne kroki do zrealizowania procesu CI/CD. Takie rozwiązanie znacząco upraszcza proces konfiguracji, szczególnie dla mniej doświadczonych programistów.

Znaczenie integracji GitHub Actions w procesie wytwarzania oprogramowania

Korzystanie z GitHub Actions ma wiele zalet w kontekście ciągłej integracji i dostarczania (CI/CD). Automatyzacja procesów budowania i testowania aplikacji pozwala na szybsze wykrywanie błędów, zapewnia spójność środowiska produkcyjnego oraz ułatwia zarządzanie wersjami aplikacji. To także istotny element w praktykach DevOps, które pozwalają na szybkie wprowadzanie nowych funkcji bez obawy o jakość oprogramowania.

Jak stworzyć własny szablon projektu w Visual Studio?

Szablony projektów w Visual Studio to narzędzia, które pozwalają programistom na szybkie tworzenie nowych projektów z predefiniowaną strukturą i konfiguracjami. Dają one możliwość rozpoczęcia pracy nad projektem w sposób uporządkowany i spójny, eliminując potrzebę ręcznego ustawiania wszystkich plików, zależności i konfiguracji na początku każdej nowej aplikacji. W tym rozdziale omówimy, jak stworzyć własne szablony projektów i jak mogą one usprawnić codzienny proces tworzenia oprogramowania.

Szablony projektów stanowią fundamentalną bazę, z której można rozpocząć budowę aplikacji w Visual Studio. Każdy szablon zawiera zestaw plików, referencji i ustawień konfiguracyjnych, które są dostosowane do konkretnego typu projektu, na przykład aplikacji ASP.NET Core, biblioteki klasowej czy aplikacji konsolowej. Korzystając z takiego szablonu, oszczędzamy czas na konfigurację środowiska, a także zapewniamy spójność między projektami. Dzięki temu wszystkie projekty rozpoczęte na podstawie tego samego szablonu będą miały tę samą strukturę i ustawienia początkowe.

Równolegle z szablonami projektów, w Visual Studio istnieje możliwość tworzenia tzw. szablonów elementów. Te szablony są mniej obszerne, ponieważ pozwalają na szybsze dodawanie pojedynczych komponentów do już istniejącego projektu. Może to być na przykład nowa klasa, interfejs czy plik HTML. Szablony elementów są szczególnie przydatne, gdy musimy wielokrotnie dodawać podobne pliki lub komponenty do naszego projektu, a proces ich tworzenia jest zbyt czasochłonny, by za każdym razem wykonywać go ręcznie.

Kiedy zaczynamy pracę z własnymi szablonami projektów, musimy zrozumieć kilka kluczowych elementów, które wchodzą w skład szablonu. Szablon projektu składa się z kilku podstawowych plików, które określają jego strukturę oraz zawartość:

1. Pliki źródłowe – to pliki kodu, które zostaną zawarte w szablonie, takie jak klasy czy interfejsy. Na przykład, szablon biblioteki klasowej może zawierać plik Class1.cs jako domyślny punkt wyjścia.

2. Zasoby osadzone – wszelkie pliki, które są potrzebne do poprawnego działania projektu, jak obrazy, pliki konfiguracyjne czy inne zasoby.

3. Pliki projektów – pliki, które definiują strukturę projektu, takie jak .csproj dla projektów C#, czy .sln dla rozwiązań. Określają one zależności między plikami oraz sposób kompilacji projektu.

4. Plik .vstemplate – jest to kluczowy plik XML, który zawiera wszystkie metadane dotyczące szablonu, takie jak jego nazwa, opis, ikona oraz typ projektu. To także tutaj definiowane są parametry, które mają być wykorzystywane podczas procesu tworzenia projektu na podstawie tego szablonu.

5. Pakowanie do pliku ZIP – gotowy szablon projektów (wraz z plikami i plikiem .vstemplate) jest kompresowany do pliku ZIP. Szablony projektów muszą znajdować się w odpowiednim folderze na komputerze, by Visual Studio mogło je rozpoznać i umożliwić ich wykorzystanie. Dla szablonów projektów jest to folder \Documents\Visual Studio\Templates\ProjectTemplates.

Proces tworzenia szablonów nie kończy się na przygotowaniu podstawowych plików. Istnieje także możliwość rozszerzenia tych szablonów, by mogły one obsługiwać bardziej złożone struktury, takie jak rozwiązania składające się z wielu projektów. Szablony projektów mogą być dostosowane do specyficznych wymagań zespołu programistycznego, co umożliwia szybkie rozpoczęcie nowych zadań z pełną strukturą i ustawieniami, które są wymagane do utrzymania spójności kodu w organizacji.

Budowanie własnych szablonów jest również świetnym sposobem na zwiększenie efektywności pracy zespołu programistycznego. Na przykład, zespół może stworzyć szablony dostosowane do określonych standardów i praktyk kodowania, dzięki czemu nowe projekty będą od razu spełniały wymogi jakościowe. Dzięki takim narzędziom jak Visual Studio, tworzenie niestandardowych szablonów staje się prostym i szybkim procesem, który może zaoszczędzić wiele godzin pracy.

Warto również zaznaczyć, że tworzenie własnych szablonów to nie tylko sposób na zwiększenie produktywności w obrębie organizacji, ale także sposób na dzielenie się swoimi rozwiązaniami z innymi programistami. Publikowanie szablonów na platformach takich jak NuGet daje możliwość wykorzystywania ich przez innych developerów na całym świecie, co może przyczynić się do rozwoju Twojej reputacji jako programisty.

Jak skutecznie skonfigurować testy jednostkowe w Visual Studio 2022?

W Visual Studio 2022 dostępnych jest kilka frameworków testowych wspierających testy jednostkowe dla aplikacji .NET, w tym MSTest, NUnit i xUnit. Każdy z nich ma swoje zalety i specyficzne cechy, które sprawiają, że są preferowane w różnych scenariuszach. MSTest to domyślny framework oferowany przez Microsoft, w pełni zintegrowany z Visual Studio. NUnit jest popularnym, otwartym frameworkiem, który cieszy się dużą popularnością wśród deweloperów .NET. Z kolei xUnit to nowoczesna i elastyczna opcja, która zyskuje na znaczeniu, szczególnie w większych projektach.

Aby rozpocząć pracę z testami jednostkowymi w Visual Studio, należy utworzyć nowy projekt testowy w rozwiązaniu zawierającym testowaną aplikację. W tym celu należy kliknąć prawym przyciskiem myszy na rozwiązanie i wybrać opcję „Dodaj | Nowy projekt...”. W oknie wyboru projektu możemy zobaczyć dostępne szablony testowe, które domyślnie są filtrowane do trzech najpopularniejszych frameworków testowych.

Warto zauważyć, że Visual Studio 2022 oferuje również szablony testów związane z Playwright, biblioteką do testowania aplikacji internetowych. Jednakże, dla celów naszej dyskusji, skupimy się na xUnit, który jest szeroko stosowany w branży.

Istnieje także alternatywna metoda tworzenia projektu testowego, polegająca na kliknięciu prawym przyciskiem myszy na klasie w kodzie źródłowym i wybraniu opcji „Utwórz testy jednostkowe” z menu kontekstowego. Po tej akcji pojawi się okno konfiguracji projektu testowego, które umożliwia stworzenie testów przy użyciu MSTestv2, chociaż Visual Studio pozwala na instalowanie dodatkowych rozszerzeń umożliwiających pracę z innymi frameworkami.

Po utworzeniu projektu testowego, wszystkie testy w projekcie mogą być zarządzane za pomocą widoku Test Explorer, który pozwala na wygodne organizowanie, uruchamianie i monitorowanie wyników testów. Test Explorer to narzędzie w Visual Studio 2022, które centralizuje proces zarządzania testami jednostkowymi. Jest to funkcjonalne okno umożliwiające deweloperom szybki dostęp do wszystkich testów, ich organizowanie oraz uruchamianie w IDE. Test Explorer można uruchomić poprzez menu Test w Visual Studio lub za pomocą skrótu klawiszowego Ctrl + E, a następnie T.

Test Explorer umożliwia również filtrowanie wyników i wyszukiwanie testów według określonych kryteriów. Można na przykład filtrować testy według przestrzeni nazw lub klasy, a także korzystać z bardziej zaawansowanych opcji, takich jak tworzenie playlist testów. Playlisty pozwalają na grupowanie testów w specjalne zestawy, które można uruchamiać w różnych konfiguracjach. Playlisty są dynamiczne, co oznacza, że mogą być automatycznie aktualizowane, a ich zawartość może być edytowana zarówno ręcznie, jak i z poziomu Test Explorer.

Wersja 17.6 Visual Studio wprowadziła również nową funkcję „all-in-one search”, która pozwala na szybkie wyszukiwanie różnych opcji i funkcji w IDE, w tym Test Explorer. Dzięki tej funkcjonalności deweloperzy mogą szybciej odnaleźć interesujące ich opcje bez konieczności przeszukiwania menu.

IntelliTest jest dostępny w wersji Enterprise Visual Studio i jest obecnie w wersji podglądowej w Visual Studio 17.9. Dzięki niemu możliwe jest generowanie testów dla każdej metody, co zapewnia pełne pokrycie kodu oraz potwierdzenie poprawności jego działania.

Oprócz wspomnianych funkcji, warto również zwrócić uwagę na korzyści płynące z regularnego stosowania testów jednostkowych w procesie rozwoju oprogramowania. Testowanie jednostkowe pozwala na wcześniejsze wykrywanie błędów, co w konsekwencji prowadzi do szybszego i bardziej niezawodnego dostarczania oprogramowania. Regularne testowanie kodu zapewnia również większą pewność, że wprowadzane zmiany nie wprowadzą nowych problemów do istniejącego już kodu.

Podstawową zasadą testowania jednostkowego jest jego integralność z procesem programowania. Testy powinny być pisane równolegle z kodem produkcyjnym, aby maksymalizować ich wartość w kontekście ciągłej weryfikacji poprawności oprogramowania.