public void ByteArray_Ok_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <byte[]>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Ok(settings, response: stream)
))
this.ShouldStreamOfCopy(request);
}
public void String_Bad_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <string>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
this.ShouldStreamOfCopy(request, false);
}
public async Task String_Bad_DiscardResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <string>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
).Init())
this.ShouldStreamOfCopy(request, success: false, keepRaw: false);
}
public async Task Stream_Ok_DiscardResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <Stream>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Ok(settings, response: stream)
).Init())
this.ShouldDirectlyStream(request);
}
public async Task ByteArray_Bad_KeepResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <byte[]>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
).Init())
this.ShouldStreamOfCopy(request, success: false);
}
public async Task String_Ok_KeepResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <string>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Ok(settings, response: stream)
).Init())
this.ShouldStreamOfCopy(request);
}
public async Task ByteArray_Ok_DiscardResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <byte[]>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Ok(settings, response: stream)
).Init())
this.ShouldStreamOfCopy(request, keepRaw: false);
}
public void Stream_Ok_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <Stream>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Ok(settings, response: stream)
))
this.ShouldDirectlyStream(request, success: true);
}
public void Stream_Bad_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <Stream>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
this.ShouldDirectlyStream(request, success: false);
}
public async Task Typed_Bad_KeepResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <StandardResponse>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
).Init())
this.ShouldStreamOfCopy(request, false);
}
public async Task Stream_Bad_KeepResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <Stream>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
).Init())
this.ShouldDirectlyStream(request, success: false);
}
public void ByteArray_Bad_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <byte[]>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
this.ShouldStreamOfCopy(request, success: false, keepRaw: false);
}
public void String_Ok_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <string>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Ok(settings, response: stream)
))
this.ShouldStreamOfCopy(request, keepRaw: false);
}
public void Typed_Ok_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <StandardResponse>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Ok(settings, response: stream)
))
this.ShouldDirectlyStream(request);
}
public async Task EnsureRefreshAuthenticationTokenAsyncThrowsForFailedCalls()
{
var client = new MusicClient("test", "gb", new MockApiRequestHandler(FakeResponse.InternalServerError()));
var token = AuthTokenTests.GetTestAuthToken();
token.ExpiresUtc = DateTime.UtcNow.AddDays(-1);
client.SetAuthenticationToken(token);
var result = await client.RefreshAuthenticationTokenAsync("secret");
}
public async Task DynamicDictionary_Bad_DiscardResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <DynamicDictionary>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
).Init())
this.ShouldDirectlyStream(request, false);
}
public async Task EnsureRefreshAuthenticationTokenAsyncReturnsExistingTokenIfValid()
{
var client = new MusicClient("test", "gb", new MockApiRequestHandler(FakeResponse.NotFound()));
var token = AuthTokenTests.GetTestAuthToken();
client.SetAuthenticationToken(token);
var result = await client.RefreshAuthenticationTokenAsync("secret");
Assert.AreEqual(token.AccessToken, result.AccessToken, "Expected the same token");
}
public async System.Threading.Tasks.Task UnauthorizedResponseDoesNothingInDefaultImplementation()
{
var command = new MockMusicClientCommand
{
OAuth2 = new OAuth2(new FakeAuthHeaderProvider()),
RequestHandler = new MockApiRequestHandler(FakeResponse.RawUnauthorized()),
};
await command.ExecuteAsync(null);
}
public async Task DynamicDictionary_Ok_KeepResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <DynamicDictionary>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Ok(settings, response: stream),
c => c.InfoAsync()
).Init())
this.ShouldStreamOfCopy(request);
}
public void DynamicDictionary_Bad_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <DynamicDictionary>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream),
client => client.Info()
))
this.ShouldDirectlyStream(request, false);
}
CreateMockRule(FakeRequest fakeRequest, FakeResponse fakeResponse, RuleStatusType statusType, bool continueProcessing)
{
var mockRule = new Mock <IBaseRule <FakeRequest, FakeResponse> >();
mockRule.Setup(x => x.ProcessAsync(fakeRequest, fakeResponse, ItIsAnyRules())).Returns(Task.CompletedTask);
mockRule.Setup(x => x.Status).Returns(statusType);
mockRule.Setup(x => x.IsNotProcessed()).Returns(statusType == RuleStatusType.NotProcessed);
mockRule.Setup(x => x.ContinueProcessing).Returns(continueProcessing);
return(mockRule);
}
public void VoidResponse_Bad_DiscardResponse(object responseValue)
{
using (var request = new MemorySetup <VoidResponse>(
responseValue,
settings => settings.ExposeRawResponse(false),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
//voidResponse NEVER reads the body so Raw is always false
this.ShouldDirectlyStream(request, success: false);
}
public void DynamicDictionary_Ok_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <DynamicDictionary>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Ok(settings, response: stream),
client => client.Info()
))
this.ShouldStreamOfCopy(request);
}
public async void DeadNodesAreNotVisited_AndPingedAppropiately_Async()
{
using (var fake = new AutoFake())
{
var dateTimeProvider = ProvideDateTimeProvider(fake);
var config = ProvideConfiguration(dateTimeProvider);
var connection = ProvideConnection(fake, config);
var getCall = FakeCalls.GetCall(fake);
var ok = Task.FromResult(FakeResponse.Ok(config));
var bad = Task.FromResult(FakeResponse.Bad(config));
getCall.ReturnsNextFromSequence(
ok, //info 1 - 9204
bad, //info 2 - 9203 DEAD
ok, //info 2 retry - 9202
ok, //info 3 - 9201
ok, //info 4 - 9204
ok, //info 5 - 9202
ok, //info 6 - 9201
ok, //info 7 - 9204
ok, //info 8 - 9203 (Now > Timeout)
ok //info 9 - 9202
);
var seenNodes = new List <Uri>();
getCall.Invokes((Uri u, IRequestConnectionConfiguration o) => seenNodes.Add(u));
var pingCall = FakeCalls.PingAtConnectionLevelAsync(fake);
pingCall.Returns(ok);
var client1 = fake.Resolve <ElasticsearchClient>();
await client1.InfoAsync(); //info call 1
await client1.InfoAsync(); //info call 2
await client1.InfoAsync(); //info call 3
await client1.InfoAsync(); //info call 4
await client1.InfoAsync(); //info call 5
await client1.InfoAsync(); //info call 6
await client1.InfoAsync(); //info call 7
await client1.InfoAsync(); //info call 8
await client1.InfoAsync(); //info call 9
AssertSeenNodesAreInExpectedOrder(seenNodes);
//4 nodes first time usage + 1 time after the first time 9203 came back to live
pingCall.MustHaveHappened(Repeated.Exactly.Times(5));
}
}
public void VoidResponse_Bad_KeepResponse(object responseValue)
{
using (var request = new MemorySetup <VoidResponse>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Bad(settings, response: stream)
))
//voidResponse NEVER reads the body so Raw is always false
//and no intermediate stream should be created
this.ShouldDirectlyStream(request, success: false);
}
public void BaseSetup()
{
MockHttpContext = new Mock <HttpContextBase>();
MockRequest = new Mock <HttpRequestBase>();
FakeResponse = new FakeResponse();
Routes = new RouteCollection();
Routes.RegisterRoutes();
MockHttpContext.Setup(m => m.Request).Returns(MockRequest.Object);
MockHttpContext.Setup(m => m.Response).Returns(FakeResponse);
}
public async Task VoidResponse_Ok_KeepResponse(object responseValue)
{
using (var request = await new AsyncMemorySetup <VoidResponse>(
responseValue,
settings => settings.ExposeRawResponse(true),
(settings, stream) => FakeResponse.Ok(settings, response: stream)
).Init())
//voidResponse NEVER reads the body so Raw is always false
//and no intermediate stream should be created
this.ShouldDirectlyStream(request);
}
public void EnsureCountryResolverPassesDefaultSettings()
{
MockApiRequestHandler mockHandler = new MockApiRequestHandler(FakeResponse.NotFound());
ICountryResolver client = new CountryResolver("test1", mockHandler);
client.CheckAvailability(result => Assert.IsNotNull(result, "Expected a result"), "xx");
Assert.AreEqual("test1", mockHandler.LastUsedSettings.AppId);
Assert.AreEqual(null, mockHandler.LastUsedSettings.CountryCode);
Assert.AreEqual(false, mockHandler.LastUsedSettings.CountryCodeBasedOnRegionInfo);
}
public async Task ProcessAsyncCanChangeStatusAndContinueProcessing(string scenario, bool expectedContinueProcessing,
RuleStatusType expectedRuleStatusType, FakeRule rule, List <IBaseRule <FakeRequest, FakeResponse> > rules)
{
var request = new FakeRequest {
ContinueProcessing = expectedContinueProcessing
};
var response = new FakeResponse();
await rule.ProcessAsync(request, response, rules);
Assert.AreEqual(expectedContinueProcessing, rule.ContinueProcessing, scenario);
Assert.AreEqual(expectedRuleStatusType, rule.Status, scenario);
}
public void EnsureUriIsBuiltCorrectlyForTrack()
{
StringBuilder uri = new StringBuilder("http://api.ent.nokia.com/1.x/gb/");
var cmd = new NewReleasesCommand
{
RequestHandler = new MockApiRequestHandler(FakeResponse.NotFound()),
Category = Category.Track,
ClientSettings = new MockMusicClientSettings(string.Empty, string.Empty, string.Empty)
};
cmd.AppendUriPath(uri);
Assert.AreEqual("http://api.ent.nokia.com/1.x/gb/products/new/track/", uri.ToString());
}
private string GetOutboundUrl(object routeValues)
{
RouteCollection routes = new RouteCollection();
RouteConfig.RegisterRoutes(routes);
var mockHttpContext = new Moq.Mock<HttpContextBase>();
var mockRequest = new Moq.Mock<HttpRequestBase>();
var fakeResponse = new FakeResponse();
mockHttpContext.Setup(x => x.Request).Returns(mockRequest.Object);
mockHttpContext.Setup(x => x.Response).Returns(fakeResponse);
mockRequest.Setup(x => x.ApplicationPath).Returns("/");
var ctx = new RequestContext(mockHttpContext.Object, new RouteData());
return routes.GetVirtualPath(ctx, new RouteValueDictionary(routeValues)).VirtualPath;
}
public void MyTestInitialize()
{
string appPath = FileHelper.CombineTrackbacksInPath(
Path.Combine(TestContext.TestDir, @"..\..\WebCore\"));
container = new Container(new FileRegistry(appPath));
var mockHttpContext = new Moq.Mock<HttpContextBase>();
var mockRequest = new Moq.Mock<HttpRequestBase>();
var fakeResponse = new FakeResponse();
var fakeAppState = new FakeApplicationState();
fakeAppState.Add("Container", container);
mockHttpContext.Setup(x => x.Request).Returns(mockRequest.Object);
mockHttpContext.Setup(x => x.Response).Returns(fakeResponse);
mockHttpContext.Setup(x => x.Application).Returns(fakeAppState);
mockRequest.Setup(x => x.ApplicationPath).Returns("/");
var requestContext = new RequestContext(mockHttpContext.Object, new RouteData());
container.Configure(a => a.For<UrlHelper>().Use(f => new UrlHelper(requestContext)));
PluginEngine.LoadPlugins(container, RouteTable.Routes, ViewEngines.Engines, ModelBinders.Binders, appPath, TestContext.TestDeploymentDir);
}
