DataSetDataTest.java

package com.belladati.sdk.dataset.impl;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotEquals;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertSame;

import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.List;

import org.testng.annotations.Test;

import com.belladati.sdk.dataset.data.DataColumn;
import com.belladati.sdk.dataset.data.DataRow;
import com.belladati.sdk.dataset.data.DataTable;
import com.belladati.sdk.dataset.data.OverwritePolicy;
import com.belladati.sdk.exception.dataset.data.NoColumnsException;
import com.belladati.sdk.exception.dataset.data.TooManyColumnsException;
import com.belladati.sdk.exception.dataset.data.UnknownColumnException;
import com.belladati.sdk.test.SDKTest;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;

@Test
public class DataSetDataTest extends SDKTest {

	private final String column = "column";

	/** table must have columns */
	@Test(expectedExceptions = NoColumnsException.class)
	public void noColumns() {
		DataTable.createBasicInstance(Collections.<String> emptyList());
	}

	/** create with single column */
	public void column() {
		DataTable table = DataTable.createBasicInstance(column);
		assertEquals(table.getColumns(), Arrays.asList(new DataColumn(column)));
		assertEquals(table.createRow().getColumns(), table.getColumns());
	}

	/** create with multiple columns passed as strings */
	public void columnsStrings() {
		String other = "other";
		DataTable table = DataTable.createBasicInstance(column, other);
		assertEquals(table.getColumns(), Arrays.asList(new DataColumn(column), new DataColumn(other)));
		assertEquals(table.createRow().getColumns(), table.getColumns());
	}

	/** create with multiple columns passed as list */
	public void columnsStringList() {
		String other = "other";
		DataTable table = DataTable.createBasicInstance(Arrays.asList(column, other));
		assertEquals(table.getColumns(), Arrays.asList(new DataColumn(column), new DataColumn(other)));
		assertEquals(table.createRow().getColumns(), table.getColumns());
	}

	/** create with multiple columns passed as strings */
	public void columnsObjects() {
		DataColumn col1 = new DataColumn(column);
		DataColumn col2 = new DataColumn("other");
		DataTable table = DataTable.createDetailedInstance(col1, col2);
		assertEquals(table.getColumns(), Arrays.asList(col1, col2));
		assertSame(table.getColumns().get(0), col1);
		assertSame(table.getColumns().get(1), col2);
		assertEquals(table.createRow().getColumns(), table.getColumns());
	}

	/** create with multiple columns passed as list */
	public void columnsObjectList() {
		DataColumn col1 = new DataColumn(column);
		DataColumn col2 = new DataColumn("other");
		DataTable table = DataTable.createDetailedInstance(Arrays.asList(col1, col2));
		assertEquals(table.getColumns(), Arrays.asList(col1, col2));
		assertSame(table.getColumns().get(0), col1);
		assertSame(table.getColumns().get(1), col2);
		assertEquals(table.createRow().getColumns(), table.getColumns());
	}

	/** columns with the same code are equal */
	public void columnsEqual() {
		assertEquals(new DataColumn(column), new DataColumn(column, "format"));
		assertEquals(new DataColumn(column).hashCode(), new DataColumn(column).hashCode());

		assertNotEquals(new DataColumn(column), new DataColumn("other"));
		assertNotEquals(new DataColumn(column).hashCode(), new DataColumn("other").hashCode());
		assertFalse(new DataColumn(column).equals(new Object()));
	}

	/** create rows */
	public void createRows() {
		DataTable table = DataTable.createBasicInstance(column);
		assertEquals(table.getRows().size(), 0);
		table.createRow();
		assertEquals(table.getRows().size(), 1);
		table.createRow("abc");
		assertEquals(table.getRows().size(), 2);
	}

	/** returned row list cannot be modified */
	@Test(expectedExceptions = UnsupportedOperationException.class)
	public void rowListImmutable() {
		DataTable table = DataTable.createBasicInstance(column);
		List<DataRow> rows = table.getRows();
		DataRow row = table.createRow();
		assertEquals(rows.size(), 0);
		rows.add(row);
	}

	/** returned column list cannot be modified */
	@Test(expectedExceptions = UnsupportedOperationException.class)
	public void columnListImmutable() {
		DataTable.createBasicInstance(column).getColumns().add(null);
	}

	/** new rows are empty */
	public void rowEmpty() {
		DataTable table = DataTable.createBasicInstance(column);
		DataRow row = table.createRow();

		assertNull(row.get(column));
		assertEquals(row.getAll(), Arrays.asList((String) null));
	}

	/** can set row content through set method */
	public void rowContentSet() {
		String content = "content";
		DataTable table = DataTable.createBasicInstance(column);

		DataRow row = table.createRow();
		row.set(column, content);

		assertEquals(row.get(column), content);
		assertEquals(row.getAll(), Arrays.asList(content));
	}

	/** can set row content through set method */
	public void rowContentSetAll() {
		String content = "content";
		DataTable table = DataTable.createBasicInstance(column);

		DataRow row = table.createRow();
		row.setAll(content);

		assertEquals(row.get(column), content);
		assertEquals(row.getAll(), Arrays.asList(content));
	}

	/** can set row content through setAll method with offset */
	public void rowContentSetOffset() {
		String content = "content";
		DataTable table = DataTable.createBasicInstance(column);

		DataRow row = table.createRow();
		row.setAll(0, content);

		assertEquals(row.get(column), content);
		assertEquals(row.getAll(), Arrays.asList(content));
	}

	/** can set row content through creation */
	public void rowContentCreate() {
		String content = "content";
		DataTable table = DataTable.createBasicInstance(column);

		DataRow row = table.createRow(content).getRows().get(0);

		assertEquals(row.get(column), content);
		assertEquals(row.getAll(), Arrays.asList(content));
	}

	/** can overwrite row values */
	public void overwriteValue() {
		String content = "content";
		DataTable table = DataTable.createBasicInstance(column);

		DataRow row = table.createRow();
		row.set(column, "other").set(column, content);

		assertEquals(row.get(column), content);
	}

	/** setting more values than columns on the table */
	@Test(expectedExceptions = TooManyColumnsException.class)
	public void tooManyValuesTable() {
		DataTable table = DataTable.createBasicInstance(column);
		table.createRow("", "");
	}

	/** setting more values than columns on a row */
	@Test(expectedExceptions = TooManyColumnsException.class)
	public void tooManyValuesRow() {
		DataTable table = DataTable.createBasicInstance(column);
		table.createRow().setAll("", "");
	}

	/** setting values with too high offset */
	@Test(expectedExceptions = TooManyColumnsException.class)
	public void tooHighOffset() {
		DataTable table = DataTable.createBasicInstance(column);
		table.createRow().setAll(1, "");
	}

	/** not setting all values using setAll */
	public void tooFewValues() {
		DataTable table = DataTable.createBasicInstance(column);
		assertEquals(table.createRow().setAll().getAll(), Arrays.asList((String) null));
	}

	/** retrieve unknown column */
	@Test(expectedExceptions = UnknownColumnException.class)
	public void getUnknownColumn() {
		DataTable.createBasicInstance(column).createRow().get("unknown");
	}

	/** set unknown column */
	@Test(expectedExceptions = UnknownColumnException.class)
	public void setUnknownColumn() {
		DataTable.createBasicInstance(column).createRow().set("unknown", "abc");
	}

	/** convert column to JSON */
	public void columnJson() {
		JsonNode columnJson = new DataColumn(column).toJson();
		assertEquals(columnJson.get("code").asText(), column);
		assertFalse(columnJson.has("format"));
	}

	/** convert formatted column to JSON */
	public void columnFormatJson() {
		String format = "format";
		JsonNode columnJson = new DataColumn(column, format).toJson();
		assertEquals(columnJson.get("code").asText(), column);
		assertEquals(columnJson.get("format").asText(), format);
	}

	/** column format can be changed */
	public void columnChangeFormatJson() {
		String format = "format";
		DataColumn dataColumn = new DataColumn(column, "something");
		dataColumn.setFormat(format);
		assertEquals(dataColumn.getFormat(), format);

		JsonNode columnJson = dataColumn.toJson();
		assertEquals(columnJson.get("code").asText(), column);
		assertEquals(columnJson.get("format").asText(), format);
	}

	/** convert row to JSON */
	public void rowJson() {
		String column2 = "other";
		final String content1 = "content1";
		final String content2 = "content2";

		DataRow row = DataTable.createBasicInstance(column, column2).createRow().setAll(content1, content2);
		ArrayNode rowJson = (ArrayNode) row.toJson();

		assertEquals(rowJson.size(), 2);
		assertEquals(rowJson.get(0).asText(), content1);
		assertEquals(rowJson.get(1).asText(), content2);
	}

	/** convert row to JSON with reserved characters */
	public void rowJsonEscape() {
		String col2 = "col2";
		String col3 = "col3";
		final String val1 = "\"I'm a text with ; and , in it\"";
		final String val2 = "\"I'm more text with ; and , in it\"";
		final String val3 = "nothing special here";

		DataRow row = DataTable.createBasicInstance(column, col2, col3).createRow().setAll(val1, val2, val3);
		ArrayNode rowJson = (ArrayNode) row.toJson();

		assertEquals(rowJson.size(), 3);
		assertEquals(rowJson.get(0).asText(), val1);
		assertEquals(rowJson.get(1).asText(), val2);
		assertEquals(rowJson.get(2).asText(), val3);
	}

	/** convert table columns */
	public void tableColumns() {
		String column2 = "other";
		DataTable table = DataTable.createBasicInstance(column, column2).createRow("content");
		JsonNode tableJson = table.toJson();

		ArrayNode columns = (ArrayNode) tableJson.get("columns");
		assertEquals(columns.size(), 2);
		assertEquals(columns.get(0), new DataColumn(column).toJson());
		assertEquals(columns.get(1), new DataColumn(column2).toJson());
	}

	/** convert table with rows and columns */
	public void tableRows() {
		final String content1 = "content1";
		final String content2 = "content2";

		DataTable table = DataTable.createBasicInstance(column);
		DataRow row1 = table.createRow().setAll(content1);
		DataRow row2 = table.createRow().setAll(content2);

		JsonNode tableJson = table.toJson();
		ArrayNode rows = (ArrayNode) tableJson.get("data");
		assertEquals(rows.get(0), row1.toJson());
		assertEquals(rows.get(1), row2.toJson());
	}

	/** correct default overwrite policy */
	public void defaultOverwritePolicy() {
		DataTable table = DataTable.createBasicInstance(column);
		assertEquals(table.getOverwritePolicy(), OverwritePolicy.deleteNone());
	}

	/** convert table policy */
	public void tablePolicy() {
		DataTable table = DataTable.createBasicInstance(column);
		assertEquals(table.toJson().get("overwrite"), table.getOverwritePolicy().toJson());
	}

	/** overwrite policy can be changed */
	public void setOverwritePolicy() {
		DataTable table = DataTable.createBasicInstance(column);
		table.setOverwritePolicy(OverwritePolicy.deleteAll());
		assertNotEquals(table.getOverwritePolicy(), OverwritePolicy.deleteNone());
		assertEquals(table.getOverwritePolicy(), OverwritePolicy.deleteAll());
	}

	/** attribute policy uses unknown attribute */
	@Test(expectedExceptions = UnknownColumnException.class)
	public void attributePolicyMismatch() {
		DataTable.createBasicInstance(column).setOverwritePolicy(OverwritePolicy.byAttributes("other"));
	}

	/** attribute policy uses known attribute */
	public void attributePolicyMatch() {
		OverwritePolicy policy = OverwritePolicy.byAttributes(column);
		DataTable table = DataTable.createBasicInstance(column).setOverwritePolicy(policy);
		assertSame(table.getOverwritePolicy(), policy);
	}

	/** date policy uses unknown attribute */
	@Test(expectedExceptions = UnknownColumnException.class)
	public void datePolicyMismatch() {
		DataTable.createBasicInstance(column).setOverwritePolicy(OverwritePolicy.byDateFrom("other", Calendar.getInstance()));
	}

	/** date policy uses known attribute */
	public void datePolicyMatch() {
		OverwritePolicy policy = OverwritePolicy.byDateFrom(column, Calendar.getInstance());
		DataTable table = DataTable.createBasicInstance(column).setOverwritePolicy(policy);
		assertSame(table.getOverwritePolicy(), policy);
	}
}