| package org.eclipse.mdm.query.entity; |
| |
| import static org.assertj.core.api.Assertions.assertThat; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.when; |
| |
| import java.time.LocalDateTime; |
| import java.util.Optional; |
| |
| import org.eclipse.mdm.api.base.adapter.Attribute; |
| import org.eclipse.mdm.api.base.adapter.EntityType; |
| import org.eclipse.mdm.api.base.file.FileService.FileServiceType; |
| import org.eclipse.mdm.api.base.model.Enumeration; |
| import org.eclipse.mdm.api.base.model.EnumerationValue; |
| import org.eclipse.mdm.api.base.model.FileLink; |
| import org.eclipse.mdm.api.base.model.MDMFile; |
| import org.eclipse.mdm.api.base.model.MimeType; |
| import org.eclipse.mdm.api.base.model.Value; |
| import org.eclipse.mdm.api.base.model.ValueType; |
| import org.eclipse.mdm.api.base.query.Record; |
| import org.eclipse.mdm.api.base.query.Result; |
| import org.eclipse.mdm.api.odsadapter.utils.ODSEnum; |
| import org.eclipse.mdm.businessobjects.utils.serialize.MDMJacksonModule; |
| import org.eclipse.mdm.query.util.Util; |
| import org.junit.BeforeClass; |
| import org.junit.Test; |
| import org.mockito.Mockito; |
| |
| import com.fasterxml.jackson.core.JsonProcessingException; |
| import com.fasterxml.jackson.databind.ObjectMapper; |
| |
| public class ColumnTest { |
| |
| public static ObjectMapper mapper = new ObjectMapper(); |
| |
| public static Util queryUtil; |
| |
| @BeforeClass |
| public static void init() { |
| mapper.registerModule(new MDMJacksonModule()); |
| // TODO |
| queryUtil = new Util(null); |
| } |
| |
| @Test |
| public void testString() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrString = createAttribute(e, "myString"); |
| Value valString = ValueType.STRING.create(attrString.getName(), "eins"); |
| record.addValue(valString); |
| |
| Column colString = queryUtil.convertColumn(result, Optional.of(attrString)); |
| assertThat(mapper.writeValueAsString(colString)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myString\",\"valueType\":\"STRING\",\"value\":\"eins\"}"); |
| } |
| |
| @Test |
| public void testStringSequence() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrStringSeq = createAttribute(e, "myStringSeq"); |
| Value valStringSeq = ValueType.STRING_SEQUENCE.create(attrStringSeq.getName(), |
| new String[] { "eins", "zwei", "drei" }); |
| record.addValue(valStringSeq); |
| |
| Column colStringSeq = queryUtil.convertColumn(result, Optional.of(attrStringSeq)); |
| assertThat(mapper.writeValueAsString(colStringSeq)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myStringSeq\",\"valueType\":\"STRING_SEQUENCE\",\"value\":[\"eins\",\"zwei\",\"drei\"]}"); |
| } |
| |
| @Test |
| public void testDate() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrDate = createAttribute(e, "myDate"); |
| Value valDate = ValueType.DATE.create(attrDate.getName(), LocalDateTime.of(2022, 5, 10, 12, 13, 14)); |
| record.addValue(valDate); |
| |
| Column colDate = queryUtil.convertColumn(result, Optional.of(attrDate)); |
| assertThat(mapper.writeValueAsString(colDate)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myDate\",\"valueType\":\"DATE\",\"value\":\"2022-05-10T12:13:14Z\"}"); |
| } |
| |
| @Test |
| public void testDateSequence() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrDateSeq = createAttribute(e, "myDateSeq"); |
| Value valDateSeq = ValueType.DATE_SEQUENCE.create(attrDateSeq.getName(), |
| new LocalDateTime[] { LocalDateTime.of(2021, 5, 10, 12, 13, 14), |
| LocalDateTime.of(2022, 5, 12, 12, 13, 14), LocalDateTime.of(2022, 5, 10, 1, 2, 3) }); |
| record.addValue(valDateSeq); |
| |
| Column colDateSeq = queryUtil.convertColumn(result, Optional.of(attrDateSeq)); |
| assertThat(mapper.writeValueAsString(colDateSeq)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myDateSeq\",\"valueType\":\"DATE_SEQUENCE\",\"value\":[\"2021-05-10T12:13:14Z\",\"2022-05-12T12:13:14Z\",\"2022-05-10T01:02:03Z\"]}"); |
| } |
| |
| @Test |
| public void testInteger() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrInteger = createAttribute(e, "myInteger"); |
| Value valInteger = ValueType.INTEGER.create(attrInteger.getName(), 42); |
| record.addValue(valInteger); |
| |
| Column colInteger = queryUtil.convertColumn(result, Optional.of(attrInteger)); |
| assertThat(mapper.writeValueAsString(colInteger)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myInteger\",\"valueType\":\"INTEGER\",\"value\":42}"); |
| } |
| |
| @Test |
| public void testIntegerSequence() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrIntegerSeq = createAttribute(e, "myIntegerSeq"); |
| Value valIntegerSeq = ValueType.INTEGER_SEQUENCE.create(attrIntegerSeq.getName(), new int[] { 1, 2, 3 }); |
| record.addValue(valIntegerSeq); |
| |
| Column colIntegerSeq = queryUtil.convertColumn(result, Optional.of(attrIntegerSeq)); |
| assertThat(mapper.writeValueAsString(colIntegerSeq)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myIntegerSeq\",\"valueType\":\"INTEGER_SEQUENCE\",\"value\":[1,2,3]}"); |
| } |
| |
| @Test |
| public void testFileLink() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrFileLink = createAttribute(e, "myFileLink"); |
| Value valFileLink = ValueType.FILE_LINK.create(attrFileLink.getName(), FileLink.newRemote("/path/test.txt", |
| new MimeType("text/plain"), "Test file", 42, null, FileServiceType.EXTREF)); |
| record.addValue(valFileLink); |
| |
| Column colFileLink = queryUtil.convertColumn(result, Optional.of(attrFileLink)); |
| assertThat(mapper.writeValueAsString(colFileLink)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myFileLink\",\"valueType\":\"FILE_LINK\",\"value\":{\"identifier\":\"EXTREF:/path/test.txt\",\"mimeType\":\"text/plain\",\"description\":\"Test file\",\"fileName\":\"test.txt\"}}"); |
| } |
| |
| @Test |
| public void testFileLinkSequence() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| MDMFile mdmFile = mock(MDMFile.class); |
| when(mdmFile.getOriginalFileName()).thenReturn("test2.txt"); |
| |
| Attribute attrFileLinkSeq = createAttribute(e, "myFileLinkSeq"); |
| Value valFileLinkSeq = ValueType.FILE_LINK_SEQUENCE.create(attrFileLinkSeq.getName(), |
| new FileLink[] { |
| FileLink.newRemote("/path/test.txt", new MimeType("text/plain"), "Test file (ExtRef)", 42, null, |
| FileServiceType.EXTREF), |
| FileLink.newRemote("/path/test2.txt", new MimeType("text/plain"), "Test file (AoFile)", 147, |
| mdmFile, FileServiceType.AOFILE) }); |
| record.addValue(valFileLinkSeq); |
| |
| Column colFileLinkSeq = queryUtil.convertColumn(result, Optional.of(attrFileLinkSeq)); |
| assertThat(mapper.writeValueAsString(colFileLinkSeq)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myFileLinkSeq\",\"valueType\":\"FILE_LINK_SEQUENCE\",\"value\":[" |
| + "{\"identifier\":\"EXTREF:/path/test.txt\",\"mimeType\":\"text/plain\",\"description\":\"Test file (ExtRef)\",\"fileName\":\"test.txt\"}," |
| + "{\"identifier\":\"AOFILE:null:null\",\"mimeType\":\"text/plain\",\"description\":\"Test file (AoFile)\",\"fileName\":\"test2.txt\"}]}"); |
| } |
| |
| @Test |
| public void testEnum() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrEnum = createAttribute(e, "myEnum"); |
| Enumeration<EnumerationValue> enumeration = createEnumeration(); |
| Value valEnum = ValueType.ENUMERATION.create(enumeration, attrEnum.getName()); |
| valEnum.set(enumeration.valueOf("red_pill")); |
| record.addValue(valEnum); |
| |
| Column colEnum = queryUtil.convertColumn(result, Optional.of(attrEnum)); |
| assertThat(mapper.writeValueAsString(colEnum)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myEnum\",\"valueType\":\"ENUMERATION\",\"value\":\"red_pill\"}"); |
| } |
| |
| @Test |
| public void testEnumSequence() throws JsonProcessingException { |
| EntityType e = Mockito.mock(EntityType.class); |
| when(e.getName()).thenReturn("TestStep"); |
| |
| Record record = new Record(e); |
| Result result = new Result(); |
| result.addRecord(record); |
| |
| Attribute attrEnumSeq = createAttribute(e, "myEnumSeq"); |
| Enumeration<EnumerationValue> enumeration = createEnumeration(); |
| Value valEnumSeq = ValueType.ENUMERATION_SEQUENCE.create(enumeration, attrEnumSeq.getName()); |
| valEnumSeq.set(new EnumerationValue[] { enumeration.valueOf("red_pill"), enumeration.valueOf("blue_pill") }); |
| record.addValue(valEnumSeq); |
| |
| Column colEnumSeq = queryUtil.convertColumn(result, Optional.of(attrEnumSeq)); |
| assertThat(mapper.writeValueAsString(colEnumSeq)).isEqualTo( |
| "{\"type\":\"TestStep\",\"attribute\":\"myEnumSeq\",\"valueType\":\"ENUMERATION_SEQUENCE\",\"value\":[\"red_pill\",\"blue_pill\"]}"); |
| } |
| |
| private Enumeration<EnumerationValue> createEnumeration() { |
| Enumeration<EnumerationValue> enumeration = new Enumeration<>("MDM", EnumerationValue.class, "choice"); |
| enumeration.addValue(new ODSEnum("red_pill", 0)); |
| enumeration.addValue(new ODSEnum("blue_pill", 1)); |
| return enumeration; |
| } |
| |
| private Attribute createAttribute(EntityType e, String name) { |
| Attribute attribute = Mockito.mock(Attribute.class); |
| when(attribute.getEntityType()).thenReturn(e); |
| when(attribute.getName()).thenReturn(name); |
| |
| return attribute; |
| } |
| } |