public async Task AddAttachmentWithNonAsciiFilenameTest()
{
var nonAsciiFileNames = new List<string> { "Просто", "مرحبا", "你好嗎", "Naïve" };
var responseList = new List<FakeHttpServerResponse>();
for (var i = 0; i < nonAsciiFileNames.Count; i++)
{
responseList.Add(new FakeHttpServerResponse(201, ResponseMeta));
}
var server = new FakeHttpServer(Port, responseList);
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
foreach (var fileName in nonAsciiFileNames.Select(fileNamePart => fileNamePart + " file.txt"))
{
await using var streamWriter = File.CreateText(fileName);
streamWriter.AutoFlush = true;
await streamWriter.WriteAsync(Guid.NewGuid().ToString()).ConfigureAwait(false);
await using var stream = File.OpenRead(fileName);
var meta = await storage.AddAttachmentAsync(Country, RecordKey, stream)
.ConfigureAwait(false);
Assert.IsNotNull(meta);
Assert.IsTrue(server.LastRequestBody.Contains($"filename=\"{fileName}\"",
StringComparison.InvariantCulture));
File.Delete(fileName);
}
server.Stop();
}
public void DeleteAttachmentNegativeTest()
{
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var exception = Assert.ThrowsAsync<StorageClientException>(() =>
storage.DeleteAttachmentAsync(Country, null, FileId));
Assert.AreEqual("Record key is null", exception.Message);
exception = Assert.ThrowsAsync<StorageClientException>(() =>
storage.DeleteAttachmentAsync(null, RecordKey, FileId));
Assert.AreEqual("Country code is null", exception.Message);
exception = Assert.ThrowsAsync<StorageClientException>(() =>
storage.DeleteAttachmentAsync(Country, RecordKey, null));
Assert.AreEqual("File ID is null", exception.Message);
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(405, "Error") });
server.Start();
var serverException = Assert.ThrowsAsync<StorageServerException>(() =>
storage.DeleteAttachmentAsync(Country, RecordKey, FileId));
Assert.IsTrue(serverException.Message.Contains(
"Unexpected response: StatusCode: 405, ReasonPhrase: 'Method Not Allowed'",
StringComparison.InvariantCulture));
server.Stop();
}
public void ShouldRespondWithStringBasedOnConfiguration()
{
using (FakeHttpServer server = new FakeHttpServer())
{
server.Host = "localhost";
server.Port = 8080;
server.Path = "api/v1/accounts";
server.ReturnString("Hello, World!!!");
server.StatusCode = HttpStatusCode.OK;
server.StatusDescription = "Okey, Dokey";
server.Headers.Add("When", new DateTime(2014, 06, 16).ToString("MM/dd/yyyy"));
StringBodyExtractor extractor = new StringBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
WebRequest request = WebRequest.Create("http://localhost:8080/api/v1/accounts");
request.Method = "POST";
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write("Hello, Universe!!!");
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Assert.AreEqual(server.StatusCode, response.StatusCode, "The wrong status code was returned.");
Assert.AreEqual(server.StatusDescription, response.StatusDescription, "The wrong status description was returned.");
Assert.AreEqual("06/16/2014", response.Headers["When"], "The wrong header was returned");
string responseText = new StreamReader(response.GetResponseStream()).ReadToEnd();
Assert.AreEqual("Hello, World!!!", responseText);
Assert.AreEqual("Hello, Universe!!!", extractor.Content);
}
}
}
public void ShouldRespondWithStringBasedOnConfiguration()
{
using (FakeHttpServer server = new FakeHttpServer())
{
server.Host = "localhost";
server.Port = 8080;
server.Path = "api/v1/accounts";
server.ReturnString("Hello, World!!!");
server.StatusCode = HttpStatusCode.OK;
server.StatusDescription = "Okey, Dokey";
server.Headers.Add("When", new DateTime(2014, 06, 16).ToString("MM/dd/yyyy"));
server.Listen();
WebRequest request = WebRequest.Create("http://localhost:8080/api/v1/accounts");
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Assert.AreEqual(server.StatusCode, response.StatusCode, "The wrong status code was returned.");
Assert.AreEqual(server.StatusDescription, response.StatusDescription, "The wrong status description was returned.");
Assert.AreEqual("06/16/2014", response.Headers["When"], "The wrong header was returned");
string responseText = getResponseString(response);
Assert.AreEqual("Hello, World!!!", responseText);
}
}
}
public void ShouldPostMultuPartWithBase64Content()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
MultiPartBodyExtractor extractor = new MultiPartBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
string message = "Hello, World!Ӽ!";
byte[] messageRaw = Encoding.UTF8.GetBytes(message);
string base64 = Convert.ToBase64String(messageRaw);
byte[] base64Raw = Encoding.UTF8.GetBytes(base64);
NameValueCollection headers = new NameValueCollection();
headers.Add("Content-Transfer-Encoding", "base64");
RestClient client = new RestClient("http://localhost:8080");
client.Post("api/customers")
.WithMultiPartBody(b =>
{
b.WithFile("file", "file.txt", base64Raw, "text/plain", headers);
})
.Execute();
var file = extractor.Files.GetFiles("file").Single();
CollectionAssert.AreEqual(base64Raw, file.Contents);
}
}
public void ShouldExtractUrlEncodedData()
{
using (FakeHttpServer server = new FakeHttpServer())
{
server.Host = "localhost";
server.Port = 8080;
server.Path = "api/v1/accounts";
server.StatusCode = HttpStatusCode.OK;
server.StatusDescription = "Success";
UrlEncodedBodyExtractor extractor = new UrlEncodedBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
WebRequest request = WebRequest.Create("http://localhost:8080/api/v1/accounts");
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write("name=bob&age=31");
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
NameValueCollection collection = extractor.Parameters;
Assert.AreEqual("bob", collection.Get("name"), "Could not extract the name parameter.");
Assert.AreEqual("31", collection.Get("age"), "Could not extract the age parameter.");
}
}
}
public void MigrateTestPositive()
{
var server = new FakeHttpServer(Port,
new[] { new FakeHttpServerResponse(200, FindResponse),
new FakeHttpServerResponse(201, FindResponse),
new FakeHttpServerResponse(200, BadFindResponse) });
server.Start();
var config = new StorageConfig(endPoint: "http://*****:*****@ssworD!"));
using var storage = Storage.NewStorage(config);
const int limit = 50;
var migrateResult = storage.MigrateAsync("country", limit).Result;
Assert.NotNull(migrateResult);
Assert.AreEqual(1, migrateResult.Migrated);
Assert.AreEqual(0, migrateResult.TotalLeft);
Assert.AreEqual(0, migrateResult.Errors.Count);
migrateResult = storage.MigrateAsync("country", limit).Result;
Assert.NotNull(migrateResult);
Assert.AreEqual(0, migrateResult.Migrated);
Assert.AreEqual(1, migrateResult.TotalLeft);
Assert.AreEqual(1, migrateResult.Errors.Count);
server.Stop();
}
public void FindOneNothingFoundTest()
{
const string response = "{\n" +
" \"data\": [\n" +
" ],\n" +
" \"meta\": {\n" +
" \"count\": 0,\n" +
" \"limit\": 100,\n" +
" \"offset\": 0,\n" +
" \"total\": 0\n" +
" }\n" +
"}";
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(200, response) });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var filter = new FindFilter()
.KeyEq(NumberField.Version, 0);
var foundedRecord = storage.FindOneAsync("country", filter).Result;
Assert.Null(foundedRecord);
server.Stop();
}
public void ReadTestPositive()
{
const string recordKey1 = "123";
const string recordKey2 = "456";
const string body1 = "body1";
const string body2 = "body2";
const string readResponse1 = "{\n" +
" \"is_encrypted\": false,\n" +
" \"record_key\": \"3E758B0DC7D6A52F2A314FA996BF5513BE8BC5D276935CE2628C67151ABC6DA3\",\n" +
" \"body\": \"pt:ewogICJtZXRhIjogewogICAgImlzX2VuY3J5cHRlZCI6IGZhbHNlLAogICAgInJlY29yZF9rZXkiOiAiMTIzIgogIH0sCiAgInBheWxvYWQiOiAiYm9keTEiCn0=\"\n" +
"}";
const string readResponse2 = "{\n" +
" \"is_encrypted\": false,\n" +
" \"record_key\": \"21006B2178B6D5D43CB19FAB2468A679653CDC9EA0280A905F5DCFEBCC0D8CFF\",\n" +
" \"body\": \"pt:ewogICJtZXRhIjogewogICAgImlzX2VuY3J5cHRlZCI6IGZhbHNlLAogICAgInJlY29yZF9rZXkiOiAiNDU2IgogIH0sCiAgInBheWxvYWQiOiAiYm9keTIiCn0=\"\n" +
"}";
var server = new FakeHttpServer(Port,
new[] { new FakeHttpServerResponse(200, readResponse1), new FakeHttpServerResponse(200, readResponse2) });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var record = storage.ReadAsync("country", "anyRecordKeyForMock").Result;
Assert.AreEqual(recordKey1, record.RecordKey);
Assert.AreEqual(body1, record.Body);
record = storage.ReadAsync("country", "anyRecordKeyForMock").Result;
Assert.AreEqual(recordKey2, record.RecordKey);
Assert.AreEqual(body2, record.Body);
server.Stop();
}
public async Task ShouldPOSTMultiPartDataAsync()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
MultiPartBodyExtractor extractor = new MultiPartBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient("http://localhost:8080");
await client.Post("api/customers")
.WithMultiPartBody(b =>
{
b.WithFormData(ub => ub.WithParameter("name", "John Smith"));
b.WithFile("file1", "path", Encoding.UTF8.GetBytes("Hello, world"), "text/plain");
})
.ExecuteAsync();
Assert.AreEqual("John Smith", extractor.Parameters["name"], "The form data was not transfered.");
var file = extractor.Files.GetFiles("file1").SingleOrDefault();
Assert.AreEqual("file1", file.Name);
Assert.AreEqual("path", file.FileName);
Assert.AreEqual("text/plain", file.ContentType);
Assert.AreEqual("Hello, world", Encoding.UTF8.GetString(file.Contents));
}
}
public void GenerateAudienceForTokenClientTest(string endpoint, string endpointMask,
FakeHttpServerResponse serverResponse, string midPopAudience, string miniPopAudience)
{
const string midPopCountryCode = "us";
const string miniPopCountryCode = "pu";
const string recordKey = "someRecordKey";
FakeHttpServer server = null;
if (!string.IsNullOrEmpty(serverResponse?.Body))
{
server = new FakeHttpServer(Port, new[] { serverResponse });
server.Start();
}
using var httpClient = new HttpClient { Timeout = new TimeSpan(0, 0, 30) };
var tokenClient = new FakeTokenClient();
using var dao = HttpDao.NewDao(EnvId, tokenClient, httpClient, endpoint, endpointMask, s_endpoint);
//midpop
Assert.ThrowsAsync <StorageServerException>(async() =>
await dao.ReadRecordAsync(midPopCountryCode, recordKey).ConfigureAwait(false));
Assert.AreEqual(midPopAudience, tokenClient.Audience);
//minipop
Assert.ThrowsAsync <StorageServerException>(async() =>
await dao.ReadRecordAsync(miniPopCountryCode, recordKey).ConfigureAwait(false));
Assert.AreEqual(miniPopAudience, tokenClient.Audience);
server?.Stop();
}
public void ShouldExtractUrlEncodedData()
{
using (FakeHttpServer server = new FakeHttpServer())
{
server.Host = "localhost";
server.Port = 8080;
server.Path = "api/v1/accounts";
server.StatusCode = HttpStatusCode.OK;
server.StatusDescription = "Success";
UrlEncodedBodyExtractor extractor = new UrlEncodedBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
WebRequest request = WebRequest.Create("http://localhost:8080/api/v1/accounts");
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write("name=bob&age=31");
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
NameValueCollection collection = extractor.Parameters;
Assert.AreEqual("bob", collection.Get("name"), "Could not extract the name parameter.");
Assert.AreEqual("31", collection.Get("age"), "Could not extract the age parameter.");
}
}
}
public void ShouldPOSTWithFormDataObject()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var bodyExtractor = new UrlEncodedBodyExtractor();
var extractor = new RequestExtractor(bodyExtractor);
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Post("http://localhost:8080/api/customers")
.WithUrlEncodedBody(new
{
Name = "Bob Smith",
Age = 31,
Title = "Mr."
})
.Execute();
string name = bodyExtractor.Parameters["Name"];
string age = bodyExtractor.Parameters["Age"];
string title = bodyExtractor.Parameters["Title"];
Assert.AreEqual("Bob Smith", name, "The name was not sent.");
Assert.AreEqual("31", age, "The age was not sent.");
Assert.AreEqual("Mr.", title, "The title was not sent.");
}
}
static void Main(string[] args)
{
FakeHttpServer fakeHttpServer = new FakeHttpServer();
fakeHttpServer.Start();
Console.ReadLine();
fakeHttpServer.Stop();
}
public void DefaultParametersTest()
{
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(200, CountryLoadResponse) });
server.Start();
using var httpClient = new HttpClient();
using var dao = HttpDao.NewDao("envId", new ApiKeyTokenClient("apiKey"), httpClient, null, "test.localhost",
s_endpoint);
var popList = dao.GetPopDictionaryClone();
Assert.AreEqual(2, popList.Count);
server.Stop();
}
public async Task AddAttachmentTest()
{
var server = new FakeHttpServer(Port,
new[]
{
new FakeHttpServerResponse(201, ResponseMeta), new FakeHttpServerResponse(201, ResponseMeta),
new FakeHttpServerResponse(201, ResponseMeta), new FakeHttpServerResponse(201, ResponseMeta),
new FakeHttpServerResponse(201, ResponseMeta)
});
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
await using var writer = GenerateMemoryStream(Guid.NewGuid().ToString());
var meta = await storage.AddAttachmentAsync(Country, RecordKey, writer.BaseStream, FileName, MimeType)
.ConfigureAwait(false);
Assert.IsNotNull(meta);
Assert.AreEqual("POST", server.LastRequestMethod);
await using var writer2 = GenerateMemoryStream(Guid.NewGuid().ToString());
meta = await storage.AddAttachmentAsync(Country, RecordKey, writer2.BaseStream, FileName, MimeType, true)
.ConfigureAwait(false);
Assert.IsNotNull(meta);
Assert.AreEqual("PUT", server.LastRequestMethod);
await using var writer3 = GenerateMemoryStream(Guid.NewGuid().ToString());
meta = await storage.AddAttachmentAsync(Country, RecordKey, writer3.BaseStream, FileName)
.ConfigureAwait(false);
Assert.IsNotNull(meta);
await using var writer4 = GenerateMemoryStream(Guid.NewGuid().ToString());
meta = await storage.AddAttachmentAsync(Country, RecordKey, writer4.BaseStream)
.ConfigureAwait(false);
Assert.IsNotNull(meta);
Assert.IsTrue(server.LastRequestBody.Contains("filename=\"file\"", StringComparison.InvariantCulture));
await using var streamWriter = File.CreateText(FileName);
streamWriter.AutoFlush = true;
await streamWriter.WriteAsync(Guid.NewGuid().ToString()).ConfigureAwait(false);
await using var stream = File.OpenRead(FileName);
meta = await storage.AddAttachmentAsync(Country, RecordKey, stream)
.ConfigureAwait(false);
Assert.IsNotNull(meta);
Assert.IsTrue(server.LastRequestBody.Contains("filename=\"file.txt\"", StringComparison.InvariantCulture));
File.Delete(FileName);
server.Stop();
}
public void WriteTestPositive()
{
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(201, "Created") });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
const string recordKey = "123";
var record = storage.WriteAsync("country", new Record(recordKey)).Result;
Assert.AreEqual(recordKey, record.RecordKey);
server.Stop();
}
public void DeleteTestPositive()
{
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(200, "OK") });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
const string recordKey = "123";
var result = storage.DeleteAsync("country", recordKey).Result;
Assert.True(result);
server.Stop();
}
public void ShouldGetInt32()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/numbers"))
{
server.ReturnString("4");
server.Listen();
RestClient client = new RestClient("http://localhost:8080");
var response = client.Get("numbers")
.WhenSuccess(r => r.FromString <int>())
.Execute();
Assert.IsTrue(response.IsSuccessStatusCode, "An error occurred getting the number.");
Assert.AreEqual(4, response.GetResult <int>());
}
}
public void GetTokenTest()
{
const int tokenExpiredLifetime = 1;
const string expectedValue1 = "1111111111";
var tokenResponse1 = "{'access_token':'" + expectedValue1 +
"' , 'expires_in':'" + tokenExpiredLifetime +
"' , 'token_type':'bearer', 'scope':'" + EnvId + "'}";
const string expectedValue2 = "2222222222";
const string tokenResponse2 = "{'access_token':'" + expectedValue2 +
"' , 'expires_in':'300' , 'token_type':'bearer', 'scope':'" + EnvId + "'}";
const string expectedValue3 = "3333333333";
const string tokenResponse3 = "{'access_token':'" + expectedValue3 +
"' , 'expires_in':'300' , 'token_type':'bearer', 'scope':'" + EnvId + "'}";
var server = new FakeHttpServer(Port,
new[]
{
new FakeHttpServerResponse(200, tokenResponse1),
new FakeHttpServerResponse(200, tokenResponse2),
new FakeHttpServerResponse(200, tokenResponse3)
});
server.Start();
using var httpClient = new HttpClient();
var tokenClient =
new OAuthTokenClient(s_defaultAuthEndpoint, null, EnvId, ClientId, ClientSecret, httpClient);
//get the first token
var token = tokenClient.RefreshTokenAsync(false, Audience, Apac).Result;
Assert.AreEqual(expectedValue1, token);
Thread.Sleep(tokenExpiredLifetime * 2 * 1_000);
//get new token after expiration
token = tokenClient.RefreshTokenAsync(false, Audience, Apac).Result;
Assert.AreEqual(expectedValue2, token);
//get cashed token
token = tokenClient.RefreshTokenAsync(false, Audience, Apac).Result;
Assert.AreEqual(expectedValue2, token);
//force update token
token = tokenClient.RefreshTokenAsync(true, Audience, Apac).Result;
Assert.AreEqual(expectedValue3, token);
server.Stop();
}
public void ShouldGETWithQueryParametersObject()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var extractor = new RequestExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Get("http://localhost:8080/api/customers")
.WithQueryParameters(new { customerid = 123 })
.Execute();
Assert.AreEqual("123", extractor.QueryString["customerid"], "The ID was not passed.");
}
}
public void ShouldGET()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
server.StatusCode = HttpStatusCode.OK;
server.Listen();
RestClient client = new RestClient();
var response = client.Get("http://localhost:8080/api/customers").Execute();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "The wrong status code was returned.");
Assert.IsTrue(response.IsSuccessStatusCode, "A success code was returned. There should be no error.");
Assert.IsNull(response.Result, "No WHEN handler was defined. The result should be null.");
}
}
public void TokenResponseWrongStatusTest()
{
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(401, "") });
server.Start();
using var httpClient = new HttpClient();
var tokenClient =
new OAuthTokenClient(s_defaultAuthEndpoint, null, EnvId, ClientId, ClientSecret, httpClient);
var exception = Assert.ThrowsAsync <StorageServerException>(async() =>
{
var unused = await tokenClient.RefreshTokenAsync(false, Audience, Emea).ConfigureAwait(false);
});
Assert.AreEqual("Unexpected authorization response status='Unauthorized', content=''", exception.Message);
server.Stop();
}
public void ShouldGETWithQueryParametersObject()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var extractor = new RequestExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Get("http://localhost:8080/api/customers")
.WithQueryParameters(new { customerid = 123 })
.Execute();
Assert.AreEqual("123", extractor.QueryString["customerid"], "The ID was not passed.");
}
}
public void ShouldGET()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
server.StatusCode = HttpStatusCode.OK;
server.Listen();
RestClient client = new RestClient();
var response = client.Get("http://localhost:8080/api/customers").Execute();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "The wrong status code was returned.");
Assert.IsTrue(response.IsSuccessStatusCode, "A success code was returned. There should be no error.");
Assert.IsNull(response.Result, "No WHEN handler was defined. The result should be null.");
}
}
public async Task UpdateAttachmentMetaTest()
{
var server = new FakeHttpServer(Port,
new[] { new FakeHttpServerResponse(200, ResponseMeta), new FakeHttpServerResponse(200, ResponseMeta) });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var meta = await storage.UpdateAttachmentMetaAsync(Country, RecordKey, FileId, FileId)
.ConfigureAwait(false);
Assert.NotNull(meta);
meta = await storage.UpdateAttachmentMetaAsync(Country, RecordKey, FileId, mimeType: MimeType)
.ConfigureAwait(false);
Assert.NotNull(meta);
server.Stop();
}
public void ShouldGETWithSimpleTemplate()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var extractor = new RequestExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Get("http://localhost:8080/api/customers/{customerId}", new
{
customerId = 123
}).Execute();
Assert.IsTrue(extractor.Url.ToString().EndsWith("123"), "The ID was not passed.");
}
}
public void ShouldGETWithCustomHeader()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var extractor = new RequestExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Get("http://localhost:8080/api/customers")
.WithHeader("test_header", "test_value")
.Execute();
var value = extractor.Headers.Get("test_header");
Assert.AreEqual("test_value", value, "The header was not passed to the server.");
}
}
public void ShouldGETWithSimpleTemplate()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var extractor = new RequestExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Get("http://localhost:8080/api/customers/{customerId}", new
{
customerId = 123
}).Execute();
Assert.IsTrue(extractor.Url.ToString().EndsWith("123"), "The ID was not passed.");
}
}
public void ShouldPOSTWithNoBody()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
RequestExtractor extractor = new RequestExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Post("http://localhost:8080/api/customers")
.WhenError(r => { throw new Exception(r.FromString <string>()); })
.Execute();
string contentLength = extractor.Headers["Content-Length"];
Assert.AreEqual("0", contentLength, "The content length was not specified.");
}
}
public async Task DeleteAttachmentTest()
{
var server = new FakeHttpServer(Port,
new[] { new FakeHttpServerResponse(204, "Deleted"), new FakeHttpServerResponse(404, "Not found") });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var status = await storage.DeleteAttachmentAsync(Country, RecordKey, FileId)
.ConfigureAwait(false);
Assert.IsTrue(status);
status = await storage.DeleteAttachmentAsync(Country, RecordKey, FileId)
.ConfigureAwait(false);
Assert.IsFalse(status);
server.Stop();
}
public void ShouldExtractMultiPartFormData()
{
using (FakeHttpServer server = new FakeHttpServer())
{
server.Host = "localhost";
server.Port = 8080;
server.Path = "api/v1/accounts";
server.StatusCode = HttpStatusCode.OK;
server.StatusDescription = "Success";
MultiPartBodyExtractor extractor = new MultiPartBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
WebRequest request = WebRequest.Create("http://localhost:8080/api/v1/accounts");
request.Method = "POST";
request.ContentType = "multipart/form-data; boundary=taco";
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write("--taco\r\n");
writer.Write("Content-Disposition: form-data; name=name\r\n");
writer.Write("\r\n");
writer.Write("bob\r\n");
writer.Write("--taco\r\n");
writer.Write("Content-Disposition: form-data; name=file; filename=help.txt\r\n");
writer.Write("Content-Type: text/plain\r\n");
writer.Write("\r\n");
writer.Write("These are the contents of the file.\r\n");
writer.Write("--taco--\r\n");
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
NameValueCollection collection = extractor.Parameters;
Assert.AreEqual("bob", collection.Get("name"), "Could not extract the name parameter.");
var files = extractor.Files.GetFiles("file");
Assert.AreEqual(1, files.Count(), "The wrong number of files were extracted.");
var file = files.First();
Assert.AreEqual("file", file.Name, "The name of the file part was not stored.");
Assert.AreEqual("help.txt", file.FileName, "The file name was not stored.");
Assert.AreEqual("text/plain", file.ContentType, "The file content type was not stored.");
Assert.AreEqual("These are the contents of the file.", Encoding.Default.GetString(file.Contents), "The file contents were wrong.");
}
}
}
public void ShouldExtractMultiPartFormData()
{
using (FakeHttpServer server = new FakeHttpServer())
{
server.Host = "localhost";
server.Port = 8080;
server.Path = "api/v1/accounts";
server.StatusCode = HttpStatusCode.OK;
server.StatusDescription = "Success";
MultiPartBodyExtractor extractor = new MultiPartBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
WebRequest request = WebRequest.Create("http://localhost:8080/api/v1/accounts");
request.Method = "POST";
request.ContentType = "multipart/form-data; boundary=taco";
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write("--taco\r\n");
writer.Write("Content-Disposition: form-data; name=name\r\n");
writer.Write("\r\n");
writer.Write("bob\r\n");
writer.Write("--taco\r\n");
writer.Write("Content-Disposition: form-data; name=file; filename=help.txt\r\n");
writer.Write("Content-Type: text/plain\r\n");
writer.Write("\r\n");
writer.Write("These are the contents of the file.\r\n");
writer.Write("--taco--\r\n");
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
NameValueCollection collection = extractor.Parameters;
Assert.AreEqual("bob", collection.Get("name"), "Could not extract the name parameter.");
var files = extractor.Files.GetFiles("file");
Assert.AreEqual(1, files.Count(), "The wrong number of files were extracted.");
var file = files.First();
Assert.AreEqual("file", file.Name, "The name of the file part was not stored.");
Assert.AreEqual("help.txt", file.FileName, "The file name was not stored.");
Assert.AreEqual("text/plain", file.ContentType, "The file content type was not stored.");
Assert.AreEqual("These are the contents of the file.", Encoding.Default.GetString(file.Contents), "The file contents were wrong.");
}
}
}
public void ReadTestNegativeUnexpected()
{
const string recordKey1 = "123";
const string responseBody1 = "unexpected";
const int responseStatus = 405;
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(responseStatus, responseBody1) });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var exception = Assert.ThrowsAsync <StorageServerException>(() => storage.ReadAsync("country", recordKey1));
Assert.IsTrue(exception.Message.Contains(
"Unexpected response: StatusCode: 405, ReasonPhrase: 'Method Not Allowed",
StringComparison.InvariantCulture));
server.Stop();
}
public void ShouldPostMultuPartWithInvalidCharacter()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
MultiPartBodyExtractor extractor = new MultiPartBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient("http://localhost:8080");
client.Post("api/customers")
.WithMultiPartBody(b =>
{
b.WithFormData(ub => ub.WithParameter("naӼme", "John Smith"));
})
.Execute();
Assert.AreEqual("John Smith", extractor.Parameters["na?me"], "The form data was not transfered.");
}
}
public void FindOneTestPositiveTest()
{
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(200, FindResponse) });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
const string recordKey = "456";
const string body = "body2";
var filter = new FindFilter()
.KeyEq(NumberField.Version, 0);
var foundedRecord = storage.FindOneAsync("country", filter).Result;
Assert.NotNull(foundedRecord);
Assert.AreEqual(body, foundedRecord.Body);
Assert.AreEqual(recordKey, foundedRecord.RecordKey);
server.Stop();
}
public void BatchWriteTestPositive()
{
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(201, "Created") });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
const string recordKey1 = "123";
const string recordKey2 = "345";
var recordList = new List <Record> {
new Record(recordKey1), new Record(recordKey2)
};
var records = storage.BatchWriteAsync("country", recordList).Result;
Assert.AreEqual(recordKey1, records[0].RecordKey);
Assert.AreEqual(recordKey2, records[1].RecordKey);
server.Stop();
}
public void ShouldPostMultuPartWithBase64Content()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
MultiPartBodyExtractor extractor = new MultiPartBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
string message = "Hello, World!Ӽ!";
byte[] messageRaw = Encoding.UTF8.GetBytes(message);
string base64 = Convert.ToBase64String(messageRaw);
byte[] base64Raw = Encoding.UTF8.GetBytes(base64);
NameValueCollection headers = new NameValueCollection();
headers.Add("Content-Transfer-Encoding", "base64");
RestClient client = new RestClient("http://localhost:8080");
client.Post("api/customers")
.WithMultiPartBody(b =>
{
b.WithFile("file", "file.txt", base64Raw, "text/plain", headers);
})
.Execute();
var file = extractor.Files.GetFiles("file").Single();
CollectionAssert.AreEqual(base64Raw, file.Contents);
}
}
public void ShouldPOSTWithFormDataObject()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var bodyExtractor = new UrlEncodedBodyExtractor();
var extractor = new RequestExtractor(bodyExtractor);
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Post("http://localhost:8080/api/customers")
.WithUrlEncodedBody(new
{
Name = "Bob Smith",
Age = 31,
Title = "Mr."
})
.Execute();
string name = bodyExtractor.Parameters["Name"];
string age = bodyExtractor.Parameters["Age"];
string title = bodyExtractor.Parameters["Title"];
Assert.AreEqual("Bob Smith", name, "The name was not sent.");
Assert.AreEqual("31", age, "The age was not sent.");
Assert.AreEqual("Mr.", title, "The title was not sent.");
}
}
public void ShouldPOSTWithArrayFormData()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var bodyExtractor = new UrlEncodedBodyExtractor();
var extractor = new RequestExtractor(bodyExtractor);
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Post("http://localhost:8080/api/customers")
.WithUrlEncodedBody(b => b
.WithParameter("CustomerId", 1)
.WithParameter("CustomerId", 2)
.WithParameter("CustomerId", 3))
.Execute();
string[] ids = bodyExtractor.Parameters.GetValues("CustomerId");
string[] expectedIds = new string[] { "1", "2", "3" };
CollectionAssert.AreEquivalent(expectedIds, ids, "The array of values were not sent.");
}
}
public void ShouldPOSTWithJsonData()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var bodyExtractor = new JsonBodyExtractor<TestCustomer>();
server.UseBodyExtractor(bodyExtractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Post("http://localhost:8080/api/customers")
.WithJsonBody(new TestCustomer() { Name = "Bob Smith", Age = 31, Title = "Mr." })
.Execute();
var customer = bodyExtractor.Result;
Assert.AreEqual("Bob Smith", customer.Name, "The name was not sent.");
Assert.AreEqual(31, customer.Age, "The age was not sent.");
Assert.AreEqual("Mr.", customer.Title, "The title was not sent.");
}
}
public void ShouldPOSTWithNoBody()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
RequestExtractor extractor = new RequestExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Post("http://localhost:8080/api/customers")
.WhenError(r => { throw new Exception(r.FromString<string>()); })
.Execute();
string contentLength = extractor.Headers["Content-Length"];
Assert.AreEqual("0", contentLength, "The content length was not specified.");
}
}
public async Task ShouldPOSTMultiPartDataAsync()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
MultiPartBodyExtractor extractor = new MultiPartBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient("http://localhost:8080");
await client.Post("api/customers")
.WithMultiPartBody(b =>
{
b.WithFormData(ub => ub.WithParameter("name", "John Smith"));
b.WithFile("file1", "path", Encoding.UTF8.GetBytes("Hello, world"), "text/plain");
})
.ExecuteAsync();
Assert.AreEqual("John Smith", extractor.Parameters["name"], "The form data was not transfered.");
var file = extractor.Files.GetFiles("file1").SingleOrDefault();
Assert.AreEqual("file1", file.Name);
Assert.AreEqual("path", file.FileName);
Assert.AreEqual("text/plain", file.ContentType);
Assert.AreEqual("Hello, world", Encoding.UTF8.GetString(file.Contents));
}
}
public void ShouldGetInt32()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/numbers"))
{
server.ReturnString("4");
server.Listen();
RestClient client = new RestClient("http://localhost:8080");
var response = client.Get("numbers")
.WhenSuccess(r => r.FromString<int>())
.Execute();
Assert.IsTrue(response.IsSuccessStatusCode, "An error occurred getting the number.");
Assert.AreEqual(4, response.GetResult<int>());
}
}
public void ShouldPostMultuPartWithInvalidCharacter()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
MultiPartBodyExtractor extractor = new MultiPartBodyExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient("http://localhost:8080");
client.Post("api/customers")
.WithMultiPartBody(b =>
{
b.WithFormData(ub => ub.WithParameter("naӼme", "John Smith"));
})
.Execute();
Assert.AreEqual("John Smith", extractor.Parameters["na?me"], "The form data was not transfered.");
}
}
public void ShouldGETWithCustomHeader()
{
using (FakeHttpServer server = new FakeHttpServer("http://localhost:8080/api/customers"))
{
var extractor = new RequestExtractor();
server.UseBodyExtractor(extractor);
server.Listen();
RestClient client = new RestClient();
var response = client.Get("http://localhost:8080/api/customers")
.WithHeader("test_header", "test_value")
.Execute();
var value = extractor.Headers.Get("test_header");
Assert.AreEqual("test_value", value, "The header was not passed to the server.");
}
}
