DEV Community: Nguyễn Tiến Dũng

End to end testing concept

Nguyễn Tiến Dũng — Sun, 04 Jun 2023 23:23:16 +0000

End-to-end test là loại test toàn diện nhất, nó kiểm tra hệ thống từ đầu đến cuối, bao gồm tất cả các thành phần liên quan.

Nó có các đặc điểm chính sau:

Kiểm tra toàn bộ quy trình hoạt động của hệ thống từ đầu đến cuối. Từ giao diện người dùng đến cơ sở dữ liệu.

Sử dụng các trình duyệt hoặc ứng dụng thực sự để thực hiện các bước trong quy trình.

Đòi hỏi phải khởi chạy toàn bộ môi trường hệ thống như ứng dụng, API, cơ sở dữ liệu.

Có thể phát hiện các vấn đề liên quan đến tích hợp giữa các thành phần khác nhau.

Ví dụ:

Người dùng truy cập vào trang web thông qua trình duyệt, tương tác với giao diện người dùng

Trang web gọi API và API gọi cơ sở dữ liệu

Kiểm tra liệu kết quả trả về có đúng với kỳ vọng hay không.

Như vậy, end-to-end test bao gồm toàn bộ quá trình tương tác của người dùng cuối với hệ thống, giúp đảm bảo tính toàn diện và tích hợp chính xác giữa các thành phần. Tuy nhiên, nó cũng tốn nhiều thời gian để thực hiện so với các loại test khác.

End-to-end test thường được thực hiện cuối cùng để kiểm tra toàn bộ hệ thống hoạt động như mong đợi.

Test Driven Development Concept

Nguyễn Tiến Dũng — Sun, 04 Jun 2023 23:20:28 +0000

1.Viết test case trước (test-first): Đặt ra các giả thuyết cho chức năng cần hoàn thành và viết các test case dựa trên đó.

2.Chạy test case: Chạy các test case và chúng sẽ fail do chưa có code thực hiện.

3.Viết code để làm test case pass: Viết code càng đơn giản nhất để làm test case pass, sau đó chạy lại test để đảm bảo đúng yêu cầu.

4.Refactor code nếu cần: Sửa code để tối ưu hóa, rồi chạy lại test case đảm bảo vẫn đúng.

Qua đó TDD giúp có bộ khung test chi tiết trước khi viết code, đảm bảo chất lượng và tính bền vững cho phần mềm.

Vậy là TDD là phương pháp phát triển phần mềm bằng cách viết test case trước rồi mới viết code thực hiện, quá trình lặp đi lặp lại để tối ưu hóa code.

Ví dụ:

public class Calculator
{
    public int Add(int x, int y) { ... }
}

Test-First:

[TestClass]
public class CalculatorTests 
{
    [TestMethod]
    public void Add_TwoPositiveNumbers_ReturnsCorrectSum()
    {
        // Arrange
        var calculator = new Calculator();

        // Act
        var result = calculator.Add(2, 3);  

        // Assert
        Assert.AreEqual(5, result);
    }
}

Còn nếu code fail thì sẽ không thực hiện đoạn Add()
Chạy Test-Case nếu chúng pass sẽ thực hiện đoạn Add()

public int Add(int x, int y) 
{
    return x + y;  
}

Refactor code nếu code vẫn chạy pass:

public int Add(int x, int y)
{
    return CalculateSum(x, y);
}

rivate int CalculateSum(int x, int y)
{
    return x + y;
}

Mình có thể viết nhiều đoạn code hơn cho đoạn test:

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

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

Integration testing concept

Nguyễn Tiến Dũng — Sun, 04 Jun 2023 23:15:01 +0000

Integration testing là một loại test nhằm đảm bảo rằng các thành phần, module của phần mềm hoạt động đúng cách khi được tích hợp với nhau.

Trong khi unit test tập trung vào từng đơn vị code riêng lẻ, integration test tập trung vào việc tích hợp nhiều đơn vị lại với nhau.

Cụ thể:

Integration test kiểm tra sự tương tác giữa các module/component khác nhau.

Nó liên quan đến tích hợp các phần phần mềm với nhau, ví dụ API với ứng dụng, ứng dụng với cơ sở dữ liệu,...

Việc integration test được thực hiện sau khi unit test các thành phần riêng lẻ.

Nó giúp phát hiện các vấn đề tương tác giữa các thành phần khi được tích hợp với nhau.

Test việc tích hợp API với ứng dụng để kiểm tra liệu ứng dụng có gọi đúng API và xử lý dữ liệu từ API một cách chính xác.

Test ứng dụng với cơ sở dữ liệu để đảm bảo việc truy vấn, cập nhật dữ liệu được thực hiện đúng.

Nói tóm lại, integration test là kiểm tra sự tương tác giữa các thành phần đã được unit test để đảm bảo chúng hoạt động đúng khi tích hợp với nhau.

Ví dụ:

[TestClass]
public class ApiIntegrationTest 
{
    [TestMethod]   
    public void GetData_CheckResult()
    {
        // Gọi API
        var apiResult = Api.GetData();

        // Gọi ứng dụng xử lý dữ liệu từ API         
        var result = App.ProcessData(apiResult);  

        // Kiểm tra kết quả
        Assert.AreEqual(expectedResult, result);    
    }
}

Ở đây tương tự:

Chúng ta gọi API bằng Api.GetData()

Gọi ứng dụng xử lý dữ liệu từ API bằng App.ProcessData(apiResult)

Cuối cùng assert kết quả trả về với kết quả mong đợi.

Đây là một đoạn integration test đơn giản để kiểm tra sự tương tác giữa API và ứng dụng bằng C# .NET.

Những điểm chính khi viết integration test:

Khởi tạo dữ liệu mock nếu cần để test

Gọi các component cần test tương tác với nhau

Kiểm tra kết quả trả về

Ưu tiên dùng database in-memory để test nhanh hơn.

Các loại test này rất quan trọng để đảm bảo mọi thứ hoạt động đúng đắn khi được tích hợp.

Unit testing concept

Nguyễn Tiến Dũng — Sun, 04 Jun 2023 23:07:48 +0000

Unit test là một loại test cụ thể được sử dụng trong TDD.

Unit test là test mỗi đơn vị/module riêng biệt của code như một class, function hoặc method.

Nó được dùng để:

Kiểm tra hàm/phương thức đó hoạt động đúng như mong đợi.

Tìm ra các lỗi ngay từ ban đầu trong quá trình phát triển code.

Giúp bảo trì và mở rộng code dễ dàng hơn bằng cách chạy các unit test khi có sự thay đổi xảy ra.

Ví dụ đoạn code dưới đây:

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTestProject1
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            // Arrange
            var calculator = new Calculator();

            // Act
            var result = calculator.Add(2, 3); 

            // Assert 
            Assert.AreEqual(5, result);
        }
    }
}

Giải thích:

TestClass: Đánh dấu lớp chứa các unit test.

TestMethod: Đánh dấu phương thức là một unit test.

Arrange: Chuẩn bị dữ liệu cần thiết.

Act: Thực hiện hành động cần test.

Assert: Kiểm tra kết quả có đúng như mong đợi hay không.

MVVM In C# .NET

Nguyễn Tiến Dũng — Tue, 11 Apr 2023 09:30:42 +0000

MVVM (Model-View-ViewModel) is a design pattern used in the development of user interfaces, particularly in the context of WPF (Windows Presentation Foundation) and Silverlight applications in C# .NET. It helps separate concerns between the user interface (View), the data (Model), and the application logic (ViewModel).

Here's a brief overview of the MVVM components:

Model: This represents the data and business logic of the application. It provides data to the ViewModel.

View: This represents the user interface (UI) of the application. It binds to the ViewModel to display data and to trigger events.

ViewModel: This acts as a mediator between the View and the Model. It provides data to the View by interacting with the Model and exposes methods and commands for the View to interact with the Model.

Here are some key concepts to understand in MVVM:

Data Binding: This is the mechanism by which data is automatically synchronized between the View and the ViewModel. It is accomplished using data binding expressions in XAML.

Commands: Commands allow the View to trigger actions in the ViewModel, without requiring knowledge of how the ViewModel performs those actions.

Dependency Injection: This is a technique used to inject dependencies (such as data services) into the ViewModel, allowing it to be more modular and testable.

Unit Testing: By separating the concerns of the application, MVVM makes it easier to write unit tests for the ViewModel and Model components.

Overall, MVVM is a powerful pattern that helps make C# .NET applications more modular, testable, and maintainable.

Model:

public class CustomerModel
{
    public string Name { get; set; }
    public string Address { get; set; }
}

ViewModel:

public class CustomerViewModel : INotifyPropertyChanged
{
    private CustomerModel _customer;

    public CustomerViewModel()
    {
        _customer = new CustomerModel();
    }

    public string Name
    {
        get { return _customer.Name; }
        set
        {
            _customer.Name = value;
            OnPropertyChanged(nameof(Name));
        }
    }

    public string Address
    {
        get { return _customer.Address; }
        set
        {
            _customer.Address = value;
            OnPropertyChanged(nameof(Address));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

View (XAML):

<Window x:Class="MyApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:vm="clr-namespace:MyApp.ViewModels"
        Title="MainWindow" Height="450" Width="800">
    <Window.DataContext>
        <vm:CustomerViewModel />
    </Window.DataContext>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition Width="*" />
        </Grid.ColumnDefinitions>
        <Label Grid.Row="0" Grid.Column="0" Content="Name:" />
        <TextBox Grid.Row="0" Grid.Column="1" Text="{Binding Name}" />
        <Label Grid.Row="1" Grid.Column="0" Content="Address:" />
        <TextBox Grid.Row="1" Grid.Column="1" Text="{Binding Address}" />
        <Button Grid.Row="2" Grid.Column="1" Content="Save" Command="{Binding SaveCommand}" />
    </Grid>
</Window>

In this example, the CustomerModel class represents the data, the CustomerViewModel class represents the logic, and the XAML View represents the UI. The DataContext property of the Window is set to an instance of the CustomerViewModel class, which provides the data and behavior for the View. Data binding expressions are used to synchronize data between the ViewModel and the View, and the SaveCommand property on the ViewModel exposes a command that the View can use to trigger an action.

MVC Architecture in .NET App

Nguyễn Tiến Dũng — Mon, 27 Mar 2023 04:33:23 +0000

Hey Hello, In this article series I’m going to cover the following areas in the Web development with C#, ASP .NET Core MVC, MVVM Tech Stack.

ASP .NET Core
Razor Pages and Blazor
MVC Architecture
MVVM Architecture
Models, ViewModels, Views, Partial views, Controllers, ViewComponents
Dependency injection, Major dependency injection lifetimes, Services
SQL Server configuration, EFCore migrations, Relationship types
Authentication, Authorization, Cookie-based Authentication
Azure Deployment

So, In this section, we will talk about MVC architecture at a high level.

What is MVC mean?
The Model-View-Controller (MVC) is an architectural design pattern that divides a software application/system into three main logical components,

The model
The view
The controller
Each of these components is made to control and manage specific development domains in an application.

MVC is one of the most frequently used industry-standard web development frameworks to create scalable and extensible projects.

Model
In basic C# ASP .NET Core Web applications, it acts as a C# class which holds application data as a Data Blueprint. It also manages the Database operations and relations.

Ex: Buyer, Seller, Admin User, Categories Classes in e-commerce Applications

So Basically, The Model component corresponds to all the data-related logic that the user works with.

View
The view is a component that displays the user interface. In C#, It’s the CSHTML file (Razor Views). This handles the app's data presentation and user interaction

In view, you can trigger/notify the events that get handled by the controllers.

Controller
A controller controls the workflow that a user interacts with MVC application*.* A controller contains the flow control logic for an ASP.NET MVC application. A controller determines what response to send back to a user when a user makes a browser request.