Diferentes valores de retorno la primera y segunda vez con Moq

Con la última versión de Moq(4.2.1312.1622), puede configurar una secuencia de eventos utilizando SetupSequence. He aquí un ejemplo:

_mockClient.SetupSequence(m => m.Connect(It.IsAny<String>(), It.IsAny<int>(), It.IsAny<int>()))
        .Throws(new SocketException())
        .Throws(new SocketException())
        .Returns(true)
        .Throws(new SocketException())
        .Returns(true);

La llamada a connect solo tendrá éxito en el tercer y quinto intento, de lo contrario se lanzará una excepción.

Así que para tu ejemplo sería algo como:

repository.SetupSequence(x => x.GetPageByUrl<IPageModel>(virtualUrl))
.Returns(null)
.Returns(pageModel.Object);

Las respuestas existentes son geniales, pero pensé en agregar mi alternativa que solo usa System.Collections.Generic.Queue y no requiere ningún conocimiento especial del framework burlón, ¡ya que no tenía ninguno cuando lo escribí! :)

var pageModel = new Mock<IPageModel>();
IPageModel pageModelNull = null;
var pageModels = new Queue<IPageModel>();
pageModels.Enqueue(pageModelNull);
pageModels.Enqueue(pageModel.Object);

Entonces...

repository.Setup(x => x.GetPageByUrl<IPageModel>(path)).Returns(pageModels.Dequeue);

Puede usar una devolución de llamada cuando configure su objeto simulado. Echa un vistazo al ejemplo del Wiki de Moq ( http://code.google.com/p/moq/wiki/QuickStart).

// returning different values on each invocation
var mock = new Mock<IFoo>();
var calls = 0;
mock.Setup(foo => foo.GetCountThing())
    .Returns(() => calls)
    .Callback(() => calls++);
// returns 0 on first invocation, 1 on the next, and so on
Console.WriteLine(mock.Object.GetCountThing());

Su configuración podría tener este aspecto:

var pageObject = pageModel.Object;
repository.Setup(x => x.GetPageByUrl<IPageModel>(path)).Returns(() => pageObject).Callback(() =>
            {
                // assign new value for second call
                pageObject = new PageModel();
            });

Ahora puede usar SetupSequence. Ver este post: http://codecontracts.info/2011/07/28/moq-setupsequence-is-great-for-mocking/

Alcanzado aquí para el mismo tipo de problema con requisitos ligeramente diferentes.
Necesito obtener diferentes valores de retorno de mock basados en diferentes valores de entrada y encontré una solución que IMO más legible ya que utiliza la sintaxis declarativa de Moq (linq to se burla).

public interface IDataAccess
{
   DbValue GetFromDb(int accountId);  
}

var dataAccessMock = Mock.Of<IDataAccess>
(da => da.GetFromDb(It.Is<int>(acctId => acctId == 0)) == new Account { AccountStatus = AccountStatus.None }
&& da.GetFromDb(It.Is<int>(acctId => acctId == 1)) == new DbValue { AccountStatus = AccountStatus.InActive }
&& da.GetFromDb(It.Is<int>(acctId => acctId == 2)) == new DbValue { AccountStatus = AccountStatus.Deleted });

var result1 = dataAccessMock.GetFromDb(0); // returns DbValue of "None" AccountStatus
var result2 = dataAccessMock.GetFromDb(1); // returns DbValue of "InActive"   AccountStatus
var result3 = dataAccessMock.GetFromDb(2); // returns DbValue of "Deleted" AccountStatus

El accepted answer, así como el SetupSequence answer, maneja constantes de retorno.

Returns() tiene algunas sobrecargas útiles donde puede devolver un valor basado en los parámetros que se enviaron al método burlado. Basado en la solución dada en la respuesta aceptada, aquí hay otro método de extensión para esas sobrecargas.

public static class MoqExtensions
{
    public static IReturnsResult<TMock> ReturnsInOrder<TMock, TResult, T1>(this ISetup<TMock, TResult> setup, params Func<T1, TResult>[] valueFunctions)
        where TMock : class
    {
        var queue = new Queue<Func<T1, TResult>>(valueFunctions);
        return setup.Returns<T1>(arg => queue.Dequeue()(arg));
    }
}

Desafortunadamente, usar el método requiere que especifique algunos parámetros de plantilla, pero el resultado sigue siendo bastante legible.

repository
    .Setup(x => x.GetPageByUrl<IPageModel>(path))
    .ReturnsInOrder(new Func<string, IPageModel>[]
        {
            p => null, // Here, the return value can depend on the path parameter
            p => pageModel.Object,
        });

Crear sobrecargas para el método de extensión con múltiples parámetros (T2, T3, etc) si es necesario.