Entre sus características tenemos

• Infraestructura Escalable
• Configuración en Windows Simple
• Transaccional
• Map/Reduce
• .Net Client API
• RESTful API
• Sharding
• Indexamiento (Lucene syntax)

En cuanto a documentacion parece estar bastante completa (en inglés), podemos consultar:

• Documentación de RavenDB en el sitio oficial
• Introducción a RavenDB en codeproject.com 

Antes de comenzar directamente con RavenDB si aún no tenemos en mente lo que una document database es podemos consultar la Wikipedia: Document-oriented database o también ver el video de la VAN de Alt.Net Hispano sobre NoSQL

Cabe mencionar que aún no puede correr en Mono y que los modos Servidor y Embedded corren bajo la framework .NET 4.0. El Cliente si corre (con algunas condiciones) en la framework .NET 3.5 y si puede correr en Mono.

Y para comenzar podemos ir directamente al clásico RavenDB HelloWorld! Tutorial

Según indica el tutorial, luego de descargar el build que decidamos, nos vamos al folder “server” y lo ejecutamos

Nota: Para este ejemplo modifiqué la configuración para que corriera en el puerto 8088, por default va a correr en el 8080.

Ahora que ya tenemos el servidor corriendo

procedemos a trabajar en una pequeña implementación utilizando el cliente de RavenDB, no olvidemos referenciar el cliente de Raven DB en nuestro proyecto.

Para esta prueba crearé una console application donde tendremos un par de clases que será la definición de nuestro documento:

Una vez teniendo nuestros POCO objects, procedemos a inicializar el DocumentStore y utilizarlo, para lo cual tendremos una clase más con un field que será el storage inicializado en el constructor y un método que se encargará de llenar el documento y almacenarlo en el storage.

Ahhh, no olvidemos que el inicializar el storage no es el único paso que debemos realizar. Para poder interactuar con los documentos necesitamos una sesión abierta, aquí el código:

Finalmente, utilizamos nuestro ClientsDirectory en una console application

y al ejecutar nuestra aplicación y luego irnos a la interfaz web de nuestro RavenDB Server

http://localhost:8088

Podemos ir a la sección “Documents” y bingo!

Nuestro primer documento creado, mismo que al darle click en la interfaz web podemos manipularlo:

No olvidemos que tenemos la opción de utilizar RavenDB embebido en nuestras aplicaciones lo cual nos quita la dependencia a un servicio adicional a nuestra aplicación que esté corriendo, adicionalmente que esto nos da libertad de utilizarla para muchos tipos de proyectos, no dejen de ver la sección Raven’s Client API

El proyecto puede descargarse Aquí

La .NET Framework nos provee 2 herramientas Uri y el método ParseQueryString de la  HttpUtility cuyos detalles de documentación se encuentran acá:

• HttpUtility.ParseQueryString Method
• Uri Class

Demos una vista a la Uri Class, para esta clase debemos tener el namespace System incluido en nuestra clase. Luego de instanciarla pasando con el constructor el URL con el que vamos a trabajar, tenemos ya las diferentes partes accesibles por medio de atributos del objeto.

    var uri = new Uri(url);
    Debug.Write(uri.AbsolutePath);
    Debug.Write(uri.AbsoluteUri);
    Debug.Write(uri.Query);
    Debug.Write(uri.Host);
    Debug.Write(uri.Port);

Y ahora HttpUtility.ParseQueryString, este método es estático asi que podemos utilizarlo con habilitar el namespace System.Web

using System.Web;

como verán el método retorna una “NameValueCollection” cuyo comportamiento es como un diccionario (llave, valor).

Extenderme a hablar de esta textutil de linux en su totalidad es mucho para un post, asi que por ahi irán saliendo uno que otro how-to de textutils.

Resulta que por algun motivo tenemos una cadena que necesitamos hacer pedazos a partir de un caracter en específico, por ejemplo un archivo con path de origen y destino para mover o copiar archivos, vamos a tomar de ejemplo lo que sería una linea del archivo

/home/fernando/hola.txt|/root/hola.txt

esto quiere decir que necesitamos una sentencia como esta:

cp /home/fernando/hola.txt /root/hola.txt

Acá es donde llega nuestro amigo AWK para plantearnos la solución a este dilema que viene a ser algo así:

echo "/home/fernando/hola.txt|/root/hola.txt" | awk '{split($1,arrayName,"|"); print "cp "arrayName[1]" "arrayName[2]}'

Especificamente quien hace la tarea es el comando “split” el cual tiene 3 parametros:

• Cadena de entrada ( $1 ) [Ver wikipedia el segmento del comando print  ]
• nombre del Arreglo ( arrayName ) , el conteo de posiciones comienza en 1.
• separador ( “|” )

Si tenemos varias lineas en un archivo de entrada en lugar del comando “echo” podemos utilizar “cat [archivo de entrada]” asi:

cat listado.txt | awk '{split($1,arrayName,"|"); print "cp "arrayName[1]" "arrayName[2]}'

La salida de este comando nos dará un listado de sentencias que podremos utilizar y ejecutar directamente, lo cual podríamos hacerlo con un apóstrofe invertido (`)

`echo "/home/fernando/hola.txt|/root/hola.txt" | awk '{split($1,arrayName,"|"); print "cp "arrayName[1]" "arrayName[2]}'`

La configuración es bien sencilla, encontré más información utilizando nUnit y por ello que nace este post (ya era hora no? ) para ejemplificar utilizando xUnit

Primero comenzamos con las descargas e instalación de:

1. specFlow
2. watiN
3. xUnit

Adicionalmente a esto, deberán tener configurado el ejecutor de test units ya sea con TestDriven.Net o con Resharper en Visual Studio.

Ya que descargamos todo esto procedemos a crear un nuevo proyecto y a agregarle las referencias a las 3 librerias descargadas.

Ojo! Por default SpecFlow genera el código para ser utilizado por nUnit y pues resulta que queremos trabajar con xUnit… Casaca! (chapinismo para decir que algo es “simple, facil,…”) debemos agregar un Application Configuration File a nuestro proyecto con lo siguiente:

( mjm… creo que debo cambiar el theme de mi blog, les dejo el formato a ustedes por el momento )

Bueno, a este punto ya estamos listos para comenzar con nuestro primer test, para el cual tomaremos esta Feature:

Feature: googling
In order to use watin
As entusiast
I want to be able to get a page and validate text

Scenario: google to search about frogs
Given I have written URL in browser http://www.google.com
When I see google home page with title Google
Then I check if Advanced Search link appear


Cabe mencionar que SpecFlow utiliza como sintaxis Gherkin cuya documentación pueden encontrarla en http://wiki.github.com/aslakhellesoy/cucumber/gherkin 

Para utilizar esta feature debemos agregar un SpecFlowFeature File, el cual aparece entre los templates de visual studio si instalamos todo como nos indicaron los links que compartí al inicio.

una vez creada nuestra feature

ejecutamos la test unit, sabiendo que va a ser fallida y observamos el mensaje de salida:

cool! tenemos el código base para iniciar, entonces agregamos una nueva clase a nuestro proyecto con el código que SpecFlow nos mostró en el mensaje de error. A este punto comenzamos a interactuar con Watin.

No debemos olvidar la respectiva referencia a la libreria en los “using” de nuestra clase:

using WatinN.Core;

la forma de interacción con WatiN es bastante extensa, yo me enfocaré en lo que nuestra feature quiere probar, que el texto “Advanced Search” aparezca al obtener el URL. Si desean adentrarse mas en el ejemplo pueden ir directamente al sitio de WatiN

Por cada una de las sentencias de nuestro “Scenario” tendremos un método lo cual nos permite dividir las acciones o validaciones segun cada una de las sentencias. Para esta prueba dejemos la instancia del browser al momento del “Given” de nuestro “Scenario”, sin embargo tambien existen las opciones de tenerlo en un constructor, trabajar un metodo setup, entre otras. Nuestro código se puede ver algo así:

en el primer método se instancia el Watin para que utilice Internet Explorer y definimos la URL que se obtendrá, esto corresponde a nuestro “Given”.

Luego viene el “When” donde le inddicamos al Browser que obtenga la dirección que necesitamos evaluar.

Finalmente llegamos a la sentencia “Then” donde indicamos al browser que espere al texto que estamos buscando (esta en ingles y en español por la deteccion de idioma que tiene google) y adicionalmente se hace el “Assert” para verificar que se encuentre en el HTML. Esta validación, es muy relacionada a lo que queremos probar.

En este caso utilizo un “WaitUntilContainsText” porque la página de google pareciera mostrar con javascript estos textos, o al menos darles algun efecto, así que le digo a Watir que espere hasta que dicho texto se encuentre en el DOM. Lo cual nos indica que no importando si la página tiene javascript y a su vez este genera más elementos en el Dom, podemos realizar validaciones sobre el mismo.

No olvidemos cerrar el navegador al finalizar la ejecución desde código para evitar llenarnos de browsers con las ejecuciones de las pruebas

Aca está el código de nuestra clase:

using System.Text.RegularExpressions;
using TechTalk.SpecFlow;
using WatiN.Core;
using Xunit;

namespace testingIISInstance
{
    [Binding]
    public class StepDefinitions
    {
        private IE _browser;
        private string _httpAddress;
        [Given(@"I have written URL in browser http://www.google.com";
        }

        [Then(@"I check if Advanced Search link appear")]
        public void ThenICheckIfAdvancedSearchLinkAppear()
        {
            _browser.DomContainer.WaitUntilContainsText(new Regex("Advertising Programs|Programas de publicidad"));
            Assert.True(
                _browser.Html.IndexOf("Advertising Programs") >= 0 || _browser.Html.IndexOf("Programas de publicidad") >= 0
                );
            _browser.Dispose();
            _browser.Close();
        }

        [When(@"I see google home page with title Google")]
        public void WhenISeeGoogleHomePageWithTitleGoogle()
        {
            _browser.GoTo(_httpAddress);
        }
    }

Prometo continuar con este tema y desglosar con mejor detalle cada uno de los elementos acá mencionados

primero debemos crear la configuracion de la zona a utilizar como genérica
$ttl 1800
@ IN SOA ns1.dominio.com. root.dominio.com. (
2008112801
10800
3600
604800
1800 )
IN NS ns1.dominio.com.
IN NS ns2.dominio.com.
IN A 192.168.10.5
www IN CNAME @


debera crearse en /var/cache/bind/[nombrequequiero].zone y los ns1 y ns2 deberan existir en la zona correspondiente a “dominio.com.”

Luego, configuramos en el master… para comenzar creamos el archivo

/etc/bind/named.conf.[nombrequequiero]

al cual se le van a colocar las definiciones de la zona de esta forma:

zone "nuevodominio1.com" {
type master;
allow-query { any; };
file "[nombrequequiero].zone";
};
zone "nuevodominio2.com" {
type master;
allow-query { any; };
file "[nombrequequiero].zone";
};

una por cada dominio que se necesite, para ello se puede utilizar el script

#!/bin/bash
DOMAINSLIST=$1
for i in $(cat $DOMAINSLIST); do
echo "zone \"$i\" {"
echo "type master;"
echo "allow-query { any; };"
echo "file \"[nombrequequiero].zone\";"
echo "};"
done

que toma como entrada el nombre de un archivo de texto que tenga todos los dominios sin ningun prefijo para concatenarlo al archivo

ejemplo:

nuevodominio1.com
nuevodominio2.com
nuevodominio3.com


En el caso de los slaves tambien creamos un archivo

/etc/bind/named.conf.[nombrequequiero]

solo que en este caso el texto a incluir es de esta forma:

zone "nuevodominio1.com" {
type slave; masters { [ipdelDNSmaster]; };
allow-query { any; };
file "[nombrequequiero].zone";
};
zone "nuevodominio2.com" {
type slave; masters { [ipdelDNSmaster]; };
allow-query { any; };
file "[nombrequequiero].zone";
};

de similar forma puede generarse con el siguiente script:

#!/bin/bash
DOMAINSLIST=$1
for i in $(cat $DOMAINSLIST); do
echo "zone \"$i\" {"
echo "type slave; masters { 209.85.29.20; };"
echo "allow-query { any; };"
echo "file \"[nombrequequiero].zone\";"
echo "};"
done


y agregarlo al archivo /etc/bind/named.conf.[nombrequequiero]

ATENCION! QUE NO SE NOS OLVIDE! HAY QUE AGREGAR LA REFERENCIA AL ARCHIVO PARA QUE SE INCLUYAN LAS ZONAS

/etc/bind/named.conf.[nombrequequiero]

EN
/etc/bind/named.conf

al final de las zonas existentes del named.conf incluimos dicho archivo de la siguiente forma:

include "/etc/bind/named.conf.3rdtierdomains";

reiniciamos el bind del slave o los slaves, si se tiene habilitada la salida a syslog, podran ver que las zonas reportan error…

Luego reiniciamos el bind del master y listo! una forma práctica de crear varias zonas de DNS