Frictionless WCF service consumption in Silverlight - Part 3: Benefits of transparent asynchrony with respect to unit testing

using System;
using System.Collections.ObjectModel;
using System.ServiceModel;

using Microsoft.Silverlight.Testing;
using Microsoft.VisualStudio.TestTools.UnitTesting;

using Rhino.Mocks;

using Sample.Silverlight.WCF.Infrastructure;
using Sample.Silverlight.WCF.Web.Services;

using ITaskService = Sample.Silverlight.WCF.Tests.Clumsy.ServiceReference1.ITaskService;

namespace Sample.Silverlight.WCF.Tests.Clumsy
{
	public class TaskManagementViewModelWithMocking : ViewModelBase
	{
		Task selected;
		Func<ITaskService> serviceFactory;

		public TaskManagementViewModelWithMocking(Func<ITaskService> serviceFactory)
		{
			this.serviceFactory = serviceFactory;
			Tasks = new ObservableCollection<Task>();
		}

		public ObservableCollection<Task> Tasks
		{
			get; private set;
		}

		public Task Selected
		{
			get { return selected; }
			set
			{
				selected = value;
				NotifyOfPropertyChange(() => Selected);
			}
		}

		public void Activate()
		{
			var service = serviceFactory();

			service.BeginGetAll(ar =>
			{
				try
				{
					var all = service.EndGetAll(ar);

					foreach (Task each in all)
					{
						Tasks.Add(each);
					}

					Selected = Tasks[0];
				}
				catch (FaultException exc)
				{
					// ... some exception handling code ...
				}
			}, null);
		}
	}

	[TestClass]
	public class TaskManagementViewModelWithMockingFixture : SilverlightTest
	{
		[TestMethod]
		public void Should_query_service_for_current_tasks_on_first_activation()
		{
			// arrange
			var expectedData = new ObservableCollection<Task>
			{
				CreateTask("Task1"), 
				CreateTask("Task2")
			};

			var mock = MockRepository.GenerateMock<ITaskService>();
			var asyncResult = MockRepository.GenerateMock<IAsyncResult>();

			// need to setup expectations for both APM methods
			mock.Expect(service => service.BeginGetAll(null, null))
				.IgnoreArguments().Return(asyncResult);

			mock.Expect(service => service.EndGetAll(asyncResult))
				.Return(expectedData);

			var model = new TaskManagementViewModelWithMocking(() => mock);

			// act
			model.Activate();

			// we need this to actually complete the call
			Callback(mock, service => service.BeginGetAll(null, null))(asyncResult);

			// assert
			Assert.AreEqual(2, model.Tasks.Count);
			Assert.AreSame(model.Tasks[0], model.Selected);
		}

		static AsyncCallback Callback<TService>(TService mock, Action<TService> method)
		{
			var arguments = mock.GetArgumentsForCallsMadeOn(method);
			return (AsyncCallback)arguments[0][0];
		}

		static Task CreateTask(string description)
		{
			return new Task {Id = new Guid(), Description = description};
		}
	}
}