@Test(expected = SQLException.class) public void testUpdateForeignCollection() throws Exception { UpdateBuilder<OurForeignCollection, Integer> stmtb = new UpdateBuilder<OurForeignCollection, Integer>(databaseType, new TableInfo<OurForeignCollection, Integer>(databaseType, OurForeignCollection.class), null); stmtb.updateColumnValue(OurForeignCollection.FOOS_FIELD_NAME, null); }
@Test(expected = SQLException.class) public void testQueryNoId() throws Exception { StatementExecutor<NoId, String> se = new StatementExecutor<NoId, String>(databaseType, new TableInfo<NoId, String>(databaseType, NoId.class), null); se.queryForId(null, "1", null); }
private static <T, ID> int createTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ifNotExists) throws SQLException { Dao<T, ID> dao = DaoManager.createDao(connectionSource, dataClass); if (dao instanceof BaseDaoImpl<?, ?>) { return doCreateTable(connectionSource, ((BaseDaoImpl<?, ?>) dao).getTableInfo(), ifNotExists); } else { TableInfo<T, ID> tableInfo = new TableInfo<T, ID>(connectionSource, null, dataClass); return doCreateTable(connectionSource, tableInfo, ifNotExists); } }
@Test(expected = SQLException.class) public void testIdEqNoId() throws Exception { new Where<FooNoId, Integer>(new TableInfo<FooNoId, Integer>(databaseType, FooNoId.class), null, databaseType) .idEq(100); }
@Test(expected = SQLException.class) public void testZeroFieldConfigsSpecified() throws Exception { DatabaseTableConfig<NoTableNameAnnotation> tableConfig = new DatabaseTableConfig<NoTableNameAnnotation>( databaseType, NoTableNameAnnotation.class, new ArrayList<DatabaseFieldConfig>()); tableConfig.extractFieldTypes(databaseType); new TableInfo<NoTableNameAnnotation, Void>(databaseType, tableConfig); }
@Test(expected = SQLException.class) public void testIdEqObjectIdNoId() throws Exception { new Where<FooNoId, Integer>(new TableInfo<FooNoId, Integer>(databaseType, FooNoId.class), null, databaseType) .idEq(new BaseDaoImpl<FooNoId, Integer>(connectionSource, FooNoId.class) { }, new FooNoId()); }
@Test(expected = SQLException.class) public void testUpdateNoId() throws Exception { StatementExecutor<NoId, String> se = new StatementExecutor<NoId, String>(databaseType, new TableInfo<NoId, String>(databaseType, NoId.class), null); NoId noId = new NoId(); noId.stuff = "1"; se.update(null, noId, null); }
@Test public void testUnknownForeignField() throws Exception { TableInfo<Foreign, Void> tableInfo = new TableInfo<Foreign, Void>(databaseType, Foreign.class); try { tableInfo.getFieldTypeByColumnName("foo"); fail("expected exception"); } catch (IllegalArgumentException e) { assertTrue(e.getMessage().contains("'" + Foreign.FOREIGN_FIELD_NAME + "'")); assertTrue(e.getMessage().contains("'foo'")); } }
private static <T, ID> int doCreateTable(Dao<T, ID> dao, boolean ifNotExists) throws SQLException { ConnectionSource connectionSource = dao.getConnectionSource(); DatabaseType databaseType = connectionSource.getDatabaseType(); if (dao instanceof BaseDaoImpl<?, ?>) { return doCreateTable(connectionSource, ((BaseDaoImpl<?, ?>) dao).getTableInfo(), ifNotExists); } else { TableInfo<T, ID> tableInfo = new TableInfo<T, ID>(databaseType, dao.getDataClass()); return doCreateTable(connectionSource, tableInfo, ifNotExists); } }
@Test(expected = SQLException.class) public void testNoIdBuildUpdater() throws Exception { Dao<NoId, Void> dao = createDao(NoId.class, false); MappedUpdate.build(dao, new TableInfo<NoId, Void>(databaseType, NoId.class)); }
@Test(expected = IllegalArgumentException.class) public void testObjectNoConstructor() throws Exception { TableInfo<NoConstructor, Void> tableInfo = new TableInfo<NoConstructor, Void>(databaseType, NoConstructor.class); Dao<NoConstructor, Void> dao = createDao(NoConstructor.class, false); new MappedPreparedStmt<NoConstructor, Void>(dao, tableInfo, null, new FieldType[0], new FieldType[0], new ArgumentHolder[0], null, StatementType.SELECT, false); }
@Test(expected = SQLException.class) public void testJustIdBuildUpdater() throws Exception { Dao<NoId, Void> dao = createDao(NoId.class, false); MappedUpdate.build(dao, new TableInfo<NoId, Void>(databaseType, NoId.class)); }
@Test(expected = SQLException.class) public void testNoIdBuildUpdater() throws Exception { Dao<NoId, Void> dao = createDao(NoId.class, false); MappedUpdate.build(dao, new TableInfo<NoId, Void>(databaseType, NoId.class)); }
@Test(expected = SQLException.class) public void testSequenceZero() throws Exception { DatabaseConnection databaseConnection = createMock(DatabaseConnection.class); expect(databaseConnection.queryForLong(isA(String.class))).andReturn(0L); replay(databaseConnection); NeedsSequenceDatabaseType needsSequence = new NeedsSequenceDatabaseType(); Dao<GeneratedIdSequence, Integer> dao = createDao(GeneratedIdSequence.class, false); MappedCreate<GeneratedIdSequence, Integer> mappedCreate = MappedCreate.build(dao, new TableInfo<GeneratedIdSequence, Integer>(databaseType, GeneratedIdSequence.class)); mappedCreate.insert(needsSequence, databaseConnection, new GeneratedIdSequence(), null); verify(databaseConnection); }
@Test(expected = SQLException.class) public void testNoIdBuildDelete() throws Exception { Dao<NoId, Void> dao = createDao(NoId.class, false); MappedDelete.build(dao, new TableInfo<NoId, Void>(databaseType, NoId.class)); }
@Test public void testBoolean() throws Exception { TableInfo<AllTypes, Void> tableInfo = new TableInfo<AllTypes, Void>(connectionSource, null, AllTypes.class); assertEquals(9, tableInfo.getFieldTypes().length); FieldType booleanField = tableInfo.getFieldTypes()[1]; assertEquals("booleanField", booleanField.getColumnName()); StringBuilder sb = new StringBuilder(); List<String> additionalArgs = new ArrayList<String>(); List<String> statementsBefore = new ArrayList<String>(); databaseType.appendColumnArg(null, sb, booleanField, additionalArgs, statementsBefore, null, null); assertTrue(sb.toString().contains("SMALLINT")); }
private static <T, ID> int doCreateTable(Dao<T, ID> dao, boolean ifNotExists) throws SQLException { if (dao instanceof BaseDaoImpl<?, ?>) { return doCreateTable(dao.getConnectionSource(), ((BaseDaoImpl<?, ?>) dao).getTableInfo(), ifNotExists); } else { TableInfo<T, ID> tableInfo = new TableInfo<T, ID>(dao.getConnectionSource(), null, dao.getDataClass()); return doCreateTable(dao.getConnectionSource(), tableInfo, ifNotExists); } }
@Test(expected = SQLException.class) public void testArgumentHolderNotSet() throws Exception { TableInfo<Foo, Integer> tableInfo = new TableInfo<Foo, Integer>(databaseType, Foo.class); Dao<Foo, Integer> dao = createDao(Foo.class, false); MappedCreate<Foo, Integer> mappedCreate = MappedCreate.build(dao, tableInfo); DatabaseConnection conn = createMock(DatabaseConnection.class); expect(conn.insert(isA(String.class), isA(Object[].class), isA(FieldType[].class), isA(GeneratedKeyHolder.class))).andReturn(1); replay(conn); mappedCreate.insert(databaseType, conn, new Foo(), null); }
@Test(expected = SQLException.class) public void testInSubQueryToManySubColumns() throws Exception { TableInfo<ForeignFoo, Integer> tableInfo = new TableInfo<ForeignFoo, Integer>(databaseType, ForeignFoo.class); Where<ForeignFoo, Integer> where = new Where<ForeignFoo, Integer>(tableInfo, null, databaseType); BaseDaoImpl<ForeignFoo, Integer> foreignDao = new BaseDaoImpl<ForeignFoo, Integer>(connectionSource, ForeignFoo.class) { }; QueryBuilder<ForeignFoo, Integer> qb = foreignDao.queryBuilder(); qb.selectColumns(ID_COLUMN_NAME, FOREIGN_COLUMN_NAME); where.in(ID_COLUMN_NAME, qb); }
@Test public void testBasic() throws SQLException { TableInfo<Foo, String> tableInfo = new TableInfo<Foo, String>(databaseType, Foo.class); assertEquals(Foo.class, tableInfo.getDataClass()); assertEquals(TABLE_NAME, tableInfo.getTableName()); assertEquals(COLUMN_NAME, tableInfo.getIdField().getColumnName()); assertEquals(1, tableInfo.getFieldTypes().length); assertSame(tableInfo.getIdField(), tableInfo.getFieldTypes()[0]); assertEquals(COLUMN_NAME, tableInfo.getFieldTypeByColumnName(COLUMN_NAME).getColumnName()); }