| static private GenerateInitTransactionResponse ( int id ) : string | ||
| id | int | |
| return | string | |
public void KeepAliveWithoutRequestsShouldNotGenerateMessage()
{
var initTransactionRequest = MockRequest.PostJson("/transaction", @"{'statements': []}");
var keepAliveRequest = MockRequest.PostJson("/transaction/1", @"{'statements': []}");
using (var testHarness = new RestTestHarness
{
{
initTransactionRequest,
MockResponse.Json(201, TransactionRestResponseHelper.GenerateInitTransactionResponse(1), "http://foo/db/data/transaction/1")
},
{
keepAliveRequest, MockResponse.Json(200, @"{'results':[], 'errors':[] }")
}
}.ShouldNotBeCalled(initTransactionRequest, keepAliveRequest))
{
var client = testHarness.CreateAndConnectTransactionalGraphClient();
using (var transaction = client.BeginTransaction())
{
// no requests
transaction.KeepAlive();
}
}
}
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 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 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;
}
}