Testear endpoints en go con echo

Supongamos que tenemos unos endpoints hechos con echo:

package handler

import (

    "net/http"

    "github.com/labstack/echo/v4"

)

type (

    User struct {

        Name  string `json:"name" form:"name"`

        Email string `json:"email" form:"email"`

    }

    handler struct {

        db map[string]*User

    }

)

func (h *handler) createUser(c echo.Context) error {

    u := new(User)

    if err := c.Bind(u); err != nil {

        return err

    }

    return c.JSON(http.StatusCreated, u)

}

func (h *handler) getUser(c echo.Context) error {

    email := c.Param("email")

    user := h.db[email]

    if user == nil {

        return echo.NewHTTPError(http.StatusNotFound, "user not found")

    }

    return c.JSON(http.StatusOK, user)

}

Lo que queremos hacer es un test de unidad que testee este comportamiento, y podemos hacerlo así: 

package handler

import (

    "net/http"

    "net/http/httptest"

    "strings"

    "testing"

    "github.com/labstack/echo/v4"

    "github.com/stretchr/testify/assert"

)

var (

    mockDB = map[string]*User{

        "jon@labstack.com": &User{"Jon Snow", "jon@labstack.com"},

    }

    userJSON = `{"name":"Jon Snow","email":"jon@labstack.com"}`

)

func TestCreateUser(t *testing.T) {

    // Setup

    e := echo.New()

    req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(userJSON))

    req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)

    rec := httptest.NewRecorder()

    c := e.NewContext(req, rec)

    h := &handler{mockDB}

    // Assertions

    if assert.NoError(t, h.createUser(c)) {

        assert.Equal(t, http.StatusCreated, rec.Code)

        assert.Equal(t, userJSON, rec.Body.String())

    }

}

func TestGetUser(t *testing.T) {

    // Setup

    e := echo.New()

    req := httptest.NewRequest(http.MethodGet, "/", nil)

    rec := httptest.NewRecorder()

    c := e.NewContext(req, rec)

    c.SetPath("/users/:email")

    c.SetParamNames("email")

    c.SetParamValues("jon@labstack.com")

    h := &handler{mockDB}

    // Assertions

    if assert.NoError(t, h.getUser(c)) {

        assert.Equal(t, http.StatusOK, rec.Code)

        assert.Equal(t, userJSON, rec.Body.String())

    }

}

Y listo!! 

Dejo link: https://echo.labstack.com/docs/testing

Unir dos listas en lisp

Vamos a unir dos listas en Lisp. Si la primera lista es vacia, retornamos la otra lista y si no lo es, costruimos una nueva lista con el primer elemento de la primera lista y la union del resto de la primera lista (porque al primero ya lo sacamos) con la otra lista. 

(defun unir (lista1 lista2) 

  (cond 

    ((null lista1) lista2)

    (T (cons (first lista1) (unir (rest lista1) lista2)))

  )

)

Si probamos : 

> (unir '(1 2 3) '(4 5 6))

(1 2 3 4 5 6)

> (unir '(1 2 3) '(4))

(1 2 3 4)

Sobrecarga de operadores por medio de traits en Rust

 La sobrecarga del operador se implementa mediante rasgos en std::ops:

#[derive(Debug, Copy, Clone)]

struct Point { x: i32, y: i32 }

impl std::ops::Add for Point {

    type Output = Self;

    fn add(self, other: Self) -> Self {

        Self {x: self.x + other.x, y: self.y + other.y}

    }

}

fn main() {

    let p1 = Point { x: 10, y: 20 };

    let p2 = Point { x: 100, y: 200 };

    println!("{:?} + {:?} = {:?}", p1, p2, p1 + p2);

}

Si lo ejecutamos : 

cargo run main.rs

   Compiling hello_cargo v0.1.0 

    Finished dev [unoptimized + debuginfo] target(s) in 0.58s

     Running `target/debug/hello_cargo main.rs`

Point { x: 10, y: 20 } + Point { x: 100, y: 200 } = Point { x: 110, y: 220 }

Podrías implementar Add para &Point. Si el tipo T para el cual está sobrecargando el operador no implementa Copy, debería considerar sobrecargar también el operador para &T. Esto evita clonaciones innecesarias.

Se podría implementar Add para dos tipos diferentes, p. impl Add<(i32, i32)> for Point agregaría una tupla a un Point.

Sería así :

impl std::ops::Add<(i32, i32)>  for Point {

    type Output = Self;

    fn add(self, other: (i32, i32)) -> Self {

        Self {x: self.x + other.0, y: self.y + other.1}

    }

}

fn main() {

    let p1 = Point { x: 10, y: 20 };

    let tuple= (100, 200);

    println!("{:?} + {:?} = {:?}", p1, tuple, p1 + tuple);

}

Y la salida va a ser : 

Point { x: 10, y: 20 } + (100, 200) = Point { x: 110, y: 220 }

Buscando el mayor y el menor en lisp

Ahora lo que vamos a hacer es buscar el menor o el mayor de una lista. El algoritmo es similar, por lo tanto vamos a utilizar una función general que busque según una función y luego escribimos el mayor o menor pasando un lambda que busque eso (con eso me refiero al menor o al mayor) : 

(defun buscar (lista fx)

  (cond

    ((null (rest lista)) (first lista))

    ((funcall fx (first lista) (buscar (rest lista) fx)) (first lista))

    (T (buscar (rest lista) fx))

  )

)

(defun menor (lista)

  (buscar lista (lambda (a b) (< a b)))

)

(defun mayor (lista)

  (buscar lista (lambda (a b) (> a b)))

)

El algoritmo buscar lo que hace es si la lista tiene un solo elemento, ya esta ese es el menor o el mayor. Si no compara el primero con el buscar del resto, por ejemplo para el menor, compara el primero con el menor del resto, si es verdadero ese es el menor y si no el menor es el menor del resto. 

Y listo! 

Comenten si quieren más algoritmos así. 

Quicksort in lisp

Un Algoritmo que me gusta mucho es el quicksort, porque es un algoritmo por demás claro. Ya he escrito lo fácil que es implementarlo en haskell 

Ahora le toca a lisp. Básicamente el algoritmo toma un pivot y agrupa los menores del pivot al principio y los mayores al final y aplica quicksort a estos 2 grupos. Y si la lista es vacia, ya esta ordenada. 

Vamos al código: 

(defun qso (l) 

   (cond 

     ((null l) l)

     (T (append 

         (qso (remove-if (lambda (a) (> a (first l))) (rest l)))

         (cons 

           (first l)

           (qso (remove-if (lambda (a) (<= a (first l))) (rest l)))

         )

        )

     )

   )

)

El Trait Default

 

El Trait Default produce un valor predeterminado para un tipo.

#[derive(Debug, Default)]

struct Derived {

    x: u32,

    y: String,

    z: Implemented,

}

#[derive(Debug)]

struct Implemented(String);

impl Default for Implemented {

    fn default() -> Self {

        Self("John Smith".into())

    }

}

fn main() {

    let default_struct = Derived::default();

    println!("{default_struct:#?}");

    let almost_default_struct = Derived {

        y: "Y is set!".into(),

        ..Derived::default()

    };

    println!("{almost_default_struct:#?}");

    let nothing: Option<Derived> = None;

    println!("{:#?}", nothing.unwrap_or_default());

}

• Se puede implementar directamente o se puede derivar mediante #[derive(Default)].
• Una implementación derive producirá un valor en el que todos los campos se establecerán en sus valores por defecto.
• Esto significa que todos los tipos de la estructura también deben implementar Default.
• Los tipos estándar de Rust a menudo implementan el valor predeterminado con valores razonables (por ejemplo, 0, "", etc.).
• La copia parcial de la estructura funciona bien de forma predeterminada.
• La biblioteca estándar de Rust es consciente de que los tipos pueden implementar el valor predeterminado y proporciona métodos convenientes para usarlo.
• la .. sintaxis se llama sintaxis de actualización de estructura

El Trait Drop en Rust

Los valores que implementan Drop pueden especificar el código que se ejecutará cuando salgan del alcance:

struct Droppable {

    name: &'static str,

}

impl Drop for Droppable {

    fn drop(&mut self) {

        println!("Dropping {}", self.name);

    }

}

fn main() {

    let a = Droppable { name: "a" };

    {

        let b = Droppable { name: "b" };

        {

            let c = Droppable { name: "c" };

            let d = Droppable { name: "d" };

            println!("Exiting block B");

        }

        println!("Exiting block A");

    }

    drop(a);

    println!("Exiting main");

}

Si ejecutamos esto tenemos: 

Exiting block B

Dropping d

Dropping c

Exiting block A

Dropping b

Dropping a

Exiting main

• Tenga en cuenta que std::mem::drop no es lo mismo que std::ops::Drop::drop.
• Los valores se eliminan automáticamente cuando salen del alcance.
• Cuando se elimina un valor, si implementa std::ops::Drop, se llamará a su implementación Drop::drop.
• Todos sus campos también se eliminarán, ya sea que implemente Drop o no.

std::mem::drop es solo una función vacía que toma cualquier valor. La importancia es que se apropia del valor, por lo que al final de su alcance se elimina. Esto lo convierte en una forma conveniente de eliminar valores explícitamente antes de que, de otro modo, saldrían del alcance.

Esto puede ser útil para objetos que realizan algún trabajo al soltarlos: liberar bloqueos, cerrar archivos, etc.

La función reduce en lisp

Vamos a hacer una función reduce o reducir en lisp. La función reduce nos permite acumular una lista de números por ejemplo o concatenar una lista de string. 

Es decir toma un valor inicial y va acumulando los valores que tiene una lista con una función que se pasa por parámetros. Veamos esto en lisp : 

(defun reducir(inicial lista fx) 

    (cond 

        ((Null lista) inicial)

        (T (reducir (Funcall fx inicial (first lista)) (rest lista) fx))

    )

) 

Si la lista esta vacía, retornamos el acumulador. Si no volvemos a llamar a la función con el valor de la acumulación del primer elemento como valor inicial y el resto del la lista. 

Y podemos llamarlo de la siguiente manera: 

 > (reducir 0 '(1 2 3 4 5) (LAMBDA (a b) (+ a b))) 

15

> (reducir "" '("hola " "Mundo") (LAMBDA (a b) (concatenate 'string a b)))

"hola Mundo"

 > (reducir "" '("uno" "dos" "tres" "super tranquilo") (LAMBDA (a b) (concatenate 'string a " " b)))

" uno dos tres super tranquilo"

Read y Write en Rust

Usando Read y BufRead, nos podemos abstraer a un vector de u8

use std::io::{BufRead, BufReader, Read, Result};

fn count_lines<R: Read>(reader: R) -> usize {

    let buf_reader = BufReader::new(reader);

    buf_reader.lines().count()

}

fn main() -> Result<()> {

    let slice: &[u8] = b"foo\nbar\nbaz\n";

    println!("lines in slice: {}", count_lines(slice));

    let file = std::fs::File::open(std::env::current_exe()?)?;

    println!("lines in file: {}", count_lines(file));

    Ok(())

}

De manera similar, Write nos permite abstraernos de igual forma:

use std::io::{Result, Write};

fn log<W: Write>(writer: &mut W, msg: &str) -> Result<()> {

    writer.write_all(msg.as_bytes())?;

    writer.write_all("\n".as_bytes())

}

fn main() -> Result<()> {

    let mut buffer = Vec::new();

    log(&mut buffer, "Hello")?;

    log(&mut buffer, "World")?;

    println!("Logged: {:?}", buffer);

    Ok(())

}

Slices en golang

Los Slices envuelven matrices para brindar una interfaz más general, poderosa y conveniente para secuencias de datos. Excepto por elementos con dimensiones explícitas, como matrices de transformación, la mayor parte de la programación de matrices en Go se realiza con Slices en lugar de simples arrays.

Los Slices contienen referencias a una matriz subyacente y, si asigna un Slice a otro, ambos se refieren a la misma matriz. Si una función toma un argumento de tipo Slice, los cambios que realice en los elementos del segmento serán visibles para quien llama, de forma análoga a pasar un puntero a la matriz subyacente. Por lo tanto, una función de lectura puede aceptar un argumento de tipo Slice en lugar de un puntero y una dimensión; la longitud dentro del segmento establece un límite superior de la cantidad de datos que se leerán. Aquí está la firma del método de lectura del tipo de archivo en el paquete os:

func (f *File) Read(buf []byte) (n int, err error)

El método devuelve el número de bytes leídos y un valor de error, si lo hubiera. Para leer los primeros 32 bytes hacemos: 

  n, err := f.Read(buf[0:32])

Este Slice es común y eficiente. De hecho, dejando de lado la eficiencia por el momento, el siguiente fragmento también leería los primeros 32 bytes del búfer.

    var n int

    var err error

    for i := 0; i < 32; i++ {

        nbytes, e := f.Read(buf[i:i+1])  // Read one byte.

        n += nbytes

        if nbytes == 0 || e != nil {

            err = e

            break

        }

    }

La longitud de un segmento se puede cambiar siempre que todavía se ajuste dentro de los límites de la matriz subyacente; simplemente asígnalo a una Slice de sí mismo. La capacidad de un Slice es accesible mediante una función incorporada, informa la longitud máxima que puede asumir el segmento. Aquí hay una función para agregar datos a un slice. Si los datos exceden la capacidad, se reasigna el slice y se devuelve el slice resultante. La función utiliza el hecho de que len y cap son legales cuando se aplican a segmentos nulos y devuelven 0.

func Append(slice, data []byte) []byte {

    l := len(slice)

    if l + len(data) > cap(slice) {  // reallocate

        // Allocate double what's needed, for future growth.

        newSlice := make([]byte, (l+len(data))*2)

        // The copy function is predeclared and works for any slice type.

        copy(newSlice, slice)

        slice = newSlice

    }

    slice = slice[0:l+len(data)]

    copy(slice[l:], data)

    return slice

}

Debemos devolver el slice después porque, aunque Append puede modificar los elementos del slice, el slice en sí (la estructura de datos en tiempo de ejecución que contiene el puntero, la longitud y la capacidad) se pasa por valor.

La idea de agregar un elemento a un slice es tan util que tenemos una función para hacerlo:  append. Sin embargo, para comprender el diseño de esa función necesitamos un poco más de información, por lo que volveremos a ello más adelante.

Función map en lisp

Vamos a hacer una función transformar o map en lisp que lo que haga es tome una lista y una función y aplique esa función a cada elemento de la lista. 

Para esto vamos a analizar los casos si la lista esta vacía, ya esta retornamos la lista vacía. Si no esta vacía, creamos una nueva lista aplicando esa función al primer elemento y llamando de forma recursiva la función transformar para el resto. 

Sería así : 

(defun transformar (l fx)

   (cond 

      ((Null l) Nil)

      (T (cons (Funcall fx (first l)) 

           (transformar (rest l) fx)))

    )

) 

Y la podemos llamar de esta manera : 

> (transformar '(1 2 3) (LAMBDA (a) (* a 2)))

(2 4 6)

o

 > (transformar '(1 2 3) (LAMBDA (a) (+ a 1)))

(2 3 4)

From y Into de Rust

 Los tipos implementan From y Into facilitan las conversiones de tipos:

fn main() {

    let s = String::from("hello");

    let addr = std::net::Ipv4Addr::from([127, 0, 0, 1]);

    let one = i16::from(true);

    let bigger = i32::from(123i16);

    println!("{s}, {addr}, {one}, {bigger}");

}

Into se implementa automáticamente cuando se implementa From:

fn main() {

    let s: String = "hello".into();

    let addr: std::net::Ipv4Addr = [127, 0, 0, 1].into();

    let one: i16 = true.into();

    let bigger: i32 = 123i16.into();

    println!("{s}, {addr}, {one}, {bigger}");

}

Es por eso que es común implementar solo From.

Al declarar un tipo de entrada de argumento de función como "cualquier cosa que pueda convertirse en una cadena", la regla es la opuesta, debes usar Into. Su función aceptará tipos que implementen From y aquellos que solo implementen Into.

FromIterator de Rust

 

FromIterator te permite crear una colección a partir de un Iterador.

fn main() {

    let primes = vec![2, 3, 5, 7];

    let prime_squares = primes

        .into_iter()

        .map(|prime| prime * prime)

        .collect::<Vec<_>>();

    println!("prime_squares: {prime_squares:?}");

}

Iterator implementa fn collect<B>(self) -> B where B: FromIterator<Self::Item>, Self: Sized

También hay implementaciones que te permiten hacer cosas interesantes como convertir un Iterador<Item = Result<V, E>> en un Result<Vec<V>, E>.

Asignación de memoria con make en Go

La función make(T, args) tiene un propósito diferente al de new(T). Crea únicamente slices, maps, y channels y devuelve un valor inicializado (no puesto a cero) de tipo T (no *T). El motivo de la distinción es que estos tres tipos representan, encubiertamente, referencias a estructuras de datos que deben inicializarse antes de su uso. Un slice, por ejemplo, es un descriptor de tres elementos que contiene un puntero a los datos (dentro de un arreglo o vector), la longitud y la capacidad, y hasta que esos elementos se inicialicen, el slice es nulo. Para slices, map y chanels, make inicializa la estructura de datos interna y prepara el valor para su uso. Por ejemplo,

make([]int, 10, 100)

asigna una arreglo de entero de 100 elementos y luego crea una estructura slice con una longitud de 10 y una capacidad de 100 que apunta a los primeros 10 elementos de la matriz. (Al crear un slice, se puede omitir la capacidad). Por el contrario, new([]int) devuelve un puntero a una estructura de slice puesta a cero recién asignada, es decir, un puntero a un slice nulo.

Estos ejemplos ilustran la diferencia entre nuevo y fabricado.

var p *[]int = new([]int)       // allocates slice structure; *p == nil; rarely useful

var v  []int = make([]int, 100) // the slice v now refers to a new array of 100 ints

// Unnecessarily complex:

var p *[]int = new([]int)

*p = make([]int, 100, 100)

// Idiomatic:

v := make([]int, 100)

Recuerde que make se aplica solo a maps, slices y channels y no devuelve un puntero. Para obtener un puntero explícito, asigne nuevo o tome la dirección de una variable explícitamente.

Iterators en Rust

Puede implementar el trait Iterador en nuestros tipos :

struct Fibonacci {

    curr: u32,

    next: u32,

}

impl Iterator for Fibonacci {

    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {

        let new_next = self.curr + self.next;

        self.curr = self.next;

        self.next = new_next;

        Some(self.curr)

    }

}

fn main() {

    let fib = Fibonacci { curr: 0, next: 1 };

    for (i, n) in fib.enumerate().take(5) {

        println!("fib({i}): {n}");

    }

}

El trait Iterador implementa muchas operaciones de programación funcional comunes sobre colecciones (por ejemplo, map, filter, reduce, etc). En Rust, estas funciones deberían producir un código tan eficiente como las implementaciones imperativas equivalentes.

IntoIterator es el trait que hace que los bucles funcionen. Se implementa mediante tipos de colección como Vec<T> y referencias a ellos como &Vec<T> y &[T]. Ranges también lo implementan. Es por eso que puedes iterar sobre un vector con for i in some_vec { .. } pero some_vec.next() no existe.

Test en Go

Go ofrece soporte integrado para pruebas unitarias que hace que sea más fácil realizar pruebas sobre la marcha. Específicamente, utilizando las convenciones de nomenclatura, el paquete de pruebas de Go y el comando go test, puede escribir y ejecutar pruebas rápidamente.

Veamos un ejemplo, vamos a hacer un archivo greetings con el siguiente contenido : 

package greetings

import "fmt"

// Hello returns a greeting for the named person.

func Hello(name string) (message string) {

// Return a greeting that embeds the name in a message.

if name == "" {

message = "Hi!"

} else {

message = fmt.Sprintf("Hi, %v. Welcome!", name)

}

return message

}

En el directorio greetings, crearemos un archivo llamado greetings_test.go, que son las pruebas. Terminar el nombre de un archivo con _test.go le indica al comando go test que este archivo contiene test.

En Greetings_test.go, vamos a pegar el siguiente código y guardar el archivo.

package greetings

import (

"regexp"

"testing"

)

// TestHelloName calls greetings.Hello with a name, checking

// for a valid return value.

func TestHelloName(t *testing.T) {

name := "Gladys"

want := regexp.MustCompile(`\b` + name + `\b`)

msg := Hello("Gladys")

if !want.MatchString(msg) {

t.Fatalf(`Hello("Gladys") = %q, %v`, msg, want)

}

}

// TestHelloEmpty calls greetings.Hello with an empty string.

func TestHelloEmpty(t *testing.T) {

msg := Hello("")

if msg != "Hi!" {

t.Fatalf(`Hello("") = %q, want "Hi!"`, msg)

}

}

En este código, se puede ver que utilizamos el paquete "test" para hacer uso de función "Fatalf"  que indica que la función no pasa el test. 

Si ejecutamos go test en el directorio obtendremos : 

$ go test

PASS

ok      example.com/greetings   0.364s

$ go test -v

=== RUN   TestHelloName

--- PASS: TestHelloName (0.00s)

=== RUN   TestHelloEmpty

--- PASS: TestHelloEmpty (0.00s)

PASS

ok      example.com/greetings   0.372s

Y eso es todo! 

Dejo link : https://go.dev/doc/tutorial/add-a-test

Arrays en Go

Los arrays son útiles al planificar el diseño detallado de la memoria y, a veces, pueden ayudar a evitar la asignación, pero principalmente son un bloque de construcción para los slice.

Existen grandes diferencias entre la forma en que funcionan los arrys en Go y C. En Go,

• Los arrys son valores. Asignar un array a otra copia todos los elementos.
• En particular, si pasa una matriz a una función, recibirá una copia de la matriz, no un puntero a ella.
• El tamaño de una matriz es parte de su tipo. Los tipos [10]int y [20]int son distintos.

Estas propiedades puede ser útiles pero también costosa; Si desea un comportamiento y eficiencia similares a los de C, puede pasar un puntero a la matriz.

func Sum(a *[3]float64) (sum float64) {

    for _, v := range *a {

        sum += v

    }

    return

}

array := [...]float64{7.0, 8.5, 9.1}

x := Sum(&array)  // Note the explicit address-of operator

Pero este código no sigue el estilo Go, podemos hacer algo similar con Slice que veremos más adelante.