@Test
public void
shouldThrowExceptionIfNoTypeMappingWasFoundWithTransactionWithoutAffectingDbBlocking() {
final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
when(storIOSQLite.lowLevel()).thenReturn(internal);
when(storIOSQLite.put()).thenReturn(new PreparedPut.Builder(storIOSQLite));
final List<TestItem> items = asList(TestItem.newInstance(), TestItem.newInstance());
final PreparedPut<PutResults<TestItem>> preparedPut =
storIOSQLite.put().objects(items).useTransaction(true).prepare();
try {
preparedPut.executeAsBlocking();
failBecauseExceptionWasNotThrown(StorIOException.class);
} catch (StorIOException expected) {
// it's okay, no type mapping was found
assertThat(expected).hasCauseInstanceOf(IllegalStateException.class);
}
verify(storIOSQLite).put();
verify(storIOSQLite).lowLevel();
verify(internal).typeMapping(TestItem.class);
verify(internal, never()).insert(any(InsertQuery.class), any(ContentValues.class));
verify(internal, never()).update(any(UpdateQuery.class), any(ContentValues.class));
verifyNoMoreInteractions(storIOSQLite, internal);
}
public void testGetItem() {
{
PSI psi = st.getStackItem("group1", "item1", "context");
assertNotNull(psi);
assertEquals("group1", psi.getGroup());
assertEquals("item1", psi.getItem());
assertEquals(m_timer.getTimeMillis(0), psi.getCreationTime());
psi.close();
TestItem item = getItem("group1", "item1");
assertNotNull(item);
assertEquals(m_timer.getTimeMillis(1) - m_timer.getTimeMillis(0), item.getTotalTime());
assertEquals(0L, item.getChildsTime());
}
int tID = m_timer.currentTimerId();
{
PSI psi1 = st.getStackItem("g1", "i1");
PSI psi2 = st.getStackItem("g1", "i2");
psi2.close();
assertEquals(
m_timer.getTimeMillis(tID + 2) - m_timer.getTimeMillis(tID + 1), psi1.getChildsTime());
psi1.close();
assertEquals(
m_timer.getTimeMillis(tID + 3) - m_timer.getTimeMillis(tID),
getItem("g1", "i1").getTotalTime());
assertEquals(
m_timer.getTimeMillis(tID + 2) - m_timer.getTimeMillis(tID + 1),
getItem("g1", "i1").getChildsTime());
}
}
/** Test setting and getting a configuration item */
@Test
public void itemTest() {
IConfigurationService cs = getConfigurationService();
String value = "xyz";
TestItem item1 = new TestItem();
item1.setValue(value);
cs.set(item1);
TestItem item2 = cs.get(TestItem.class);
Assert.assertEquals(item1, item2);
// remove key
item1 = new TestItem();
item1.setValue(null);
cs.set(item1);
item2 = cs.get(TestItem.class);
Assert.assertEquals(item1, item2);
}
@Test
public void
shouldThrowExceptionIfNoTypeMappingWasFoundWithTransactionWithoutAffectingDbAsObservable() {
final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
when(storIOSQLite.internal()).thenReturn(internal);
when(storIOSQLite.delete()).thenReturn(new PreparedDelete.Builder(storIOSQLite));
final List<TestItem> items = asList(TestItem.newInstance(), TestItem.newInstance());
final TestSubscriber<DeleteResults<TestItem>> testSubscriber =
new TestSubscriber<DeleteResults<TestItem>>();
storIOSQLite
.delete()
.objects(items)
.useTransaction(true)
.prepare()
.createObservable()
.subscribe(testSubscriber);
testSubscriber.awaitTerminalEvent();
testSubscriber.assertNoValues();
assertThat(testSubscriber.getOnErrorEvents().get(0))
.isInstanceOf(StorIOException.class)
.hasCauseInstanceOf(IllegalStateException.class);
verify(storIOSQLite).delete();
verify(storIOSQLite).internal();
verify(internal).typeMapping(TestItem.class);
verify(internal, never()).delete(any(DeleteQuery.class));
verifyNoMoreInteractions(storIOSQLite, internal);
}
private Dataset setUpDataset(Query query, TestItem testItem) {
try {
// testItem.requiresTextIndex()
if (doesQueryHaveDataset(query) && doesTestItemHaveDataset(testItem)) {
// Only warn if there are results to test
// Syntax tests may have FROM etc and a manifest data file.
if (testItem.getResultFile() != null)
Log.warn(this, testItem.getName() + " : query data source and also in test file");
}
// In test file?
if (doesTestItemHaveDataset(testItem))
// Not specified in the query - get from test item and load
return createDataset(testItem.getDefaultGraphURIs(), testItem.getNamedGraphURIs());
// Check 3 - were there any at all?
if (!doesQueryHaveDataset(query)) fail("No dataset");
// Left to query
return null;
} catch (JenaException jEx) {
fail("JenaException creating data source: " + jEx.getMessage());
return null;
}
}
@Override
public Property<?> getContainerProperty(Object itemId, Object propertyId) {
TestItem item = getItem(itemId);
if (null == item) {
return null;
}
return item.getItemProperty(propertyId);
}
void runTestSelect(Query query, QueryExecution qe) throws Exception {
// Do the query!
ResultSetRewindable resultsActual = ResultSetFactory.makeRewindable(qe.execSelect());
qe.close();
if (results == null) return;
// Assumes resultSetCompare can cope with full isomorphism possibilities.
ResultSetRewindable resultsExpected;
if (results.isResultSet())
resultsExpected = ResultSetFactory.makeRewindable(results.getResultSet());
else if (results.isModel())
resultsExpected = ResultSetFactory.makeRewindable(results.getModel());
else {
fail("Wrong result type for SELECT query");
resultsExpected = null; // Keep the compiler happy
}
if (query.isReduced()) {
// Reduced - best we can do is DISTINCT
resultsExpected = unique(resultsExpected);
resultsActual = unique(resultsActual);
}
// Hack for CSV : tests involving bNodes need manually checking.
if (testItem.getResultFile().endsWith(".csv")) {
resultsActual = convertToStrings(resultsActual);
resultsActual.reset();
int nActual = ResultSetFormatter.consume(resultsActual);
int nExpected = ResultSetFormatter.consume(resultsExpected);
resultsActual.reset();
resultsExpected.reset();
assertEquals("CSV: Different number of rows", nExpected, nActual);
boolean b = resultSetEquivalent(query, resultsExpected, resultsActual);
if (!b) System.out.println("Manual check of CSV results required: " + testItem.getName());
return;
}
boolean b = resultSetEquivalent(query, resultsExpected, resultsActual);
if (!b) {
resultsExpected.reset();
resultsActual.reset();
boolean b2 = resultSetEquivalent(query, resultsExpected, resultsActual);
printFailedResultSetTest(query, qe, resultsExpected, resultsActual);
}
assertTrue("Results do not match: " + testItem.getName(), b);
return;
}
private String makeDescription() {
String tmp = "";
if (testItem.getDefaultGraphURIs() != null) {
for (Iterator<String> iter = testItem.getDefaultGraphURIs().iterator(); iter.hasNext(); )
tmp = tmp + iter.next();
}
if (testItem.getNamedGraphURIs() != null) {
for (Iterator<String> iter = testItem.getNamedGraphURIs().iterator(); iter.hasNext(); )
tmp = tmp + iter.next();
}
String d = "Test " + testNumber + " :: " + testItem.getName();
// +" :: QueryFile="+testItem.getQueryFile()+
// ", DataFile="+tmp+", ResultsFile="+testItem.getResultFile() ;
return d;
}
private void compareGraphResults(Model resultsActual, Query query) {
if (results != null) {
try {
if (!results.isGraph()) fail("Expected results are not a graph: " + testItem.getName());
Model resultsExpected = results.getModel();
if (!resultsExpected.isIsomorphicWith(resultsActual)) {
printFailedModelTest(query, resultsExpected, resultsActual);
fail("Results do not match: " + testItem.getName());
}
} catch (Exception ex) {
String typeName = (query.isConstructType() ? "construct" : "describe");
fail("Exception in result testing (" + typeName + "): " + ex);
}
}
}
/**
* Convenience method to launch verification
*
* @param testItem TestItem instance from which the various parameters to a Verifier instance can
* be surmized.
* @return - Verifier instance with verification result - us isPass() to determine success or
* failure
*/
public static Verifier getVerifier(TestItem testItem) {
// User may want to get a specific class for the verification (date, integer, amount, etc.)
String cls = testItem.getDataProperties().getString("class");
if (isBlank(cls)) cls = "";
// User may have specified some comparison mode other than equal (the default)
String md = testItem.getDataProperties().getString("comparemode");
if (isBlank(md)) md = "";
if (isBlank(md)) md = DDTSettings.Settings().getDefaultComparison();
// User may have specified some option for the output (lowecase, ignorecase, etc.)
String opt = testItem.getDataProperties().getString("option");
if (isBlank(opt)) opt = "";
// User typically specifies some expected value
String ev = testItem.getDataProperties().getString("value");
if (isBlank(ev)) ev = "";
// User can indicate whether or not to trim white spaces off of actual value and expected values
// prior to comparison
// If the user did not specify anything (blank) then use the settings, else use the specified
// value
String strip = testItem.getDataProperties().getString("stripWhiteSpace");
if (isBlank(strip)) strip = DDTSettings.Settings().getStripWhiteSpace() ? "true" : "false";
boolean stripWhiteSpace = Util.asBoolean(strip);
if (testItem.shouldFail()) return new Verifier(ev, "", md, opt, cls, stripWhiteSpace, true);
// The Actual Value (second param) will be set by caller
return new Verifier(ev, "", md, opt, cls, stripWhiteSpace);
}
@Override
protected void setUp() throws Exception {
super.setUp();
// SPARQL and ARQ tests are done with no value matching (for query execution and results
// testing)
resetNeeded = true;
ARQ.setTrue(ARQ.strictGraph);
// Turn parser warnings off for the test data.
oldWarningFlag = CheckerLiterals.WarnOnBadLiterals;
CheckerLiterals.WarnOnBadLiterals = false;
// Sort out results.
results = testItem.getResults();
}
@Test
public void
shouldThrowExceptionIfNoTypeMappingWasFoundWithoutTransactionWithoutAffectingDbAsCompletable() {
final StorIOSQLite storIOSQLite = mock(StorIOSQLite.class);
final StorIOSQLite.Internal internal = mock(StorIOSQLite.Internal.class);
when(storIOSQLite.lowLevel()).thenReturn(internal);
when(storIOSQLite.put()).thenReturn(new PreparedPut.Builder(storIOSQLite));
final List<TestItem> items = asList(TestItem.newInstance(), TestItem.newInstance());
final TestSubscriber<PutResults<TestItem>> testSubscriber =
new TestSubscriber<PutResults<TestItem>>();
storIOSQLite
.put()
.objects(items)
.useTransaction(false)
.prepare()
.asRxCompletable()
.subscribe(testSubscriber);
testSubscriber.awaitTerminalEvent();
testSubscriber.assertNoValues();
assertThat(testSubscriber.getOnErrorEvents().get(0))
.isInstanceOf(StorIOException.class)
.hasCauseInstanceOf(IllegalStateException.class);
verify(storIOSQLite).put();
verify(storIOSQLite).lowLevel();
verify(storIOSQLite).defaultScheduler();
verify(internal).typeMapping(TestItem.class);
verify(internal, never()).insert(any(InsertQuery.class), any(ContentValues.class));
verify(internal, never()).update(any(UpdateQuery.class), any(ContentValues.class));
verifyNoMoreInteractions(storIOSQLite, internal);
}
@Override
protected void setup(VaadinRequest request) {
VerticalLayout layout = new VerticalLayout();
layout.setSizeFull();
final Table table = new Table();
table.setColumnReorderingAllowed(true);
table.setSizeFull();
BeanItemContainer<TestItem> cont = new BeanItemContainer<>(TestItem.class);
for (int i = 0; i < ROW_COUNT; i++) {
TestItem ti = new TestItem();
ti.setValue1("Value1_" + i);
ti.setValue2("Value2_" + (ROW_COUNT - i));
ti.setValue3("Value3_" + i);
ti.setValue4("Value4_" + (ROW_COUNT - i));
ti.setValue5("Value5_" + i);
cont.addBean(ti);
}
table.setContainerDataSource(cont);
table.setImmediate(true);
table.setSelectable(true);
table.setMultiSelect(false);
table.setPageLength(10);
table.setDragMode(Table.TableDragMode.ROW);
table.setDropHandler(
new DropHandler() {
@Override
public void drop(DragAndDropEvent dragAndDropEvent) {}
@Override
public AcceptCriterion getAcceptCriterion() {
return AcceptAll.get();
}
});
table.addColumnReorderListener(
new ColumnReorderListener() {
@Override
public void columnReorder(ColumnReorderEvent event) {
System.out.println("columnReorder");
}
});
table.addHeaderClickListener(
new HeaderClickListener() {
@Override
public void headerClick(HeaderClickEvent event) {
System.out.println("Header was clicked");
}
});
layout.addComponent(table);
addComponent(layout);
}
public QueryTest(String testName, EarlReport earl, FileManager fm, TestItem t) {
super(TestUtils.safeName(testName), t.getURI(), earl);
queryFileManager = fm;
testItem = t;
}
@Override
public String toString() {
if (testItem.getName() != null) return testItem.getName();
return super.getName();
}
private static boolean doesTestItemHaveDataset(TestItem testItem) {
boolean r =
(testItem.getDefaultGraphURIs() != null && testItem.getDefaultGraphURIs().size() > 0)
|| (testItem.getNamedGraphURIs() != null && testItem.getNamedGraphURIs().size() > 0);
return r;
}
