@Test
public void testFindFieldTransitive() throws Exception {
List<SyntheticField> fields = new ArrayList<SyntheticField>();
SyntheticField f1 = new SimpleSyntheticField(PersonDomain.class.getDeclaredField("name"));
SyntheticField f2 = new SimpleSyntheticField(PersonDomain.class.getDeclaredField("address"));
fields.add(f1);
fields.add(f2);
SyntheticField f3 = new SimpleSyntheticField(AddressDomain.class.getDeclaredField("id"));
when(reflectionHelper.getSyntheticFields(any(Class.class)))
.thenReturn(Collections.singletonList(f3));
SyntheticField[] res;
res =
converterHelper.findField(
fields, "id", new String[] {"address"}, PersonDomain.class, false);
assertThat(res).hasSize(2);
assertThat(res[0]).isEqualTo(f2);
assertThat(res[1]).isEqualTo(f3);
exception.expect(JTransfoException.class);
exception.expectMessage(
"Cannot find getter from [getBla, isBla, hasBla] on "
+ "class org.jtransfo.object.PersonDomain.");
converterHelper.findField(fields, "id", new String[] {"bla"}, PersonDomain.class, false);
}
/**
* Returns the list of variants that can be converted from a given object class.
*
* @param sourceClass The source class.
* @param targetVariant The expected representation metadata.
* @return The list of variants that can be converted.
*/
public static List<VariantInfo> getVariants(Class<?> sourceClass, Variant targetVariant) {
List<VariantInfo> result = null;
List<VariantInfo> helperVariants = null;
for (ConverterHelper ch : Engine.getInstance().getRegisteredConverters()) {
// List of variants that can be converted from the source class
helperVariants = ch.getVariants(sourceClass);
if (helperVariants != null) {
// Loop over the variants list
for (VariantInfo helperVariant : helperVariants) {
if (targetVariant == null) {
result = addVariant(result, helperVariant);
} else if (helperVariant.includes(targetVariant)) {
// Detected a more generic variant, but still consider
// the conversion is possible to the target variant.
result = addVariant(result, new VariantInfo(targetVariant.getMediaType()));
} else if (targetVariant.includes(helperVariant)) {
// Detected a more specific variant, but still consider
// the conversion is possible to the target variant.
result = addVariant(result, helperVariant);
}
}
}
}
return result;
}
/**
* Returns the list of variants that can be converted from a given object class.
*
* @param sourceClass The source class.
* @param targetVariant The expected representation metadata.
* @return The list of variants that can be converted.
*/
public static List<VariantInfo> getVariants(Class<?> sourceClass, Variant targetVariant) {
List<VariantInfo> result = null;
for (ConverterHelper ch : Engine.getInstance().getRegisteredConverters()) {
if (ch != null) {
try {
result = ch.addVariants(sourceClass, targetVariant, result);
} catch (IOException e) {
Context.getCurrentLogger()
.log(Level.FINE, "Unable get the variants of the " + ch + " converter helper.", e);
}
}
}
return result;
}
@Test
public void testGetDefaultTypeConverterEmptyList() throws Exception {
TypeConverter typeConverter = converterHelper.getDefaultTypeConverter(Object.class, Date.class);
assertThat(typeConverter).isInstanceOf(NoConversionTypeConverter.class);
}
@Test
public void testGetDeclaredTypeConverter_null() throws Exception {
TypeConverter tc = mock(TypeConverter.class);
TypeConverter res = converterHelper.getDeclaredTypeConverter(null, tc);
assertThat(res).isEqualTo(tc);
}
@Test
public void testGetDeclaredTypeConverterAsClass() throws Exception {
MappedBy mappedBy = mock(MappedBy.class);
when(mappedBy.typeConverterClass()).thenReturn(NoConversionTypeConverter.class);
when(mappedBy.typeConverter()).thenReturn(MappedBy.DEFAULT_TYPE_CONVERTER);
when(mappedBy.field()).thenReturn(MappedBy.DEFAULT_FIELD);
when(reflectionHelper.newInstance(NoConversionTypeConverter.class.getName()))
.thenReturn(new NoConversionTypeConverter());
TypeConverter res = converterHelper.getDeclaredTypeConverter(mappedBy);
assertThat(res).isInstanceOf(NoConversionTypeConverter.class);
TypeConverter res2 = converterHelper.getDeclaredTypeConverter(mappedBy);
assertThat(res2 == res).isTrue(); // instance needs to be cached and reused
}
/**
* Returns the best converter helper matching the given parameters.
*
* @param <T> The target class.
* @param source The source representation variant.
* @param target The target class.
* @param resource The parent resource.
* @return The matched converter helper or null.
*/
public static <T> ConverterHelper getBestHelper(
Representation source, Class<T> target, UniformResource resource) {
ConverterHelper result = null;
float bestScore = -1.0F;
float currentScore;
for (ConverterHelper ch : Engine.getInstance().getRegisteredConverters()) {
currentScore = ch.score(source, target, resource);
if (currentScore > bestScore) {
bestScore = currentScore;
result = ch;
}
}
return result;
}
@Test
public void testGetMapOnlies_none() throws Exception {
Field field = TaggedPersonTo.class.getDeclaredField("lastChanged"); // has both annotations
field.setAccessible(true);
List<MapOnly> res = converterHelper.getMapOnlies(field);
assertThat(res).isNull(); // neither -> null
}
@Test
public void testGetMapOnlies_mapOnlies() throws Exception {
Field field = TaggedPersonTo.class.getDeclaredField("name"); // has both annotations
field.setAccessible(true);
List<MapOnly> res = converterHelper.getMapOnlies(field);
assertThat(res).hasSize(2); // no MapOnly, two in MapOnlies
}
@Test
public void testGetDeclaredTypeConverterDefaults() throws Exception {
MappedBy mappedBy = mock(MappedBy.class);
when(mappedBy.typeConverterClass()).thenReturn(MappedBy.DefaultTypeConverter.class);
when(mappedBy.typeConverter()).thenReturn(MappedBy.DEFAULT_TYPE_CONVERTER);
when(mappedBy.field()).thenReturn(MappedBy.DEFAULT_FIELD);
assertThat(converterHelper.getDeclaredTypeConverter(mappedBy)).isNull();
}
@Test
public void testFindField() throws Exception {
List<SyntheticField> fields = new ArrayList<SyntheticField>();
SyntheticField f1 = new SimpleSyntheticField(SimpleExtendedDomain.class.getDeclaredField("b"));
SyntheticField f2 = new SimpleSyntheticField(SimpleExtendedDomain.class.getDeclaredField("c"));
fields.add(f1);
fields.add(f2);
SyntheticField[] res;
res = converterHelper.findField(fields, "c", new String[0], SimpleExtendedDomain.class, false);
assertThat(res[0]).isEqualTo(f2);
exception.expect(JTransfoException.class);
exception.expectMessage(
"Cannot find getter from [getBla, isBla, hasBla] on class "
+ "org.jtransfo.object.SimpleExtendedDomain.");
converterHelper.findField(fields, "bla", new String[0], SimpleExtendedDomain.class, false);
}
@Test
public void testGetDeclaredTypeConverter() throws Exception {
MapOnly mapOnly = mock(MapOnly.class);
when(mapOnly.typeConverterClass()).thenReturn(MappedBy.DefaultTypeConverter.class);
when(mapOnly.typeConverter()).thenReturn(MappedBy.DEFAULT_TYPE_CONVERTER);
TypeConverter tc = mock(TypeConverter.class);
TypeConverter res = converterHelper.getDeclaredTypeConverter(mapOnly, tc);
assertThat(res).isEqualTo(tc);
}
@Test
public void testGetToConverterTransitive() throws Exception {
ReflectionTestUtils.setField(
converterHelper, "reflectionHelper", new ReflectionHelper()); // echte gebruiken
ToConverter res = converterHelper.getToConverter(PersonTransitiveTo.class, PersonDomain.class);
assertThat(res).isNotNull();
assertThat(res.getToTo()).hasSize(3);
assertThat(res.getToDomain()).hasSize(3);
}
@Test
public void testGetDefaultTypeConverterNoMatchingConverter() throws Exception {
List<TypeConverter> tcs = new ArrayList<TypeConverter>();
tcs.add(new DefaultTypeConverter());
tcs.add(new DefaultTypeConverter());
ReflectionTestUtils.setField(converterHelper, "typeConvertersInOrder", tcs);
TypeConverter typeConverter = converterHelper.getDefaultTypeConverter(Object.class, Date.class);
assertThat(typeConverter).isInstanceOf(NoConversionTypeConverter.class);
}
@Test
public void testGetDefaultTypeConverterMatchingConverter() throws Exception {
TypeConverter typeConverter = mock(TypeConverter.class);
when(typeConverter.canConvert(any(Class.class), any(Class.class))).thenReturn(true);
ReflectionTestUtils.setField(
converterHelper, "typeConvertersInOrder", Collections.singletonList(typeConverter));
TypeConverter result = converterHelper.getDefaultTypeConverter(Object.class, Date.class);
assertThat(result).isEqualTo(typeConverter);
}
@Test
public void testSetTypeConvertersInOrder() throws Exception {
List org = (List) ReflectionTestUtils.getField(converterHelper, "typeConvertersInOrder");
TypeConverter typeConverter = mock(TypeConverter.class);
assertThat(org.size()).isEqualTo(0); // default is empty
converterHelper.setTypeConvertersInOrder(Collections.singletonList(typeConverter));
List res = (List) ReflectionTestUtils.getField(converterHelper, "typeConvertersInOrder");
assertThat(res.size()).isEqualTo(1);
assertThat((Object) res).isInstanceOf(LockableList.class);
assertThat((Boolean) ReflectionTestUtils.getField(res, "readOnly")).isTrue();
}
@Test
public void testGetDeclaredTypeConverterAsName() throws Exception {
MappedBy mappedBy = mock(MappedBy.class);
when(mappedBy.typeConverterClass()).thenReturn(MappedBy.DefaultTypeConverter.class);
when(mappedBy.typeConverter()).thenReturn(NoConversionTypeConverter.class.getName());
when(mappedBy.field()).thenReturn(MappedBy.DEFAULT_FIELD);
when(reflectionHelper.newInstance(NoConversionTypeConverter.class.getName()))
.thenReturn(new NoConversionTypeConverter());
TypeConverter res = converterHelper.getDeclaredTypeConverter(mappedBy);
assertThat(res).isInstanceOf(NoConversionTypeConverter.class);
}
/**
* Returns the best converter helper matching the given parameters.
*
* @param source The object to convert to a representation.
* @param target The target representation variant.
* @param resource The optional parent resource.
* @return The matched converter helper or null.
*/
public static ConverterHelper getBestHelper(
Object source, Variant target, UniformResource resource) {
ConverterHelper result = null;
float bestScore = -1.0F;
float currentScore;
for (ConverterHelper ch : Engine.getInstance().getRegisteredConverters()) {
try {
currentScore = ch.score(source, target, resource);
if (currentScore > bestScore) {
bestScore = currentScore;
result = ch;
}
} catch (Exception e) {
Context.getCurrentLogger()
.log(Level.SEVERE, "Unable get the score of the " + ch + " converter helper.", e);
}
}
return result;
}
@Test
public void testGetToConverterInvalidMapping() throws Exception {
ReflectionTestUtils.setField(
converterHelper, "reflectionHelper", new ReflectionHelper()); // echte gebruiken
exception.expect(JTransfoException.class);
exception.expectMessage(
"Cannot determine mapping for field string in class "
+ "org.jtransfo.object.FaultyExtendedTo. The field zzz in class "
+ "org.jtransfo.object.SimpleExtendedDomain cannot be found.");
converterHelper.getToConverter(FaultyExtendedTo.class, SimpleExtendedDomain.class);
}
@Test
public void testGetToConverter() throws Exception {
ReflectionTestUtils.setField(
converterHelper, "reflectionHelper", new ReflectionHelper()); // echte gebruiken
ToConverter res =
converterHelper.getToConverter(SimpleExtendedTo.class, SimpleExtendedDomain.class);
assertThat(res).isNotNull();
assertThat(res.getToTo()).hasSize(4);
assertThat(res.getToTo().get(0)).isInstanceOf(ToToConverter.class);
assertThat(res.getToDomain()).hasSize(3);
assertThat(res.getToDomain().get(0)).isInstanceOf(ToDomainConverter.class);
}
@Test
public void testGetDeclaredTypeConverterIae() throws Exception {
MappedBy mappedBy = mock(MappedBy.class);
when(mappedBy.typeConverterClass()).thenReturn(MappedBy.DefaultTypeConverter.class);
when(mappedBy.typeConverter()).thenReturn(NoConversionTypeConverter.class.getName());
when(mappedBy.field()).thenReturn(MappedBy.DEFAULT_FIELD);
when(reflectionHelper.newInstance(NoConversionTypeConverter.class.getName()))
.thenThrow(new IllegalAccessException());
exception.expect(JTransfoException.class);
exception.expectMessage(
"Declared TypeConverter class org.jtransfo.NoConversionTypeConverter cannot be accessed.");
converterHelper.getDeclaredTypeConverter(mappedBy);
}
@Test
public void testGetDeclaredTypeConverter_withTypeConverter() throws Exception {
MapOnly mapOnly = mock(MapOnly.class);
when(reflectionHelper.newInstance(
"org.jtransfo.internal.ConverterHelperTest$DefaultTypeConverter"))
.thenReturn(new DefaultTypeConverter());
when(mapOnly.typeConverterClass()).thenReturn(DefaultTypeConverter.class);
when(mapOnly.typeConverter()).thenReturn(MappedBy.DEFAULT_TYPE_CONVERTER);
TypeConverter tc = mock(TypeConverter.class);
TypeConverter res = converterHelper.getDeclaredTypeConverter(mapOnly, tc);
assertThat(res).isInstanceOf(DefaultTypeConverter.class);
}
/**
* Copy data from a service object to a CIMI object.
*
* @param context The current context
* @param dataService Source service object
* @param dataCimi Destination CIMI object
*/
protected void doCopyToCimi(
final CimiContext context, final Job dataService, final CimiJob dataCimi) {
this.fill(context, dataService, dataCimi);
if (true == context.mustBeExpanded(dataCimi)) {
dataCimi.setAction(dataService.getAction());
dataCimi.setProgress(dataService.getProgress());
dataCimi.setReturnCode(dataService.getReturnCode());
dataCimi.setStatus(ConverterHelper.toString(dataService.getState()));
dataCimi.setStatusMessage(dataService.getStatusMessage());
dataCimi.setTimeOfStatusChange(dataService.getTimeOfStatusChange());
dataCimi.setTargetResource(
ConverterHelper.buildTargetResource(context, dataService.getTargetResource()));
if ((null != dataService.getAffectedResources())
&& (dataService.getAffectedResources().size() > 0)) {
TargetResource target;
List<TargetResource> list = new ArrayList<TargetResource>();
for (CloudResource resource : dataService.getAffectedResources()) {
target = ConverterHelper.buildTargetResource(context, resource);
if (null != target) {
list.add(target);
}
}
dataCimi.setAffectedResources(list.toArray(new TargetResource[list.size()]));
}
if (null != dataService.getParentJob()) {
dataCimi.setParentJob(
new ParentJob(context.makeHref(dataCimi, dataService.getParentJob().getUuid())));
}
if ((null != dataService.getNestedJobs()) && (dataService.getNestedJobs().size() > 0)) {
List<NestedJob> list = new ArrayList<NestedJob>();
for (Job job : dataService.getNestedJobs()) {
list.add(new NestedJob(context.makeHref(dataCimi, job.getUuid())));
}
dataCimi.setNestedJobs(list.toArray(new NestedJob[list.size()]));
}
}
}
@Test
public void testGetToConverter_mapOnly() throws Exception {
ReflectionTestUtils.setField(
converterHelper, "reflectionHelper", new ReflectionHelper()); // echte gebruiken
((Map<String, TypeConverter>)
ReflectionTestUtils.getField(converterHelper, "typeConverterInstances"))
.put("always2", new DefaultTypeConverter());
ToConverter res = converterHelper.getToConverter(TaggedPersonTo.class, PersonDomain.class);
assertThat(res).isNotNull();
assertThat(res.getToTo()).hasSize(4);
assertThat(res.getToTo().get(0)).isInstanceOf(TaggedConverter.class);
assertThat(res.getToDomain()).hasSize(3);
assertThat(res.getToDomain().get(0)).isInstanceOf(TaggedConverter.class);
}
@Test
public void testWithPath() throws Exception {
assertThat(converterHelper.withPath(new String[] {"parts", "to", "add"}))
.isEqualTo(" (with path parts.to.add) ");
}
@Test
public void testGetDeclaredTypeConverterNull() throws Exception {
assertThat(converterHelper.getDeclaredTypeConverter(null)).isNull();
}
