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