public async Task Save_ShouldCallsTheCorrectUrlAndHaveTheCorrectBody()
{
async Task <AblyRequest> CallSave(PushChannelSubscription subscription)
{
AblyRequest request = null;
var rest = GetRestClient(r =>
{
request = r;
return(Task.FromResult(new AblyResponse()
{
TextResponse = string.Empty
}));
});
await rest.Push.Admin.ChannelSubscriptions.SaveAsync(subscription);
return(request);
}
var sub = PushChannelSubscription.ForDevice("test");
var request = await CallSave(sub);
request.Url.Should().Be("/push/channelSubscriptions");
request.Method.Should().Be(HttpMethod.Post);
request.PostData.Should().BeSameAs(sub);
}
public async Task List_ShouldCallCorrectUrlAndQueryParameters()
{
async Task <AblyRequest> ListDevices(ListDeviceDetailsRequest query)
{
AblyRequest currentRequest = null;
var client = GetRestClient(request =>
{
currentRequest = request;
return(Task.FromResult(new AblyResponse()
{
StatusCode = HttpStatusCode.OK, TextResponse = "[]"
}));
});
await client.Push.Admin.DeviceRegistrations.List(query);
return(currentRequest);
}
var emptyFilterRequest = await ListDevices(ListDeviceDetailsRequest.Empty(100));
emptyFilterRequest.Url.Should().Be("/push/deviceRegistrations");
emptyFilterRequest.QueryParameters.Should().HaveCount(1);
emptyFilterRequest.QueryParameters.Should().ContainKey("limit");
var deviceIdRequest = await ListDevices(ListDeviceDetailsRequest.WithDeviceId("123"));
deviceIdRequest.Url.Should().Be("/push/deviceRegistrations");
deviceIdRequest.QueryParameters.Should().ContainKey("deviceId").WhoseValue.Should().Be("123");
var clientIdRequest = await ListDevices(ListDeviceDetailsRequest.WithClientId("234"));
clientIdRequest.Url.Should().Be("/push/deviceRegistrations");
clientIdRequest.QueryParameters.Should().ContainKey("clientId").WhoseValue.Should().Be("234");
}
public async Task Save_ShouldNotAddDeviceAuthenticationWhenDeviceIdDoesNotMatchLocalDeviceSaved()
{
AblyRequest executedRequest = null;
var restClient = GetRestClient(request =>
{
executedRequest = request;
return(Task.FromResult(new AblyResponse()
{
TextResponse = string.Empty
}));
});
var deviceDetails = new LocalDevice()
{
Id = "123"
};
restClient.Device = new LocalDevice()
{
Id = "456", DeviceIdentityToken = "token"
};
_ = await restClient.Push.Admin.DeviceRegistrations.SaveAsync(deviceDetails);
executedRequest.Headers.Should().NotContainKey(Defaults.DeviceIdentityTokenHeader);
}
protected RestClient GetRestClient()
{
var rest = new RestClient(opts => { opts.Key = ValidKey; opts.UseBinaryProtocol = false; });
rest.ExecuteHttpRequest = x => { _currentRequest = x; return(new AblyResponse()); };
return(rest);
}
public static void AssertContainsParameter(this AblyRequest request, string key, string value)
{
Assert.True(
request.QueryParameters.ContainsKey(key),
$"Header '{key}' doesn't exist in request");
Assert.Equal(value, request.QueryParameters[key]);
}
public async Task Remove_ShouldCallTheCorrectUrl()
{
async Task <AblyRequest> CallRemove(PushChannelSubscription subscription)
{
AblyRequest request = null;
var rest = GetRestClient(r =>
{
request = r;
return(Task.FromResult(new AblyResponse()
{
TextResponse = string.Empty
}));
});
await rest.Push.Admin.ChannelSubscriptions.RemoveAsync(subscription);
return(request);
}
var request = await CallRemove(PushChannelSubscription.ForDevice("channel", "device"));
request.Url.Should().Be("/push/channelSubscriptions");
request.Method.Should().Be(HttpMethod.Delete);
request.QueryParameters.Should().ContainKey("channel").WhoseValue.Should().Be("channel");
request.QueryParameters.Should().ContainKey("deviceId").WhoseValue.Should().Be("device");
var requestWithClientId = await CallRemove(PushChannelSubscription.ForClientId("channel", "123"));
requestWithClientId.QueryParameters.Should().ContainKey("channel").WhoseValue.Should().Be("channel");
requestWithClientId.QueryParameters.Should().ContainKey("clientId").WhoseValue.Should().Be("123");
}
public async Task Save_ShouldValidateSubscriptionBeforeSendingItToTheServer()
{
async Task <AblyRequest> CallSave(PushChannelSubscription subscription)
{
AblyRequest request = null;
var rest = GetRestClient(r =>
{
request = r;
return(Task.FromResult(new AblyResponse()
{
TextResponse = string.Empty
}));
});
await rest.Push.Admin.ChannelSubscriptions.SaveAsync(subscription);
return(request);
}
Func <Task> nullSubscription = () => CallSave(null);
Func <Task> withEmptyChannel = () => CallSave(PushChannelSubscription.ForDevice(string.Empty));
(await nullSubscription.Should().ThrowAsync <AblyException>()).Which.ErrorInfo.Code.Should()
.Be(ErrorCodes.BadRequest);
(await withEmptyChannel.Should().ThrowAsync <AblyException>()).Which.ErrorInfo.Code.Should()
.Be(ErrorCodes.BadRequest);
}
public void RunBeforeAllTests()
{
TestData = GetTestData();
TestData.TestAppSpec = JObject.Parse(File.ReadAllText("testAppSpec.json"));
AblyHttpClient client = new AblyHttpClient(TestData.restHost, null, TestData.tls, null);
AblyRequest request = new AblyRequest("/apps", HttpMethod.Post);
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Content-Type", "application/json");
request.RequestBody = TestData.TestAppSpec.ToString().GetBytes();
AblyResponse response;
try
{
response = client.Execute(request);
}
catch (Exception) { return; }
var json = JObject.Parse(response.TextResponse);
string appId = TestData.appId = (string)json["appId"];
foreach (var key in json["keys"])
{
var testkey = new Key();
testkey.keyName = appId + "." + (string)key["keyName"];
testkey.keySecret = (string)key["keySecret"];
testkey.keyStr = (string)key["keyStr"];
testkey.capability = (string)key["capability"];
TestData.keys.Add(testkey);
}
SetupSampleStats();
}
public async Task RemoveWhere_ShouldCallTheCorrectUrl()
{
async Task <AblyRequest> CallRemoveWhere(IDictionary <string, string> whereParams)
{
AblyRequest request = null;
var rest = GetRestClient(r =>
{
request = r;
return(Task.FromResult(new AblyResponse()
{
TextResponse = string.Empty
}));
});
await rest.Push.Admin.ChannelSubscriptions.RemoveWhereAsync(whereParams);
return(request);
}
var request = await CallRemoveWhere(new Dictionary <string, string>());
request.Url.Should().Be("/push/channelSubscriptions");
request.Method.Should().Be(HttpMethod.Delete);
request.QueryParameters.Should().BeEmpty();
var requestWithChannelAndDeviceId = await CallRemoveWhere(new Dictionary <string, string>() { { "channel", "test" }, { "deviceId", "best" } });
requestWithChannelAndDeviceId.QueryParameters.Should().ContainKey("channel").WhoseValue.Should().Be("test");
requestWithChannelAndDeviceId.QueryParameters.Should().ContainKey("deviceId").WhoseValue.Should().Be("best");
var requestWithRandomParameter = await CallRemoveWhere(new Dictionary <string, string>() { { "random", "value" } });
requestWithRandomParameter.QueryParameters.Should().ContainKey("random").WhoseValue.Should().Be("value");
}
public PaginatedResult <T> ParsePaginatedResponse <T>(AblyRequest request, AblyResponse response, Func <HistoryRequestParams, Task <PaginatedResult <T> > > executeDataQueryRequest) where T : class
{
LogResponse(response);
var result = Paginated(request, response, executeDataQueryRequest);
var items = new List <T>();
if (typeof(T) == typeof(Message))
{
var typedResult = result as PaginatedResult <Message>;
typedResult.Items.AddRange(ParseMessagesResponse(response, request.ChannelOptions));
}
if (typeof(T) == typeof(Stats))
{
var typedResult = result as PaginatedResult <Stats>;
typedResult?.Items.AddRange(ParseStatsResponse(response));
}
if (typeof(T) == typeof(PresenceMessage))
{
var typedResult = result as PaginatedResult <PresenceMessage>;
typedResult.Items.AddRange(ParsePresenceMessages(response, request.ChannelOptions));
}
return(result);
}
public byte[] GetRequestBody(AblyRequest request)
{
if (request.PostData == null)
{
return new byte[] { }
}
;
if (request.PostData is IEnumerable <Message> )
{
return(GetMessagesRequestBody(request.PostData as IEnumerable <Message>,
request.ChannelOptions));
}
byte[] result;
if (_protocol == Protocol.Json || !Config.MsgPackEnabled)
{
result = JsonHelper.Serialize(request.PostData).GetBytes();
}
else
{
#if MSGPACK
result = MsgPackHelper.Serialise(request.PostData);
#endif
}
if (Logger.IsDebug)
{
Logger.Debug("Request body: " + result.GetText());
}
return(result);
}
public async Task ListChannels_ShouldCallsTheCorrectUrl()
{
async Task <AblyRequest> CallListChannels(PaginatedRequestParams filter)
{
AblyRequest request = null;
var rest = GetRestClient(r =>
{
request = r;
return(Task.FromResult(new AblyResponse()
{
TextResponse = "[]"
}));
});
await rest.Push.Admin.ChannelSubscriptions.ListChannelsAsync(filter);
return(request);
}
var request = await CallListChannels(PaginatedRequestParams.Empty);
request.Url.Should().Be("/push/channels");
var limitRequest = await CallListChannels(new PaginatedRequestParams { Limit = 150 });
limitRequest.QueryParameters.Should().ContainKey("limit").WhoseValue.Should().Be("150");
}
private static async Task SetupSampleStats(TestEnvironmentSettings settings)
{
var lastInterval = StartInterval;
var interval1 = lastInterval - TimeSpan.FromMinutes(120);
var interval2 = lastInterval - TimeSpan.FromMinutes(60);
var interval3 = lastInterval;
var json = TestAppSetup._statsFixture;
json = json.Replace("[[Interval1]]", interval1.ToString("yyyy-MM-dd:HH:mm"));
json = json.Replace("[[Interval2]]", interval2.ToString("yyyy-MM-dd:HH:mm"));
json = json.Replace("[[Interval3]]", interval3.ToString("yyyy-MM-dd:HH:mm"));
AblyHttpClient client = settings.GetHttpClient();
var request = new AblyRequest("/stats", HttpMethod.Post);
request.Protocol = Protocol.Json;
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Content-Type", "application/json");
AblyRest ablyRest = new AblyRest(settings.FirstValidKey);
await ablyRest.AblyAuth.AddAuthHeader(request);
request.RequestBody = json.GetBytes();
await client.Execute(request);
}
public void SetRequestBody(AblyRequest request)
{
request.RequestBody = GetRequestBody(request);
if (_protocol == Protocol.MsgPack && Logger.IsDebug)
{
LogRequestBody(request.RequestBody);
}
}
public void WhenLocalDevice_DoesNOT_HaveEitherDeviceIdentityTokenAndSecret_ShouldNotAddAnyHeaders()
{
var request = new AblyRequest("/", HttpMethod.Get);
var localDevice = new LocalDevice();
_ = GetRestClient();
PushAdmin.AddDeviceAuthenticationToRequest(request, localDevice);
request.Headers.Should().BeEmpty();
}
private Task <AblyResponse> AuthExecuteHttpRequest(AblyRequest request)
{
if (request.Url.Contains("authUrl"))
{
return(JsonHelper.Serialize(new TokenRequest {
ClientId = "123"
}).ToAblyResponse());
}
return(DummyTokenResponse.ToTask());
}
public AblyResponse ExecuteRequest(AblyRequest request)
{
if (!request.SkipAuthentication)
{
throw new InvalidOperationException("AblySimpleRestClient does not support authenticated requests");
}
_messageHandler.SetRequestBody(request);
return(_httpClient.Execute(request));
}
private AblyRest TrackLastRequest(AblyRest client)
{
var exec = client.ExecuteHttpRequest;
client.ExecuteHttpRequest = request =>
{
_lastRequest = request;
return(exec(request));
};
return(client);
}
private static int GetLimit(AblyRequest request)
{
if (request.QueryParameters.ContainsKey("limit"))
{
var limitQuery = request.QueryParameters["limit"];
if (limitQuery.IsNotEmpty())
{
return(int.Parse(limitQuery));
}
}
return(Defaults.QueryLimit);
}
public T ParseResponse <T>(AblyRequest request, AblyResponse response) where T : class
{
LogResponse(response);
var responseText = response.TextResponse;
if (_protocol == Protocol.MsgPack)
{
return((T)MsgPackHelper.Deserialise(response.Body, typeof(T)));
}
return(JsonHelper.Deserialize <T>(responseText));
}
public void WhenLocalDeviceHasDeviceSecret_ShouldAddHeaderToRequestWithCorrectValue()
{
var request = new AblyRequest("/", HttpMethod.Get);
var localDevice = new LocalDevice()
{
DeviceSecret = "test"
};
_ = GetRestClient();
PushAdmin.AddDeviceAuthenticationToRequest(request, localDevice);
request.Headers.Should().ContainKey(Defaults.DeviceSecretHeader).WhoseValue.Should().Be("test");
}
private AblyRealtime GetClient()
{
Func <AblyRequest, AblyResponse> executeHttpRequest = (request) =>
{
CurrentRequest = request;
return(new AblyResponse()
{
TextResponse = _dummyTokenResponse
});
};
return(GetClient(executeHttpRequest));
}
private static async Task <TestEnvironmentSettings> Initialise(string environment = "sandbox")
{
var settings = new TestEnvironmentSettings
{
Tls = true,
};
if (environment != null)
{
settings.Environment = environment;
}
JObject testAppSpec = JObject.Parse(ResourceHelper.GetResource("test-app-setup.json"));
var cipher = testAppSpec["cipher"];
settings.CipherParams = new CipherParams(
(string)cipher["algorithm"],
((string)cipher["key"]).FromBase64(),
CipherMode.CBC,
((string)cipher["iv"]).FromBase64());
AblyHttpClient client = settings.GetHttpClient(environment);
AblyRequest request = new AblyRequest("/apps", HttpMethod.Post);
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Content-Type", "application/json");
request.RequestBody = testAppSpec["post_apps"].ToString().GetBytes();
request.Protocol = Protocol.Json;
var response = await RetryExecute(() => client.Execute(request));
var json = JObject.Parse(response.TextResponse);
string appId = settings.AppId = (string)json["appId"];
foreach (var key in json["keys"])
{
var testKey = new Key
{
KeyName = appId + "." + (string)key["keyName"],
KeySecret = (string)key["keySecret"],
KeyStr = (string)key["keyStr"],
Capability = (string)key["capability"]
};
settings.Keys.Add(testKey);
}
// await SetupSampleStats(settings);
return(settings);
}
public void WhenLocalDeviceHasBothDeviceIdentityTokenAndSecret_ShouldOnlyAddIdentityTokenHeader()
{
var request = new AblyRequest("/", HttpMethod.Get);
var localDevice = new LocalDevice()
{
DeviceIdentityToken = "test", DeviceSecret = "secret"
};
_ = GetRestClient();
PushAdmin.AddDeviceAuthenticationToRequest(request, localDevice);
request.Headers.Should().ContainKey(Defaults.DeviceIdentityTokenHeader).WhoseValue.Should().Be("test");
request.Headers.Should().NotContainKey(Defaults.DeviceSecretHeader);
}
public void Stats_CreatesGetRequestWithCorrectPath()
{
var rest = GetRestClient();
AblyRequest request = null;
rest.ExecuteHttpRequest = x => { request = x; return(new AblyResponse {
Type = ResponseType.Json, TextResponse = "[{ }]"
}); };
rest.Stats();
Assert.Equal(HttpMethod.Get, request.Method);
Assert.Equal("/stats", request.Url);
}
private static int GetLimit(AblyRequest request)
{
if (request.QueryParameters.ContainsKey("limit"))
{
var limitQuery = request.QueryParameters["limit"];
var limit = Config.Limit;
if (limitQuery.IsNotEmpty())
{
limit = int.Parse(limitQuery);
}
return(limit);
}
return(Config.Limit);
}
public WithTextProtocolWithoutEncryption()
{
_client = new RestClient(new AblyOptions()
{
Key = fakeKey, UseBinaryProtocol = false
});
_client.ExecuteHttpRequest = request =>
{
currentRequest = request;
return(new AblyResponse()
{
TextResponse = "{}"
});
};
}
public async Task TokenAuthCanBeUsedOverHttpAndHttps(bool tls)
{
//Arrange
var tokenValue = "TokenValue";
var rest = new AblyRest(opts =>
{
opts.Token = tokenValue;
opts.Tls = tls;
});
var request = new AblyRequest("/test", HttpMethod.Get, Protocol.Json);
//Act
await rest.AblyAuth.AddAuthHeader(request);
// If it throws the test will fail
}
public WithTextProtocolWithEncryption()
{
options = new ChannelOptions(Crypto.GetDefaultParams());
_client = new RestClient(new AblyOptions()
{
Key = fakeKey, UseBinaryProtocol = false
});
_client.ExecuteHttpRequest = request =>
{
currentRequest = request;
return(new AblyResponse()
{
TextResponse = "{}"
});
};
}
internal static void AddDeviceAuthenticationToRequest(AblyRequest request, LocalDevice device)
{
if (device is null)
{
return;
}
if (device.DeviceIdentityToken.IsNotEmpty())
{
request.Headers.Add(Defaults.DeviceIdentityTokenHeader, device.DeviceIdentityToken);
}
else if (device.DeviceSecret.IsNotEmpty())
{
request.Headers.Add(Defaults.DeviceSecretHeader, device.DeviceSecret);
}
}
