Crazor.Test 1.0.3-beta

Writing Unit Tests for cards

Crazor has a companion assembly called Crazor.Test which implements helper classes/methods to make it super easy to test the logic of your cards.

To start you create a MSTest test project

Add Crazor package

Add the Crazor.Test package

nuget add package crazor.test

Modifications to your Web Project

1. Edit the .csproj to make it a aspnetcore project change <Project Sdk="Microsoft.NET.Sdk"> to <Project Sdk="Microsoft.NET.Sdk.Web">

   <Project Sdk="Microsoft.NET.Sdk.Web">
   

2. add a Cards folder (should be a peer to Pages folder)

3. add Cards/_ViewImports.cshtml file containing this:

   @using AdaptiveCards
   @using Crazor
   @using Crazor.Exceptions
   @using Crazor.Attributes
   @using System.Threading;
   @using System.Threading.Tasks;
   @using System.ComponentModel.DataAnnotations
   @removeTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
   @removeTagHelper *, Microsoft.AspNetCore.Mvc.Razor
   @addTagHelper *, Crazor
   @addTagHelper *, {YOUR ASSEMBLY NAME HERE}
   

Creating a unit test

Now we will create a card and write a unit tests against the card.

Create a test card Foo

1. Create a test card folder in cards/Foo

2. Create a Default.cshtml file in it

   @inherits CardView
   <Card Version="1.5">
    <TextBlock>Counter=@Counter</TextBlock>
       <Action.Execute Verb="@nameof(OnSubmit)"/>
   </Card>
   
   @functions {
    public int Counter {get;set;}
   
    public void OnSubmit() => Counter++;
   }
   

3. Now create a unit test for it by creating a .cs file called TestFoo.cs and deriving your class for CardTest

   using AdaptiveCards;
   using Crazor.Test;
   using Crazor.Test.MSTest;
   
   namespace MyTests
   {
       [TestClass]
       public class TestFoo : CardTest
       {
           [TestMethod]
           public async Task TestIncrementCounter()
           {
               // create an instance of the card by binding to it's route.
               await LoadCard("/Cards/Foo")
                   	// add assertion against the card
                       .AssertTextBlock("Counter=0")
                   // submit an action
                   .ExecuteAction("OnSubmit")
                   	// write assertions agains the card that is returned
                       .AssertTextBlock("Counter=1");
           }
       }
   }
   

That's it! The pattern is essentially that you

• use LoadCard(route) to instantiate a card.
  • You write assertions against the card
• call ExecuteAction() to send input into the card.
  • You write assertions against the card

Assertion Methods

Writing a custom assertion extension

All of the assertion methods are extensions to Task<CardTestContext>, so it is easy to create your own assertion helpers.

Here is the implementation of AssertTextBlock. You can see that you await the task to get the context. The context has

• Card - the adaptive card
• Services - The dependency injection services provider.

And it always returns the context back out so that the assertions can be chained together in a fluent style.

public static async Task<CardTestContext> AssertTextBlock(this Task<CardTestContext> contextTask, string id, string text)
{
    var context = await contextTask;
    var actual = context.Card.GetElements<AdaptiveTextBlock>().SingleOrDefault(el => el.Id == id)?.Text;
    Assert.AreEqual(text, actual, $"TextBlock[{id}] Expected:'{text}' Actual:'{actual}'");
    return context;
}