Tag Archives: visual studio 2010

Localizar más facilmente una vista Razor con Resharper

Si alguna vez habéis tenido que localizar y maquetar una web que inicialmente estaba en un idioma en varios sabréis que es algo que quita mucho tiempo y desespera profundamente.

Es un proceso lento, repetitivo y que requiere compilar para ver los cambios… vamos, una fiesta.

Como me ha tocado hacer lo propio con las nuevas vistas de Terminis me he planteado la pregunta, ¿Resharper no me podrá ayudar a hacerlo más rápido?

Respuesta rápida: NO por defecto, pero podemos mejorarlo un poco.

Resharper tiene una opción para refactorizar un string y moverlo a un fichero de recursos pero esta opción solo funciona en código interpretado no en texto suelto de vistas Razor :_(

 

Investigando un poco he encontrado un pequeño truco que permite convertir un trozo del HTML en “código interpretado” por el compilador y así poder recfactorizarlo a recurso: crear un surround template:

Template Explorer

Creando el Surround Template

Resharper usa los templates para ayudarte a codificar más rápido y son francamente útiles. En concreto, los surround templates, sirven para seleccionar un texto y envolverlo con, por ejemplo, un tag HTML.

Para nuestra pequeña “trampa” necesitamos crear uno que envuelva el texto seleccionado entre @(“TEXTO”) para que resharper pueda interpretarlo y moverlo a un fichero de recursos.

Para ello seleccionamos en el Template Explorer la opción de “Surround Templates” en los tabs de arriba, elegimos el scope “Razor” y pulsamos en “New Template”:

New Surround Template

Esto nos abrirá una ventana para que peguemos el código del template y le demos un nombre. Yo lo he llamado “@” (si, lo sé, super original..)

Este es el código:

@(“$SELECTION$”)

Luego, en la lista, tienes que arrastrarlo a la quick list para tenerlo más a mano (como en la imagen de arriba).

Bien, con esto ya tenemos el surround template listo y tan solo tenemos que usarlo.

Usandolo en nuestra vista Razor

Tenemos un texto en un h2 que queremos incluir en el fichero de recursos lo más rápido posible.

h2

Hacerlo de la forma “tradicional” implicaría ir al fichero de recursos, añadir uno nuevo, darle un nombre, copiar&pegar este texto, clonarlo para el resto de idiomas, localizar en cada idioma y volver a la vista de razor para sustituir el texto por la llamada al fichero de recursos: un coñazo.

Con surround template (y con los benditos shortcuts!):

1) CTRL + W hasta seleccionar toda la frase a localizar:

h2_1

2) CTRL + E , J: Surround with: @:

h2_2

3) CTRL + R, O: Refactor, Move To:

RefactorMoveTo

 

¡voilá! Resharper se encarga el solo de crear el recurso (en el fichero que le digas), sustituirlo en el Razor y dejarlo listo para clonarlo en el resto de idiomas.

ACTUALIZADO

El gran Subgurim me comenta una forma aún más rápida de refactorzar texto:

En el explorador de soluciones seleccionamos el proyecto y, en sus propiedades -> Resharper modificamos:

  • Localizable: True
  • Localizable inspector: Pessimistic

ResharperLocalizationProperties

 

Con esto habilitamos la opción de Refactor > Move To Resources en el menú de acceso rápido con ALT+ENTER lo cual hace el paso 3 mucho más rápido:

¡Gracias Maestro!


No es la solución que esperaba encontrar pero me ha ahorrado horas de tedioso copy&paste…

¡Nos vemos compilando!

Testeo de javascript/jquery desde Visual Studio usando QUnit

 

 

Conforme pasa el tiempo la importancia del javascript en nuestros sitios web se hace más evidente y, en demasiadas ocasiones, esto se olvida y se relega dejando todo nuestro código .js fuera de la cobertura de tests.

En el nuevo proyecto que estoy desarrollando en Avanzis me he propuesto tener el mayor Code Coverage posible y, para ello, voy a testear también el javascript que escriba.

Para ello necesito un modo de hacerlo de forma cómoda y rápida y que, al ser un proyecto NET MVC, cumpla las siguientes condiciones:

  • Los tests de javascript se puedan lanzar desde Visual Studio.
  • El TeamCity sea capaz de lanzarlos automáticamente en cada compilación (o en un Nightly Build en caso de que tarde mucho)
  • Se pueda calcular el Code Coverage
Con estas tres premisas me he lanzado a investigar y he encontrado la combinación perfecta: QUnit + NQUnit + JSCoverage
¿Y como monto este puzzle? ¡Vamos a ello!
 
Este primer post explica como configurar Visual Studio para poder lanzar test QUnit de forma sencilla. En otros post hablaremos sobre NQUnit, como integrarlo con TeamCity y como usar JSCoverage.

Proyecto de QUnit en Visual Studio

QUnit es un framework de Javascript para realizar pruebas unitarios desarrollado por la gente de jQuery para testear sus propios plugins.

El modo más cómodo de integrar QUnit en Visual Studio es instalar el paquete de NuGetQUnit for ASP.NET MVC” (http://nuget.org/packages/QUnit-MVC) en un nuevo proyecto web (en mi ejemplo: MiProyecto.Javascript.Tests) para que nos cree una estructura similar a esta:

 

 

En Content tendremos el css necesario para mostrar la web de resultados de QUnit.

“qunit.js” es la propia librería de QUnit.

Scripts es la carpeta en la que vamos a crear la estructura de carpetas de nuestros tests. En mi caso he optado por crear una carpeta “Tests” para los ficheros .js de test de QUnit y otra llamada como el proyecto (MiProyecto/Common) para los ficheros a testear.

Obviamente estos ficheros (miproyecto.common.math.js) están en su carpeta correspondiente dentro del proyecto de la web MVC por lo que debemos hacer es agregarlos como enlace desde la carpeta del proyecto de test: (en el ejemplo, botón derecho sobre “Common” > Add Existing Item > Buscamos el .js en su carpeta original y seleccionamos en el desplegable de “Add” la opción “Add as Link“:

De este modo puedes acceder al .js original desde el proyecto de Test sin tener que copiar el fichero.

Por último solo necesitamos una página html en la que incluir estos ficheros javascript con una estructura prefijada por QUnit para mostrar los resultados.

El código de la página debe ser similar a este:

<!DOCTYPE html>
<html>
<head>
    <title>QUnit Test Suite</title>
    <link rel="stylesheet" href="Content/qunit.css" type="text/css" media="screen" />
    <script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.7.2.min.js"></script>
    <script type="text/javascript" src="Scripts/qunit.js"></script>
    <script type="text/javascript" src="Scripts/MiProyecto/Common/math.js"></script>
    <script type="text/javascript" src="Scripts/Tests/math.tests.js"></script>
</head>
<body>
    <h1 id="qunit-header">
        MiProyecto QUnit Test Suite</h1>
    <h2 id="qunit-banner">
    </h2>
    <div id="qunit-testrunner-toolbar">
    </div>
    <h2 id="qunit-userAgent">
    </h2>
    <ol id="qunit-tests">
    </ol>
    <div id="qunit-fixture">
    </div>
</body>
</html>

Como ves hay que añadir tanto los scripts propios de QUnit como los ficheros a testear y los propios ficheros de tests.

Nota: Desde Resharper se pueden lanzar los tests directamente sin tener que ejecutar esta página PERO tiene ciertas limitaciones (no se puede usar la creación dinámica de valores en el qunit-fixture y no se puede depurar facilmente) por lo que al final opté por hacer la página y ejecutarla manualmente para poder depurar con Firebug.

¡Bien! Ya tenemos la estructura creada pero, ¿cómo se escriben los tests? ¡Allá vamos!

 

Tests en QUnit

Supongamos que tenemos el siguiente fichero javascript en nuestra web (miproyecto.common.math.js) que tiene un par de métodos para hacer sumas, uno que simplemente suma dos números y otro que obtiene el valor de dos inputs por id, los suma y devuelve un span con el resultado:

//Suma dos valores SOLO si son números 
var sumNumbers = function (x, y) {
    if (typeof x === "number" && typeof y === "number")
    { return x + y; } else {
        return "error";
    }
}

//Obtiene el valor de dos elementos por su id, los suma (si son números) y crea un <span> con el resultado
var createSpanSumResultFromInputs = function (idX, idY) {

    var spanResultado = $(document.createElement('span'));

    var x = $("#" + idX).val();
    var y = $("#" + idY).val();
    var result = sumNumbers(x, y);
    if (typeof result === "number") {
        var stringResult = x + '+' + y + '=' + result;
        spanResultado.InnerHtml = stringResult;
    } else {
        spanResultado.InnerHtml = "error";
    }

    return spanResultado;
}

Estos dos ejemplos sirven para demostrar como hacer tests simples para validar entrada de datos, validar resultado y validar modificación de la DOM (lo más común en nuestros scripts).

Para nuestro fichero de test creamos un nuevo fichero js (miproyecto.common.math.tests.js) que está estructurado de la siguiente forma:

// Referencia: Ruta relativa del fichero javascript a testear (para que Resharper la incluya antes de lanzar el test)
/// <reference path="/Scripts/Terminis/Common/math.js"/>

// Clase que engloba todos los tests. Es aquí donde se especifica el SetUp y el TearDown
module('Math Tests', {
    setup: function () {
        // setup code

    },
    teardown: function () {
        // teardown code
    }
});

// Método de test
test('nombre del test', function () {
    //... Asserts
});

Como ves la estructura es similar a la de una clase de test de NUnit. Tenemos SetUp y TearDown y varios métodos de tests con varios asserts (o afirmaciones). ¡Importante! no olvidar el “<reference>” o nuestros tests fallarán al invocar los métodos a probar.

 

Para empezar vamos a probar nuestro método “sum” validando que solo sume dos números y devuelva el valor correcto o el string “error” en caso contrario:

test('Sum Validation.', function () {
    equal(sumNumbers("", ""), "error", "sumar dos cadenas vacias devuelve error");
    equal(sumNumbers("zadasdad", "asdadsa"), "error", "sumar dos textos devuelve error");
    equal(sumNumbers("asdasd", 1), "error", "sumar texto y número devuelve error");
    equal(sumNumbers(1, "asdasdasd"), "error", "sumar número y texto devuelve error");
});

test('Sum Correct Results.', function () {
    equal(sumNumbers(1, 2), 3, "suma de dos enteros");
    equal(sumNumbers(-1, -2), -3, "suma de dos negativos");
    equal(sumNumbers(-2, 1), -1, "suma mixta");
    equal(sumNumbers(1, 2.5), 3.5, "suma de entero y decimal");
    equal(sumNumbers(1.5, 2.5), 4, "suma de dos decimales");
});

Es muy sencillo hacer los asserts. Tan solo hay que hacer uso de la API de QUnit (usando “ok”, “equal”, “notEqual”, “raises”, etc…), poner el resultado de la llamada, el valor esperado y un mensaje para identificar el tipo de afirmación que estamos probando.

 

En el segundo método las pruebas se complican ya que los valores de entrada dependen de elementos de la DOM y el resultado es un <span> por lo que necesitamos crear lo que necesitamos en el SetUp antes de lanzar los tests:

module('createSpanSumResultFromInputs Tests', {
    setup: function () {
        // setup code
        $('#qunit-fixture').append('<input type="text" id="xTest" value="1"/>');
        $('#qunit-fixture').append('<input type="text" id="yTest" value="2"/>');
        $('#qunit-fixture').append('<input type="text" id="wrongValue" value="this is not a number"/>');
    }
});

En el SetUp de este nuevo módulo (solo se ejecutará este SetUp antes de las siguientes llamadas “test()”) hemos creado 3 inputs, dos con valores correctos y uno incorrecto para tests de validación, como si de una página “mockeada” se tratara. 

Para crearlos los hemos añadido al contenedor con id “qunit-fixture“, este elemento es un div cuyo contenido se crea y de destruye en cada ejecución por lo que podemos guarrear todo lo que queramos con él.

Los tests en este caso no diferirían demasiado a los ya visto con anterioridad:

test('Validation Tests', function () {
    equal(createSpanSumResultFromInputs("not exists", "yTest").text(), "error", "Si no existe el idX devuelve error");
    equal(createSpanSumResultFromInputs("xTest", "not exists").text(), "error", "Si no existe el idY devuelve error");
    equal(createSpanSumResultFromInputs("xTest", "wrongValue").text(), "error", "Si uno de los dos no es un número devuelve error");
});

test('Correct Test', function () {
    equal(createSpanSumResultFromInputs("xTest", "yTest").text(), "1+2=3" , "Obtiene los dos valores de sendos input's y devuelve <span> con la operacion");
});

Con esto ya sabemos todo lo básico de los test con QUnit. Existen muchas más cosas como el asyncTest() para peticiones que incluyan callbacks que son harina de otro costal.

 

El resultado es una web similar a esta con todos los test organizados por módulos > tests > asserts pudiendo relanzar test, ocultar test correctos y depurar con FireBug:

 

Con esto ya sabemos la base para empezar a chapurrear tests de javascript en nuestro Visual Studio :)

En la próxima entrega hablaremos sobre como lanzar estos tests desde un servidor de integración continua (como TeamCity) y calcular el Code Coverage.

 

Un saludo.

¡Nos vemos Compilando!

Configurar Git (BitBucket) en Visual Studio 2010 y no morir en el intento

 

Que Git se ha convertido en el más famoso y mejor controlador de versiones de código es una cosa que ya sabéis pero, ¿cómo puedo configurar las herramientas necesarias para poder trabajar con un repositorio Git en mi Visual Studio 2010?

El objetivo de este pequeño tutorial es conseguirlo sin morir en el intento

Nota: Este tutorial no explica el funcionamiento de un control de versiones por lo que doy por supuesto que todo el mundo sabe lo que es un commit, push, pull, branch, etc… Otro día haré un artículo dedicado a explicar más a fondo como funciona un control de versiones :)

 

¿BitBucket o GitHub?

¡Para empezar! Necesitamos una cuenta en algún servicio de repositorio de Git (si no dispones de uno local o el de tu empresa).

Actualmente existen dos grandes servicios gratuitos de Git que son GitHub y BitBucket. No voy a entrar a discutir cual es mejor en este artículo, solo diré que BitBucket te permite tener, de forma gratuita, repositorios privados lo cual es perfecto para esas pequeñas aplicaciones que tienes en casa y quieres salvaguardar.

Es por este motivo principalmente por lo que yo uso BitBucket como Source Control :)

 

¿Ya tienes cuenta en BitBucket? ¡Descarguemos Git!

 

Descargando y Configurando Git para Windows

Bien, lo primero que necesitamos es descargar Git para Windows el cual podemos encontrar aquí: http://code.google.com/p/msysgit/downloads/list

Descarga e instala la última versión disponible.

 

No hay que modificar casi nada durante el proceso de instalación. La única opción que recomiendo modificar es la de “Adjusing your PATH environment” la cual aconsejo cambiar de “Use Git Bash only” a “Run git from the Windows Command Prompt” tal y como se ve en la siguiente captura:

 

El resto lo puedes dejar igual.

 

¡Bien! ¡Ya lo tenemos instalado! Ahora tenemos que configurarlo para que funcione con nuestra cuenta de BitBucktet.

Para ello ejecutamos el “Git Bash” (si, es una consola, no te asustes, jeje) e introducimos la configuración global de nuestro usuario de BitBucket e Email escribiendo:

git config --global user.name "tu usuario de BitBucket aquí"

git config --globla user.email "tu email de BitBucket aquí"

 

Con esto ya lo tenemos!

Ahora vamos a configurar las herramientas en el Visual Studio 2010.

Configurando Git en Visual Studio 2010

Debido a que Visual Studio no incluye Git como control de código por defecto (solo incluye SourceSafe y Team Foundation Server) necesitamos instalar una pequeña extensión de Git para que funcione.
Para ello vamos a “Tools > Extension Manager” o “Herramientas > Administrador de Extensiones” en castellano y, en la Galería Online buscamos “Git” para instalar el “Git Source Control Provider“:

Una vez instalado lo escogemos como Source Control por defecto en “Herramientas > Opciones > Source Control > Selección de Complemento > Git Source Control Provider”

 

Lo próximo que debemos hacer es abrir (o crear) la solución que queremos subir a BitBucket y, pulsando botón derecho sobre el nombre de la solución clickamos en “New Repository“.

Esto creará un nuevo repositorio Git en el mismo directorio en el que está la solución.

Verás que en el “Solution Explorer” aparecen unos símbolos con un “+” amarillo. Esto indica que el fichero es nuevo y no se encuentra en tu repositorio local.

Haciendo click derecho de nuevo sobre la solución y pulsando en “Pending Changes” podremos ver el listado de ficheros pendientes, escribir un comentario y hacer el primer commit contra tu repositorio local.

¡Ya está! ¡Ya tenemos configurado Git para Visual Studio! Eso si, de momento solo lo deja en local y BitBucket ni lo hemos usado.

¿Qué toca ahora? Configurar Git Bash para que suba nuestros commits a BitBucket.

 

Configurar Remote y hacer Push desde Visual Studio a BitBucket

De nuevo botón derecho en la solución > Pending Changes > Git Bash y se nos abrirá la consola de Git. Ahora tenemos que configurar el acceso remoto.

Para ello escribimos lo siguiente:

git remote add origin https://usuario@bitbucket.org/nombre_del_repositorio.git

Supongamos que mi usuario es “vfportero” y mi repositorio en BitBucket se llama “demo”. El remote sería así:

git remote add origin https://vfportero@bitbucket.org/demo.git

 

¡Perfecto! Con esto ya podemos escribir: 

git push

Nos pedirá el password de BitBucket y, una vez escrito, y el bash solito se encargará de subir los ficheros al repositorio remoto :)

 

Espero que os haya servido de ayuda.

¡Nos vemos Compilando!

Uso de App.Config en aplicaciones de consola o Win Forms en .NET

Es muy común en nuestras aplicaciones el tener que extraer ciertas variables de configuración a un fichero externo para que se puedan modificar sin necesidad de volver a publicar la aplicación (como por ejemplo rutas que varían en función del servidor en el que publicas la aplicación, cuentas de correo para envíos que pueden cambiar su contraseña, cadenas de conexión, etc…)

En web ya tenemos el famoso Web.Config y su uso es bastante común para cualquier desarrollador web por lo que nos vamos a centrar en este sencillo artículo a cómo añadir un fichero de configuración a una aplicación de escritorio, escribirlo, leerlo y posteriormente modificarlo desde el bloc de notas.

 

Crear el fichero de configuración

Lo primero que debemos hacer es agregar el fichero de configuración a nuestra solución. Para ello nos vamos al explorador de soluciones de nuestro Visual Studio > Botón Derecho > Add > New Item > Application Configuration File.

 

 

Se añadirá un fichero XML con una estructura similar a la del Web.Config en el que podremos ir añadiendo las variables que queramos extraer añadiendo entradas al tag “appSettings” como el ejemplo siguiente:

 

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="mailEnvio" value="info@compilando.es"/>
    <add key="servidorEnvio" value="mail.compilando.es"/>
  </appSettings>
</configuration>

 

 

Leer el fichero de configuración desde la apliación

Una vez creado el fichero de configuración y añadidas las variables de configuración que queramos basta con hacer uso de la clase ConfigurationManager para leer el valor de las misma desde el código de nuestra aplicación:

 

 

string mailEnvio = ConfigurationManager.AppSettings["mailEnvio"];

 

 

Recuerda que has de utilizar el espacio de nombres “System.Configuration” (si no te aparece la clase es porque te falta añadir la dll al proyecto. Vete a Referencias > Añadir Referencia y en la pestaña de .NET busca System.Configuration y añadela al proyecto).

 

Publicar y Modificar la configuración del fichero desde fuera del Visual Studio

Una vez terminada y publicada nuestra aplicación (para este caso la llamaremos “Ejemplo”) tendremos el fichero ejecutable “Ejemplo.exe” que será el que arranque nuestra aplicación de consola o Win Forms y, junto a él, tendremos otro fichero llamado “Ejemplo.exe.config”

Este fichero es el fichero de configuración de la aplicación y se puede abrir perfectamente con el Bloc de Notas y editar los valores del XML para cambiar las variables de configuración si necesitar de recompilar la aplicación.

Así, en este ejemplo, podríamos cambiar el mail desde el que nuestra aplicación envío tan solo editando este fichero sin necesidad de abrir el Visual Studio lo que nos da una flexibilidad mayor a la hora de publicar y distribuir nuestra aplicaciones de escritorio.

 

Nos vemos Compilando!!