public void GoodRequest()
{
var res = new MockResponse()
{
ContentType = "application/json",
Code = System.Net.HttpStatusCode.OK,
Body = @"{ ""token"": 123, ""submissions"": 456, ""message"": ""test""}"
};
using (var c = new TestClient(res))
{
var actualResult = c.Client.Export.Request("test", SlideRoom.API.Resources.RequestFormat.Csv);
// test the request
var queryString = c.Request.QueryString;
GeneralClient.TestRequiredParameters(queryString);
queryString.ContainsAndEquals("export", "test");
queryString.ContainsAndEquals("format", "csv");
queryString.NotContains("ss");
queryString.NotContains("since");
var expectedResult = new SlideRoom.API.Resources.RequestResult()
{
Message = "test",
Submissions = 456,
Token = 123
};
Assert.AreEqual(expectedResult.Message, actualResult.Message);
Assert.AreEqual(expectedResult.Submissions, actualResult.Submissions);
Assert.AreEqual(expectedResult.Token, actualResult.Token);
}
}
public void GoodDownload()
{
var res = new MockResponse()
{
ContentType = "text/plain",
Code = System.Net.HttpStatusCode.OK,
Body = "test,report"
};
using (var c = new TestClient(res))
{
var actualResult = c.Client.Export.Download(123);
// test the request
var queryString = c.Request.QueryString;
GeneralClient.TestRequiredParameters(queryString);
queryString.ContainsAndEquals("token", "123");
Assert.IsFalse(actualResult.Pending);
Assert.IsNotNull(actualResult.ExportStream);
var actualReport = String.Empty;
using (StreamReader reader = new StreamReader(actualResult.ExportStream, Encoding.UTF8))
{
actualReport = reader.ReadToEnd();
}
Assert.AreEqual("test,report", actualReport);
}
}
public void BadRequest()
{
var res = new MockResponse()
{
ContentType = "application/json",
Code = System.Net.HttpStatusCode.NotFound,
Body = @"{ ""message"": ""Invalid Format"" }"
};
using (var c = new TestClient(res))
{
try
{
c.Client.Export.Request("test", SlideRoom.API.Resources.RequestFormat.Csv);
Assert.Fail("should throw an exception");
}
catch (SlideRoom.API.SlideRoomAPIException e)
{
Assert.AreEqual("Invalid Format", e.Message);
Assert.AreEqual(System.Net.HttpStatusCode.NotFound, e.StatusCode);
}
catch
{
Assert.Fail("should throw a SlideRoomAPIException");
}
}
}
public void BadDownload()
{
var res = new MockResponse()
{
ContentType = "application/json",
Code = System.Net.HttpStatusCode.Gone,
Body = @"{ ""message"": ""Export no longer available."" }"
};
using (var c = new TestClient(res))
{
try
{
c.Client.Export.Download(123);
Assert.Fail("should throw an exception");
}
catch (SlideRoom.API.SlideRoomAPIException e)
{
Assert.AreEqual("Export no longer available.", e.Message);
Assert.AreEqual(System.Net.HttpStatusCode.Gone, e.StatusCode);
}
catch
{
Assert.Fail("should throw a SlideRoomAPIException");
}
}
}
public void GoodPendingDownload()
{
var res = new MockResponse()
{
ContentType = "application/json",
Code = System.Net.HttpStatusCode.Accepted,
Body = ""
};
using (var c = new TestClient(res))
{
var actualResult = c.Client.Export.Download(123);
var expectedResult = new SlideRoom.API.Resources.DownloadResult()
{
Pending = true,
ExportStream = null
};
Assert.AreEqual(actualResult.ExportStream, expectedResult.ExportStream);
Assert.AreEqual(actualResult.Pending, expectedResult.Pending);
}
}
public MockHttpContext()
{
cookies = new HttpCookieCollection();
response = new MockResponse(cookies);
request = new MockRequest(cookies);
}
public void GoodRequestWithSinceAndSavedSearch()
{
var res = new MockResponse()
{
ContentType = "application/json",
Code = System.Net.HttpStatusCode.OK,
Body = @"{ ""token"": 123, ""submissions"": 456, ""message"": ""test""}"
};
var since = DateTime.Now;
var sinceVal = (long)((TimeSpan)(since.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0, 0))).TotalSeconds;
using (var c = new TestClient(res))
{
var actualResult = c.Client.Export.Request("test", SlideRoom.API.Resources.RequestFormat.Csv, "saved search", since);
// test the request too..
var queryString = c.Request.QueryString;
GeneralClient.TestRequiredParameters(queryString);
queryString.ContainsAndEquals("export", "test");
queryString.ContainsAndEquals("format", "csv");
queryString.ContainsAndEquals("ss", "saved search");
queryString.ContainsAndEquals("since", sinceVal.ToString());
var expectedResult = new SlideRoom.API.Resources.RequestResult()
{
Message = "test",
Submissions = 456,
Token = 123
};
Assert.AreEqual(expectedResult.Message, actualResult.Message);
Assert.AreEqual(expectedResult.Submissions, actualResult.Submissions);
Assert.AreEqual(expectedResult.Token, actualResult.Token);
}
}
public void ContentTypeReturnsNullForNoHeader()
{
var mockResponse = new MockResponse(200);
Assert.Null(mockResponse.Headers.ContentType);
}
public void DateReturnsNullForNoHeader()
{
var mockResponse = new MockResponse(200);
Assert.Null(mockResponse.Headers.Date);
}
public async Task ActionGroupsCreateOrUpdateTest()
{
var actionGroupResource = new ActionGroupResource("ONE", "Name", null, "West Us",
new Dictionary <string, string>(), null, true,
new List <EmailReceiver>()
{
new EmailReceiver("Email", "Email@AZ", true, ReceiverStatus.Enabled)
},
new List <SmsReceiver>()
{
new SmsReceiver("SmsName", "countryCode", "phoneNum", ReceiverStatus.Enabled)
},
new List <WebhookReceiver>(),
new List <ItsmReceiver>(),
new List <AzureAppPushReceiver>(),
new List <AutomationRunbookReceiver>(),
new List <VoiceReceiver>(),
new List <LogicAppReceiver>(),
new List <AzureFunctionReceiver>(),
new List <ArmRoleReceiver>());
var mockResponse = new MockResponse((int)HttpStatusCode.OK);
var content = @"{
'id': 'ONE',
'name': 'Name',
'type': null,
'location': 'West Us',
'tags': { },
'properties':
{
'groupShortName': null,
'enabled': true,
'emailReceivers': [
{
'name': 'Email',
'emailAddress': 'Email@AZ',
'useCommonAlertSchema': true,
'status': 'Enabled'
}
],
'smsReceivers': [
{
'name': 'SmsName',
'countryCode': 'countryCode',
'phoneNumber': 'phoneNum',
'status': 'Enabled'
}
],
'webhookReceivers': [],
'itsmReceivers': [],
'azureAppPushReceivers': [],
'automationRunbookReceivers': [],
'voiceReceivers': [],
'logicAppReceivers': [],
'azureFunctionReceivers': [],
'armRoleReceivers': []
}
}
".Replace("'", "\"");
mockResponse.SetContent(content);
var mockTransport = new MockTransport(mockResponse);
var insightsClient = GetInsightsManagementClient(mockTransport);
var result = (await insightsClient.ActionGroups.CreateOrUpdateAsync("rg1", "actGroup1", actionGroupResource)).Value;
AreEqual(actionGroupResource, result);
}
public void ExecuteMultipleStatementInOneRequestHttpRequest()
{
const string headerName = "MyTestHeader";
const string headerValue = "myTestHeaderValue";
var customHeaders = new NameValueCollection {
{ headerName, headerValue }
};
var initTransactionRequest = MockRequest.PostJson("/transaction", @"{
'statements': [{'statement': 'MATCH n\r\nRETURN count(n)', 'resultDataContents':[], 'parameters': {}}, {'statement': 'MATCH t\r\nRETURN count(t)', 'resultDataContents':[], 'parameters': {}}]}");
var commitRequest = MockRequest.PostJson("/transaction/1/commit", @"{'statements': []}");
using (var testHarness = new RestTestHarness
{
{
initTransactionRequest,
MockResponse.Json(201, TransactionRestResponseHelper.GenerateInitTransactionResponse(1), "http://foo/db/data/transaction/1")
},
{
commitRequest, MockResponse.Json(200, @"{'results':[], 'errors':[] }")
}
})
{
var response = MockResponse.NeoRoot20();
testHarness.Add(MockRequest.Get(""), response);
var httpClient = testHarness.GenerateHttpClient("http://foo/db/data");
testHarness.CreateAndConnectTransactionalGraphClient();
ITransactionalGraphClient client = new GraphClient(new Uri("http://foo/db/data"), httpClient);
client.Connect();
using (var transaction = client.BeginTransaction())
{
// dummy query to generate request
var rawClient = client as IRawGraphClient;
if (rawClient == null)
{
Assert.Fail("ITransactionalGraphClient is not IRawGraphClient");
}
var queries = new List <CypherQuery>()
{
client.Cypher
.Match("n")
.Return(n => n.Count())
.Query,
client.Cypher
.Match("t")
.Return(t => t.Count())
.Query
};
httpClient.ClearReceivedCalls();
rawClient.ExecuteMultipleCypherQueriesInTransaction(queries, customHeaders);
transaction.Commit();
var calls = httpClient.ReceivedCalls().ToList();
Assert.IsNotEmpty(calls);
HttpRequestMessage requestMessage = null;
foreach (var call in calls)
{
if (call.GetArguments().Single().GetType() == typeof(HttpRequestMessage))
{
requestMessage = (HttpRequestMessage)call.GetArguments().Single();
}
}
Assert.IsNotNull(requestMessage);
var customHeader = requestMessage.Headers.Single(h => h.Key == headerName);
Assert.IsNotNull(customHeader);
Assert.AreEqual(headerValue, customHeader.Value.Single());
}
}
}
public void ShouldDeserializeArrayOfNodesInPropertyAsResultOfCollectFunctionInCypherQuery()
{
// Arrange
var cypherQuery = new CypherQuery(
@"START root=node(0) MATCH root-[:HAS_COMPANIES]->()-[:HAS_COMPANY]->company, company--foo RETURN company, collect(foo) as Bar",
new Dictionary <string, object>(),
CypherResultMode.Projection,
CypherResultFormat.Rest);
var cypherApiQuery = new CypherApiQuery(cypherQuery);
using (var testHarness = new RestTestHarness
{
{
MockRequest.PostObjectAsJson("/cypher", cypherApiQuery),
MockResponse.Json(HttpStatusCode.OK, @"{
'columns' : [ 'ColumnA', 'ColumnBFromCollect' ],
'data' : [ [ {
'paged_traverse' : 'http://localhost:8000/db/data/node/358/paged/traverse/{returnType}{?pageSize,leaseTime}',
'outgoing_relationships' : 'http://localhost:8000/db/data/node/358/relationships/out',
'data' : {
'Bar' : 'BHP',
'Baz' : '1'
},
'all_typed_relationships' : 'http://localhost:8000/db/data/node/358/relationships/all/{-list|&|types}',
'traverse' : 'http://localhost:8000/db/data/node/358/traverse/{returnType}',
'self' : 'http://localhost:8000/db/data/node/358',
'property' : 'http://localhost:8000/db/data/node/358/properties/{key}',
'all_relationships' : 'http://localhost:8000/db/data/node/358/relationships/all',
'outgoing_typed_relationships' : 'http://localhost:8000/db/data/node/358/relationships/out/{-list|&|types}',
'properties' : 'http://localhost:8000/db/data/node/358/properties',
'incoming_relationships' : 'http://localhost:8000/db/data/node/358/relationships/in',
'incoming_typed_relationships' : 'http://localhost:8000/db/data/node/358/relationships/in/{-list|&|types}',
'extensions' : {
},
'create_relationship' : 'http://localhost:8000/db/data/node/358/relationships'
}, [ {
'paged_traverse' : 'http://localhost:8000/db/data/node/362/paged/traverse/{returnType}{?pageSize,leaseTime}',
'outgoing_relationships' : 'http://localhost:8000/db/data/node/362/relationships/out',
'data' : {
'OpportunityType' : 'Board',
'Description' : 'Foo'
},
'all_typed_relationships' : 'http://localhost:8000/db/data/node/362/relationships/all/{-list|&|types}',
'traverse' : 'http://localhost:8000/db/data/node/362/traverse/{returnType}',
'self' : 'http://localhost:8000/db/data/node/362',
'property' : 'http://localhost:8000/db/data/node/362/properties/{key}',
'all_relationships' : 'http://localhost:8000/db/data/node/362/relationships/all',
'outgoing_typed_relationships' : 'http://localhost:8000/db/data/node/362/relationships/out/{-list|&|types}',
'properties' : 'http://localhost:8000/db/data/node/362/properties',
'incoming_relationships' : 'http://localhost:8000/db/data/node/362/relationships/in',
'incoming_typed_relationships' : 'http://localhost:8000/db/data/node/362/relationships/in/{-list|&|types}',
'extensions' : {
},
'create_relationship' : 'http://localhost:8000/db/data/node/362/relationships'
}, {
'paged_traverse' : 'http://localhost:8000/db/data/node/359/paged/traverse/{returnType}{?pageSize,leaseTime}',
'outgoing_relationships' : 'http://localhost:8000/db/data/node/359/relationships/out',
'data' : {
'OpportunityType' : 'Executive',
'Description' : 'Bar'
},
'all_typed_relationships' : 'http://localhost:8000/db/data/node/359/relationships/all/{-list|&|types}',
'traverse' : 'http://localhost:8000/db/data/node/359/traverse/{returnType}',
'self' : 'http://localhost:8000/db/data/node/359',
'property' : 'http://localhost:8000/db/data/node/359/properties/{key}',
'all_relationships' : 'http://localhost:8000/db/data/node/359/relationships/all',
'outgoing_typed_relationships' : 'http://localhost:8000/db/data/node/359/relationships/out/{-list|&|types}',
'properties' : 'http://localhost:8000/db/data/node/359/properties',
'incoming_relationships' : 'http://localhost:8000/db/data/node/359/relationships/in',
'incoming_typed_relationships' : 'http://localhost:8000/db/data/node/359/relationships/in/{-list|&|types}',
'extensions' : {
},
'create_relationship' : 'http://localhost:8000/db/data/node/359/relationships'
} ] ] ]
}")
}
})
{
var graphClient = testHarness.CreateAndConnectGraphClient();
//Act
var results = graphClient.ExecuteGetCypherResults <CollectResult>(cypherQuery);
//Assert
Assert.IsInstanceOf <IEnumerable <CollectResult> >(results);
var resultsArray = results.ToArray();
Assert.AreEqual(1, resultsArray.Count());
var firstResult = resultsArray[0];
Assert.AreEqual(358, firstResult.ColumnA.Reference.Id);
Assert.AreEqual("BHP", firstResult.ColumnA.Data.Bar);
Assert.AreEqual("1", firstResult.ColumnA.Data.Baz);
var collectedResults = firstResult.ColumnBFromCollect.ToArray();
Assert.AreEqual(2, collectedResults.Count());
var firstCollectedResult = collectedResults[0];
Assert.AreEqual(362, firstCollectedResult.Reference.Id);
Assert.AreEqual("Board", firstCollectedResult.Data.OpportunityType);
Assert.AreEqual("Foo", firstCollectedResult.Data.Description);
var secondCollectedResult = collectedResults[1];
Assert.AreEqual(359, secondCollectedResult.Reference.Id);
Assert.AreEqual("Executive", secondCollectedResult.Data.OpportunityType);
Assert.AreEqual("Bar", secondCollectedResult.Data.Description);
}
}
private void BuildResponse(HttpListenerResponse response, MockResponse mockResponse)
{
response.StatusCode = mockResponse.StatusCode;
response.StatusDescription = mockResponse.StatusDescription;
response.Headers.Clear();
if (mockResponse.Headers != null)
{
foreach (string header in mockResponse.Headers)
{
var value = mockResponse.Headers[header];
switch (header)
{
case "Connection":
response.KeepAlive = (value.ToLower() == "keep-alive");
break;
case "Content-Length":
response.ContentLength64 = long.Parse(value);
break;
case "Content-Type":
response.ContentType = value;
break;
case "Location":
response.RedirectLocation = value;
break;
case "Transfer-Encoding":
response.SendChunked = (value.ToLower() == "chunked");
break;
default:
response.Headers[header] = value;
break;
}
}
}
if (mockResponse.Content != null)
{
var contentType = GetContentType(mockResponse.Headers?.Get("Content-Type"));
if (IsTextContent(contentType))
{
var encoding = GetEncoding(contentType.CharSet);
var content = encoding.GetBytes(mockResponse.Content);
using (var stream = response.OutputStream)
{
stream.Write(content, 0, content.Length);
}
}
else
{
using (BinaryWriter writer = new BinaryWriter(response.OutputStream))
{
writer.Write(Convert.FromBase64String(mockResponse.Content));
}
}
}
}
public async Task ProviderGetValidateMessage()
{
var mockResponse = new MockResponse((int)HttpStatusCode.OK);
var content = @"{
'namespace': 'Microsoft.Websites',
'registrationState': 'Registered',
'resourceTypes': [
{
'resourceType': 'sites',
'locations': [
'Central US'
],
'aliases': [{
'name': 'Microsoft.Compute/virtualMachines/sku.name',
'paths': [{
'path': 'properties.hardwareProfile.vmSize',
'apiVersions': [
'2015-05-01-preview',
'2015-06-15',
'2016-03-30',
'2016-04-30-preview'
]
}]
},
{
'name': 'Microsoft.Compute/virtualMachines/imagePublisher',
'paths': [{
'path': 'properties.storageProfile.imageReference.publisher',
'apiVersions': [
'2015-05-01-preview',
'2015-06-15',
'2016-03-30',
'2016-04-30-preview'
]
}]
}]
},
{
'resourceType': 'sites/pages',
'locations': [
'West US'
]
}]
}".Replace("'", "\"");
mockResponse.SetContent(content);
var header = new HttpHeader("x-ms-request-id", "1");
mockResponse.AddHeader(header);
var mockTransport = new MockTransport(mockResponse);
var client = GetResourceManagementClient(mockTransport);
var result = (await client.Providers.GetAsync("Microsoft.Websites", expand: "resourceTypes/aliases")).Value;
// Validate headers
var request = mockTransport.Requests[0];
Assert.AreEqual(HttpMethod.Get.Method, request.Method.Method);
Assert.IsTrue(request.Headers.Contains("Authorization"));
// Validate result
Assert.AreEqual("Microsoft.Websites", result.Namespace);
Assert.AreEqual("Registered", result.RegistrationState);
Assert.AreEqual(2, result.ResourceTypes.Count);
Assert.AreEqual("sites", result.ResourceTypes[0].ResourceType);
Assert.AreEqual(1, result.ResourceTypes[0].Locations.Count);
Assert.AreEqual("Central US", result.ResourceTypes[0].Locations[0]);
Assert.AreEqual(2, result.ResourceTypes[0].Aliases.Count);
Assert.AreEqual("Microsoft.Compute/virtualMachines/sku.name", result.ResourceTypes[0].Aliases[0].Name);
Assert.AreEqual(1, result.ResourceTypes[0].Aliases[0].Paths.Count);
Assert.AreEqual("properties.hardwareProfile.vmSize", result.ResourceTypes[0].Aliases[0].Paths[0].Path);
}
public void DownloadSecretDenied()
{
CertificateClientOptions options = new CertificateClientOptions
{
Transport = new MockTransport(request =>
{
if (request.Uri.Path.Contains("/certificates/"))
{
MockResponse response = new MockResponse(200);
response.AddHeader(Core.HttpHeader.Common.JsonContentType);
response.SetContent(@"{
""id"": ""https://heathskeyvault.vault.azure.net/certificates/1611349050/548e19c596cf49779ca1706240a788e3"",
""kid"": ""https://heathskeyvault.vault.azure.net/keys/1611349050/548e19c596cf49779ca1706240a788e3"",
""sid"": ""https://heathskeyvault.vault.azure.net/secrets/1611349050/548e19c596cf49779ca1706240a788e3"",
""x5t"": ""SM_LGoask0yHvMVSk3h-0Kf3gqE"",
""cer"": ""MIIDKjCCAhKgAwIBAgIQYV16SxDIQkKURxXo6sQkUTANBgkqhkiG9w0BAQsFADASMRAwDgYDVQQDEwdkZWZhdWx0MB4XDTIwMTExMDA0MjYxNloXDTIxMTExMDA0MzYxNlowEjEQMA4GA1UEAxMHZGVmYXVsdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALrumIRenUa5LmJsRurAhrRoJP0hyCg8jQz5ujXFoyf/flklfyqxnau5/a2yS4mnfJm9fX1aFF1/OdEg5qxcyHSBR66\u002BdPV27oxIfM6JKVqbHBcaG07OVFHh\u002B2yWBwTjAiPZjOxCxEMw37tdgDctnEBQzaTackhFU21seBWnHCC74mF2N3Iy93itptOguvwIh6CnLcduvIeb6o9lfr72XJg0BjJ/Bmpf92W5VwMWinHUumomCeLjA5lnIiOGGrmVNqaRJWf1ezhg3JtzNJRSV0sbLjHoCmziKAL4pFLEiF6tz\u002B6apvz1voDufit6r0gKwez8YaOnQjUAmXetoZmSOQkCAwEAAaN8MHowDgYDVR0PAQH/BAQDAgSQMAkGA1UdEwQCMAAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB8GA1UdIwQYMBaAFNwU63f97Oel4UIAJt6/nQ9Ka12HMB0GA1UdDgQWBBTcFOt3/eznpeFCACbev50PSmtdhzANBgkqhkiG9w0BAQsFAAOCAQEAcs\u002B0b3\u002BUI0AmrvwQZVugfnbngNN5jDpuEyP8gms4Txpg93auVXgXlgiNsrKUgIi2U2CQLY6pdUUSilBHifCdxM3lxgB7wIkYc8ihu8eVBI7m4KNo1io0Jxwsw9KKG3612NUXuKDz8oHMUsJ49Iq8IaRaJdVpiydZCA9ltwhajWpgauOTMRsxtZdkG\u002BlakSCehBCgmjGR04NRG0jGNRaTh4ANHNQgFqP4Vp6mkzDxQu8B4PI5YKZfhpusqEDOSb5HeM8nwLYntNH32in1XKx3s5BSMUmbrdmeihAIyYxR3Imal5LwjckXvu6eXlRfe6BynbDW1g3IwNASMIwt3u0dhQ=="",
""attributes"": {
""enabled"": true,
""nbf"": 1604982376,
""exp"": 1636518976,
""created"": 1604982976,
""updated"": 1604982976,
""recoveryLevel"": ""Recoverable\u002BPurgeable"",
""recoverableDays"": 90
},
""policy"": {
""id"": ""https://heathskeyvault.vault.azure.net/certificates/1611349050/policy"",
""key_props"": {
""exportable"": true,
""kty"": ""RSA"",
""key_size"": 2048,
""reuse_key"": false
},
""secret_props"": {
""contentType"": ""application/x-pkcs12""
},
""x509_props"": {
""subject"": ""CN=default"",
""ekus"": [
""1.3.6.1.5.5.7.3.1"",
""1.3.6.1.5.5.7.3.2""
],
""key_usage"": [
""dataEncipherment"",
""digitalSignature""
],
""validity_months"": 12,
""basic_constraints"": {
""ca"": false
}
},
""lifetime_actions"": [
{
""trigger"": {
""lifetime_percentage"": 80
},
""action"": {
""action_type"": ""AutoRenew""
}
}
],
""issuer"": {
""name"": ""Self"",
""cert_transparency"": false
},
""attributes"": {
""enabled"": true,
""created"": 1604982971,
""updated"": 1604982971
}
},
""pending"": {
""id"": ""https://heathskeyvault.vault.azure.net/certificates/1611349050/pending""
}
}");
return(response);
}
else if (request.Uri.Path.StartsWith("/secrets/1611349050/548e19c596cf49779ca1706240a788e3"))
{
MockResponse response = new MockResponse(403);
response.AddHeader(Core.HttpHeader.Common.JsonContentType);
response.SetContent(@"{
""error"": {
""code"": ""Forbidden"",
""message"": ""The user, group or application 'appid=f9ab11db-b032-44b3-af0a-44713541cc40;oid=0aa95430-9a7f-4c8e-8cf6-579278e68947;iss=https://sts.windows.net/72f988bf-86f1-41af-91ab-2d7cd011db47/' does not have secrets get permission on key vault 'heathskeyvault;location=westus2'. For help resolving this issue, please see https://go.microsoft.com/fwlink/?linkid=2125287"",
""innererror"": {
""code"": ""ForbiddenByPolicy""
}
}
}");
return(response);
}
else
{
return(new MockResponse(404));
}
}),
};
CertificateClient client = InstrumentClient(new CertificateClient(new Uri("https://heathskeyvault.vault.azure.net"), new DefaultAzureCredential(), options));
RequestFailedException ex = Assert.ThrowsAsync <RequestFailedException>(async() => await client.DownloadCertificateAsync("test"));
Assert.AreEqual(403, ex.Status);
Assert.AreEqual("Forbidden", ex.ErrorCode);
}
public async Task GetBatch()
{
var response1 = new MockResponse(200);
response1.SetContent(SerializationHelpers.Serialize(new []
{
CreateSetting(0),
CreateSetting(1),
}, SerializeBatch));
response1.AddHeader(new HttpHeader("Link", $"</kv?after=5>;rel=\"next\""));
var response2 = new MockResponse(200);
response2.SetContent(SerializationHelpers.Serialize(new []
{
CreateSetting(2),
CreateSetting(3),
CreateSetting(4),
}, SerializeBatch));
var mockTransport = new MockTransport(response1, response2);
ConfigurationClient service = CreateTestService(mockTransport);
var query = new SettingSelector();
int keyIndex = 0;
while (true)
{
using (Response <SettingBatch> response = await service.GetBatchAsync(query, CancellationToken.None))
{
SettingBatch batch = response.Value;
for (int i = 0; i < batch.Count; i++)
{
ConfigurationSetting value = batch[i];
Assert.AreEqual("key" + keyIndex, value.Key);
keyIndex++;
}
var nextBatch = batch.NextBatch;
if (nextBatch == null)
{
break;
}
query = nextBatch;
}
}
Assert.AreEqual(2, mockTransport.Requests.Count);
MockRequest request1 = mockTransport.Requests[0];
Assert.AreEqual(HttpPipelineMethod.Get, request1.Method);
Assert.AreEqual("https://contoso.azconfig.io/kv/?key=*&label=*", request1.UriBuilder.ToString());
AssertRequestCommon(request1);
MockRequest request2 = mockTransport.Requests[1];
Assert.AreEqual(HttpPipelineMethod.Get, request2.Method);
Assert.AreEqual("https://contoso.azconfig.io/kv/?key=*&label=*&after=5", request2.UriBuilder.ToString());
AssertRequestCommon(request1);
}
public static MockResponse WithContent(this MockResponse response, string content)
{
response.SetContent(content);
return(response);
}
public async Task ListSubscriptions()
{
var mockResponse = new MockResponse((int)HttpStatusCode.OK);
var content = @"{
'value': [{
'id': '/subscriptions/38b598fc-e57a-423f-b2e7-dc0ddb631f1f',
'subscriptionId': '38b598fc-e57a-423f-b2e7-dc0ddb631f1f',
'displayName': 'Visual Studio Ultimate with MSDN',
'state': 'Disabled',
'subscriptionPolicies': {
'locationPlacementId': 'Public_2014-09-01',
'quotaId': 'MSDN_2014-09-01'
}
},
{
'id': '/subscriptions/9167af2d-c13e-4d34-9a57-8f37dba6ff31',
'subscriptionId': '9167af2d-c13e-4d34-9a57-8f37dba6ff31',
'displayName': 'Subscription-1',
'state': 'Enabled',
'subscriptionPolicies': {
'locationPlacementId': 'Internal_2014-09-01',
'quotaId': 'Internal_2014-09-01'
}
},
{
'id': '/subscriptions/78814224-3c2d-4932-9fe3-913da0f278ee',
'subscriptionId': '78814224-3c2d-4932-9fe3-913da0f278ee',
'displayName': 'Cloud Tools Development',
'state': 'Enabled',
'subscriptionPolicies': {
'locationPlacementId': 'Internal_2014-09-01',
'quotaId': 'Internal_2014-09-01'
}
}]
}".Replace("'", "\"");
var header = new HttpHeader("x-ms-request-id", "1");
mockResponse.AddHeader(header);
mockResponse.SetContent(content);
var mockTransport = new MockTransport(mockResponse);
var client = GetResourceManagementClient(mockTransport);
var listSubscriptionsResult = await client.Subscriptions.ListAsync().ToEnumerableAsync();
// Validate headers
var request = mockTransport.Requests[0];
Assert.AreEqual(HttpMethod.Get.Method, request.Method.Method);
Assert.IsTrue(request.Headers.Contains("Authorization"));
// Validate result
Assert.NotNull(listSubscriptionsResult);
Assert.AreEqual("/subscriptions/38b598fc-e57a-423f-b2e7-dc0ddb631f1f", listSubscriptionsResult.FirstOrDefault().Id);
Assert.AreEqual("38b598fc-e57a-423f-b2e7-dc0ddb631f1f", listSubscriptionsResult.FirstOrDefault().SubscriptionId);
Assert.AreEqual("Visual Studio Ultimate with MSDN", listSubscriptionsResult.FirstOrDefault().DisplayName);
Assert.AreEqual("Disabled", listSubscriptionsResult.FirstOrDefault().State.ToString());
Assert.NotNull(listSubscriptionsResult.FirstOrDefault().SubscriptionPolicies);
Assert.AreEqual("Public_2014-09-01", listSubscriptionsResult.FirstOrDefault().SubscriptionPolicies.LocationPlacementId);
Assert.AreEqual("MSDN_2014-09-01", listSubscriptionsResult.FirstOrDefault().SubscriptionPolicies.QuotaId);
}
internal override async Task <string> HttpSendAsync(HttpRequestMessage msg)
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Headers.Add("X-RateLimit-Limit", "222");
response.Headers.Add("X-RateLimit-Remaining", "122");
response.Headers.Add("X-RateLimit-Reset", "33333");
httpHeaders = response.Headers;
var uri = msg.RequestUri.AbsoluteUri;
if (uri.Contains("/videos") && msg.Method == HttpMethod.Post)
{
responseType = MockResponse.Video;
}
if (uri.Contains("/signature") && msg.Method == HttpMethod.Post)
{
if (responseType != MockResponse.SignatureFailed)
{
responseType = MockResponse.Signature;
}
}
var content = @"{}";
switch (responseType)
{
case MockResponse.MissingData:
content = missing_data;
break;
case MockResponse.DataNotArray:
content = data_not_array;
break;
case MockResponse.MissingMeta:
content = missing_meta;
break;
case MockResponse.MissingLinks:
content = missing_links;
break;
case MockResponse.MissingFirst:
content = missing_first;
break;
case MockResponse.MissingLast:
content = missing_last;
break;
case MockResponse.MissingNext:
content = missing_next;
break;
case MockResponse.MissingPrevious:
content = missing_previous;
break;
case MockResponse.RecordPaginate:
content = record_paginate;
break;
case MockResponse.RecordPaginateEmpty:
content = record_paginate_empty;
break;
case MockResponse.MissingId:
content = missing_id;
break;
case MockResponse.Recipe:
content = recipe;
break;
case MockResponse.RecipesList:
content = recipesList_base;
if (msg.RequestUri.Query != "")
{
content = recipesList_query;
}
break;
case MockResponse.Preset:
content = preset;
break;
case MockResponse.PresetsList:
content = presetsList_base;
if (msg.RequestUri.Query != "")
{
content = presetsList_query;
}
break;
case MockResponse.CategoriesList:
content = categoriesList_base;
if (msg.RequestUri.Query != "")
{
content = categoriesList_query;
}
break;
case MockResponse.Category:
content = category;
if (msg.RequestUri.AbsoluteUri.Contains("subtree"))
{
content = categoriesList_base;
}
break;
case MockResponse.Video:
content = video;
break;
case MockResponse.Signature:
content = "";
if (msg.RequestUri.AbsoluteUri.Contains("single"))
{
content = signature_single;
}
if (msg.RequestUri.AbsoluteUri.Contains("multipart"))
{
content = signature_multipart;
}
break;
case MockResponse.SignatureFailed:
content = "";
if (msg.RequestUri.AbsoluteUri.Contains("single"))
{
content = signature_single_failed;
}
if (msg.RequestUri.AbsoluteUri.Contains("multipart"))
{
content = signature_multipart_failed;
}
break;
case MockResponse.VideosList:
content = videosList_base;
if (msg.RequestUri.Query != "")
{
content = videosList_query;
}
break;
case MockResponse.Playlist:
content = playlist;
break;
case MockResponse.PlaylistsList:
content = playlistsList_base;
if (msg.RequestUri.Query != "")
{
content = playlistsList_query;
}
break;
break;
}
return(content);
}
public void ShouldDeserializeTableStructureWithNodeDataObjects()
{
// Arrange
const string queryText = @"
START x = node({p0})
MATCH x-[r]->n
RETURN x AS Fooness, type(r) AS RelationshipType, n.Name? AS Name, n.UniqueId? AS UniqueId
LIMIT 3";
var cypherQuery = new CypherQuery(
queryText,
new Dictionary <string, object>
{
{ "p0", 123 }
},
CypherResultMode.Projection,
CypherResultFormat.Rest);
var cypherApiQuery = new CypherApiQuery(cypherQuery);
using (var testHarness = new RestTestHarness
{
{
MockRequest.PostObjectAsJson("/cypher", cypherApiQuery),
MockResponse.Json(HttpStatusCode.OK, @"{
'data' : [ [ {
'outgoing_relationships' : 'http://foo/db/data/node/0/relationships/out',
'data' : {
'Bar' : 'bar',
'Baz' : 'baz'
},
'traverse' : 'http://foo/db/data/node/0/traverse/{returnType}',
'all_typed_relationships' : 'http://foo/db/data/node/0/relationships/all/{-list|&|types}',
'property' : 'http://foo/db/data/node/0/properties/{key}',
'self' : 'http://foo/db/data/node/0',
'properties' : 'http://foo/db/data/node/0/properties',
'outgoing_typed_relationships' : 'http://foo/db/data/node/0/relationships/out/{-list|&|types}',
'incoming_relationships' : 'http://foo/db/data/node/0/relationships/in',
'extensions' : {
},
'create_relationship' : 'http://foo/db/data/node/0/relationships',
'paged_traverse' : 'http://foo/db/data/node/0/paged/traverse/{returnType}{?pageSize,leaseTime}',
'all_relationships' : 'http://foo/db/data/node/0/relationships/all',
'incoming_typed_relationships' : 'http://foo/db/data/node/0/relationships/in/{-list|&|types}'
}, 'HOSTS', 'foo', 44321 ], [ {
'outgoing_relationships' : 'http://foo/db/data/node/0/relationships/out',
'data' : {
'Bar' : 'bar',
'Baz' : 'baz'
},
'traverse' : 'http://foo/db/data/node/0/traverse/{returnType}',
'all_typed_relationships' : 'http://foo/db/data/node/0/relationships/all/{-list|&|types}',
'property' : 'http://foo/db/data/node/0/properties/{key}',
'self' : 'http://foo/db/data/node/2',
'properties' : 'http://foo/db/data/node/0/properties',
'outgoing_typed_relationships' : 'http://foo/db/data/node/0/relationships/out/{-list|&|types}',
'incoming_relationships' : 'http://foo/db/data/node/0/relationships/in',
'extensions' : {
},
'create_relationship' : 'http://foo/db/data/node/0/relationships',
'paged_traverse' : 'http://foo/db/data/node/0/paged/traverse/{returnType}{?pageSize,leaseTime}',
'all_relationships' : 'http://foo/db/data/node/0/relationships/all',
'incoming_typed_relationships' : 'http://foo/db/data/node/0/relationships/in/{-list|&|types}'
}, 'LIKES', 'bar', 44311 ], [ {
'outgoing_relationships' : 'http://foo/db/data/node/0/relationships/out',
'data' : {
'Bar' : 'bar',
'Baz' : 'baz'
},
'traverse' : 'http://foo/db/data/node/0/traverse/{returnType}',
'all_typed_relationships' : 'http://foo/db/data/node/0/relationships/all/{-list|&|types}',
'property' : 'http://foo/db/data/node/0/properties/{key}',
'self' : 'http://foo/db/data/node/12',
'properties' : 'http://foo/db/data/node/0/properties',
'outgoing_typed_relationships' : 'http://foo/db/data/node/0/relationships/out/{-list|&|types}',
'incoming_relationships' : 'http://foo/db/data/node/0/relationships/in',
'extensions' : {
},
'create_relationship' : 'http://foo/db/data/node/0/relationships',
'paged_traverse' : 'http://foo/db/data/node/0/paged/traverse/{returnType}{?pageSize,leaseTime}',
'all_relationships' : 'http://foo/db/data/node/0/relationships/all',
'incoming_typed_relationships' : 'http://foo/db/data/node/0/relationships/in/{-list|&|types}'
}, 'HOSTS', 'baz', 42586 ] ],
'columns' : [ 'Fooness', 'RelationshipType', 'Name', 'UniqueId' ]
}")
}
})
{
var graphClient = testHarness.CreateAndConnectGraphClient();
//Act
var results = graphClient.ExecuteGetCypherResults <ResultWithNodeDataObjectsDto>(cypherQuery);
//Assert
Assert.IsInstanceOf <IEnumerable <ResultWithNodeDataObjectsDto> >(results);
var resultsArray = results.ToArray();
Assert.AreEqual(3, resultsArray.Count());
var firstResult = resultsArray[0];
Assert.AreEqual("bar", firstResult.Fooness.Bar);
Assert.AreEqual("baz", firstResult.Fooness.Baz);
Assert.AreEqual("HOSTS", firstResult.RelationshipType);
Assert.AreEqual("foo", firstResult.Name);
Assert.AreEqual(44321, firstResult.UniqueId);
var secondResult = resultsArray[1];
Assert.AreEqual("bar", secondResult.Fooness.Bar);
Assert.AreEqual("baz", secondResult.Fooness.Baz);
Assert.AreEqual("LIKES", secondResult.RelationshipType);
Assert.AreEqual("bar", secondResult.Name);
Assert.AreEqual(44311, secondResult.UniqueId);
var thirdResult = resultsArray[2];
Assert.AreEqual("bar", thirdResult.Fooness.Bar);
Assert.AreEqual("baz", thirdResult.Fooness.Baz);
Assert.AreEqual("HOSTS", thirdResult.RelationshipType);
Assert.AreEqual("baz", thirdResult.Name);
Assert.AreEqual(42586, thirdResult.UniqueId);
}
}
public void ShouldSupportAnonymousReturnTypesEndToEnd()
{
const string queryText = "START root=node({p0})\r\nMATCH root-->other\r\nRETURN other AS Foo";
var parameters = new Dictionary <string, object>
{
{ "p0", 123 }
};
var cypherQuery = new CypherQuery(queryText, parameters, CypherResultMode.Projection);
var cypherApiQuery = new CypherApiQuery(cypherQuery);
using (var testHarness = new RestTestHarness
{
{
MockRequest.PostObjectAsJson("/cypher", cypherApiQuery),
MockResponse.Json(HttpStatusCode.OK, @"{
'columns' : [ 'Foo' ],
'data' : [ [ {
'outgoing_relationships' : 'http://localhost:8000/db/data/node/748/relationships/out',
'data' : {
'Name' : 'Antimony',
'UniqueId' : 38
},
'all_typed_relationships' : 'http://localhost:8000/db/data/node/748/relationships/all/{-list|&|types}',
'traverse' : 'http://localhost:8000/db/data/node/748/traverse/{returnType}',
'self' : 'http://localhost:8000/db/data/node/748',
'property' : 'http://localhost:8000/db/data/node/748/properties/{key}',
'outgoing_typed_relationships' : 'http://localhost:8000/db/data/node/748/relationships/out/{-list|&|types}',
'properties' : 'http://localhost:8000/db/data/node/748/properties',
'incoming_relationships' : 'http://localhost:8000/db/data/node/748/relationships/in',
'extensions' : {
},
'create_relationship' : 'http://localhost:8000/db/data/node/748/relationships',
'paged_traverse' : 'http://localhost:8000/db/data/node/748/paged/traverse/{returnType}{?pageSize,leaseTime}',
'all_relationships' : 'http://localhost:8000/db/data/node/748/relationships/all',
'incoming_typed_relationships' : 'http://localhost:8000/db/data/node/748/relationships/in/{-list|&|types}'
} ], [ {
'outgoing_relationships' : 'http://localhost:8000/db/data/node/610/relationships/out',
'data' : {
'Name' : 'Bauxite',
'UniqueId' : 24
},
'all_typed_relationships' : 'http://localhost:8000/db/data/node/610/relationships/all/{-list|&|types}',
'traverse' : 'http://localhost:8000/db/data/node/610/traverse/{returnType}',
'self' : 'http://localhost:8000/db/data/node/610',
'property' : 'http://localhost:8000/db/data/node/610/properties/{key}',
'outgoing_typed_relationships' : 'http://localhost:8000/db/data/node/610/relationships/out/{-list|&|types}',
'properties' : 'http://localhost:8000/db/data/node/610/properties',
'incoming_relationships' : 'http://localhost:8000/db/data/node/610/relationships/in',
'extensions' : {
},
'create_relationship' : 'http://localhost:8000/db/data/node/610/relationships',
'paged_traverse' : 'http://localhost:8000/db/data/node/610/paged/traverse/{returnType}{?pageSize,leaseTime}',
'all_relationships' : 'http://localhost:8000/db/data/node/610/relationships/all',
'incoming_typed_relationships' : 'http://localhost:8000/db/data/node/610/relationships/in/{-list|&|types}'
} ], [ {
'outgoing_relationships' : 'http://localhost:8000/db/data/node/749/relationships/out',
'data' : {
'Name' : 'Bismuth',
'UniqueId' : 37
},
'all_typed_relationships' : 'http://localhost:8000/db/data/node/749/relationships/all/{-list|&|types}',
'traverse' : 'http://localhost:8000/db/data/node/749/traverse/{returnType}',
'self' : 'http://localhost:8000/db/data/node/749',
'property' : 'http://localhost:8000/db/data/node/749/properties/{key}',
'outgoing_typed_relationships' : 'http://localhost:8000/db/data/node/749/relationships/out/{-list|&|types}',
'properties' : 'http://localhost:8000/db/data/node/749/properties',
'incoming_relationships' : 'http://localhost:8000/db/data/node/749/relationships/in',
'extensions' : {
},
'create_relationship' : 'http://localhost:8000/db/data/node/749/relationships',
'paged_traverse' : 'http://localhost:8000/db/data/node/749/paged/traverse/{returnType}{?pageSize,leaseTime}',
'all_relationships' : 'http://localhost:8000/db/data/node/749/relationships/all',
'incoming_typed_relationships' : 'http://localhost:8000/db/data/node/749/relationships/in/{-list|&|types}'
} ] ]
}")
}
})
{
var graphClient = testHarness.CreateAndConnectGraphClient();
var results = graphClient
.Cypher
.Start("root", graphClient.RootNode)
.Match("root-->other")
.Return(other => new
{
Foo = other.As <Commodity>()
})
.Results
.ToList();
Assert.AreEqual(3, results.Count());
var result = results[0];
Assert.AreEqual("Antimony", result.Foo.Name);
Assert.AreEqual(38, result.Foo.UniqueId);
result = results[1];
Assert.AreEqual("Bauxite", result.Foo.Name);
Assert.AreEqual(24, result.Foo.UniqueId);
result = results[2];
Assert.AreEqual("Bismuth", result.Foo.Name);
Assert.AreEqual(37, result.Foo.UniqueId);
}
}
public void ShouldDeserializeTableStructureWithRelationships()
{
// Arrange
const string queryText = @"
START x = node({p0})
MATCH x-[r]->n
RETURN x AS Fooness, type(r) AS RelationshipType, n.Name? AS Name, n.UniqueId? AS UniqueId
LIMIT 3";
var cypherQuery = new CypherQuery(
queryText,
new Dictionary <string, object>
{
{ "p0", 123 }
},
CypherResultMode.Projection,
CypherResultFormat.Rest);
var cypherApiQuery = new CypherApiQuery(cypherQuery);
using (var testHarness = new RestTestHarness
{
{
MockRequest.PostObjectAsJson("/cypher", cypherApiQuery),
MockResponse.Json(HttpStatusCode.OK, @"{
'data' : [ [ {
'start' : 'http://foo/db/data/node/0',
'data' : {
'Bar' : 'bar',
'Baz' : 'baz'
},
'property' : 'http://foo/db/data/relationship/0/properties/{key}',
'self' : 'http://foo/db/data/relationship/0',
'properties' : 'http://foo/db/data/relationship/0/properties',
'type' : 'HAS_REFERENCE_DATA',
'extensions' : {
},
'end' : 'http://foo/db/data/node/1'
}, 'HOSTS', 'foo', 44321 ], [ {
'start' : 'http://foo/db/data/node/1',
'data' : {
'Bar' : 'bar',
'Baz' : 'baz'
},
'property' : 'http://foo/db/data/relationship/1/properties/{key}',
'self' : 'http://foo/db/data/relationship/1',
'properties' : 'http://foo/db/data/relationship/1/properties',
'type' : 'HAS_REFERENCE_DATA',
'extensions' : {
},
'end' : 'http://foo/db/data/node/1'
}, 'LIKES', 'bar', 44311 ], [ {
'start' : 'http://foo/db/data/node/2',
'data' : {
'Bar' : 'bar',
'Baz' : 'baz'
},
'property' : 'http://foo/db/data/relationship/2/properties/{key}',
'self' : 'http://foo/db/data/relationship/2',
'properties' : 'http://foo/db/data/relationship/2/properties',
'type' : 'HAS_REFERENCE_DATA',
'extensions' : {
},
'end' : 'http://foo/db/data/node/1'
}, 'HOSTS', 'baz', 42586 ] ],
'columns' : [ 'Fooness', 'RelationshipType', 'Name', 'UniqueId' ]
}")
}
})
{
var graphClient = testHarness.CreateAndConnectGraphClient();
//Act
//Act
var results = graphClient.ExecuteGetCypherResults <ResultWithRelationshipDto>(cypherQuery);
//Assert
Assert.IsInstanceOf <IEnumerable <ResultWithRelationshipDto> >(results);
var resultsArray = results.ToArray();
Assert.AreEqual(3, resultsArray.Count());
var firstResult = resultsArray[0];
Assert.AreEqual(0, firstResult.Fooness.Reference.Id);
Assert.AreEqual("bar", firstResult.Fooness.Data.Bar);
Assert.AreEqual("baz", firstResult.Fooness.Data.Baz);
Assert.AreEqual("HOSTS", firstResult.RelationshipType);
Assert.AreEqual("foo", firstResult.Name);
Assert.AreEqual(44321, firstResult.UniqueId);
var secondResult = resultsArray[1];
Assert.AreEqual(1, secondResult.Fooness.Reference.Id);
Assert.AreEqual("bar", secondResult.Fooness.Data.Bar);
Assert.AreEqual("baz", secondResult.Fooness.Data.Baz);
Assert.AreEqual("LIKES", secondResult.RelationshipType);
Assert.AreEqual("bar", secondResult.Name);
Assert.AreEqual(44311, secondResult.UniqueId);
var thirdResult = resultsArray[2];
Assert.AreEqual(2, thirdResult.Fooness.Reference.Id);
Assert.AreEqual("bar", thirdResult.Fooness.Data.Bar);
Assert.AreEqual("baz", thirdResult.Fooness.Data.Baz);
Assert.AreEqual("HOSTS", thirdResult.RelationshipType);
Assert.AreEqual("baz", thirdResult.Name);
Assert.AreEqual(42586, thirdResult.UniqueId);
}
}
/// <summary>
/// Allows this instance to receive and process incoming requests.
/// </summary>
/// <exception cref="PlayerStateException"/>
public void Start()
{
lock (statelock)
{
if (CurrentState != State.Off)
{
throw new PlayerStateException(CurrentState, "Player has already started.");
}
httpListener.Start();
Task.Run(() =>
{
while (httpListener.IsListening)
{
var context = httpListener.GetContext();
var playerRequest = context.Request;
var playerResponse = context.Response;
lock (statelock)
{
try
{
switch (CurrentState)
{
case State.Playing:
{
var mock = (JObject)record.Read();
var mockRequest = MockRequest.FromJson((JObject)mock["request"]);
var mockPlayerRequest = MockRequest.FromHttpRequest(remoteAddress, playerRequest);
MockResponse mockResponse;
var differences = mockRequest.GetDifferences(mockPlayerRequest).ToArray();
if (differences.Length == 0)
{
mockResponse = MockResponse.FromJson((JObject)mock["response"]);
}
else
{
var differencesMessage = string.Join(", ",
differences.Select(d =>
$"{d.Property} (Recorded='{d.ThisValue}', Requested='{d.OtherValue}')"));
var message =
$"Player could not play the request at {playerRequest.Url.PathAndQuery}. " +
$"The request doesn't match the current recorded one: {differencesMessage}";
mockResponse = MockResponse.FromPlayerError(PlayerErrorCode.RequestNotFound, "Player request mismatch", message);
}
BuildResponse(playerResponse, mockResponse);
}
break;
case State.Recording:
{
var mockRequest = MockRequest.FromHttpRequest(remoteAddress, playerRequest);
var request = BuildRequest(mockRequest);
MockResponse mockResponse;
try
{
using (var response = (HttpWebResponse)request.GetResponse())
{
mockResponse = MockResponse.FromHttpResponse(response);
}
}
catch (WebException ex)
{
if (ex.Response == null)
{
throw ex;
}
mockResponse = MockResponse.FromHttpResponse((HttpWebResponse)ex.Response);
}
var mock = JObject.FromObject(new
{
request = mockRequest.ToJson(),
response = mockResponse.ToJson()
});
record.Write(mock);
BuildResponse(playerResponse, mockResponse);
}
break;
default:
throw new PlayerStateException(CurrentState, "Player is not in operation.");
}
}
catch (Exception ex)
{
PlayerErrorCode errorCode;
string process;
switch (CurrentState)
{
case State.Playing:
errorCode = PlayerErrorCode.PlayException;
process = "play";
break;
case State.Recording:
errorCode = PlayerErrorCode.RecordException;
process = "record";
break;
default:
errorCode = PlayerErrorCode.Exception;
process = "process";
break;
}
var mockResponse = MockResponse.FromPlayerError(errorCode, "Player exception", $"Player could not {process} the request at {playerRequest.Url.PathAndQuery} because of exception: {ex}");
BuildResponse(playerResponse, mockResponse);
}
finally
{
playerResponse.Close();
}
}
}
});
CurrentState = State.Idle;
}
}
public void ToStringsFormatsStatusAndResponsePhrase()
{
var response = new MockResponse(200, "Phrase");
Assert.AreEqual("Status: 200, ReasonPhrase: Phrase", response.ToString());
}
public void AsyncRequestsInTransactionShouldBeExecutedInOrder()
{
const string queryTextBase = @"MATCH (n) RETURN {0} as Total";
const string resultColumnBase = @"{{'columns':['Total'], 'data':[{{'row':[{0}]}}]}}";
const int asyncRequests = 15;
var queries = new CypherQuery[asyncRequests];
var apiQueries = new CypherStatementList[asyncRequests];
var responses = new MockResponse[asyncRequests];
var testHarness = new RestHarnessWithCounter();
for (int i = 0; i < asyncRequests; i++)
{
queries[i] = new CypherQuery(string.Format(queryTextBase, i), new Dictionary <string, object>(),
CypherResultMode.Projection);
apiQueries[i] = new CypherStatementList {
new CypherTransactionStatement(queries[i], false)
};
responses[i] = MockResponse.Json(200,
@"{'results':[" + string.Format(resultColumnBase, i) + @"], 'errors':[] }");
if (i > 0)
{
testHarness.Add(MockRequest.PostObjectAsJson("/transaction/1", apiQueries[i]), responses[i]);
}
}
testHarness.Add(
MockRequest.PostObjectAsJson("/transaction", apiQueries[0]),
MockResponse.Json(201, TransactionRestResponseHelper.GenerateInitTransactionResponse(1, string.Format(resultColumnBase, 0)),
"http://foo/db/data/transaction/1")
);
testHarness.Add(
MockRequest.PostJson("/transaction/1/commit", @"{'statements': []}"),
MockResponse.Json(200, @"{'results':[], 'errors':[] }")
);
try
{
var client = testHarness.CreateAndConnectTransactionalGraphClient();
var rawClient = (IRawGraphClient)client;
var tasks = new Task[asyncRequests];
using (var tran = client.BeginTransaction())
{
for (int i = 0; i < asyncRequests; i++)
{
int tmpResult = i;
tasks[i] = rawClient.ExecuteGetCypherResultsAsync <DummyTotal>(queries[i]).ContinueWith(task =>
{
Assert.AreEqual(tmpResult, task.Result.Single().Total);
});
}
Task.WaitAll(tasks);
tran.Commit();
}
}
finally
{
testHarness.Dispose();
}
// check that we have a total order
Assert.AreEqual(asyncRequests, testHarness.Queue.Count);
int lastElement = -1;
for (int i = 0; i < asyncRequests; i++)
{
int headItem;
Assert.IsTrue(testHarness.Queue.TryDequeue(out headItem));
Assert.Greater(headItem, lastElement);
lastElement = headItem;
}
}
public async Task UpdateItemAsync(MockResponse item)
{
await Task.FromResult(_context.MockResponses.Update(item));
await _context.SaveChangesAsync();
}
public void NestedTransactionWithTransactionScopeQueryFirst()
{
const string queryTextMsTransaction = @"MATCH (n) RETURN count(n)";
const string queryTextTx = @"MATCH (t) RETURN count(t)";
const string resultColumn = @"{'columns':['count(n)'], 'data':[{'row':[1]}]}";
var cypherQueryMsTx = new CypherQuery(queryTextMsTransaction, new Dictionary <string, object>(), CypherResultMode.Projection);
var cypherQueryMsTxStatement = new CypherStatementList {
new CypherTransactionStatement(cypherQueryMsTx, false)
};
var cypherQueryTx = new CypherQuery(queryTextTx, new Dictionary <string, object>(), CypherResultMode.Projection);
var cypherQueryTxStatement = new CypherStatementList {
new CypherTransactionStatement(cypherQueryTx, false)
};
var deleteRequest = MockRequest.Delete("/transaction/1");
var commitRequest = MockRequest.PostJson("/transaction/1/commit", @"{'statements': []}");
var commitRequestTx = MockRequest.PostJson("/transaction/2/commit", @"{'statements': []}");
using (var testHarness = new RestTestHarness
{
{
MockRequest.PostObjectAsJson("/transaction", cypherQueryMsTxStatement),
MockResponse.Json(201, TransactionRestResponseHelper.GenerateInitTransactionResponse(1, resultColumn), "http://foo/db/data/transaction/1")
},
{
MockRequest.PostObjectAsJson("/transaction", cypherQueryTxStatement),
MockResponse.Json(201, TransactionRestResponseHelper.GenerateInitTransactionResponse(2, resultColumn), "http://foo/db/data/transaction/2")
},
{
commitRequest, MockResponse.Json(200, @"{'results':[], 'errors':[] }")
},
{
commitRequestTx, MockResponse.Json(200, @"{'results':[], 'errors':[] }")
},
{
deleteRequest, MockResponse.Json(200, @"{'results':[], 'errors':[] }")
}
}.ShouldNotBeCalled(commitRequest))
{
var client = testHarness.CreateAndConnectTransactionalGraphClient();
using (var msTransaction = new TransactionScope())
{
Assert.IsTrue(client.InTransaction);
long totalMsTx = client.Cypher
.Match("(n)")
.Return(n => n.Count())
.Results
.SingleOrDefault();
Assert.AreEqual(1, totalMsTx);
using (var tx = client.BeginTransaction())
{
long total = client.Cypher
.Match("(t)")
.Return(t => t.Count())
.Results
.SingleOrDefault();
Assert.AreEqual(1, total);
// should not be called
tx.Commit();
}
}
}
}
public S3ClientMock(MockResponse type) : base(type)
{
}
public void RequestIdReturnsNullForNoHeader()
{
var mockResponse = new MockResponse(200);
Assert.Null(mockResponse.Headers.RequestId);
}
public async Task WhatIfAtSubscriptionScope_SendingRequestWithStrings_SerializesPayload()
{
// Arrange.
string[] divideCases =
{
@"{
'$schema': 'http://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#',
'contentVersion': '1.0.0.0',
'parameters': {
'roleDefName': {
'value': 'myCustomRole'
}
}
}".Replace("'", "\""),
@"{
'roleDefName': {
'value': 'myCustomRole'
}
}".Replace("'", "\"")
};
foreach (string item in divideCases)
{
string templateContent = @"{
'$schema': 'http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#',
'contentVersion': '1.0.0.0',
'parameters': {
'roleDefName': {
'type': 'string'
}
},
'resources': [
],
'outputs': {}
}".Replace("'", "\"");
var mockResponse = new MockResponse((int)HttpStatusCode.OK);
JsonElement jsonParameter = JsonSerializer.Deserialize <JsonElement>(item);
if (!jsonParameter.TryGetProperty("parameters", out JsonElement parameter))
{
parameter = jsonParameter;
}
var deploymentWhatIf = new DeploymentWhatIf(
new DeploymentWhatIfProperties(DeploymentMode.Incremental)
{
Template = templateContent,
ParametersJson = parameter
})
{
Location = "westus"
};
var mockTransport = new MockTransport(mockResponse);
var client = GetResourceManagementClient(mockTransport);
// Act.
await client.Deployments.StartWhatIfAtSubscriptionScopeAsync("test-subscription-deploy", deploymentWhatIf);
// Assert.
var request = mockTransport.Requests[0];
Stream stream = new MemoryStream();
await request.Content.WriteToAsync(stream, default);
stream.Position = 0;
var resquestContent = new StreamReader(stream).ReadToEnd();
var resultJson = JsonDocument.Parse(resquestContent).RootElement;
Assert.AreEqual("Incremental", resultJson.GetProperty("properties").GetProperty("mode").GetString());
Assert.AreEqual("1.0.0.0", resultJson.GetProperty("properties").GetProperty("template").GetProperty("contentVersion").GetString());
Assert.AreEqual("myCustomRole", resultJson.GetProperty("properties").GetProperty("parameters").GetProperty("roleDefName").GetProperty("value").GetString());
}
}
public async Task RecognizeEntitiesResultsSorted_NoErrors()
{
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(@"
{
""documents"": [
{
""id"": ""1"",
""entities"": [
{
""name"": ""Microsoft"",
""matches"": [
{
""text"": ""Microsoft"",
""offset"": 0,
""length"": 9,
""confidenceScore"": 0.26
}
],
""language"": ""en"",
""id"": ""Microsoft"",
""url"": ""https://en.wikipedia.org/wiki/Microsoft"",
""dataSource"": ""Wikipedia""
}
],
""warnings"": []
},
{
""id"": ""2"",
""entities"": [
{
""name"": ""Microsoft"",
""matches"": [
{
""text"": ""Microsoft"",
""offset"": 0,
""length"": 9,
""confidenceScore"": 0.26
}
],
""language"": ""en"",
""id"": ""Microsoft"",
""url"": ""https://en.wikipedia.org/wiki/Microsoft"",
""dataSource"": ""Wikipedia""
}
],
""warnings"": []
}
],
""errors"": [],
""modelVersion"": ""2020-02-01""
}"));
var mockResponse = new MockResponse(200);
mockResponse.ContentStream = stream;
var mockTransport = new MockTransport(new[] { mockResponse });
var client = CreateTestClient(mockTransport);
var documents = new List <TextDocumentInput>()
{
new TextDocumentInput("1", "Microsoft was founded"),
new TextDocumentInput("2", "Microsoft was founded"),
};
var response = await client.RecognizeEntitiesBatchAsync(documents, new TextAnalyticsRequestOptions());
var resultCollection = response.Value;
Assert.AreEqual("1", resultCollection[0].Id);
Assert.AreEqual("2", resultCollection[1].Id);
}
public async Task SendingRequestProducesEvents()
{
var response = new MockResponse(500);
response.SetContent(new byte[] { 6, 7, 8, 9, 0 });
response.AddHeader(new HttpHeader("Custom-Response-Header", "Improved value"));
var mockTransport = new MockTransport(response);
var pipeline = new HttpPipeline(mockTransport, new [] { LoggingPolicy.Shared });
string requestId;
using (HttpPipelineRequest request = pipeline.CreateRequest())
{
request.SetRequestLine(HttpPipelineMethod.Get, new Uri("https://contoso.a.io"));
request.AddHeader("Date", "3/26/2019");
request.AddHeader("Custom-Header", "Value");
request.Content = HttpPipelineRequestContent.Create(new byte[] { 1, 2, 3, 4, 5 });
requestId = request.RequestId;
await pipeline.SendRequestAsync(request, CancellationToken.None);
}
var e = _listener.SingleEventById(RequestEvent);
Assert.AreEqual(EventLevel.Informational, e.Level);
Assert.AreEqual("Request", e.EventName);
Assert.AreEqual(requestId, e.GetProperty <string>("requestId"));
Assert.AreEqual("https://contoso.a.io/", e.GetProperty <string>("uri"));
Assert.AreEqual("GET", e.GetProperty <string>("method"));
StringAssert.Contains($"Date:3/26/2019{Environment.NewLine}", e.GetProperty <string>("headers"));
StringAssert.Contains($"Custom-Header:Value{Environment.NewLine}", e.GetProperty <string>("headers"));
e = _listener.SingleEventById(RequestContentEvent);
Assert.AreEqual(EventLevel.Verbose, e.Level);
Assert.AreEqual("RequestContent", e.EventName);
Assert.AreEqual(requestId, e.GetProperty <string>("requestId"));
CollectionAssert.AreEqual(new byte[] { 1, 2, 3, 4, 5 }, e.GetProperty <byte[]>("content"));
e = _listener.SingleEventById(ResponseEvent);
Assert.AreEqual(EventLevel.Informational, e.Level);
Assert.AreEqual("Response", e.EventName);
Assert.AreEqual(requestId, e.GetProperty <string>("requestId"));
Assert.AreEqual(e.GetProperty <int>("status"), 500);
StringAssert.Contains($"Custom-Response-Header:Improved value{Environment.NewLine}", e.GetProperty <string>("headers"));
e = _listener.SingleEventById(ResponseContentEvent);
Assert.AreEqual(EventLevel.Verbose, e.Level);
Assert.AreEqual("ResponseContent", e.EventName);
Assert.AreEqual(requestId, e.GetProperty <string>("requestId"));
CollectionAssert.AreEqual(new byte[] { 6, 7, 8, 9, 0 }, e.GetProperty <byte[]>("content"));
e = _listener.SingleEventById(ErrorResponseEvent);
Assert.AreEqual(EventLevel.Error, e.Level);
Assert.AreEqual("ErrorResponse", e.EventName);
Assert.AreEqual(requestId, e.GetProperty <string>("requestId"));
Assert.AreEqual(e.GetProperty <int>("status"), 500);
StringAssert.Contains($"Custom-Response-Header:Improved value{Environment.NewLine}", e.GetProperty <string>("headers"));
e = _listener.SingleEventById(ErrorResponseContentEvent);
Assert.AreEqual(EventLevel.Informational, e.Level);
Assert.AreEqual("ErrorResponseContent", e.EventName);
Assert.AreEqual(requestId, e.GetProperty <string>("requestId"));
CollectionAssert.AreEqual(new byte[] { 6, 7, 8, 9, 0 }, e.GetProperty <byte[]>("content"));
}
public async Task AnalyzeSentimentAssessmentInOtherSentence()
{
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(@"
{
""documents"": [
{
""id"": ""1"",
""sentiment"": ""positive"",
""confidenceScores"": {
""positive"": 0.5,
""neutral"": 0.0,
""negative"": 0.5
},
""sentences"": [
{
""sentiment"": ""positive"",
""confidenceScores"": {
""positive"": 1.0,
""neutral"": 0.0,
""negative"": 0.0
},
""offset"": 0,
""length"": 30,
""text"": ""The park was clean."",
""targets"": [
{
""sentiment"": ""positive"",
""confidenceScores"": {
""positive"": 1.0,
""negative"": 0.0
},
""offset"": 4,
""length"": 4,
""text"": ""park"",
""relations"": [
{
""relationType"": ""assessment"",
""ref"": ""#/documents/0/sentences/0/assessments/0""
}
]
}
],
""assessments"": [
{
""sentiment"": ""positive"",
""confidenceScores"": {
""positive"": 1.0,
""negative"": 0.0
},
""offset"": 13,
""length"": 5,
""text"": ""clean"",
""isNegated"": false
}
]
},
{
""sentiment"": ""positive"",
""confidenceScores"": {
""positive"": 0.0,
""neutral"": 0.0,
""negative"": 1.0
},
""offset"": 31,
""length"": 23,
""text"": ""It was clean."",
""targets"": [
{
""sentiment"": ""positive"",
""confidenceScores"": {
""positive"": 0.0,
""negative"": 1.0
},
""offset"": 35,
""length"": 4,
""text"": ""park"",
""relations"": [
{
""relationType"": ""assessment"",
""ref"": ""#/documents/0/sentences/0/assessments/0""
}
]
}
],
""assessments"": []
}
],
""warnings"": []
}
],
""errors"": [],
""modelVersion"": ""2020-04-01""
}"));
var mockResponse = new MockResponse(200);
mockResponse.ContentStream = stream;
var mockTransport = new MockTransport(new[] { mockResponse });
var client = CreateTestClient(mockTransport);
DocumentSentiment response = await client.AnalyzeSentimentAsync("The park was clean. It was clean.");
SentenceOpinion opinionS1 = response.Sentences.ElementAt(0).Opinions.FirstOrDefault();
Assert.AreEqual("park", opinionS1.Target.Text);
Assert.AreEqual(TextSentiment.Positive, opinionS1.Target.Sentiment);
Assert.AreEqual("clean", opinionS1.Assessments.FirstOrDefault().Text);
SentenceOpinion opinionS2 = response.Sentences.ElementAt(1).Opinions.FirstOrDefault();
Assert.AreEqual("park", opinionS2.Target.Text);
Assert.AreEqual(TextSentiment.Positive, opinionS2.Target.Sentiment);
Assert.AreEqual("clean", opinionS2.Assessments.FirstOrDefault().Text);
}
public async Task ValidateClaimsChallengeTokenRequest()
{
string currentClaimChallenge = null;
int tokensRequested = 0;
var credential = new TokenCredentialStub((r, c) =>
{
tokensRequested++;
Assert.AreEqual(currentClaimChallenge, r.Claims);
return(new AccessToken(Guid.NewGuid().ToString(), DateTimeOffset.UtcNow + TimeSpan.FromDays(1)));
}, IsAsync);
var policy = new ARMChallengeAuthenticationPolicy(credential, "scope");
var insufficientClaimsChallengeResponse = new MockResponse(401);
insufficientClaimsChallengeResponse.AddHeader(new HttpHeader("WWW-Authenticate", CaeInsufficientClaimsChallenge));
var sessionRevokedChallengeResponse = new MockResponse(401);
sessionRevokedChallengeResponse.AddHeader(new HttpHeader("WWW-Authenticate", CaeSessionsRevokedClaimsChallenge));
var armChallengeResponse = new MockResponse(401);
armChallengeResponse.AddHeader(new HttpHeader("WWW-Authenticate", ArmChallenge));
var keyvaultChallengeResponse = new MockResponse(401);
keyvaultChallengeResponse.AddHeader(new HttpHeader("WWW-Authenticate", KeyVaultChallenge));
MockTransport transport = CreateMockTransport(new MockResponse(200),
insufficientClaimsChallengeResponse,
new MockResponse(200),
sessionRevokedChallengeResponse,
new MockResponse(200),
armChallengeResponse,
keyvaultChallengeResponse);
var response = await SendGetRequest(transport, policy, uri : new Uri("https://example.com"), cancellationToken : default);
Assert.AreEqual(tokensRequested, 1);
Assert.AreEqual(response.Status, 200);
currentClaimChallenge = Base64Url.DecodeString(CaeInsufficientClaimsChallengeValue);
response = await SendGetRequest(transport, policy, uri : new Uri("https://example.com"), cancellationToken : default);
Assert.AreEqual(tokensRequested, 2);
Assert.AreEqual(response.Status, 200);
currentClaimChallenge = Base64Url.DecodeString(CaeSessionsRevokedClaimsChallengeValue);
response = await SendGetRequest(transport, policy, uri : new Uri("https://example.com"), cancellationToken : default);
Assert.AreEqual(tokensRequested, 3);
Assert.AreEqual(response.Status, 200);
currentClaimChallenge = null;
response = await SendGetRequest(transport, policy, uri : new Uri("https://example.com"), cancellationToken : default);
Assert.AreEqual(tokensRequested, 3);
Assert.AreEqual(response.Status, 401);
response = await SendGetRequest(transport, policy, uri : new Uri("https://example.com"), cancellationToken : default);
Assert.AreEqual(tokensRequested, 3);
Assert.AreEqual(response.Status, 401);
}
public async Task WhatIf_ReceivingResponse_DeserializesResult()
{
// Arrange.
var deploymentWhatIf = new DeploymentWhatIf(new DeploymentWhatIfProperties(DeploymentMode.Incremental));
var content = @"{
'status': 'Succeeded',
'properties': {
'changes': [
{
'resourceId': '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myExistingIdentity',
'changeType': 'Modify',
'before': {
'apiVersion': '2018-11-30',
'id': '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myExistingIdentity',
'type': 'Microsoft.ManagedIdentity/userAssignedIdentities',
'name': 'myExistingIdentity',
'location': 'westus2'
},
'after': {
'apiVersion': '2018-11-30',
'id': '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myExistingIdentity',
'type': 'Microsoft.ManagedIdentity/userAssignedIdentities',
'name': 'myExistingIdentity',
'location': 'westus2',
'tags': {
'myNewTag': 'my tag value'
}
},
'delta': [
{
'path': 'tags.myNewTag',
'propertyChangeType': 'Create',
'after': 'my tag value'
}
]
}
]
}
}".Replace("'", "\"");
var mockResponse = new MockResponse((int)HttpStatusCode.OK);
mockResponse.SetContent(content);
var mockTransport = new MockTransport(mockResponse);
var client = GetResourceManagementClient(mockTransport);
// Act.
var raw = await client.Deployments.StartWhatIfAsync("test-rg", "test-deploy", deploymentWhatIf);
var result = (await WaitForCompletionAsync(raw)).Value;
// Assert.
Assert.AreEqual("Succeeded", result.Status);
Assert.NotNull(result.Changes);
Assert.AreEqual(1, result.Changes.Count);
WhatIfChange change = result.Changes[0];
Assert.AreEqual(ChangeType.Modify, change.ChangeType);
Assert.NotNull(change.Before);
Assert.AreEqual("myExistingIdentity", JsonDocument.Parse(JsonSerializer.Serialize(change.Before)).RootElement.GetProperty("name").GetString());
Assert.NotNull(change.After);
Assert.AreEqual("myExistingIdentity", JsonDocument.Parse(JsonSerializer.Serialize(change.After)).RootElement.GetProperty("name").GetString());
Assert.NotNull(change.Delta);
Assert.AreEqual(1, change.Delta.Count);
Assert.AreEqual("tags.myNewTag", change.Delta[0].Path);
Assert.AreEqual(PropertyChangeType.Create, change.Delta[0].PropertyChangeType);
Assert.AreEqual("my tag value", change.Delta[0].After);
}
public ClientMock(MockResponse type)
{
responseType = type;
}
public void AsyncRequestsInTransactionShouldBeExecutedInOrder()
{
const string queryTextBase = @"MATCH (n) RETURN {0} as Total";
const string resultColumnBase = @"{{'columns':['Total'], 'data':[{{'row':[{0}]}}]}}";
const int asyncRequests = 15;
var queries = new CypherQuery[asyncRequests];
var apiQueries = new CypherStatementList[asyncRequests];
var responses = new MockResponse[asyncRequests];
var testHarness = new RestHarnessWithCounter();
for (int i = 0; i < asyncRequests; i++)
{
queries[i] = new CypherQuery(string.Format(queryTextBase, i), new Dictionary<string, object>(),
CypherResultMode.Projection);
apiQueries[i] = new CypherStatementList {new CypherTransactionStatement(queries[i], false)};
responses[i] = MockResponse.Json(200,
@"{'results':[" + string.Format(resultColumnBase, i) + @"], 'errors':[] }");
if (i > 0)
{
testHarness.Add(MockRequest.PostObjectAsJson("/transaction/1", apiQueries[i]), responses[i]);
}
}
testHarness.Add(
MockRequest.PostObjectAsJson("/transaction", apiQueries[0]),
MockResponse.Json(201, GenerateInitTransactionResponse(1, string.Format(resultColumnBase, 0)),
"http://foo/db/data/transaction/1")
);
testHarness.Add(
MockRequest.PostJson("/transaction/1/commit", @"{'statements': []}"),
MockResponse.Json(200, @"{'results':[], 'errors':[] }")
);
try
{
var client = testHarness.CreateAndConnectTransactionalGraphClient();
var rawClient = (IRawGraphClient)client;
var tasks = new Task[asyncRequests];
using (var tran = client.BeginTransaction())
{
for (int i = 0; i < asyncRequests; i++)
{
int tmpResult = i;
tasks[i] = rawClient.ExecuteGetCypherResultsAsync<DummyTotal>(queries[i]).ContinueWith(task =>
{
Assert.AreEqual(tmpResult, task.Result.Single().Total);
});
}
Task.WaitAll(tasks);
tran.Commit();
}
}
finally
{
testHarness.Dispose();
}
// check that we have a total order
Assert.AreEqual(asyncRequests, testHarness.Queue.Count);
int lastElement = -1;
for (int i = 0; i < asyncRequests; i++)
{
int headItem;
Assert.IsTrue(testHarness.Queue.TryDequeue(out headItem));
Assert.Greater(headItem, lastElement);
lastElement = headItem;
}
}
public void GoodRequestWithPool()
{
var res = new MockResponse()
{
ContentType = "application/json",
Code = System.Net.HttpStatusCode.OK,
Body = @"{ ""token"": 123, ""submissions"": 456, ""message"": ""test""}"
};
using (var c = new TestClient(res))
{
var actualResult = c.Client.Export.Request("test", SlideRoom.API.Resources.RequestFormat.Csv, "saved search", null, SlideRoom.API.Resources.Pool.Archived);
// test the request too..
var queryString = c.Request.QueryString;
GeneralClient.TestRequiredParameters(queryString);
queryString.ContainsAndEquals("export", "test");
queryString.ContainsAndEquals("format", "csv");
queryString.ContainsAndEquals("ss", "saved search");
queryString.NotContains("since");
queryString.ContainsAndEquals("pool", "archived");
}
}
