//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testJobDefinitionRetrieval()
public virtual void testJobDefinitionRetrieval()
{
string queryJobDefinitionId = "aJobDefId";
Response response = given().queryParam("jobDefinitionId", queryJobDefinitionId).then().expect().statusCode(Status.OK.StatusCode).when().get(JOB_DEFINITION_QUERY_URL);
// assert query invocation
InOrder inOrder = Mockito.inOrder(mockedQuery);
inOrder.verify(mockedQuery).jobDefinitionId(queryJobDefinitionId);
inOrder.verify(mockedQuery).list();
string content = response.asString();
IList <IDictionary <string, string> > jobDefinitions = from(content).getList("");
assertThat(jobDefinitions).hasSize(1);
assertThat(jobDefinitions[0]).NotNull;
string returnedId = from(content).getString("[0].id");
string returnedProcessDefinitionId = from(content).getString("[0].processDefinitionId");
string returnedProcessDefinitionKey = from(content).getString("[0].processDefinitionKey");
string returnedActivityId = from(content).getString("[0].activityId");
string returnedJobType = from(content).getString("[0].jobType");
string returnedJobConfiguration = from(content).getString("[0].jobConfiguration");
bool returnedSuspensionState = from(content).getBoolean("[0].suspended");
long? returnedJobPriority = from(content).getObject("[0].overridingJobPriority", typeof(Long));
assertThat(returnedId).isEqualTo(MockProvider.EXAMPLE_JOB_DEFINITION_ID);
assertThat(returnedProcessDefinitionId).isEqualTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID);
assertThat(returnedProcessDefinitionKey).isEqualTo(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY);
assertThat(returnedActivityId).isEqualTo(MockProvider.EXAMPLE_ACTIVITY_ID);
assertThat(returnedJobType).isEqualTo(MockProvider.EXAMPLE_JOB_TYPE);
assertThat(returnedJobConfiguration).isEqualTo(MockProvider.EXAMPLE_JOB_CONFIG);
assertThat(returnedSuspensionState).isEqualTo(MockProvider.EXAMPLE_JOB_DEFINITION_IS_SUSPENDED);
assertThat(returnedJobPriority).isEqualTo(MockProvider.EXAMPLE_JOB_DEFINITION_PRIORITY);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDeploymentRetrieval()
public virtual void testDeploymentRetrieval()
{
InOrder inOrder = Mockito.inOrder(mockedQuery);
string queryKey = "Name";
Response response = given().queryParam("nameLike", queryKey).then().expect().statusCode(Status.OK.StatusCode).when().get(DEPLOYMENT_QUERY_URL);
// assert query invocation
inOrder.verify(mockedQuery).deploymentNameLike(queryKey);
inOrder.verify(mockedQuery).list();
string content = response.asString();
IList <string> deployments = from(content).getList("");
Assert.assertEquals("There should be one deployment returned.", 1, deployments.Count);
Assert.assertNotNull("There should be one deployment returned", deployments[0]);
string returnedId = from(content).getString("[0].id");
string returnedName = from(content).getString("[0].name");
string returnedSource = from(content).getString("[0].source");
string returnedDeploymentTime = from(content).getString("[0].deploymentTime");
Assert.assertEquals(MockProvider.EXAMPLE_DEPLOYMENT_ID, returnedId);
Assert.assertEquals(MockProvider.EXAMPLE_DEPLOYMENT_NAME, returnedName);
Assert.assertEquals(MockProvider.EXAMPLE_DEPLOYMENT_SOURCE, returnedSource);
Assert.assertEquals(MockProvider.EXAMPLE_DEPLOYMENT_TIME, returnedDeploymentTime);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPrioritiseCorrectly()
public virtual void ShouldPrioritiseCorrectly()
{
BatchingMessageHandler batchHandler = new BatchingMessageHandler(_downstreamHandler, _inQueueConfig, _batchConfig, _jobSchedulerFactory, NullLogProvider.Instance);
NewEntry.Request newEntry = new NewEntry.Request(null, Content(""));
AppendEntries.Request append = new AppendEntries.Request(_leader, 1, -1, -1, Entries(0, 0, 0), 0);
AppendEntries.Request emptyAppend = new AppendEntries.Request(_leader, 1, -1, -1, RaftLogEntry.empty, 0);
Heartbeat heartbeat = new Heartbeat(null, 0, 0, 0);
batchHandler.Handle(Wrap(newEntry));
batchHandler.Handle(Wrap(append));
batchHandler.Handle(Wrap(heartbeat));
batchHandler.Handle(Wrap(emptyAppend));
verifyZeroInteractions(_downstreamHandler);
// when
batchHandler.Run();
batchHandler.Run();
batchHandler.Run();
batchHandler.Run();
// then
InOrder inOrder = Mockito.inOrder(_downstreamHandler);
inOrder.verify(_downstreamHandler).handle(Wrap(heartbeat));
inOrder.verify(_downstreamHandler).handle(Wrap(emptyAppend));
inOrder.verify(_downstreamHandler).handle(Wrap(append));
inOrder.verify(_downstreamHandler).handle(Wrap(new NewEntry.BatchRequest(singletonList(Content("")))));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testIncludeInputsAndOutputs()
public virtual void testIncludeInputsAndOutputs()
{
mockedQuery = setUpMockHistoricDecisionInstanceQuery(Collections.singletonList(MockProvider.createMockHistoricDecisionInstanceWithInputsAndOutputs()));
string decisionDefinitionId = MockProvider.EXAMPLE_DECISION_DEFINITION_ID;
Response response = given().queryParam("decisionDefinitionId", decisionDefinitionId).queryParam("includeInputs", true).queryParam("includeOutputs", true).then().expect().statusCode(Status.OK.StatusCode).when().get(HISTORIC_DECISION_INSTANCE_RESOURCE_URL);
InOrder inOrder = inOrder(mockedQuery);
inOrder.verify(mockedQuery).decisionDefinitionId(decisionDefinitionId);
inOrder.verify(mockedQuery).includeInputs();
inOrder.verify(mockedQuery).includeOutputs();
inOrder.verify(mockedQuery).list();
string content = response.asString();
IList <string> instances = from(content).getList("");
assertEquals(1, instances.Count);
Assert.assertNotNull(instances[0]);
IList <IDictionary <string, object> > returnedInputs = from(content).getList("[0].inputs");
IList <IDictionary <string, object> > returnedOutputs = from(content).getList("[0].outputs");
assertThat(returnedInputs, @is(notNullValue()));
assertThat(returnedOutputs, @is(notNullValue()));
verifyHistoricDecisionInputInstances(returnedInputs);
verifyHistoricDecisionOutputInstances(returnedOutputs);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldCloseGlobalAllocationsOnClose()
internal virtual void ShouldCloseGlobalAllocationsOnClose()
{
// given
ByteBufferFactory.Allocator allocator = mock(typeof(ByteBufferFactory.Allocator));
when(allocator.Allocate(anyInt())).thenAnswer(invocationOnMock => ByteBuffer.allocate(invocationOnMock.getArgument(0)));
ByteBufferFactory factory = new ByteBufferFactory(() => allocator, 100);
// when doing some allocations that are counted as global
factory.AcquireThreadLocalBuffer();
factory.ReleaseThreadLocalBuffer();
factory.AcquireThreadLocalBuffer();
factory.ReleaseThreadLocalBuffer();
factory.GlobalAllocator().allocate(123);
factory.GlobalAllocator().allocate(456);
// and closing it
factory.Close();
// then
InOrder inOrder = inOrder(allocator);
inOrder.verify(allocator, times(1)).allocate(100);
inOrder.verify(allocator, times(1)).allocate(123);
inOrder.verify(allocator, times(1)).allocate(456);
inOrder.verify(allocator, times(1)).close();
inOrder.verifyNoMoreInteractions();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testUnfinishedHistoricCaseActivityQuery()
public virtual void testUnfinishedHistoricCaseActivityQuery()
{
IList <HistoricCaseActivityInstance> mockedHistoricCaseActivityInstances = MockProvider.createMockRunningHistoricCaseActivityInstances();
HistoricCaseActivityInstanceQuery mockedHistoricCaseActivityInstanceQuery = mock(typeof(HistoricCaseActivityInstanceQuery));
when(mockedHistoricCaseActivityInstanceQuery.list()).thenReturn(mockedHistoricCaseActivityInstances);
when(processEngine.HistoryService.createHistoricCaseActivityInstanceQuery()).thenReturn(mockedHistoricCaseActivityInstanceQuery);
Response response = given().queryParam("unfinished", true).then().expect().statusCode(Status.OK.StatusCode).when().get(HISTORIC_CASE_ACTIVITY_INSTANCE_RESOURCE_URL);
InOrder inOrder = inOrder(mockedHistoricCaseActivityInstanceQuery);
inOrder.verify(mockedHistoricCaseActivityInstanceQuery).notEnded();
inOrder.verify(mockedHistoricCaseActivityInstanceQuery).list();
string content = response.asString();
IList <string> instances = from(content).getList("");
Assert.assertEquals(1, instances.Count);
Assert.assertNotNull(instances[0]);
string returnedCaseDefinitionId = from(content).getString("[0].caseDefinitionId");
string returnedActivityEndTime = from(content).getString("[0].endTime");
Assert.assertEquals(MockProvider.EXAMPLE_CASE_DEFINITION_ID, returnedCaseDefinitionId);
Assert.assertNull(returnedActivityEndTime);
}
/*
* Tests that we unfreeze active transactions after commit and after apply of batch if batch length (in time)
* is larger than safeZone time.
*/
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldUnfreezeKernelTransactionsAfterApplyIfBatchIsLarge() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldUnfreezeKernelTransactionsAfterApplyIfBatchIsLarge()
{
// GIVEN
int maxBatchSize = 10;
long idReuseSafeZoneTime = 100;
Dependencies dependencies = mock(typeof(Dependencies));
TransactionObligationFulfiller fulfiller = mock(typeof(TransactionObligationFulfiller));
when(dependencies.ObligationFulfiller()).thenReturn(fulfiller);
when(dependencies.LogService()).thenReturn(NullLogService.Instance);
when(dependencies.VersionContextSupplier()).thenReturn(EmptyVersionContextSupplier.EMPTY);
KernelTransactions kernelTransactions = mock(typeof(KernelTransactions));
when(dependencies.KernelTransactions()).thenReturn(kernelTransactions);
TransactionCommitProcess commitProcess = mock(typeof(TransactionCommitProcess));
when(dependencies.CommitProcess()).thenReturn(commitProcess);
TransactionCommittingResponseUnpacker unpacker = Life.add(new TransactionCommittingResponseUnpacker(dependencies, maxBatchSize, idReuseSafeZoneTime));
// WHEN
int txCount = maxBatchSize;
int doesNotMatter = 1;
unpacker.UnpackResponse(new DummyTransactionResponse(doesNotMatter, txCount, idReuseSafeZoneTime + 1), NO_OP_TX_HANDLER);
// THEN
InOrder inOrder = inOrder(commitProcess, kernelTransactions);
inOrder.verify(commitProcess, times(1)).commit(any(), any(), any());
inOrder.verify(kernelTransactions, times(1)).unblockNewTransactions();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRollbackTransactionAndTellRegistryToForgetItsHandle()
public virtual void ShouldRollbackTransactionAndTellRegistryToForgetItsHandle()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
TransitionalTxManagementKernelTransaction transactionContext = kernel.NewTransaction(@explicit, AUTH_DISABLED, -1);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(kernel, mock(typeof(QueryExecutionEngine)), queryService, registry, uriScheme, true, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
handle.Rollback(output);
// then
InOrder transactionOrder = inOrder(transactionContext, registry);
transactionOrder.verify(transactionContext).rollback();
transactionOrder.verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).errors(argThat(HasNoErrors()));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCaseInstanceRetrieval()
public virtual void testCaseInstanceRetrieval()
{
string queryCaseInstanceId = "aCaseInstanceId";
Response response = given().queryParam("caseInstanceId", queryCaseInstanceId).then().expect().statusCode(Status.OK.StatusCode).when().get(CASE_INSTANCE_QUERY_URL);
// assert query invocation
InOrder inOrder = Mockito.inOrder(mockedQuery);
inOrder.verify(mockedQuery).caseInstanceId(queryCaseInstanceId);
inOrder.verify(mockedQuery).list();
string content = response.asString();
IList <IDictionary <string, string> > caseInstances = from(content).getList("");
assertThat(caseInstances).hasSize(1);
assertThat(caseInstances[0]).NotNull;
string returnedId = from(content).getString("[0].id");
string returnedCaseDefinitionId = from(content).getString("[0].caseDefinitionId");
string returnedBusinessKeyKey = from(content).getString("[0].businessKey");
string returnedTenantId = from(content).getString("[0].tenantId");
bool returnedActiveState = from(content).getBoolean("[0].active");
bool returnedCompletedState = from(content).getBoolean("[0].completed");
bool returnedTerminatedState = from(content).getBoolean("[0].terminated");
assertThat(returnedId).isEqualTo(MockProvider.EXAMPLE_CASE_INSTANCE_ID);
assertThat(returnedCaseDefinitionId).isEqualTo(MockProvider.EXAMPLE_CASE_INSTANCE_CASE_DEFINITION_ID);
assertThat(returnedBusinessKeyKey).isEqualTo(MockProvider.EXAMPLE_CASE_INSTANCE_BUSINESS_KEY);
assertThat(returnedTenantId).isEqualTo(MockProvider.EXAMPLE_TENANT_ID);
assertThat(returnedActiveState).isEqualTo(MockProvider.EXAMPLE_CASE_INSTANCE_IS_ACTIVE);
assertThat(returnedCompletedState).isEqualTo(MockProvider.EXAMPLE_CASE_INSTANCE_IS_COMPLETED);
assertThat(returnedTerminatedState).isEqualTo(MockProvider.EXAMPLE_CASE_INSTANCE_IS_TERMINATED);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSimpleAuthorizationQuery()
public virtual void testSimpleAuthorizationQuery()
{
IList <Authorization> mockAuthorizations = MockProvider.createMockGlobalAuthorizations();
AuthorizationQuery mockQuery = setUpMockQuery(mockAuthorizations);
Response response = given().queryParam("type", org.camunda.bpm.engine.authorization.Authorization_Fields.AUTH_TYPE_GLOBAL).then().expect().statusCode(Status.OK.StatusCode).when().get(SERVICE_PATH);
InOrder inOrder = inOrder(mockQuery);
inOrder.verify(mockQuery).authorizationType(org.camunda.bpm.engine.authorization.Authorization_Fields.AUTH_TYPE_GLOBAL);
inOrder.verify(mockQuery).list();
string content = response.asString();
IList <string> instances = from(content).getList("");
Assert.assertEquals("There should be one authorization returned.", 1, instances.Count);
Assert.assertNotNull("The returned authorization should not be null.", instances[0]);
Authorization mockAuthorization = mockAuthorizations[0];
Assert.assertEquals(mockAuthorization.Id, from(content).getString("[0].id"));
Assert.assertEquals(mockAuthorization.AuthorizationType, from(content).getInt("[0].type"));
Assert.assertEquals(Permissions.READ.Name, from(content).getString("[0].permissions[0]"));
Assert.assertEquals(Permissions.UPDATE.Name, from(content).getString("[0].permissions[1]"));
Assert.assertEquals(mockAuthorization.UserId, from(content).getString("[0].userId"));
Assert.assertEquals(mockAuthorization.GroupId, from(content).getString("[0].groupId"));
Assert.assertEquals(mockAuthorization.ResourceType, from(content).getInt("[0].resourceType"));
Assert.assertEquals(mockAuthorization.ResourceId, from(content).getString("[0].resourceId"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testExecutionRetrieval()
public virtual void testExecutionRetrieval()
{
string queryKey = "key";
Response response = given().queryParam("processDefinitionKey", queryKey).then().expect().statusCode(Status.OK.StatusCode).when().get(EXECUTION_QUERY_URL);
// assert query invocation
InOrder inOrder = Mockito.inOrder(mockedQuery);
inOrder.verify(mockedQuery).processDefinitionKey(queryKey);
inOrder.verify(mockedQuery).list();
string content = response.asString();
IList <string> executions = from(content).getList("");
Assert.assertEquals("There should be one execution returned.", 1, executions.Count);
Assert.assertNotNull("There should be one execution returned", executions[0]);
string returnedExecutionId = from(content).getString("[0].id");
bool? returnedIsEnded = from(content).getBoolean("[0].ended");
string returnedProcessInstanceId = from(content).getString("[0].processInstanceId");
string returnedTenantId = from(content).getString("[0].tenantId");
Assert.assertEquals(MockProvider.EXAMPLE_EXECUTION_ID, returnedExecutionId);
Assert.assertEquals(MockProvider.EXAMPLE_EXECUTION_IS_ENDED, returnedIsEnded);
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID, returnedProcessInstanceId);
Assert.assertEquals(MockProvider.EXAMPLE_TENANT_ID, returnedTenantId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLockRelationshipsWhileReadingThem() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldLockRelationshipsWhileReadingThem()
{
// given
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") org.neo4j.helpers.collection.Visitor<org.neo4j.kernel.impl.api.index.EntityUpdates,Exception> visitor = mock(org.neo4j.helpers.collection.Visitor.class);
Visitor <EntityUpdates, Exception> visitor = mock(typeof(Visitor));
StoreScan <Exception> storeScan = _storeView.visitRelationships(new int[] { _relTypeId }, id => id == _relPropertyKeyId, visitor);
// when
storeScan.Run();
// then
assertThat("allocated locks: " + _lockMocks.Keys, _lockMocks.Count, greaterThanOrEqualTo(2));
Lock lock0 = _lockMocks[0L];
Lock lock1 = _lockMocks[1L];
assertNotNull("Lock[relationship=0] never acquired", lock0);
assertNotNull("Lock[relationship=1] never acquired", lock1);
InOrder order = inOrder(_locks, lock0, lock1);
order.verify(_locks).acquireRelationshipLock(0, Org.Neo4j.Kernel.impl.locking.LockService_LockType.ReadLock);
order.verify(lock0).release();
order.verify(_locks).acquireRelationshipLock(1, Org.Neo4j.Kernel.impl.locking.LockService_LockType.ReadLock);
order.verify(lock1).release();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCloseLockGroupAfterAppliers() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCloseLockGroupAfterAppliers()
{
// given
long nodeId = 5;
LockService lockService = mock(typeof(LockService));
Lock nodeLock = mock(typeof(Lock));
when(lockService.AcquireNodeLock(nodeId, Org.Neo4j.Kernel.impl.locking.LockService_LockType.WriteLock)).thenReturn(nodeLock);
System.Action <bool> applierCloseCall = mock(typeof(System.Action)); // <-- simply so that we can use InOrder mockito construct
CapturingBatchTransactionApplierFacade applier = new CapturingBatchTransactionApplierFacade(this, applierCloseCall);
RecordStorageEngine engine = RecordStorageEngineBuilder().lockService(lockService).transactionApplierTransformer(applier.wrapAroundActualApplier).build();
CommandsToApply commandsToApply = mock(typeof(CommandsToApply));
when(commandsToApply.Accept(any())).thenAnswer(invocationOnMock =>
{
// Visit one node command
Visitor <StorageCommand, IOException> visitor = invocationOnMock.getArgument(0);
NodeRecord after = new NodeRecord(nodeId);
after.InUse = true;
visitor.visit(new Command.NodeCommand(new NodeRecord(nodeId), after));
return(null);
});
// when
engine.Apply(commandsToApply, TransactionApplicationMode.INTERNAL);
// then
InOrder inOrder = inOrder(lockService, applierCloseCall, nodeLock);
inOrder.verify(lockService).acquireNodeLock(nodeId, Org.Neo4j.Kernel.impl.locking.LockService_LockType.WriteLock);
inOrder.verify(applierCloseCall).accept(true);
inOrder.verify(nodeLock, times(1)).release();
inOrder.verifyNoMoreInteractions();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testFinishedHistoricActivityQueryAsPost()
public virtual void testFinishedHistoricActivityQueryAsPost()
{
IDictionary <string, bool> body = new Dictionary <string, bool>();
body["finished"] = true;
Response response = given().contentType(POST_JSON_CONTENT_TYPE).body(body).then().expect().statusCode(Status.OK.StatusCode).when().post(HISTORIC_ACTIVITY_INSTANCE_RESOURCE_URL);
InOrder inOrder = inOrder(mockedQuery);
inOrder.verify(mockedQuery).finished();
inOrder.verify(mockedQuery).list();
string content = response.asString();
IList <string> instances = from(content).getList("");
Assert.assertEquals("There should be one activity instance returned.", 1, instances.Count);
Assert.assertNotNull("The returned activity instance should not be null.", instances[0]);
string returnedProcessInstanceId = from(content).getString("[0].processInstanceId");
string returnedProcessDefinitionId = from(content).getString("[0].processDefinitionId");
string returnedActivityEndTime = from(content).getString("[0].endTime");
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID, returnedProcessInstanceId);
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID, returnedProcessDefinitionId);
Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_END_TIME, returnedActivityEndTime);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleExecutionEngineThrowingUndeclaredCheckedExceptions() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldHandleExecutionEngineThrowingUndeclaredCheckedExceptions()
{
// given
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
when(executionEngine.ExecuteQuery(eq("match (n) return n"), eq(NoParams), any(typeof(TransactionalContext)))).thenAnswer(invocationOnMock =>
{
throw new Exception("BOO");
});
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(MockKernel(), executionEngine, queryService, registry, uriScheme, false, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
Statement statement = new Statement("match (n) return n", map(), false, (ResultDataContent[])null);
handle.Commit(statements(statement), output, mock(typeof(HttpServletRequest)));
// then
verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).statementResult(Null, eq(false), Null);
outputOrder.verify(output).errors(argThat(HasErrors(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.ExecutionFailed)));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReportProgressInTheSpecifiedIntervals()
public virtual void ShouldReportProgressInTheSpecifiedIntervals()
{
// given
Indicator indicator = IndicatorMock();
ProgressListener progressListener = Factory.mock(indicator, 10).singlePart(TestName.MethodName, 16);
// when
progressListener.Started();
for (int i = 0; i < 16; i++)
{
progressListener.Add(1);
}
progressListener.Done();
// then
InOrder order = inOrder(indicator);
order.verify(indicator).startProcess(16);
for (int i = 0; i < 10; i++)
{
order.verify(indicator).progress(i, i + 1);
}
order.verify(indicator).completeProcess();
order.verifyNoMoreInteractions();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRollbackTransactionIfExecutionErrorOccurs() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldRollbackTransactionIfExecutionErrorOccurs()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
TransitionalTxManagementKernelTransaction transactionContext = kernel.NewTransaction(@explicit, AUTH_DISABLED, -1);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(executionEngine.ExecuteQuery("query", NoParams, transactionalContext)).thenThrow(new System.NullReferenceException());
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
TransactionHandle handle = GetTransactionHandle(kernel, executionEngine, registry);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
handle.Execute(statements(new Statement("query", map(), false, (ResultDataContent[])null)), output, mock(typeof(HttpServletRequest)));
// then
verify(transactionContext).rollback();
verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).transactionCommitUri(uriScheme.txCommitUri(1337));
outputOrder.verify(output).errors(argThat(HasErrors(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.ExecutionFailed)));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLogMessageIfCypherSyntaxErrorOccurs() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldLogMessageIfCypherSyntaxErrorOccurs()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(executionEngine.ExecuteQuery("matsch (n) return n", NoParams, transactionalContext)).thenThrow(new QueryExecutionKernelException(new SyntaxException("did you mean MATCH?")));
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(kernel, executionEngine, queryService, registry, uriScheme, false, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
Statement statement = new Statement("matsch (n) return n", map(), false, (ResultDataContent[])null);
handle.Commit(statements(statement), output, mock(typeof(HttpServletRequest)));
// then
verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).errors(argThat(HasErrors(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.SyntaxError)));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldApplyCommittedCommand() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldApplyCommittedCommand()
{
// given
RaftLogCommitIndexMonitor listener = mock(typeof(RaftLogCommitIndexMonitor));
_monitors.addMonitorListener(listener);
InOrder inOrder = inOrder(_coreState, _commandDispatcher);
_raftLog.append(new RaftLogEntry(0, Operation(_nullTx)));
_raftLog.append(new RaftLogEntry(0, Operation(_nullTx)));
_raftLog.append(new RaftLogEntry(0, Operation(_nullTx)));
// when
_applicationProcess.notifyCommitted(2);
_applicationProcess.start();
// then
inOrder.verify(_coreState).commandDispatcher();
inOrder.verify(_commandDispatcher).dispatch(eq(_nullTx), eq(0L), AnyCallback());
inOrder.verify(_commandDispatcher).dispatch(eq(_nullTx), eq(1L), AnyCallback());
inOrder.verify(_commandDispatcher).dispatch(eq(_nullTx), eq(2L), AnyCallback());
inOrder.verify(_commandDispatcher).close();
verify(listener).commitIndex(2);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCommitSinglePeriodicCommitStatement() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCommitSinglePeriodicCommitStatement()
{
// given
string queryText = "USING PERIODIC COMMIT CREATE()";
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
Result executionResult = mock(typeof(Result));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(executionEngine.IsPeriodicCommit(queryText)).thenReturn(true);
when(executionEngine.ExecuteQuery(eq(queryText), eq(NoParams), eq(transactionalContext))).thenReturn(executionResult);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
TransactionHandle handle = GetTransactionHandle(kernel, executionEngine, registry);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
Statement statement = new Statement(queryText, map(), false, (ResultDataContent[])null);
// when
handle.Commit(statements(statement), output, mock(typeof(HttpServletRequest)));
// then
verify(executionEngine).executeQuery(queryText, NoParams, transactionalContext);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).statementResult(executionResult, false, ( ResultDataContent[] )null);
outputOrder.verify(output).notifications(anyCollectionOf(typeof(Notification)));
outputOrder.verify(output).errors(argThat(HasNoErrors()));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testUnfinishedHistoricActivityQueryAsPost()
public virtual void testUnfinishedHistoricActivityQueryAsPost()
{
IList <HistoricActivityInstance> mockedHistoricActivityInstances = MockProvider.createMockRunningHistoricActivityInstances();
HistoricActivityInstanceQuery mockedhistoricActivityInstanceQuery = mock(typeof(HistoricActivityInstanceQuery));
when(mockedhistoricActivityInstanceQuery.list()).thenReturn(mockedHistoricActivityInstances);
when(processEngine.HistoryService.createHistoricActivityInstanceQuery()).thenReturn(mockedhistoricActivityInstanceQuery);
IDictionary <string, bool> body = new Dictionary <string, bool>();
body["unfinished"] = true;
Response response = given().contentType(POST_JSON_CONTENT_TYPE).body(body).then().expect().statusCode(Status.OK.StatusCode).when().post(HISTORIC_ACTIVITY_INSTANCE_RESOURCE_URL);
InOrder inOrder = inOrder(mockedhistoricActivityInstanceQuery);
inOrder.verify(mockedhistoricActivityInstanceQuery).unfinished();
inOrder.verify(mockedhistoricActivityInstanceQuery).list();
string content = response.asString();
IList <string> instances = from(content).getList("");
Assert.assertEquals("There should be one activity instance returned.", 1, instances.Count);
Assert.assertNotNull("The returned activity instance should not be null.", instances[0]);
string returnedProcessDefinitionId = from(content).getString("[0].processDefinitionId");
string returnedActivityEndTime = from(content).getString("[0].endTime");
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID, returnedProcessDefinitionId);
Assert.assertNull(returnedActivityEndTime);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testVariableInstanceRetrievalAsPost()
public virtual void testVariableInstanceRetrievalAsPost()
{
string queryVariableName = "aVariableInstanceName";
IDictionary <string, string> queryParameter = new Dictionary <string, string>();
queryParameter["variableName"] = queryVariableName;
Response response = given().contentType(POST_JSON_CONTENT_TYPE).body(queryParameter).then().expect().statusCode(Status.OK.StatusCode).and().body("size()", @is(1)).body("[0].id", equalTo(mockInstanceBuilder.Id)).body("[0].name", equalTo(mockInstanceBuilder.Name)).body("[0].type", equalTo(VariableTypeHelper.toExpectedValueTypeName(mockInstanceBuilder.TypedValue.Type))).body("[0].value", equalTo(mockInstanceBuilder.TypedValue.Value)).body("[0].processInstanceId", equalTo(mockInstanceBuilder.ProcessInstanceId)).body("[0].executionId", equalTo(mockInstanceBuilder.ExecutionId)).body("[0].caseInstanceId", equalTo(mockInstanceBuilder.CaseInstanceId)).body("[0].caseExecutionId", equalTo(mockInstanceBuilder.CaseExecutionId)).body("[0].taskId", equalTo(mockInstanceBuilder.TaskId)).body("[0].activityInstanceId", equalTo(mockInstanceBuilder.ActivityInstanceId)).body("[0].tenantId", equalTo(mockInstanceBuilder.TenantId)).body("[0].errorMessage", equalTo(mockInstanceBuilder.ErrorMessage)).body("[0].serializedValue", nullValue()).when().post(VARIABLE_INSTANCE_QUERY_URL);
// assert query invocation
InOrder inOrder = Mockito.inOrder(mockedQuery);
inOrder.verify(mockedQuery).variableName(queryVariableName);
inOrder.verify(mockedQuery).list();
string content = response.asString();
IList <string> variables = from(content).getList("");
Assert.assertEquals("There should be one process definition returned.", 1, variables.Count);
Assert.assertNotNull("There should be one process definition returned", variables[0]);
verify(mockedQuery).disableBinaryFetching();
// requirement to not break existing API; should be:
// verify(mockedQuery).disableCustomObjectDeserialization();
verify(mockedQuery, never()).disableCustomObjectDeserialization();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testAdditionalIncidentsForTypeOption()
public virtual void testAdditionalIncidentsForTypeOption()
{
given().queryParam("incidentsForType", "failedJob").then().expect().statusCode(Status.OK.StatusCode).when().get(PROCESS_DEFINITION_STATISTICS_URL);
InOrder inOrder = Mockito.inOrder(processDefinitionStatisticsQueryMock);
inOrder.verify(processDefinitionStatisticsQueryMock).includeIncidentsForType("failedJob");
inOrder.verify(processDefinitionStatisticsQueryMock).list();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sortByName()
public virtual void sortByName()
{
given().queryParam("sortBy", "name").queryParam("sortOrder", "desc").then().expect().statusCode(Status.OK.StatusCode).when().get(QUERY_URL);
InOrder inOrder = Mockito.inOrder(mockQuery);
inOrder.verify(mockQuery).orderByTenantName();
inOrder.verify(mockQuery).desc();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testActivityStatisticsWithFailedJobs()
public virtual void testActivityStatisticsWithFailedJobs()
{
given().pathParam("id", "aDefinitionId").queryParam("failedJobs", "true").then().expect().statusCode(Status.OK.StatusCode).when().get(ACTIVITY_STATISTICS_URL);
InOrder inOrder = Mockito.inOrder(activityQueryMock);
inOrder.verify(activityQueryMock).includeFailedJobs();
inOrder.verify(activityQueryMock).list();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testActivityStatisticsIncidentsForTypeTypeOption()
public virtual void testActivityStatisticsIncidentsForTypeTypeOption()
{
given().pathParam("id", "aDefinitionId").queryParam("incidentsForType", "failedJob").then().expect().statusCode(Status.OK.StatusCode).when().get(ACTIVITY_STATISTICS_URL);
InOrder inOrder = Mockito.inOrder(activityQueryMock);
inOrder.verify(activityQueryMock).includeIncidentsForType("failedJob");
inOrder.verify(activityQueryMock).list();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSimpleHistoricActivityQuery()
public virtual void testSimpleHistoricActivityQuery()
{
string processInstanceId = MockProvider.EXAMPLE_PROCESS_INSTANCE_ID;
Response response = given().queryParam("processInstanceId", processInstanceId).then().expect().statusCode(Status.OK.StatusCode).when().get(HISTORIC_ACTIVITY_INSTANCE_RESOURCE_URL);
InOrder inOrder = inOrder(mockedQuery);
inOrder.verify(mockedQuery).processInstanceId(processInstanceId);
inOrder.verify(mockedQuery).list();
string content = response.asString();
IList <string> instances = from(content).getList("");
Assert.assertEquals("There should be one activity instance returned.", 1, instances.Count);
Assert.assertNotNull("The returned activity instance should not be null.", instances[0]);
string returnedId = from(content).getString("[0].id");
string returnedParentActivityInstanceId = from(content).getString("[0].parentActivityInstanceId");
string returnedActivityId = from(content).getString("[0].activityId");
string returnedActivityName = from(content).getString("[0].activityName");
string returnedActivityType = from(content).getString("[0].activityType");
string returnedProcessDefinitionKey = from(content).getString("[0].processDefinitionKey");
string returnedProcessDefinitionId = from(content).getString("[0].processDefinitionId");
string returnedProcessInstanceId = from(content).getString("[0].processInstanceId");
string returnedExecutionId = from(content).getString("[0].executionId");
string returnedTaskId = from(content).getString("[0].taskId");
string returnedCalledProcessInstanceId = from(content).getString("[0].calledProcessInstanceId");
string returnedCalledCaseInstanceId = from(content).getString("[0].calledCaseInstanceId");
string returnedAssignee = from(content).getString("[0].assignee");
DateTime returnedStartTime = DateTimeUtil.parseDate(from(content).getString("[0].startTime"));
DateTime returnedEndTime = DateTimeUtil.parseDate(from(content).getString("[0].endTime"));
long returnedDurationInMillis = from(content).getLong("[0].durationInMillis");
bool canceled = from(content).getBoolean("[0].canceled");
bool completeScope = from(content).getBoolean("[0].completeScope");
string returnedTenantId = from(content).getString("[0].tenantId");
Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_ID, returnedId);
Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_PARENT_ACTIVITY_INSTANCE_ID, returnedParentActivityInstanceId);
Assert.assertEquals(MockProvider.EXAMPLE_ACTIVITY_ID, returnedActivityId);
Assert.assertEquals(MockProvider.EXAMPLE_ACTIVITY_NAME, returnedActivityName);
Assert.assertEquals(MockProvider.EXAMPLE_ACTIVITY_TYPE, returnedActivityType);
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_KEY, returnedProcessDefinitionKey);
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_DEFINITION_ID, returnedProcessDefinitionId);
Assert.assertEquals(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID, returnedProcessInstanceId);
Assert.assertEquals(MockProvider.EXAMPLE_EXECUTION_ID, returnedExecutionId);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_ID, returnedTaskId);
Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_CALLED_PROCESS_INSTANCE_ID, returnedCalledProcessInstanceId);
Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_CALLED_CASE_INSTANCE_ID, returnedCalledCaseInstanceId);
Assert.assertEquals(MockProvider.EXAMPLE_TASK_ASSIGNEE_NAME, returnedAssignee);
Assert.assertEquals(DateTimeUtil.parseDate(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_START_TIME), returnedStartTime);
Assert.assertEquals(DateTimeUtil.parseDate(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_END_TIME), returnedEndTime);
Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_DURATION, returnedDurationInMillis);
Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_IS_CANCELED, canceled);
Assert.assertEquals(MockProvider.EXAMPLE_HISTORIC_ACTIVITY_INSTANCE_IS_COMPLETE_SCOPE, completeScope);
Assert.assertEquals(MockProvider.EXAMPLE_TENANT_ID, returnedTenantId);
}
