nucleus/businessobjects/src/test/java/org/eclipse/mdm/query/entity/ColumnTest.java - mdmbl/org.eclipse.mdm - Git at Google

 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;
 	}
 }
	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;
	}
	}