public async Task TestFilterOrderDesc(string keyField, int rangeStart, int rangeEnd)
{
int expectedCount = rangeEnd - rangeStart + 1;
// Arrange
var request = new HttpRequestMessage(HttpMethod.Get, $"{uri}?$count=true&$orderby={keyField} desc&$filter=({keyField} ge {rangeStart}) and ({keyField} le {rangeEnd})");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var res = HttpContentHelper.DerializeJsonFromStream <ODataResponse <Person> >(await response.Content.ReadAsStreamAsync());
// Assert - Values count
Assert.Equal(res.value.Count, expectedCount);
// Assert - Count
Assert.Equal(res.odataCount, expectedCount);
// Assert - first id
Assert.Equal(res.value[0].id, rangeEnd);
// Assert - last id
Assert.Equal(res.value[res.value.Count - 1].id, rangeStart);
}
}
public async Task TestFilterContains(string fieldName, string contains, int expectedCount)
{
// Arrange
var request = new HttpRequestMessage(HttpMethod.Get, $"{uri}?$count=true&$filter=contains({fieldName},'{contains}')");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var res = HttpContentHelper.DerializeJsonFromStream <ODataResponse <Person> >(await response.Content.ReadAsStreamAsync());
// Assert - Values count
Assert.Equal(res.value.Count, expectedCount);
// Assert - Count
Assert.Equal(res.odataCount, expectedCount);
// Assert
foreach (var val in res.value)
{
Assert.Contains(contains, val.first);
}
}
}
public void HttpContentHelper_StringContentJson_Encodes_Object_As_Json()
{
var content = HttpContentHelper.StringContentJson(new { Value = 1 });
var text = content.ReadAsStringAsync().Result;
Assert.AreEqual(@"{""Value"":1}", text);
}
public VideoStreamResult PlayVideoAsync(string filename)
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", filename);
var httpContentHelper = new HttpContentHelper();
return(new VideoStreamResult(new FileInfo(path).OpenRead(), httpContentHelper.GetContentType(path)));
}
public void HttpContentHelper_FormUrlEncoded_Sets_The_ContentType_Header()
{
var content = HttpContentHelper.FormUrlEncoded(new [, ] {
{ "key1", "value1" }
});
Assert.AreEqual("application/x-www-form-urlencoded", content.Headers.ContentType.ToString());
}
public static async Task <HttpResponseMessage> PostAsync <T>(this HttpClient httpClient, String requestUri, T contentObj)
{
HttpContent content = HttpContentHelper.ToJsonContent(contentObj);
HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(requestUri, content);
httpResponseMessage.EnsureSuccessStatusCode();
return(httpResponseMessage);
}
public void HttpContentHelper_FormUrlEncoded_Encodes_Values()
{
var content = HttpContentHelper.FormUrlEncoded(new [, ] {
{ "key", "&" }
});
var text = content.ReadAsStringAsync().Result;
Assert.AreEqual("key=%26", text);
}
public void HttpContentHelper_FormUrlEncoded_Handles_Empty_Value_Correctly()
{
var content = HttpContentHelper.FormUrlEncoded(new [, ] {
{ "key", "" }
});
var text = content.ReadAsStringAsync().Result;
Assert.AreEqual("key=", text);
}
public void HttpContentHelper_FormUrlEncoded_Returns_FormUrlEncodedContent()
{
var content = HttpContentHelper.FormUrlEncoded(new [, ] {
{ "key1", "value1" },
{ "key2", "value2" },
});
var text = content.ReadAsStringAsync().Result;
Assert.AreEqual("key1=value1&key2=value2", text);
}
public FileStreamResult DownloadFileAsyn(string filename)
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", filename);
var httpContentHelper = new HttpContentHelper();
Response.ContentType = httpContentHelper.GetContentType(path);
var stream = new FileInfo(path).OpenRead();
return(File(stream, httpContentHelper.GetContentType(path), filename));
}
public static async Task <IResponse <TReturn> > PostAsync <T, TReturn>(this HttpClient httpClient, String requestUri, T contentObj)
where TReturn : class
{
HttpContent content = HttpContentHelper.ToJsonContent(contentObj);
HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(requestUri, content);
httpResponseMessage.EnsureSuccessStatusCode();
TReturn obj = await httpResponseMessage.ReadContentAsAsync <TReturn>();
IResponse <TReturn> response = new Response <TReturn>(httpResponseMessage, obj);
return(response);
}
/// <summary>
/// Post current ad creative to facebook page as an asynchronous operation.
/// <see cref="AdCreative.Id"/> is required.
/// </summary>
/// <param name="accessToken">
/// User access token.
/// </param>
/// <param name="pageAccessToken">
/// Page access token.
/// </param>
/// <returns>
/// The task object representing the asynchronous operation.
/// </returns>
public async Task <ResponseMessage <string> > PublishAsync(string accessToken, string pageAccessToken)
{
var storyId = await GetEffectiveObjectStoryIdAsync(accessToken);
if (!String.IsNullOrEmpty(storyId))
{
var xref = $"f{Guid.NewGuid().ToString("N").Remove(14).ToLower()}"; // It seems that facebook doesn't check this argument.
var dic = new Dictionary <string, string>
{
{ "_reqName", "object:post" },
{ "include_headers", "false" },
{ "is_published", "true" },
{ "locale", "en_US" },
{ "method", "post" },
{ "pretty", "0" },
{ "suppress_http_code", "1" },
{ "xref", xref },
{ "access_token", pageAccessToken }
};
var request = new HttpRequestMessage
{
RequestUri = new Uri(Basic.Apis.Marketing.AdCreativePublishing(storyId), UriKind.Absolute),
Method = HttpMethod.Post,
Content = HttpContentHelper.CreateFormUrlEncodedContentFrom <object>(null, dic.ToArray())
};
using (var client = new HttpClient())
{
var response = await client.SendAsync(request);
return(await response.ToResponseMessageAsync());
}
}
else
{
return(new ResponseMessage <string>
{
Code = ResponseCode.UNKNOWN_ERROR,
ReasonPhrase = "Failed to publish current ad creative to facebook."
});
}
}
/// <summary>
/// Publishes current post to facebook as an asynchronous operation.
/// </summary>
/// <param name="targetId">
/// The target of post publishing.
/// </param>
/// <param name="accessToken">
/// Access token.
/// </param>
/// <returns>
/// The task object representing the asynchronous operation.
/// </returns>
public async Task <ResponseMessage <string> > PublishAsync(string targetId, string accessToken)
{
var dic = new Dictionary <string, string>
{
{ "access_token", accessToken }
};
var request = new HttpRequestMessage
{
RequestUri = new Uri(Basic.Apis.Gragh.PostPublishing(targetId), UriKind.Absolute),
Method = HttpMethod.Post,
Content = HttpContentHelper.CreateFormUrlEncodedContentFrom(this, dic.ToArray())
};
using (var client = new HttpClient())
{
var response = await client.SendAsync(request);
return(await response.ToResponseMessageAsync());
}
}
/// <summary>
/// Posts an ad creative creating request to facebook with user's ad account id as an asynchronous
/// operation.
/// </summary>
/// <param name="adAccountId">
/// The ad account id of user.
/// </param>
/// <param name="accessToken">
/// User access token.
/// </param>
/// <returns>
/// The task object representing the asynchronous operation.
/// </returns>
public async Task <ResponseMessage <string> > PostAsync(string adAccountId, string accessToken)
{
var dic = new Dictionary <string, string>
{
{ "access_token", accessToken }
};
var request = new HttpRequestMessage
{
RequestUri = new Uri(Basic.Apis.Marketing.AdCreative(adAccountId), UriKind.Absolute),
Method = HttpMethod.Post,
Content = HttpContentHelper.CreateMultipartFormDataContentFrom(this, dic.ToArray())
};
using (var client = new HttpClient())
{
var response = await client.SendAsync(request);
return(await response.ToResponseMessageAsync());
}
}
public async Task TestCountTop(string method, int top)
{
// Arrange
var request = new HttpRequestMessage(new HttpMethod(method), $"{uri}?$count=true&$top={top}");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var res = HttpContentHelper.DerializeJsonFromStream <ODataResponse <Person> >(await response.Content.ReadAsStreamAsync());
// Assert - Top
Assert.Equal(res.value.Count, top);
// Assert - Count +/- 1
Assert.True((res.odataCount >= odataCount) && (res.odataCount <= (odataCount + 1)));
}
}
/// <summary>
/// Get effective_object_story_id by the <see cref="AdCreative"/> as an asynchronous operation.
/// </summary>
/// <param name="accessToken">
/// User access token.
/// </param>
/// <returns>
/// The task object representing the asynchronous operation.
/// </returns>
/// <exception cref="Exception">
/// Throw if failed to get effective_object_story_id.
/// </exception>
private async Task <string> GetEffectiveObjectStoryIdAsync(string accessToken)
{
var dic = new Dictionary <string, string>
{
{ "fields", "effective_object_story_id" },
{ "access_token", accessToken }
};
var request = new HttpRequestMessage
{
RequestUri = new Uri(Basic.Apis.Marketing.AdCreativeInfo(this.Id), UriKind.Absolute),
Method = HttpMethod.Post,
Content = HttpContentHelper.CreateFormUrlEncodedContentFrom <object>(null, dic.ToArray())
};
using (var client = new HttpClient())
{
var response = await client.SendAsync(request);
var responseMsg = await response.ToResponseMessageAsync();
if (responseMsg.Code == ResponseCode.SUCCESS)
{
var jobj = JObject.Parse(responseMsg.Data);
if (jobj["effective_object_story_id"] != null)
{
return(jobj["effective_object_story_id"].ToString());
}
else
{
return(null);
}
}
else
{
throw new Exception(responseMsg.ReasonPhrase);
}
}
}
public async Task <FileResult> DownloadFile(string filename)
{
if (string.IsNullOrEmpty(filename))
{
return(null);
}
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", filename);
var memory = new MemoryStream();
using (var stream = new FileInfo(path).OpenRead())
{
await stream.CopyToAsync(memory);
stream.Close();
}
memory.Position = 0;
var httpContentHelper = new HttpContentHelper();
return(File(memory, httpContentHelper.GetContentType(path), Path.GetFileName(path)));
}
public void HttpContentHelper_FormUrlEncoded_Throws_On_Second_Dimension_Too_Small()
{
HttpContentHelper.FormUrlEncoded(new [, ] {
{ "1" }
});
}
public async Task TestThrottleDelaySecs(int throttleDelaySecs)
{
// Set throttleDelaySecs
var request = new HttpRequestMessage(HttpMethod.Post, $"{uriApi}throttle/{throttleDelaySecs}");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
// Check if value was assigned properly
request = new HttpRequestMessage(HttpMethod.Get, $"{uriApi}");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var res = HttpContentHelper.DerializeJsonFromStream <Dictionary <string, int> >(await response.Content.ReadAsStreamAsync());
// Assert
Assert.True(res.ContainsKey("throttleDelaySecs"));
// Assert
Assert.True(res["throttleDelaySecs"] == throttleDelaySecs);
}
// Verify is throttling is indeed working as expected
request = new HttpRequestMessage(HttpMethod.Get, $"{uriOdata}?$count=true&$top=1");
Stopwatch stopwatch = Stopwatch.StartNew();
using (var response = await _client.SendAsync(request))
{
stopwatch.Stop();
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var res = HttpContentHelper.DerializeJsonFromStream <ODataResponse <Person> >(await response.Content.ReadAsStreamAsync());
// Assert - Only one record returned
Assert.Single(res.value);
// Assert - Executed at least as long as throttleDelaySecs
Assert.True(stopwatch.ElapsedMilliseconds > throttleDelaySecs * 1000);
}
// Reset throttleDelaySecs
request = new HttpRequestMessage(HttpMethod.Post, $"{uriApi}throttle/0");
request.Content = HttpContentHelper.CreateHttpContent(0);
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
public async Task TestCRUD()
{
var entity = DbContextHelper.InitObject(new Person(), idCRUD);
// GET record which is not exists yet
var request = new HttpRequestMessage(HttpMethod.Get, $"{uri}{entity.id}");
using (var response = await _client.SendAsync(request))
{
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
// POST new record
request = new HttpRequestMessage(HttpMethod.Post, uri);
request.Content = HttpContentHelper.CreateHttpContent(entity);
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
// GET record created above and compare with original
request = new HttpRequestMessage(HttpMethod.Get, $"{uri}{entity.id}");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var res = HttpContentHelper.DerializeJsonFromStream <Person>(await response.Content.ReadAsStreamAsync());
// Assert
Assert.Equal(HttpContentHelper.ObjectToString(res), HttpContentHelper.ObjectToString(entity));
}
// PUT updated record
request = new HttpRequestMessage(HttpMethod.Put, $"{uri}{entity.id}");
entity = DbContextHelper.InitObject(new Person(), idCRUD + 1);
entity.id = idCRUD;
request.Content = HttpContentHelper.CreateHttpContent(entity);
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
// GET updated record and compare with original
request = new HttpRequestMessage(HttpMethod.Get, $"{uri}{entity.id}");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var res = HttpContentHelper.DerializeJsonFromStream <Person>(await response.Content.ReadAsStreamAsync());
// Assert
Assert.Equal(HttpContentHelper.ObjectToString(res), HttpContentHelper.ObjectToString(entity));
}
// PATCH record
request = new HttpRequestMessage(HttpMethod.Patch, $"{uri}{entity.id}");
entity = DbContextHelper.InitObject(new Person(), idCRUD + 2);
entity.id = idCRUD;
request.Content = HttpContentHelper.CreateHttpContent(entity);
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
// GET updated record and compare with original
request = new HttpRequestMessage(HttpMethod.Get, $"{uri}{entity.id}");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var res = HttpContentHelper.DerializeJsonFromStream <Person>(await response.Content.ReadAsStreamAsync());
// Assert
Assert.Equal(HttpContentHelper.ObjectToString(res), HttpContentHelper.ObjectToString(entity));
}
// Attempt to POST same record again
request = new HttpRequestMessage(HttpMethod.Post, uri);
request.Content = HttpContentHelper.CreateHttpContent(entity);
using (var response = await _client.SendAsync(request))
{
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
// DELETE record
request = new HttpRequestMessage(HttpMethod.Delete, $"{uri}{entity.id}");
using (var response = await _client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
// Assert
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
// Attempt to GET deleted record
request = new HttpRequestMessage(HttpMethod.Get, $"{uri}{entity.id}");
using (var response = await _client.SendAsync(request))
{
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
}
public void HttpContentHelper_StringContentJson_Has_Correct_ContentType()
{
var content = HttpContentHelper.StringContentJson(new { Value = 1 });
Assert.AreEqual("application/json; charset=utf-8", content.Headers.ContentType.ToString());
}
public void HttpContentHelper_StringContentJson_Throws_On_Null_Object()
{
HttpContentHelper.StringContentJson(null);
}
public void HttpContentHelper_FormUrlEncoded_Throws_On_Null_Array()
{
HttpContentHelper.FormUrlEncoded(null);
}
