Läs artikeln i sin helhet här

Att köra manuella tester med hjälp av WCF Service Host och WCF Test Client är ett alternativ för att testa tjänsten i sin helhet. Manuella tester har sin plats i utvecklingscykeln men gapet mellan enhetstester och manuella tester bör fyllas med automatiserade integrationstester och funktionstester .

Då kommer vi till frågan hur vi på ett enkelt sätt kan husera WCF tjänsten och sedan exekvera de automatiserade testerna på den? Min rekommendation är att instansiera tjänstevärden inom ramen för din testklass (ServiceHost). För att slippa skriva all tråkig ServiceHost-kod nyttjer jag själv  ett bibliotek som kallas ServiceModelEx skrivet av Juval Löwy. Det  innehåller, bland mycket annat, klasser som förenklar konfigurering av WCF-värden. I sin absolut enklaste form räcker det med två rader kod; en rad för att instansiera tjänsten och öppna kanalen och en rad kod för att stänga kanalen och värden.

[TestClass]
public class when_process_is_successfully_invoked : ContextSpecification {

    protected IMyService    Service;
    protected bool          Result;

    protected override void Context() {
        //create instance and open ipc channel
        Service = InProcFactory.CreateInstance<MyService, IMyService>();
    }

    protected override void Because() {
        //execute integration test
        Result = Service.Process();
    }

    [TestMethod]
    public void should_return_true() {
        //assert state
        Assert.IsTrue(Result);
    }

    public override void Cleanup() {
        //close channel
        InProcFactory.CloseProxy(Service);
    }
}

Så min rekommendation till dig är att surfa över till IDesign.net och ladda ned ServiceModelEx. Användandet av ServiceModelEx behandlas även i Juvals bok.

I denna artikel visar jag hur du snabbt kommer igång med utvecklingen av en Windows Workflow Foundation (WF)-tjänst tillsammans med Windows Server AppFabric. Jag vill även påvisa att det nu är i princip lika enkelt att husera ett arbetsflöde och en WCF-tjänst som det är att husera en ASP.NET webbapplikation i IIS.

Värt att notera är att jag i denna artikel använder Windows Server AppFabric Beta 2 och Visual Studio 2010 RC vilket gör att detaljer kan skilja sig från de kommande versionerna.

Installera Windows Server AppFabric

För att installera Windows Server AppFabric på din utvecklingsburk kan jag varmt rekommendera användandet av Web Platform Installer (WebPI). Du får inte bara Windows Server AppFabric installerat utan WebPI gör också konfigurationen av Windows Server AppFabric åt dig. Himla smidigt för att snabbt komma igång med utvecklingen. Vill du istället ladda ned installationspaketet och göra installation och konfiguration manuellt så går naturligtvis det också bra. I denna artikel använder jag WebPI.

Efter installation av WebPI behöver jag aktivera Enterprise funktionerna i WebPI. Det gör jag genom att klicka på Options…

… följt av klick i Enterprise kryssrutan.

Nu får jag tillgång till en ytterligare flik i WebPI där valet Application Server finns.

Efter att jag klickat på Install installeras och konfigureras Windows Server AppFabric åt mig. (OK. Nu har jag skrivit Windows Server AppFabric för många gånger. Hädanefter skriver jag bara AppFabric men vi vet alla att det är Windows Server AppFabric jag menar och inget annat. Eller hur?).

Bygg Workflow Service

Jag startar Visual Studio 2010 med administratörsbehörighet (Run as administrator). Detta för att få interagera med IIS. Jag skapar sedan et nytt projekt av typen WCF Workflow Service Application.

Innan jag börjar utveckla min tjänst så vill jag ändra egenskaperna på projektet så Visual Studio förstår att det är AppFabric jag vill använda för test och inte den inbyggda webbservern. För att använda AppFabric så anger jag i projektets egenskaper att använda IIS – Use Local IIS Web server. Jag klickar också på Create Virtual Directory för att skapa den plats där min tjänst kommer exponeras.

Nu är jag redo att bygga min tjänst. Visual Studio skapade ett sekventiellt arbetsflöde åt mig när jag skapade projektet. För denna artikel räcker detta arbetsflöde bra. Vi kan se att det består av två aktiviteter – en aktivitet för att ta emot en förfråga och en aktivitet för att skicka svaret. Det är dessa två aktiviteter som utgör kontraktet för min tjänst. Namnet på tjänsteoperationen är GetData. För att se innehållet i meddelandet klickar jag på View message…

I dialogen Content Definition kan jag se att en variabel, med namn data, som är definierad i arbetsflödet tilldelas innehållet av meddelandet.

För att se vilka variabler jag har till förfogande för vald aktivitet klickar jag på Variables i arbetsflödesdesignern. Jag ser då mycket riktigt att data är definierad och att den är av typen System.Int32.

För sakens skull tittar jag även på svarsmeddelandet genom att klicka på View message… på SendResponse aktiviteten.

Jag kan då se att svarsmeddelandet innehåller samma värde som skickas in som parameter i förfrågan till tjänsten (data) men skickas istället tillbaka som en sträng (System.String). Detta är fullt tillräckligt för en enkel “ping”-tjänst. Men jag vill göra en “ping”-tjänst deluxe…

Jag tänker mig en tjänst som multiplicerar inkommande värde med 1000. För att göra det drar jag ut Assign-aktiviteten från verktygslådan in i mitt arbetsflöde och lägger den mellan Request och Response aktiviteterna.

När jag gjort det får jag ett valideringsfel. Det beror i detta fall på att jag ännu inte har angivit något utryck i Assign-aktiviteten.

Det är variabeln data som jag vill multiplicera med sig själv så jag skriver “data” i fältet To. Jag noterar då två saker med Assign-aktiviteten; Det första är att jag får IntelliSense i fälten för utryck. Det andra jag noterar är att utryck endast kan anges med Visual Basic.

Jag känner mig nu nöjd med min Workflow Service. Arbetsflödet ser nu ut som följer. Förfrågan kommer in – inkommande värde multipliceras med 1000 – produkten av multipliceringen skickas tillbaka i svaret.

Innan jag provkör min tjänst vill jag säkerställa mig om att tjänsten är satt som startsida. Visual Studio startar då WCF testklienten och refererar min tjänst automatiskt när jag sedan startar debuggern.

Dags att köra! => F5. WCF testklient startas och min tjänst refereras automatiskt. Jag anger “5” som parameter i förfrågan och får, som förväntat, “5000” till svar.

Men hur kan jag nu se att AppFabric har varit inblandat i allt detta?

Verktygen för att hantera AppFabric integreras med IIS Manager. Så jag startar IIS Manager och noterar att en ny sektion har lagts till i Features vyn för min applikation.

Genom att klicka på AppFabric Dashboard får jag en överblick av läget vad gäller tjänster och arbetsflöden. Jag ser att jag har ett arbetsflöde som har aktiverats och avslutats inom de senaste 24 timmarna.

Detta var en överblick av Windows Server AppFabric och WCF Workflow Services. Jag hoppas med den att du nu har fått ytterligare lite inspiration och framöver överväger att använda Windows Workflow Foundation (WF) tillsammans med Windows Communication Foundation (WCF) och Windows Server AppFabric för att implementera dina tjänster.

Om du är riktigt sugen på WF/WCF/AppFabric och vill anta utmaningen att bli en WF-AppFabric-Ninja så har vi en kanonbra två dagars gör-det-själv utbildning att ladda ned här.

First of - the ActiveRecord base class exposes a Paged method. Allowing you to easily get a paged list of the specific entity.

[Fact]
public void it_returns_the_given_number_of_entities() {

    var pageSize = 5;

    var entities = FakeEntity.Paged(pageSize);

    Assert.Equal(pageSize, entities.Count());
}

Second, The PagedList contains a NextPageToken property containing the ContinuationToken for the text page (if there’s one).

[Fact]
public void it_returns_a_page_token_for_the_next_page()
{
    var pageSize = 5;

    var entities = FakeEntity.Paged(pageSize);

    Assert.Equal("6@partition", entities.NextPageToken.Token);
}

Under the hood this is performed by my Skip method implemented as a IQueryable extensions – so the same code works for your unit tests and for “real” DataServiceQueries 

public static IPagedList<TEntity> Paged(int pageSize, string pageToken) {
    return ActiveRecordContext.Current
        .CreateQuery<TEntity>()
        .Skip(pageToken)
        .Take(pageSize)
        .ToPagedList();
}

public ActionResult Index(string page) {

    if(string.IsNullOrEmpty(page))
        return View(Task.Paged(PageSize)); 

    return View(Task.Paged(PageSize, page));
}

Jag körde först med John Lam’s Vibrant Ink port men tyckte efter ett tag, precis som Rob Conery, att det temat har lite för hög kontrast. Rob’s uppdatering tycker jag ger tydlig text som samtidigt är snäll mot ögonen.

För att importera ett tema väljer du alternativet Import and Export setting i Tools-menyn i Visual Studio. Kom ihåg att detta verktyg tillåter dig att importera och exportera mer eller mindre alla inställningar du kan göra i Visual Studio. Så innan du importerar någon annans inställningar kan det vara värt att exportera dina inställningar. Du kan också välja att bara importera eller exportera specifika inställningar, vilket gör att du kan importera t ex endast färger från ett “tema” du laddat ned.

En annan anpassning som jag också får frågor om är knapparna jag har för att byta profil snabbt. Med profil menar jag i praktiken inställningar för olika ändamål. Profilerna som jag har kallar jag “Code”, “Document” och “Present”. De representerar alla ett scenario som jag kan befinna mig i tillsammans med Visual Studio - Koda, dokumentera eller presentera.

Code är det läge som jag använder i majoriteten av min tid i Visual Studio. När jag skall presentera något och visa kod med t ex en projektor så använder jag Present profilen vilken tar bort onödiga fönster och har större fontstorlek. Document är mer eller mindre den “vanliga” C# profilen som ger kod med svart text på vit bakgrund – vilket jag tycker lämpar sig bättre för dokument och blogginlägg.

Varje knapp ovan exekverar ett makro i Visual Studio som läser in inställningarna för aktuell profil.

Private RootFolder As String = "c:\users\chrislof\Documents\Visual Studio 10\Settings\"

Public Sub ImportPresentationSettings()
   ImportSettingsFile("Presentation")
End Sub

Private Sub ImportSettingsFile(ByVal FileName As String)
   FileName = System.IO.Path.Combine(RootFolder, FileName & ".vssettings")
   DTE.ExecuteCommand("Tools.ImportandExportSettings", "-import:""" & FileName & """")
End Sub

Sara Ford har beskrivit detta förfarande i sin Visual Studio Tips & Tricks serie.

Ovan anpassningar fungerar (numera) precis lika bra i VS2010 som i VS2008. Möjligheterna har som du förstår funnits ett bra tag men jag tycker att de är väl värda lite nytt ljus.

På MSDN finns en redogörelse för de patchar som är applicerade på respektive Guest OS version samt information om vilka SDK versioner som är kompatibla med vilka Guest OS versioner.

Windows Azure Tools for Visual Studio v1.1 behöver du installera för att bygga Azure tjänster med Visual Studio 2010 RC.

Detaljerad information om SDK och Guest OS kompabilitet finner du här.

If we have a look on the test for the Create action, it first setups the Task entity for testing by calling its static Setup(int) method. By calling Setup it will use a local, in memory, repository and populate it with the given number of entities.

[Fact]
public void it_creates_new_task() {

    Task.Setup(0); //setup for test but don't create entities
    var controller = new TasksController();
    
    controller.Create(new Task());

    Assert.Equal(1, Task.All().Count());
}

The Setup method also allows you to specify how the pre-populated entities will be initialized with data. In the example below the Task repository will be populated with one Task with a RowKey of "1" and a PartitionKey of "AR4A".

[Fact]
public void it_should_display_requested_task() {

    Task.Setup(1)
        .With(x => x.RowKey).Returns("1")
        .With(x => x.PartitionKey).Returns("AR4A"); //for now.. 

    var controller = new TasksController();
    var result = controller.Edit("1") as ViewResult;

    Assert.Equal("1", ((Task)result.ViewData.Model).RowKey);

}

So the stubs support in "ActiveRecord for Azure" basically shows how to substitute the "cloud aware" DataServiceContext with an in-memory context, allowing you to unit test your applications without accessing Windows Azure Table Storage.

The above examples are available in the download below.

The complete “ActiveRecord for Azure” sample source is available here.

När skall man använda vad? Varför bytte ADO.NET Data Services och .NET RIA Services namn till WCF Data Services respektive WCF RIA Services?

Produktgruppen reder ut begreppen här.

Visual Studio 2010 Beta 2 släpptes som bekant i oktober månad. Vid den tidpunkten vad den senaste versionen av Windows Azure verktygen för Visual Studio den version som släpptes i juli. Detta gjorde att Visual Studio teamet valde att inte skicka med verktygen för Windows Azure i Visual Studio 2010 Beta 2 då de visste att det kommer en ny version i samband med Windows Azure releasen på PDC. Men det är inte så illa som det kanske låter. De såg istället till att det fanns ett enkelt sätt att installera Windows Azure verktygen när de väl är släppta.

När du väljer att skapa ett nytt projekt av typen Windows Azure Cloud Service så kommer du första gången att skickas till webbsidan för nedladdning och installation av Visual Studio Tools for Windows Azure. En helt respektabel lösning på det hela tycker jag. När Visual Studio 2010 släpps någon gång i vår så kan vi nog vara ganska säkra på att de har synkat releaserna. (Detta gäller också ASP.NET MVC 2 men är en annan historia)

När jag har skapat mitt projekt får jag möjligheten att lägga till en eller flera sk Roller. En Roll är helt enkelt en viss typ av applikation som kan köras i Windows Azure. Några nyheter som vi kan se här är bland annat roller för WCF och ASP.NET MVC. Just nu kör jag på Visual Web Developer 2010 Express (gratisversionen av Visual Studio) vilket gör att jag inte får tillgång till den nya F# Worker-rollen.

Nu när min molntjänst har skapats har jag fått två projekt i Visual Studio. Det ena projektet är definitionen av min molntjänst (CloudService11) – denna innehåller, bland en hel del annat,  information om vilka roller som ingår och antalet instanser av dessa roller.

Med Visual Studio 2010 kommer också .NET Framework 4 (eller om man nu ser på det åt andra hållet). Som standard när jag skapar ett nytt projekt i Visual Studio 2010 så är det förvalt att projektet skall köras på just .NET Framework 4. Vad jag måste ha i åtanke här är att Windows Azure inte, än, stöder .NET Framework 4 utan där är det .NET Framework 3.5 SP1 som gäller. Jag måste alltså ändra vilket ramverk min molntjänst skall baseras på för att kunna publicera den till Windows Azure. Med någon av betalversionerna av Visual Studio 2010 kan jag välja detta direkt när projektet skapas men iom att jag nu gör Express får jag ändra detta i efterhand. Detta gör jag genom att högerklicka på mitt webbprojekt och välja Properties. I denna vy ser jag sedan till att Target framework är satt till .NET Framework 3.5.

Vad jag också brukar göra är att ändra antalet instanser av varje roll. Det är nämligen så att man måste ha minst två instanser av varje roll för att fastställda SLA:er skall gälla. För att göra detta dubbelklickar jag på min roll Hello World och justerar därefter värdet på Instance count till 2. Vad som också kan vara värt att lägga märke till här är möjligheten att välja storlek på den virtuella maskin som min roll (webbapplikation i detta fall) kommer installeras och köras i. En Small är en burk med ca 2GB RAM och 1 processorkärna. För varje storlek dubblas kapaciteten, vilket gör att en ExtraLarge är på ca 16GB RAM och 8 processorkärnor.

Jag har nu knåpat på min webbapplikation och vill prova den i Windows Azure. Jag skulle kunna publicera den till molnet och testa där men ett mycket snabbare sätt är att köra den i den lokala simuleringsmiljön Windows Azure Simulation Environment. Genom att starta debuggern (F5) startas också simuleringsmiljön och min molntjänst publiceras dit.

Genom att öppna Development Fabric kan jag nu se att jag har två instanser av min Hello World webbapplikation rullandes.

Nu när jag känner mig nöjd med min molntjänst högerklickar jag på mitt molntjänstprojekt och väljer Publish. Visual Studio skapar då ett paket som är redo att laddas upp till Windows Azure.

Lycka till i molnet och God Jul!

Mer läsning

• Getting Started
• Kom igång med Windows Azure idag!
• Tävla och vinn i molnet – Windows Azure Developer Challange

Wire it up

First I’ve to set up the “ActiveRecord for Azure” environment – that’s; create tables, wire up configuration change handlers etc. I’ve put all this kind of logic into the ActiveRecordEnvironment class. All I have to do is to call its Start-method. Probably the best place to do this is in the RoleInstance startup event. To do that I just create a class which derives from RoleEntryPoint and overrides its OnStart –method.

public class WebRole : RoleEntryPoint
{
    public override bool OnStart()
    {
        //start the ActiveRecord environment
        ActiveRecordEnvironment.Start(this);

        return base.OnStart();
    }
}

The Model

I’m now ready to implement my Model. Since it’s a Task List application I’m building the Model at least  needs to have a Task entity. To store an entity in Windows Azure Tables it has to have three properties called RowKey, PartitionKey and Timestamp.  You could certainly write these yourself (or derive from TableServiceEntity) but you have to handle the generation and associations of RowKeys and PartitionKeys “manually”.  The ActiveRecord base class takes care of this for me and also equips the entity with the CRUD operations.

public class Task : ActiveRecord<Task>
{
    [Required]
    public string Title { get; set; }
    
    public DateTime Due { get; set; }

    public bool Complete { get; set; }
}

As you probably already recognized I’m using the validation attribute Required from the System.ComponentModel.DataAnnotations namespace to mark the Title property as mandatory. ASP.NET MVC 2 now knows how to handle these validation attributes. (No more validation logic scattered through out the app – yay!).

The Controller 

Listing all Tasks is as simple as calling the All-method on the Task class (provided by the ActiveRecord base class)

public ActionResult Index() {
    return View(Task.All());
}

As you can see in the below Edit Action Method the data access code is minimal. Allowing you to focus on the business problem while leveraging the performance of Windows Azure Table Storage. The “ActiveRecord for Azure” specific code rows are commented with “AR4A” – all other rows are just plain vanilla ASP.NET MVC.

[HttpPost]
public ActionResult Edit(string id, Task task) {
    var existingTask = Task.Find(id); //AR4A

    try {
        UpdateModel(existingTask);
        existingTask.Save(); //AR4A

        return RedirectToAction("Index");
    }catch {
        return View(task);
    }
}

To delete an entity I just call (you probably already figured this one out – didn’t you?) – Delete.

[HttpPost]
public ActionResult Delete(string id) {
    Task.Delete(id); //AR4A
    return RedirectToAction("Index");
}

In the above example I called the static Delete-method and passed in the Id (RowId) of the Task to delete. I could also have called the Delete method on the specific Task instance to delete it.

Wrapping it up

So in just a few minutes I built myself a Task List application using Windows Azure and ASP.NET MVC 2. It’s so nice not having to spend hours on infrastructure code that in itself doesn’t provide any business value – isn’t it?

You can download the full example below. Please remember – this comes as-is and should be considered example code only.