org.eclipse.mdm.nucleus/org.eclipse.mdm.businessobjects/src/test/java/org/eclipse/mdm/businessobjects/utils/SerializerTest.java

/********************************************************************************
 * Copyright (c) 2015-2018 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/
package org.eclipse.mdm.businessobjects.utils;

import static org.assertj.core.api.Assertions.assertThat;

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Arrays;
import java.util.Map;

import org.eclipse.mdm.api.base.model.EnumRegistry;
import org.eclipse.mdm.api.base.model.Enumeration;
import org.eclipse.mdm.api.base.model.FileLink;
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.model.VersionState;
import org.junit.Test;

import com.google.common.collect.ImmutableMap;

public class SerializerTest {

	@Test
	public void testApplyValueBoolean() throws Exception {

		assertThat(Serializer.deserializeValue(ValueType.BOOLEAN.create("testValue"), "1")).isEqualTo(Boolean.TRUE);
		assertThat(Serializer.deserializeValue(ValueType.BOOLEAN.create("testValue"), 1)).isEqualTo(Boolean.TRUE);
		assertThat(Serializer.deserializeValue(ValueType.BOOLEAN.create("testValue"), "0")).isEqualTo(Boolean.FALSE);
		assertThat(Serializer.deserializeValue(ValueType.BOOLEAN.create("testValue"), 0)).isEqualTo(Boolean.FALSE);
		assertThat(Serializer.deserializeValue(ValueType.BOOLEAN.create("testValue"), "2")).isEqualTo(Boolean.FALSE);
		assertThat(Serializer.deserializeValue(ValueType.BOOLEAN.create("testValue"), 2)).isEqualTo(Boolean.FALSE);
	}

	@Test
	public void testApplyValueByte() throws Exception {

		assertThat(Serializer.deserializeValue(ValueType.BYTE.create("testValue"), "42")).isEqualTo((byte) 42);
		assertThat(Serializer.deserializeValue(ValueType.BYTE.create("testValue"), 42)).isEqualTo((byte) 42);
		assertThat(Serializer.deserializeValue(ValueType.BYTE.create("testValue"), (byte) 42)).isEqualTo((byte) 42);
	}

	@Test
	public void testApplyValueShort() throws Exception {

		assertThat(Serializer.deserializeValue(ValueType.SHORT.create("testValue"), "42")).isEqualTo((short) 42);
		assertThat(Serializer.deserializeValue(ValueType.SHORT.create("testValue"), 42)).isEqualTo((short) 42);
		assertThat(Serializer.deserializeValue(ValueType.SHORT.create("testValue"), (short) 42)).isEqualTo((short) 42);
	}

	@Test
	public void testApplyValueInt() throws Exception {

		assertThat(Serializer.deserializeValue(ValueType.INTEGER.create("testValue"), "42")).isEqualTo(42);
		assertThat(Serializer.deserializeValue(ValueType.INTEGER.create("testValue"), 42)).isEqualTo(42);
		assertThat(Serializer.deserializeValue(ValueType.INTEGER.create("testValue"), 42)).isEqualTo(42);
	}

	@Test
	public void testApplyValueLong() throws Exception {

		assertThat(Serializer.deserializeValue(ValueType.LONG.create("testValue"), "42")).isEqualTo(42L);
		assertThat(Serializer.deserializeValue(ValueType.LONG.create("testValue"), 42)).isEqualTo(42L);
		assertThat(Serializer.deserializeValue(ValueType.LONG.create("testValue"), 42L)).isEqualTo(42L);
	}

	@Test
	public void testApplyValueFloat() throws Exception {

		assertThat(Serializer.deserializeValue(ValueType.FLOAT.create("testValue"), "42.1")).isEqualTo(42.1f);
		assertThat(Serializer.deserializeValue(ValueType.FLOAT.create("testValue"), 42.1)).isEqualTo(42.1f);
		assertThat(Serializer.deserializeValue(ValueType.FLOAT.create("testValue"), 42)).isEqualTo(42.0f);
	}

	@Test
	public void testApplyValueDouble() throws Exception {

		assertThat(Serializer.deserializeValue(ValueType.DOUBLE.create("testValue"), "42.1")).isEqualTo(42.1);
		assertThat(Serializer.deserializeValue(ValueType.DOUBLE.create("testValue"), 42.1)).isEqualTo(42.1);
		assertThat(Serializer.deserializeValue(ValueType.DOUBLE.create("testValue"), 42)).isEqualTo(42.0);
	}

	@Test
	public void testApplyValueDate() throws Exception {
		assertThat(Serializer.deserializeValue(ValueType.DATE.create("testValue"), "2018-01-02T12:13:14Z"))
				.isEqualTo(LocalDateTime.of(2018, 01, 02, 12, 13, 14));
		assertThat(Serializer.deserializeValue(ValueType.DATE.create("testValue"), 123456789L))
				.isEqualTo(LocalDateTime.ofEpochSecond(123456789L, 0, ZoneOffset.UTC));
	}

	@Test
	public void testApplyValueEnumerationValue() throws Exception {
		@SuppressWarnings("unchecked")
		Enumeration<VersionState> versionStateEnum = (Enumeration<VersionState>) EnumRegistry.getInstance()
				.get(EnumRegistry.VERSION_STATE);
		Value v = ValueType.ENUMERATION.create(versionStateEnum, EnumRegistry.VERSION_STATE);
		v.set(versionStateEnum.valueOf("VALID"));
		assertThat(Serializer.deserializeValue(v, "VALID")).isEqualTo(versionStateEnum.valueOf("VALID"));
	}

	@Test
	public void testDeserializeFileLink() throws Exception {

		FileLink link1 = FileLink.newRemote("root/fileLink.pdf", new MimeType("application/pdf"), "desc");

		Map<String, String> map = ImmutableMap.of("remotePath", "root/fileLink.pdf", "mimeType", "application/pdf",
				"description", "desc");

		Value v = ValueType.FILE_LINK.create("fileLink");
		assertThat(Serializer.deserializeValue(v, map)).isEqualTo(link1);
	}

	@Test
	public void testDeserializeFileLinkSequence() throws Exception {

		FileLink link1 = FileLink.newRemote("root/fileLink1.pdf", new MimeType("application/pdf"), "desc1");
		FileLink link2 = FileLink.newRemote("root/image.jpeg", new MimeType("application/jpeg"), "desc2");

		Map<String, String> map1 = ImmutableMap.of("remotePath", "root/fileLink1.pdf", "mimeType", "application/pdf",
				"description", "desc1");

		Map<String, String> map2 = ImmutableMap.of("remotePath", "root/image.jpeg", "mimeType", "application/jpeg",
				"description", "desc2");

		Value v = ValueType.FILE_LINK_SEQUENCE.create("fileLink");
		assertThat((FileLink[]) Serializer.deserializeValue(v, Arrays.asList(map1, map2))).containsExactly(link1,
				link2);
	}

	@Test
	public void testSerializeFileLink() throws Exception {

		FileLink link1 = FileLink.newRemote("root/fileLink.pdf", new MimeType("application/pdf"), "desc");

		Map<String, String> map = ImmutableMap.of("remotePath", "root/fileLink.pdf", "mimeType", "application/pdf",
				"description", "desc");

		assertThat(Serializer.serializeValue(ValueType.FILE_LINK.create("fileLink", link1))).isEqualTo(map);
	}

	@Test
	public void testSerializeFileLinkSequence() throws Exception {

		FileLink link1 = FileLink.newRemote("root/fileLink1.pdf", new MimeType("application/pdf"), "desc1");
		FileLink link2 = FileLink.newRemote("root/image.jpeg", new MimeType("application/jpeg"), "desc2");

		Map<String, String> map1 = ImmutableMap.of("remotePath", "root/fileLink1.pdf", "mimeType", "application/pdf",
				"description", "desc1");

		Map<String, String> map2 = ImmutableMap.of("remotePath", "root/image.jpeg", "mimeType", "application/jpeg",
				"description", "desc2");

		assertThat(Serializer
				.serializeValue(ValueType.FILE_LINK_SEQUENCE.create("fileLinks", new FileLink[] { link1, link2 })))
						.isEqualTo(Arrays.asList(map1, map2));
	}
}