NBuilder .NET (Cómo funciona para desarrolladores)

NBuilder es unbiblioteca .NET simplificar la generación de datos de prueba. Los desarrolladores pueden crear complejos gráficos de objetos sin esfuerzo gracias a su fluida interfaz. Ofrece flexibilidad, eficacia y una integración perfecta con los marcos de pruebas más conocidos. En este artículo, exploraremos las características de NBuilder, cómo instalarlo y demostraremos sus capacidades con ejemplos prácticos de código.

Características de NBuilder

1. NBuilder es una biblioteca .NET de código abierto en C# diseñada para simplificar la creación de objetos con fines de prueba y simulación. Permite a los desarrolladores generar rápidamente objetos con entradas predeterminadas o especificadas a medida en función de distintos tipos de datos.

2. Es especialmente útil para pruebas unitarias, pruebas funcionales y pruebas de integración.

3. Es uno de los paquetes esenciales para probar tipos de datos .NET incorporados y objetos complejos.

4. Se utiliza para generar datos aleatorios. Puedes contribuir a este proyecto de código abierto.

5. Con NBuilder, puede anular sin esfuerzo las propiedades predeterminadas y escribir configuraciones personalizadas.

Instalación de NBuilder

Para instalar NBuilder en la consola de NuGet Package Manager, utilice el siguiente comando.

Install-Package Nbuilder

Install-Package Nbuilder

IRON VB CONVERTER ERROR developers@ironsoftware.com

El comando anterior instalará NBuilder con todas sus dependencias.

Utilización de NBuilder

NBuilder proporciona una forma fluida de crear objetos sobre la marcha. Empecemos con un ejemplo sencillo de creación de un objeto.

Aquí está el código fuente de la Clase Modelo Persona.

class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public bool IsMarried { get; set; }
    }

class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public bool IsMarried { get; set; }
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ejemplo 1: Creación de un objeto Persona con valores por defecto

var person = Builder<Person>
                .CreateNew()
                .Build();
// person = { Id = 1, Name = Name1, Email = Email1 , IsMarried  = false }

var person = Builder<Person>
                .CreateNew()
                .Build();
// person = { Id = 1, Name = Name1, Email = Email1 , IsMarried  = false }

IRON VB CONVERTER ERROR developers@ironsoftware.com

Imagen de muestra

Ejemplo 2: Creación de objetos con un generador personalizado

A continuación se muestra un ejemplo de cómo utilizar NBuilder para crear y configurar un objeto Persona con propiedades personalizadas:

var customPersonBuilder = Builder<Person>.CreateNew()
                .With(p => p.Name = "Tom")
                .With(p => p.Email = "Tom@email.com");
var objTom = customPersonBuilder.Build();

var customPersonBuilder = Builder<Person>.CreateNew()
                .With(p => p.Name = "Tom")
                .With(p => p.Email = "Tom@email.com");
var objTom = customPersonBuilder.Build();

Dim customPersonBuilder = Builder(Of Person).CreateNew().With(Sub(p) p.Name = "Tom").With(Sub(p) p.Email = "Tom@email.com")
Dim objTom = customPersonBuilder.Build()

El código anterior crea un nuevo objeto Persona con propiedades personalizadas. Inicializa un customPersonBuilder para un objeto Persona, estableciendo el Nombre como "Tom" y el Email como "Tom@email.com". Finalmente, construye el objeto y lo asigna a objTom.

Ejemplo 3: Creación de una lista de objetos persona con valor por defecto

var personList = Builder<Person>
                                     .CreateListOfSize(10)
                                     .Build();

var personList = Builder<Person>
                                     .CreateListOfSize(10)
                                     .Build();

IRON VB CONVERTER ERROR developers@ironsoftware.com

Imagen de muestra

Aquí personList tiene 10 objetos con sus valores por defecto y los imprime.

var personList = Builder<Person>
                                            .CreateListOfSize(10)
                                            .Build();
// Here it creates the 10 objects of Person in personList
foreach (var person in personList)
{
    Console.WriteLine($"{person.Id}, {person.Name}, {person.Email}, {person.IsMarried}, ");
}

var personList = Builder<Person>
                                            .CreateListOfSize(10)
                                            .Build();
// Here it creates the 10 objects of Person in personList
foreach (var person in personList)
{
    Console.WriteLine($"{person.Id}, {person.Name}, {person.Email}, {person.IsMarried}, ");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ejemplo 4: Personalización de objetos generados

A veces puede ser necesario personalizar los objetos que se crean. También puede personalizar el valor de un objeto utilizando la función with() método.

var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = "Kim")
                .With(p => p.Email = "abc@email.com")
                .With(p => p.IsMarried = false)
                .Build();
// Output:  
//    Id:  1, Name: Name1, Email: Email1, IsMarried False,
//    Id : 2, Name: Name2, Email: Email2, IsMarried True,
//    Id : 3, Name: Name3, Email: Email3, IsMarried False,
//    Id : 4, Name: Name4, Email: Email4, IsMarried True,
//    Id : 5, Name: Name5, Email: Email5, IsMarried False,
//    Id : 6, Name: Name6, Email: Email6, IsMarried True,
//    Id : 7, Name: Name7, Email: Email7, IsMarried False,
//    Id : 8, Name: Name8, Email: Email8, IsMarried True,
//    Id : 9, Name: Name9, Email: Email9, IsMarried False,
//    Id : 10, Name: Name10, Email: Email10, IsMarried True,

var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = "Kim")
                .With(p => p.Email = "abc@email.com")
                .With(p => p.IsMarried = false)
                .Build();
// Output:  
//    Id:  1, Name: Name1, Email: Email1, IsMarried False,
//    Id : 2, Name: Name2, Email: Email2, IsMarried True,
//    Id : 3, Name: Name3, Email: Email3, IsMarried False,
//    Id : 4, Name: Name4, Email: Email4, IsMarried True,
//    Id : 5, Name: Name5, Email: Email5, IsMarried False,
//    Id : 6, Name: Name6, Email: Email6, IsMarried True,
//    Id : 7, Name: Name7, Email: Email7, IsMarried False,
//    Id : 8, Name: Name8, Email: Email8, IsMarried True,
//    Id : 9, Name: Name9, Email: Email9, IsMarried False,
//    Id : 10, Name: Name10, Email: Email10, IsMarried True,

Dim personList = Builder(Of Person) .CreateListOfSize(10).All().With(Sub(p) p.Name = "Kim").With(Sub(p) p.Email = "abc@email.com").With(Sub(p) p.IsMarried = False).Build()
' Output:  
'    Id:  1, Name: Name1, Email: Email1, IsMarried False,
'    Id : 2, Name: Name2, Email: Email2, IsMarried True,
'    Id : 3, Name: Name3, Email: Email3, IsMarried False,
'    Id : 4, Name: Name4, Email: Email4, IsMarried True,
'    Id : 5, Name: Name5, Email: Email5, IsMarried False,
'    Id : 6, Name: Name6, Email: Email6, IsMarried True,
'    Id : 7, Name: Name7, Email: Email7, IsMarried False,
'    Id : 8, Name: Name8, Email: Email8, IsMarried True,
'    Id : 9, Name: Name9, Email: Email9, IsMarried False,
'    Id : 10, Name: Name10, Email: Email10, IsMarried True,

Esto crea un personList con su valor por defecto como Name = "Kim", Email = "abc@email.com", y IsMarried = false.

Ejemplo 5: Creación de una lista de objetos persona con datos aleatorios realistas

Para obtener valores de datos realistas en Person List, puede utilizar la biblioteca Faker Library .NET para obtener el valor real de los datos.

var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = Faker.Name.FullName())
                .With(p => p.Id = Faker.RandomNumber.Next(20, 60))
                .Build();

var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = Faker.Name.FullName())
                .With(p => p.Id = Faker.RandomNumber.Next(20, 60))
                .Build();

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ejemplo 6: Creación de una lista de objetos persona con datos secuenciales

Hay ocasiones en las que puede ser necesario generar objetos con datos secuenciales. NBuilder .NET facilita esto utilizando el método Do.

var personList = Builder<Person>.CreateListOfSize(10)
                .All()
                .Do((p, i) => p.Id = 501 + i)
                .Do((p, i) => p.Name = $"Person {i + 1}")
                .Build();

var personList = Builder<Person>.CreateListOfSize(10)
                .All()
                .Do((p, i) => p.Id = 501 + i)
                .Do((p, i) => p.Name = $"Person {i + 1}")
                .Build();

IRON VB CONVERTER ERROR developers@ironsoftware.com

En este caso, el traductor de All() el método se aplica a las operaciones posteriores a los 10 objetos persona y crea una lista en la memoria. El Do() se utiliza para ejecutar la Acción Delegada en cada objeto Persona.

En este caso, establece la propiedad Id de cada persona especificada por 501. Las expresiones lambda(p, i) toman dos parámetros: p es la persona e i es el índice de ese objeto concreto en la lista que va de(0 a 9) ya que la lista tiene 10 objetos respectivamente. Al añadir el valor i en la propiedad Id, las propiedades se establecen secuencialmente de 501 a 510, y la propiedad Name se establecerá de Persona 1 a Persona 10.

Ejemplo 7: NBuilder con pruebas unitarias mediante Xunit

NBuilder en .NET se utiliza significativamente en entornos de pruebas, donde los desarrolladores necesitan generar un conjunto realista y diverso de datos para las pruebas. Hace que las pruebas sean fáciles y mantenibles con objetos complejos que permiten a los desarrolladores definir una lógica de inicialización personalizada mediante expresiones lambda y funciones delegadas que satisfacen a los interesados en una generación de datos de prueba eficiente y flexible.

Clase modelo y servicio para pruebas unitarias

class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public bool IsMarried { get; set; }
    }
class PersonService
    {
        public string GetPersonEmail(Person person)
        {
            return person.Email;
        }
    }

class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public bool IsMarried { get; set; }
    }
class PersonService
    {
        public string GetPersonEmail(Person person)
        {
            return person.Email;
        }
    }

Friend Class Person
		Public Property Id() As Integer
		Public Property Name() As String
		Public Property Email() As String
		Public Property IsMarried() As Boolean
End Class
Friend Class PersonService
		Public Function GetPersonEmail(ByVal person As Person) As String
			Return person.Email
		End Function
End Class

Aquí, la clase Persona tiene las siguientes propiedades, y PersonService sólo tiene un método público GetPersonEmail() que devuelve el correo electrónico de Persona de ese objeto en particular.

Clases de prueba y datos de prueba

public class PersonTests
{
     [Fact]
     public void GetPersonEmail_ReturnCorrectEmail()
     {
         // Arrange
         var service = new PersonService();
         string expectedEmail = "Tom@email.com";
         var person = Builder<Person>.CreateNew()
             .With(p => p.Name = "Tom")
             .With(p => p.Email "Tom@email.com")
             .Build();
         // Act
         var actualEmail = service.GetPersonEmailById(person);
         // Assert
         Assert.Equal(actualEmail, expectedEmail);
     }
}

public class PersonTests
{
     [Fact]
     public void GetPersonEmail_ReturnCorrectEmail()
     {
         // Arrange
         var service = new PersonService();
         string expectedEmail = "Tom@email.com";
         var person = Builder<Person>.CreateNew()
             .With(p => p.Name = "Tom")
             .With(p => p.Email "Tom@email.com")
             .Build();
         // Act
         var actualEmail = service.GetPersonEmailById(person);
         // Assert
         Assert.Equal(actualEmail, expectedEmail);
     }
}

Public Class PersonTests
	 <Fact>
	 Public Sub GetPersonEmail_ReturnCorrectEmail()
		 ' Arrange
		 Dim service = New PersonService()
		 Dim expectedEmail As String = "Tom@email.com"
		 Dim person = Builder(Of Person).CreateNew().With(Sub(p) p.Name = "Tom").With(Function(p) p.Email "Tom@email.com").Build()
		 ' Act
		 Dim actualEmail = service.GetPersonEmailById(person)
		 ' Assert
		 Assert.Equal(actualEmail, expectedEmail)
	 End Sub
End Class

Esta prueba unitaria verifica que el método GetPersonEmailById de la clase PersonService devuelve correctamente la dirección de correo electrónico de un objeto Person con el correo electrónico esperado "Tom@email.com". Utiliza el patrón Arrange-Act-Assert para configurar los datos de prueba, ejecutar el método y, a continuación, comprobar que el resultado real coincide con el resultado esperado.

Integración de NBuilder con IronPDF

Más información sobre IronPDF es una potente biblioteca de C# diseñada paracrear PDF a partir de HTML dentro de las aplicaciones .NET. Gracias a su intuitiva API, los desarrolladores pueden integrar a la perfección la funcionalidad PDF en sus proyectos, ya se trate de generar facturas, informes o formularios interactivos.

Instalación de IronPDF

Abra la consola de NuGet Package Manager y ejecute el siguiente comando:

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Rellenar la lista de 5 objetos Persona

// Generating instances of the Person class with NBuilder
var people = Builder<Person>.CreateListOfSize(5).Build();

// Generating instances of the Person class with NBuilder
var people = Builder<Person>.CreateListOfSize(5).Build();

' Generating instances of the Person class with NBuilder
Dim people = Builder(Of Person).CreateListOfSize(5).Build()

Creación de documentos PDF con IronPDF

Este código establece la clave de licencia de IronPDF y genera contenido HTML a partir de una lista de objetos Persona.

IronPdf.License.LicenseKey = "Your-License-Key";
var htmlContent = "<h1>Person List</h1>";
foreach (var person in people)
{
    htmlContent += $"<p>Id: {person.Id}, Name: {person.Name}, Email: {person.Email}, IsMarried: {person.IsMarried}</p>";
}

IronPdf.License.LicenseKey = "Your-License-Key";
var htmlContent = "<h1>Person List</h1>";
foreach (var person in people)
{
    htmlContent += $"<p>Id: {person.Id}, Name: {person.Name}, Email: {person.Email}, IsMarried: {person.IsMarried}</p>";
}

IronPdf.License.LicenseKey = "Your-License-Key"
Dim htmlContent = "<h1>Person List</h1>"
For Each person In people
	htmlContent &= $"<p>Id: {person.Id}, Name: {person.Name}, Email: {person.Email}, IsMarried: {person.IsMarried}</p>"
Next person

IronPDF.License.LicenseKey se establece con una clave de licencia específica para habilitar las funciones de IronPDF.

El contenido HTML se construye dinámicamente iterando sobre la lista de personas, añadiendo los detalles de cada objeto Persona(Id, Nombre, Email, IsMarried) en la estructura HTML.

Renderización de la lista de personas en un documento PDF mediante IronPDF

Este código convierte el contenido HTML en un documento PDF utilizando el ChromePdfRenderer de IronPDF.

var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf(htmlContent);
pdfDoc.SaveAs("PersonList.pdf");

var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf(htmlContent);
pdfDoc.SaveAs("PersonList.pdf");

Dim renderer = New ChromePdfRenderer()
Dim pdfDoc = renderer.RenderHtmlAsPdf(htmlContent)
pdfDoc.SaveAs("PersonList.pdf")

ChromePdfRenderer es instanciado para renderizar el contenido HTML almacenado en htmlContent en un documento PDF. El documento PDF resultante se guarda en el sistema de archivos con el nombre "PersonList.pdf".

Salida

A continuación se muestra la lista de personas generada por IronPDF. Contiene cinco personas, cada una con valores por defecto.

Conclusión

En conclusión, NBuilder es una herramienta sólida y flexible para generar datos de prueba en .NET, agilizar la creación de gráficos de objetos complejos y mejorar la eficacia de los procesos de prueba. Al integrarse con IronPDF, los desarrolladores pueden ampliar fácilmente sus aplicaciones para incluirCapacidad de generación de PDF para quienes lo consideren valioso para sus proyectos. Juntos, NBuilder e IronPDF pueden mejorar significativamente los flujos de trabajo de desarrollo, haciendo que las pruebas y la generación de documentos sean fluidas y eficientes.