DEV Community: David Sánchez

Use 1Password SSH Agent in WSL

David Sánchez — Sun, 06 Nov 2022 22:20:14 +0000

TIL: You can use 1Password's SSH Agent in WSL, and it's not that complicated.

I've been using Windows + WSL as my main driver for a few weeks, and one of the things I missed the most was the ease of setup of the 1Password's SSH agent and Linux or macOS.

After searching for a while, I found one thread in the 1Password Community forum that linked to a post containing the steps to forward the SSH Agent requests from WSL to the Windows' SSH agent.

Amazingly, you don't have to do anything extra to make it work with 1Password SSH agent, and I'll write the steps I did to activate it below.

Enable 1Password SSH Agent

If you have not created or imported your SSH keys into 1Password, you can do it by following this article.

To activate 1Password's SSH agent, you must have Windows Hello activated. You can learn more about Windows Hello in this article.

Open your 1Password settings and go to the “Developer” section. You need to check the “Use the SSH agent” checkbox.

That's all we need to do to activate the SSH agent.

Download `npiperelay`

To communicate between WSL and the 1Password SSH agent, we'd need to use npiperelay. This tool allows WSL to communicate with Windows' named pipes.

To install it, we need to open the GitHub repository and download the latest release. At the time of writing this post, the latest release is v0.1.0 from July 2, 2020.

Unzip it, and paste the npiperelay.exe file in any folder that's configured in your system's PATH.

If you don't know how to modify your system's PATH, you can learn how to do it in this article.

Connect WSL with 1Password's SSH agent

Now that we have the prerequisites fulfilled, we can connect our WSL distro with the SSH agent.

I'm using Ubuntu as my WSL distro, this may change if you're using another distro.

We need to install socat which is a utility to transfer data between channels, this tool will use npiperelay to then communicate with the named pipes.

sudo apt install socat

In your WSL terminal, create a new folder named .1password in your home directory:

mkdir $HOME/.1password

Create a new file named .agent-bridge.sh in your home directory. You can name this file whatever you want, this naming was just a personal preference from me.

touch $HOME/.agent-bridge.sh && chmod +x $HOME/.agent-bridge.sh

And add the following content to the newly created file:

# Code extracted from https://stuartleeks.com/posts/wsl-ssh-key-forward-to-windows/ with minor modifications

# Configure ssh forwarding
export SSH_AUTH_SOCK=$HOME/.1password/agent.sock
# need `ps -ww` to get non-truncated command for matching
# use square brackets to generate a regex match for the process we want but that doesn't match the grep command running it!
ALREADY_RUNNING=$(ps -auxww | grep -q "[n]piperelay.exe -ei -s //./pipe/openssh-ssh-agent"; echo $?)
if [[ $ALREADY_RUNNING != "0" ]]; then
    if [[ -S $SSH_AUTH_SOCK ]]; then
        # not expecting the socket to exist as the forwarding command isn't running (http://www.tldp.org/LDP/abs/html/fto.html)
        echo "removing previous socket..."
        rm $SSH_AUTH_SOCK
    fi
    echo "Starting SSH-Agent relay..."
    # setsid to force new session to keep running
    # set socat to listen on $SSH_AUTH_SOCK and forward to npiperelay which then forwards to openssh-ssh-agent on windows
    (setsid socat UNIX-LISTEN:$SSH_AUTH_SOCK,fork EXEC:"npiperelay.exe -ei -s //./pipe/openssh-ssh-agent",nofork &) >/dev/null 2>&1
fi

Open .bashrc (or your shell's configuration file if you don't use BASH), and add the following line at the end of the file:

source $HOME/.agent-bridge.sh

Reset your Windows Terminal, and you should be able to see your keys imported into 1Password when listing the keys added to the agent.

You won't have to repeat this process again, as long as you don't remove any configuration we created.

I'm happy to have found a way to use my SSH keys stored in 1Password when using WSL, it eases the things a bit for me as I haven't used Windows in at least a decade. I'm still trying to make myself comfortable in this operating system, but I guess time will tell what happens.

Nevertheless, WSL has been an amazing tool, and I'd like to thank everyone involved on it.

Convertir un array de objetos a un objeto usando TypeScript

David Sánchez — Tue, 03 Aug 2021 12:27:03 +0000

Tuve la necesidad de convertir un arreglo de objetos (Array<{ id: string, name: string }>) en un sólo objeto donde la llave era el campo id y el valor era el campo name. Esto puede parecer muy sencillo al inicio, y lo es, pero a la hora de tipar correctamente el resultado en TypeScript me demoré un buen tiempo investigando hasta lograr encontrar la respuesta.

Advertencia: Usaré el anglicismo "tipar" y "tipado" para referirme a la acción de crear los tipos de variables en TypeScript. Esta palabra no existe en Español.

Función sin tipar

Queremos crear una función que haga la siguiente conversión:



arrayCollectionToObject([
  { id: 'A', name: 'First' },
  { id: 'B', name: 'Second' },
  { id: 'C', name: 'Third' }
]); // { A: 'First', B: 'Second', C: 'Third' }

Comencemos con escribir la función que realizaría esta acción sin hacer uso alguno de tipos. La función se vería más o menos así:



function arrayCollectionToObject(collection) {
  const result = {};
  for (const item of collection) {
    result[item.id] = item.name;
  }
  return result;
}

Nota: Para disminuir un poco la complejidad del código en el ejemplo he usado una aproximación imperativa en lugar de usar una aproximación declarativa haciendo uso del reduce.

Vamos a describir que hace la función línea a línea.



const result = {};

En esta línea simplemente estamos creando un nuevo objeto, este será el objeto en el cual realizaremos las operaciones de conversión del array.



for (const item of collection) {
  result[item.id] = item.name;
}

Aquí estamos iterando uno a uno los elementos que están en el array, haciendo uso de la sentencia for...of, y dentro del bloque for estamos agregando al objeto result una nueva llave que tendrá como valor lo que tenga item.id y que tiene como valor lo que tenga item.name.



return result;

Aquí devolvemos nuestro objeto result después de que le agregamos las llaves y valores necesarios.

Problema

Nuestro código funciona correctamente. Si le enviamos un arreglo de objetos con la estructura esperada obtendremos como resultado un sólo objeto.



arrayCollectionToObject([
  { id: 'A', name: 'First' },
  { id: 'B', name: 'Second' },
  { id: 'C', name: 'Third' }
]); // { A: 'First', B: 'Second', C: 'Third' }

Pero hay un problema en el tipado con TypeScript, el parámetro acepta cualquier tipo variable (any) y el tipo de objeto retornado es simplemente un objeto vacío ({}).

Si a nuestra función le pasamos un argumento cualquiera, este será aceptado, TypeScript no validará nada y podremos tener errores en tiempo de ejecución.



arrayCollectionToObject(42); // TypeError. Error en tiempo de ejecución 😭

Si usamos un editor con auto-completado (como Visual Studio Code) no podremos aprovechar el auto-completado en el objeto devuelto por la función.

Mejorando el tipado de nuestra función

Tenemos como objetivo asegurar el tipo de dato que recibirá la función, permitiendo sólo colecciones de objetos que cumplan con la estructura esperada, y también debemos mejorar el tipado del objeto que devuelve la función.

Asegurando el parámetro

Para asegurar el parámetro vamos a hacer uso de Generics. Los Generics son una utilidad que permiten generalizar los tipos, permiten capturar el tipo provisto por el usuario para poder utilizar esta información del tipo en un futuro.



function arrayCollectionToObject<
  T extends { id: S; name: string },
  S extends string
>(collection: T[] = []) {
  // Resto del código...
}

En este pequeño cambio estamos realizando lo siguiente:



T extends { id: S; name: string }

Estamos diciendo que vamos a recibir un valor con un tipo determinado de dato y a este tipo lo llamaremos T. Lo único de lo que estamos seguros es que el tipo de dato que recibimos es un objeto y que tiene por lo menos las propiedades id y name.

La propiedad id tendrá otro Generic, a este tipo determinado de dato lo llamaremos S y nos servirá más adelante para poder agregar correctamente el tipo del resultado.



S extends string

Aquí estamos agregando otra restricción a nuestro Generic llamado S. Estamos asegurándonos que el valor que tendrá este tipo será un sub-tipo de string.

Con este pequeño cambio ya estamos seguros de que nuestra función sólo recibirá como argumento un valor que cumpla con la estructura que esperamos. En caso de no cumplir con la estructura esperada, obtendremos un error en tiempo de compilación.



arrayCollectionToObject(42); // Error en tiempo de compilación 🥳

Asegurando el objeto resultante

En el paso anterior logramos asegurar el tipo del parámetro que se recibirá en la función y prevenir que se le pase como argumento cualquier tipo de valor. También podemos hacer que nuestra función nos provea un tipo más específico en el resultado que se obtiene al ejecutarla.

El objetivo es que el tipo del objeto resultante tenga como nombre de las llaves el valor que tenía cada elemento del arreglo en la llave id. Para lograr esto, sólo debemos hacer un cambio en la siguiente linea:



function arrayCollectionToObject<...>(collection: T[] = []) {
  const result = {} as { [K in T['id']]: string };
  // Resto del código...
}

Esta linea lo que hace es que un tipo de objeto cuyas llaves serán iguales a cada uno de los valores de id existentes en T y su valor será un string.

¿Recuerdas que había un Generic llamado S en la declaración de la función? Resulta que el Generic es usado para poder tener un String literal, si no hubiésemos hecho esto, TypeScript nos hubiera tipado las llaves del objeto resultante como un string y no con el valor exacto de cada id.

De esta forma, ya podemos ver que el auto-completado de nuestro editor funciona correctamente.

Código final

Después de agregar los tipos nuestro código debería haber quedado de la siguiente forma:



function arrayCollectionToObject<

  T extends { id: S, name: string },

  S extends string

>(collection: T[] = []) {

  const result = {} as { [K in T['id']]: string };

  for (const item of collection) {

    result[item.id] = item.name;

  }

  return result;

}

Conclusión

No soy un experto en TypeScript y mi experiencia con el lenguaje es poca, pero lo poco que he conocido me ha demostrado que se pueden realizar cosas muy interesantes con su sistema de tipos. Realizar este pequeño ejemplo me ayudó a fortalecer bases sobre Generics, restricción de Generics, protección de tipos y mapeado de tipos.

Es cierto que encontrar los tipos correctos en nuestro código a veces puede llevarnos muchísimo tiempo, encontrarlos para este ejercicio me llevó más tiempo del que hubiera deseado, pero se debe ver esto como una inversión a futuro. El tener nuestro código con un tipado correcto nos podrá asegurar muchísimas cosas a medida que el proyecto crece.

Créditos a Mohammad Rahmani por la foto de portada del artículo.

¿Qué hay de nuevo en Next.js?

David Sánchez — Wed, 16 Jun 2021 13:22:12 +0000

Sobre la Next.js Conf

Hoy, 15 de Junio de 2021, fue la Next.js Conf de 2021. Esta fue virtual y corta (duró 24 minutos), el enfoque de la conferencia estuvo dividido en 2 partes:

Next.js Live, una nueva plataforma de desarrollo y colaboración creada por Vercel.
Next.js 11, la nueva versión del framework.

En la conferencia se hizo demasiado énfasis en cómo mejorar la experiencia de usuario (UX) a la vez que se mejora la experiencia de desarrollo (DX). Abajo explicaré las novedades que nos trae Next.js 11 y Next.js Live.

Next.js 11

En la nueva versión de Next.js, se llevó al siguiente nivel la conexión entre UX y DX, aunque también tuvo una participación especial las mejoras en el rendimiento del framework:

Hubo una mejora del 24% en el tiempo de inicio. Este tiempo es desde que se crea una nueva sesión de desarrollo y se visualiza el resultado en pantalla.
Hubo una mejora de 40% en el tiempo de procesamiento de cambios. Este tiempo es desde que se guarda un cambio en el archivo y se visualiza el cambio en la pantalla.

Para obtener acceso a estas mejoras de performance sólo hay que mantener actualizado Next.js:

npm i next@latest react@latest react-dom@latest

Ahora, demos una mirada a los nuevos componentes que se introdujeron para mejorar el DX y el UX:

Mejoras en el componente de imagen

El componente de imagen provisto por Next.js next/image, nos ayuda a optimizar las imágenes abstrayendo toda la complejidad que esto implica.

Este componente se introdujo en Next.js 10, pero obtuvo unas nuevas funcionalidades en Next.js 11:

Si se importa una imagen por medio del keyword import y esta se envía al prop src, el componente calculará automáticamente el width y el height de la imagen. Tener estos atributos ayudará a reducir el Cumulative Layout Shift, una de las medidas que usa Web Vitals.
Se podrá agregar una imagen provisional de carga. Cuando el usuario tenga una conexión a Internet de baja calidad, se le mostrará una versión difuminada del resultado final mientras termina de cargar. Lo único que se debe hacer es agregar el prop placeholder="blur" a la imagen.

Aquí un pequeño ejemplo de cómo funciona:

import Image from 'next/image`
import tShirt from '../public/t-shirt.png'

function Backpack() {
  return (
    <Image
      src={tShirt}
      placeholder="blur"
      alt="Picture of a T-Shirt with Vercel's logo"
    />
  )
}

El resultado es similar a lo que se ve a continuación:

(El video lo he tomado del post de Next.js 11)

Conformance

Se agregó Conformance, que es un conjunto de reglas creadas por Google para ahorrarle al desarrollador tener que memorizar reglas para mantener un buen performance y poder mantenerse al día con los cambios.

Conformance es una especie de linter que le provee confianza al desarrollador al limitarlo a una serie de reglas. Durante el stream, mostraron el funcionamiento de un plugin de ESLint que permite encontrar scripts que bloquean el renderizado o que previene realizar recargas completas de la página al no usar next/Link.

Podemos usar Conformance en nuestro proyecto con Next.js 11 al ejecutar next lint.

Componente Script

Al igual que en Next.js 10 se introdujo el componente next/image, en esta nueva versión de Next.js se introduce un nuevo componente que permitirá abstraer las complejidades que conlleva optimizar la carga de scripts: next/script.

import Script from 'next/script';

// Componente...
<Script
  src="https://unpkg.com/three@0.129.0/build/three.min.js"
  strategy="afterInteractive"
/>

Para poder hacer uso de estas optimizaciones, el componente Script recibe un prop llamado strategy, este recibirá 3 valores:

beforeInteractive: Este es usado para scripts críticos que deben ser cargados y ejecutados antes de que la página tenga interactividad.
afterInteractive: Este es usado para scripts que deban ser ejecutados después de que la página tenga interactividad.
lazyOnload: Este es usado para scripts que puedan esperar a cargar en momentos de inactividad en la ejecución.

Webpack 5

Ya desde Next.js 10.2 podíamos hacer que Webpack 5 fuera el bundler que se utilizara en nuestro proyecto. Lo podíamos activar por medio de un flag en nuestro archivo de configuración de Next.js (next.config.js).

La novedad es que ahora Webpack 5 es el bundler por defecto y no hay necesidad de agregar un flag para que se use esta versión.

Migración desde Create React App (CRA)

Esta es una herramienta que está en estado experimental en la actualidad y no se habló de ella en la conferencia, aunque aparece en el post de presentación de Next.js 11.

La idea con esta herramienta es poder migrar de forma automática proyectos que fueron creados usando Create React App a usar Next.js. Se puede usar ejecutando el siguiente comando:

npx @next/codemod cra-to-next

De nuevo, es experimental, así que es probable que aún tenga errores.

Next.js Live

(La imagen la he tomado del post de Next.js 11)

Next.js Live fue con lo que empezó la conferencia y se llevó una buena cantidad de tiempo mostrando sus características.

Next.js Live es un entorno de desarrollo y colaboración en tiempo real exclusivamente para proyectos en Next.js. Nos permite tener un editor (Monaco, el mismo que usa Visual Studio Code) en el navegador para modificar nuestro proyecto de Next.js a su vez que aplica los cambios en nuestro navegador y le envía los cambios incrementales a las otras personas que tengan el proyecto abierto.

Los usuarios que están visualizando nuestro proyecto pueden dibujar encima del proyecto y escribir en él, esto es muy útil si se quiere dar atención a un detalle en específico y pedir o proveer feedback. Lo interesante con estos cursores es que no sólo funcionan obteniendo la posición del mouse en el plano (X, Y) sino que Next.js Live tiene más información a nivel de componentes que permite que la posición de los cursores se vea correctamente incluso en responsive.

También vale aclarar que Next.js Live nos permite realizar cambios a nuestro proyecto sin problemas cuando no tenemos conexión a Internet.

Este servicio aún está en Preview y para acceder a él, primero debemos registrarnos a una lista de espera. Al momento de escribir este artículo, no he obtenido acceso a esta plataforma. Si deseas registrar tu correo a la lista de espera puedes ir a https://nextjs.org/live

Conclusiones

La conexión de la que tanto hablaron entre UX y DX al inicio de la conferencia la entregaron con creces en la nueva versión de Next.js, las nuevas características del componente de imagen y el nuevo componente de script reducen un montón la complejidad existente en optimizar las páginas.

Estoy totalmente a favor de la aproximación que han tomado en Next.js para hacer de la optimización un asunto del framework, disminuyendo así la responsabilidad que recae en los desarrolladores en la implementación de la buenas prácticas y reduciendo esto sólo a la toma de decisiones.

No puedo opinar mucho de Next.js Live, más que decir que estoy ansioso de poder obtener acceso al mismo ojalá en poco tiempo.

Fuentes

Si les gustó el post, les agradezco darle una reacción ❤️ y compartirlo en sus redes sociales.

My Journey into Ruby: Modules

David Sánchez — Mon, 05 Apr 2021 12:07:25 +0000

Let's talk about modules in Ruby, how they differ to classes, why are they useful and how does the Ruby method lookup works.

Modules in Ruby are similar to classes, they hold multiple methods. However, the modules cannot be instantiated as classes do, the modules do not have the method new.

We can think of modules as mix-ins, they allow you to inject some code into a class. The mix-in exports the desired functionality to a child class, without creating an "is a" relationship. In Ruby, the main difference between inheriting from a class and mixing a module is that you can mix in more than one module.

The Well-Grounded Rubyist book has a really good example about when a module may be needed.

💡 When you're designing a program and you identify a behavior or set of behaviors that may be exhibited by more than one kind of entity or object, you've found a good candidate for a module.

Let's review the basics of module creation. We will use "stack-likeness" as our main example. We want to create a module that introduces stack-like behavior to any class.

ℹ️ A stack is a one dimensional data structure that follows a particular order for the operations to be performed on it: LIFO (Last In First Out), the last element to be added into the stack will be the first element to be queried on the stack.

Module Creation

Writing a module follows almost the same syntax that we use to create classes, the only difference is that we need to start the definition using the module keyword instead of the class keyword:

module Stacklike
    def stack
        @items ||= []
    end

    def push(obj)
        items.push(obj)
    end

    def pop
        items.pop
    end
end

What we did here is pretty simple. We're creating an instance variable called @stack that is an array representing our stack (1D data structure we talked about above) and we then abstract the push and pop behaviors of the stack into the push and pop methods of the module.

Mixing the Module Into a Class

In order to mix the module into a class we are going to make use of one of three different keywords: include, prepend and extend.

⚠️ For this example, I'm going to show how to use the include keyword to add Stack-likeness into our class, to understand how the other keywords work we'll need to go through how the method lookup works in Ruby and we'll do that later in this article.

class Stack
    include Stacklike
end

That's it. That's all that is needed in order to mix our Stacklike module into our Stack class, and now it can behave like a stack.

stack = Stack.new
stack.push("First item")
stack.push("Second item")
stack.push("Third item")
puts "Objects currently in the stack:"
puts stack.items
last_item = stack.pop
puts "Removed from the stack:"
puts last_item
puts "Objects currently in the stack:"
puts stack.items

If we execute this code, we'll see that the stack behavior is currently being applied to our Stack class and the Stack-likeness behavior can be introduced to any other class that we want in our codebase, it is easily reusable.

💡 Rubyists often use adjectives for module names in order to reinforce the notion that the module defines a behavior.

Method Lookup Path

The method lookup path is a mechanism in which Ruby starts "bubbling up" in the "object chain" in order to find what object or module is the one that contains the method that we're currently calling. This is what's being used when we call object.pop or object.items in our past example, those methods are not explicitly defined in Stack, but they're found in the method lookup path of the Class by including the Stacklike module.

Consider the following code:

module M
    def x
        puts "Hey! I'm the module M"
    end
end

class B
    def x
        puts "Hey! I'm the class B"
    end
end

class A < B
    includes M
end

We are creating a class (A) that inherits from another class (B) and also mixes the behavior that's provided by a module (M). Now, we can instantiate the class A and call the method X, by following the Method Lookup Path, we'll get "Hey I'm the module M" as the result.

a = A.new
a.x # Hey I'm the module M

The Class A object will try to find a method to execute based on the message that has been received (x). If Ruby has looked up all the way in the object chain until it reaches out Kernel or BasicObject and still hasn't found it, then it won't be found.

ℹ️ The point of BasicObject is to have as few instance methods as possible, so it doesn't provide much functionality. Most of the functionality or Ruby's fundamental methods is actually found in the Kernel module, that are included in all objects that descend from Object.

By looking at the diagram above, you'll note that the way the method x is found in the example is by following the path: [A, M, B, Object, Kernel, BasicObject] and as the method x is found in M, it will use that instead of using the one found in B. You can use the ancestors method to find this path in any object, it is provided by the Kernel module.

ℹ️ If two modules are included in the same class and they both contain a method with the same name, they're going to be searched in reverse order of inclusion. The last mixed-in module is searched first.

Prepend and Extend Keywords

When mixing-in the first module into the class, I told that the prepend and extend keywords could be used to that as well. Let's see the differences between them.

Prepend

It works almost the same as include, the difference is that when you prepend a module to the class, the object will look for the method in the module first, before looking for it in the class.

Consider this change in the code above:

class A < B
    prepend M

    def x
        puts "Hey! I'm the class A"
    end
end

The method lookup path will change to [M, A, B, Object, Kernel, BasicObject].

Extend

Both include and prepend will make the methods of the modules available as instance methods of the class. extend works a bit different by making module's methods available as class methods instead. Extending an object doesn't add the module into the ancestor chain.

Super Method

There's this keyword called super that we can use inside the body of a method definition. What this keyword does is that it jumps to the next-highest definition of the current method in the method lookup path.

Consider the following change in the example code:

module M
    def x
        puts "Hey! I'm the module"
        puts "But I'm going to call the next higher-up method..."
        super
        puts "Back in the module"
    end
end

Calling the method x will result in something like:

a = A.new
a.x

# Hey I'm the module
# But I'm going to call the next higher-up method
# Hey I'm the Class B
# Back in the module

Because the super keyword is going to call the method x that is found in the Class B which is the next object that is available in the method lookup path in this example.

It's also important to note that the super keyword handles arguments in a different way as methods would do:

When called with no argument list, it will automatically forward the arguments that were passed to the method from which it's called.
When called with an empty argument list (super()), it sends no arguments to the higher up method, even if there were arguments passed to the current method.
When called with specific arguments (super(1, 2, 3)), it sends exactly those arguments to the higher up method.

When to Use Mix-Ins vs Inheritance

Having both inheritance and modules means that you have a lot of choice, but having a lot of choice also means that you also must be very careful about the considerations both this approaches introduce.

As noted at the beginning of this post, modules don't have instances. Entities or things are better modeled using classes, while behaviors or properties are better encapsulated using modules.
Classes can have a single superclass, but can mix in as many modules as needed.

You may like to break everything into separate modules, because you think something that you write for one entity may be useful in another entities in the future. But the overmodularization also exists. You've got the tools, and is up to you to consider how to balance them.

Hope you've liked this post, I learned a lot while studying modules and I tried to summarize it as much and as easy I could in this post.

If you've got any feedback or question about this post, please add it as a comment. I'm sure we all could learn about this.

Thanks for your time ❤️👋

Install MySQL using Docker

David Sánchez — Sat, 27 Mar 2021 06:00:32 +0000

I've been a Docker user for some years and I never get tired of the power, flexibility and organization that it brings to my personal machine. In this article I will show you how do I install MySQL in my computer using Docker in order to be able to use it while avoiding all the headaches that might come by installing the database locally.

What is Docker?

Let's start with a short explanation about what is Docker. It is a technology that has become the standard when building and distributing applications. Docker's objective is to standardize the way to distribute software by packing the code and dependencies in artifacts called containers. A container will have a set of processes that executes in your machine, but are logically isolated from the rest of your system.

Containers bring a lot of benefits such as:

Flexibility: You can pack any type of application into a container.
Lightweight: All containers reuse the kernel between them.
Portable: They're designed to run the same way in any computer.
Low coupling: They are contained and are not affected by different configuration or software that may be installed in the host OS.
Scalable: You can easily copy containers multiple times.
Safe: A container may only access certain parts of the system that it has been granted access.

To know more about Docker you can read the official Docker Overview article.

You can also read how to install Docker on macOS, Linux (using Ubuntu or Linux Mint) and Windows.

What is MySQL?

Now, let's talk a bit about MySQL. It's a DBMS (Database Management System) that allows us to manage relational databases. It was created by Sun Microsystems and then absorbed by Oracle when they purchased Sun on 2010. It's a pretty popular DBMS in the community due to being Open Source and free to use for commercial purposes.

You use DBMS, such as MySQL, in order to store and retrieve data for multiple purposes such as applications, websites, and services.

To know more about MySQL you can read the official What is MySQL? article.

Why Do I Use Docker for This?

You might say that I'd be better if I just run a [brew](https://brew.sh/) install (I moved to macOS a while ago) and that's all, and while that may be true, I still find myself being a bit uncomfortable installing services that I may use sporadically. For this reason, I'm using Docker to keep my main OS free of services and configurations that may come to haunt me in the future.

Another benefit I find in using Docker is that I can just upgrade or downgrade the version of the container with a simple command, just by modifying its tag.

Create a Docker Volume

We're installing a database in order to persist information, aren't we? So we need to find a way that our Docker containers are able to persist information in our host machine.

Note: Docker containers doesn't persist information by default. They execute the processes and when you stop them, all the information that was written to the hard drive is gone.

We will make use of Docker Volumes to persist our data through multiple executions of the containers. Docker Volumes are managed by Docker and bring us multiple advantages such as:

Not dependent on the directory structure and the OS host machine.
Easy to back up or migrate.
Safely shared among multiple containers.
Easy to manage.
You can read more about this topic in the Docker Volumes documentation.

In order to create a new Docker Volume it is pretty simple, we just have to execute the following command in our terminal:

docker volume create mysql-volume

And that's it! Docker has created our Volume that we'll be using to persist our data.

Create a Docker MySQL Container

Now that we have our Docker Volume created, we can create the container that will contain the mysql binary, services and configuration.

In order to do this we'll execute the following command:

docker run --name mysql-db -e MYSQL_ROOT_PASSWORD=mysql --mount source=mysql,target=/var/lib/mysql -p 3306:3306 -d mysql

I'm going to explain what every part of this command does:

docker run Creates a Docker Container based on a Docker Image
--name mysql-db This is the name of the container we're creating right now. Docker containers must have unique naming.
-e MYSQL_ROOT_PASSWORD=mysql Set an environment variable containing the password of the root user. Please don't judge me for using this password, is just for educational purposes, but you should change the password to something else more secure.
--mount source=mysql-volume,target=/var/lib/mysql This is where we told our container to use our newly created mysql-volume Docker Volume to store information that's going to be written on /var/lib/mysql which is the directory where MySQL persists the information.
-p 3306:3306 We tell Docker to expose the 3306 port of the container into the 3306 port of our host OS in order to be able to access the MySQL service.
-d It just tells Docker to run the container in detached mode or in background.
mysql The Docker Image that we're going to use as "blueprint" to create our container.

That's it! After executing that line we may have MySQL running inside a Docker Container that's exposing the 3306 port into our system so we can do queries to it.

Test Installation

We can check that our container is working correctly by connecting to the MySQL client.

docker exec -ti mysql-db mysql -u root -p

And then entering the password we added as value of the MYSQL_ROOT_PASSWORD environment variable.

If you receive an output in console showing the Copyright notice and a mysql> prompt, then it means that the container is running correctly and you can start using it now!

That's all to create a Docker Container for MySQL, now you can use it for whatever you want. If you've got any question about this process, I'll be more than happy to help you so please leave it in the comments and expect an answer from me as soon as I have time to answer it.

Hope you've liked the post and leave your reaction in the sidebar on the left (or in the bottom if you're in a small screen device) ❤️

My Journey into Rails: Beginnings

David Sánchez — Mon, 15 Mar 2021 12:30:50 +0000

I'm a software engineer whose focus is mainly in web development. Since I started coding professionally my backend experience has gravitated around Python, using Django, Flask, FastAPI, etc.

I changed my employer a few months ago, and though I'm mainly a frontend developer, I'm also expected to write some backend code in order to fulfill the tickets I'm assigned to. But in the new company, we don't use Python at all, we use Ruby and I've never used Ruby before.

At the beginning, I thought that I could start reading Ruby code and since I had experience with Python it was going to make sense as I worked with it, but I was truly wrong with that. There were a bunch of syntax differences that wouldn't make sense to me at first by looking at the code and I had to search what they were supposed to do. That's clearly not a very productive way of doing things, isn't it? So that set me a challenge in order to learn Ruby & Ruby on Rails so I can be a bit more productive in the backend side of the project.

Let's get serious about learning Ruby

I needed a way to learn about Ruby's syntax first so I can be more comfortable reading the code and understanding what it does. I used two resources to do this:

Disclaimer: As I'm not 100% into backend in the new project I was able to do this while the project advances, I'm not sure this is the best approach if your time is a bit limited in the project you're currently working on.

The Well Grounded Rubyist (3rd edition): I love this book, it teaches every aspect of Ruby in a way that's pretty simple to understand and it has some examples and exercises that will help you review the concepts once you finish every chapter of the book.
Codecademy: I haven't used this page for years, but it was clearly a great resource that was recommended to me by a friend. I used it after reading the book above and it helped me a lot to review even more the concepts, as you have to make some exercises in order to advance on it.

After using both this resources, I was able to better understand the syntax of Ruby and navigate through the codebase of the project as everything now fits much better in my mind.

What's different with Ruby compared to Python or Node?

Parenthesis are optional

First thing I found different between Ruby and Python or Node was the optional parenthesis to call a method (or pass messages into an object). This was of the first issues I met when I was first reading Ruby code as it was totally different from I was used to.

class Greeter
    def greet name
        puts "Hello #{name}"
    end
end

greeter = Greeter.new # Create a new object of the Greeter class
greeter.greet "David" # prints "Hello David" in console

Flexibility when naming methods

Ruby is very flexible when it comes to naming methods. You will find a lot of "operators" that are just language conventions using method names to do certain actions. For example, the "append" operator to add a new element into an array is just a method named <<.

numbers = [1, 2, 3, 4]
numbers << 5
puts numbers # This will print 1 2 3 4 and 5 in console

Or the setters, that are created by appending an = to the attribute name.

class Customer
    def initializer name
        @name = name
    end

    def name # This is the getter of the name attribute
        @name
    end

    def name= newName # This is the setter, look at the = in the name
        @name = newName
    end
end

customer = Customer.new "David"
puts "Customer is #{customer.name}"
customer.name = "John"
puts "Customer is #{customer.name}"

It always returns the last line

This is something I loved when learning Rust and I'm glad something kinda similar is present in Ruby. Ruby will always return the result of the last line of the expression, unless you set a return keyword in a statement that comes before.

In the example above, you can see that in the getter method I didn't set an explicit return keyword, but calling the name method will anyways return the value of the @name variable. That method works as if I did something as:

def name
    return @name
end

Local variables vs Instance variables vs Class variables

These kind of variables exists in all object oriented languages I've used until today, but the syntax to create them is really different to what I was used in Python.

Local variables

These are the variables that are only available in a block and cannot be accessed outside that scope. This is the normal behavior that you find in variables that are created inside a method or that are passed as arguments.

Instance variables

These are variables that are available to all the methods of the instance. Each instance may have different values for these variables. You create this type of variable by prepending an @ character to the name of the variable, such as @name in the example above.

Class variables

These are variables that are available in the class and all instances will have the same value, modifying it in a single instance means that all instances will also have the new value updated. You create this type of variable by prepending the @@ characters to the name of the variable.

class Customer
    @@types = ["Regular", "Loyal"]

    def types
        @@types
    end
end

first_customer = Customer.new
puts first_customer.types # Regular, Loyal
second_customer = Customer.new
second_customer.types << "VIP"
puts second_customer.types # Regular, Loyal & VIP
puts first_customer.types # Regular, Logal & VIP

Instance methods vs Class methods

These type of methods also exists in all object oriented languages I've used until today, but the syntax really confused me a bit coming from a Python background.

Instance methods

These are methods that are only accesible when you create a new instance of a class. In all the examples above I created instance methods, no big deal.

Class methods

These are methods that are accesible from the class itself and you don't need an instance of the class in order to execute them. They are created by prepending the self. to the name of the method.

class Sample
    def self.hello_class
        "Hello from the class method"
    end
end

puts Sample.hello_class # Hello from the class method

And more things...

There was some other topics that I'd like to cover here but they will make this post really long, I'll cover them later in this series in a more detailed way.

What I like about Ruby?

It looks like a very fun language to work with and I found its syntax to be elegant and easy to understand. It has a lot of useful built-in behaviors and frameworks such as Ruby on Rails makes it really easy to go from 0 to a MVP in short time.

What I dislike about Ruby?

This is not a Ruby per-se problem, but I found the Ruby on Rails learning curve to be a bit steep. There's a lot of things that in Python are totally explicit (following the "Explicit is better than implicit" principle) and are not so "explicit" in Ruby, you'll need to search in multiple files in order to understand where they are actually declared and how they work.

That's it... for now.

I've found Ruby to be a really fun to learn language and using it has been a total pleasure. I'm eager to learn new things about the language and Ruby on Rails in order to be a bit more productive in the backend side of the current project I'm currently working on and to achieve proficiency in this language.

I love teaching others in order to better learn concepts, so I will try to make more of these posts in a tutorial-like style when I learn new concepts. If you liked this post, please be assured that I will publish new ones with other concepts or thoughts about this topic.

I hope you liked this post.

Please tell me in the comments if you want to have a post about a particular aspect of Ruby or if you have any comments or feedback that could help me improve this post, and please, don't forget to react to this post, that would make me really happy.

Thank you for your time ❤️👋

I made a small game in Arduino

David Sánchez — Sat, 10 Oct 2020 23:20:36 +0000

I've always been very interested in electronics since I got an "Electronic for Kids" kit that my parents bought me more than 15 years ago, it felt like playing with LEGO but much more interesting. The thing is that as the years passed, I got more interested in software and somehow stopped doing electronics just for fun (I coursed some electronics courses in the university).

With the pandemic and the lock-down, I have been recovering the interest of doing more side-projects in my free time (I don't have the guts to go out from home yet) and then I remembered that I had some electronic stuff and an Arduino in my shelves. With the stuff I found, I then started thinking about what project could I do that will help me learn new stuff in both software and hardware.

After some minutes thinking about which project I could do with the stuff I had, I came up with this idea about doing a project like the game of the Chrome's Offline dinosaur where you have to jump over some obstacles. This will be possible with the 16 x 2 LCD screen I found, the Arduino, and the push button.

You can check the code of the project with its corresponding breadboard view in this GitHub repository:

d4vsanchez / jump-arduino

A very simple game for Arduino.

Jump

This is a very simple game for Arduino, you should avoid having the ball deflated by falling into the spikes.

Getting started

To run this project you must have the following items:

Arduino UNO installed in your computer.
An Arduino UNO compatible board.
A push button.
An LCD screen.
A 12KΩ resistor.
A 220Ω resistor.
Jumper wires.

Installation

Clone the project.
Open jump.ino with Arduino IDE.
Upload it to your Arduino UNO.

Breadboard view

How does this work?

To Do list

The following items are missing to say this is v1 release:

I may have a bug somewhere because the LCD flickers strangely in the "Game Over" message.
A better animation when the ball jumps.
A blog entry explaining how I did it.
Better screenshots to show…

View on GitHub

Let's work

First I needed to connect the LCD screen to the Arduino. I forgot how to do that, the last time I did something in an LCD screen was at the university for a "security system" project and that was like 3 or 4 years ago. So I followed the "Hello world" tutorial for LCD Screen in the Arduino website.

When the screen lit up and displayed the "hello, world" message I was ready to get into the coding of the game. I divided the game development into 3 stages:

Create the obstacles in a random position and slide them in the screen.
Create the ball and the collision logic.
Add the jump logic to the ball.

Generating obstacles and movement

The obstacles are going to fill the whole bottom row of the LCD screen. I could do this with two different approaches: Using a boolean array of 16 positions or using a single short typed variable.

I choose the latter approach because it will use only 2 bytes, while the former would be using 16 bytes. This also meant that I have to the operations in the obstacles by doing bitwise operations.

Let's start with the fundamental operation of the obstacles: "Being painted on-screen". The code can be reviewed in the paintObstacles() function, I'm going to iterate the 16 positions of the bottom row and I'll check if the current position has a 1 in the binary representation of the number. For example, if I had the number 143 its binary representation is 10001111 and those positions will be filled as an obstacle.

To check if the current position has 1 or a 0, I just do an AND bitwise operation with the rightmost digit, and then I do a right shift bitwise operation to move all the digits to the left one position.

To generate the new obstacles, the code can be reviewed in the generateObstacles() function and I use a simple random number generation between 0 and 9, and there is a 30% chance that you get a new obstacle in the game. To generate a new obstacle I do a left shift operation to move the digits one place to the left and then an OR operation with the rightmost digit in case you get a new obstacle.

That's all for obstacles!

Generating the ball and adding collision logic

The ball will be stationary in a cell of the LCD screen, starting in the bottom cell, the code can be reviewed in the paintBall() function. The ball is always going to be in the third cell from left to right which could be represented in binary as 8912.

The function to set the cursor of the LCD receives and integer from 0 to 15, so I cannot send 8192 as an argument. Getting that number is done by doing a subtraction and logarithm: First I do a log10(8192)/log10(2) to obtain 13 (2 to the power of 13 is 8192) and then I subtract this number from the total number of columns which is 16, that gives me 3.

To know if the ball has collided with an obstacle I just check if the ball is in the air or not (a boolean variable) and do a AND operation between USER_POSITION (which is 8192) and the currentObstacles value (which can be any number between 0 and 32767); if this operation returns 1 it means that the ball has collided with an obstacle. This code can be reviewed in the hasLost() function.

After implementing this logic, I tweeted the current progress of the project, this is the tweet I made when I finished the collision logic.

// Detect dark theme var iframe = document.getElementById('tweet-1312864511368589317-248'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1312864511368589317&theme=dark" }

Translation: The idea is to make a game similar to the dinosaur game in Chrome where you have to jump obstacles. I'm missing the jump logic and refining the code.

Jump Logic

When pressing the push button I save the the current execution time in a variable. I have function called isInAir() checking if that time is lower than 2 frame executions in the game, a frame is painted every 500ms. If the return of this function is true I paint the ball in the upper row and the collision logic will return false.

This is another tweet I made showing the final result.

// Detect dark theme var iframe = document.getElementById('tweet-1312879111346544641-67'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1312879111346544641&theme=dark" }

Translation: It's got jumps 😃 I've got to refine the code that went downwards in cleanness over time, and I'll upload it to GitHub. I've got some details to fix, such as the Game Over which looks to have bug in the letters and add some details to the ball when it jumps.

Ta-da!

That's the game project, well at least this first version. I'm thinking into adding a bit more animations and small features such as a score.

I hope you all like it and reproduce your own version at home! I'll be happy to receive PRs to the project with cool stuff that you implement on your own version.

Conclusion

I wanted to optimize as much as possible in the size of the program, that's why I made some decisions in the design of the game such as using a short data type instead of the 16 positions bool array. The program ended weighting 3048 bytes (roughly 3 KB) and using 91 bytes of dynamic memory.

Doing this kind of projects will make have fun (if you like doing electronics) and will also teach you different topics related to programming such as bit management.

Thanks so much for reading up to here and remember to like ❤️ and share the article if you found it interesting!

Rebasing in Git to maintain history's health

David Sánchez — Tue, 30 Jun 2020 16:09:44 +0000

Have you ever felt that the Git history of your project is becoming a big mess and when you need to find out why a change was made you encounter a lot of small commits that were just adding tiny bits of code that you forgot to add in previous commits? Well, this also happened to me.

I'm a passionate learner so I'm always trying to find out new ways of doing things and questioning the current knowledge I have about a tool. When I found out that the Git history of my project was having a lot of meaningless commits, I started asking myself if there was a better way to add those changes to previously made commits so they can maintain cohesion and in the future, another developer doesn't need to solve the puzzle by searching through multiple commits to finding the reason of the change.

This is when I found about Rebasing in Git. There are two ways that we can use Rebase: as a "replacement" of git merge and change, drop, and squash previously made commits. Gotcha, you can see that one of the use cases of the Rebase command fits perfectly the use case I'm searching for.

I'm not going to talk about git rebase as a "replacement" of git merge in this article, but if you are curious how is that so, I recommend you to read this article from the people at Atlassian where they explain it.

To explain how to do Interactive Rebase in Git I've created this simple example repository that has some meaningless commits that I want to get rid of.

By using tig we can observe multiple things:

I'm doing these changes in a separate branch called feature-branch, it's very important that you do not use git rebase on public/shared branches as it will overwrite history. This means that if you force-push the changes, anyone else who's also working in your branch will go out of sync.
There are two meaningless commits in my feature-branch that only fixes some accents that I forgot to add in the Adding my personal information commit. We will be fusing them 2 with the original commit.
I made them all quickly in my example, but you may extrapolate the things we're going to make here into bigger projects.

Let's do it

First, we'll take the SHA-1 of the oldest commit that we want to retain as-is. In this case, the last commit we want maintaining as-is is the Adding my initial description file commit. This is because we are going to be fusing the two "Forgot ..." commits with the Adding my personal information commit, hence not retaining it as-is.

Now that we have the hash of the commit, we're going to execute the following command which is going to run Rebase in Interactive mode, so we can easily pick which actions we want to perform to the commits.

git rebase -i 6c8e26c^

You may notice two things in the command:

We're using only a few characters of the hash: Git allows us to refer to a commit by only using few characters from it. You can check out that in Git's documentation.
The caret at the end: In order to have our current commit available in the rebase command we will need to bring the parent of the 6c8e26c commit. This will let us do the fusion operation between the 3 commits.

Executing this command will open the editor that we have configured in Git with the following text:

pick d7ce763 Adding my personal information
pick b049848 Forgot to add accent in my last name
pick b215b9e Forgot to add accent in my city
pick b544998 Adding software development skills

# Rebase 6c8e26c..b544998 onto b544998 (4 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

By reading at the commands, the best fit of actions for what we want to do is the following:

Pick the Adding my personal information commit (leave it as-is)
Fixup the Forgot to add accent in my last name commit
Fixup the Forgot to add accent in my city commit
Pick the Adding software development skills commit (leave it as-is)

By using the Fixup action instead of the Squash action, we're telling Git to move the changes of both commits to the above commit (Adding my personal information) and not ask us to rewrite the commit message or append their commit messages to the one we had originally.

This is how our file will look like after making the changes:

pick d7ce763 Adding my personal information
fixup b049848 Forgot to add accent in my last name
fixup b215b9e Forgot to add accent in my city
pick b544998 Adding software development skills

# Rebase 6c8e26c..b544998 onto b544998 (4 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

Now it's only necessary to save and quit the editor and Git will do these operations instantly.

This is the final result of running our rebase command with the fixup.

There are no more meaningless commits, both have been fused with the commit that added the personal information. This way no one has to solve the puzzle by having multiple commits that fix stuff that we mistyped or forgot to do in previous commits that are not yet merged into the stable branch or shared with another coworker.

You can also use this Interactive Rebase to edit something in a previous commit that you just happened to see right now, you just have to use the edit action and Git will take you to that moment in history so you can modify it. The only difference when you finish making the change is that you don't do a git commit but you do a git commit --amend.

Conclusion

Maintaining meaningful commits in your Git history is important, it helps other developers flow through changes in a more natural way and waste less time reading meaningless changes that were added just to comply with Git's rule to always add a commit message.

Rebase will help us achieve this goal by giving us tools to traverse the history of our repository and do changes to our commits so we don't need to create a single commit to fix something insignificant but we can edit the commit in which the problem it was introduced.

We may need to take care of rebasing though. It is good that we only use it in branches that are not shared with anyone else and the commits are not merged into a public branch. After our branch is merged in the main branch of the project is not a good idea to rebase it, we'll have to create a new commit.

I hope to read your comments about this method and if you like the post I really appreciate you to share it and add a reaction to it!

Mocking and patching in Python for unit testing

David Sánchez — Sun, 23 Feb 2020 21:16:48 +0000

Ubidots is an effortless point-and-click Internet of Things (IoT) application builder with data analytics and visualization. I am an engineer at Ubidots, and it is our daily goal to seamlessly and cleanly turn your sensor data into information that matters. Hiring an engineering team to develop a platform that both functions and looks great is costly in both time and money so we did it for you. One feature that many clients enjoy is Historical Reporting which is generated and saved with Amazon S3.

When developing this feature, we needed to create a unit test using Python to test feature reliability. Using a mocked class of the boto3 module. As we were in a test environment we couldn't allow the upload of files to our S3 Bucket nor did we have the correct credentials so we needed to find a way to mock the class but including (or actually taking out) the following features:

Don't communicate with Amazon, as I don't need to upload anything.
Don't raise an exception by not having the correct credentials.

For obvious reasons, I cannot copy & paste the Ubidots source code, but for the purpose of this article, I have included an example somewhat similar to that which we use daily.

Let's code!

Let's start with the most important part of the post: The code!

Create the model

This will be our "Report model" and it's got a method that will let us create the report and send it by email.

import StringIO

from django.db import models
from boto3.session import Session

class Report(models.Model):
    # ...
    # Information about the model

    def create_report_and_send_by_email(self):
        stream = StringIO.StringIO()
        self.create_report(stream)

        # Go back to the first bit of the stream
        stream.seek(0)

        session = Session(aws_access_key_id=AWS_ACCESS_KEY, aws_secret_access_key=AWS_SECRET_ACCESS_KEY)
        s3 = session.resource('s3')
        s3.Bucket(AWS_BUCKET_DATA).put_object(
            Key='file.pdf',
            Body=stream.read(),
            ACL='public-read',
            Expires=(datetime.datetime.now() + datetime.timedelta(days=1)).strftime('%Y/%m/%d'),
            ContentType='application/pdf'
        )

        # Do some other stuff and send the file by email

    # More methods
    # ...

Here, I've only implemented one method of our model as this is the focus of this article, but normally this model will have additional fields and other methods which have been left off solely for simplicity reasons.

Create the test

This will be the file that implements the unit tests for our model, you can read a bit more about writing and running unit tests in the Django Documentation site.

from django.core import mail
from django.test import TestCase
from reports.models.report import Report

class ReportTest(TestCase):
    def tearDown(self):
        Report.objects.all().delete()
        mail.outbox = []

    def test_create_report_and_send_by_email(self):
        info = # This is a dict with the information of the fake Report
        report = Report.objects.create(**info)

        # There shouldn't be emails in the outbox
        self.assertEqual(len(mail.outbox), 0)

        report.create_report_and_send_by_email(self)

        # There should be one email in the outbox
        self.assertEqual(len(mail.outbox), 1)

If we were to run this code without the correct AWS credentials, it will raise an exception that says that the credentials are not correct and therefore our test will fail.

Here is when we need to do a mock of the Session class from boto3; preventing the session from making a connection to Amazon S3. In this case, we expect nothing to be returned, the only thing we're going to do with the mock is prevent the connection with Amazon S3.

Create the mock

The first thing we need to do is import the mock and boto3 libraries in our test file.

import mock
from boto3.session import Session

Now, we need to create our mock for Session and Resource classes, and we'll implement the methods we use with the same arguments to run our test. Below you will find our "FakeSession" and "FakeResource" to be used as our mocks classes.

class FakeResource():
    def Bucket(self, bucket):
        return self

    def put_object(self, Key=None, Body=None, ACL='', Expires='', ContentType=''):
        # We do nothing here, but return the same data type without data
        return {}

class FakeSession(Session):
    def resource(self, name):
        return FakeResource()

Now, with these two mock classes created, we can add them to the test case using the patch. Using the patch, the test will run using these fake classes instead of the real ones from boto3.

@mock.patch('reports.models.report.Session', FakeSession)
def test_create_report_and_send_by_email(self):
    # Same implementation we used before
    # ...

As you can see, the patch is made to the namespace of the module that we're testing, not to the namespace of the original module we want to modify.

Adding the mock to the Test

Our test code (including the previous steps) looks like this:

import mock

from django.core import mail
from django.test import TestCase
from boto3.session import Session
from reports.models.report import Report

class FakeResource():
    def Bucket(self, bucket):
        return self

    def put_object(self, Key=None, Body=None, ACL='', Expires='', ContentType=''):
        # We do nothing here, but return the same data type without data
        return {}

class FakeSession(Session):
    def resource(self, name):
        return FakeResource()

@mock.patch('reports.models.report.Session', FakeSession)
class ReportTest(TestCase):
    def tearDown(self):
        Report.objects.all().delete()
        mail.outbox = []

    def test_create_report_and_send_by_email(self):
        info = {"name": "Fake report"} # This is a dict with the information of the fake Report
        report = Report.objects.create(**info)

        # There shouldn't be emails in the outbox
        self.assertEqual(len(mail.outbox), 0)

        report.create_report_and_send_by_email(self)

        # There should be one email in the outbox
        self.assertEqual(len(mail.outbox), 1)

When this new test case is executed it will use the implementations we've created in FakeSession each time Session from boto3 is instanced.

Using the patching decorator we were able to make a mock class from a third-party (boto3) work the way we needed to test some modules; even when missing some parameters that would otherwise be available in a production environment, using a mock class we could test our module without the need of building content data to run the program.

Authors' thoughts: This mock should only be made when it is necessary. It is important to think about how will this modification affect the test of the module; in the case of this piece, we only modified modules to prevent boto3 from connecting to Amazon and did not raise an exception. For our needs, the S3 feature wasn't important for the correct behavior of the test.

If you found this article helpful please leave your reaction and share it in your networks! And you're also very welcome to leave feedback in the comments section ❤️.

Install Docker Community Edition in Linux Mint

David Sánchez — Sun, 16 Feb 2020 22:53:40 +0000

Docker is a popular software package that makes easier to create, deploy and run multiple applications using containers. By using containers, developers may be assured that their code will run on any other machine that may not have the same packages or configuration as the one used to create the project originally.

There are two Docker versions in existence: Docker CE (Community Edition) and Docker EE (Enterprise Edition). Docker CE is free and it's the one that we'll see how to install in this tutorial.

System Requirements

Linux Mint
A user account that has superuser privileges

What I'll use

Terminal: I'm using terminator as my Terminal Emulator. It's not going to be visible in the tutorial but 🤷
Linux Mint: I'm using Linux Mint 19.3 (Tricia) as my distribution.

Install Docker

These instructions are very similar to the ones posted in Docker's Documentation, there are going to be some differences specific to Linux Mint installation.

Step 1: Install dependencies to use a repository over HTTPS
Step 2: Add the Docker's official GPG key
Step 3: Set up the Docker repository
Step 4: Install Docker Engine
(Optional) Step 5: Allow non-privileged user to run Docker

Step 1: Install dependencies to use a repository over HTTPS

sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common

Step 2: Add the Docker's official GPG key

When you add third-party repositories in Linux, you need to add their GPG key to ensure that the packages that are uploaded are valid and they can be installed in your system.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Running this command will add the Docker's official GPG key to your system.

Step 3: Set up the Docker repository

This is the part I told you that will change a bit from the original instructions in Docker's website. Their instructions are only intended for Ubuntu and its derivatives, but if you follow them closely in Linux Mint, you'll end up having errors in the configuration.

This following line will tell us which is the Ubuntu version that our Linux Mint is built in top of:

grep "UBUNTU_CODENAME" /etc/os-release | awk -F '=' '{ print $2 }'

As I'm using Linux Mint 19.3 (Tricia) it will display bionic as the output. This line will then be used to add the Docker repository in your system:

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(grep "UBUNTU_CODENAME" /etc/os-release | awk -F '=' '{ print $2 }') \
   stable"

Step 4: Install Docker Engine

After this step is successfully executed, we can now install the Docker Engine by running a simple apt-get install command:

Note: I'm adding an apt-get update command here to make sure that we have the latest changes in the repositories. Usually, the previous step should automatically do it, but I want to be sure that they're up to date.

sudo apt-get update && sudo apt-get install docker-ce docker-ce-cli containerd.io

(Optional) Step 5: Allow a non-privileged user to run Docker

If you try to run Docker with your normal user, you'll run into an error because Docker cannot be run by non-privileged users. This step adds your user to the docker group in your system and after rebooting your computer you'll be able to run Docker without sudo.

sudo usermod -aG docker $USER

That's it, you should have Docker running correctly in your computer. If you're struggling with any step or just want to know a bit more about what does any of these commands do, just leave me a comment and I'll be more than happy to help you!

This is my first post in Dev.to and I'll be very grateful if you leave me any feedback about this post in the comments ❤️.

DEV Community: David Sánchez

Use 1Password SSH Agent in WSL

Enable 1Password SSH Agent

Download npiperelay

Connect WSL with 1Password's SSH agent

Convertir un array de objetos a un objeto usando TypeScript

Función sin tipar

Problema

Mejorando el tipado de nuestra función

Asegurando el parámetro

Asegurando el objeto resultante

Código final

Conclusión

¿Qué hay de nuevo en Next.js?

Sobre la Next.js Conf

Next.js 11

Mejoras en el componente de imagen

Conformance

Componente Script

Webpack 5

Migración desde Create React App (CRA)

Next.js Live

Conclusiones

Fuentes

My Journey into Ruby: Modules

Module Creation

Mixing the Module Into a Class

Method Lookup Path

Prepend and Extend Keywords

Prepend

Extend

Super Method

When to Use Mix-Ins vs Inheritance

Install MySQL using Docker

What is Docker?

What is MySQL?

Why Do I Use Docker for This?

Create a Docker Volume

Create a Docker MySQL Container

Test Installation

My Journey into Rails: Beginnings

Let's get serious about learning Ruby

What's different with Ruby compared to Python or Node?

It always returns the last line

Local variables vs Instance variables vs Class variables

Instance methods vs Class methods

And more things...

What I like about Ruby?

What I dislike about Ruby?

That's it... for now.

I made a small game in Arduino

d4vsanchez / jump-arduino

A very simple game for Arduino.

Jump

Getting started

Installation

Breadboard view

How does this work?

To Do list

Let's work

Generating obstacles and movement

Generating the ball and adding collision logic

Jump Logic

Ta-da!

Conclusion

Rebasing in Git to maintain history's health

Let's do it

Conclusion

Mocking and patching in Python for unit testing

Let's code!

Create the model

Create the test

Create the mock

Adding the mock to the Test

Install Docker Community Edition in Linux Mint

System Requirements

What I'll use

Install Docker

Step 1: Install dependencies to use a repository over HTTPS

Step 2: Add the Docker's official GPG key

Download `npiperelay`