public virtual void testSelectHistoricSerializedValuesUpdate()
{
ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
JsonSerializable bean = new JsonSerializable("a String", 42, false);
runtimeService.setVariable(instance.Id, "simpleBean", objectValue(bean).serializationDataFormat(JSON_FORMAT_NAME));
if (ProcessEngineConfiguration.HISTORY_FULL.Equals(processEngineConfiguration.History))
{
HistoricVariableUpdate historicUpdate = (HistoricVariableUpdate)historyService.createHistoricDetailQuery().variableUpdates().singleResult();
assertNotNull(historicUpdate.Value);
assertNull(historicUpdate.ErrorMessage);
assertEquals(ValueType.OBJECT.Name, historicUpdate.TypeName);
assertEquals(ValueType.OBJECT.Name, historicUpdate.VariableTypeName);
JsonSerializable historyValue = (JsonSerializable)historicUpdate.Value;
assertEquals(bean.StringProperty, historyValue.StringProperty);
assertEquals(bean.IntProperty, historyValue.IntProperty);
assertEquals(bean.BooleanProperty, historyValue.BooleanProperty);
ObjectValue typedValue = (ObjectValue)historicUpdate.TypedValue;
assertEquals(JSON_FORMAT_NAME, typedValue.SerializationDataFormat);
JSONAssert.assertEquals(bean.toExpectedJsonString(), new string(typedValue.ValueSerialized), true);
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
assertEquals(typeof(JsonSerializable).FullName, typedValue.ObjectTypeName);
}
}
public virtual void testSerializationAsJava()
{
ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
JavaSerializable bean = new JavaSerializable("a String", 42, true);
// request object to be serialized as Java
runtimeService.setVariable(instance.Id, "simpleBean", objectValue(bean).serializationDataFormat(Variables.SerializationDataFormats.JAVA).create());
// validate untyped value
object value = runtimeService.getVariable(instance.Id, "simpleBean");
assertEquals(bean, value);
// validate typed value
ObjectValue typedValue = runtimeService.getVariableTyped(instance.Id, "simpleBean");
assertEquals(ValueType.OBJECT, typedValue.Type);
assertTrue(typedValue.Deserialized);
assertEquals(bean, typedValue.Value);
assertEquals(bean, typedValue.getValue(typeof(JavaSerializable)));
assertEquals(typeof(JavaSerializable), typedValue.ObjectType);
assertEquals(Variables.SerializationDataFormats.JAVA.Name, typedValue.SerializationDataFormat);
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
assertEquals(typeof(JavaSerializable).FullName, typedValue.ObjectTypeName);
}
protected internal virtual T build <T>(T mockVariable) where T : org.camunda.bpm.engine.runtime.VariableInstance
{
when(mockVariable.Id).thenReturn(id_Renamed);
when(mockVariable.Name).thenReturn(name_Renamed);
when(mockVariable.TypeName).thenReturn(typedValue_Renamed.Type.Name);
if (typedValue_Renamed.GetType().IsAssignableFrom(typeof(ObjectValue)))
{
ObjectValue objectValue = (ObjectValue)typedValue_Renamed;
if (objectValue.Deserialized)
{
when(mockVariable.Value).thenReturn(typedValue_Renamed.Value);
}
else
{
when(mockVariable.Value).thenReturn(null);
}
}
else
{
when(mockVariable.Value).thenReturn(typedValue_Renamed.Value);
}
when(mockVariable.TypedValue).thenReturn(typedValue_Renamed);
when(mockVariable.ProcessInstanceId).thenReturn(processInstanceId_Renamed);
when(mockVariable.ExecutionId).thenReturn(executionId_Renamed);
when(mockVariable.CaseInstanceId).thenReturn(caseInstanceId_Renamed);
when(mockVariable.CaseExecutionId).thenReturn(caseExecutionId_Renamed);
when(mockVariable.TaskId).thenReturn(taskId_Renamed);
when(mockVariable.ActivityInstanceId).thenReturn(activityInstanceId_Renamed);
when(mockVariable.TenantId).thenReturn(tenantId_Renamed);
when(mockVariable.ErrorMessage).thenReturn(errorMessage_Renamed);
return(mockVariable);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testFallbackSerializerDoesNotOverrideRegularSerializer()
public virtual void testFallbackSerializerDoesNotOverrideRegularSerializer()
{
// given
// that the process engine is configured with a serializer for a certain format
// and a fallback serializer factory for the same format
ProcessEngineConfigurationImpl engineConfiguration = (new StandaloneInMemProcessEngineConfiguration()).setJdbcUrl("jdbc:h2:mem:camunda-forceclose").setProcessEngineName("engine-forceclose");
engineConfiguration.CustomPreVariableSerializers = Arrays.asList <TypedValueSerializer>(new ExampleConstantSerializer());
engineConfiguration.FallbackSerializerFactory = new ExampleSerializerFactory();
processEngine = engineConfiguration.buildProcessEngine();
deployOneTaskProcess(processEngine);
// when setting a variable that no regular serializer can handle
ObjectValue objectValue = Variables.objectValue("foo").serializationDataFormat(ExampleSerializer.FORMAT).create();
ProcessInstance pi = processEngine.RuntimeService.startProcessInstanceByKey("oneTaskProcess", Variables.createVariables().putValueTyped("var", objectValue));
ObjectValue fetchedValue = processEngine.RuntimeService.getVariableTyped(pi.Id, "var", true);
// then the fallback serializer is used
Assert.assertNotNull(fetchedValue);
Assert.assertEquals(ExampleSerializer.FORMAT, fetchedValue.SerializationDataFormat);
Assert.assertEquals(ExampleConstantSerializer.DESERIALIZED_VALUE, fetchedValue.Value);
}
public virtual void testSerializationOfUnknownFormat()
{
// given
ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
// when
ObjectValue objectValue = Variables.serializedObjectValue("foo").serializationDataFormat("application/foo").objectTypeName("org.camunda.Foo").create();
runtimeService.setVariable(instance.Id, "var", objectValue);
// then
try
{
runtimeService.getVariable(instance.Id, "var");
fail();
}
catch (ProcessEngineException e)
{
assertTextPresent("Fallback serializer cannot handle deserialized objects", e.Message);
}
ObjectValue returnedValue = runtimeService.getVariableTyped(instance.Id, "var", false);
assertFalse(returnedValue.Deserialized);
assertEquals("application/foo", returnedValue.SerializationDataFormat);
assertEquals("foo", returnedValue.ValueSerialized);
assertEquals("org.camunda.Foo", returnedValue.ObjectTypeName);
}
public static MockObjectValue fromObjectValue(ObjectValue objectValue)
{
MockObjectValue result = new MockObjectValue(objectValue.Value);
result.isDeserialized = objectValue.Deserialized;
result.objectTypeName = objectValue.ObjectTypeName;
result.serializationDataFormat = objectValue.SerializationDataFormat;
result.serializedValue = objectValue.ValueSerialized;
result.type = objectValue.Type;
return(result);
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: public org.camunda.bpm.engine.impl.variable.serializer.TypedValueSerializer<?> getSerializer(org.camunda.bpm.engine.variable.value.TypedValue value)
public virtual TypedValueSerializer <object> getSerializer(TypedValue value)
{
if (value is ObjectValue)
{
ObjectValue objectValue = (ObjectValue)value;
if (objectValue.SerializationDataFormat != null && !objectValue.Deserialized)
{
return(new FallbackSpinObjectValueSerializer(objectValue.SerializationDataFormat));
}
}
return(null);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testGetSingleVariableInstanceDeserialized()
public virtual void testGetSingleVariableInstanceDeserialized()
{
ObjectValue serializedValue = MockObjectValue.fromObjectValue(Variables.objectValue("a value").serializationDataFormat("aDataFormat").create()).objectTypeName("aTypeName");
MockHistoricVariableInstanceBuilder builder = MockProvider.mockHistoricVariableInstance().typedValue(serializedValue);
HistoricVariableInstance variableInstanceMock = builder.build();
when(variableInstanceQueryMock.variableId(variableInstanceMock.Id)).thenReturn(variableInstanceQueryMock);
when(variableInstanceQueryMock.disableBinaryFetching()).thenReturn(variableInstanceQueryMock);
when(variableInstanceQueryMock.singleResult()).thenReturn(variableInstanceMock);
given().pathParam("id", MockProvider.EXAMPLE_VARIABLE_INSTANCE_ID).then().expect().statusCode(Status.OK.StatusCode).and().body("id", equalTo(builder.Id)).body("name", equalTo(builder.Name)).body("type", equalTo(VariableTypeHelper.toExpectedValueTypeName(builder.TypedValue.Type))).body("value", equalTo("a value")).body("valueInfo.serializationDataFormat", equalTo("aDataFormat")).body("valueInfo.objectTypeName", equalTo("aTypeName")).body("processDefinitionKey", equalTo(builder.ProcessDefinitionKey)).body("processDefinitionId", equalTo(builder.ProcessDefinitionId)).body("processInstanceId", equalTo(builder.ProcessInstanceId)).body("executionId", equalTo(builder.ExecutionId)).body("errorMessage", equalTo(builder.ErrorMessage)).body("activityInstanceId", equalTo(builder.ActivityInstanceId)).body("caseDefinitionKey", equalTo(builder.CaseDefinitionKey)).body("caseDefinitionId", equalTo(builder.CaseDefinitionId)).body("caseInstanceId", equalTo(builder.CaseInstanceId)).body("caseExecutionId", equalTo(builder.CaseExecutionId)).body("taskId", equalTo(builder.TaskId)).body("tenantId", equalTo(builder.TenantId)).body("createTime", equalTo(MockProvider.EXAMPLE_HISTORIC_VARIABLE_INSTANCE_CREATE_TIME)).body("removalTime", equalTo(MockProvider.EXAMPLE_HISTORIC_VARIABLE_INSTANCE_REMOVAL_TIME)).body("rootProcessInstanceId", equalTo(builder.RootProcessInstanceId)).when().get(VARIABLE_INSTANCE_URL);
verify(variableInstanceQueryMock, times(1)).disableBinaryFetching();
verify(variableInstanceQueryMock, never()).disableCustomObjectDeserialization();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testGetSingleVariableUpdateDeserialized()
public virtual void testGetSingleVariableUpdateDeserialized()
{
ObjectValue serializedValue = MockObjectValue.fromObjectValue(Variables.objectValue("a value").serializationDataFormat("aDataFormat").create()).objectTypeName("aTypeName");
MockHistoricVariableUpdateBuilder builder = MockProvider.mockHistoricVariableUpdate().typedValue(serializedValue);
HistoricVariableUpdate variableInstanceMock = builder.build();
when(historicDetailQueryMock.detailId(variableInstanceMock.Id)).thenReturn(historicDetailQueryMock);
when(historicDetailQueryMock.disableBinaryFetching()).thenReturn(historicDetailQueryMock);
when(historicDetailQueryMock.singleResult()).thenReturn(variableInstanceMock);
given().pathParam("id", builder.Id).then().expect().statusCode(Status.OK.StatusCode).and().body("id", equalTo(builder.Id)).body("variableName", equalTo(builder.Name)).body("variableInstanceId", equalTo(builder.VariableInstanceId)).body("variableType", equalTo(VariableTypeHelper.toExpectedValueTypeName(builder.TypedValue.Type))).body("value", equalTo("a value")).body("valueInfo.serializationDataFormat", equalTo("aDataFormat")).body("valueInfo.objectTypeName", equalTo("aTypeName")).body("processDefinitionKey", equalTo(builder.ProcessDefinitionKey)).body("processDefinitionId", equalTo(builder.ProcessDefinitionId)).body("processInstanceId", equalTo(builder.ProcessInstanceId)).body("errorMessage", equalTo(builder.ErrorMessage)).body("activityInstanceId", equalTo(builder.ActivityInstanceId)).body("revision", equalTo(builder.Revision)).body("time", equalTo(builder.Time)).body("taskId", equalTo(builder.TaskId)).body("executionId", equalTo(builder.ExecutionId)).body("caseDefinitionKey", equalTo(builder.CaseDefinitionKey)).body("caseDefinitionId", equalTo(builder.CaseDefinitionId)).body("caseInstanceId", equalTo(builder.CaseInstanceId)).body("caseExecutionId", equalTo(builder.CaseExecutionId)).body("tenantId", equalTo(builder.TenantId)).when().get(HISTORIC_DETAIL_URL);
verify(historicDetailQueryMock, times(1)).disableBinaryFetching();
verify(historicDetailQueryMock, never()).disableCustomObjectDeserialization();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testGetSingleVariableInstanceSerialized()
public virtual void testGetSingleVariableInstanceSerialized()
{
ObjectValue serializedValue = Variables.serializedObjectValue("a serialized value").serializationDataFormat("aDataFormat").objectTypeName("aTypeName").create();
MockVariableInstanceBuilder builder = MockProvider.mockVariableInstance().typedValue(serializedValue);
VariableInstance variableInstanceMock = builder.build();
when(variableInstanceQueryMock.variableId(variableInstanceMock.Id)).thenReturn(variableInstanceQueryMock);
when(variableInstanceQueryMock.disableBinaryFetching()).thenReturn(variableInstanceQueryMock);
when(variableInstanceQueryMock.disableCustomObjectDeserialization()).thenReturn(variableInstanceQueryMock);
when(variableInstanceQueryMock.singleResult()).thenReturn(variableInstanceMock);
given().pathParam("id", MockProvider.EXAMPLE_VARIABLE_INSTANCE_ID).queryParam("deserializeValue", false).then().expect().statusCode(Status.OK.StatusCode).and().body("id", equalTo(builder.Id)).body("name", equalTo(builder.Name)).body("type", equalTo(VariableTypeHelper.toExpectedValueTypeName(builder.TypedValue.Type))).body("value", equalTo("a serialized value")).body("valueInfo.serializationDataFormat", equalTo("aDataFormat")).body("valueInfo.objectTypeName", equalTo("aTypeName")).body("processInstanceId", equalTo(builder.ProcessInstanceId)).body("executionId", equalTo(builder.ExecutionId)).body("caseInstanceId", equalTo(builder.CaseInstanceId)).body("caseExecutionId", equalTo(builder.CaseExecutionId)).body("taskId", equalTo(builder.TaskId)).body("activityInstanceId", equalTo(builder.ActivityInstanceId)).body("tenantId", equalTo(builder.TenantId)).body("errorMessage", equalTo(builder.ErrorMessage)).when().get(VARIABLE_INSTANCE_URL);
verify(variableInstanceQueryMock, times(1)).disableBinaryFetching();
verify(variableInstanceQueryMock, times(1)).disableCustomObjectDeserialization();
}
public virtual HistoricVariableUpdate build()
{
HistoricVariableUpdate mockVariable = mock(typeof(HistoricVariableUpdate));
when(mockVariable.Id).thenReturn(id_Renamed);
when(mockVariable.VariableName).thenReturn(name_Renamed);
when(mockVariable.VariableInstanceId).thenReturn(variableInstanceId_Renamed);
when(mockVariable.VariableTypeName).thenReturn(typedValue_Renamed.Type.Name);
if (typedValue_Renamed.GetType().IsAssignableFrom(typeof(ObjectValue)))
{
ObjectValue objectValue = (ObjectValue)typedValue_Renamed;
if (objectValue.Deserialized)
{
when(mockVariable.Value).thenReturn(typedValue_Renamed.Value);
}
else
{
when(mockVariable.Value).thenReturn(null);
}
}
else
{
when(mockVariable.Value).thenReturn(typedValue_Renamed.Value);
}
when(mockVariable.TypedValue).thenReturn(typedValue_Renamed);
when(mockVariable.ProcessDefinitionKey).thenReturn(processDefinitionKey_Renamed);
when(mockVariable.ProcessDefinitionId).thenReturn(processDefinitionId_Renamed);
when(mockVariable.ProcessInstanceId).thenReturn(processInstanceId_Renamed);
when(mockVariable.ErrorMessage).thenReturn(errorMessage_Renamed);
when(mockVariable.Revision).thenReturn(revision_Renamed);
when(mockVariable.Time).thenReturn(DateTimeUtil.parseDate(time_Renamed));
when(mockVariable.ActivityInstanceId).thenReturn(activityInstanceId_Renamed);
when(mockVariable.TaskId).thenReturn(taskId_Renamed);
when(mockVariable.ExecutionId).thenReturn(executionId_Renamed);
when(mockVariable.TypeName).thenReturn(typedValue_Renamed.Type.Name);
when(mockVariable.CaseDefinitionKey).thenReturn(caseDefinitionKey_Renamed);
when(mockVariable.CaseDefinitionId).thenReturn(caseDefinitionId_Renamed);
when(mockVariable.CaseInstanceId).thenReturn(caseInstanceId_Renamed);
when(mockVariable.CaseExecutionId).thenReturn(caseExecutionId_Renamed);
when(mockVariable.TenantId).thenReturn(tenantId_Renamed);
when(mockVariable.UserOperationId).thenReturn(userOperationId_Renamed);
return(mockVariable);
}
public virtual void testSelectHistoricSerializedValues()
{
if (processEngineConfiguration.HistoryLevel.Id >= org.camunda.bpm.engine.impl.history.HistoryLevel_Fields.HISTORY_LEVEL_AUDIT.Id)
{
ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
JsonSerializable bean = new JsonSerializable("a String", 42, false);
runtimeService.setVariable(instance.Id, "simpleBean", objectValue(bean).serializationDataFormat(JSON_FORMAT_NAME));
HistoricVariableInstance historicVariable = historyService.createHistoricVariableInstanceQuery().singleResult();
assertNotNull(historicVariable.Value);
assertNull(historicVariable.ErrorMessage);
ObjectValue typedValue = (ObjectValue)historicVariable.TypedValue;
assertEquals(JSON_FORMAT_NAME, typedValue.SerializationDataFormat);
JSONAssert.assertEquals(bean.toExpectedJsonString(), new string(typedValue.ValueSerialized), true);
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
assertEquals(typeof(JsonSerializable).FullName, typedValue.ObjectTypeName);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void execute(org.camunda.bpm.engine.delegate.DelegateExecution execution) throws Exception
public virtual void execute(DelegateExecution execution)
{
// validate integer variable
int?expectedIntValue = 1234;
assertEquals(expectedIntValue, execution.getVariable("anIntegerVariable"));
assertEquals(expectedIntValue, execution.getVariableTyped("anIntegerVariable").Value);
assertEquals(ValueType.INTEGER, execution.getVariableTyped("anIntegerVariable").Type);
assertNull(execution.getVariableLocal("anIntegerVariable"));
assertNull(execution.getVariableLocalTyped("anIntegerVariable"));
// set an additional local variable
execution.setVariableLocal("aStringVariable", "aStringValue");
string expectedStringValue = "aStringValue";
assertEquals(expectedStringValue, execution.getVariable("aStringVariable"));
assertEquals(expectedStringValue, execution.getVariableTyped("aStringVariable").Value);
assertEquals(ValueType.STRING, execution.getVariableTyped("aStringVariable").Type);
assertEquals(expectedStringValue, execution.getVariableLocal("aStringVariable"));
assertEquals(expectedStringValue, execution.getVariableLocalTyped("aStringVariable").Value);
assertEquals(ValueType.STRING, execution.getVariableLocalTyped("aStringVariable").Type);
SimpleSerializableBean objectValue = (SimpleSerializableBean)execution.getVariable("anObjectValue");
assertNotNull(objectValue);
assertEquals(10, objectValue.IntProperty);
ObjectValue variableTyped = execution.getVariableTyped("anObjectValue");
assertEquals(10, variableTyped.getValue(typeof(SimpleSerializableBean)).IntProperty);
assertEquals(Variables.SerializationDataFormats.JAVA.Name, variableTyped.SerializationDataFormat);
objectValue = (SimpleSerializableBean)execution.getVariable("anUntypedObjectValue");
assertNotNull(objectValue);
assertEquals(30, objectValue.IntProperty);
variableTyped = execution.getVariableTyped("anUntypedObjectValue");
assertEquals(30, variableTyped.getValue(typeof(SimpleSerializableBean)).IntProperty);
assertEquals(Context.ProcessEngineConfiguration.DefaultSerializationFormat, variableTyped.SerializationDataFormat);
}
/// <summary>
/// Tests that
/// 1) a serialized value can be set OUT OF process application context
/// even if the data format is not available (using the fallback serializer)
/// 2) and that this value can be deserialized IN process application context
/// by using the PA-local serializer
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void customFormatCanBeUsedForVariableSerialization()
public virtual void customFormatCanBeUsedForVariableSerialization()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.runtime.ProcessInstance pi = runtimeService.startProcessInstanceByKey("testProcess", org.camunda.bpm.engine.variable.Variables.createVariables().putValue("serializedObject", serializedObjectValue("foo").serializationDataFormat(org.camunda.bpm.integrationtest.functional.spin.dataformat.FooDataFormat.NAME).objectTypeName(org.camunda.bpm.integrationtest.functional.spin.dataformat.Foo.class.getName())));
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
ProcessInstance pi = runtimeService.startProcessInstanceByKey("testProcess", Variables.createVariables().putValue("serializedObject", serializedObjectValue("foo").serializationDataFormat(FooDataFormat.NAME).objectTypeName(typeof(Foo).FullName)));
ObjectValue objectValue = null;
try
{
ProcessApplicationContext.CurrentProcessApplication = ReferenceStoringProcessApplication.INSTANCE;
objectValue = runtimeService.getVariableTyped(pi.Id, "serializedObject", true);
}
finally
{
ProcessApplicationContext.clear();
}
object value = objectValue.Value;
Assert.assertNotNull(value);
Assert.assertTrue(value is Foo);
}
public SerializedObjectValueBuilderImpl(ObjectValue value)
{
variableValue = (ObjectValueImpl)value;
}
public ObjectVariableBuilderImpl(ObjectValue value)
{
variableValue = (ObjectValueImpl)value;
}
