001package com.avaje.ebean;
002
003import com.avaje.ebean.cache.ServerCacheManager;
004import com.avaje.ebean.meta.MetaInfoManager;
005import com.avaje.ebean.plugin.SpiServer;
006import com.avaje.ebean.text.csv.CsvReader;
007import com.avaje.ebean.text.json.JsonContext;
008
009import javax.persistence.OptimisticLockException;
010import javax.persistence.PersistenceException;
011import java.util.ArrayList;
012import java.util.Collection;
013import java.util.List;
014import java.util.Map;
015import java.util.Set;
016
017/**
018 * Test double for EbeanServer.
019 */
020public class TDEbeanServer implements EbeanServer {
021
022  public List deletedBeans = new ArrayList();
023
024  public List savedBeans = new ArrayList();
025
026  @Override
027  public void shutdown(boolean shutdownDataSource, boolean deregisterDriver) {
028
029  }
030
031  @Override
032  public DocumentStore docStore() {
033    return null;
034  }
035
036  @Override
037  public SpiServer getPluginApi() {
038    return null;
039  }
040
041  @Override
042  public AutoTune getAutoTune() {
043    return null;
044  }
045
046  @Override
047  public String getName() {
048    return null;
049  }
050
051  @Override
052  public ExpressionFactory getExpressionFactory() {
053    return null;
054  }
055
056  @Override
057  public MetaInfoManager getMetaInfoManager() {
058    return null;
059  }
060
061  @Override
062  public BeanState getBeanState(Object bean) {
063    return null;
064  }
065
066  @Override
067  public Object getBeanId(Object bean) {
068    return null;
069  }
070
071  @Override
072  public Object setBeanId(Object bean, Object id) {
073    return id;
074  }
075
076  @Override
077  public Map<String, ValuePair> diff(Object a, Object b) {
078    return null;
079  }
080
081  @Override
082  public <T> T createEntityBean(Class<T> type) {
083    return null;
084  }
085
086  @Override
087  public <T> CsvReader<T> createCsvReader(Class<T> beanType) {
088    return null;
089  }
090
091  @Override
092  public <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
093    return null;
094  }
095
096  @Override
097  public <T> Query<T> createQuery(Class<T> beanType, String eql) {
098    return null;
099  }
100
101  @Override
102  public <T> Query<T> createQuery(Class<T> beanType) {
103    return null;
104  }
105
106  @Override
107  public <T> Query<T> find(Class<T> beanType) {
108    return null;
109  }
110
111  @Override
112  public Object nextId(Class<?> beanType) {
113    return null;
114  }
115
116  @Override
117  public <T> Filter<T> filter(Class<T> beanType) {
118    return null;
119  }
120
121  @Override
122  public <T> void sort(List<T> list, String sortByClause) {
123
124  }
125
126  @Override
127  public <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) {
128    return null;
129  }
130
131  @Override
132  public SqlQuery createSqlQuery(String sql) {
133    return null;
134  }
135
136  @Override
137  public SqlUpdate createSqlUpdate(String sql) {
138    return null;
139  }
140
141  @Override
142  public CallableSql createCallableSql(String callableSql) {
143    return null;
144  }
145
146  @Override
147  public void register(TransactionCallback transactionCallback) throws PersistenceException {
148
149  }
150
151  @Override
152  public Transaction createTransaction() {
153    return null;
154  }
155
156  @Override
157  public Transaction createTransaction(TxIsolation isolation) {
158    return null;
159  }
160
161  @Override
162  public Transaction beginTransaction() {
163    return null;
164  }
165
166  @Override
167  public Transaction beginTransaction(TxIsolation isolation) {
168    return null;
169  }
170
171  @Override
172  public Transaction beginTransaction(TxScope scope) {
173    return null;
174  }
175
176  @Override
177  public Transaction currentTransaction() {
178    return null;
179  }
180
181  @Override
182  public void commitTransaction() {
183
184  }
185
186  @Override
187  public void rollbackTransaction() {
188
189  }
190
191  @Override
192  public void endTransaction() {
193
194  }
195
196  @Override
197  public void refresh(Object bean) {
198
199  }
200
201  @Override
202  public void refreshMany(Object bean, String propertyName) {
203
204  }
205
206  @Override
207  public <T> T find(Class<T> beanType, Object id) {
208    return null;
209  }
210
211  @Override
212  public <T> T getReference(Class<T> beanType, Object id) {
213    return null;
214  }
215
216  @Override
217  public <T> int findRowCount(Query<T> query, Transaction transaction) {
218    return 0;
219  }
220
221  @Override
222  public <T> List<Object> findIds(Query<T> query, Transaction transaction) {
223    return null;
224  }
225
226  @Override
227  public <T> void findEach(Query<T> query, QueryEachConsumer<T> consumer, Transaction transaction) {
228
229  }
230
231  @Override
232  public <T> void findEachWhile(Query<T> query, QueryEachWhileConsumer<T> consumer, Transaction transaction) {
233
234  }
235
236  @Override
237  public <T> List<T> findList(Query<T> query, Transaction transaction) {
238    return null;
239  }
240
241  @Override
242  public <T> FutureRowCount<T> findFutureRowCount(Query<T> query, Transaction transaction) {
243    return null;
244  }
245
246  @Override
247  public <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction) {
248    return null;
249  }
250
251  @Override
252  public <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction) {
253    return null;
254  }
255
256  @Override
257  public <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction) {
258    return null;
259  }
260
261  @Override
262  public <T> Set<T> findSet(Query<T> query, Transaction transaction) {
263    return null;
264  }
265
266  @Override
267  public <T> Map<?, T> findMap(Query<T> query, Transaction transaction) {
268    return null;
269  }
270
271  @Override
272  public <T> T findUnique(Query<T> query, Transaction transaction) {
273    return null;
274  }
275
276  @Override
277  public List<SqlRow> findList(SqlQuery query, Transaction transaction) {
278    return null;
279  }
280
281  @Override
282  public SqlRow findUnique(SqlQuery query, Transaction transaction) {
283    return null;
284  }
285
286  @Override
287  public void findEach(SqlQuery sqlQuery, QueryEachConsumer<SqlRow> queryEachConsumer, Transaction transaction) {
288
289  }
290
291  @Override
292  public void findEachWhile(SqlQuery sqlQuery, QueryEachWhileConsumer<SqlRow> queryEachWhileConsumer, Transaction transaction) {
293
294  }
295
296  @Override
297  public <T> List<Version<T>> findVersions(Query<T> query, Transaction transaction) {
298    return null;
299  }
300
301  @Override
302  public <T> Set<String> validateQuery(Query<T> query) {
303    return null;
304  }
305
306  @Override
307  public void save(Object bean) throws OptimisticLockException {
308    savedBeans.add(bean);
309  }
310
311  @Override
312  public int saveAll(Collection<?> beans) throws OptimisticLockException {
313    savedBeans.addAll(beans);
314    return 0;
315  }
316
317  @Override
318  public boolean delete(Object bean) throws OptimisticLockException {
319    deletedBeans.add(bean);
320    return false;
321  }
322
323  @Override
324  public int deleteAll(Collection<?> c) throws OptimisticLockException {
325    deletedBeans.addAll(c);
326    return 0;
327  }
328
329  @Override
330  public <T> int delete(Query<T> query, Transaction transaction) {
331    return 0;
332  }
333
334  @Override
335  public int deleteAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
336    return 0;
337  }
338
339  @Override
340  public int delete(Class<?> beanType, Object id) {
341    return 0;
342  }
343
344  @Override
345  public int delete(Class<?> beanType, Object id, Transaction transaction) {
346    return 0;
347  }
348
349  @Override
350  public int deletePermanent(Class<?> beanType, Object id) {
351    return 0;
352  }
353
354  @Override
355  public int deletePermanent(Class<?> beanType, Object id, Transaction transaction) {
356    return 0;
357  }
358
359  @Override
360  public int deleteAll(Class<?> beanType, Collection<?> ids) {
361    return 0;
362  }
363
364  @Override
365  public int deleteAll(Class<?> beanType, Collection<?> ids, Transaction transaction) {
366    return 0;
367  }
368
369  @Override
370  public int deleteAllPermanent(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
371    return 0;
372  }
373
374  @Override
375  public boolean deletePermanent(Object bean) throws OptimisticLockException {
376    return false;
377  }
378
379  @Override
380  public boolean deletePermanent(Object bean, Transaction transaction) throws OptimisticLockException {
381    return false;
382  }
383
384  @Override
385  public int deleteAllPermanent(Collection<?> beans) throws OptimisticLockException {
386    return 0;
387  }
388
389  @Override
390  public int deleteAllPermanent(Class<?> beanType, Collection<?> ids) {
391    return 0;
392  }
393
394  @Override
395  public int deleteAllPermanent(Class<?> beanType, Collection<?> ids, Transaction transaction) {
396    return 0;
397  }
398
399  @Override
400  public int execute(SqlUpdate sqlUpdate) {
401    return 0;
402  }
403
404  @Override
405  public int execute(Update<?> update) {
406    return 0;
407  }
408
409  @Override
410  public int execute(Update<?> update, Transaction t) {
411    return 0;
412  }
413
414  @Override
415  public int execute(CallableSql callableSql) {
416    return 0;
417  }
418
419  @Override
420  public void externalModification(String tableName, boolean inserted, boolean updated, boolean deleted) {
421
422  }
423
424  @Override
425  public <T> T publish(Class<T> beanType, Object id, Transaction transaction) {
426    return null;
427  }
428
429  @Override
430  public <T> T publish(Class<T> beanType, Object id) {
431    return null;
432  }
433
434  @Override
435  public <T> List<T> publish(Query<T> query, Transaction transaction) {
436    return null;
437  }
438
439  @Override
440  public <T> List<T> publish(Query<T> query) {
441    return null;
442  }
443
444  @Override
445  public <T> T draftRestore(Class<T> beanType, Object id, Transaction transaction) {
446    return null;
447  }
448
449  @Override
450  public <T> T draftRestore(Class<T> beanType, Object id) {
451    return null;
452  }
453
454  @Override
455  public <T> List<T> draftRestore(Query<T> query, Transaction transaction) {
456    return null;
457  }
458
459  @Override
460  public <T> List<T> draftRestore(Query<T> query) {
461    return null;
462  }
463
464  @Override
465  public <T> T find(Class<T> beanType, Object uid, Transaction transaction) {
466    return null;
467  }
468
469  @Override
470  public void save(Object bean, Transaction transaction) throws OptimisticLockException {
471    savedBeans.add(bean);
472  }
473
474  @Override
475  public int saveAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
476    savedBeans.addAll(beans);
477    return 0;
478  }
479
480  @Override
481  public void markAsDirty(Object bean) {
482
483  }
484
485  @Override
486  public <T> UpdateQuery<T> update(Class<T> beanType) {
487    return null;
488  }
489
490  @Override
491  public <T> int update(Query<T> query, Transaction transaction) {
492    return 0;
493  }
494
495  @Override
496  public void update(Object bean) throws OptimisticLockException {
497
498  }
499
500  @Override
501  public void update(Object bean, Transaction t) throws OptimisticLockException {
502
503  }
504
505  @Override
506  public void update(Object bean, Transaction transaction, boolean deleteMissingChildren) throws OptimisticLockException {
507
508  }
509
510  @Override
511  public void updateAll(Collection<?> beans) throws OptimisticLockException {
512
513  }
514
515  @Override
516  public void updateAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
517
518  }
519
520  @Override
521  public void insert(Object bean) {
522
523  }
524
525  @Override
526  public void insert(Object bean, Transaction t) {
527
528  }
529
530  @Override
531  public void insertAll(Collection<?> beans) {
532
533  }
534
535  @Override
536  public void insertAll(Collection<?> beans, Transaction t) {
537
538  }
539
540  @Override
541  public boolean delete(Object bean, Transaction t) throws OptimisticLockException {
542    return false;
543  }
544
545  @Override
546  public int execute(SqlUpdate updSql, Transaction t) {
547    return 0;
548  }
549
550  @Override
551  public int execute(CallableSql callableSql, Transaction t) {
552    return 0;
553  }
554
555  @Override
556  public void execute(TxScope scope, TxRunnable r) {
557
558  }
559
560  @Override
561  public void execute(TxRunnable r) {
562
563  }
564
565  @Override
566  public <T> T execute(TxScope scope, TxCallable<T> c) {
567    return null;
568  }
569
570  @Override
571  public <T> T execute(TxCallable<T> c) {
572    return null;
573  }
574
575  @Override
576  public ServerCacheManager getServerCacheManager() {
577    return null;
578  }
579
580  @Override
581  public BackgroundExecutor getBackgroundExecutor() {
582    return null;
583  }
584
585  @Override
586  public JsonContext json() {
587    return null;
588  }
589}