Mi buen amigo
Rodrigo me dice: "
A ver si jubilas NUnit y te pasas a Team System". Bien, ese es mi propósito para el año entrante.
Jubilar NUnit, CruiseControl, RedMine y mi querido Subversion. En cuanto salga Windows Server 2008, y Team System 2008 será lo primero que haga, remodelar mi pequeña y barata infraestructura.
Como decía actualmente estoy usando lo siguiente en un modesto Pentium 4, con 512Mb de Ram que hace las labores de mini-servidor en casa.
Pruebas unitarias:
MbUnit y
NUnitIntegración Continua:
CruiseControl.Net y
CruiseControl.rbCobertura de código: NCoverConstrucción:
NantRepositorio de código:
Subversion Gestión de proyectos:
RedMineUna infraestructura de coste 0, versátil y potente, que me permite hacer prácticamente de todo.
Si, tal vez no esté todo integrado ni disponga de un entorno unificado, pero no se le ha resistido prácticamente nada. Herramientas con las que he pasado horas y horas de esas noches desveladas en que el proceso de automatizar tareas se convierte casi en una experiencia religiosa, “ala
Enrique Iglesias” si, descubriendo el infinito… herramientas que han dejado el listón muy arriba, que por el momento me hacen dudar si TFS estará a la altura, si llegará a cautivarme como lo han hecho mis queridas compañeras…
Incluida la última en llegar que ha sido RedMine, para aquellos que no la conozcan, es un gestor de proyectos, escrito en Ruby por Jean-Philippe Lang y es uno de los proyectos más activos dentro de la comunidad de
Ruby.
Con RedMine, se pueden gestionar diversos proyectos de toda índole, aunque está basado en Ruby, yo por ejemplo lo uso para gestionar proyectos .Net, permite que varias personas trabajen en el mismo equipo, planificar objetivos, seguimiento de incidencias, gestión de la documentación del proyecto mediante Wiki, Foros, integración con distintos repositorios de datos (Subversion, CVS, Mercurial, Bazaar y Dracs), autentificación por LDAP etc…
Yo incluso lo tengo personalizado (lo bueno de poder tocar el código) para que me muestre en la página principal de los proyectos información sobre la últimas compilaciones, información que proviene del CruiseControl.
También, modifique el visor del repositorio para poder mostrar código c# con la sintaxis coloreada, para que gestionar documentación sobre los frameworks, ver informes sobre cobertura etc... en fin, pueden ser pijadas para algunos, en fin echaré de menos todas esas horas editando archivos XML, encadenando procesos y generando informes…
Prometo contar mis experiencias religiosas con TFS el año que viene…
Alguien me ha recordado que empecé a escribir sobre el tema de las pruebas
unitarias y finalmente no termine… o por lo menos no conté algunas de las
prácticas que uso… cierto.
Parte 1 -
Parte 2Básicamente la técnica que uso habitualmente consiste en aprovisionar un
sitio de forma automática. Y ¿Cómo se aprovisiona un sitio automáticamente?,
pues de la manera más sencilla posible. Usando Plantillas.
Provisión - Escenario de Pruebas
De modo que tengo distintas plantillas pre cargadas con listas, bibliotecas
de documentos, páginas etc… algunas incluyendo contenido, archivos, elementos de
las listas y un montón de cosas.
Es sencillísimo crear estos escenarios y pueden ser simples, incluyendo uno ó
unos pocos elementos ó complejos incluyendo una jerarquía de de sitios, en cuyo
caso crearemos una plantilla por cada sitio para más tarde reconstruir una
jerarquía de sitios determinada.
Después usamos un ayudante en nuestras pruebas para aprovisionar nuestros
sitios, un ejemplo de un aprovisionador de sitios básico sería algo como
esto, he recortado algunas cosas ...
public class SPProvisioningHelper
{
private const string DefaultWebName = "TestSite";
private readonly Dictionary<string, SPWeb> _webs;
private SPSite _site;
private string _urlTestSite;
public SPProvisioningHelper()
{
_webs = new Dictionary<string, SPWeb>();
UrlTestSite = "http://enjendro/unittests/";
}
// Url del sitio de pruebas
public string UrlTestSite
{
get { return _urlTestSite; }
set { _urlTestSite = value; }
}
// Coleccion de sitios sobre la que estamos trabajando
public SPSite Site
{
get { return _site; }
}
// Una web determianda
public SPWeb GetWeb(string name)
{
return _webs[name];
}
// Provisiona una web vacia colgada de parentUrl
// Pruebas rápidas y de creación de elementos
public void WebProvisioning(string parentUrl)
{
_webs.Add(DefaultWebName, CreateWeb(DefaultWebName, parentUrl, string.Empty));
}
// Crea una web
public void WebProvisioning(string name, string parentUrl)
{
_webs.Add(name, CreateWeb(name, parentUrl, string.Empty));
}
// Crea una web basada en una plantilla
public void WebProvisioning(string name, string parentUrl, string template)
{
_webs.Add(name, CreateWeb(name, parentUrl, template));
}
// Crea las webs (hace el trabajo duro)
private SPWeb CreateWeb(string title, string parentUrl, string template)
{
Trace.WriteLine(string.Format("Creating test web {0} at {1}", title, parentUrl));
_site = new SPSite(UrlTestSite + parentUrl);
SPWeb web = _site.OpenWeb();
SPWeb newWeb;
// Stop
if (web == null)
{
throw new SPException(string.Format("Can´t open SharePoint Site in: {0}", _site.Url));
}
// Si existe lo borramos
if (web.Webs[title].Exists)
{
RecursiveDeleteWebs(web.Webs[title]);
web.Webs[title].Delete();
}
// Web vacio
if (template.Equals(string.Empty))
{
newWeb = web.Webs.Add(title);
}
else
{
// web basado en plantilla personalizada
try
{
SPWebTemplateCollection webTemplateCollection;
webTemplateCollection = _site.GetCustomWebTemplates((uint) web.Locale.LCID);
SPWebTemplate webTemplate = webTemplateCollection[template];
newWeb = web.Webs.Add(title,
title,
string.Empty,
(uint) web.Locale.LCID,
webTemplate,
true,
false);
}
// web basado en plantilla no personalizada
catch (ArgumentException)
{
newWeb = web.Webs.Add(title,
title,
string.Empty,
(uint) web.Locale.LCID,
template,
true,
false);
}
}
Trace.WriteLine(string.Format("Created web {0} at {1}", newWeb.Title, newWeb.Url));
return newWeb;
}
// Limpieza
public void Clean()
{
DeleteWebs();
// Disposes
}
// Elimina las webs
private void DeleteWebs()
{
foreach (SPWeb web in _webs.Values)
{
RecursiveDeleteWebs(web);
}
}
// Elimina todo recursivamente
private void RecursiveDeleteWebs(SPWeb parentWeb)
{
// ...
}
}
Pruebas
Después en nuestras pruebas podemos inicializar los distintos escenarios, veamos un ejemplo usando el
aprovisionador anterior
[TestFixture]
public class Tests
{
// El ayudante
private SPProvisioningHelper provisioningHelper;
[TestFixtureSetUp]
public void Setup()
{
// Incializamos el ayudante
provisioningHelper = new SPProvisioningHelper();
// Ejemplos
// Aprovisionamos p1 desde una plantilla nuestra
provisioningHelper.WebProvisioning("p1", "P1", "Plantilla1.stp");
// jerarquia
provisioningHelper.WebProvisioning("p1", string.Empty);
// p1/p1a -> sitio de grupo
provisioningHelper.WebProvisioning("p1a", "p1", "STS");
// p1/p1b -> un blog
provisioningHelper.WebProvisioning("p1b", "p1", "Blog");
// p1/p1a/p1a1 -> un wiki
provisioningHelper.WebProvisioning("p1a1", "p1/p1a", "Wiki");
// p1/p1a/p1a1/p1a11 -> sitio en blanco
provisioningHelper.WebProvisioning("p1a11", "p1/p1a/p1a1");
}
// Una prueba simple
[Test]
public void GetCurrentUserName()
{
string expectedUser = WindowsIdentity.GetCurrent().Name;
SPUser user = provisioningHelper.GetWeb("p1").CurrentUser;
string userName = user.LoginName;
Trace.WriteLine(string.Format("Expected: {0} User: {1}", expectedUser, userName));
Assert.IsTrue(expectedUser.Equals(userName,StringComparison.OrdinalIgnoreCase));
}
// Limpieza
[TestFixtureTearDown]
public void TearDown()
{
provisioningHelper.Clean();
}
}
Esto es básicamente, desde luego como ocurre con todos los sistemas que deben
ser aprovisionados, estos llevan su tiempo, en cualquier caso tampoco me parece
tanto y además hay unos estupendos quad core relativamente baratos así que no es
escusa para no tener una máquina de pruebas.
