OutOfCoffeeException

Auf dem .NET Open Space hat Björn Rochel seine xUnit BDD Extensions vorgestellt und wir haben uns in einer Session auch länger darüber unterhalten.

Heute habe ich seine Extensions das erste Mal ausprobiert und einen neuen Unit Test nach BDD Art geschrieben.

Dieser spezielle Test war besonders kompliziert, da ich hier Code in einem Windows Service testen wollte und dafür die OnStart Methode aufrufen musste, die protected ist. Außerdem startet der Code der getestet wird mehrere neue Threads, und der Test sollte prüfen, ob diese Threads auch wirklich gestartet wurden.

Der Test sieht dann folgendermaßen aus:

public class 
When_the_Service_Starts_And_There_Are_three_Tasks : 
TaskRunnerServiceSpecification
   {
       #region Arrange

       protected override void EstablishContext()
       {
           base.EstablishContext();

           newThreads = new List<Thread>();

           // add some tasks
           tasks.Add(new TestTask(this));
           tasks.Add(new TestTask(this));
           tasks.Add(new TestTask(this));
       }

       internal IList<Thread> newThreads;



       #endregion

       #region Act

       protected override void Because()
       {
           // because OnStart was called...
           taskRunnerService.InvokeNonPublicMethod(
              "OnStart", new object[] {
                 new string[0]});

           // ... wait a second to give the other 
           // threads a chance to execute
           Thread.Sleep(1000);
       }

       #endregion

       #region Assert

       [Observation]
       public void should_create_three_new_threads()
       {
           newThreads.Distinct().Count().
           ShouldBeEqualTo(3);
       }

       [Observation]
       public void should_execute_all_tasks()
       {
           tasks[0].wasExecuted.ShouldBeTrue();
           tasks[1].wasExecuted.ShouldBeTrue();
           tasks[2].wasExecuted.ShouldBeTrue();
       }


       #endregion

       #region Cleanup


       protected override void AfterEachObservation()
       {
           base.AfterEachObservation();

           foreach (var thread in newThreads)
           {
               if (thread.IsAlive)
                   thread.Abort();
           }
       }

       #endregion
   }

Im Prinzip verbirgt sich dahinter ein “ganz normaler” Unit Test mit xUnit und Rhino Mocks (wobei ich in diesem speziellen Test zufällig gerade keine Mocks nutze), allerdings besser strukturiert und mit lesbareren Methodennamen (z.B. ShouldBeTrue statt Assert.True).

Durch die Bennenung der Tests und Methoden nach BDD-Art ist die Ausgabe im ReSharper Testrunner richtig gut lesbar:

In dem Beispielcode oben fehlt noch eine Hilfsklasse für diesen Test, TestTask. Diese setzt nur ihre “wasExecuted”-Eigenschaft auf true, falls die Execute-Methode aufgerufen wurde, und fügt ihren Thread zur newThreads-Liste hinzu.

Wir werden das in der Praxis weiter ausprobieren (ein anderer Kollege hat sich vorhin auch schon an BDD versucht), und diesen Ansatz wenn er sich bewährt für alle unsere Unit Tests übernehmen.

Ganz weit oben in der Liste meiner “Lieblingsfeatures” von C# stehen Lambda-Ausdrücke. Vereinfacht gesagt sind Lambda-Ausdrücke die Weiterentwicklung der Anonymen Methoden aus C# 2.0. Anonyme Methoden erlauben es, Code direkt an einen Delegate zuzuweisen. Beispiel:

In C# 1.0/1.1 muss man einem Delegate eine vorhandene Methode zuweisen:

   1: public void BeispielMethode()

   2: {

   3:     button1.Click += new EventHandler(button1_click);

   4: }

   5:  

   6: private void button1_Click(object sender, EventArgs e)

   7: {

   8:     MessageBox.Show("Button wurde geklickt!");

   9: }

In C# 2.0 ist es nicht mehr erforderlich, dem Delegate eine benannte Methode zuzuweisen. Stattdessen kann man ihm direkt eine anonyme Methode zuweisen, der Code verkürzt sich auf die folgenden Zeilen:

   1: public void BeispielMethode()

   2: {

   3:     button1.Click += delegate(object sender, EventArgs e)

   4:     {

   5:         MessageBox.Show("Button wurde geklickt!");

   6:     };

   7: }

Mit den Lambda-Ausdrücken aus C# 3.0 wird der Code erneut deutlich kürzer:

   1: button1.Click += 

   2:     (sender, e) => MessageBox.Show("Button wurde geklickt!");

Dem Click-Ereignis wird hier ein Lambda Ausdruck zugewiesen. Dieser besteht aus zwei Teilen: einer Parameterliste (links vom =>) und einem Ausdruck, auf den diese Parameter abgebildet werden (rechts vom =>).

Der Compiler erkennt hier automatisch, dass sender vom Typ object und e vom Typ EventArgs ist.

Da ich super müde bin und gleich einschlafe (habe den ganzen Tag einen 70-536 Prüfungsvorbereitungskurs unterrichtet) soll das erst mal genug sein zu dem Thema, wer mehr über Lambdas wissen möchte finden einen guten Artikel bei Scott Guthrie:

New "Orcas" Language Feature: Lambda Expressions

(this post is in English, because I think it might be useful for non-German readers as well)

A few days ago I wrote that I added CardSpace support to my blog. I've now cleaned up and commented my source code and you  can download it now.

CardSpace support for dasBlog - download

Use this file at your own risk. I do not guarantee that it is bug free or that it is the best and easiest way to add CardSpace to your blog. All I can say is that it works for me :).

You need .NET 3.0 on your server. You also need a valid SSL certificate (or otherwise you must create your own certificate with tools like selfssl form theIIS 6.0 resource kit and install it on every client from which you want to use the CardSpace login). For my blog, I use a SSL certificate that I bought from http://www.namecheap.com/, which costs less than 15$ / year.

To install CardSpace support for dasBlog, just copy CardSpaceLogin.aspx, CardSpaceLogin.aspx.cs, images\informationcard.gif and app_code\TokenProcessor.cs to your dasBlog directory. 

I'm not the author of TokenProcessor.cs, this file is part of the CardSpace samples on http://cardspace.netfx3.com.

In CardSpace v1, this only works via HTTPS. You need a valid SSL certificate for your web site. The user account under which you run dasBlog
must have access to the private key of your SSL certficate. The CardSpace samples on http://cardspace.netfx3.com contain a tool which can find the name and location of the file in which your SSL certificate is stored (findprivatekey.exe). Find that file and grant your dasBlog ASP .NET account read permissions.

To associate an existing user account with an information card, login by using username and password first. Then go to the CardSpace login page and select a card. This card will then be associated with your user account.

If you use this for your blog, please let me know by e-mail or by writing a comment for this blog entry.

In diesem Beitrag werde ich zeigen, wie sich Windows CardSpace in dasBlog integrieren lässt, ohne dass dafür Änderungen am Quellcode von dasBlog notwendig sind. Ziel ist, dass sich der Blog-Administrator mit Windows CardSpace anmelden kann. CardSpace soll in diesem Beispiel nicht für Besucher des Blogs genutzt werden (z.B. für die Kommentarfunktion), sondern nur für den Administrator.

Dafür sind einige Voraussetzungen erforderlich:

1) WebSpace mit .NET 3.0 Unterstützung

Zum Entschlüsseln des CardSpace-Tokens verwende ich die TokenProcessor Hilfsklasse von netfx3.com, die im Moment noch .NET 3.0 Klassen verwendet. Es soll aber bald eine .NET 1.1 Version dieser Klasse geben, so dass mein Code mit dieser Klasse (und noch 2-3 weiteren kleinen Änderungen - ich verwende generische Typen) ebenfalls auf .NET 1.1 laufen würde.

2) Ein SSL Zertifikat

CardSpace funktioniert nur mit einem gültigen und fehlerfreien SSL Zertifikat. Selbstausgestellte Zertifikate gehen auch, wenn sie im Client als vertrauenswürdige Zertifikate gespeichert werden, was in diesem Beispiel (Login nur für den Admin) noch ok wäre. Sollen sich beliebige Besucher der Seite über CardSpace anmelden, ist das keine akzeptable Alternative mehr.

Zum Glück gibt es aber mindestens einen sehr günstigen Anbieter, der Zertifikate für unter 15€ pro Jahr verkauft: http://www.namecheap.com/learn/other-services/cheap-ssl-certificate-rapidssl.asp

Dort habe ich auch ein Zertifikat für OutOfCoffeeException.de für 2 Jahre gekauft.

3) Der Prozess, unter dem dasBlog läuft, muss Zugriff auf den private Key des SSL Zertifikats haben, damit er die Security-Tokens entschlüsseln kann. Einige der Samples auf netfx3 (z.B. dieses) enthalten das Tool findprivatekey.exe, das die Datei, indem ein Zertifikat gespeicher ist, anzeigen kann. Auf diese Datei müssen Leserechte für den Prozess, unter dem dasBlog läuft, gesetzt werden.

Somit wären also die Vorbedingungen geklärt.

Mir war es wichtig, dass mein CardSpace-Login ohne Änderungen am dasBlog Quellcode selbst funktioniert, damit ich später problemlos neuere Versionen installieren kann, ohne meine Änderungen zu überschreiben. Ich habe deshalb eine neue Seite CardSpaceLogin.aspx erstellt, die die CardSpace Anmeldung übernimmt. Außerdem habe ich ein Makro geschrieben, dass einen Link "Anmeldung mit Windows CardSpace" erzeugt, der auf diese Seite verlinkt und das für CardSpace benötigte Object-Tag in die Hauptseite meines Blogs einbaut (wenn man in den Seitenquelltext schaut findet man es ganz am Ende der Seite). Sofern ich mein Blog über https aufgerufen habe kann ich mich so direkt vom Blog aus anmelden.

Die CardSpaceLogin.aspx Seite selbst besteht nur aus einem Button zum Anmelden mit CardSpace und einem Object-Tag:

(ja, der Code ist zu breit für mein Blog, im Moment habe ich aber keine Idee wie ich das schöner formattieren könnte)

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="CardSpaceLogin.aspx.cs" Inherits="_Default"
    ValidateRequest="false" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Windows CardSpace Login</title>
</head>
<body>
    <form id="CardSpaceForm" runat="server">
        <div style="text-align: center; padding: 128px;">
            <div style="text-align: center; padding: 32px; background-color: #a0ffa0;">
                <img src="/images/informationcard.gif" alt="Windows CardSpace" /><br /><br />
                <asp:Button runat="server" Text="Anmeldung mit Windows CardSpace" /><br />
                <asp:Literal ID="LoginStatus" runat="server"></asp:Literal>
                <object type="application/x-informationcard" name="xmlToken">
                    <param name="tokenType" value="urn:oasis:names:tc:SAML:1.0:assertion" />
                    <param name="requiredClaims" value="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/privatepersonalidentifier" />
                </object>
            </div>
        </div>
    </form>
</body>
</html>

 Dieser Object-Tag wird von Browsern, die CardSpace unterstützten, erkannt. In dem Moment wo der Button geklickt wird, wird das Formular "submitted", also die Formularinhalte an den Server übertragen. Da der Object-Tag im Formular steht, erkennt der Browser, dass er an dieser Stelle ein CardSpace-Securitytoken übermitteln soll. Also wird dem Benutzer ein Dialog (der Identityselector) angezeigt, in dem er eine Karte für die Anemdlung an der Seite auswählen kann. Das (verschlüsselte und signierte) SecurityToken wird anschließend an den Server übertragen und kann dort ausgewertet werden.

Etwas vereinfacht wird nun der folgende Code ausgeführt:

public partial class _Default : System.Web.UI.Page 
{
    protected void Page_Load(object sender, EventArgs e)
    {
        SiteConfig siteConfig = SiteConfig.GetSiteConfig();

        string stoken = Request["xmltoken"] as string;
        if (string.IsNullOrEmpty(stoken))
        {
            return;
        }

        Microsoft.IdentityModel.TokenProcessor.Token token = 
            new Microsoft.IdentityModel.TokenProcessor.Token(stoken);       

        List<CardSpaceToken> tokens = CardSpaceToken.GetTokens();

        // compare the token with all tokens in cardspaceSecurity.config
        foreach (CardSpaceToken cst in tokens)
        {
            // found token in cardSpacesecurity.config, now find
            // the user with the user name that was specified there
            if (token.UniqueID == cst.UniqueID)
            {
                SiteSecurityConfig securityConfig = SiteSecurity.GetSecurity();
                foreach (User user in securityConfig.Users)
                {
                    // found user with this CardSpace token. log the user in.
                    if (user.Name == cst.UserName)
                    {
                        Login(user.Name, user.Password);
                        Response.Redirect(Utils.GetBaseUrl(), true);
                        return;
                    }
                }
            }
        }        
    }

}

Mit der anfangs erwähnten Hilfsklasse TokenProcessor wird das Token entschlüsselt. Über die Klasse könnte ich sämtliche Inhalte des Tokens abfragen, mich interessiert hier aber nur die UniqueID. Diese ID ist für jeden Benutzer eindeutig, und ersetzt quasi Benutzername + Kennwort. Ich muss diese ID nur noch mit den IDs vergleichen, die ich bereits für meine Blog-Benutzer gespeichert habe. Finde ich eine passende gespeicherte ID, dann melde ich den Benutzer an. Falls ich keine ID finde, aber bereits ein Benutzer angemeldet ist, dann ordne ich die ID der verwendeten Karte diesem Benutzer zu (dieser Teil ist im Codeausschnitt oben schon nicht mehr zu sehen).

Das war's auch schon. Um CardSpace in meinem Blog zu verwenden musste ich keine einzige vorhandene Datei ändern, und nur 3 neue Dateien hinzufügen (CardSpaceLogin.aspx, CardSpaceLogin.aspx.cs und TokenProcessor.cs). Zusätzlich habe ich dann noch ein Makro geschrieben, um den Anmeldelink in mein Blog zu integrieren, aber das ist im prinzip schon zusätzliche Sonderausstattung :).

Ich werde in den nächsten Tagen den Code noch etwas aufräumen und anschließend veröffentlichen.

Ich bin nicht der erste, der CardSpace in dasBlog integriert. Eine andere Variante gibt es hier: Early SVN patch of DasBlog 1.9.6264 with information card support available. Für meine Variante ist jedoch keine Modifikation am original Quellcode erforderlich.

Da die vorhandenen DasBlog-Makros zum anzeigen von Kommentaren nicht ganz die Ausgabe erzeugen, die ich gerne haben wollte (und weil ich wegen einer neuen Kaffeemaschine und damit verbundenem zu hohen Kaffeekonsum nicht schlafen konnte), habe ich mir gestern Nacht zwei neue Makros geschrieben. Das eine zeigt die letzten 5 Kommentare, das andere eine Liste der Leute, die am häufigsten Kommentare in meinem Blog schreiben.

DasBlog lässt sich mit Makros sehr einfach um neue Funktionen erweitern. Wie das genau geht ist sehr schön auf der dasBlog Webseite beschrieben. Als Grundlage für meine Makros habe ich das Makro von Voidclass verwendet und erweitert.

Was man beachten sollte bei der Makroentwicklung: entwickelt man mit .NET 2.0, dann muss auch dasBlog auf 2.0 laufen, sonst funktioniert es natürlich nicht. Irgendwie hatte ich heute Nacht ein Brett vorm Kopf, ich habe ziemlich lange gebraucht um darauf zu kommen, obwohl ich das ja eigentlich wusste.

Den Quellcode zu meinen Makros gibt's auch zum Download: http://www.outofcoffeeexception.de/downloads/dasBlogCoffeeMacros.zip

Achtung: ich habe den Code irgendwann so um 4 oder 5 Uhr nachts geschrieben. Ich garantiere also für nichts. Der Code ist auch nicht besonders aufgeräumt oder gut kommentiert.

Und wer das Makro mal testen möchte, kann es ja direkt mit einem Kommentar zu diesem Eintrag ausprobieren :)