WF4.0进行单元测试

[TestMethod] 
public void ShouldAddGoodSumAssertOutArgument() 
{ 
    var output = WorkflowInvoker.Invoke(new GoodSum() { x = 1, y = 2 }); 
 
    AssertOutArgument.AreEqual(output, "sum", 3); 
}

public sealed class ReadLine : NativeActivity<string> 
{ 
    private BookmarkCallback _readCompleteCallback; 
 
    [RequiredArgument] 
    public InArgument<string> BookmarkName { get; set; } 
 
    protected override bool CanInduceIdle 
    { 
        get { return true; } 
    } 
 
    public BookmarkCallback ReadCompleteCallback 
    { 
        get { return _readCompleteCallback ?? (_readCompleteCallback = new BookmarkCallback(OnReadComplete)); } 
    } 
 
    protected override void Execute(NativeActivityContext context) 
    { 
        // Inform the host that this activity needs data and wait for the callback 
        context.CreateBookmark(BookmarkName.Get(context), ReadCompleteCallback); 
    } 
 
    private void OnReadComplete(NativeActivityContext context, Bookmark bookmark, object state) 
    { 
        // Store the value returned by the host 
        context.SetValue(Result, state as string); 
    } 
}

[TestMethod] 
public void ShouldOutputGreeting() 
{ 
    // Arrange 
    const string expectedFirstName = "Test"; 
    const string expectedLastName = "User"; 
    var expectedGreeting = string.Format("Hello {0} {1}", expectedFirstName, expectedLastName); 
    var sut = WorkflowApplicationTest.Create(new TestReadLine()); 
 
    // Act 
 
    // Run the workflow 
    sut.TestActivity(); 
 
    // Wait for the first idle event - prompt for First Name 
    // will return false if the activity does not go idle within the 
    // timeout (default 1 sec) 
    Assert.IsTrue(sut.WaitForIdleEvent()); 
 
    // Should have a bookmark named "FirstName" 
    Assert.IsTrue(sut.Bookmarks.Contains("FirstName")); 
 
    Assert.AreEqual(BookmarkResumptionResult.Success, 
                    sut.TestWorkflowApplication.ResumeBookmark("FirstName", expectedFirstName)); 
 
    // Wait for the second idle event - prompt for Last Name 
    Assert.IsTrue(sut.WaitForIdleEvent()); 
 
    // Should have a bookmark named "LastName" 
    Assert.IsTrue(sut.Bookmarks.Contains("LastName")); 
 
    Assert.AreEqual(BookmarkResumptionResult.Success, 
                    sut.TestWorkflowApplication.ResumeBookmark("LastName", expectedLastName)); 
 
    // Wait for the workflow to complete 
    Assert.IsTrue(sut.WaitForCompletedEvent()); 
 
    // Assert 
    // WorkflowApplicationTest.TextLines returns an array of strings 
    // that contains strings written by the WriteLine activity 
    Assert.AreEqual(4, sut.TextLines.Length); 
    Assert.AreEqual(expectedGreeting, sut.TextLines[2]); 
}

    public sealed class GetAverage : CodeActivity<string>
    {
        public InArgument<int> Number { get; set; }


        protected override void CacheMetadata(CodeActivityMetadata metadata)
        {
            // This activity requires the average extension
            metadata.RequireExtension(typeof (AverageExtension));

            // This lambda will create one if it is not already added
            metadata.AddDefaultExtensionProvider(() => new AverageExtension());

            base.CacheMetadata(metadata);
        }

        protected override string Execute(CodeActivityContext context)
        {
            // Get the average extension
            var average = context.GetExtension<AverageExtension>();

            if (average == null)
                throw new InvalidOperationException("Cannot access AverageExtension");

            var number = Number.Get(context);

            // Store this number
            average.StoreNumber(number);

            return string.Format("Stored {0}, Average:{1}", number, average.GetAverage());
        }
    }

private readonly Binding _binding = new NetNamedPipeBinding(); 
 
/// <summary> 
///   The endpoint address to be used by the test host 
/// </summary> 
private readonly EndpointAddress _serviceAddress = new EndpointAddress("net.pipe://localhost/TestService"); 
 
 
/// <summary> 
/// Tests the GetAverage Activity by invoking it in a WorkflowService multiple times 
/// </summary> 
[TestMethod()] 
[DeploymentItem("Service1.xamlx")] 
public void ShouldInvokeAverageExtension() 
{ 
    const string expected1 = "Stored 33, Average:33"; 
    const string expected2 = "Stored 44, Average:38.5"; 
    const string expected3 = "Stored 55, Average:44"; 
 
    string result1; 
    string result2; 
    string result3; 
 
    // Self-Host Service1.xamlx using Named Pipes 
    using (var testHost = WorkflowServiceTestHost.Open("Service1.xamlx", _serviceAddress.Uri)) 
    { 
        // Use the generated proxy with named pipes  
        var proxy = new ServiceClient(_binding, _serviceAddress); 
 
        try 
        { 
            result1 = proxy.GetData(33); 
            result2 = proxy.GetData(44); 
            result3 = proxy.GetData(55); 
            proxy.Close(); 
        } 
        catch (Exception) 
        { 
            proxy.Abort();             
            throw; 
        } 
 
        Assert.AreEqual(expected1, result1); 
        Assert.AreEqual(expected2, result2); 
        Assert.AreEqual(expected3, result3); 
    } 
}