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