src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
IntQueue { public int indexOf (int value) { if (size == 0) return -1; int[] values = this.values; final int head = this.head, tail = this.tail; if (head < tail) { for (int i = head; i < tail; i++) if (values[i] == value) return i - head; } else { for (int i = head, n = values.length; i < n; i++) if (values[i] == value) return i - head; for (int i = 0; i < tail; i++) if (values[i] == value) return i + values.length - head; } return -1; } IntQueue(); IntQueue(int initialSize); void addLast(int object); void addFirst(int object); void ensureCapacity(int additional); int removeFirst(); int removeLast(); int indexOf(int value); boolean removeValue(int value); int removeIndex(int index); boolean notEmpty(); boolean isEmpty(); int first(); int last(); int get(int index); void clear(); Iterator<Integer> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
|
@Test public void indexOfTest () { final IntQueue q = new IntQueue(); for (int j = 0; j <= 6; j++) q.addLast(j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf(j), j); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst(j); for (int j = 3; j <= 6; j++) q.addLast(j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf(j), j); }
|
IntQueue { public Iterator<Integer> iterator () { if (iterable == null) iterable = new IntQueueIterable(this); return iterable.iterator(); } IntQueue(); IntQueue(int initialSize); void addLast(int object); void addFirst(int object); void ensureCapacity(int additional); int removeFirst(); int removeLast(); int indexOf(int value); boolean removeValue(int value); int removeIndex(int index); boolean notEmpty(); boolean isEmpty(); int first(); int last(); int get(int index); void clear(); Iterator<Integer> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
|
@Test public void iteratorTest () { final IntQueue q = new IntQueue(); for (int j = 0; j <= 6; j++) q.addLast(j); Iterator<Integer> iter = q.iterator(); for (int j = 0; j <= 6; j++) assertEquals(iter.next().intValue(), j); iter = q.iterator(); iter.next(); iter.remove(); assertValues(q, 1, 2, 3, 4, 5, 6); iter.next(); iter.remove(); assertValues(q, 2, 3, 4, 5, 6); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5, 6); iter.next(); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst(j); for (int j = 3; j <= 6; j++) q.addLast(j); iter = q.iterator(); for (int j = 0; j <= 6; j++) assertEquals(iter.next().intValue(), j); iter = q.iterator(); iter.next(); iter.remove(); assertValues(q, 1, 2, 3, 4, 5, 6); iter.next(); iter.remove(); assertValues(q, 2, 3, 4, 5, 6); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5, 6); iter.next(); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5); }
|
IntQueue { public String toString () { if (size == 0) { return "[]"; } final int[] values = this.values; final int head = this.head; final int tail = this.tail; StringBuilder sb = new StringBuilder(64); sb.append('['); sb.append(values[head]); for (int i = (head + 1) % values.length; i != tail; i = (i + 1) % values.length) { sb.append(", ").append(values[i]); } sb.append(']'); return sb.toString(); } IntQueue(); IntQueue(int initialSize); void addLast(int object); void addFirst(int object); void ensureCapacity(int additional); int removeFirst(); int removeLast(); int indexOf(int value); boolean removeValue(int value); int removeIndex(int index); boolean notEmpty(); boolean isEmpty(); int first(); int last(); int get(int index); void clear(); Iterator<Integer> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
|
@Test public void toStringTest () { IntQueue q = new IntQueue(1); assertEquals("[]", q.toString()); q.addLast(4); assertEquals("[4]", q.toString()); q.addLast(5); q.addLast(6); q.addLast(7); assertEquals("[4, 5, 6, 7]", q.toString()); }
|
ConcurrentCharArray extends CharArray implements ConcurrentCollection { @Override public void add(char value) { lock.lockWrite(); super.add(value); lock.unlockWrite(); } ConcurrentCharArray(); ConcurrentCharArray(int capacity); ConcurrentCharArray(boolean ordered, int capacity); ConcurrentCharArray(CharArray array); ConcurrentCharArray(char[] array); ConcurrentCharArray(boolean ordered, char[] array, int startIndex, int count); @Override void add(char value); @Override void add(char value1, char value2); @Override void add(char value1, char value2, char value3); @Override void add(char value1, char value2, char value3, char value4); @Override void addAll(char[] array, int offset, int length); @Override char get(int index); @Override void set(int index, char value); @Override void insert(int index, char value); @Override void swap(int first, int second); @Override char removeIndex(int index); @Override void removeRange(int start, int end); @Override char pop(); @Override char peek(); @Override char first(); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void clear(); @Override char[] shrink(); @Override char[] ensureCapacity(int additionalCapacity); @Override char[] setSize(int newSize); @Override void reverse(); @Override void shuffle(); @Override void addAll(CharArray array, int offset, int length); @Override void incr(int index, char value); @Override void mul(int index, char value); @Override boolean contains(char value); @Override int indexOf(char value); @Override int lastIndexOf(char value); @Override boolean removeValue(char value); @Override boolean removeAll(CharArray array); @Override void sort(); @Override void truncate(int newSize); @Override char random(); @Override char[] toArray(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); @Override String toString(String separator); @Override ReadWriteLock getLock(); }
|
@Test public void testAddItems() { ConcurrentCharArray a = new ConcurrentCharArray(); CountDownLatch latch = new CountDownLatch(100); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 100; i++) { a.add((char)i); } } }, 100); assertEquals(a.size, 10*1000); }
|
ConcurrentFloatArray extends FloatArray implements ConcurrentCollection { @Override public void add(float value) { lock.lockWrite(); super.add(value); lock.unlockWrite(); } ConcurrentFloatArray(); ConcurrentFloatArray(int capacity); ConcurrentFloatArray(boolean ordered, int capacity); ConcurrentFloatArray(FloatArray array); ConcurrentFloatArray(float[] array); ConcurrentFloatArray(boolean ordered, float[] array, int startIndex, int count); @Override void add(float value); @Override void add(float value1, float value2); @Override void add(float value1, float value2, float value3); @Override void add(float value1, float value2, float value3, float value4); @Override void addAll(FloatArray array, int offset, int length); @Override void addAll(float[] array, int offset, int length); @Override float get(int index); @Override void set(int index, float value); @Override void incr(int index, float value); @Override void mul(int index, float value); @Override void insert(int index, float value); @Override void swap(int first, int second); @Override boolean contains(float value); @Override int indexOf(float value); @Override int lastIndexOf(char value); @Override boolean removeValue(float value); @Override float removeIndex(int index); @Override void removeRange(int start, int end); @Override boolean removeAll(FloatArray array); @Override float pop(); @Override float peek(); @Override float first(); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void clear(); @Override float[] shrink(); @Override float[] ensureCapacity(int additionalCapacity); @Override float[] setSize(int newSize); @Override void sort(); @Override void reverse(); @Override void shuffle(); @Override void truncate(int newSize); @Override float random(); @Override float[] toArray(); @Override int hashCode(); @Override boolean equals(Object object); @Override boolean equals(Object object, float epsilon); @Override String toString(); @Override String toString(String separator); @Override ReadWriteLock getLock(); }
|
@Test public void testAddItems() { ConcurrentFloatArray a = new ConcurrentFloatArray(); CountDownLatch latch = new CountDownLatch(100); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 100; i++) { a.add(i); } } }, 100); assertEquals(a.size, 10*1000); }
|
ConcurrentDelayedRemovalArray extends DelayedRemovalArray<T> implements ConcurrentCollection { @Override public void add(T value) { lock.lockWrite(); super.add(value); lock.unlockWrite(); } ConcurrentDelayedRemovalArray(); ConcurrentDelayedRemovalArray(Array<? extends T> array); ConcurrentDelayedRemovalArray(boolean ordered, int capacity, Class arrayType); ConcurrentDelayedRemovalArray(boolean ordered, int capacity); ConcurrentDelayedRemovalArray(boolean ordered, T[] array, int startIndex, int count); ConcurrentDelayedRemovalArray(Class arrayType); ConcurrentDelayedRemovalArray(int capacity); ConcurrentDelayedRemovalArray(T[] array); @Override void begin(); @Override void end(); @Override boolean removeValue(T value, boolean identity); @Override T removeIndex(int index); @Override void removeRange(int start, int end); @Override void clear(); @Override void set(int index, T value); @Override void insert(int index, T value); @Override void swap(int first, int second); @Override T pop(); @Override void sort(); @Override void sort(Comparator<? super T> comparator); @Override void reverse(); @Override void shuffle(); @Override void truncate(int newSize); @Override T[] setSize(int newSize); @Override void add(T value); @Override void add(T value1, T value2); @Override void add(T value1, T value2, T value3); @Override void add(T value1, T value2, T value3, T value4); @Override void addAll(Array<? extends T> array, int start, int count); @Override void addAll(T[] array, int start, int count); @Override T get(int index); @Override boolean contains(T value, boolean identity); @Override boolean containsAll(Array<? extends T> values, boolean identity); @Override boolean containsAny(Array<? extends T> values, boolean identity); @Override int indexOf(T value, boolean identity); @Override int lastIndexOf(T value, boolean identity); @Override boolean removeAll(Array<? extends T> array, boolean identity); @Override T peek(); @Override T first(); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override T[] shrink(); @Override T[] ensureCapacity(int additionalCapacity); @Override T selectRanked(Comparator<T> comparator, int kthLowest); @Override int selectRankedIndex(Comparator<T> comparator, int kthLowest); @Override Iterator<T> iterator(); @Override Iterable<T> select(Predicate<T> predicate); @Override T random(); @Override T[] toArray(); @Override V[] toArray(Class<V> type); @Override int hashCode(); @Override boolean equals(Object object); @Override boolean equalsIdentity(Object object); @Override String toString(); @Override String toString(String separator); @Override ReadWriteLock getLock(); }
|
@Test public void testAddItems() { ConcurrentDelayedRemovalArray<Integer> a = new ConcurrentDelayedRemovalArray<>(); CountDownLatch latch = new CountDownLatch(100); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 100; i++) { a.add(i); } } }, 100); assertEquals(a.size, 10*1000); }
|
ConcurrentSnapshotArray extends SnapshotArray<T> implements ConcurrentCollection { @Override public void add(T value) { lock.lockWrite(); super.add(value); lock.unlockWrite(); } ConcurrentSnapshotArray(); ConcurrentSnapshotArray(Array array); ConcurrentSnapshotArray(boolean ordered, int capacity, Class arrayType); ConcurrentSnapshotArray(boolean ordered, int capacity); ConcurrentSnapshotArray(boolean ordered, T[] array, int startIndex, int count); ConcurrentSnapshotArray(Class arrayType); ConcurrentSnapshotArray(int capacity); ConcurrentSnapshotArray(T[] array); @Override void add(T value); @Override void add(T value1, T value2); @Override void add(T value1, T value2, T value3); @Override void add(T value1, T value2, T value3, T value4); @Override void addAll(Array<? extends T> array, int start, int count); @Override void addAll(T[] array, int start, int count); @Override T get(int index); @Override void set(int index, T value); @Override void insert(int index, T value); @Override void swap(int first, int second); @Override boolean contains(T value, boolean identity); @Override boolean containsAll(Array<? extends T> values, boolean identity); @Override boolean containsAny(Array<? extends T> values, boolean identity); @Override boolean removeValue(T value, boolean identity); @Override boolean removeAll(Array<? extends T> array, boolean identity); @Override T selectRanked(Comparator<T> comparator, int kthLowest); @Override int selectRankedIndex(Comparator<T> comparator, int kthLowest); @Override Iterable<T> select(Predicate<T> predicate); @Override int indexOf(T value, boolean identity); @Override int lastIndexOf(T value, boolean identity); @Override T removeIndex(int index); @Override void removeRange(int start, int end); @Override T pop(); @Override T peek(); @Override T first(); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void clear(); @Override Iterator<T> iterator(); @Override T[] shrink(); @Override T[] ensureCapacity(int additionalCapacity); @Override T[] setSize(int newSize); @Override void reverse(); @Override void shuffle(); @Override void truncate(int newSize); @Override T random(); @Override T[] toArray(); @Override V[] toArray(Class<V> type); @Override int hashCode(); @Override boolean equals(Object object); @Override T[] begin(); @Override void end(); @Override void sort(); @Override void sort(Comparator<? super T> comparator); @Override boolean equalsIdentity(Object object); @Override String toString(); @Override String toString(String separator); @Override ReadWriteLock getLock(); }
|
@Test public void testAddItems() { ConcurrentSnapshotArray<Integer> a = new ConcurrentSnapshotArray<>(); CountDownLatch latch = new CountDownLatch(100); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 100; i++) { a.add(i); } } }, 100); assertEquals(a.size, 100*100); }
|
ConcurrentShortArray extends ShortArray implements ConcurrentCollection { @Override public void add(short value) { lock.lockWrite(); super.add(value); lock.unlockWrite(); } ConcurrentShortArray(); ConcurrentShortArray(int capacity); ConcurrentShortArray(boolean ordered, int capacity); ConcurrentShortArray(Short array); ConcurrentShortArray(short[] array); ConcurrentShortArray(boolean ordered, short[] array, int startIndex, int count); ConcurrentShortArray(ShortArray array); @Override void add(short value); @Override void add(int value); @Override void add(short value1, short value2); @Override void add(short value1, short value2, short value3); @Override void add(short value1, short value2, short value3, short value4); @Override void addAll(ShortArray array, int offset, int length); @Override void addAll(short[] array, int offset, int length); @Override short get(int index); @Override void set(int index, short value); @Override void incr(int index, short value); @Override void mul(int index, short value); @Override void insert(int index, short value); @Override void swap(int first, int second); @Override boolean contains(short value); @Override int indexOf(short value); @Override int lastIndexOf(char value); @Override boolean removeValue(short value); @Override short removeIndex(int index); @Override void removeRange(int start, int end); @Override boolean removeAll(ShortArray array); @Override short pop(); @Override short peek(); @Override short first(); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void clear(); @Override short[] shrink(); @Override short[] ensureCapacity(int additionalCapacity); @Override short[] setSize(int newSize); @Override void sort(); @Override void reverse(); @Override void shuffle(); @Override void truncate(int newSize); @Override short random(); @Override short[] toArray(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); @Override String toString(String separator); @Override ReadWriteLock getLock(); }
|
@Test public void testAddItems() { ConcurrentShortArray a = new ConcurrentShortArray(); CountDownLatch latch = new CountDownLatch(10); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 1000; i++) { a.add(i); } } }, 10); assertEquals(a.size, 10*1000); }
|
ConcurrentIntSet extends IntSet implements ConcurrentCollection { @Override public boolean add(int key) { lock.lockWrite(); boolean b = super.add(key); lock.unlockWrite(); return b; } ConcurrentIntSet(); ConcurrentIntSet(int initialCapacity); ConcurrentIntSet(int initialCapacity, float loadFactor); ConcurrentIntSet(IntSet set); @Override boolean add(int key); @Override void addAll(IntArray array, int offset, int length); @Override void addAll(int[] array, int offset, int length); @Override void addAll(IntSet set); @Override boolean remove(int key); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void shrink(int maximumCapacity); @Override void clear(int maximumCapacity); @Override void clear(); @Override boolean contains(int key); @Override int first(); @Override void ensureCapacity(int additionalCapacity); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override IntSetIterator iterator(); @Override ReadWriteLock getLock(); }
|
@Test public void testAdd() { ConcurrentIntSet set = new ConcurrentIntSet(); Random r = new Random(); CountDownLatch latch = new CountDownLatch(1000); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } while (!set.add(r.nextInt())){ } } }, 1000); assertEquals(1000, set.size); }
|
MuxFs extends MirrorFs { @Override public int getattr(String path, StatFiller stat) { logger.debug(path); if (!path.endsWith(".mkv")) { return super.getattr(path, stat); } Path muxFile = real(path); return tryCatchRunnable.apply(() -> { stat.statWithSize(muxFile, info -> Optional.ofNullable(muxedSizeCache.getIfPresent(info)), () -> Try.withCatch(() -> extraSizeCache.get(muxFile)).get()); }); } MuxFs(Path mirroredPath, Path tempDir); @VisibleForTesting MuxFs(Path mirroredPath, Path tempDir, MuxerFactory muxerFactory, Sleeper sleeper, FileChannelCloser fileChannelCloser, ExecutorService executorService); @Override String getFSName(); @Override int readdir(String path, DirectoryFiller filler); @Override int getattr(String path, StatFiller stat); @Override // TODO: Multiple SRT file support int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testGetAttrForMkvWithMatchingSrtHasExtraSize() throws Exception { StatFiller stat = mock(StatFiller.class); Path mkv = mockPath("file.mkv", 38445L); Path srt1 = mockPath("file.eng.srt", 2893756L); Path srt2 = mockPath("file.der.srt", 2345L); Path srt3 = mockPath("file.swe.srt", 78568L); mockDirectoryStream(mirrorRoot, srt1, mkv, srt3, srt2); mockAttributes(mkv, 758, 38445L); when(stat.statWithSize(eq(mkv), sizeGetterCaptor.capture(), extraSizeGetterCaptor.capture())).thenReturn(mock(UnixFileStat.class)); int result = fs.getattr("file.mkv", stat); assertThat(result).isEqualTo(SUCCESS); verify(stat).statWithSize(eq(mkv), any(), any()); verifyNoMoreInteractions(stat); assertThat(sizeGetterCaptor.getValue().apply(FileInfo.of(mkv))).isEmpty(); assertThat(extraSizeGetterCaptor.getValue().get()).isEqualTo(2893756L + 2345L + 78568L); }
@Test public void testGetAttrManyFiles() throws Exception { StatFiller stat = mock(StatFiller.class); Path mkv1 = mockPath("file1.mkv", 6736L); Path mkv1txt1 = mockPath("file1.txt", 123456789L); Path mkv1srt1 = mockPath("file1.eng.srt", 2893756L); Path mkv1srt2 = mockPath("file1.der.srt", 2345L); Path mkv1srt3 = mockPath("file1.swe.srt", 78568L); Path mkv2 = mockPath("file2.mkv"); Path mkv3srt1 = mockPath("file3.srt", 324685L); Path mkv4 = mockPath("file4.mkv"); Path mkv4txt1 = mockPath("file4.txt", 4725L); Path mkv4srt1 = mockPath("file4.esp.srt", 235468L); Path mkv4srt2 = mockPath("file4.klingon.srt", 62369L); Path mkv4srt3 = mockPath("file4.elvish.srt", 468L); mockShuffledDirectoryStream(mirrorRoot, mkv1txt1, mkv1srt1, mkv1, mkv1srt3, mkv1srt2, mkv2, mkv3srt1, mkv4, mkv4txt1, mkv4srt1, mkv4srt2, mkv4srt3); mockAttributes(mkv1, 1234, 6736L); when(stat.statWithSize(eq(mkv1), sizeGetterCaptor.capture(), extraSizeGetterCaptor.capture())).thenReturn(mock(UnixFileStat.class)); int result = fs.getattr("file1.mkv", stat); assertThat(result).isEqualTo(SUCCESS); verify(stat).statWithSize(eq(mkv1), any(), any()); verifyNoMoreInteractions(stat); assertThat(sizeGetterCaptor.getValue().apply(FileInfo.of(mkv1))).isEmpty(); assertThat(extraSizeGetterCaptor.getValue().get()).isEqualTo(2893756L + 2345L + 78568L); }
@Test public void testMuxedFileSizeCacheIsEmptyBeforeMuxing() throws Exception { mux2fs = new MuxFs(mirrorRoot, tempDir, muxerFactory, sleeper, fileChannelCloser, MoreExecutors.newDirectExecutorService()); fs = mux2fs; StatFiller stat = mock(StatFiller.class); Path mkv = mockPath("file.mkv", 700000000L); Path srt = mockPath("file.srt", 2000L); mockDirectoryStream(mirrorRoot, srt, mkv); when(stat.statWithSize(eq(mkv), sizeGetterCaptor.capture(), extraSizeGetterCaptor.capture())).thenReturn(mock(UnixFileStat.class)); mockAttributes(mkv, 234); FileInfo info = FileInfo.of(mkv); int result = fs.getattr("file.mkv", stat); assertThat(result).isEqualTo(SUCCESS); verify(stat).statWithSize(eq(mkv), any(), any()); verifyNoMoreInteractions(stat); assertThat(sizeGetterCaptor.getValue().apply(info)).isEmpty(); assertThat(extraSizeGetterCaptor.getValue().get()).isEqualTo(2000L); }
|
MirrorFs implements se.tfiskgul.mux2fs.fs.base.FileSystem { @Override public int getattr(String path, StatFiller stat) { logger.debug(path); return tryCatchRunnable.apply(() -> stat.stat(real(path))); } MirrorFs(Path mirroredPath); @VisibleForTesting protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser); @Override String getFSName(); @Override int getattr(String path, StatFiller stat); @Override int readdir(String path, DirectoryFiller filler); @Override int readLink(String path, Consumer<String> buf, int size); @Override int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testGetAttrSubDir() throws Exception { StatFiller stat = mock(StatFiller.class); Path foo = mockPath("/foo"); int result = fs.getattr("/foo", stat); assertThat(result).isEqualTo(SUCCESS); verify(stat).stat(foo); }
@Test public void testGetAttr() throws Exception { StatFiller stat = mock(StatFiller.class); when(fileSystem.getPath(mirrorRoot.toString(), "/")).thenReturn(mirrorRoot); int result = fs.getattr("/", stat); assertThat(result).isEqualTo(SUCCESS); verify(stat).stat(mirrorRoot); }
|
MirrorFs implements se.tfiskgul.mux2fs.fs.base.FileSystem { @Override public int readdir(String path, DirectoryFiller filler) { Path realPath = readdirInitial(path, filler); return tryCatch.apply(() -> { try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(realPath)) { for (Path entry : directoryStream) { if (!add(filler, entry)) { return SUCCESS; } } } return SUCCESS; }); } MirrorFs(Path mirroredPath); @VisibleForTesting protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser); @Override String getFSName(); @Override int getattr(String path, StatFiller stat); @Override int readdir(String path, DirectoryFiller filler); @Override int readLink(String path, Consumer<String> buf, int size); @Override int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testReadDir() throws Exception { Path foo = mockPath("foo"); Path bar = mockPath("bar"); mockDirectoryStream(mirrorRoot, foo, bar); DirectoryFiller filler = mock(DirectoryFiller.class); int result = fs.readdir("/", filler); assertThat(result).isEqualTo(SUCCESS); verify(fileSystem.provider()).newDirectoryStream(eq(mirrorRoot), any()); verify(filler).add(".", mirrorRoot); verify(filler).add("..", mirrorRoot); verify(filler).add("foo", foo); verify(filler).add("bar", bar); verifyNoMoreInteractions(filler); }
|
MirrorFs implements se.tfiskgul.mux2fs.fs.base.FileSystem { protected Optional<String> getFileName(Path entry) { return Optional.ofNullable(entry).flatMap(notNull -> Optional.ofNullable(notNull.getFileName())).map(Object::toString); } MirrorFs(Path mirroredPath); @VisibleForTesting protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser); @Override String getFSName(); @Override int getattr(String path, StatFiller stat); @Override int readdir(String path, DirectoryFiller filler); @Override int readLink(String path, Consumer<String> buf, int size); @Override int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testGetFileNameOnNullPathIsEmpty() throws Exception { assertThat(new MirrorFs(mirrorRoot).getFileName(null)).isEmpty(); }
@Test public void testGetFileNameOnNullFileNameIsEmpty() throws Exception { assertThat(new MirrorFs(mirrorRoot).getFileName(mock(Path.class))).isEmpty(); }
|
MirrorFs implements se.tfiskgul.mux2fs.fs.base.FileSystem { @Override public int open(String path, FileHandleFiller filler) { logger.info(path); return openReal(real(path), filler); } MirrorFs(Path mirroredPath); @VisibleForTesting protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser); @Override String getFSName(); @Override int getattr(String path, StatFiller stat); @Override int readdir(String path, DirectoryFiller filler); @Override int readLink(String path, Consumer<String> buf, int size); @Override int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testOpen() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); Path fooBar = mockPath("foo.bar"); when(fileSystem.provider().newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); int result = fs.open("foo.bar", filler); assertThat(result).isEqualTo(SUCCESS); verify(filler).setFileHandle(gt(0)); verifyNoMoreInteractions(filler); verify(fileSystem.provider()).newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ))); verifyNoMoreInteractions(fileSystem.provider()); }
@Test public void testOpenFileHandleIsUnique() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); ArgumentCaptor<Integer> handleCaptor = ArgumentCaptor.forClass(Integer.class); doNothing().when(filler).setFileHandle(handleCaptor.capture()); Path fooBar = mockPath("foo.bar"); when(fileSystem.provider().newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); int result = fs.open("foo.bar", filler); result += fs.open("foo.bar", filler); result += fs.open("foo.bar", filler); assertThat(result).isEqualTo(SUCCESS); verify(filler, times(3)).setFileHandle(gt(0)); verifyNoMoreInteractions(filler); verify(fileSystem.provider(), times(3)).newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ))); verifyNoMoreInteractions(fileSystem.provider()); assertThat(handleCaptor.getAllValues()).hasSize(3).doesNotHaveDuplicates(); }
|
MirrorFs implements se.tfiskgul.mux2fs.fs.base.FileSystem { @Override public int release(String path, int fileHandle) { logger.info("release({}, {})", fileHandle, path); FileChannel fileChannel = openFiles.remove(fileHandle); if (fileChannel == null) { return -ErrorCodes.EBADF(); } safeClose(fileChannel); return SUCCESS; } MirrorFs(Path mirroredPath); @VisibleForTesting protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser); @Override String getFSName(); @Override int getattr(String path, StatFiller stat); @Override int readdir(String path, DirectoryFiller filler); @Override int readLink(String path, Consumer<String> buf, int size); @Override int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testReleaseNegativeFileHandle() { int result = fs.release("foo.bar", -23); assertThat(result).isEqualTo(-ErrorCodes.EBADF()); }
@Test public void testReleaseNonOpenedFileHandle() { int result = fs.release("foo.bar", 23); assertThat(result).isEqualTo(-ErrorCodes.EBADF()); }
@Test public void testRelease() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); ArgumentCaptor<Integer> handleCaptor = ArgumentCaptor.forClass(Integer.class); doNothing().when(filler).setFileHandle(handleCaptor.capture()); Path fooBar = mockPath(mirrorRoot, "foo.bar"); when(fileSystem.provider().newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); fs.open("foo.bar", filler); int result = fs.release("foo.bar", handleCaptor.getValue()); assertThat(result).isEqualTo(SUCCESS); }
|
MirrorFs implements se.tfiskgul.mux2fs.fs.base.FileSystem { @Override public int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle) { FileChannel fileChannel = openFiles.get(fileHandle); logger.trace("{} {} {}", path, size, offset); return readFromFileChannel(buf, offset, size, fileChannel); } MirrorFs(Path mirroredPath); @VisibleForTesting protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser); @Override String getFSName(); @Override int getattr(String path, StatFiller stat); @Override int readdir(String path, DirectoryFiller filler); @Override int readLink(String path, Consumer<String> buf, int size); @Override int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testReadBadFileDescriptor() { int result = fs.read("foo.bar", empty(), 10, 1234, 567); assertThat(result).isEqualTo(-ErrorCodes.EBADF()); }
@Test public void testRead() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); ArgumentCaptor<Integer> handleCaptor = ArgumentCaptor.forClass(Integer.class); doNothing().when(filler).setFileHandle(handleCaptor.capture()); Path fooBar = mockPath("foo.bar"); FileChannel fileChannel = mock(FileChannel.class); when(fileSystem.provider().newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ)))).thenReturn(fileChannel); fs.open("foo.bar", filler); Integer fileHandle = handleCaptor.getValue(); ArgumentCaptor<ByteBuffer> bufferCaptor = ArgumentCaptor.forClass(ByteBuffer.class); when(fileChannel.read(bufferCaptor.capture(), eq(1234L))).thenReturn(10); int result = fs.read("foo.bar", (data) -> assertThat(data).hasSize(10), 10, 1234L, fileHandle); assertThat(result).isEqualTo(10); verify(fileChannel).read(any(), eq(1234L)); verifyNoMoreInteractions(fileChannel); assertThat(bufferCaptor.getValue().limit()).isEqualTo(10); }
|
MirrorFs implements se.tfiskgul.mux2fs.fs.base.FileSystem { @Override public void destroy() { logger.info("Cleaning up"); openFiles.forEach((fh, channel) -> safeClose(channel)); openFiles.clear(); } MirrorFs(Path mirroredPath); @VisibleForTesting protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser); @Override String getFSName(); @Override int getattr(String path, StatFiller stat); @Override int readdir(String path, DirectoryFiller filler); @Override int readLink(String path, Consumer<String> buf, int size); @Override int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testDestroy() { fs.destroy(); }
|
MirrorFs implements se.tfiskgul.mux2fs.fs.base.FileSystem { @Override public int readLink(String path, Consumer<String> buf, int size) { logger.debug(path); Path real = real(path); return tryCatch.apply(() -> { Path target = Files.readSymbolicLink(real); return getFileName(target).map(name -> { buf.accept(truncateIfNeeded(name, size)); return SUCCESS; }).orElse(-ErrorCodes.EINVAL()); }); } MirrorFs(Path mirroredPath); @VisibleForTesting protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser); @Override String getFSName(); @Override int getattr(String path, StatFiller stat); @Override int readdir(String path, DirectoryFiller filler); @Override int readLink(String path, Consumer<String> buf, int size); @Override int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testReadLink() throws Exception { Path fooBar = mockPath("foo.bar"); Path target = mockPath("bar.foo"); when(fileSystem.provider().readSymbolicLink(fooBar)).thenReturn(target); int result = fs.readLink("foo.bar", (name) -> assertThat(name).isEqualTo("bar.foo"), 1024); assertThat(result).isEqualTo(SUCCESS); }
@Test public void testReadLinkLongNameIsTruncated() throws Exception { Path fooBar = mockPath("foo.bar"); Path target = mockPath("ThisIsALongName"); when(fileSystem.provider().readSymbolicLink(fooBar)).thenReturn(target); int result = fs.readLink("foo.bar", (name) -> assertThat(name).isEqualTo("ThisI"), 5); assertThat(result).isEqualTo(SUCCESS); }
|
FileInfo { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } FileInfo other = (FileInfo) obj; return Objects.equals(inode, other.inode) && Objects.equals(mtime, other.mtime) && Objects.equals(ctime, other.ctime) && Objects.equals(size, other.size); } FileInfo(long inode, FileTime mtime, FileTime ctime, long size); FileInfo(long inode, Instant mtime, Instant ctime, long size); static FileInfo of(Path path); long getInode(); FileTime getMtime(); FileTime getCtime(); long getSize(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
|
@Test public void testEquals() { long ino = 1234L; long size = 9876L; Instant modificationTime = Instant.now(); Instant inodeTime = Instant.now().plusSeconds(5); FileInfo fileInfo = new FileInfo(ino, modificationTime, inodeTime, size); assertThat(fileInfo).isEqualTo(fileInfo); assertThat(fileInfo).isNotEqualTo(null); assertThat(fileInfo).isNotEqualTo(inodeTime); }
|
UnixFileStatImpl implements UnixFileStat, StatFiller { @Override public UnixFileStat stat(Path path) throws IOException { Map<String, Object> map = Files.readAttributes(path, "unix:*", LinkOption.NOFOLLOW_LINKS); setDev((long) map.get("dev")); setIno((long) map.get("ino")); setLinks((int) map.get("nlink")); setMode((int) map.get("mode")); setUid((int) map.get("uid")); setGid((int) map.get("gid")); setRdev((long) map.get("rdev")); long size = (long) map.get("size"); setSize(size); setBlkSize(BLK_SIZE); setBlocks(size / 512 + 1); setAccessTime(getInstant(map, "lastAccessTime")); setModificationTime(getInstant(map, "lastModifiedTime")); setInodeTime(getInstant(map, "ctime")); return this; } protected UnixFileStatImpl(); @Override long getDev(); @Override long getIno(); @Override int getLinks(); @Override int getMode(); @Override int getUid(); @Override int getGid(); @Override long getRdev(); @Override long getSize(); @Override int getBlkSize(); @Override long getBlocks(); @Override Instant getAccessTime(); @Override Instant getModificationTime(); @Override Instant getInodeTime(); @Override UnixFileStat stat(Path path); @Override UnixFileStat statWithSize(Path path, Function<FileInfo, Optional<Long>> sizeGetter, Supplier<Long> extraSizeGetter); }
|
@Test public void testStat() throws Exception { int nonce = 123; FileSystem fileSystem = mockFileSystem(); Path path = mockPath("/", fileSystem); Instant base = Instant.now(); Map<String, Object> attributes = mockAttributes(nonce, base); when(fileSystem.provider().readAttributes(eq(path), eq("unix:*"), any())).thenReturn(attributes); UnixFileStatImpl stat = new UnixFileStatImpl(); UnixFileStat result = stat.stat(path); assertThat(result).isSameAs(stat); assertThat(stat.getDev()).isEqualTo(nonce * 3L); assertThat(stat.getIno()).isEqualTo(nonce * 5L); assertThat(stat.getLinks()).isEqualTo(nonce * 7); assertThat(stat.getMode()).isEqualTo(nonce * 11); assertThat(stat.getUid()).isEqualTo(nonce * 13); assertThat(stat.getGid()).isEqualTo(nonce * 17); assertThat(stat.getRdev()).isEqualTo(nonce * 19L); assertThat(stat.getSize()).isEqualTo(nonce * 23L); assertThat(stat.getBlocks()).isEqualTo(stat.getSize() / 512 + 1); assertThat(stat.getAccessTime()).isEqualTo(FileTime.from(base.minus(29, ChronoUnit.DAYS)).toInstant()); assertThat(stat.getModificationTime()).isEqualTo(FileTime.from(base.minus(31, ChronoUnit.DAYS)).toInstant()); assertThat(stat.getInodeTime()).isEqualTo(FileTime.from(base.minus(37, ChronoUnit.DAYS)).toInstant()); }
|
Muxer { public void start() throws IOException { if (state.compareAndSet(NOT_STARTED, RUNNING)) { try { access(mkv, AccessMode.READ); access(srt, AccessMode.READ); access(tempDir, AccessMode.WRITE); output.toFile().deleteOnExit(); ProcessBuilder builder = factory.from("mkvmerge", "-o", output.toString(), mkv.toString(), srt.toString()); builder.directory(tempDir.toFile()).inheritIO(); process = builder.start(); } catch (Exception e) { state.set(FAILED); deleteWarn(output); throw e; } } } private Muxer(Path mkv, Path srt, Path tempDir, ProcessBuilderFactory factory, Sleeper sleeper); static Muxer of(Path mkv, Path srt, Path tempDir); void start(); State state(); int waitFor(); boolean waitFor(long timeout, TimeUnit unit); Optional<Path> getOutput(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); Path getMkv(); boolean waitForOutput(); }
|
@Test public void testMkvMustBeReadable() throws Exception { doThrow(new NoSuchFileException(null)).when(provider).checkAccess(mkv, AccessMode.READ); exception.expect(NoSuchFileException.class); muxer.start(); }
@Test public void testSrtMustBeReadable() throws Exception { doThrow(new NoSuchFileException(null)).when(provider).checkAccess(srt, AccessMode.READ); exception.expect(NoSuchFileException.class); muxer.start(); }
@Test public void testempDirMustBeWriteable() throws Exception { doThrow(new NoSuchFileException(null)).when(provider).checkAccess(tempDir, AccessMode.WRITE); exception.expect(NoSuchFileException.class); muxer.start(); }
@Test public void testStart() throws Exception { muxer.start(); verify(muxer.getOutputForTest().toFile()).deleteOnExit(); verify(factory).from("mkvmerge", "-o", muxer.getOutput().get().toString(), mkv.toString(), srt.toString()); }
|
MuxFs extends MirrorFs { @Override public int open(String path, FileHandleFiller filler) { if (!path.endsWith(".mkv")) { return super.open(path, filler); } logger.info(path); Path muxFile = real(path); List<Path> subFiles = getMatchingSubFiles(muxFile); if (subFiles.isEmpty()) { logger.debug("{} doesn't need muxing", path); return super.open(path, filler); } return Try.withCatch(() -> FileInfo.of(muxFile), Exception.class).map(info -> open(path, filler, muxFile, subFiles, info)).recover(this::translateOrThrow).get(); } MuxFs(Path mirroredPath, Path tempDir); @VisibleForTesting MuxFs(Path mirroredPath, Path tempDir, MuxerFactory muxerFactory, Sleeper sleeper, FileChannelCloser fileChannelCloser, ExecutorService executorService); @Override String getFSName(); @Override int readdir(String path, DirectoryFiller filler); @Override int getattr(String path, StatFiller stat); @Override // TODO: Multiple SRT file support int open(String path, FileHandleFiller filler); @Override int read(String path, Consumer<byte[]> buf, int size, long offset, int fileHandle); @Override int release(String path, int fileHandle); @Override void destroy(); }
|
@Test public void testOpenMkvNoMatchingSubsShouldOpenNormally() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); Path mkv1 = mockPath("file1.mkv"); Path mkv2 = mockPath("file2.mkv"); Path mkv2txt1 = mockPath("file2.txt", 123456789L); Path mkv2srt1 = mockPath("file2.eng.srt", 2893756L); Path mkv2srt2 = mockPath("file2.der.srt", 2345L); Path mkv2srt3 = mockPath("file2.swe.srt", 78568L); mockShuffledDirectoryStream(mirrorRoot, mkv1, mkv2, mkv2txt1, mkv2srt1, mkv2srt2, mkv2srt3); when(fileSystem.provider().newFileChannel(eq(mkv1), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); int result = fs.open("file1.mkv", filler); assertThat(result).isEqualTo(SUCCESS); }
@Test public void testIOExceptionInMuxerStartFallsBackToOriginal() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); Path mkv1 = mockPath("file1.mkv"); Path mkv2 = mockPath("file2.mkv"); Path mkv2txt1 = mockPath("file2.txt", 123456789L); Path mkv2srt1 = mockPath("file2.eng.srt", 2893756L); mockShuffledDirectoryStream(mirrorRoot, mkv1, mkv2, mkv2txt1, mkv2srt1); mockAttributes(mkv2, 1); Muxer muxer = mock(Muxer.class); when(muxerFactory.from(mkv2, mkv2srt1, tempDir)).thenReturn(muxer); doThrow(new IOException()).when(muxer).start(); when(fileSystem.provider().newFileChannel(eq(mkv2), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); int result = fs.open("file2.mkv", filler); assertThat(result).isEqualTo(SUCCESS); verify(muxerFactory).from(mkv2, mkv2srt1, tempDir); verifyNoMoreInteractions(muxerFactory); verify(muxer).start(); verifyNoMoreInteractions(muxer); verify(filler).setFileHandle(gt(1)); verify(fileSystem.provider()).newFileChannel(eq(mkv2), eq(set(StandardOpenOption.READ))); }
@Test public void testOpenMkvMatchingSubNoMuxerOutputFallsBackToOriginal() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); Path mkv1 = mockPath("file1.mkv"); Path mkv2 = mockPath("file2.mkv"); Path mkv2txt1 = mockPath("file2.txt", 123456789L); Path mkv2srt1 = mockPath("file2.eng.srt", 2893756L); mockShuffledDirectoryStream(mirrorRoot, mkv1, mkv2, mkv2txt1, mkv2srt1); mockAttributes(mkv2, 1); Muxer muxer = mock(Muxer.class); when(muxerFactory.from(mkv2, mkv2srt1, tempDir)).thenReturn(muxer); when(fileSystem.provider().newFileChannel(eq(mkv2), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); when(muxer.getOutput()).thenReturn(Optional.empty()); int result = fs.open("file2.mkv", filler); assertThat(result).isEqualTo(SUCCESS); verify(muxerFactory).from(mkv2, mkv2srt1, tempDir); verifyNoMoreInteractions(muxerFactory); verify(muxer).start(); verify(muxer).waitForOutput(); verify(muxer).getOutput(); verifyNoMoreInteractions(muxer); verify(filler).setFileHandle(gt(1)); verify(fileSystem.provider()).newFileChannel(eq(mkv2), eq(set(StandardOpenOption.READ))); }
@Test public void testOpenMkvMatchingSubShouldBeMuxed() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); Path mkv1 = mockPath("file1.mkv"); Path mkv2 = mockPath("file2.mkv"); Path mkv2txt1 = mockPath("file2.txt", 123456789L); Path mkv2srt1 = mockPath("file2.eng.srt", 2893756L); mockShuffledDirectoryStream(mirrorRoot, mkv1, mkv2, mkv2txt1, mkv2srt1); mockAttributes(mkv2, 1); Muxer muxer = mock(Muxer.class); when(muxerFactory.from(mkv2, mkv2srt1, tempDir)).thenReturn(muxer); Path muxedFile = mockPath(tempDir, "file1.mkv"); when(muxer.getOutput()).thenReturn(Optional.of(muxedFile)); when(fileSystem.provider().newFileChannel(eq(muxedFile), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); int result = fs.open("file2.mkv", filler); assertThat(result).isEqualTo(SUCCESS); verify(muxerFactory).from(mkv2, mkv2srt1, tempDir); verifyNoMoreInteractions(muxerFactory); verify(muxer).start(); verify(muxer).waitForOutput(); verify(muxer).getOutput(); verifyNoMoreInteractions(muxer); verify(filler).setFileHandle(gt(1)); verify(fileSystem.provider()).newFileChannel(eq(muxedFile), eq(set(StandardOpenOption.READ))); }
@Test public void testOpenMkvMatchingSubTwiceShouldBeMuxedOnce() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); Path mkv1 = mockPath("file1.mkv"); Path mkv2 = mockPath("file2.mkv"); Path mkv2txt1 = mockPath("file2.txt", 123456789L); Path mkv2srt1 = mockPath("file2.eng.srt", 2893756L); mockShuffledDirectoryStream(mirrorRoot, mkv1, mkv2, mkv2txt1, mkv2srt1); mockAttributes(mkv2, 1); Muxer muxer = mock(Muxer.class); when(muxerFactory.from(mkv2, mkv2srt1, tempDir)).thenReturn(muxer); Path muxedFile = mockPath(tempDir, "file1.mkv"); when(muxer.getOutput()).thenReturn(Optional.of(muxedFile)); when(fileSystem.provider().newFileChannel(eq(muxedFile), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); fs.open("file2.mkv", filler); Muxer muxer2 = mock(Muxer.class); when(muxerFactory.from(mkv2, mkv2srt1, tempDir)).thenReturn(muxer2); mockShuffledDirectoryStream(mirrorRoot, mkv1, mkv2, mkv2txt1, mkv2srt1); int result = fs.open("file2.mkv", filler); assertThat(result).isEqualTo(SUCCESS); verify(muxerFactory, times(2)).from(mkv2, mkv2srt1, tempDir); verifyNoMoreInteractions(muxerFactory); verify(muxer, times(2)).start(); verify(muxer, times(2)).waitForOutput(); verify(muxer, times(2)).getOutput(); verifyNoMoreInteractions(muxer); verifyNoMoreInteractions(muxer2); verify(filler, times(2)).setFileHandle(gt(1)); verify(fileSystem.provider(), times(2)).newFileChannel(eq(muxedFile), eq(set(StandardOpenOption.READ))); }
@Test public void testOpenMkvMatchingSubOpenMuxedFileFailsFallsBackToOriginal() throws Exception { FileHandleFiller filler = mock(FileHandleFiller.class); Path mkv1 = mockPath("file1.mkv"); Path mkv2 = mockPath("file2.mkv"); Path mkv2txt1 = mockPath("file2.txt", 123456789L); Path mkv2srt1 = mockPath("file2.eng.srt", 2893756L); mockShuffledDirectoryStream(mirrorRoot, mkv1, mkv2, mkv2txt1, mkv2srt1); mockAttributes(mkv2, 1); Muxer muxer = mock(Muxer.class); when(muxerFactory.from(mkv2, mkv2srt1, tempDir)).thenReturn(muxer); Path muxedFile = mockPath(tempDir, "file1.mkv"); when(muxer.getOutput()).thenReturn(Optional.of(muxedFile)); when(fileSystem.provider().newFileChannel(eq(muxedFile), eq(set(StandardOpenOption.READ)))).thenThrow(new IOException()); when(fileSystem.provider().newFileChannel(eq(mkv2), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class)); int result = fs.open("file2.mkv", filler); assertThat(result).isEqualTo(SUCCESS); verify(muxerFactory).from(mkv2, mkv2srt1, tempDir); verifyNoMoreInteractions(muxerFactory); verify(muxer).start(); verify(muxer).waitForOutput(); verify(muxer).getOutput(); verifyNoMoreInteractions(muxer); verify(muxedFile.toFile()).delete(); verify(filler).setFileHandle(gt(1)); verify(fileSystem.provider()).newFileChannel(eq(muxedFile), eq(set(StandardOpenOption.READ))); verify(fileSystem.provider()).newFileChannel(eq(mkv2), eq(set(StandardOpenOption.READ))); }
|
Muxer { public int waitFor() throws InterruptedException { switch (state()) { case NOT_STARTED: throw new IllegalStateException("Not started"); case FAILED: return process != null ? process.exitValue() : -127; case RUNNING: case SUCCESSFUL: return process.waitFor(); default: throw new IllegalStateException("BUG: Unkown state"); } } private Muxer(Path mkv, Path srt, Path tempDir, ProcessBuilderFactory factory, Sleeper sleeper); static Muxer of(Path mkv, Path srt, Path tempDir); void start(); State state(); int waitFor(); boolean waitFor(long timeout, TimeUnit unit); Optional<Path> getOutput(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); Path getMkv(); boolean waitForOutput(); }
|
@Test public void testWaitForNonStartedMuxer() throws Exception { exception.expect(IllegalStateException.class); muxer.waitFor(); }
@Test public void testWaitFor50millisNonStartedMuxer() throws Exception { exception.expect(IllegalStateException.class); muxer.waitFor(50, MILLISECONDS); }
|
Muxer { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } Muxer other = (Muxer) obj; return Objects.equals(mkv, other.mkv) && Objects.equals(output, other.output) && Objects.equals(srt, other.srt) && Objects.equals(tempDir, other.tempDir); } private Muxer(Path mkv, Path srt, Path tempDir, ProcessBuilderFactory factory, Sleeper sleeper); static Muxer of(Path mkv, Path srt, Path tempDir); void start(); State state(); int waitFor(); boolean waitFor(long timeout, TimeUnit unit); Optional<Path> getOutput(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); Path getMkv(); boolean waitForOutput(); }
|
@Test public void testEquals() { Muxer another = Muxer.of(mkv, srt, tempDir); boolean result = muxer.equals(another); assertThat(result).isFalse(); }
|
Muxer { @Override public int hashCode() { return Objects.hash(mkv, output, srt, tempDir); } private Muxer(Path mkv, Path srt, Path tempDir, ProcessBuilderFactory factory, Sleeper sleeper); static Muxer of(Path mkv, Path srt, Path tempDir); void start(); State state(); int waitFor(); boolean waitFor(long timeout, TimeUnit unit); Optional<Path> getOutput(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); Path getMkv(); boolean waitForOutput(); }
|
@Test public void testHashCode() { Muxer another = Muxer.of(mkv, srt, tempDir); int hashCode = another.hashCode(); assertThat(hashCode).isNotEqualTo(muxer.hashCode()); }
|
Muxer { public Path getMkv() { return mkv; } private Muxer(Path mkv, Path srt, Path tempDir, ProcessBuilderFactory factory, Sleeper sleeper); static Muxer of(Path mkv, Path srt, Path tempDir); void start(); State state(); int waitFor(); boolean waitFor(long timeout, TimeUnit unit); Optional<Path> getOutput(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); Path getMkv(); boolean waitForOutput(); }
|
@Test public void testGetMkv() { assertThat(muxer.getMkv()).isEqualTo(mkv); }
|
MuxedFile { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } MuxedFile other = (MuxedFile) obj; return Objects.equals(info, other.info) && Objects.equals(muxer, other.muxer); } MuxedFile(FileInfo info, Muxer muxer); FileInfo getInfo(); Muxer getMuxer(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
@Test public void testEquals() { FileInfo info = mock(FileInfo.class); Muxer muxer = mock(Muxer.class); MuxedFile muxedFile = new MuxedFile(info, muxer); MuxedFile muxedFile2 = new MuxedFile(info, muxer); assertThat(muxedFile).isEqualTo(muxedFile); assertThat(muxedFile).isEqualTo(muxedFile2); assertThat(muxedFile).isNotEqualTo(null); assertThat(muxedFile).isNotEqualTo(info); }
|
MuxedFile { @Override public int hashCode() { return Objects.hash(info, muxer); } MuxedFile(FileInfo info, Muxer muxer); FileInfo getInfo(); Muxer getMuxer(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
|
@Test public void testHashCode() { FileInfo info = mock(FileInfo.class); Muxer muxer = mock(Muxer.class); MuxedFile muxedFile = new MuxedFile(info, muxer); MuxedFile muxedFile2 = new MuxedFile(info, muxer); assertThat(muxedFile.hashCode()).isEqualTo(muxedFile2.hashCode()); }
|
Main { public static void main(String[] args) throws IOException { try { Strict arguments = new CommandLineArguments().parse(args); if (arguments.isHelp()) { System.out.println(arguments.getHelp()); } else if (arguments.isVersion()) { System.out.println("mux2fs version " + arguments.getVersion()); } else { arguments.validate(); mount(arguments); } } catch (Exception e) { System.err.println(CommandLineArguments.getUsage()); throw e; } } static void main(String[] args); }
|
@Test public void testHelp() throws Exception { Main.main(array("-h")); }
@Test public void testInvalidOptions() throws Exception { exception.expect(ParameterException.class); Main.main(array("nonse -o nse c -p ommand line")); }
@Test public void testInvalidFuseOptions() throws Exception { exception.expect(FuseException.class); Main.main(array("/", "/tmp", "-o", "tempdir=/tmp,nonsense=invalid")); }
@Test public void testVersion() throws Exception { Main.main(array("-v")); }
|
TodoService { public List<TodoEntity> getAll() { return todoDAO.findAll(); } List<TodoEntity> getAll(); boolean add(TodoEntity entity); boolean edit(TodoEntity entity); boolean delete(long id); }
|
@Test public void GetAllTest_When_MethodCall_ExpectTodoEntityList(){ TodoEntity todo1 = new TodoEntity(); todo1.setId(1); todo1.setStatus(TodoStatusType.OPEN); todo1.setName("Test todo1 name"); TodoEntity todo2 = new TodoEntity(); todo1.setId(2); todo1.setStatus(TodoStatusType.CLOSED); todo1.setName("Test todo2 name"); List<TodoEntity> existingEntities = Arrays.asList(todo1, todo2); when(todoDAO.findAll()).thenReturn(existingEntities); assertThat(todoService.getAll()).hasSize(2).contains(todo1, todo2); }
|
TodoService { public boolean add(TodoEntity entity) { if(todoDAO.findByName(entity.getName())!=null) return false; entity.setStatus(TodoStatusType.OPEN); todoDAO.saveOrUpdate(entity); return true; } List<TodoEntity> getAll(); boolean add(TodoEntity entity); boolean edit(TodoEntity entity); boolean delete(long id); }
|
@Test public void AddTest_When_GivenNewNotExistingBeforeTodoEntityWithNameOnly_ExpectTrue(){ TodoEntity todoToAdd = new TodoEntity(); todoToAdd.setName("Test todoToAdd name"); assertThat(todoService.add(todoToAdd)).isTrue(); }
@Test public void AddTest_When_GivenTodoEntityWithNameThatExistedBefore_ExpectFalse(){ TodoEntity alreadyExistingTodo = new TodoEntity(); alreadyExistingTodo.setId(1); alreadyExistingTodo.setStatus(TodoStatusType.OPEN); alreadyExistingTodo.setName("Test already existing name"); TodoEntity todoToAdd = new TodoEntity(); todoToAdd.setName(alreadyExistingTodo.getName()); when(todoDAO.findByName(alreadyExistingTodo.getName())).thenReturn(alreadyExistingTodo); assertThat(todoService.add(todoToAdd)).isFalse(); }
|
TodoService { public boolean edit(TodoEntity entity) { if(todoDAO.findById(entity.getId()) == null) return false; TodoEntity existingTodoEntity = todoDAO.findByName(entity.getName()); if(existingTodoEntity!=null && existingTodoEntity.getId()!=entity.getId()) return false; if(entity.getStatus()==null) return false; todoDAO.saveOrUpdate(entity); return true; } List<TodoEntity> getAll(); boolean add(TodoEntity entity); boolean edit(TodoEntity entity); boolean delete(long id); }
|
@Test public void EditTest_When_GivenAlreadyExistingTodoEntityWithChangedName_ExpectTrue(){ TodoEntity alreadyExistingTodo = new TodoEntity(); alreadyExistingTodo.setId(1); alreadyExistingTodo.setStatus(TodoStatusType.OPEN); alreadyExistingTodo.setName("Test already existing name"); TodoEntity todoToEdit = new TodoEntity(); todoToEdit.setId(1); todoToEdit.setStatus(TodoStatusType.OPEN); todoToEdit.setName("Test new name for already existing todo"); when(todoDAO.findById(alreadyExistingTodo.getId())).thenReturn(alreadyExistingTodo); assertThat(todoService.edit(todoToEdit)).isTrue(); }
@Test public void EditTest_When_GivenTodoEntityThatNotExistedBefore_ExpectFalse() { TodoEntity todoToEdit = new TodoEntity(); todoToEdit.setId(1); todoToEdit.setStatus(TodoStatusType.OPEN); todoToEdit.setName("Test todoToEdit name todo"); when(todoDAO.findById(todoToEdit.getId())).thenReturn(null); assertThat(todoService.edit(todoToEdit)).isFalse(); }
@Test public void EditTest_When_GivenTodoEntityWithTheSameNameAsAlreadyExistingTodoEntity_ExpectFalse() { TodoEntity alreadyExistingTodo = new TodoEntity(); alreadyExistingTodo.setId(1); alreadyExistingTodo.setStatus(TodoStatusType.OPEN); alreadyExistingTodo.setName("Test already existing name"); TodoEntity todoToEdit = new TodoEntity(); todoToEdit.setId(2); todoToEdit.setStatus(TodoStatusType.OPEN); todoToEdit.setName(alreadyExistingTodo.getName()); when(todoDAO.findById(todoToEdit.getId())).thenReturn(todoToEdit); when(todoDAO.findByName(alreadyExistingTodo.getName())).thenReturn(alreadyExistingTodo); assertThat(todoService.edit(todoToEdit)).isFalse(); }
@Test public void EditTest_When_GivenTodoEntityWithNullStatus_ExpectFalse() { TodoEntity alreadyExistingTodo = new TodoEntity(); alreadyExistingTodo.setId(1); alreadyExistingTodo.setStatus(TodoStatusType.OPEN); alreadyExistingTodo.setName("Test already existing name"); TodoEntity todoToEdit = new TodoEntity(); todoToEdit.setId(1); todoToEdit.setStatus(null); todoToEdit.setName("Test new name for already existing todo"); when(todoDAO.findById(todoToEdit.getId())).thenReturn(alreadyExistingTodo); when(todoDAO.findByName(alreadyExistingTodo.getName())).thenReturn(alreadyExistingTodo); assertThat(todoService.edit(todoToEdit)).isFalse(); }
|
TodoService { public boolean delete(long id) { if(todoDAO.findById(id) == null) return false; todoDAO.delete(id); return true; } List<TodoEntity> getAll(); boolean add(TodoEntity entity); boolean edit(TodoEntity entity); boolean delete(long id); }
|
@Test public void DeleteTest_When_GivenExistingTodoEntityId_ExpectTrue(){ TodoEntity alreadyExistingTodo = new TodoEntity(); alreadyExistingTodo.setId(1); alreadyExistingTodo.setStatus(TodoStatusType.OPEN); alreadyExistingTodo.setName("Test already existing name"); when(todoDAO.findById(alreadyExistingTodo.getId())).thenReturn(alreadyExistingTodo); assertThat(todoService.delete(alreadyExistingTodo.getId())).isTrue(); }
@Test public void DeleteTest_When_GivenNonExistingTodoEntityId_ExpectFalse(){ long nonExistingId = 1; when(todoDAO.findById(nonExistingId)).thenReturn(null); assertThat(todoService.delete(nonExistingId)).isFalse(); }
|
AuthorizationAdvisor { @Before("execution(* *(..)) && @annotation(authorize)") public void handle(Authorize authorize) throws Throwable { if (!provider.isAuthenticated()) { throw new AuthenticationException(new Reportable("auth.not.authenticated")); } if (isNotBlank(authorize.scopes())) { checkScopes(authorize.scopes()); } if (isNotBlank(authorize.roles())) { checkRoles(authorize.roles()); } if (isNotBlank(authorize.authorities())) { checkAuthorities(authorize.authorities()); } } @Autowired AuthorizationAdvisor(AuthorizationContextProvider provider); @Before("execution(* *(..)) && @annotation(authorize)") void handle(Authorize authorize); }
|
@Test public void shouldThrowAnAuthenticationErrorIfTheCurrentAuthenticationContextIsNotAuthenticated() throws Throwable { this.provider = new SimpleAuthorizationContextProvider().authenticated(false); this.advisor = new AuthorizationAdvisor(provider); try { advisor.handle(authorize().withRoles("role:user").build()); } catch (AuthenticationException e) { List<Reportable> errors = e.getErrors(); Assertions.assertThat(errors).hasSize(1); Assertions.assertThat(errors.get(0).getCode()).isEqualTo("AUT-0001"); Assertions.assertThat(errors.get(0).getMessage()).isEqualTo("Full authentication is required to access this resource."); } }
@Test public void shouldThrowAnAuthorizationErrorIfTheCurrentAuthorizationContextDoesNotHaveTheSpecifiedAnnoationRole() throws Throwable { try { advisor.handle(authorize().withRoles("role:user").build()); } catch (AuthorizationException e) { List<Reportable> errors = e.getErrors(); Assertions.assertThat(errors).hasSize(1); Assertions.assertThat(errors.get(0).getCode()).isEqualTo("ATZ-0003"); Assertions.assertThat(errors.get(0).getMessage()).isEqualTo("Access is denied."); } }
@Test public void shouldBeAuthorizedWhenTheCurrentAuthorizationContextHasTheSpecifiedAnnoationRole() throws Throwable { provider.withRoles("role:user"); advisor.handle(authorize().withRoles("role:user").build()); }
@Test public void shouldThrowAnAuthorizationErrorIfTheCurrentAuthorizationContextDoesNotHaveTheSpecifiedAnnoationAuthority() throws Throwable { try { advisor.handle(authorize().withAuthorities("authority:internal").build()); } catch (AuthorizationException e) { List<Reportable> errors = e.getErrors(); Assertions.assertThat(errors).hasSize(1); Assertions.assertThat(errors.get(0).getCode()).isEqualTo("ATZ-0004"); Assertions.assertThat(errors.get(0).getMessage()).isEqualTo("Access is denied."); } }
@Test public void shouldBeAuthorizedWhenTheCurrentAuthorizationContextHasTheSpecifiedAnnoationAuthority() throws Throwable { provider.withAuthorities("authority:internal"); advisor.handle(authorize().withAuthorities("authority:internal").build()); }
@Test public void shouldThrowAnAuthorizationErrorIfTheCurrentAuthorizationContextDoesNotHaveTheSpecifiedAnnoationScope() throws Throwable { try { advisor.handle(authorize().withScopes("accounts:read").build()); } catch (AuthorizationException e) { List<Reportable> errors = e.getErrors(); Assertions.assertThat(errors).hasSize(1); Assertions.assertThat(errors.get(0).getCode()).isEqualTo("ATZ-0001"); Assertions.assertThat(errors.get(0).getMessage()).isEqualTo("Insufficient scope for this resource."); } }
@Test public void shouldBeAuthorizedWhenTheCurrentAuthorizationContextHasTheSpecifiedAnnoationScope() throws Throwable { provider.withScopes("accounts:read"); advisor.handle(authorize().withScopes("accounts:read").build()); }
@Test public void shouldBeAuthorizedWhenTheCurrentAuthorizationContextHasTheSpecifiedAnnoationScopeAuthorityAndRole() throws Throwable { provider.withScopes("accounts:read").withRoles("role:user").withAuthorities("authority:internal"); advisor.handle(authorize().withScopes("accounts:read").withRoles("role:user").withAuthorities("authority:internal").build()); }
@Test public void shouldThrowAnAuthorizationErrorWhenTheCurrentAuthorizationContextIsMissingARequiredScopeRoleOrAuthority() throws Throwable { provider.withScopes("accounts:read").withAuthorities("authority:internal"); try { advisor.handle(authorize().withScopes("accounts:read").withRoles("role:user").withAuthorities("authority:internal").build()); } catch (AuthorizationException e) { List<Reportable> errors = e.getErrors(); Assertions.assertThat(errors).hasSize(1); Assertions.assertThat(errors.get(0).getCode()).isEqualTo("ATZ-0003"); Assertions.assertThat(errors.get(0).getMessage()).isEqualTo("Access is denied."); } }
|
StringTokenizer { public static Set<String> tokenize(String input) { return StringUtils.isBlank(input) ? new HashSet<String>() : new HashSet<String>(Arrays.asList(input.trim().split("\\s*,\\s*"))); } private StringTokenizer(); static Set<String> tokenize(String input); }
|
@Test public void shouldBeAbleToTokenizeAStringWithSpacesBetweenItems() { Set<String> set = StringTokenizer.tokenize("first, second, third"); assertThat(set).contains("first", "second", "third"); }
@Test public void shouldBeAbleToTokenizeAStringWithSpacesBeforeAndAfterAndBetweenItems() { Set<String> set = StringTokenizer.tokenize(" first, second, third "); assertThat(set).contains("first", "second", "third"); }
@Test public void shouldBeAbleToTokenizeAStringWithAdditionalCommas() { Set<String> set = StringTokenizer.tokenize("first,,,second,,third,,"); assertThat(set).contains("first", "second", "third"); }
@Test public void shouldReturnAnEmptyListIfTheStringToTokenizeIsNull() { Set<String> set = StringTokenizer.tokenize(" "); assertThat(set).isEmpty(); }
@Test public void shouldBeAbleToTokenizeAString() { Set<String> set = StringTokenizer.tokenize("first,second,third"); assertThat(set).contains("first", "second", "third"); }
|
OAuth2AuthorizationContext implements AuthorizationContextProvider { public boolean isAuthenticated() { OAuth2Authentication oauth = oauth2Authentication(); return oauth == null ? false : oauth.isAuthenticated(); } OAuth2AuthorizationContext(); boolean isAuthenticated(); Set<String> getScopes(); Set<String> getAuthorities(); Set<String> getRoles(); String getUsername(); }
|
@Test public void shouldBeAuthenticatedWhenTheUnderlyingAuthenticationIsAuthenticated() { when(authentication.isAuthenticated()).thenReturn(true); OAuth2AuthorizationContext ctx = new OAuth2AuthorizationContext(); Assertions.assertThat(ctx.isAuthenticated()).isTrue(); }
@Test public void shouldNotBeAuthenticatedWhenTheUnderlyingAuthenticationIsNotAuthenticated() { when(authentication.isAuthenticated()).thenReturn(false); OAuth2AuthorizationContext ctx = new OAuth2AuthorizationContext(); assertThat(ctx.isAuthenticated()).isFalse(); }
@Test public void shouldNotBeAuthenticatedWhenTheUnderlyingAuthenticationIsNull() { when(context.getAuthentication()).thenReturn(null); SecurityContextHolder.setContext(context); OAuth2AuthorizationContext ctx = new OAuth2AuthorizationContext(); assertThat(ctx.isAuthenticated()).isFalse(); }
@Test public void shouldNotBeAuthenticatedWhenTheUnderlyingAuthenticationIsNotAnOAuth2Authentication() { when(context.getAuthentication()).thenReturn(anonymousAuthentication); SecurityContextHolder.setContext(context); OAuth2AuthorizationContext ctx = new OAuth2AuthorizationContext(); assertThat(ctx.isAuthenticated()).isFalse(); }
|
OAuth2AuthorizationContext implements AuthorizationContextProvider { public Set<String> getScopes() { OAuth2Authentication oauth = oauth2Authentication(); if (oauth == null) { return new HashSet<String>(); } Set<String> scope = oauth.getOAuth2Request().getScope(); return scope == null ? new HashSet<String>() : scope; } OAuth2AuthorizationContext(); boolean isAuthenticated(); Set<String> getScopes(); Set<String> getAuthorities(); Set<String> getRoles(); String getUsername(); }
|
@Test public void shouldReturnAnEmtpySetOfScopesIfTheAuthenticationIsNotAnOAuth2Authentication() { when(context.getAuthentication()).thenReturn(testAuthentication); SecurityContextHolder.setContext(context); OAuth2AuthorizationContext ctx = new OAuth2AuthorizationContext(); assertThat(ctx.getScopes()).hasSize(0); }
|
OAuth2AuthorizationContext implements AuthorizationContextProvider { public Set<String> getAuthorities() { OAuth2Authentication oauth = oauth2Authentication(); if (oauth == null) { return new HashSet<String>(); } Collection<GrantedAuthority> authorities = oauth.getAuthorities(); return authorities == null ? new HashSet<String>() : authorities.stream().map(authority -> authority.getAuthority()).collect(Collectors.toSet()); } OAuth2AuthorizationContext(); boolean isAuthenticated(); Set<String> getScopes(); Set<String> getAuthorities(); Set<String> getRoles(); String getUsername(); }
|
@Test public void shouldReturnAnEmtpySetOfAuthoritiesIfTheAuthenticationIsNotAnOAuth2Authentication() { when(context.getAuthentication()).thenReturn(testAuthentication); SecurityContextHolder.setContext(context); OAuth2AuthorizationContext ctx = new OAuth2AuthorizationContext(); assertThat(ctx.getAuthorities()).hasSize(0); }
|
AccountConversionService { public AccountRepresentation convert(Account account) { AccountRepresentation representation = new AccountRepresentation(); representation.setId(account.getId()); representation.setCreated(account.getCreated()); representation.setUpdated(account.getUpdated()); representation.setUsername(account.getUsername()); representation.setLocked(account.isLocked()); representation.setRoles(account.getRoles().stream().map(role -> roleConversionService.convert(role)).collect(Collectors.toSet())); return representation; } @Autowired AccountConversionService(RoleService roleService, RoleConversionService roleConversionService); AccountRepresentation convert(Account account); Account convert(AccountRepresentation representation); Account convert(AccountRepresentation representation, Account account); }
|
@Test public void shouldBeAbleToConvertAnAccountIntoAnAccountRepresentation() { Account account = account().withRole(role().build()).build(); AccountRepresentation representation = accountConversionService.convert(account); assertThat(representation.getId()).isEqualTo(account.getId()); assertThat(representation.getCreated()).isEqualTo(account.getCreated()); assertThat(representation.getUpdated()).isEqualTo(account.getUpdated()); assertThat(representation.getUsername()).isEqualTo(account.getUsername()); assertThat(representation.getPassword()).isNull(); assertThat(representation.getRoles()).hasSize(1); }
@Test public void shouldBeAbleToConvertAnAccountRepresentationIntoANewAccount() { Role role = role().save(); AccountRepresentation representation = AccountDSL.account().withRoles(roleConversionService.convert(role)).build(); Account account = accountConversionService.convert(representation); assertThat(account.getUsername()).isEqualTo(representation.getUsername()); assertThat(account.getPassword()).isEqualTo(representation.getPassword()); assertThat(account.getRoles()).hasSize(1); assertThat(account.getRoles()).contains(role); }
@Test public void shouldBeAbleToConvertAnAccountRepresentationIntoAnExistingAccount() { Role role1 = role().save(); Role role2 = role().save(); Role role3 = role().save(); AccountRepresentation representation = AccountDSL.account().withUsername("foo").withPassword("foo").withRoles(roleConversionService.convert(role3)).build(); Account account = account().withRole(role1).withRole(role2).build(); Account updated = accountConversionService.convert(representation, account); assertThat(updated.getId()).isEqualTo(account.getId()); assertThat(updated.getCreated()).isEqualTo(account.getCreated()); assertThat(updated.getUpdated()).isEqualTo(account.getUpdated()); assertThat(updated.getRoles()).hasSize(1); assertThat(updated.getRoles()).contains(role3); assertThat(updated.getUsername()).isEqualTo(account.getUsername()); assertThat(updated.getPassword()).isEqualTo(account.getPassword()); assertThat(updated.isLocked()).isEqualTo(account.isLocked()); }
|
AudienceConversionService { public Audience convert(AudienceRepresentation representation) { Audience audience = new Audience(representation.getName()); audience.setDescription(representation.getDescription()); return audience; } Audience convert(AudienceRepresentation representation); AudienceRepresentation convert(Audience audience); Audience convert(AudienceRepresentation representation, Audience audience); }
|
@Test public void shouldBeAbleToConvertAAudienceIntoAAudienceRepresentation() { Audience audience = audience().build(); AudienceRepresentation representation = audienceConversionService.convert(audience); assertThat(representation.getId()).isEqualTo(audience.getId()); assertThat(representation.getCreated()).isEqualTo(audience.getCreated()); assertThat(representation.getUpdated()).isEqualTo(audience.getUpdated()); assertThat(representation.getName()).isEqualTo(audience.getName()); assertThat(representation.getDescription()).isEqualTo(audience.getDescription()); }
@Test public void shouldBeAbleToConvertAAudienceRepresentationIntoANewAudience() { AudienceRepresentation representation = AudienceDSL.audience().build(); Audience audience = audienceConversionService.convert(representation); assertThat(audience.getName()).isEqualTo(representation.getName()); assertThat(audience.getDescription()).isEqualTo(representation.getDescription()); }
@Test public void shouldBeAbleToConvertAAudienceRepresentationIntoAnExistingAudience() { AudienceRepresentation representation = AudienceDSL.audience().build(); Audience audience = audience().build(); Audience updated = audienceConversionService.convert(representation, audience); assertThat(updated.getId()).isEqualTo(audience.getId()); assertThat(updated.getCreated()).isEqualTo(audience.getCreated()); assertThat(updated.getUpdated()).isEqualTo(audience.getUpdated()); assertThat(updated.getName()).isEqualTo(representation.getName()); assertThat(updated.getDescription()).isEqualTo(representation.getDescription()); }
|
ScopeConversionService { public Scope convert(ScopeRepresentation representation) { Scope audience = new Scope(representation.getName()); audience.setDescription(representation.getDescription()); return audience; } Scope convert(ScopeRepresentation representation); ScopeRepresentation convert(Scope scope); Scope convert(ScopeRepresentation representation, Scope scope); }
|
@Test public void shouldBeAbleToConvertAScopeIntoAScopeRepresentation() { Scope scope = scope().build(); ScopeRepresentation representation = scopeConversionService.convert(scope); assertThat(representation.getId()).isEqualTo(scope.getId()); assertThat(representation.getCreated()).isEqualTo(scope.getCreated()); assertThat(representation.getUpdated()).isEqualTo(scope.getUpdated()); assertThat(representation.getName()).isEqualTo(scope.getName()); assertThat(representation.getDescription()).isEqualTo(scope.getDescription()); }
@Test public void shouldBeAbleToConvertAScopeRepresentationIntoANewScope() { ScopeRepresentation representation = ScopeDSL.scope().build(); Scope scope = scopeConversionService.convert(representation); assertThat(scope.getName()).isEqualTo(representation.getName()); assertThat(scope.getDescription()).isEqualTo(representation.getDescription()); }
@Test public void shouldBeAbleToConvertAScopeRepresentationIntoAnExistingScope() { ScopeRepresentation representation = ScopeDSL.scope().build(); Scope scope = scope().build(); Scope updated = scopeConversionService.convert(representation, scope); assertThat(updated.getId()).isEqualTo(scope.getId()); assertThat(updated.getCreated()).isEqualTo(scope.getCreated()); assertThat(updated.getUpdated()).isEqualTo(scope.getUpdated()); assertThat(updated.getName()).isEqualTo(representation.getName()); assertThat(updated.getDescription()).isEqualTo(representation.getDescription()); }
|
GrantTypeConversionService { public GrantTypeRepresentation convert(GrantType grantType) { GrantTypeRepresentation representation = new GrantTypeRepresentation(grantType.getId()); representation.setCreated(grantType.getCreated()); representation.setUpdated(grantType.getUpdated()); representation.setName(grantType.getName()); representation.setDescription(grantType.getDescription()); return representation; } GrantTypeRepresentation convert(GrantType grantType); GrantType convert(GrantTypeRepresentation representation); GrantType convert(GrantTypeRepresentation representation, GrantType grantType); }
|
@Test public void shouldBeAbleToConvertAGrantTypeIntoAGrantTypeRepresentation() { GrantType grantType = grantType().build(); GrantTypeRepresentation representation = grantTypeConversionService.convert(grantType); assertThat(representation.getId()).isEqualTo(grantType.getId()); assertThat(representation.getCreated()).isEqualTo(grantType.getCreated()); assertThat(representation.getUpdated()).isEqualTo(grantType.getUpdated()); assertThat(representation.getName()).isEqualTo(grantType.getName()); assertThat(representation.getDescription()).isEqualTo(grantType.getDescription()); }
@Test public void shouldBeAbleToConvertAGrantTypeRepresentationIntoANewGrantType() { GrantTypeRepresentation representation = GrantTypeDSL.grantType().build(); GrantType grantType = grantTypeConversionService.convert(representation); assertThat(grantType.getName()).isEqualTo(representation.getName()); assertThat(grantType.getDescription()).isEqualTo(representation.getDescription()); }
@Test public void shouldBeAbleToConvertAGrantTypeRepresentationIntoAnExistingGrantType() { GrantTypeRepresentation representation = GrantTypeDSL.grantType().build(); GrantType grantType = grantType().build(); GrantType updated = grantTypeConversionService.convert(representation, grantType); assertThat(updated.getId()).isEqualTo(grantType.getId()); assertThat(updated.getCreated()).isEqualTo(grantType.getCreated()); assertThat(updated.getUpdated()).isEqualTo(grantType.getUpdated()); assertThat(updated.getName()).isEqualTo(representation.getName()); assertThat(updated.getDescription()).isEqualTo(representation.getDescription()); }
|
AuthorityConversionService { public Authority convert(AuthorityRepresentation representation) { Authority authority = new Authority(representation.getName()); authority.setDescription(representation.getDescription()); return authority; } Authority convert(AuthorityRepresentation representation); AuthorityRepresentation convert(Authority authority); Authority convert(AuthorityRepresentation representation, Authority authority); }
|
@Test public void shouldBeAbleToConvertAAuthorityIntoAAuthorityRepresentation() { Authority authority = authority().build(); AuthorityRepresentation representation = authorityConversionService.convert(authority); assertThat(representation.getId()).isEqualTo(authority.getId()); assertThat(representation.getCreated()).isEqualTo(authority.getCreated()); assertThat(representation.getUpdated()).isEqualTo(authority.getUpdated()); assertThat(representation.getName()).isEqualTo(authority.getName()); assertThat(representation.getDescription()).isEqualTo(authority.getDescription()); }
@Test public void shouldBeAbleToConvertAAuthorityRepresentationIntoANewAuthority() { AuthorityRepresentation representation = AuthorityDSL.authority().build(); Authority authority = authorityConversionService.convert(representation); assertThat(authority.getName()).isEqualTo(representation.getName()); assertThat(authority.getDescription()).isEqualTo(representation.getDescription()); }
@Test public void shouldBeAbleToConvertAAuthorityRepresentationIntoAnExistingAuthority() { AuthorityRepresentation representation = AuthorityDSL.authority().build(); Authority authority = authority().build(); Authority updated = authorityConversionService.convert(representation, authority); assertThat(updated.getId()).isEqualTo(authority.getId()); assertThat(updated.getCreated()).isEqualTo(authority.getCreated()); assertThat(updated.getUpdated()).isEqualTo(authority.getUpdated()); assertThat(updated.getName()).isEqualTo(representation.getName()); assertThat(updated.getDescription()).isEqualTo(representation.getDescription()); }
|
RoleConversionService { public Role convert(RoleRepresentation representation) { Role role = new Role(representation.getName()); role.setDescription(representation.getDescription()); return role; } Role convert(RoleRepresentation representation); RoleRepresentation convert(Role role); Role convert(RoleRepresentation representation, Role role); }
|
@Test public void shouldBeAbleToConvertARoleIntoARoleRepresentation() { Role role = role().build(); RoleRepresentation representation = roleConversionService.convert(role); assertThat(representation.getId()).isEqualTo(role.getId()); assertThat(representation.getCreated()).isEqualTo(role.getCreated()); assertThat(representation.getUpdated()).isEqualTo(role.getUpdated()); assertThat(representation.getName()).isEqualTo(role.getName()); assertThat(representation.getDescription()).isEqualTo(role.getDescription()); }
@Test public void shouldBeAbleToConvertARoleRepresentationIntoANewRole() { RoleRepresentation representation = RoleDSL.role().build(); Role role = roleConversionService.convert(representation); assertThat(role.getName()).isEqualTo(representation.getName()); assertThat(role.getDescription()).isEqualTo(representation.getDescription()); }
@Test public void shouldBeAbleToConvertARoleRepresentationIntoAnExistingRole() { RoleRepresentation representation = RoleDSL.role().build(); Role role = role().build(); Role updated = roleConversionService.convert(representation, role); assertThat(updated.getId()).isEqualTo(role.getId()); assertThat(updated.getCreated()).isEqualTo(role.getCreated()); assertThat(updated.getUpdated()).isEqualTo(role.getUpdated()); assertThat(updated.getName()).isEqualTo(representation.getName()); assertThat(updated.getDescription()).isEqualTo(representation.getDescription()); }
|
PaginatedListConversionService { public <C> PaginatedListRepresentation<C> convert(PaginatedList<?> list, Class<C> type) { PaginatedListRepresentation<C> representation = new PaginatedListRepresentation<>(); representation.setCriteria(criteriaConversionService.convert(list.getCriteria())); representation.setTotal(list.getTotal()); representation.setRemaining(list.getRemainingResults()); representation.setPages(list.getTotalPages()); return representation; } @Autowired PaginatedListConversionService(CriteriaConversionService criteriaConversionService); PaginatedListRepresentation<C> convert(PaginatedList<?> list, Class<C> type); }
|
@Test public void shouldBeAbleToConverAPaginatedListIntoAPaginatedListRepresentation() { Criteria criteria = Criteria.criteria().from(new Date()).to(new Date()).limit(10).page(1); PaginatedList<?> list = new PaginatedList<>(new ArrayList<>(), 100, criteria); PaginatedListRepresentation<AccountRepresentation> representation = paginatedListConversionService.convert(list, AccountRepresentation.class); assertThat(representation.getPayload()).isEmpty(); assertThat(representation.getCriteria()).isEqualToComparingFieldByField(criteriaConversionService.convert(criteria)); assertThat(representation.getPages()).isEqualTo(10); assertThat(representation.getTotal()).isEqualTo(100); assertThat(representation.getRemaining()).isEqualTo(90); }
|
CriteriaConversionService { public CriteriaRepresentation convert(Criteria criteria) { CriteriaRepresentation representation = new CriteriaRepresentation(); representation.setFrom(criteria.hasFrom() ? criteria.getFrom().getTime() : null); representation.setTo(criteria.hasTo() ? criteria.getTo().getTime() : null); representation.setPage(criteria.getPage()); representation.setLimit(criteria.getLimit()); return representation; } CriteriaRepresentation convert(Criteria criteria); }
|
@Test public void shouldBeAbleToConvertCriteriaIntoACriteriaRepresentation() { Criteria criteria = Criteria.criteria().from(new Date()).to(new Date()).limit(10).page(1); CriteriaRepresentation representation = criteriaConversionService.convert(criteria); assertThat(representation.getPage()).isEqualTo(criteria.getPage()); assertThat(representation.getLimit()).isEqualTo(criteria.getLimit()); assertThat(representation.getFrom()).isNotNull(); assertThat(representation.getTo()).isNotNull(); }
|
ClientConversionService { public ClientRepresentation convert(Client client) { ClientRepresentation representation = new ClientRepresentation(); representation.setId(client.getId()); representation.setCreated(client.getCreated()); representation.setUpdated(client.getUpdated()); representation.setClientId(client.getClientId()); representation.setName(client.getName()); representation.setDescription(client.getDescription()); representation.setAudiences(client.getAudiences().stream().map(audience -> audienceConversionService.convert(audience)).collect(Collectors.toCollection(HashSet::new))); representation.setAuthorities(client.getAuthorities().stream().map(authority -> authorityConversionService.convert(authority)).collect(Collectors.toCollection(HashSet::new))); representation.setGrantTypes(client.getGrantTypes().stream().map(grantType -> grantTypeConversionService.convert(grantType)).collect(Collectors.toCollection(HashSet::new))); representation.setScopes(client.getScopes().stream().map(scope -> scopeConversionService.convert(scope)).collect(Collectors.toCollection(HashSet::new))); representation.setRedirectUri(client.getRedirectUri()); representation.setAccessTokenValiditySeconds(client.getAccessTokenValiditySeconds()); representation.setRefreshTokenValiditySeconds(client.getRefreshTokenValiditySeconds()); return representation; } @Autowired ClientConversionService(ScopeConversionService scopeConversionService, GrantTypeConversionService grantTypeConversionService, AuthorityConversionService authorityConversionService, AudienceConversionService audienceConversionService, AuthorityService authorityService, AudienceService audienceService, ScopeService scopeService, GrantTypeService grantTypeService); ClientRepresentation convert(Client client); Client convert(ClientRepresentation representation); Client convert(ClientRepresentation representation, Client client); }
|
@Test public void shouldBeAbleToConvertAClientIntoAClientRepresentation() { Authority authority = authority().build(); Audience audience = audience().build(); Scope scope = scope().build(); GrantType grantType = grantType().build(); Client client = client().withAudience(audience).withDescription("description").withAuthority(authority).withScope(scope).withGrantType(grantType).build(); ClientRepresentation representation = clientConversionService.convert(client); assertThat(representation.getId()).isEqualTo(client.getId()); assertThat(representation.getCreated()).isEqualTo(client.getCreated()); assertThat(representation.getUpdated()).isEqualTo(client.getUpdated()); assertThat(representation.getClientId()).isEqualTo(client.getClientId()); assertThat(representation.getClientSecret()).isNull(); assertThat(representation.getDescription()).isEqualTo("description"); assertThat(representation.getAccessTokenValiditySeconds()).isEqualTo(client.getAccessTokenValiditySeconds()); assertThat(representation.getRefreshTokenValiditySeconds()).isEqualTo(client.getRefreshTokenValiditySeconds()); assertThat(representation.getAudiences()).hasSize(1); assertThat(representation.getAuthorities()).hasSize(1); assertThat(representation.getScopes()).hasSize(1); assertThat(representation.getGrantTypes()).hasSize(1); }
@Test public void shouldBeAbleToConvertAClientRepresentationIntoANewClient() { Authority authority = authority().save(); Audience audience = audience().save(); Scope scope = scope().save(); GrantType grantType = grantType().save(); ClientRepresentation representation = ClientDSL.client().withDescription("desc").withAudiences(audienceConversionService.convert(audience)).withAuthorities(authorityConversionService.convert(authority)).withScopes(scopeConversionService.convert(scope)).withGrantTypes(grantTypeConversionService.convert(grantType)).build(); Client client = clientConversionService.convert(representation); assertThat(client.getAuthorities()).hasSize(1); assertThat(client.getAuthorities()).contains(authority); assertThat(client.getAudiences()).hasSize(1); assertThat(client.getAudiences()).contains(audience); assertThat(client.getGrantTypes()).hasSize(1); assertThat(client.getGrantTypes()).contains(grantType); assertThat(client.getScopes()).hasSize(1); assertThat(client.getScopes()).contains(scope); assertThat(client.getDescription()).isEqualTo("desc"); assertThat(client.getAccessTokenValiditySeconds()).isEqualTo(representation.getAccessTokenValiditySeconds()); assertThat(client.getRefreshTokenValiditySeconds()).isEqualTo(representation.getRefreshTokenValiditySeconds()); assertThat(client.getClientId()).isEqualTo(representation.getClientId()); assertThat(client.getClientSecret()).isEqualTo(representation.getClientSecret()); }
@Test public void shouldBeAbleToConvertAClientRepresentationIntoAnExistingClient() { Authority authority = authority().save(); Audience audience = audience().save(); Scope scope = scope().save(); GrantType grantType = grantType().save(); Client client = client().withDescription("desc").withGrantType(grantType).save(); ClientRepresentation representation = ClientDSL.client().withAudiences(audienceConversionService.convert(audience)).withAuthorities(authorityConversionService.convert(authority)).withScopes(scopeConversionService.convert(scope)).withGrantTypes(grantTypeConversionService.convert(grantType)).build(); Client updated = clientConversionService.convert(representation, client); assertThat(updated.getId()).isEqualTo(client.getId()); assertThat(updated.getCreated()).isEqualTo(client.getCreated()); assertThat(updated.getUpdated()).isEqualTo(client.getUpdated()); assertThat(updated.getClientId()).isEqualTo(client.getClientId()); assertThat(updated.getClientSecret()).isEqualTo(client.getClientSecret()); assertThat(updated.getName()).isEqualTo(client.getName()); assertThat(updated.getAuthorities()).hasSize(1); assertThat(updated.getAuthorities()).contains(authority); assertThat(updated.getAudiences()).hasSize(1); assertThat(updated.getAudiences()).contains(audience); assertThat(updated.getGrantTypes()).hasSize(1); assertThat(updated.getGrantTypes()).contains(grantType); assertThat(updated.getScopes()).hasSize(1); assertThat(updated.getScopes()).contains(scope); assertThat(updated.getRedirectUri()).isEqualTo(representation.getRedirectUri()); assertThat(updated.getName()).isEqualTo(representation.getName()); assertThat(updated.getDescription()).isEqualTo(representation.getDescription()); assertThat(updated.getAccessTokenValiditySeconds()).isEqualTo(representation.getAccessTokenValiditySeconds()); assertThat(updated.getRefreshTokenValiditySeconds()).isEqualTo(representation.getRefreshTokenValiditySeconds()); }
|
CommonPasswordsDictionary { public static List<String> list() { return passwords; } private CommonPasswordsDictionary(); static List<String> list(); static boolean contains(String password); }
|
@Test public void shouldBeAbleToListTenThousandOfTheMostCommonPasswords() { List<String> common = CommonPasswordsDictionary.list(); assertThat(common).hasSize(10000); }
|
CommonPasswordsDictionary { public static boolean contains(String password) { return StringUtils.isBlank(password) ? false : !passwords.parallelStream().filter(pw -> pw.equalsIgnoreCase(password)).collect(Collectors.toList()).isEmpty(); } private CommonPasswordsDictionary(); static List<String> list(); static boolean contains(String password); }
|
@Test public void shouldBeAbleToIdentifyCommonPasswords() { assertThat(CommonPasswordsDictionary.contains("password")).isTrue(); assertThat(CommonPasswordsDictionary.contains("midnight")).isTrue(); assertThat(CommonPasswordsDictionary.contains("123456")).isTrue(); assertThat(CommonPasswordsDictionary.contains("asdfs2342o8fhshfsd")).isFalse(); }
@Test public void shouldPerformACaseInsensitiveMatchWhenIdentifyingCommonPasswords() { assertThat(CommonPasswordsDictionary.contains("password")).isTrue(); assertThat(CommonPasswordsDictionary.contains("PASSWORD")).isTrue(); assertThat(CommonPasswordsDictionary.contains("PAsswoRD")).isTrue(); }
@Test public void shouldReturnFalseIfThePasswordToCheckIsNullOrEmpty() { assertThat(CommonPasswordsDictionary.contains(null)).isFalse(); assertThat(CommonPasswordsDictionary.contains("")).isFalse(); assertThat(CommonPasswordsDictionary.contains(" ")).isFalse(); }
|
RpcStartupHookProvider implements StartupHookProvider { @Override public void onStartup() { System.out.println("Handler scanning package = " + config.getHandlerPackage()); List<String> handlers; try (ScanResult scanResult = new ClassGraph() .whitelistPackages(config.getHandlerPackage()) .enableAllInfo() .scan()) { handlers = scanResult .getClassesWithAnnotation(ServiceHandler.class.getName()) .getNames(); } System.out.println("RpcStartupHookProvider: handlers size " + handlers.size()); for(String className: handlers) { try { Class handler = Class.forName(className); ServiceHandler a = (ServiceHandler)handler.getAnnotation(ServiceHandler.class); serviceMap.put(a.id(), (Handler)handler.getConstructor().newInstance()); System.out.println("RpcStartupHookProvider add id " + a.id() + " map to " + className); if(config.isRegisterService()) Server.serviceIds.add(a.id().replace('/', '.')); } catch (Exception e) { e.printStackTrace(); } } pathResourceProviders = SingletonServiceFactory.getBeans(PathResourceProvider.class); predicatedHandlersProviders = SingletonServiceFactory.getBeans(PredicatedHandlersProvider.class); } @Override void onStartup(); }
|
@Test public void testStartup() { RpcStartupHookProvider provider = new RpcStartupHookProvider(); provider.onStartup(); Map<String, Handler> servicesMap = provider.serviceMap; Assert.assertTrue(servicesMap.size() > 0); System.out.println("serviceMap size = " + servicesMap.size()); }
|
RpcRouterConfig { public boolean isRegisterService() { return registerService; } RpcRouterConfig(); String getDescription(); void setDescription(String description); String getHandlerPackage(); void setHandlerPackage(String handlerPackage); String getJsonPath(); void setJsonPath(String jsonPath); String getFormPath(); void setFormPath(String formPath); String getColferPath(); void setColferPath(String colferPath); String getResourcesBasePath(); void setResourcesBasePath(String resourcesBasePath); boolean isRegisterService(); void setRegisterService(boolean registerService); }
|
@Test public void testRegisterServiceTrue() { String configName = "rpc-router-true"; RpcRouterConfig config = (RpcRouterConfig) Config.getInstance().getJsonObjectConfig(configName, RpcRouterConfig.class); Assert.assertTrue(config.isRegisterService()); }
@Test public void testRegisterServiceFalse() { String configName = "rpc-router-false-package"; RpcRouterConfig config = (RpcRouterConfig) Config.getInstance().getJsonObjectConfig(configName, RpcRouterConfig.class); Assert.assertFalse(config.isRegisterService()); }
@Test public void testRegisterServiceEmpty() { String configName = "rpc-router-empty"; RpcRouterConfig config = (RpcRouterConfig) Config.getInstance().getJsonObjectConfig(configName, RpcRouterConfig.class); Assert.assertFalse(config.isRegisterService()); }
|
RpcRouterConfig { public String getHandlerPackage() { return handlerPackage; } RpcRouterConfig(); String getDescription(); void setDescription(String description); String getHandlerPackage(); void setHandlerPackage(String handlerPackage); String getJsonPath(); void setJsonPath(String jsonPath); String getFormPath(); void setFormPath(String formPath); String getColferPath(); void setColferPath(String colferPath); String getResourcesBasePath(); void setResourcesBasePath(String resourcesBasePath); boolean isRegisterService(); void setRegisterService(boolean registerService); }
|
@Test public void testHandlerPackageEmpty() { String configName = "rpc-router-empty"; RpcRouterConfig config = (RpcRouterConfig) Config.getInstance().getJsonObjectConfig(configName, RpcRouterConfig.class); List<String> handlers; try (ScanResult scanResult = new ClassGraph() .whitelistPackages(config.getHandlerPackage()) .enableAllInfo() .scan()) { handlers = scanResult .getClassesWithAnnotation(ServiceHandler.class.getName()) .getNames(); } Assert.assertTrue(handlers.size() > 0); }
@Test public void testHandlerPackageSingle() { String configName = "rpc-router-false-package"; RpcRouterConfig config = (RpcRouterConfig) Config.getInstance().getJsonObjectConfig(configName, RpcRouterConfig.class); List<String> handlers; try (ScanResult scanResult = new ClassGraph() .whitelistPackages(config.getHandlerPackage()) .enableAllInfo() .scan()) { handlers = scanResult .getClassesWithAnnotation(ServiceHandler.class.getName()) .getNames(); } Assert.assertTrue(handlers.size() > 0); }
|
StringMethods { public String checkExtension(final String path) { if (path.equals("") || path.length() < EXTENSION.length() || !path.substring(path.length() - EXTENSION.length(), path.length()).equals(EXTENSION)) { return path + EXTENSION; } return path; } private StringMethods(); static StringMethods getInstance(); String fixPath(final String path); String checkExtension(final String path); String getNameDB(final String path); static boolean containsIgnoreCase(String str, String searchStr); static final String DEFAULT_FOLDER; }
|
@Test public void When_CheckExtensionIsCalled_Expect_CorrectStringReturned() { assertThat(stringMethods.checkExtension(TEST_PATH), is("/test_path/file_name.ncf")); assertThat(stringMethods.checkExtension(".ncf"), is(".ncf")); }
|
StringMethods { public String getNameDB(final String path) { if (path.length() < EXTENSION.length() || !path.substring(path.length() - EXTENSION.length(), path.length()).equals(EXTENSION)) { return path.substring(path.lastIndexOf('/') + 1, path.length()); } return path.substring(path.lastIndexOf('/') + 1, path.length() - EXTENSION.length()); } private StringMethods(); static StringMethods getInstance(); String fixPath(final String path); String checkExtension(final String path); String getNameDB(final String path); static boolean containsIgnoreCase(String str, String searchStr); static final String DEFAULT_FOLDER; }
|
@Test public void When_GetNameDBIsCalled_Expect_CorrectStringReturned() { assertThat(stringMethods.getNameDB(TEST_PATH), is("file_name")); }
|
StringMethods { public static boolean containsIgnoreCase(String str, String searchStr) { if (str != null && searchStr != null) { int len = searchStr.length(); int max = str.length() - len; for (int i = 0; i <= max; ++i) { if (str.regionMatches(true, i, searchStr, 0, len)) { return true; } } return false; } else { return false; } } private StringMethods(); static StringMethods getInstance(); String fixPath(final String path); String checkExtension(final String path); String getNameDB(final String path); static boolean containsIgnoreCase(String str, String searchStr); static final String DEFAULT_FOLDER; }
|
@Test public void When_ContainsIgnoreCaseIsCalled_Expect_CorrectResult() { assertThat(containsIgnoreCase("STRING1", "StRiNg1"), is(true)); assertThat(containsIgnoreCase("STRING1", "StRiNg12"), is(false)); }
|
PlaylistParser { public static Playlist parse(final InputStream inputStream) { if (inputStream == null) { throw new IllegalArgumentException("Input stream is null!"); } List<Playlist.Track> tracks = new ArrayList<>(); int version = -1, entries = -1; BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream)); try { String line; while ((line = reader.readLine()) != null) { Matcher fileMatcher = FILE_PATTERN.matcher(line); if (fileMatcher.matches()) { int trackIndex = getTrackIndexAndAddIfMissing(tracks, fileMatcher); tracks.get(trackIndex).file = fileMatcher.group(2).trim(); continue; } Matcher titleMatcher = TITLE_PATTERN.matcher(line); if (titleMatcher.matches()) { int trackIndex = getTrackIndexAndAddIfMissing(tracks, titleMatcher); tracks.get(trackIndex).title = titleMatcher.group(2).trim(); continue; } Matcher lengthMatcher = LENGTH_PATTERN.matcher(line); if (lengthMatcher.matches()) { int trackIndex = getTrackIndexAndAddIfMissing(tracks, lengthMatcher); tracks.get(trackIndex).length = Long.valueOf(lengthMatcher.group(2).trim()); continue; } Matcher numberOfEntries = FOOTER_NUMBER_OF_ENTRIES_PATTERN.matcher(line); if (numberOfEntries.matches()) { entries = Integer.valueOf(numberOfEntries.group(1).trim()); continue; } Matcher versionMatcher = FOOTER_VERSION_PATTERN.matcher(line); if (versionMatcher.matches()) { version = Integer.valueOf(versionMatcher.group(1).trim()); } } } catch (IOException e) { Log.e(TAG, "Failed to parse playlist file: " + e); } if (tracks.size() != entries) { Log.w(TAG, "Parsed track count doesn't match proclaimed NumberOfEntries"); } return new Playlist(tracks, version); } private PlaylistParser(); static Playlist parse(final InputStream inputStream); static Playlist parse(final String string, final String encoding); static Playlist parse(final String string); }
|
@Test public void parseInputStream() throws UnsupportedEncodingException { Playlist playlist = PlaylistParser.parse(new ByteArrayInputStream(TEST_PLS.getBytes(ENCODING_UTF8))); assertNotNull(playlist); assertEquals(TEST_PLAYLIST_SIZE, playlist.getTracks().size()); assertEquals(TEST_PLAYLIST_VERSION, playlist.getVersion()); Playlist.Track track1 = playlist.getTracks().get(0); assertEquals("http: assertEquals(null, track1.getTitle()); assertEquals(-1, track1.getLength()); Playlist.Track track2 = playlist.getTracks().get(1); assertEquals("example2.mp3", track2.getFile()); assertEquals("Just some local audio that is 2mins long", track2.getTitle()); assertEquals(120, track2.getLength()); Playlist.Track track3 = playlist.getTracks().get(2); assertEquals("F:\\Music\\whatever.m4a", track3.getFile()); assertEquals("absolute path on Windows", track3.getTitle()); assertEquals(0, track3.getLength()); Playlist.Track track4 = playlist.getTracks().get(3); assertEquals("%UserProfile%\\Music\\short.ogg", track4.getFile()); assertEquals("example for an Environment variable", track4.getTitle()); assertEquals(5, track4.getLength()); }
@Test public void parseStringWithCustomUtf8Encoding() throws UnsupportedEncodingException { Playlist playlist = PlaylistParser.parse(TEST_PLS, ENCODING_UTF8); assertNotNull(playlist); assertEquals(TEST_PLAYLIST_SIZE, playlist.getTracks().size()); assertEquals(TEST_PLAYLIST_VERSION, playlist.getVersion()); }
@Test public void parseStringWithCustomAsciiEncoding() throws UnsupportedEncodingException { Playlist playlist = PlaylistParser.parse(TEST_PLS, ENCODING_ASCII); assertNotNull(playlist); assertEquals(TEST_PLAYLIST_SIZE, playlist.getTracks().size()); assertEquals(TEST_PLAYLIST_VERSION, playlist.getVersion()); }
@Test public void parseString() { Playlist playlist = PlaylistParser.parse(TEST_PLS); assertNotNull(playlist); assertEquals(TEST_PLAYLIST_SIZE, playlist.getTracks().size()); assertEquals(TEST_PLAYLIST_VERSION, playlist.getVersion()); }
@Test public void parseNullInputStream() { expectedException.expect(IllegalArgumentException.class); PlaylistParser.parse((InputStream) null); }
@Test public void parseNullString() { expectedException.expect(IllegalArgumentException.class); PlaylistParser.parse((String) null); }
|
Playlist { Playlist(final List<Track> tracks, final int version) { this.tracks = tracks; this.version = version; } Playlist(final List<Track> tracks, final int version); List<Track> getTracks(); int getVersion(); @Override String toString(); }
|
@Test public void playlist() { List<Playlist.Track> tracks = new ArrayList<>(); tracks.add(new Playlist.Track()); Playlist playlist = new Playlist(tracks, TEST_VERSION); assertEquals(TEST_VERSION, playlist.getVersion()); assertEquals(tracks, playlist.getTracks()); assertEquals(1, playlist.getTracks().size()); }
|
DefaultCommonDao implements ICommonDao { @Override public <T> PaginationSupport<T> queryForPaginatedPojoList(String sql, Object[] args, Class<T> pojoType, RowSelection rowSelection) throws DataAccessException { return PaginatedRepairerFactory.getInstance(dbType).queryForPaginatedPojoList(dataSource, sql, args, pojoType, rowSelection); } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testQueryForPaginatedPojoList() { fail("Not yet implemented"); }
|
DefaultCommonDao implements ICommonDao { @Override public int updateByPhysical(Object... pojos) throws DataAccessException { int r = 0; for (Object obj : pojos) { SqlUpdGenerator sqlGenerator = new SqlUpdGenerator(obj, true); try { r += execute(sqlGenerator.getSql(), sqlGenerator.getArgs()); } catch (IllegalArgumentException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } catch (IllegalAccessException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } catch (NoSuchFieldException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } catch (SecurityException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } catch (ParseException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } } return r; } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testUpdateByPhysical() { UserInfoPO pojo = new UserInfoPO(); pojo.setPkId(2L); pojo.setEmail("[email protected]"); dao.updateByPhysical(pojo); System.out.println("fin"); }
|
DefaultCommonDao implements ICommonDao { @Override public int deleteByLogic(Object... pojos) throws DataAccessException { int r = 0; for (Object obj : pojos) { try { SqlDelGenerator sqlGenerator = new SqlDelGenerator(obj, false); r += execute(sqlGenerator.getSql(), sqlGenerator.getArgs()); } catch (IllegalArgumentException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } catch (IllegalAccessException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } catch (NoSuchFieldException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } catch (SecurityException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } catch (SQLException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } } return r; } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testDeleteByLogic() { fail("Not yet implemented"); }
|
DefaultCommonDao implements ICommonDao { @Override public <T> int delete(Class<T> pojoType, Map<String, Object> args) throws DataAccessException { SqlDelGenerator sqlGenerator = new SqlDelGenerator(pojoType, args); try { int r = execute(sqlGenerator.getSql(), sqlGenerator.getArgs()); return r; } catch (IllegalArgumentException e) { logger.error("init delete sql error!", e); throw new DataAccessException("init delete sql error!", e); } catch (IllegalAccessException e) { logger.error("init delete sql error!", e); throw new DataAccessException("init delete sql error!", e); } catch (NoSuchFieldException e) { logger.error("init delete sql error!", e); throw new DataAccessException("init delete sql error!", e); } catch (SecurityException e) { logger.error("init delete sql error!", e); throw new DataAccessException("init delete sql error!", e); } catch (SQLException e) { logger.error("init delete sql error!", e); throw new DataAccessException("init delete sql error!", e); } } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testDelete() { Map<String, Object> args = new HashMap<String, Object>(); args.put("id", 1L); args.put("userId", 1L); int i = dao.delete(UserNotifyPO.class, args); System.out.println("size:" + i); }
|
DefaultCommonDao implements ICommonDao { @Override public int deleteByPhysical(Object... pojos) throws DataAccessException { int r = 0; for (Object obj : pojos) { try { SqlDelGenerator sqlGenerator = new SqlDelGenerator(obj, true); r += execute(sqlGenerator.getSql(), sqlGenerator.getArgs()); } catch (IllegalArgumentException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } catch (IllegalAccessException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } catch (NoSuchFieldException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } catch (SecurityException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } catch (SQLException e) { logger.error("init delete sql error! exec number : {}", r, e); throw new DataAccessException("init delete sql error!", e); } } return r; } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testDeleteByPhysical() { fail("Not yet implemented"); }
@Test public void testDeleteByPhysicalClzObject() { int i = dao.deleteByPhysical(UserNotifyPO.class, 1L); System.out.println("size:" + i); }
|
DefaultCommonDao implements ICommonDao { @Override public int insert(Object... pojos) throws DataAccessException { int r = 0; Map<String, List<Object[]>> sqlAndArgsList = new HashMap<String, List<Object[]>>(); Map<String, List<Object>> sqlPojosMapping = new HashMap<String, List<Object>>(); try { for (Object obj : pojos) { SqlInsGenerator sqlGenerator = new SqlInsGenerator(obj); String sql = sqlGenerator.getSql(); if (sqlAndArgsList.containsKey(sql)) { sqlAndArgsList.get(sql).add(sqlGenerator.getArgs()); sqlPojosMapping.get(sql).add(obj); } else { List<Object[]> argsList = new ArrayList<Object[]>(); argsList.add(sqlGenerator.getArgs()); sqlAndArgsList.put(sql, argsList); List<Object> objsList = new ArrayList<Object>(); objsList.add(obj); sqlPojosMapping.put(sql, objsList); } } } catch (IllegalArgumentException e) { logger.error("init insert sql error! exec number : {}", r, e); throw new DataAccessException("init insert sql error!", e); } catch (IllegalAccessException e) { logger.error("init insert sql error! exec number : {}", r, e); throw new DataAccessException("init insert sql error!", e); } catch (NoSuchFieldException e) { logger.error("init insert sql error! exec number : {}", r, e); throw new DataAccessException("init insert sql error!", e); } catch (SecurityException e) { logger.error("init insert sql error! exec number : {}", r, e); throw new DataAccessException("init insert sql error!", e); } Connection conn; try { conn = getConnection(); } catch (SQLException e) { logger.error("Get connection from datasource error", e); throw new DataAccessException("Get connection from datasource error!", e); } try { for (String sql : sqlAndArgsList.keySet()) { int[] ii = batchUpdate(conn, sql, sqlAndArgsList.get(sql)); SelectKey selectKey = SqlRepairer.getSelectKey(dbType); if (selectKey != null) { List<Object> objs = sqlPojosMapping.get(sql); if (objs != null && !objs.isEmpty()) { IdentityFinder identityFinder = new IdentityFinder(conn, selectKey); try { identityFinder.find(objs.toArray()); } catch (IllegalArgumentException e) { logger.error("find identity!", e); throw new DataAccessException("find identity error!", e); } catch (IllegalAccessException e) { logger.error("find identity!", e); throw new DataAccessException("find identity error!", e); } catch (SQLException e) { logger.error("find identity!", e); throw new DataAccessException("find identity error!", e); } } } for (int i : ii) { if (DBType.MYSQL.equals(this.dbType)) { r += (i == -2 ? 1 : 0); } else { r += i; } } } } finally { try { close(conn); } catch (SQLException e) { throw new DataAccessException("close connection error!", e); } } return r; } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testInsert() { UserNotifyPO poa = new UserNotifyPO(); poa.setUserId(1L); poa.setType(1); int i = dao.insert(poa); System.out.println("size:" + i); ActiveDevicePO po = new ActiveDevicePO(); po.setAgent("test0"); po.setChannel("test0"); po.setCreateTime(new Date()); po.setImei("1230"); po.setPlatform("test0"); po.setVendor("test0"); po.setVersion("10"); ActiveDevicePO po1 = new ActiveDevicePO(); po1.setId(1L); po1.setAgent("test1"); po1.setChannel("test1"); po1.setCreateTime(new Date()); po1.setImei("1231"); po1.setPlatform("test1"); po1.setVendor("test1"); po1.setVersion("11"); dao.insert(po, po1); System.out.println(po1.getId()); System.out.println(po.getId()); UserPO user = new UserPO(); user.setId(123455L); dao.insert(user); }
|
OraclePaginatedRepairer extends AbstractPaginatedRepairer { @Override public <T> PaginationSupport<T> queryForPaginatedPojoList( DataSource dataSource, String sql, Object[] args, Class<T> pojoType, RowSelection rowSelection) throws DataAccessException { StringBuilder cSql = new StringBuilder("select count(1) from ("); cSql.append(sql) .append(") mt"); StringBuilder nSql = new StringBuilder("select * from ("); nSql.append("select ROWNUM rw, mt.* from (") .append(sql) .append(" ORDER BY ") .append(rowSelection.getOrder()) .append(" ") .append(rowSelection.getSort().getValue()) .append(") mt "); nSql.append(") mst where mst.rw between ? and ? "); PaginationSupport<T> ps = new PaginationSupport<T>(); BigDecimal count = query(dataSource, cSql.toString(), args, new ScalarHandler<BigDecimal>()); ps.setTotalCount(count.intValue()); ps.setPageSize(rowSelection.getPageSize()); ps.setPageCount((int) (ps.getTotalCount() / ps.getPageSize() + (ps.getTotalCount() % ps.getPageSize() == 0 ? 0 : 1 ))); int ccr = rowSelection.getStartPage() * rowSelection.getPageSize(); if (ps.getTotalCount() <= ccr) { ps.setCurrentPage(rowSelection.getStartPage()); ps.setObject(new ArrayList<T>()); } else { ps.setCurrentPage(rowSelection.getStartPage()); Object[] nArgs = new Object[args.length + 2]; for (int i = 0; i < args.length; i++) { nArgs[i] = args[i]; } nArgs[args.length] = ccr; nArgs[args.length + 1] = ccr + rowSelection.getPageSize() - 1; List<T> ls = query(dataSource, nSql.toString(), nArgs, new PojoListResultSetExtractor<T>(pojoType)); ps.setObject(ls); } return ps; } OraclePaginatedRepairer(); @Override PaginationSupport<T> queryForPaginatedPojoList(
DataSource dataSource, String sql, Object[] args,
Class<T> pojoType, RowSelection rowSelection); }
|
@Test public void testQueryForPaginatedPojoList() { String sql = "select * from t_account"; Object[] args = {}; Class<?> pojoType = TestPO.class; RowSelection rowSelection = new RowSelection(0, 10, "pk_id"); PaginationSupport<?> ps = instance.queryForPaginatedPojoList(dataSource, sql, args, pojoType, rowSelection); System.out.println(ps.getObject().size()); }
|
MySQLPaginatedRepairer extends AbstractPaginatedRepairer { @Override public <T> PaginationSupport<T> queryForPaginatedPojoList(DataSource dataSource, String sql, Object[] args, Class<T> pojoType, RowSelection rowSelection) throws DataAccessException { StringBuilder cSql = new StringBuilder("select count(1) from ("); cSql.append(sql) .append(") mt"); StringBuilder nSql = new StringBuilder(sql); nSql.append(" ORDER BY ") .append(rowSelection.getOrder()) .append(" ") .append(rowSelection.getSort().getValue()) .append(" limit ?, ?"); PaginationSupport<T> ps = new PaginationSupport<T>(); Long count = query(dataSource, cSql.toString(), args, new ScalarHandler<Long>()); ps.setTotalCount(count); ps.setPageSize(rowSelection.getPageSize()); ps.setPageCount((int) (ps.getTotalCount() / ps.getPageSize() + (ps.getTotalCount() % ps.getPageSize() == 0 ? 0 : 1 ))); int ccr = rowSelection.getStartPage() * rowSelection.getPageSize(); if (ps.getTotalCount() <= ccr) { ps.setCurrentPage(rowSelection.getStartPage()); ps.setObject(new ArrayList<T>()); } else { ps.setCurrentPage(rowSelection.getStartPage()); Object[] nArgs = new Object[args.length + 2]; for (int i = 0; i < args.length; i++) { nArgs[i] = args[i]; } nArgs[args.length] = ccr; nArgs[args.length + 1] = rowSelection.getPageSize(); List<T> ls = query(dataSource, nSql.toString(), nArgs, new PojoListResultSetExtractor<T>(pojoType)); ps.setObject(ls); } return ps; } MySQLPaginatedRepairer(); @Override PaginationSupport<T> queryForPaginatedPojoList(DataSource dataSource, String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); }
|
@Test public void testQueryForPaginatedPojoList() { String sql = "select * from t_litigation_record"; Object[] args = {}; Class<?> pojoType = TestPO.class; RowSelection rowSelection = new RowSelection(0, 10, "id"); PaginationSupport<?> ps = instance.queryForPaginatedPojoList(dataSource, sql, args, pojoType, rowSelection); System.out.println(ps.getObject().size()); }
|
SqlUpdGenerator implements Generator { public String getSql() throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ParseException { if (sql == null) { generate(); } return sql; } SqlUpdGenerator(); SqlUpdGenerator(Object pojo, boolean usePhysicalPk); String getSql(); Object[] getArgs(); }
|
@Test public void testGetSql() throws IllegalArgumentException, SecurityException, IllegalAccessException, NoSuchFieldException, ParseException { UserPO po = new UserPO(); po.setId(1L); SqlUpdGenerator generator = new SqlUpdGenerator(po, true); System.out.println(generator.getSql()); Object[] args = generator.getArgs(); for (Object arg : args) { System.out.print(arg + ","); } }
|
ParamTransformGenerator implements Generator { public void generate() throws DataAccessException { if (oraSql == null || "".equalsIgnoreCase(oraSql.trim())) { throw new DataAccessException("SQL is null"); } List<Object> arglist = new ArrayList<Object>(); Pattern p = Pattern.compile(PATTERN); Matcher m = p.matcher(oraSql); while (m.find()) { String key = m.group(); if (!params.containsKey(key.substring(1))) { throw new DataAccessException("Params not contains key~" + key + ";"); } arglist.add(params.get(key.substring(1))); } sql = oraSql.replaceAll(PATTERN, "?"); args = arglist.toArray(); } ParamTransformGenerator(String sql, Map<String, Object> params); void generate(); String getSql(); Object[] getArgs(); }
|
@Test public void testGenerate() { String sql = " select * from abc where a=:test1 and b like :test2 an p = :test1"; Map<String, Object> params = new HashMap<String, Object>(); params.put("test1", 1); params.put("test2", "%t"); ParamTransformGenerator generator = new ParamTransformGenerator(sql, params); generator.generate(); Assert.assertTrue(" select * from abc where a=? and b like ? an p = ?".equals(generator.getSql())); Assert.assertTrue(generator.getArgs().length == 3); }
|
DefaultCommonDao implements ICommonDao { @Override public List<Map<String, Object>> queryForMapList(String sql, Object... args) throws DataAccessException { return (List<Map<String, Object>>) query(sql, args, new MapListResultSetExtractor()); } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testQueryForMapList() { List<Map<String, Object>> ls = dao.queryForMapList("select * from cache_push where show_time <= ? AND status = ? LIMIT 180;", new Date(), 1); for (Map<String, Object> map : ls) { System.out.println(map.get("push_id")); } }
@Test public void testQueryForMapListStringMap() { Map<String, Object> params = new HashMap<String, Object>(); params.put("id", 1); List<Map<String, Object>> ls = dao.queryForMapList("select * from T_USER where id = :id", params); for (Map<String, Object> map : ls) { System.out.println(map.get("USER_NAME")); } }
|
SqlSelHashGenerator extends SqlSelGenerator implements Generator { public String[] getSqls() throws IllegalAccessException { if (sqls == null) { generateParam(); } return sqls.toArray(new String[0]); } SqlSelHashGenerator(); SqlSelHashGenerator(Class<?> pojoClazz, Map<String, Object[]> args); List<Object[]> getArgsObjs(); String[] getSqls(); }
|
@Test public void testGetSqls() throws IllegalAccessException { Map<String, Object[]> args = new HashMap<String, Object[]>(); args.put("id", new Object[]{1,101,2,102,3}); args.put("cnt", new Object[]{"123"}); SqlSelHashGenerator sqlGen = new SqlSelHashGenerator(DemoHashTable.class, args); String[] sqls = sqlGen.getSqls(); List<Object[]> rArgs = sqlGen.getArgsObjs(); for (int i = 0; i < sqls.length; i++) { System.out.println(sqls[i]); System.out.println(rArgs.get(i).length); } }
|
SqlSelGenerator implements Generator { public String getSql() throws IllegalAccessException { if (sql == null) { generateParam(); } return sql; } SqlSelGenerator(); SqlSelGenerator(Class<?> pojoClazz, Map<String, Object[]> args); Object[] getArgs(); String getSql(); Class<?> getPojoClazz(); void setPojoClazz(Class<?> pojoClazz); }
|
@Test public void testGetSql() throws IllegalAccessException { Map<String, Object[]> args = new HashMap<String, Object[]>(); args.put("id", new Object[]{1,2,3}); SqlSelGenerator sqlGen = new SqlSelGenerator(DemoTablePO.class, args); System.out.println(sqlGen.getSql()); System.out.println(sqlGen.getArgs().length); }
|
RedisWeakCachedCommonDao extends DefaultCommonDao { @SuppressWarnings("unchecked") @Override public <T> T queryForPojoOne(Class<T> pojoType, Map<String, Object> args) throws DataAccessException { Jedis jedis = getJedis(); if (jedis != null) { try { T t = null; ORMTable ormTable = pojoType.getAnnotation(ORMTable.class); String cachedTableKey = "".equalsIgnoreCase(ormTable.cachedShortAlias()) ? ormTable.tableName() : ormTable.cachedShortAlias(); String[] cachedKeys = ormTable.cachedKey(); for (String cachedKey : cachedKeys) { String[] ks = cachedKey.split("="); Object arg = args.get(ks[0]); if (arg != null) { String key = cachedTableKey + "." + ks[1] + "." + String.valueOf(arg); T obj = null; try { obj = (T) getCache(jedis, key); } catch (ClassNotFoundException e) { logger.warn("Get from cache fail!", e); } catch (IOException e) { logger.warn("Get from cache fail!", e); } if (obj != null) { t = obj; break; } } } if (t != null) { return t; } else { t = super.queryForPojoOne(pojoType, args); if (t != null) { for (String cachedKey : cachedKeys) { String[] fk = cachedKey.split("="); try { Field f = t.getClass().getDeclaredField(fk[0]); f.setAccessible(true); String key = cachedTableKey + "." + fk[1] + "." + f.get(t); setCache(jedis, key, t); } catch (Exception e) { logger.warn("Set to cache fail!", e); } } } } return t; } finally { jedisPool.returnResource(jedis); } } else { return super.queryForPojoOne(pojoType, args); } } RedisWeakCachedCommonDao(); void setJedisPool(JedisPool jedisPool); void setCacheSeconds(int cacheSeconds); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @SuppressWarnings("unchecked") @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); }
|
@Test public void testQueryForPojoOne() { Map<String, Object> args = new HashMap<String, Object>(); args.put("id", "123"); UserPO user = dao.queryForPojoOne(UserPO.class, args); System.out.println(user.getId()); }
|
RedisWeakCachedCommonDao extends DefaultCommonDao { @Override public int deleteByPhysical(Object... pojos) throws DataAccessException { int r = super.deleteByPhysical(pojos); deleteCache(pojos); return r; } RedisWeakCachedCommonDao(); void setJedisPool(JedisPool jedisPool); void setCacheSeconds(int cacheSeconds); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @SuppressWarnings("unchecked") @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); }
|
@Test public void testDeleteByPhysical() { UserPO user = new UserPO(); user.setId(123L); dao.deleteByPhysical(user); }
|
GenerationCodeJDBC implements IGenerationCode { @Override public void generate(String pack, String outputFolder, boolean useDefault) { try { List<Table> tables = gainTables(); buildSource(pack, outputFolder, tables, useDefault); } catch (Exception e) { logger.error("build source error!", e); } } GenerationCodeJDBC(); @Override void generate(String pack, String outputFolder, boolean useDefault); @Override void generatePrefix(String prefix, String pack, String outputFolder, boolean useDefault); @Override void generateTable(String tableName, String pack, String outputFolder, boolean useDefault); void setDataSource(DataSource dataSource); void setXADataSource(XADataSource dataSource); void setConnection(Connection connection); }
|
@Test public void testGenerate() { boolean useDefault = false; generationCodeJDBC.generate("cn.org.zeronote.modules.plugin.admin.po", "/Test/services", useDefault); }
@Test public void testGenerateUseDefault() { boolean useDefault = true; generationCodeJDBC.generate("cn.org.zeronote.modules.plugin.admin.po", "/Test/services", useDefault); }
|
GenerationCodeJDBC implements IGenerationCode { @Override public void generatePrefix(String prefix, String pack, String outputFolder, boolean useDefault) { try { List<Table> tables = gainTables(); List<Table> tabs = new ArrayList<Table>(); for (Table table : tables) { if (table.getTableName().startsWith(prefix)) { tabs.add(table); logger.info("Generat table:{}", table.getTableName()); } } if (!tabs.isEmpty()) { buildSource(pack, outputFolder, tabs, useDefault); } else { logger.warn("No table have be Generate!"); } } catch (Exception e) { logger.error("build source error!", e); } } GenerationCodeJDBC(); @Override void generate(String pack, String outputFolder, boolean useDefault); @Override void generatePrefix(String prefix, String pack, String outputFolder, boolean useDefault); @Override void generateTable(String tableName, String pack, String outputFolder, boolean useDefault); void setDataSource(DataSource dataSource); void setXADataSource(XADataSource dataSource); void setConnection(Connection connection); }
|
@Test public void testGeneratePrefix() { boolean useDefault = false; generationCodeJDBC.generatePrefix("user_", "cn.org.zeronote.modules.plugin.admin.po", "/Test/services", useDefault); }
@Test public void testGeneratePrefixUseDefault() { boolean useDefault = true; generationCodeJDBC.generatePrefix("user_", "cn.org.zeronote.modules.plugin.admin.po", "/Test/services", useDefault); }
|
GenerationCodeJDBC implements IGenerationCode { @Override public void generateTable(String tableName, String pack, String outputFolder, boolean useDefault) { try { List<Table> tables = gainTables(); List<Table> tabs = new ArrayList<Table>(); for (Table table : tables) { if (table.getTableName().equals(tableName)) { tabs.add(table); logger.info("Generat table:{}", tableName); break; } } if (!tabs.isEmpty()) { buildSource(pack, outputFolder, tabs, useDefault); } else { logger.warn("No table have be Generate!"); } } catch (Exception e) { logger.error("build source error!", e); } } GenerationCodeJDBC(); @Override void generate(String pack, String outputFolder, boolean useDefault); @Override void generatePrefix(String prefix, String pack, String outputFolder, boolean useDefault); @Override void generateTable(String tableName, String pack, String outputFolder, boolean useDefault); void setDataSource(DataSource dataSource); void setXADataSource(XADataSource dataSource); void setConnection(Connection connection); }
|
@Test public void testGenerateTable() { boolean useDefault = false; generationCodeJDBC.generateTable("user_notify", "cn.org.zeronote.modules.plugin.admin.po", "/Test/services", useDefault); }
@Test public void testGenerateTableUseDefault() { boolean useDefault = true; generationCodeJDBC.generateTable("user_notify", "cn.org.zeronote.modules.plugin.admin.po", "/Test/services", useDefault); }
|
DefaultCommonDao implements ICommonDao { @Override public <T> List<T> queryForPojoList(String sql, Object[] args, Class<T> pojoType) throws DataAccessException { return (List<T>) query(sql, args, new PojoListResultSetExtractor<T>(pojoType)); } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testQueryForPojoListClassOfTMapOfStringObject() { Map<String, Object> args = new HashMap<String, Object>(); List<UserPO> users = dao.queryForPojoList(UserPO.class, args); for (UserPO po : users) { System.out.println(po.isCanUpdate()); } }
|
DefaultCommonDao implements ICommonDao { @SuppressWarnings("unchecked") @Override public <T> T queryForSimpObject(String sql, Object[] args, Class<T> requiredType) throws DataAccessException { Object o = query(sql, args, new ScalarHandler<Object>()); return (T) convertValueToRequiredType(o, requiredType); } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testQueryForSimpObject() { fail("Not yet implemented"); }
|
DefaultCommonDao implements ICommonDao { @Override public <T> List<T> queryForSimpObjectList(String sql, Object[] args, Class<T> requiredType) throws DataAccessException { List<T> o = query(sql, args, new SimpListResultSetExtractor<T>(requiredType)); return o; } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testQueryForSimpObjectList() { fail("Not yet implemented"); }
|
DefaultCommonDao implements ICommonDao { @Override public <T> T queryForPojoOne(Class<T> pojoType, Map<String, Object> args) throws DataAccessException { Map<String, Object[]> argsMap = new HashMap<String, Object[]>(); for (String key : args.keySet()) { argsMap.put(key, new Object[]{args.get(key)}); } SqlSelGenerator sqlGenerator = new SqlSelGenerator(pojoType, argsMap); String sql; Object[] objArgs; try { sql = sqlGenerator.getSql(); objArgs = sqlGenerator.getArgs(); } catch (IllegalAccessException e) { logger.error("init query sql error!", e); throw new DataAccessException("init query sql error!", e); } return (T) query(sql, objArgs, new PojoResultSetExtractor<T>(pojoType)); } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testQueryForPojoOne() { fail("Not yet implemented"); }
|
DefaultCommonDao implements ICommonDao { @Override public <T> T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor) throws DataAccessException { return query(sql, args, resultSetExtractor); } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testQueryCallback() { fail("Not yet implemented"); }
|
DefaultCommonDao implements ICommonDao { @Override public int update(String sql, Object... args) throws DataAccessException { return execute(sql, args); } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testUpdate() { fail("Not yet implemented"); }
|
DefaultCommonDao implements ICommonDao { @Override public int updateByLogic(Object... pojos) throws DataAccessException { int r = 0; for (Object obj : pojos) { SqlUpdGenerator sqlGenerator = new SqlUpdGenerator(obj, false); try { r += execute(sqlGenerator.getSql(), sqlGenerator.getArgs()); } catch (IllegalArgumentException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } catch (IllegalAccessException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } catch (NoSuchFieldException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } catch (SecurityException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } catch (ParseException e) { logger.error("init update sql error! exec number : {}", r, e); throw new DataAccessException("init update sql error!", e); } } return r; } DefaultCommonDao(); @Override PaginationSupport<T> queryForPaginatedPojoList(String sql,
Object[] args, Class<T> pojoType, RowSelection rowSelection); @Override PaginationSupport<T> queryForPaginatedPojoList(
Class<T> pojoType, Map<String, Object> args,
RowSelection rowSelection); @Override List<Map<String, Object>> queryForMapList(String sql, Object... args); @Override List<Map<String, Object>> queryForMapList(String sql, Map<String, Object> params); @Override List<T> queryForPojoList(String sql, Object[] args,
Class<T> pojoType); @Override List<T> queryForPojoList(String sql, Map<String, Object> params,
Class<T> pojoType); @Override List<T> queryForPojoList(Class<T> pojoType, Map<String, Object> args); @Override List<T> queryForPojoList(Class<T> pojoType, String col, Object... args); @SuppressWarnings("unchecked") @Override T queryForSimpObject(String sql, Object[] args, Class<T> requiredType); @Override List<T> queryForSimpObjectList(String sql, Object[] args,
Class<T> requiredType); @Override T queryForPojoOne(Class<T> pojoType, Map<String, Object> args); @Override T queryCallback(String sql, Object[] args, ResultSetExtractor<T> resultSetExtractor); @Override int update(String sql, Object... args); @Override int updateByLogic(Object... pojos); @Override int updateByPhysical(Object... pojos); @Override int deleteByLogic(Object... pojos); @Override int deleteByPhysical(Object... pojos); @Override int delete(Class<T> pojoType, Map<String, Object> args); @Override int deleteByLogic(Class<T> pojoType, Object... args); @Override int deleteByPhysical(Class<T> pojoType, Object... args); @Override int insert(Object... pojos); @Override int[] batchUpdate(String sql, List<Object[]> argsList); @Override int[] batchUpdateByLogic(Class<T> pojoType, T... pojos); @Override int[] batchUpdateByPhysical(Class<T> pojoType, T... pojos); void setDataSource(DataSource dataSource); void setDbType(DBType dbType); }
|
@Test public void testUpdateByLogic() { fail("Not yet implemented"); }
|
KiqrCodec implements MessageCodec<T, T> { @Override public T transform(T object) { return object; } KiqrCodec(Class<T> clazz); @Override void encodeToWire(Buffer buffer, T object); @Override T decodeFromWire(int pos, Buffer buffer); @Override T transform(T object); @Override String name(); @Override byte systemCodecID(); }
|
@Test public void passThrough(){ KeyBasedQuery result = uut.transform(new KeyBasedQuery("store", "key serde", "key".getBytes(), "value serde")); assertThat(result.getStoreName(), is(equalTo("store"))); assertThat(result.getKeySerde(), is(equalTo("key serde"))); assertThat(new String(result.getKey()), is(equalTo("key"))); assertThat(result.getValueSerde(), is(equalTo("value serde"))); }
|
KiqrCodec implements MessageCodec<T, T> { @Override public byte systemCodecID() { return -1; } KiqrCodec(Class<T> clazz); @Override void encodeToWire(Buffer buffer, T object); @Override T decodeFromWire(int pos, Buffer buffer); @Override T transform(T object); @Override String name(); @Override byte systemCodecID(); }
|
@Test public void id(){ byte b = uut.systemCodecID(); assertThat(b, is(equalTo((byte) -1))); }
|
RuntimeVerticle extends AbstractVerticle { protected KafkaStreams createAndStartStream(){ streams = new KafkaStreams(builder, props); streams.setStateListener(((newState, oldState) -> { vertx.eventBus().publish(Config.CLUSTER_STATE_BROADCAST_ADDRESS, newState.toString()); LOG.info("State change in KafkaStreams recorded: oldstate=" + oldState + ", newstate=" + newState); if(listener != null) listener.onChange(newState, oldState); })); streams.start(); return streams; } protected RuntimeVerticle(KStreamBuilder builder, Properties props, KafkaStreams.StateListener listener); @Override void start(Future<Void> startFuture); @Override void stop(Future<Void> stopFuture); }
|
@Test public void successfulStart(TestContext context){ KafkaStreams streamsMock = mock(KafkaStreams.class); KStreamBuilder builderMock = mock(KStreamBuilder.class); Properties props = new Properties(); RuntimeVerticle verticleSpy = spy(new RuntimeVerticle(builderMock, props, null)); doReturn(streamsMock).when(verticleSpy).createAndStartStream(); rule.vertx().deployVerticle(verticleSpy, context.asyncAssertSuccess(handler -> { context.assertTrue(rule.vertx().deploymentIDs().size() > 0); })); }
@Test public void failingStart(TestContext context){ KafkaStreams streamsMock = mock(KafkaStreams.class); KStreamBuilder builderMock = mock(KStreamBuilder.class); Properties props = new Properties(); RuntimeVerticle verticleSpy = spy(new RuntimeVerticle(builderMock, props, null)); doThrow(RuntimeException.class).when(verticleSpy).createAndStartStream(); rule.vertx().deployVerticle(verticleSpy, context.asyncAssertFailure()); }
|
SpecificBlockingRestKiqrClientImpl implements SpecificBlockingKiqrClient<K,V> { @Override public Optional<V> getScalarKeyValue( K key) { return genericClient.getScalarKeyValue(store, keyClass, key, valueClass, keySerde, valueSerde); } SpecificBlockingRestKiqrClientImpl(String host, int port, String store, Class<K> keyClass, Class<V> valueClass, Serde<K> keySerde, Serde<V> valueSerde); SpecificBlockingRestKiqrClientImpl(GenericBlockingKiqrClient genericClient, String store, Class<K> keyClass, Class<V> valueClass, Serde<K> keySerde, Serde<V> valueSerde); @Override Optional<V> getScalarKeyValue( K key); @Override Map<K, V> getAllKeyValues(); @Override Map<K, V> getRangeKeyValues( K from, K to); @Override Map<Long, V> getWindow( K key, long from, long to); @Override Optional<Long> count(String store); @Override Map<Window, V> getSession(K key); }
|
@Test public void scalar(){ when(clientMock.getScalarKeyValue(any(), any(), any(), any(), any(), any())).thenReturn(Optional.of(6L)); Optional<Long> result = unitUnderTest.getScalarKeyValue("key1"); assertTrue(result.isPresent()); assertThat(result.get(), is(equalTo(6L))); }
|
SpecificBlockingRestKiqrClientImpl implements SpecificBlockingKiqrClient<K,V> { @Override public Map<K, V> getAllKeyValues() { return genericClient.getAllKeyValues(store, keyClass, valueClass, keySerde, valueSerde); } SpecificBlockingRestKiqrClientImpl(String host, int port, String store, Class<K> keyClass, Class<V> valueClass, Serde<K> keySerde, Serde<V> valueSerde); SpecificBlockingRestKiqrClientImpl(GenericBlockingKiqrClient genericClient, String store, Class<K> keyClass, Class<V> valueClass, Serde<K> keySerde, Serde<V> valueSerde); @Override Optional<V> getScalarKeyValue( K key); @Override Map<K, V> getAllKeyValues(); @Override Map<K, V> getRangeKeyValues( K from, K to); @Override Map<Long, V> getWindow( K key, long from, long to); @Override Optional<Long> count(String store); @Override Map<Window, V> getSession(K key); }
|
@Test public void all(){ Map<String, Long> results = new HashMap<>(); results.put("key1", 6L); when(clientMock.getAllKeyValues(any(), eq(String.class), eq(Long.class), any(), any())).thenReturn(results); Map<String, Long> result = unitUnderTest.getAllKeyValues(); assertThat(result.size(), is(equalTo(1))); assertThat(result, hasEntry("key1", 6L)); }
|
SpecificBlockingRestKiqrClientImpl implements SpecificBlockingKiqrClient<K,V> { @Override public Map<K, V> getRangeKeyValues( K from, K to) { return genericClient.getRangeKeyValues(store, keyClass, valueClass, keySerde, valueSerde, from, to); } SpecificBlockingRestKiqrClientImpl(String host, int port, String store, Class<K> keyClass, Class<V> valueClass, Serde<K> keySerde, Serde<V> valueSerde); SpecificBlockingRestKiqrClientImpl(GenericBlockingKiqrClient genericClient, String store, Class<K> keyClass, Class<V> valueClass, Serde<K> keySerde, Serde<V> valueSerde); @Override Optional<V> getScalarKeyValue( K key); @Override Map<K, V> getAllKeyValues(); @Override Map<K, V> getRangeKeyValues( K from, K to); @Override Map<Long, V> getWindow( K key, long from, long to); @Override Optional<Long> count(String store); @Override Map<Window, V> getSession(K key); }
|
@Test public void range(){ Map<String, Long> results = new HashMap<>(); results.put("key1", 6L); when(clientMock.getRangeKeyValues(any(), eq(String.class), eq(Long.class), any(), any(), any(), any())).thenReturn(results); Map<String, Long> result = unitUnderTest.getRangeKeyValues("key1", "key2"); assertThat(result.size(), is(equalTo(1))); assertThat(result, hasEntry("key1", 6L)); }
|
SpecificBlockingRestKiqrClientImpl implements SpecificBlockingKiqrClient<K,V> { @Override public Map<Long, V> getWindow( K key, long from, long to) { return genericClient.getWindow(store, keyClass, key, valueClass, keySerde, valueSerde, from, to); } SpecificBlockingRestKiqrClientImpl(String host, int port, String store, Class<K> keyClass, Class<V> valueClass, Serde<K> keySerde, Serde<V> valueSerde); SpecificBlockingRestKiqrClientImpl(GenericBlockingKiqrClient genericClient, String store, Class<K> keyClass, Class<V> valueClass, Serde<K> keySerde, Serde<V> valueSerde); @Override Optional<V> getScalarKeyValue( K key); @Override Map<K, V> getAllKeyValues(); @Override Map<K, V> getRangeKeyValues( K from, K to); @Override Map<Long, V> getWindow( K key, long from, long to); @Override Optional<Long> count(String store); @Override Map<Window, V> getSession(K key); }
|
@Test public void window(){ Map<Long, Long> results = new HashMap<>(); results.put(1L, 6L); when(clientMock.getWindow(anyString(), eq(String.class), eq("key1"), eq(Long.class), anyObject(), anyObject(), eq(0L), eq(1L))).thenReturn(results); Map<Long, Long> result = unitUnderTest.getWindow("key1", 0L, 1L); assertThat(result.size(), is(equalTo(1))); assertThat(result, hasEntry(1L, 6L)); }
|
StringJavaScriptVariable extends JavaScriptVariable { @Override public String getVariableValue() { return quote(super.getVariableValue()); } StringJavaScriptVariable(final String theVariableName,
final String theVariableValue); @Override String getVariableValue(); }
|
@Test public void testGetVariableValue() throws Exception { final String variableName = "theVariableName"; final String variableValue = "theVariableValue"; final String expectedValue = "\"" + variableValue + "\""; final StringJavaScriptVariable variable = new StringJavaScriptVariable(variableName, variableValue); assertEquals(variableName, variable.getVariableName()); assertEquals(expectedValue, variable.getVariableValue()); }
|
JvmStateReceiverAdapter extends ReceiverAdapter { @Override public void receive(final Message jGroupMsg) { final Map serverInfoMap = (Map) jGroupMsg.getObject(); final Jvm jvm = getJvm(serverInfoMap); final JvmState jvmState = getJvmState(serverInfoMap); if (jvm != null && !JvmState.JVM_STOPPED.equals(jvmState)) { jvmStateService.updateState(jvm, jvmState, StringUtils.EMPTY); } else if (jvm == null) { LOGGER.error("Cannot update the state since no JVM was found with the following details: {}", serverInfoMap); } } JvmStateReceiverAdapter(final JvmStateService jvmStateService, final JvmPersistenceService jvmPersistenceService); @Override void receive(final Message jGroupMsg); @Override void viewAccepted(View view); }
|
@Test @SuppressWarnings("unchecked") public void testReceiveWithRuntimeException() throws Exception { final Identifier<Jvm> jvmId = new Identifier<>("1"); Jvm jvm = new Jvm(jvmId, "jvm-name"); final Map<Object, Object> serverInfoMap = new HashMap(); serverInfoMap.put(JvmStateReceiverAdapter.NAME_KEY, jvm.getJvmName()); serverInfoMap.put(JvmStateReceiverAdapter.STATE_KEY, LifecycleState.STOPPING); msg = new Message(); msg.setObject(serverInfoMap); when (mockJvmPersistenceService.findJvmByExactName(jvm.getJvmName())).thenThrow(new NoResultException("")); jvmStateReceiverAdapter.receive(msg); verify(mockJvmStateService, never()).updateState(eq(jvm), eq(JvmState.JVM_STOPPING), eq(StringUtils.EMPTY)); }
@Test @SuppressWarnings("unchecked") public void testReceiveNullId() { final Identifier<Jvm> jvmId = new Identifier<>("1"); Jvm jvm = new Jvm(jvmId, "jvm-name"); final Map<Object, Object> serverInfoMap = new HashMap(); serverInfoMap.put(JvmStateReceiverAdapter.NAME_KEY, jvm.getJvmName()); serverInfoMap.put(JvmStateReceiverAdapter.STATE_KEY, LifecycleState.STOPPING); msg = new Message(); msg.setObject(serverInfoMap); when (mockJvmPersistenceService.findJvmByExactName(jvm.getJvmName())).thenReturn(null); jvmStateReceiverAdapter.receive(msg); verify(mockJvmStateService, never()).updateState(eq(jvm), eq(JvmState.JVM_STOPPING), eq(StringUtils.EMPTY)); }
@Test @SuppressWarnings("unchecked") public void testReceive() throws Exception { final Identifier<Jvm> jvmId = new Identifier<>("1"); Jvm jvm = new Jvm(jvmId, "jvm-name"); final Map<Object, Object> serverInfoMap = new HashMap(); serverInfoMap.put(JvmStateReceiverAdapter.NAME_KEY, jvm.getJvmName()); serverInfoMap.put(JvmStateReceiverAdapter.STATE_KEY, LifecycleState.STOPPING); msg = new Message(); msg.setObject(serverInfoMap); when (mockJvmPersistenceService.findJvmByExactName(jvm.getJvmName())).thenReturn(jvm); jvmStateReceiverAdapter.receive(msg); verify(mockJvmStateService).updateState(eq(jvm), eq(JvmState.JVM_STOPPING), eq(StringUtils.EMPTY)); }
|
JvmServiceImpl implements JvmService { @Override @Transactional public void createDefaultTemplates(final String jvmName, Group parentGroup) { final String groupName = parentGroup.getName(); List<String> templateNames = groupPersistenceService.getGroupJvmsResourceTemplateNames(groupName); for (final String templateName : templateNames) { String templateContent = getGroupJvmResourceTemplate(groupName, templateName, resourceService.generateResourceGroup(), false); String metaDataStr = groupPersistenceService.getGroupJvmResourceTemplateMetaData(groupName, templateName); try { ResourceTemplateMetaData metaData = resourceService.getMetaData(metaDataStr); final ResourceIdentifier resourceIdentifier = new ResourceIdentifier.Builder() .setResourceName(metaData.getDeployFileName()) .setJvmName(jvmName) .setGroupName(groupName) .build(); resourceService.createResource(resourceIdentifier, metaData, IOUtils.toInputStream(templateContent, StandardCharsets.UTF_8)); } catch (IOException e) { LOGGER.error("Failed to map meta data for JVM {} in group {}", jvmName, groupName, e); throw new InternalErrorException(FaultType.BAD_STREAM, "Failed to map meta data for JVM " + jvmName + " in group " + groupName, e); } } for (Application app : applicationService.findApplications(parentGroup.getId())) { templateNames = groupPersistenceService.getGroupAppsResourceTemplateNames(groupName, app.getName()); for (String templateName : templateNames) { String metaDataStr = groupPersistenceService.getGroupAppResourceTemplateMetaData(groupName, templateName, app.getName()); try { ResourceTemplateMetaData metaData = resourceService.getMetaData(metaDataStr); if (metaData.getEntity().getDeployToJvms()) { final String template = resourceService.getAppTemplate(groupName, app.getName(), templateName); final ResourceIdentifier resourceIdentifier = new ResourceIdentifier.Builder() .setResourceName(templateName).setJvmName(jvmName) .setWebAppName(app.getName()).build(); resourceService.createResource(resourceIdentifier, metaData, new ByteArrayInputStream(template.getBytes(StandardCharsets.UTF_8))); } } catch (IOException e) { LOGGER.error("Failed to map meta data while creating JVM for template {} in group {}", templateName, groupName, e); throw new InternalErrorException(FaultType.BAD_STREAM, "Failed to map data for template " + templateName + " in group " + groupName, e); } } } } JvmServiceImpl(final JvmPersistenceService jvmPersistenceService,
final GroupPersistenceService groupPersistenceService,
final ApplicationService applicationService,
final SimpMessagingTemplate messagingTemplate,
final GroupStateNotificationService groupStateNotificationService,
final ResourceService resourceService,
final ClientFactoryHelper clientFactoryHelper,
final String topicServerStates,
final JvmControlService jvmControlService,
final BinaryDistributionService binaryDistributionService,
final BinaryDistributionLockManager binaryDistributionLockManager,
final HistoryFacadeService historyFacadeService,
final FileUtility fileUtility); @Override @Transactional Jvm createJvm(CreateJvmAndAddToGroupsRequest createJvmAndAddToGroupsRequest, User user); @Override @Transactional void createDefaultTemplates(final String jvmName, Group parentGroup); @Override @Transactional(readOnly = true) Jvm getJvm(final Identifier<Jvm> aJvmId); @Override @Transactional(readOnly = true) Jvm getJvm(final String jvmName); @Override @Transactional(readOnly = true) List<Jvm> getJvms(); @Override List<Jvm> getJvmsByGroupName(String name); @Override @Transactional Jvm updateJvm(final UpdateJvmRequest updateJvmRequest, final boolean updateJvmPassword); @Override @Transactional void deleteJvm(final Identifier<Jvm> id, boolean hardDelete, final User user); @Override Jvm generateAndDeployJvm(String jvmName, User user); Jvm upgradeJDK(String jvmName, User user); @Override Jvm generateAndDeployFile(String jvmName, String fileName, User user); @Override @Transactional void performDiagnosis(Identifier<Jvm> aJvmId, final User user); @Override @Transactional String previewResourceTemplate(String fileName, String jvmName, String groupName, String template); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(final String jvmName); @Override @Transactional String getResourceTemplate(final String jvmName,
final String resourceTemplateName,
final boolean tokensReplaced); @Override @Transactional String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<Jvm> id, final JvmState state); @Override @Transactional JvmHttpRequestResult pingAndUpdateJvmState(final Jvm jvm); @Override @Transactional void deployApplicationContextXMLs(Jvm jvm, User user); @Override @Transactional(readOnly = true) Long getJvmStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getJvmCount(final String groupName); @Override Long getJvmStoppedCount(final String groupName); @Override Long getJvmForciblyStoppedCount(final String groupName); @Override @Transactional void deleteJvm(final String name, final String userName); }
|
@Test public void testCreateDefaultTemplates() throws IOException { System.setProperty(ApplicationProperties.PROPERTIES_ROOT_PATH, "./src/test/resources"); final Entity mockEntity = mock(Entity.class); final Jvm jvm = new Jvm(new Identifier<Jvm>(99L), "testJvm", new HashSet<Group>()); Set<Jvm> jvms = new HashSet<>(); jvms.add(jvm); List<Application> applications = new LinkedList<>(); Group group = new Group(new Identifier<Group>(99L), "Test", jvms); Application application = new Application(new Identifier<Application>(99L), "testApplication", null, null, null, false, false, false, null, null); List<String> templateNames = new ArrayList<String>(); templateNames.add("testTEmplate"); applications.add(application); ResourceTemplateMetaData mockMetaData = mock(ResourceTemplateMetaData.class); when(mockMetaData.getDeployFileName()).thenReturn("testFile"); when(Config.mockResourceService.getMetaData(anyString())).thenReturn(mockMetaData); when(Config.mockGroupPersistenceService.getGroupJvmsResourceTemplateNames(anyString())).thenReturn(templateNames); when(Config.mockGroupPersistenceService.getGroupJvmResourceTemplate(anyString(), anyString())).thenReturn("test"); when(Config.mockGroupPersistenceService.getGroup(anyString())).thenReturn(group); when(Config.mockGroupPersistenceService.getGroupAppsResourceTemplateNames(anyString())).thenReturn(templateNames); when(Config.mockApplicationService.findApplications(any())).thenReturn(applications); when(mockMetaData.getEntity()).thenReturn(mockEntity); when(mockEntity.getDeployToJvms()).thenReturn(false); jvmService.createDefaultTemplates(jvm.getJvmName(), group); verify(Config.mockGroupPersistenceService, times(1)).getGroupJvmsResourceTemplateNames(anyString()); verify(Config.mockGroupPersistenceService, times(1)).getGroupJvmResourceTemplate(anyString(), anyString()); verify(Config.mockResourceService,times(1)).getMetaData(anyString()); System.clearProperty(ApplicationProperties.PROPERTIES_ROOT_PATH); }
|
JvmServiceImpl implements JvmService { @Override @Transactional(readOnly = true) public List<Jvm> getJvms() { return jvmPersistenceService.getJvms(); } JvmServiceImpl(final JvmPersistenceService jvmPersistenceService,
final GroupPersistenceService groupPersistenceService,
final ApplicationService applicationService,
final SimpMessagingTemplate messagingTemplate,
final GroupStateNotificationService groupStateNotificationService,
final ResourceService resourceService,
final ClientFactoryHelper clientFactoryHelper,
final String topicServerStates,
final JvmControlService jvmControlService,
final BinaryDistributionService binaryDistributionService,
final BinaryDistributionLockManager binaryDistributionLockManager,
final HistoryFacadeService historyFacadeService,
final FileUtility fileUtility); @Override @Transactional Jvm createJvm(CreateJvmAndAddToGroupsRequest createJvmAndAddToGroupsRequest, User user); @Override @Transactional void createDefaultTemplates(final String jvmName, Group parentGroup); @Override @Transactional(readOnly = true) Jvm getJvm(final Identifier<Jvm> aJvmId); @Override @Transactional(readOnly = true) Jvm getJvm(final String jvmName); @Override @Transactional(readOnly = true) List<Jvm> getJvms(); @Override List<Jvm> getJvmsByGroupName(String name); @Override @Transactional Jvm updateJvm(final UpdateJvmRequest updateJvmRequest, final boolean updateJvmPassword); @Override @Transactional void deleteJvm(final Identifier<Jvm> id, boolean hardDelete, final User user); @Override Jvm generateAndDeployJvm(String jvmName, User user); Jvm upgradeJDK(String jvmName, User user); @Override Jvm generateAndDeployFile(String jvmName, String fileName, User user); @Override @Transactional void performDiagnosis(Identifier<Jvm> aJvmId, final User user); @Override @Transactional String previewResourceTemplate(String fileName, String jvmName, String groupName, String template); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(final String jvmName); @Override @Transactional String getResourceTemplate(final String jvmName,
final String resourceTemplateName,
final boolean tokensReplaced); @Override @Transactional String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<Jvm> id, final JvmState state); @Override @Transactional JvmHttpRequestResult pingAndUpdateJvmState(final Jvm jvm); @Override @Transactional void deployApplicationContextXMLs(Jvm jvm, User user); @Override @Transactional(readOnly = true) Long getJvmStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getJvmCount(final String groupName); @Override Long getJvmStoppedCount(final String groupName); @Override Long getJvmForciblyStoppedCount(final String groupName); @Override @Transactional void deleteJvm(final String name, final String userName); }
|
@Test public void testGetAll() { jvmService.getJvms(); verify(Config.mockJvmPersistenceService, times(1)).getJvms(); }
|
JvmServiceImpl implements JvmService { @Override @Transactional(readOnly = true) public Jvm getJvm(final Identifier<Jvm> aJvmId) { return jvmPersistenceService.getJvm(aJvmId); } JvmServiceImpl(final JvmPersistenceService jvmPersistenceService,
final GroupPersistenceService groupPersistenceService,
final ApplicationService applicationService,
final SimpMessagingTemplate messagingTemplate,
final GroupStateNotificationService groupStateNotificationService,
final ResourceService resourceService,
final ClientFactoryHelper clientFactoryHelper,
final String topicServerStates,
final JvmControlService jvmControlService,
final BinaryDistributionService binaryDistributionService,
final BinaryDistributionLockManager binaryDistributionLockManager,
final HistoryFacadeService historyFacadeService,
final FileUtility fileUtility); @Override @Transactional Jvm createJvm(CreateJvmAndAddToGroupsRequest createJvmAndAddToGroupsRequest, User user); @Override @Transactional void createDefaultTemplates(final String jvmName, Group parentGroup); @Override @Transactional(readOnly = true) Jvm getJvm(final Identifier<Jvm> aJvmId); @Override @Transactional(readOnly = true) Jvm getJvm(final String jvmName); @Override @Transactional(readOnly = true) List<Jvm> getJvms(); @Override List<Jvm> getJvmsByGroupName(String name); @Override @Transactional Jvm updateJvm(final UpdateJvmRequest updateJvmRequest, final boolean updateJvmPassword); @Override @Transactional void deleteJvm(final Identifier<Jvm> id, boolean hardDelete, final User user); @Override Jvm generateAndDeployJvm(String jvmName, User user); Jvm upgradeJDK(String jvmName, User user); @Override Jvm generateAndDeployFile(String jvmName, String fileName, User user); @Override @Transactional void performDiagnosis(Identifier<Jvm> aJvmId, final User user); @Override @Transactional String previewResourceTemplate(String fileName, String jvmName, String groupName, String template); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(final String jvmName); @Override @Transactional String getResourceTemplate(final String jvmName,
final String resourceTemplateName,
final boolean tokensReplaced); @Override @Transactional String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<Jvm> id, final JvmState state); @Override @Transactional JvmHttpRequestResult pingAndUpdateJvmState(final Jvm jvm); @Override @Transactional void deployApplicationContextXMLs(Jvm jvm, User user); @Override @Transactional(readOnly = true) Long getJvmStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getJvmCount(final String groupName); @Override Long getJvmStoppedCount(final String groupName); @Override Long getJvmForciblyStoppedCount(final String groupName); @Override @Transactional void deleteJvm(final String name, final String userName); }
|
@Test public void testGetSpecific() { final Identifier<Jvm> id = new Identifier<>(-123456L); jvmService.getJvm(id); verify(Config.mockJvmPersistenceService, times(1)).getJvm(eq(id)); }
@Test public void testGetJvmByName() { jvmService.getJvm("testJvm"); verify(Config.mockJvmPersistenceService).findJvmByExactName("testJvm"); }
|
JvmServiceImpl implements JvmService { @Override @Transactional public void performDiagnosis(Identifier<Jvm> aJvmId, final User user) { Jvm jvm = jvmPersistenceService.getJvm(aJvmId); historyFacadeService.write(jvm.getJvmName(), new ArrayList<>(jvm.getGroups()), "Diagnose and resolve state", EventType.USER_ACTION_INFO, user.getId()); final JvmHttpRequestResult jvmHttpRequestResult = pingAndUpdateJvmState(jvm); if (StringUtils.isNotEmpty(jvmHttpRequestResult.details)) { final EventType eventType = jvmHttpRequestResult.details.isEmpty() || jvmHttpRequestResult.jvmState.equals(JvmState.JVM_STOPPED) || jvmHttpRequestResult.jvmState.equals(JvmState.FORCED_STOPPED) ? EventType.SYSTEM_INFO : EventType.SYSTEM_ERROR; historyFacadeService.write(jvm.getJvmName(), new ArrayList<>(jvm.getGroups()), jvmHttpRequestResult.details, eventType, user.getId()); } } JvmServiceImpl(final JvmPersistenceService jvmPersistenceService,
final GroupPersistenceService groupPersistenceService,
final ApplicationService applicationService,
final SimpMessagingTemplate messagingTemplate,
final GroupStateNotificationService groupStateNotificationService,
final ResourceService resourceService,
final ClientFactoryHelper clientFactoryHelper,
final String topicServerStates,
final JvmControlService jvmControlService,
final BinaryDistributionService binaryDistributionService,
final BinaryDistributionLockManager binaryDistributionLockManager,
final HistoryFacadeService historyFacadeService,
final FileUtility fileUtility); @Override @Transactional Jvm createJvm(CreateJvmAndAddToGroupsRequest createJvmAndAddToGroupsRequest, User user); @Override @Transactional void createDefaultTemplates(final String jvmName, Group parentGroup); @Override @Transactional(readOnly = true) Jvm getJvm(final Identifier<Jvm> aJvmId); @Override @Transactional(readOnly = true) Jvm getJvm(final String jvmName); @Override @Transactional(readOnly = true) List<Jvm> getJvms(); @Override List<Jvm> getJvmsByGroupName(String name); @Override @Transactional Jvm updateJvm(final UpdateJvmRequest updateJvmRequest, final boolean updateJvmPassword); @Override @Transactional void deleteJvm(final Identifier<Jvm> id, boolean hardDelete, final User user); @Override Jvm generateAndDeployJvm(String jvmName, User user); Jvm upgradeJDK(String jvmName, User user); @Override Jvm generateAndDeployFile(String jvmName, String fileName, User user); @Override @Transactional void performDiagnosis(Identifier<Jvm> aJvmId, final User user); @Override @Transactional String previewResourceTemplate(String fileName, String jvmName, String groupName, String template); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(final String jvmName); @Override @Transactional String getResourceTemplate(final String jvmName,
final String resourceTemplateName,
final boolean tokensReplaced); @Override @Transactional String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<Jvm> id, final JvmState state); @Override @Transactional JvmHttpRequestResult pingAndUpdateJvmState(final Jvm jvm); @Override @Transactional void deployApplicationContextXMLs(Jvm jvm, User user); @Override @Transactional(readOnly = true) Long getJvmStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getJvmCount(final String groupName); @Override Long getJvmStoppedCount(final String groupName); @Override Long getJvmForciblyStoppedCount(final String groupName); @Override @Transactional void deleteJvm(final String name, final String userName); }
|
@Test public void testPerformDiagnosis() throws IOException, URISyntaxException { Identifier<Jvm> aJvmId = new Identifier<>(11L); Jvm jvm = mock(Jvm.class); when(jvm.getId()).thenReturn(aJvmId); final URI uri = new URI("http: when(jvm.getStatusUri()).thenReturn(new URI("http: when(Config.mockJvmPersistenceService.getJvm(aJvmId)).thenReturn(jvm); ClientHttpResponse mockResponse = mock(ClientHttpResponse.class); when(mockResponse.getStatusCode()).thenReturn(HttpStatus.OK); when(Config.mockClientFactoryHelper.requestGet(any(URI.class))).thenReturn(mockResponse); jvmService.performDiagnosis(aJvmId, new User("user")); verify(Config.mockClientFactoryHelper).requestGet(eq(uri)); reset(Config.mockClientFactoryHelper); when(mockResponse.getStatusCode()).thenReturn(HttpStatus.REQUEST_TIMEOUT); when(Config.mockClientFactoryHelper.requestGet(any(URI.class))).thenReturn(mockResponse); jvmService.performDiagnosis(aJvmId, new User("user")); verify(Config.mockClientFactoryHelper).requestGet(eq(uri)); }
|
JvmServiceImpl implements JvmService { @Override @Transactional(readOnly = true) public List<String> getResourceTemplateNames(final String jvmName) { return jvmPersistenceService.getResourceTemplateNames(jvmName); } JvmServiceImpl(final JvmPersistenceService jvmPersistenceService,
final GroupPersistenceService groupPersistenceService,
final ApplicationService applicationService,
final SimpMessagingTemplate messagingTemplate,
final GroupStateNotificationService groupStateNotificationService,
final ResourceService resourceService,
final ClientFactoryHelper clientFactoryHelper,
final String topicServerStates,
final JvmControlService jvmControlService,
final BinaryDistributionService binaryDistributionService,
final BinaryDistributionLockManager binaryDistributionLockManager,
final HistoryFacadeService historyFacadeService,
final FileUtility fileUtility); @Override @Transactional Jvm createJvm(CreateJvmAndAddToGroupsRequest createJvmAndAddToGroupsRequest, User user); @Override @Transactional void createDefaultTemplates(final String jvmName, Group parentGroup); @Override @Transactional(readOnly = true) Jvm getJvm(final Identifier<Jvm> aJvmId); @Override @Transactional(readOnly = true) Jvm getJvm(final String jvmName); @Override @Transactional(readOnly = true) List<Jvm> getJvms(); @Override List<Jvm> getJvmsByGroupName(String name); @Override @Transactional Jvm updateJvm(final UpdateJvmRequest updateJvmRequest, final boolean updateJvmPassword); @Override @Transactional void deleteJvm(final Identifier<Jvm> id, boolean hardDelete, final User user); @Override Jvm generateAndDeployJvm(String jvmName, User user); Jvm upgradeJDK(String jvmName, User user); @Override Jvm generateAndDeployFile(String jvmName, String fileName, User user); @Override @Transactional void performDiagnosis(Identifier<Jvm> aJvmId, final User user); @Override @Transactional String previewResourceTemplate(String fileName, String jvmName, String groupName, String template); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(final String jvmName); @Override @Transactional String getResourceTemplate(final String jvmName,
final String resourceTemplateName,
final boolean tokensReplaced); @Override @Transactional String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<Jvm> id, final JvmState state); @Override @Transactional JvmHttpRequestResult pingAndUpdateJvmState(final Jvm jvm); @Override @Transactional void deployApplicationContextXMLs(Jvm jvm, User user); @Override @Transactional(readOnly = true) Long getJvmStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getJvmCount(final String groupName); @Override Long getJvmStoppedCount(final String groupName); @Override Long getJvmForciblyStoppedCount(final String groupName); @Override @Transactional void deleteJvm(final String name, final String userName); }
|
@Test public void testGetResourceTemplateNames() { String testJvmName = "testJvmName"; ArrayList<String> value = new ArrayList<>(); when(Config.mockJvmPersistenceService.getResourceTemplateNames(testJvmName)).thenReturn(value); value.add("testJvm.tpl"); List<String> result = jvmService.getResourceTemplateNames(testJvmName); assertTrue(result.size() == 1); }
|
JvmServiceImpl implements JvmService { @Override @Transactional public String getResourceTemplate(final String jvmName, final String resourceTemplateName, final boolean tokensReplaced) { final String template = jvmPersistenceService.getResourceTemplate(jvmName, resourceTemplateName); if (tokensReplaced) { return resourceService.generateResourceFile(resourceTemplateName, template, resourceService.generateResourceGroup(), jvmPersistenceService.findJvmByExactName(jvmName), ResourceGeneratorType.TEMPLATE); } return template; } JvmServiceImpl(final JvmPersistenceService jvmPersistenceService,
final GroupPersistenceService groupPersistenceService,
final ApplicationService applicationService,
final SimpMessagingTemplate messagingTemplate,
final GroupStateNotificationService groupStateNotificationService,
final ResourceService resourceService,
final ClientFactoryHelper clientFactoryHelper,
final String topicServerStates,
final JvmControlService jvmControlService,
final BinaryDistributionService binaryDistributionService,
final BinaryDistributionLockManager binaryDistributionLockManager,
final HistoryFacadeService historyFacadeService,
final FileUtility fileUtility); @Override @Transactional Jvm createJvm(CreateJvmAndAddToGroupsRequest createJvmAndAddToGroupsRequest, User user); @Override @Transactional void createDefaultTemplates(final String jvmName, Group parentGroup); @Override @Transactional(readOnly = true) Jvm getJvm(final Identifier<Jvm> aJvmId); @Override @Transactional(readOnly = true) Jvm getJvm(final String jvmName); @Override @Transactional(readOnly = true) List<Jvm> getJvms(); @Override List<Jvm> getJvmsByGroupName(String name); @Override @Transactional Jvm updateJvm(final UpdateJvmRequest updateJvmRequest, final boolean updateJvmPassword); @Override @Transactional void deleteJvm(final Identifier<Jvm> id, boolean hardDelete, final User user); @Override Jvm generateAndDeployJvm(String jvmName, User user); Jvm upgradeJDK(String jvmName, User user); @Override Jvm generateAndDeployFile(String jvmName, String fileName, User user); @Override @Transactional void performDiagnosis(Identifier<Jvm> aJvmId, final User user); @Override @Transactional String previewResourceTemplate(String fileName, String jvmName, String groupName, String template); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(final String jvmName); @Override @Transactional String getResourceTemplate(final String jvmName,
final String resourceTemplateName,
final boolean tokensReplaced); @Override @Transactional String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<Jvm> id, final JvmState state); @Override @Transactional JvmHttpRequestResult pingAndUpdateJvmState(final Jvm jvm); @Override @Transactional void deployApplicationContextXMLs(Jvm jvm, User user); @Override @Transactional(readOnly = true) Long getJvmStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getJvmCount(final String groupName); @Override Long getJvmStoppedCount(final String groupName); @Override Long getJvmForciblyStoppedCount(final String groupName); @Override @Transactional void deleteJvm(final String name, final String userName); }
|
@Test public void testGetResourceTemplate() { String testJvmName = "testJvmName"; String resourceTemplateName = "test-resource.tpl"; Jvm jvm = mock(Jvm.class); String expectedValue = "<template>resource</template>"; when(Config.mockJvmPersistenceService.getResourceTemplate(testJvmName, resourceTemplateName)).thenReturn(expectedValue); List<Jvm> jvmList = new ArrayList<>(); jvmList.add(jvm); when(Config.mockJvmPersistenceService.findJvmByExactName(anyString())).thenReturn(jvm); when(Config.mockResourceService.generateResourceGroup()).thenReturn(new ResourceGroup()); when(Config.mockResourceService.generateResourceFile(eq(resourceTemplateName), eq(expectedValue), any(ResourceGroup.class), eq(jvm), any(ResourceGeneratorType.class))).thenReturn(expectedValue); String result = jvmService.getResourceTemplate(testJvmName, resourceTemplateName, true); assertEquals(expectedValue, result); result = jvmService.getResourceTemplate(testJvmName, resourceTemplateName, false); assertEquals(expectedValue, result); }
|
JvmServiceImpl implements JvmService { @Override @Transactional public String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template) { String retVal = null; try { retVal = jvmPersistenceService.updateResourceTemplate(jvmName, resourceTemplateName, template); } catch (ResourceTemplateUpdateException | NonRetrievableResourceTemplateContentException e) { LOGGER.error("Failed to update the template {}", resourceTemplateName, e); } return retVal; } JvmServiceImpl(final JvmPersistenceService jvmPersistenceService,
final GroupPersistenceService groupPersistenceService,
final ApplicationService applicationService,
final SimpMessagingTemplate messagingTemplate,
final GroupStateNotificationService groupStateNotificationService,
final ResourceService resourceService,
final ClientFactoryHelper clientFactoryHelper,
final String topicServerStates,
final JvmControlService jvmControlService,
final BinaryDistributionService binaryDistributionService,
final BinaryDistributionLockManager binaryDistributionLockManager,
final HistoryFacadeService historyFacadeService,
final FileUtility fileUtility); @Override @Transactional Jvm createJvm(CreateJvmAndAddToGroupsRequest createJvmAndAddToGroupsRequest, User user); @Override @Transactional void createDefaultTemplates(final String jvmName, Group parentGroup); @Override @Transactional(readOnly = true) Jvm getJvm(final Identifier<Jvm> aJvmId); @Override @Transactional(readOnly = true) Jvm getJvm(final String jvmName); @Override @Transactional(readOnly = true) List<Jvm> getJvms(); @Override List<Jvm> getJvmsByGroupName(String name); @Override @Transactional Jvm updateJvm(final UpdateJvmRequest updateJvmRequest, final boolean updateJvmPassword); @Override @Transactional void deleteJvm(final Identifier<Jvm> id, boolean hardDelete, final User user); @Override Jvm generateAndDeployJvm(String jvmName, User user); Jvm upgradeJDK(String jvmName, User user); @Override Jvm generateAndDeployFile(String jvmName, String fileName, User user); @Override @Transactional void performDiagnosis(Identifier<Jvm> aJvmId, final User user); @Override @Transactional String previewResourceTemplate(String fileName, String jvmName, String groupName, String template); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(final String jvmName); @Override @Transactional String getResourceTemplate(final String jvmName,
final String resourceTemplateName,
final boolean tokensReplaced); @Override @Transactional String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<Jvm> id, final JvmState state); @Override @Transactional JvmHttpRequestResult pingAndUpdateJvmState(final Jvm jvm); @Override @Transactional void deployApplicationContextXMLs(Jvm jvm, User user); @Override @Transactional(readOnly = true) Long getJvmStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getJvmCount(final String groupName); @Override Long getJvmStoppedCount(final String groupName); @Override Long getJvmForciblyStoppedCount(final String groupName); @Override @Transactional void deleteJvm(final String name, final String userName); }
|
@Test public void testUpdateResourceTemplate() { String testJvmName = "testJvmName"; String resourceTemplateName = "test-resource.tpl"; String template = "<template>update</template>"; when(Config.mockJvmPersistenceService.updateResourceTemplate(testJvmName, resourceTemplateName, template)).thenReturn(template); String result = jvmService.updateResourceTemplate(testJvmName, resourceTemplateName, template); assertEquals(template, result); }
|
WebServerServiceImpl implements WebServerService { @Override @Transactional(readOnly = true) public WebServer getWebServer(final Identifier<WebServer> aWebServerId) { return webServerPersistenceService.getWebServer(aWebServerId); } WebServerServiceImpl(final WebServerPersistenceService webServerPersistenceService,
final ResourceService resourceService,
@Qualifier("webServerInMemoryStateManagerService")
final InMemoryStateManagerService<Identifier<WebServer>, WebServerReachableState> inMemoryStateManagerService,
final String templatePath,
final BinaryDistributionLockManager binaryDistributionLockManager); @Override @Transactional WebServer createWebServer(final CreateWebServerRequest createWebServerRequest,
final User aCreatingUser); @Override @Transactional(readOnly = true) WebServer getWebServer(final Identifier<WebServer> aWebServerId); @Override @Transactional(readOnly = true) WebServer getWebServer(final String aWebServerName); @Override @Transactional(readOnly = true) List<WebServer> getWebServers(); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) List<WebServer> getWebServersPropagationNew(); @Override @Transactional(readOnly = true) List<WebServer> findWebServers(final Identifier<Group> aGroupId); @Override @Transactional WebServer updateWebServer(final UpdateWebServerRequest anUpdateWebServerCommand,
final User anUpdatingUser); @Override @Transactional void deleteWebServer(final Identifier<WebServer> id, final boolean hardDelete, final User user); @Override boolean isStarted(WebServer webServer); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<WebServer> id, final WebServerReachableState state, final String errorStatus); @Override String generateInstallServiceScript(WebServer webServer); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(String webServerName); @Override @Transactional(readOnly = true) String getResourceTemplate(final String webServerName, final String resourceTemplateName,
final boolean tokensReplaced, final ResourceGroup resourceGroup); @Override String getResourceTemplateMetaData(String aWebServerName, String resourceTemplateName); @Override @Transactional void uploadWebServerConfig(WebServer webServer, String templateName, String templateContent, String metaDataStr, String groupName, User user); @Override @Transactional String updateResourceTemplate(final String wsName, final String resourceTemplateName, final String template); @Override @Transactional(readOnly = true) String previewResourceTemplate(final String fileName, final String webServerName, final String groupName, final String template); @Override @Transactional(readOnly = true) Long getWebServerStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getWebServerCount(final String groupName); @Override Long getWebServerStoppedCount(final String groupName); @Override WebServer generateAndDeployFile(String webServerName, String fileName, User user); static final String INSTALL_SERVICE_SCRIPT_NAME; }
|
@SuppressWarnings("unchecked") @Test public void test() { when(Config.mockWebServerPersistenceService.getWebServer(any(Identifier.class))).thenReturn(mockWebServer); final WebServer webServer = wsService.getWebServer(new Identifier<WebServer>(1L)); assertEquals(new Identifier<WebServer>(1L), webServer.getId()); assertEquals(group.getId(), webServer.getGroups().iterator().next().getId()); assertEquals("the-ws-name", webServer.getName()); assertEquals("the-ws-group-name", webServer.getGroups().iterator().next().getName()); assertEquals("the-ws-hostname", webServer.getHost()); }
@Test public void testGetWebServer() { final WebServer mockWebServer = mock(WebServer.class); when(mockWebServer.getName()).thenReturn("mockWebServer"); when(Config.mockWebServerPersistenceService.findWebServerByName(eq("aWebServer"))).thenReturn(mockWebServer); assertEquals("mockWebServer", wsService.getWebServer("aWebServer").getName()); }
|
JvmServiceImpl implements JvmService { @Override @Transactional public String previewResourceTemplate(String fileName, String jvmName, String groupName, String template) { return resourceService.generateResourceFile(fileName, template, resourceService.generateResourceGroup(), jvmPersistenceService.findJvm(jvmName, groupName), ResourceGeneratorType.PREVIEW); } JvmServiceImpl(final JvmPersistenceService jvmPersistenceService,
final GroupPersistenceService groupPersistenceService,
final ApplicationService applicationService,
final SimpMessagingTemplate messagingTemplate,
final GroupStateNotificationService groupStateNotificationService,
final ResourceService resourceService,
final ClientFactoryHelper clientFactoryHelper,
final String topicServerStates,
final JvmControlService jvmControlService,
final BinaryDistributionService binaryDistributionService,
final BinaryDistributionLockManager binaryDistributionLockManager,
final HistoryFacadeService historyFacadeService,
final FileUtility fileUtility); @Override @Transactional Jvm createJvm(CreateJvmAndAddToGroupsRequest createJvmAndAddToGroupsRequest, User user); @Override @Transactional void createDefaultTemplates(final String jvmName, Group parentGroup); @Override @Transactional(readOnly = true) Jvm getJvm(final Identifier<Jvm> aJvmId); @Override @Transactional(readOnly = true) Jvm getJvm(final String jvmName); @Override @Transactional(readOnly = true) List<Jvm> getJvms(); @Override List<Jvm> getJvmsByGroupName(String name); @Override @Transactional Jvm updateJvm(final UpdateJvmRequest updateJvmRequest, final boolean updateJvmPassword); @Override @Transactional void deleteJvm(final Identifier<Jvm> id, boolean hardDelete, final User user); @Override Jvm generateAndDeployJvm(String jvmName, User user); Jvm upgradeJDK(String jvmName, User user); @Override Jvm generateAndDeployFile(String jvmName, String fileName, User user); @Override @Transactional void performDiagnosis(Identifier<Jvm> aJvmId, final User user); @Override @Transactional String previewResourceTemplate(String fileName, String jvmName, String groupName, String template); @Override @Transactional(readOnly = true) List<String> getResourceTemplateNames(final String jvmName); @Override @Transactional String getResourceTemplate(final String jvmName,
final String resourceTemplateName,
final boolean tokensReplaced); @Override @Transactional String updateResourceTemplate(final String jvmName, final String resourceTemplateName, final String template); @Override @Transactional(propagation = Propagation.REQUIRES_NEW) void updateState(final Identifier<Jvm> id, final JvmState state); @Override @Transactional JvmHttpRequestResult pingAndUpdateJvmState(final Jvm jvm); @Override @Transactional void deployApplicationContextXMLs(Jvm jvm, User user); @Override @Transactional(readOnly = true) Long getJvmStartedCount(final String groupName); @Override @Transactional(readOnly = true) Long getJvmCount(final String groupName); @Override Long getJvmStoppedCount(final String groupName); @Override Long getJvmForciblyStoppedCount(final String groupName); @Override @Transactional void deleteJvm(final String name, final String userName); }
|
@Test public void testPreviewTemplate() { final String jvmName = "jvm-1Test"; Jvm testJvm = new Jvm(new Identifier<Jvm>(111L), jvmName, "testHost", new HashSet<Group>(), 9101, 9102, 9103, -1, 9104, new Path("./"), "", JvmState.JVM_STOPPED, "", null, null, null, null, null, null, null); List<Jvm> jvmList = new ArrayList<>(); jvmList.add(testJvm); when(Config.mockJvmPersistenceService.findJvm(anyString(), anyString())).thenReturn(testJvm); when(Config.mockResourceService.generateResourceGroup()).thenReturn(new ResourceGroup()); when(Config.mockResourceService.generateResourceFile(anyString(), anyString(), any(ResourceGroup.class), eq(testJvm), any(ResourceGeneratorType.class))).thenReturn("TEST jvm-1Test TEST"); String preview = jvmService.previewResourceTemplate("myFile", jvmName, "groupTest", "TEST ${jvm.jvmName} TEST"); assertEquals("TEST jvm-1Test TEST", preview); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.