Est-il possible de se moquer d'un .NET HttpWebResponse?

Vous pouvez changer votre consommation de code à prendre dans une interface d'une usine qui crée les demandes et les réponses qui peuvent être moqué de qui encapsule la mise en œuvre effective.

Mise À Jour: Revisiter

J'ai été faire downvotes de temps après ma réponse a été acceptée, et j'avoue que ma réponse originale à cette question était de mauvaise qualité et a fait un gros hypothèse.

Moqueur HttpWebRequest en 4,5+

La confusion de ma réponse originale à cette question réside dans le fait que vous pouvez se moquer HttpWebResponse en 4.5, mais pas les versions antérieures. En se moquant de 4,5 utilise également obsolète constructeurs. Ainsi, le plan d'action recommandé est l'abstraction de la demande et la réponse. De toute façon, ci-dessous est un travail complet de test à l'aide .NET 4.5 Moq 4.2.

[Test]
public void Create_should_create_request_and_respond_with_stream()
{
    //arrange
    var expected = "response content";
    var expectedBytes = Encoding.UTF8.GetBytes(expected);
    var responseStream = new MemoryStream();
    responseStream.Write(expectedBytes, 0, expectedBytes.Length);
    responseStream.Seek(0, SeekOrigin.Begin);

    var response = new Mock<HttpWebResponse>();
    response.Setup(c => c.GetResponseStream()).Returns(responseStream);

    var request = new Mock<HttpWebRequest>();
    request.Setup(c => c.GetResponse()).Returns(response.Object);

    var factory = new Mock<IHttpWebRequestFactory>();
    factory.Setup(c => c.Create(It.IsAny<string>()))
        .Returns(request.Object);

    //act
    var actualRequest = factory.Object.Create("http://www.google.com");
    actualRequest.Method = WebRequestMethods.Http.Get;

    string actual;

    using (var httpWebResponse = (HttpWebResponse)actualRequest.GetResponse())
    {
        using (var streamReader = new StreamReader(httpWebResponse.GetResponseStream()))
        {
            actual = streamReader.ReadToEnd();
        }
    }


    //assert
    actual.Should().Be(expected);
}

public interface IHttpWebRequestFactory
{
    HttpWebRequest Create(string uri);
}

Meilleure réponse: Résumé de la Réponse et Demande

Voici un endroit plus sûr de bare-bones de la mise en œuvre d'une abstraction qui fonctionne pour les versions précédentes (bien, en baisse à 3,5): au moins

[Test]
public void Create_should_create_request_and_respond_with_stream()
{
//arrange
var expected = "response content";
var expectedBytes = Encoding.UTF8.GetBytes(expected);
var responseStream = new MemoryStream();
responseStream.Write(expectedBytes, 0, expectedBytes.Length);
responseStream.Seek(0, SeekOrigin.Begin);
var response = new Mock<IHttpWebResponse>();
response.Setup(c => c.GetResponseStream()).Returns(responseStream);
var request = new Mock<IHttpWebRequest>();
request.Setup(c => c.GetResponse()).Returns(response.Object);
var factory = new Mock<IHttpWebRequestFactory>();
factory.Setup(c => c.Create(It.IsAny<string>()))
.Returns(request.Object);
//act
var actualRequest = factory.Object.Create("http://www.google.com");
actualRequest.Method = WebRequestMethods.Http.Get;
string actual;
using (var httpWebResponse = actualRequest.GetResponse())
{
using (var streamReader = new StreamReader(httpWebResponse.GetResponseStream()))
{
actual = streamReader.ReadToEnd();
}
}
//assert
actual.Should().Be(expected);
}
public interface IHttpWebRequest
{
//expose the members you need
string Method { get; set; }
IHttpWebResponse GetResponse();
}
public interface IHttpWebResponse : IDisposable
{
//expose the members you need
Stream GetResponseStream();
}
public interface IHttpWebRequestFactory
{
IHttpWebRequest Create(string uri);
}
//barebones implementation
private class HttpWebRequestFactory : IHttpWebRequestFactory
{
public IHttpWebRequest Create(string uri)
{
return new WrapHttpWebRequest((HttpWebRequest)WebRequest.Create(uri));
}
}
public class WrapHttpWebRequest : IHttpWebRequest
{
private readonly HttpWebRequest _request;
public WrapHttpWebRequest(HttpWebRequest request)
{
_request = request;
}
public string Method
{
get { return _request.Method; }
set { _request.Method = value; }
}
public IHttpWebResponse GetResponse()
{
return new WrapHttpWebResponse((HttpWebResponse)_request.GetResponse());
}
}
public class WrapHttpWebResponse : IHttpWebResponse
{
private WebResponse _response;
public WrapHttpWebResponse(HttpWebResponse response)
{
_response = response;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
private void Dispose(bool disposing)
{
if (disposing)
{
if (_response != null)
{
((IDisposable)_response).Dispose();
_response = null;
}
}
}
public Stream GetResponseStream()
{
return _response.GetResponseStream();
}
}

Plutôt que de se moquant de la HttpWebResponse est je voudrais placer l'appel derrière une interface, et se moquer de cette interface.

Si l'on analyse la réponse web frappé le site je le veux aussi, c'est un test que si elle ne classe Un appel de l'WebResponse interface pour obtenir les données nécessaires.

Pour se moquant d'un interface, je préfère Rhino se moque de. Voir ici sur la façon de l'utiliser.

Aucun de Microsoft à l'adresse HTTP de la pile a été développé avec les tests unitaires et de la séparation dans l'esprit.

Vous disposez de trois options:

• Faire l'appel pour le web aussi petite que possible (c'est à dire d'envoyer et de récupérer des données et les transmettre à d'autres méthodes) et de tester le reste. Aussi loin que l'appel web est concerné, il devrait y avoir encore de la magie qui s'y passe et très simple.
• Envelopper le HTTP appel dans une autre classe et de passer votre maquette de l'objet lors des tests.
• Envelopper HttpWebResponse et HttpWebRequest par deux autres classes. C'est ce que le MVC équipe a fait avec HttpContext.

Deuxième option:

interface IWebCaller
{
string CallWeb(string address);
}

J'ai Trouvé une excellente solution dans ce post de blog:

Il est très facile à utiliser, il vous suffit pour ce faire:

string response = "my response string here";
WebRequest.RegisterPrefix("test", new TestWebRequestCreate());
TestWebRequest request = TestWebRequestCreate.CreateTestRequest(response);

Et copier ces fichiers à votre projet:

    class TestWebRequestCreate : IWebRequestCreate
{
static WebRequest nextRequest;
static object lockObject = new object();
static public WebRequest NextRequest
{
get { return nextRequest ;}
set
{
lock (lockObject)
{
nextRequest = value;
}
}
}
///<summary>See <see cref="IWebRequestCreate.Create"/>.</summary>
public WebRequest Create(Uri uri)
{
return nextRequest;
}
///<summary>Utility method for creating a TestWebRequest and setting
///it to be the next WebRequest to use.</summary>
///<param name="response">The response the TestWebRequest will return.</param>
public static TestWebRequest CreateTestRequest(string response)
{
TestWebRequest request = new TestWebRequest(response);
NextRequest = request;
return request;
}
}
class TestWebRequest : WebRequest
{
MemoryStream requestStream = new MemoryStream();
MemoryStream responseStream;
public override string Method { get; set; }
public override string ContentType { get; set; }
public override long ContentLength { get; set; }
///<summary>Initializes a new instance of <see cref="TestWebRequest"/>
///with the response to return.</summary>
public TestWebRequest(string response)
{
responseStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(response));
}
///<summary>Returns the request contents as a string.</summary>
public string ContentAsString()
{
return System.Text.Encoding.UTF8.GetString(requestStream.ToArray());
}
///<summary>See <see cref="WebRequest.GetRequestStream"/>.</summary>
public override Stream GetRequestStream()
{
return requestStream;
}
///<summary>See <see cref="WebRequest.GetResponse"/>.</summary>
public override WebResponse GetResponse()
{
return new TestWebReponse(responseStream);
}
}
class TestWebReponse : WebResponse
{
Stream responseStream;
///<summary>Initializes a new instance of <see cref="TestWebReponse"/>
///with the response stream to return.</summary>
public TestWebReponse(Stream responseStream)
{
this.responseStream = responseStream;
}
///<summary>See <see cref="WebResponse.GetResponseStream"/>.</summary>
public override Stream GetResponseStream()
{
return responseStream;
}
}