diff --git a/core-java-8/pom.xml b/core-java-8/pom.xml index f5506f095e..17d330b3b8 100644 --- a/core-java-8/pom.xml +++ b/core-java-8/pom.xml @@ -1,258 +1,276 @@ - - 4.0.0 - com.baeldung - core-java-8 - 0.1.0-SNAPSHOT - jar - - core-java-8 - - - - com.baeldung - parent-modules - 1.0.0-SNAPSHOT - - - - - - - com.google.guava - guava - ${guava.version} - - - - org.apache.commons - commons-collections4 - ${commons-collections4.version} - - - - commons-io - commons-io - ${commons-io.version} - - - - org.apache.commons - commons-lang3 - ${commons-lang3.version} - - - - org.apache.commons - commons-math3 - ${commons-math3.version} - - - - log4j - log4j - 1.2.17 - - - - commons-codec - commons-codec - ${commons-codec.version} - - - - org.projectlombok - lombok - ${lombok.version} - provided - - - - - - org.assertj - assertj-core - ${assertj.version} - test - - - - com.jayway.awaitility - awaitility - ${avaitility.version} - test - - - - - - core-java-8 - - - src/main/resources - true - - - - - - org.apache.maven.plugins - maven-dependency-plugin - - - copy-dependencies - prepare-package - - copy-dependencies - - - ${project.build.directory}/libs - - - - - - - org.apache.maven.plugins - maven-jar-plugin - - - - true - libs/ - org.baeldung.executable.ExecutableMavenJar - - - - - - org.apache.maven.plugins - maven-assembly-plugin - - - package - - single - - - ${project.basedir} - - - org.baeldung.executable.ExecutableMavenJar - - - - jar-with-dependencies - - - - - - - org.apache.maven.plugins - maven-shade-plugin - - - - shade - - - true - - - org.baeldung.executable.ExecutableMavenJar - - - - - - - - com.jolira - onejar-maven-plugin - - - - org.baeldung.executable.ExecutableMavenJar - true - ${project.build.finalName}-onejar.${project.packaging} - - - one-jar - - - - - - org.springframework.boot - spring-boot-maven-plugin - - - - repackage - - - spring-boot - org.baeldung.executable.ExecutableMavenJar - - - - - - - - - - - integration - - - - org.apache.maven.plugins - maven-surefire-plugin - - - integration-test - - test - - - - **/*ManualTest.java - - - **/*IntegrationTest.java - - - - - - - json - - - - - - - - - - - - 21.0 - 3.5 - 3.6.1 - 2.5 - 4.1 - 4.01 - 1.10 - 1.16.12 - - - 3.6.1 - 1.7.0 - - + + 4.0.0 + com.baeldung + core-java-8 + 0.1.0-SNAPSHOT + jar + + core-java-8 + + + + com.baeldung + parent-modules + 1.0.0-SNAPSHOT + + + + + + + com.google.guava + guava + ${guava.version} + + + + org.apache.commons + commons-collections4 + ${commons-collections4.version} + + + + commons-io + commons-io + ${commons-io.version} + + + + org.apache.commons + commons-lang3 + ${commons-lang3.version} + + + + org.apache.commons + commons-math3 + ${commons-math3.version} + + + + log4j + log4j + 1.2.17 + + + + commons-codec + commons-codec + ${commons-codec.version} + + + + org.projectlombok + lombok + ${lombok.version} + provided + + + + + + org.assertj + assertj-core + ${assertj.version} + test + + + + com.jayway.awaitility + awaitility + ${avaitility.version} + test + + + + org.openjdk.jmh + jmh-core + 1.19 + + + + org.openjdk.jmh + jmh-generator-annprocess + 1.19 + + + + org.openjdk.jmh + jmh-generator-bytecode + 1.19 + + + + + + core-java-8 + + + src/main/resources + true + + + + + + org.apache.maven.plugins + maven-dependency-plugin + + + copy-dependencies + prepare-package + + copy-dependencies + + + ${project.build.directory}/libs + + + + + + + org.apache.maven.plugins + maven-jar-plugin + + + + true + libs/ + org.baeldung.executable.ExecutableMavenJar + + + + + + org.apache.maven.plugins + maven-assembly-plugin + + + package + + single + + + ${project.basedir} + + + org.baeldung.executable.ExecutableMavenJar + + + + jar-with-dependencies + + + + + + + org.apache.maven.plugins + maven-shade-plugin + + + + shade + + + true + + + org.baeldung.executable.ExecutableMavenJar + + + + + + + + com.jolira + onejar-maven-plugin + + + + org.baeldung.executable.ExecutableMavenJar + true + ${project.build.finalName}-onejar.${project.packaging} + + + one-jar + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + repackage + + + spring-boot + org.baeldung.executable.ExecutableMavenJar + + + + + + + + + + + integration + + + + org.apache.maven.plugins + maven-surefire-plugin + + + integration-test + + test + + + + **/*ManualTest.java + + + **/*IntegrationTest.java + + + + + + + json + + + + + + + + + + + + 21.0 + 3.5 + 3.6.1 + 2.5 + 4.1 + 4.01 + 1.10 + 1.16.12 + + + 3.6.1 + 1.7.0 + + \ No newline at end of file diff --git a/core-java-8/src/test/java/com/baeldung/counter/CounterStatistics.java b/core-java-8/src/test/java/com/baeldung/counter/CounterStatistics.java new file mode 100644 index 0000000000..2a42a166fa --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/counter/CounterStatistics.java @@ -0,0 +1,45 @@ +package com.baeldung.counter; + +import java.util.HashMap; +import java.util.Map; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Mode; + +import com.baeldung.counter.CounterUtil.MutableInteger; + +@Fork(value = 1, warmups = 3) +@BenchmarkMode(Mode.All) +public class CounterStatistics { + + private static final Map counterMap = new HashMap<>(); + private static final Map counterWithMutableIntMap = new HashMap<>(); + private static final Map counterWithIntArrayMap = new HashMap<>(); + private static final Map counterWithLongWrapperMap = new HashMap<>(); + + @Benchmark + public void wrapperAsCounter() { + CounterUtil.counterWithWrapperObject(counterMap); + } + + @Benchmark + public void lambdaExpressionWithWrapper() { + CounterUtil.counterWithLambdaAndWrapper(counterWithLongWrapperMap); + } + + @Benchmark + public void mutableIntegerAsCounter() { + CounterUtil.counterWithMutableInteger(counterWithMutableIntMap); + } + + @Benchmark + public void primitiveArrayAsCounter() { + CounterUtil.counterWithPrimitiveArray(counterWithIntArrayMap); + } + + public static void main(String[] args) throws Exception { + org.openjdk.jmh.Main.main(args); + } +} diff --git a/core-java-8/src/test/java/com/baeldung/counter/CounterTest.java b/core-java-8/src/test/java/com/baeldung/counter/CounterTest.java new file mode 100644 index 0000000000..657b510452 --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/counter/CounterTest.java @@ -0,0 +1,53 @@ +package com.baeldung.counter; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import com.baeldung.counter.CounterUtil.MutableInteger; + +public class CounterTest { + + @Test + public void whenMapWithWrapperAsCounter_runsSuccessfully() { + Map counterMap = new HashMap<>(); + CounterUtil.counterWithWrapperObject(counterMap); + + assertEquals(3, counterMap.get("China") + .intValue()); + assertEquals(2, counterMap.get("India") + .intValue()); + } + + @Test + public void whenMapWithLambdaAndWrapperCounter_runsSuccessfully() { + Map counterMap = new HashMap<>(); + CounterUtil.counterWithLambdaAndWrapper(counterMap); + + assertEquals(3l, counterMap.get("China") + .longValue()); + assertEquals(2l, counterMap.get("India") + .longValue()); + } + + @Test + public void whenMapWithMutableIntegerCounter_runsSuccessfully() { + Map counterMap = new HashMap<>(); + CounterUtil.counterWithMutableInteger(counterMap); + assertEquals(3, counterMap.get("China") + .getCount()); + assertEquals(2, counterMap.get("India") + .getCount()); + } + + @Test + public void whenMapWithPrimitiveArray_runsSuccessfully() { + Map counterMap = new HashMap<>(); + CounterUtil.counterWithPrimitiveArray(counterMap); + assertEquals(3, counterMap.get("China")[0]); + assertEquals(2, counterMap.get("India")[0]); + } +} diff --git a/core-java-8/src/test/java/com/baeldung/counter/CounterUtil.java b/core-java-8/src/test/java/com/baeldung/counter/CounterUtil.java new file mode 100644 index 0000000000..647fbfb0cc --- /dev/null +++ b/core-java-8/src/test/java/com/baeldung/counter/CounterUtil.java @@ -0,0 +1,61 @@ +package com.baeldung.counter; + +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class CounterUtil { + + private final static String[] COUNTRY_NAMES = { "China", "Australia", "India", "USA", "USSR", "UK", "China", "France", "Poland", "Austria", "India", "USA", "Egypt", "China" }; + + public static void counterWithWrapperObject(Map counterMap) { + for (String country : COUNTRY_NAMES) { + counterMap.compute(country, (k, v) -> v == null ? 1 : v + 1); + } + } + + public static void counterWithLambdaAndWrapper(Map counterMap) { + counterMap.putAll(Stream.of(COUNTRY_NAMES) + .parallel() + .collect(Collectors.groupingBy(k -> k, Collectors.counting()))); + } + + public static class MutableInteger { + int count; + + public MutableInteger(int count) { + this.count = count; + } + + public void increment() { + this.count++; + } + + public int getCount() { + return this.count; + } + } + + public static void counterWithMutableInteger(Map counterMap) { + for (String country : COUNTRY_NAMES) { + MutableInteger oldValue = counterMap.get(country); + if (oldValue != null) { + oldValue.increment(); + } else { + counterMap.put(country, new MutableInteger(1)); + } + } + } + + public static void counterWithPrimitiveArray(Map counterMap) { + for (String country : COUNTRY_NAMES) { + int[] oldCounter = counterMap.get(country); + if (oldCounter != null) { + oldCounter[0] += 1; + } else { + counterMap.put(country, new int[] { 1 }); + } + } + } + +} diff --git a/core-java-concurrency/src/test/java/com/baeldung/concurrent/executorservice/WaitingForThreadsToFinishTest.java b/core-java-concurrency/src/test/java/com/baeldung/concurrent/executorservice/WaitingForThreadsToFinishTest.java index 17b71aa35b..7e2bf590fd 100644 --- a/core-java-concurrency/src/test/java/com/baeldung/concurrent/executorservice/WaitingForThreadsToFinishTest.java +++ b/core-java-concurrency/src/test/java/com/baeldung/concurrent/executorservice/WaitingForThreadsToFinishTest.java @@ -9,7 +9,6 @@ import java.util.List; import java.util.concurrent.*; import static junit.framework.TestCase.assertTrue; -import static org.junit.Assert.fail; public class WaitingForThreadsToFinishTest { @@ -40,16 +39,13 @@ public class WaitingForThreadsToFinishTest { CountDownLatch latch = new CountDownLatch(2); for (int i = 0; i < 2; i++) { - WORKER_THREAD_POOL.submit(new Runnable() { - @Override - public void run() { - try { - Thread.sleep(1000); - latch.countDown(); - } catch (InterruptedException e) { - e.printStackTrace(); - Thread.currentThread().interrupt(); - } + WORKER_THREAD_POOL.submit(() -> { + try { + Thread.sleep(1000); + latch.countDown(); + } catch (InterruptedException e) { + e.printStackTrace(); + Thread.currentThread().interrupt(); } }); } @@ -83,13 +79,9 @@ public class WaitingForThreadsToFinishTest { awaitTerminationAfterShutdown(WORKER_THREAD_POOL); try { - WORKER_THREAD_POOL.submit(new Callable() { - @Override - public String call() throws Exception { - fail("This thread should have been rejected !"); - Thread.sleep(1000000); - return null; - } + WORKER_THREAD_POOL.submit((Callable) () -> { + Thread.sleep(1000000); + return null; }); } catch (RejectedExecutionException ex) { // diff --git a/core-java/src/main/java/com/baeldung/array/ArrayInverter.java b/core-java/src/main/java/com/baeldung/array/ArrayInverter.java new file mode 100644 index 0000000000..7f7fcbb5a8 --- /dev/null +++ b/core-java/src/main/java/com/baeldung/array/ArrayInverter.java @@ -0,0 +1,41 @@ +package com.baeldung.array; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.stream.IntStream; + +import org.apache.commons.lang3.ArrayUtils; + +import com.google.common.collect.Lists; + +public class ArrayInverter { + + public void invertUsingFor(Object[] array) { + for (int i = 0; i < array.length / 2; i++) { + Object temp = array[i]; + array[i] = array[array.length - 1 - i]; + array[array.length - 1 - i] = temp; + } + } + + public void invertUsingCollectionsReverse(Object[] array) { + List list = Arrays.asList(array); + Collections.reverse(list); + } + + public Object[] invertUsingStreams(final Object[] array) { + return IntStream.range(1, array.length + 1).mapToObj(i -> array[array.length - i]).toArray(); + } + + public void invertUsingCommonsLang(Object[] array) { + ArrayUtils.reverse(array); + } + + public Object[] invertUsingGuava(Object[] array) { + List list = Arrays.asList(array); + List reverted = Lists.reverse(list); + return reverted.toArray(); + } + +} diff --git a/core-java/src/main/java/com/baeldung/polymorphism/GenericFile.java b/core-java/src/main/java/com/baeldung/polymorphism/GenericFile.java index 4075083c49..03e704f36f 100644 --- a/core-java/src/main/java/com/baeldung/polymorphism/GenericFile.java +++ b/core-java/src/main/java/com/baeldung/polymorphism/GenericFile.java @@ -54,7 +54,7 @@ public class GenericFile { } public String getFileInfo() { - return "File Name: " + this.getName() + "\n" + "Extension: " + this.getExtension() + "\n" + "Date Created: " + this.getDateCreated() + "\n" + "Version: " + this.getVersion() + "\n"; + return String.format("File Name: %s\n" + " Extension: %s\n" + " Date Created: %s\n" + " Version: %s\n", this.getName(), this.getExtension(), this.getDateCreated(), this.getVersion()); } public Object read() { diff --git a/core-java/src/main/java/com/baeldung/polymorphism/ImageFile.java b/core-java/src/main/java/com/baeldung/polymorphism/ImageFile.java index ac72a40993..e237f3f826 100644 --- a/core-java/src/main/java/com/baeldung/polymorphism/ImageFile.java +++ b/core-java/src/main/java/com/baeldung/polymorphism/ImageFile.java @@ -30,7 +30,7 @@ public class ImageFile extends GenericFile { } public String getFileInfo() { - return super.getFileInfo() + "Height: " + this.getHeight() + "\n" + "Width: " + this.getWidth(); + return String.format(" %s Height: %d\n Width: %d", super.getFileInfo(), this.getHeight(), this.getWidth()); } public String read() { diff --git a/core-java/src/main/java/com/baeldung/polymorphism/TextFile.java b/core-java/src/main/java/com/baeldung/polymorphism/TextFile.java index 8280b4ee95..2c28c968b8 100644 --- a/core-java/src/main/java/com/baeldung/polymorphism/TextFile.java +++ b/core-java/src/main/java/com/baeldung/polymorphism/TextFile.java @@ -21,7 +21,7 @@ public class TextFile extends GenericFile { } public String getFileInfo() { - return super.getFileInfo() + "Word Count: " + wordCount; + return String.format(" %s Word Count: %d", super.getFileInfo(), wordCount); } public String read() { diff --git a/core-java/src/main/resources/countries.properties b/core-java/src/main/resources/countries.properties index e743b5a40b..50b5e85653 100644 --- a/core-java/src/main/resources/countries.properties +++ b/core-java/src/main/resources/countries.properties @@ -1,3 +1,3 @@ -UK -US -Germany +UK +US +Germany \ No newline at end of file diff --git a/core-java/src/test/java/com/baeldung/array/ArrayInverterUnitTest.java b/core-java/src/test/java/com/baeldung/array/ArrayInverterUnitTest.java new file mode 100644 index 0000000000..ca59ee51fb --- /dev/null +++ b/core-java/src/test/java/com/baeldung/array/ArrayInverterUnitTest.java @@ -0,0 +1,49 @@ +package com.baeldung.array; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.Test; + +public class ArrayInverterUnitTest { + + private String[] fruits = { "apples", "tomatoes", "bananas", "guavas", "pineapples", "oranges" }; + + @Test + public void invertArrayWithForLoop() { + ArrayInverter inverter = new ArrayInverter(); + inverter.invertUsingFor(fruits); + + assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits); + } + + @Test + public void invertArrayWithCollectionsReverse() { + ArrayInverter inverter = new ArrayInverter(); + inverter.invertUsingCollectionsReverse(fruits); + + assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits); + } + + @Test + public void invertArrayWithStreams() { + ArrayInverter inverter = new ArrayInverter(); + + assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(inverter.invertUsingStreams(fruits)); + } + + @Test + public void invertArrayWithCommonsLang() { + ArrayInverter inverter = new ArrayInverter(); + inverter.invertUsingCommonsLang(fruits); + + assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(fruits); + } + + @Test + public void invertArrayWithGuava() { + ArrayInverter inverter = new ArrayInverter(); + + assertThat(new String[] { "oranges", "pineapples", "guavas", "bananas", "tomatoes", "apples" }).isEqualTo(inverter.invertUsingGuava(fruits)); + } + +} diff --git a/core-java/src/test/java/com/baeldung/file/FilesTest.java b/core-java/src/test/java/com/baeldung/file/FilesTest.java index e17e8580aa..c5a5b8a3a1 100644 --- a/core-java/src/test/java/com/baeldung/file/FilesTest.java +++ b/core-java/src/test/java/com/baeldung/file/FilesTest.java @@ -91,4 +91,4 @@ public class FilesTest { new FileInputStream(fileName))) .isEqualTo("UK\r\n" + "US\r\n" + "Germany\r\n" + "Spain\n"); } -} +} \ No newline at end of file diff --git a/core-java/src/test/java/com/baeldung/nestedclass/NewOuter.java b/core-java/src/test/java/com/baeldung/nestedclass/NewOuter.java index a3a723b30e..260f69fd1b 100644 --- a/core-java/src/test/java/com/baeldung/nestedclass/NewOuter.java +++ b/core-java/src/test/java/com/baeldung/nestedclass/NewOuter.java @@ -14,9 +14,9 @@ public class NewOuter { public void run() { System.out.println("a = " + a); System.out.println("b = " + b); - System.out.println("NewOuterTest.this.a = " + NewOuter.this.a); - System.out.println("NewOuterTest.b = " + NewOuter.b); - System.out.println("NewOuterTest.this.b = " + NewOuter.this.b); + System.out.println("NewOuter.this.a = " + NewOuter.this.a); + System.out.println("NewOuter.b = " + NewOuter.b); + System.out.println("NewOuter.this.b = " + NewOuter.this.b); } } diff --git a/core-java/src/test/java/com/baeldung/polymorphism/PolymorphismUnitTest.java b/core-java/src/test/java/com/baeldung/polymorphism/PolymorphismUnitTest.java index 8fb606c2fc..58826766e0 100644 --- a/core-java/src/test/java/com/baeldung/polymorphism/PolymorphismUnitTest.java +++ b/core-java/src/test/java/com/baeldung/polymorphism/PolymorphismUnitTest.java @@ -3,8 +3,6 @@ package com.baeldung.polymorphism; import static org.junit.Assert.*; import java.awt.image.BufferedImage; - -import org.junit.Ignore; import org.junit.Test; public class PolymorphismUnitTest { diff --git a/core-kotlin/src/test/kotlin/com/baeldung/kotlin/ExtensionMethods.kt b/core-kotlin/src/test/kotlin/com/baeldung/kotlin/ExtensionMethods.kt new file mode 100644 index 0000000000..09ce898860 --- /dev/null +++ b/core-kotlin/src/test/kotlin/com/baeldung/kotlin/ExtensionMethods.kt @@ -0,0 +1,51 @@ +package com.baeldung.kotlin + +import org.junit.Assert +import org.junit.Test + +class ExtensionMethods { + @Test + fun simpleExtensionMethod() { + fun String.escapeForXml() : String { + return this + .replace("&", "&") + .replace("<", "<") + .replace(">", ">") + } + + Assert.assertEquals("Nothing", "Nothing".escapeForXml()) + Assert.assertEquals("<Tag>", "".escapeForXml()) + Assert.assertEquals("a&b", "a&b".escapeForXml()) + } + + @Test + fun genericExtensionMethod() { + fun T.concatAsString(b: T) : String { + return this.toString() + b.toString() + } + + Assert.assertEquals("12", "1".concatAsString("2")) + Assert.assertEquals("12", 1.concatAsString(2)) + // This doesn't compile + // Assert.assertEquals("12", 1.concatAsString(2.0)) + } + + @Test + fun infixExtensionMethod() { + infix fun Number.toPowerOf(exponent: Number): Double { + return Math.pow(this.toDouble(), exponent.toDouble()) + } + + Assert.assertEquals(9.0, 3 toPowerOf 2, 0.1) + Assert.assertEquals(3.0, 9 toPowerOf 0.5, 0.1) + } + + @Test + fun operatorExtensionMethod() { + operator fun List.times(by: Int): List { + return this.map { it * by } + } + + Assert.assertEquals(listOf(2, 4, 6), listOf(1, 2, 3) * 2) + } +} diff --git a/gradle/gradle-fat-jar/build.gradle b/gradle/gradle-fat-jar/build.gradle new file mode 100644 index 0000000000..6afad80652 --- /dev/null +++ b/gradle/gradle-fat-jar/build.gradle @@ -0,0 +1,41 @@ +buildscript { + repositories { + jcenter() + } + dependencies { + classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.1' + } +} + +apply plugin: 'java' +apply plugin: 'com.github.johnrengelman.shadow' + +repositories { + mavenCentral() +} + +jar { + manifest { + attributes "Main-Class": "com.baeldung.fatjar.Application" + } + + from { + configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } + } +} + + +task customFatJar(type: Jar) { + manifest { + attributes 'Main-Class': 'com.baeldung.fatjar.Application' + } + baseName = 'all-in-one-jar' + from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } } + with jar +} + + +dependencies{ + compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.25' + compile group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.25' +} \ No newline at end of file diff --git a/gradle/gradle-fat-jar/src/main/java/com/baeldung/fatjar/Application.java b/gradle/gradle-fat-jar/src/main/java/com/baeldung/fatjar/Application.java new file mode 100644 index 0000000000..470d89c332 --- /dev/null +++ b/gradle/gradle-fat-jar/src/main/java/com/baeldung/fatjar/Application.java @@ -0,0 +1,16 @@ +package com.baeldung.fatjar; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +public class Application { + + static final Logger logger = LoggerFactory.getLogger(Application.class); + + public static void main(String[] args) { + + logger.info("Hello at Baeldung!"); + } + +} \ No newline at end of file diff --git a/hibernate5/src/test/java/com/baeldung/hibernate/HibernateSpatialTest.java b/hibernate5/src/test/java/com/baeldung/hibernate/HibernateSpatialTest.java index 6d0aa0a4cd..a5c7b329fc 100644 --- a/hibernate5/src/test/java/com/baeldung/hibernate/HibernateSpatialTest.java +++ b/hibernate5/src/test/java/com/baeldung/hibernate/HibernateSpatialTest.java @@ -14,7 +14,9 @@ import org.junit.Test; import javax.persistence.Query; import java.io.IOException; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertEquals; + import static org.junit.Assert.assertTrue; public class HibernateSpatialTest { @@ -76,10 +78,8 @@ public class HibernateSpatialTest { Query query = session.createQuery("select p from PointEntity p where within(p.point, :area) = true", PointEntity.class); query.setParameter("area", wktToGeometry("POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))")); - assertEquals(3, query.getResultList().size()); - assertEquals("POINT (1 1)", ((PointEntity) query.getResultList().get(0)).getPoint().toString()); - assertEquals("POINT (1 2)", ((PointEntity) query.getResultList().get(1)).getPoint().toString()); - assertEquals("POINT (3 4)", ((PointEntity) query.getResultList().get(2)).getPoint().toString()); + assertThat(query.getResultList().stream().map(p -> ((PointEntity) p).getPoint().toString())) + .containsOnly("POINT (1 1)", "POINT (1 2)", "POINT (3 4)"); } private void insertPoint(String point) throws ParseException { diff --git a/libraries/helloWorld.docx b/libraries/helloWorld.docx new file mode 100644 index 0000000000..09e71a4d4e Binary files /dev/null and b/libraries/helloWorld.docx differ diff --git a/logging-modules/logback/README.md b/logging-modules/logback/README.md new file mode 100644 index 0000000000..e69de29bb2 diff --git a/logging-modules/logback/pom.xml b/logging-modules/logback/pom.xml new file mode 100644 index 0000000000..8169134442 --- /dev/null +++ b/logging-modules/logback/pom.xml @@ -0,0 +1,35 @@ + + + + 4.0.0 + + logback + logback + 0.1-SNAPSHOT + + + UTF-8 + 1.2.3 + + + + com.baeldung + parent-modules + 1.0.0-SNAPSHOT + ../../ + + + + + + ch.qos.logback + logback-classic + ${logback.version} + + + + + + diff --git a/logging-modules/logback/src/main/java/com/baeldung/logback/Example.java b/logging-modules/logback/src/main/java/com/baeldung/logback/Example.java new file mode 100644 index 0000000000..e3d09dc321 --- /dev/null +++ b/logging-modules/logback/src/main/java/com/baeldung/logback/Example.java @@ -0,0 +1,14 @@ +package com.baeldung.logback; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class Example { + + private static final Logger logger = LoggerFactory.getLogger(Example.class); + + public static void main(String[] args) { + logger.info("Example log from {}", Example.class.getSimpleName()); + } + +} diff --git a/logging-modules/logback/src/main/java/com/baeldung/logback/MapAppender.java b/logging-modules/logback/src/main/java/com/baeldung/logback/MapAppender.java new file mode 100644 index 0000000000..99cc6488e5 --- /dev/null +++ b/logging-modules/logback/src/main/java/com/baeldung/logback/MapAppender.java @@ -0,0 +1,37 @@ +package com.baeldung.logback; + +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.core.AppenderBase; + +import java.util.HashMap; +import java.util.Map; + +public class MapAppender extends AppenderBase { + + private final Map eventMap = new HashMap<>(); + + private String prefix; + + @Override + protected void append(final ILoggingEvent event) { + if (prefix == null || "".equals(prefix)) { + addError("Prefix is not set for MapAppender."); + return; + } + + eventMap.put(prefix + System.currentTimeMillis(), event); + } + + public String getPrefix() { + return prefix; + } + + public void setPrefix(final String prefix) { + this.prefix = prefix; + } + + public Map getEventMap() { + return eventMap; + } + +} diff --git a/logging-modules/logback/src/main/resources/logback.xml b/logging-modules/logback/src/main/resources/logback.xml new file mode 100644 index 0000000000..37ae2adbb0 --- /dev/null +++ b/logging-modules/logback/src/main/resources/logback.xml @@ -0,0 +1,18 @@ + + + + test + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + \ No newline at end of file diff --git a/logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderIntegrationTest.java b/logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderIntegrationTest.java new file mode 100644 index 0000000000..20366a229d --- /dev/null +++ b/logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderIntegrationTest.java @@ -0,0 +1,33 @@ +package com.baeldung.logback; + +import ch.qos.logback.classic.Logger; +import org.junit.Before; +import org.junit.Test; +import org.slf4j.LoggerFactory; + +import static org.junit.Assert.assertEquals; + +public class MapAppenderIntegrationTest { + + private Logger rootLogger; + + @Before + public void setUp() throws Exception { + rootLogger = (Logger) LoggerFactory.getLogger("ROOT"); + } + + @Test + public void whenLoggerEmitsLoggingEvent_thenAppenderReceivesEvent() throws Exception { + rootLogger.info("Test from {}", this.getClass().getSimpleName()); + MapAppender appender = (MapAppender) rootLogger.getAppender("map"); + assertEquals(appender.getEventMap().size(), 1); + } + + @Test + public void givenNoPrefixSet_whenLoggerEmitsEvent_thenAppenderReceivesNoEvent() throws Exception { + rootLogger.info("Test from {}", this.getClass().getSimpleName()); + MapAppender appender = (MapAppender) rootLogger.getAppender("badMap"); + assertEquals(appender.getEventMap().size(), 0); + } + +} diff --git a/logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderTest.java b/logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderTest.java new file mode 100644 index 0000000000..a5a938a923 --- /dev/null +++ b/logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderTest.java @@ -0,0 +1,60 @@ +package com.baeldung.logback; + +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.LoggerContext; +import ch.qos.logback.classic.spi.LoggingEvent; +import ch.qos.logback.core.BasicStatusManager; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class MapAppenderTest { + + private LoggerContext ctx; + + private MapAppender mapAppender = new MapAppender(); + + private LoggingEvent event; + + @Before + public void setUp() throws Exception { + ctx = new LoggerContext(); + ctx.setName("test context"); + ctx.setStatusManager(new BasicStatusManager()); + mapAppender.setContext(ctx); + mapAppender.setPrefix("prefix"); + event = new LoggingEvent("fqcn", ctx.getLogger("logger"), Level.INFO, "Test message for logback appender", null, new Object[0]); + ctx.start(); + } + + @After + public void tearDown() throws Exception { + ctx.stop(); + mapAppender.stop(); + } + + @Test + public void whenPrefixIsNull_thenMapAppenderDoesNotLog() throws Exception { + mapAppender.setPrefix(null); + mapAppender.append(event); + assertTrue(mapAppender.getEventMap().isEmpty()); + } + + @Test + public void whenPrefixIsEmpty_thenMapAppenderDoesNotLog() throws Exception { + mapAppender.setPrefix(""); + mapAppender.append(event); + assertTrue(mapAppender.getEventMap().isEmpty()); + } + + @Test + public void whenLogMessageIsEmitted_thenMapAppenderReceivesMessage() throws Exception { + mapAppender.append(event); + assertEquals(mapAppender.getEventMap().size(), 1); + mapAppender.getEventMap().forEach((k, v) -> assertTrue(k.startsWith("prefix"))); + } + +} diff --git a/logging-modules/logback/src/test/resources/logback-test.xml b/logging-modules/logback/src/test/resources/logback-test.xml new file mode 100644 index 0000000000..8254e6ac80 --- /dev/null +++ b/logging-modules/logback/src/test/resources/logback-test.xml @@ -0,0 +1,14 @@ + + + + test + + + + + + + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml index cac0cc5845..cf01712cba 100644 --- a/pom.xml +++ b/pom.xml @@ -107,6 +107,7 @@ logging-modules/log-mdc logging-modules/log4j logging-modules/log4j2 + logging-modules/logback lombok mapstruct @@ -201,6 +202,7 @@ spring-rest-query-language spring-rest spring-rest-simple + spring-security-acl spring-security-cache-control spring-security-client/spring-security-jsp-authentication spring-security-client/spring-security-jsp-authorize diff --git a/spring-5/pom.xml b/spring-5/pom.xml index 7e30179f07..b6b6f9d370 100644 --- a/spring-5/pom.xml +++ b/spring-5/pom.xml @@ -14,7 +14,7 @@ org.springframework.boot spring-boot-starter-parent - 2.0.0.M6 + 2.0.0.M7 diff --git a/spring-cloud/README.md b/spring-cloud/README.md index 1b793144b1..b24e5b0296 100644 --- a/spring-cloud/README.md +++ b/spring-cloud/README.md @@ -15,6 +15,7 @@ - [Intro to Spring Cloud Netflix - Hystrix](http://www.baeldung.com/spring-cloud-netflix-hystrix) - [Dockerizing a Spring Boot Application](http://www.baeldung.com/dockerizing-spring-boot-application) - [Introduction to Spring Cloud Rest Client with Netflix Ribbon](http://www.baeldung.com/spring-cloud-rest-client-with-netflix-ribbon) +- [A Quick Guide to Spring Cloud Consul](http://www.baeldung.com/spring-cloud-consul) ### Relevant Articles: - [Introduction to Spring Cloud Rest Client with Netflix Ribbon](http://www.baeldung.com/spring-cloud-rest-client-with-netflix-ribbon) diff --git a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/discovery/DiscoveryClientApplication.java b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/discovery/DiscoveryClientApplication.java index b4f42219a4..d013969ad3 100644 --- a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/discovery/DiscoveryClientApplication.java +++ b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/discovery/DiscoveryClientApplication.java @@ -1,59 +1,16 @@ package com.baeldung.spring.cloud.consul.discovery; -import java.net.URI; - -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.builder.SpringApplicationBuilder; -import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.cloud.client.discovery.EnableDiscoveryClient; -import org.springframework.context.annotation.Bean; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.GetMapping; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RestController; -import org.springframework.web.client.RestTemplate; @SpringBootApplication @EnableDiscoveryClient -@RestController public class DiscoveryClientApplication { - @Bean - public RestTemplate restTemplate() { - return new RestTemplate(); - } - - @Autowired - private DiscoveryClient discoveryClient; - - @GetMapping("/discoveryClient") - public String home() { - return restTemplate().getForEntity(serviceUrl().resolve("/ping"), String.class) - .getBody(); - } - - @GetMapping("/ping") - public String ping() { - return "pong"; - } - - @RequestMapping("/my-health-check") - public ResponseEntity myCustomCheck() { - return new ResponseEntity<>(HttpStatus.OK); - } - - public URI serviceUrl() { - return discoveryClient.getInstances("myApp") - .stream() - .findFirst() - .map(si -> si.getUri()) - .orElse(null); - } - public static void main(String[] args) { new SpringApplicationBuilder(DiscoveryClientApplication.class).web(true) .run(args); } + } diff --git a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/discovery/DiscoveryClientController.java b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/discovery/DiscoveryClientController.java new file mode 100644 index 0000000000..1436096d10 --- /dev/null +++ b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/discovery/DiscoveryClientController.java @@ -0,0 +1,50 @@ +package com.baeldung.spring.cloud.consul.discovery; + +import java.net.URI; +import java.util.Optional; + +import javax.naming.ServiceUnavailableException; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.cloud.client.discovery.DiscoveryClient; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.client.RestClientException; +import org.springframework.web.client.RestTemplate; + +@RestController +public class DiscoveryClientController { + + @Autowired + private DiscoveryClient discoveryClient; + + private final RestTemplate restTemplate = new RestTemplate(); + + @GetMapping("/discoveryClient") + public String discoveryPing() throws RestClientException, ServiceUnavailableException { + URI service = serviceUrl().map(s -> s.resolve("/ping")) + .orElseThrow(ServiceUnavailableException::new); + return restTemplate.getForEntity(service, String.class) + .getBody(); + } + + @GetMapping("/ping") + public String ping() { + return "pong"; + } + + @GetMapping("/my-health-check") + public ResponseEntity myCustomCheck() { + return new ResponseEntity<>(HttpStatus.OK); + } + + public Optional serviceUrl() { + return discoveryClient.getInstances("myApp") + .stream() + .findFirst() + .map(si -> si.getUri()); + } + +} diff --git a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/health/ServiceDiscoveryApplication.java b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/health/ServiceDiscoveryApplication.java index 7db361eb4f..020d7d017c 100644 --- a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/health/ServiceDiscoveryApplication.java +++ b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/health/ServiceDiscoveryApplication.java @@ -2,24 +2,9 @@ package com.baeldung.spring.cloud.consul.health; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.builder.SpringApplicationBuilder; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RestController; @SpringBootApplication -@RestController public class ServiceDiscoveryApplication { - @RequestMapping("/my-health-check") - public ResponseEntity myCustomCheck() { - String message = "Testing my healh check function"; - return new ResponseEntity<>(message, HttpStatus.FORBIDDEN); - } - - @RequestMapping("/ping") - public String ping() { - return "pong"; - } public static void main(String[] args) { new SpringApplicationBuilder(ServiceDiscoveryApplication.class).web(true) diff --git a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/health/ServiceDiscoveryController.java b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/health/ServiceDiscoveryController.java new file mode 100644 index 0000000000..20deba993f --- /dev/null +++ b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/health/ServiceDiscoveryController.java @@ -0,0 +1,22 @@ +package com.baeldung.spring.cloud.consul.health; + +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +public class ServiceDiscoveryController { + + @GetMapping("/ping") + public String ping() { + return "pong"; + } + + @GetMapping("/my-health-check") + public ResponseEntity myCustomCheck() { + String message = "Testing my healh check function"; + return new ResponseEntity<>(message, HttpStatus.FORBIDDEN); + } + +} diff --git a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/DistributedPropertiesApplication.java b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/DistributedPropertiesApplication.java index 919bf08921..c1d2b0acc5 100644 --- a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/DistributedPropertiesApplication.java +++ b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/DistributedPropertiesApplication.java @@ -1,34 +1,16 @@ package com.baeldung.spring.cloud.consul.properties; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.builder.SpringApplicationBuilder; -import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @SpringBootApplication @RestController public class DistributedPropertiesApplication { - @Value("${my.prop}") - String value; - - @Autowired - private MyProperties properties; - - @RequestMapping("/getConfigFromValue") - public String getConfigFromValue() { - return value; - } - - @RequestMapping("/getConfigFromProperty") - public String getConfigFromProperty() { - return properties.getProp(); - } - public static void main(String[] args) { new SpringApplicationBuilder(DistributedPropertiesApplication.class).web(true) .run(args); } + } diff --git a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/DistributedPropertiesController.java b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/DistributedPropertiesController.java new file mode 100644 index 0000000000..da2d37eb76 --- /dev/null +++ b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/DistributedPropertiesController.java @@ -0,0 +1,27 @@ +package com.baeldung.spring.cloud.consul.properties; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +public class DistributedPropertiesController { + + @Value("${my.prop}") + String value; + + @Autowired + private MyProperties properties; + + @GetMapping("/getConfigFromValue") + public String getConfigFromValue() { + return value; + } + + @GetMapping("/getConfigFromProperty") + public String getConfigFromProperty() { + return properties.getProp(); + } + +} diff --git a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/MyProperties.java b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/MyProperties.java index 7accac168d..d92b18ed51 100644 --- a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/MyProperties.java +++ b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/properties/MyProperties.java @@ -8,6 +8,7 @@ import org.springframework.context.annotation.Configuration; @Configuration @ConfigurationProperties("my") public class MyProperties { + private String prop; public String getProp() { @@ -17,4 +18,5 @@ public class MyProperties { public void setProp(String prop) { this.prop = prop; } + } diff --git a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/ribbon/RibbonClientApplication.java b/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/ribbon/RibbonClientApplication.java deleted file mode 100644 index b2b54fbe8e..0000000000 --- a/spring-cloud/spring-cloud-consul/src/main/java/com/baeldung/spring/cloud/consul/ribbon/RibbonClientApplication.java +++ /dev/null @@ -1,47 +0,0 @@ -package com.baeldung.spring.cloud.consul.ribbon; - -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.autoconfigure.SpringBootApplication; -import org.springframework.boot.builder.SpringApplicationBuilder; -import org.springframework.cloud.client.loadbalancer.LoadBalanced; -import org.springframework.context.annotation.Bean; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.GetMapping; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RestController; -import org.springframework.web.client.RestTemplate; - -@SpringBootApplication -@RestController -public class RibbonClientApplication { - - @LoadBalanced - @Bean - RestTemplate getRestTemplate() { - return new RestTemplate(); - } - - @Autowired - RestTemplate restTemplate; - - @RequestMapping("/ribbonClient") - public String home() { - return restTemplate.getForObject("http://myApp/ping", String.class); - } - - @GetMapping("/ping") - public String ping() { - return "pong"; - } - - @RequestMapping("/my-health-check") - public ResponseEntity myCustomCheck() { - return new ResponseEntity<>(HttpStatus.OK); - } - - public static void main(String[] args) { - new SpringApplicationBuilder(RibbonClientApplication.class).web(true) - .run(args); - } -} diff --git a/spring-integration/pom.xml b/spring-integration/pom.xml index a162f18b9c..4e210122b0 100644 --- a/spring-integration/pom.xml +++ b/spring-integration/pom.xml @@ -22,7 +22,7 @@ 1.1.4.RELEASE 1.4.7 1.1.1 - + 4.12 2.10 1.5.0 @@ -56,7 +56,7 @@ exec-maven-plugin ${exec-maven-plugin.version} - com.baeldung.samples.Main + com.baeldung.samples.FileCopyConfig @@ -106,6 +106,12 @@ spring-integration-file ${spring.integration.version} + + junit + junit + ${junit.version} + test + diff --git a/spring-security-acl/README.md b/spring-security-acl/README.md new file mode 100644 index 0000000000..fb3e8160ab --- /dev/null +++ b/spring-security-acl/README.md @@ -0,0 +1,4 @@ +## Spring Security ACL Project + +### Relevant Articles +- [Introduction to Spring Security ACL](http://www.baeldung.com/spring-security-acl) diff --git a/spring-security-acl/pom.xml b/spring-security-acl/pom.xml new file mode 100644 index 0000000000..67197bc2f8 --- /dev/null +++ b/spring-security-acl/pom.xml @@ -0,0 +1,66 @@ + + + 4.0.0 + + com.baeldung + spring-security-acl + 0.0.1-SNAPSHOT + war + + spring-security-acl + Spring Security ACL + + + parent-boot-5 + com.baeldung + 0.0.1-SNAPSHOT + ../parent-boot-5 + + + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + + com.h2database + h2 + + + + org.springframework + spring-test + test + + + + org.springframework.security + spring-security-test + test + + + + org.springframework.security + spring-security-acl + + + org.springframework.security + spring-security-config + + + org.springframework + spring-context-support + + + net.sf.ehcache + ehcache-core + 2.6.11 + jar + + + + + diff --git a/spring-security-acl/src/main/java/org/baeldung/acl/config/ACLContext.java b/spring-security-acl/src/main/java/org/baeldung/acl/config/ACLContext.java new file mode 100644 index 0000000000..337e745c3c --- /dev/null +++ b/spring-security-acl/src/main/java/org/baeldung/acl/config/ACLContext.java @@ -0,0 +1,80 @@ +package org.baeldung.acl.config; + +import javax.sql.DataSource; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.cache.ehcache.EhCacheFactoryBean; +import org.springframework.cache.ehcache.EhCacheManagerFactoryBean; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler; +import org.springframework.security.access.expression.method.MethodSecurityExpressionHandler; +import org.springframework.security.acls.AclPermissionCacheOptimizer; +import org.springframework.security.acls.AclPermissionEvaluator; +import org.springframework.security.acls.domain.AclAuthorizationStrategy; +import org.springframework.security.acls.domain.AclAuthorizationStrategyImpl; +import org.springframework.security.acls.domain.ConsoleAuditLogger; +import org.springframework.security.acls.domain.DefaultPermissionGrantingStrategy; +import org.springframework.security.acls.domain.EhCacheBasedAclCache; +import org.springframework.security.acls.jdbc.BasicLookupStrategy; +import org.springframework.security.acls.jdbc.JdbcMutableAclService; +import org.springframework.security.acls.jdbc.LookupStrategy; +import org.springframework.security.acls.model.PermissionGrantingStrategy; +import org.springframework.security.core.authority.SimpleGrantedAuthority; + +@Configuration +@EnableAutoConfiguration +public class ACLContext { + + @Autowired + DataSource dataSource; + + @Bean + public EhCacheBasedAclCache aclCache() { + return new EhCacheBasedAclCache(aclEhCacheFactoryBean().getObject(), permissionGrantingStrategy(), aclAuthorizationStrategy()); + } + + @Bean + public EhCacheFactoryBean aclEhCacheFactoryBean() { + EhCacheFactoryBean ehCacheFactoryBean = new EhCacheFactoryBean(); + ehCacheFactoryBean.setCacheManager(aclCacheManager().getObject()); + ehCacheFactoryBean.setCacheName("aclCache"); + return ehCacheFactoryBean; + } + + @Bean + public EhCacheManagerFactoryBean aclCacheManager() { + return new EhCacheManagerFactoryBean(); + } + + @Bean + public PermissionGrantingStrategy permissionGrantingStrategy() { + return new DefaultPermissionGrantingStrategy(new ConsoleAuditLogger()); + } + + @Bean + public AclAuthorizationStrategy aclAuthorizationStrategy() { + return new AclAuthorizationStrategyImpl(new SimpleGrantedAuthority("ROLE_ADMIN")); + } + + @Bean + public MethodSecurityExpressionHandler defaultMethodSecurityExpressionHandler() { + DefaultMethodSecurityExpressionHandler expressionHandler = new DefaultMethodSecurityExpressionHandler(); + AclPermissionEvaluator permissionEvaluator = new AclPermissionEvaluator(aclService()); + expressionHandler.setPermissionEvaluator(permissionEvaluator); + expressionHandler.setPermissionCacheOptimizer(new AclPermissionCacheOptimizer(aclService())); + return expressionHandler; + } + + @Bean + public LookupStrategy lookupStrategy() { + return new BasicLookupStrategy(dataSource, aclCache(), aclAuthorizationStrategy(), new ConsoleAuditLogger()); + } + + @Bean + public JdbcMutableAclService aclService() { + return new JdbcMutableAclService(dataSource, lookupStrategy(), aclCache()); + } + +} \ No newline at end of file diff --git a/spring-security-acl/src/main/java/org/baeldung/acl/config/AclMethodSecurityConfiguration.java b/spring-security-acl/src/main/java/org/baeldung/acl/config/AclMethodSecurityConfiguration.java new file mode 100644 index 0000000000..e503cb1a41 --- /dev/null +++ b/spring-security-acl/src/main/java/org/baeldung/acl/config/AclMethodSecurityConfiguration.java @@ -0,0 +1,21 @@ +package org.baeldung.acl.config; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Configuration; +import org.springframework.security.access.expression.method.MethodSecurityExpressionHandler; +import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity; +import org.springframework.security.config.annotation.method.configuration.GlobalMethodSecurityConfiguration; + +@Configuration +@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true) +public class AclMethodSecurityConfiguration extends GlobalMethodSecurityConfiguration { + + @Autowired + MethodSecurityExpressionHandler defaultMethodSecurityExpressionHandler; + + @Override + protected MethodSecurityExpressionHandler createExpressionHandler() { + return defaultMethodSecurityExpressionHandler; + } + +} diff --git a/spring-security-acl/src/main/java/org/baeldung/acl/config/JPAPersistenceConfig.java b/spring-security-acl/src/main/java/org/baeldung/acl/config/JPAPersistenceConfig.java new file mode 100644 index 0000000000..24d170e56c --- /dev/null +++ b/spring-security-acl/src/main/java/org/baeldung/acl/config/JPAPersistenceConfig.java @@ -0,0 +1,16 @@ +package org.baeldung.acl.config; + +import org.springframework.boot.autoconfigure.domain.EntityScan; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.PropertySource; +import org.springframework.data.jpa.repository.config.EnableJpaRepositories; +import org.springframework.transaction.annotation.EnableTransactionManagement; + +@Configuration +@EnableTransactionManagement +@EnableJpaRepositories(basePackages = "org.baeldung.acl.persistence.dao") +@PropertySource("classpath:org.baeldung.acl.datasource.properties") +@EntityScan(basePackages={ "org.baeldung.acl.persistence.entity" }) +public class JPAPersistenceConfig { + +} diff --git a/spring-security-acl/src/main/java/org/baeldung/acl/persistence/dao/NoticeMessageRepository.java b/spring-security-acl/src/main/java/org/baeldung/acl/persistence/dao/NoticeMessageRepository.java new file mode 100644 index 0000000000..91a2af7d83 --- /dev/null +++ b/spring-security-acl/src/main/java/org/baeldung/acl/persistence/dao/NoticeMessageRepository.java @@ -0,0 +1,24 @@ +package org.baeldung.acl.persistence.dao; + +import java.util.List; + +import org.baeldung.acl.persistence.entity.NoticeMessage; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.repository.query.Param; +import org.springframework.security.access.prepost.PostAuthorize; +import org.springframework.security.access.prepost.PostFilter; +import org.springframework.security.access.prepost.PreAuthorize; + +public interface NoticeMessageRepository extends JpaRepository{ + + @PostFilter("hasPermission(filterObject, 'READ')") + List findAll(); + + @PostAuthorize("hasPermission(returnObject, 'READ')") + NoticeMessage findById(Integer id); + + @SuppressWarnings("unchecked") + @PreAuthorize("hasPermission(#noticeMessage, 'WRITE')") + NoticeMessage save(@Param("noticeMessage")NoticeMessage noticeMessage); + +} diff --git a/spring-security-acl/src/main/java/org/baeldung/acl/persistence/entity/NoticeMessage.java b/spring-security-acl/src/main/java/org/baeldung/acl/persistence/entity/NoticeMessage.java new file mode 100644 index 0000000000..bd1e866f83 --- /dev/null +++ b/spring-security-acl/src/main/java/org/baeldung/acl/persistence/entity/NoticeMessage.java @@ -0,0 +1,29 @@ +package org.baeldung.acl.persistence.entity; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; + +@Entity +@Table(name="system_message") +public class NoticeMessage { + + @Id + @Column + private Integer id; + @Column + private String content; + public Integer getId() { + return id; + } + public void setId(Integer id) { + this.id = id; + } + public String getContent() { + return content; + } + public void setContent(String content) { + this.content = content; + } +} \ No newline at end of file diff --git a/spring-security-acl/src/main/resources/acl-data.sql b/spring-security-acl/src/main/resources/acl-data.sql new file mode 100644 index 0000000000..a4e0011834 --- /dev/null +++ b/spring-security-acl/src/main/resources/acl-data.sql @@ -0,0 +1,26 @@ +INSERT INTO acl_sid (id, principal, sid) VALUES +(1, 1, 'manager'), +(2, 1, 'hr'), +(3, 0, 'ROLE_EDITOR'); + +INSERT INTO acl_class (id, class) VALUES +(1, 'org.baeldung.acl.persistence.entity.NoticeMessage'); + +INSERT INTO system_message(id,content) VALUES +(1,'First Level Message'), +(2,'Second Level Message'), +(3,'Third Level Message'); + +INSERT INTO acl_object_identity (id, object_id_class, object_id_identity, parent_object, owner_sid, entries_inheriting) VALUES +(1, 1, 1, NULL, 3, 0), +(2, 1, 2, NULL, 3, 0), +(3, 1, 3, NULL, 3, 0); + +INSERT INTO acl_entry (id, acl_object_identity, ace_order, sid, mask, granting, audit_success, audit_failure) VALUES +(1, 1, 1, 1, 1, 1, 1, 1), +(2, 1, 2, 1, 2, 1, 1, 1), +(3, 1, 3, 3, 1, 1, 1, 1), +(4, 2, 1, 2, 1, 1, 1, 1), +(5, 2, 2, 3, 1, 1, 1, 1), +(6, 3, 1, 3, 1, 1, 1, 1), +(7, 3, 2, 3, 2, 1, 1, 1); \ No newline at end of file diff --git a/spring-security-acl/src/main/resources/acl-schema.sql b/spring-security-acl/src/main/resources/acl-schema.sql new file mode 100644 index 0000000000..9f74048230 --- /dev/null +++ b/spring-security-acl/src/main/resources/acl-schema.sql @@ -0,0 +1,58 @@ +create table IF NOT EXISTS system_message (id integer not null, content varchar(255), primary key (id)); + +CREATE TABLE IF NOT EXISTS acl_sid ( + id bigint(20) NOT NULL AUTO_INCREMENT, + principal tinyint(1) NOT NULL, + sid varchar(100) NOT NULL, + PRIMARY KEY (id), + UNIQUE KEY unique_uk_1 (sid,principal) +); + +CREATE TABLE IF NOT EXISTS acl_class ( + id bigint(20) NOT NULL AUTO_INCREMENT, + class varchar(255) NOT NULL, + PRIMARY KEY (id), + UNIQUE KEY unique_uk_2 (class) +); + +CREATE TABLE IF NOT EXISTS acl_entry ( + id bigint(20) NOT NULL AUTO_INCREMENT, + acl_object_identity bigint(20) NOT NULL, + ace_order int(11) NOT NULL, + sid bigint(20) NOT NULL, + mask int(11) NOT NULL, + granting tinyint(1) NOT NULL, + audit_success tinyint(1) NOT NULL, + audit_failure tinyint(1) NOT NULL, + PRIMARY KEY (id), + UNIQUE KEY unique_uk_4 (acl_object_identity,ace_order) +); + +CREATE TABLE IF NOT EXISTS acl_object_identity ( + id bigint(20) NOT NULL AUTO_INCREMENT, + object_id_class bigint(20) NOT NULL, + object_id_identity bigint(20) NOT NULL, + parent_object bigint(20) DEFAULT NULL, + owner_sid bigint(20) DEFAULT NULL, + entries_inheriting tinyint(1) NOT NULL, + PRIMARY KEY (id), + UNIQUE KEY unique_uk_3 (object_id_class,object_id_identity) +); + +ALTER TABLE acl_entry +ADD FOREIGN KEY (acl_object_identity) REFERENCES acl_object_identity(id); + +ALTER TABLE acl_entry +ADD FOREIGN KEY (sid) REFERENCES acl_sid(id); + +-- +-- Constraints for table acl_object_identity +-- +ALTER TABLE acl_object_identity +ADD FOREIGN KEY (parent_object) REFERENCES acl_object_identity (id); + +ALTER TABLE acl_object_identity +ADD FOREIGN KEY (object_id_class) REFERENCES acl_class (id); + +ALTER TABLE acl_object_identity +ADD FOREIGN KEY (owner_sid) REFERENCES acl_sid (id); \ No newline at end of file diff --git a/spring-security-acl/src/main/resources/org.baeldung.acl.datasource.properties b/spring-security-acl/src/main/resources/org.baeldung.acl.datasource.properties new file mode 100644 index 0000000000..40f1e6ef38 --- /dev/null +++ b/spring-security-acl/src/main/resources/org.baeldung.acl.datasource.properties @@ -0,0 +1,12 @@ +spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_ON_EXIT=FALSE +spring.datasource.username=sa +spring.datasource.password= +spring.datasource.driverClassName=org.h2.Driver +spring.jpa.hibernate.ddl-auto=update +spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect + +spring.h2.console.path=/myconsole +spring.h2.console.enabled=true +spring.datasource.initialize=true +spring.datasource.schema=classpath:acl-schema.sql +spring.datasource.data=classpath:acl-data.sql \ No newline at end of file diff --git a/spring-security-acl/src/test/java/org/baeldung/acl/SpringAclTest.java b/spring-security-acl/src/test/java/org/baeldung/acl/SpringAclTest.java new file mode 100644 index 0000000000..b864639d74 --- /dev/null +++ b/spring-security-acl/src/test/java/org/baeldung/acl/SpringAclTest.java @@ -0,0 +1,119 @@ +package org.baeldung.acl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import java.util.List; + +import org.baeldung.acl.persistence.dao.NoticeMessageRepository; +import org.baeldung.acl.persistence.entity.NoticeMessage; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; +import org.springframework.security.access.AccessDeniedException; +import org.springframework.security.test.context.support.WithMockUser; +import org.springframework.security.test.context.support.WithSecurityContextTestExecutionListener; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestExecutionListeners; +import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.test.context.support.DependencyInjectionTestExecutionListener; +import org.springframework.test.context.support.DirtiesContextTestExecutionListener; +import org.springframework.test.context.transaction.TransactionalTestExecutionListener; +import org.springframework.test.context.web.ServletTestExecutionListener; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration +@TestExecutionListeners(listeners={ServletTestExecutionListener.class, + DependencyInjectionTestExecutionListener.class, + DirtiesContextTestExecutionListener.class, + TransactionalTestExecutionListener.class, + WithSecurityContextTestExecutionListener.class}) +public class SpringAclTest extends AbstractJUnit4SpringContextTests{ + + private static Integer FIRST_MESSAGE_ID = 1; + private static Integer SECOND_MESSAGE_ID = 2; + private static Integer THIRD_MESSAGE_ID = 3; + private static String EDITTED_CONTENT = "EDITED"; + + @Configuration + @ComponentScan("org.baeldung.acl.*") + public static class SpringConfig { + + } + + @Autowired + NoticeMessageRepository repo; + + @Test + @WithMockUser(username="manager") + public void givenUserManager_whenFindAllMessage_thenReturnFirstMessage(){ + List details = repo.findAll(); + assertNotNull(details); + assertEquals(1,details.size()); + assertEquals(FIRST_MESSAGE_ID,details.get(0).getId()); + } + + @Test + @WithMockUser(username="manager") + public void givenUserManager_whenFind1stMessageByIdAndUpdateItsContent_thenOK(){ + NoticeMessage firstMessage = repo.findById(FIRST_MESSAGE_ID); + assertNotNull(firstMessage); + assertEquals(FIRST_MESSAGE_ID,firstMessage.getId()); + + firstMessage.setContent(EDITTED_CONTENT); + repo.save(firstMessage); + + NoticeMessage editedFirstMessage = repo.findById(FIRST_MESSAGE_ID); + assertNotNull(editedFirstMessage); + assertEquals(FIRST_MESSAGE_ID,editedFirstMessage.getId()); + assertEquals(EDITTED_CONTENT,editedFirstMessage.getContent()); + } + + @Test + @WithMockUser(username="hr") + public void givenUsernameHr_whenFindMessageById2_thenOK(){ + NoticeMessage secondMessage = repo.findById(SECOND_MESSAGE_ID); + assertNotNull(secondMessage); + assertEquals(SECOND_MESSAGE_ID,secondMessage.getId()); + } + + @Test(expected=AccessDeniedException.class) + @WithMockUser(username="hr") + public void givenUsernameHr_whenUpdateMessageWithId2_thenFail(){ + NoticeMessage secondMessage = new NoticeMessage(); + secondMessage.setId(SECOND_MESSAGE_ID); + secondMessage.setContent(EDITTED_CONTENT); + repo.save(secondMessage); + } + + @Test + @WithMockUser(roles={"EDITOR"}) + public void givenRoleEditor_whenFindAllMessage_thenReturn3Message(){ + List details = repo.findAll(); + assertNotNull(details); + assertEquals(3,details.size()); + } + + @Test + @WithMockUser(roles={"EDITOR"}) + public void givenRoleEditor_whenUpdateThirdMessage_thenOK(){ + NoticeMessage thirdMessage = new NoticeMessage(); + thirdMessage.setId(THIRD_MESSAGE_ID); + thirdMessage.setContent(EDITTED_CONTENT); + repo.save(thirdMessage); + } + + @Test(expected=AccessDeniedException.class) + @WithMockUser(roles={"EDITOR"}) + public void givenRoleEditor_whenFind1stMessageByIdAndUpdateContent_thenFail(){ + NoticeMessage firstMessage = repo.findById(FIRST_MESSAGE_ID); + assertNotNull(firstMessage); + assertEquals(FIRST_MESSAGE_ID,firstMessage.getId()); + firstMessage.setContent(EDITTED_CONTENT); + repo.save(firstMessage); + } +} + \ No newline at end of file diff --git a/testing-modules/junit-5/src/main/java/com/baeldung/junit5/bean/NumbersBean.java b/testing-modules/junit-5/src/main/java/com/baeldung/junit5/bean/NumbersBean.java new file mode 100644 index 0000000000..48730fd844 --- /dev/null +++ b/testing-modules/junit-5/src/main/java/com/baeldung/junit5/bean/NumbersBean.java @@ -0,0 +1,22 @@ +package com.baeldung.junit5.bean; + +/** + * Bean that contains utility methods to work with numbers. + * + * @author Donato Rimenti + * + */ +public class NumbersBean { + + /** + * Returns true if a number is even, false otherwise. + * + * @param number + * the number to check + * @return true if the argument is even, false otherwise + */ + public boolean isNumberEven(int number) { + return number % 2 == 0; + } + +} diff --git a/testing-modules/junit-5/src/test/java/com/baeldung/junit5/bean/test/NumbersBeanUnitTest.java b/testing-modules/junit-5/src/test/java/com/baeldung/junit5/bean/test/NumbersBeanUnitTest.java new file mode 100644 index 0000000000..0297d010e8 --- /dev/null +++ b/testing-modules/junit-5/src/test/java/com/baeldung/junit5/bean/test/NumbersBeanUnitTest.java @@ -0,0 +1,43 @@ +package com.baeldung.junit5.bean.test; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import com.baeldung.junit5.bean.NumbersBean; + +/** + * Test class for {@link NumbersBean}. + * + * @author Donato Rimenti + * + */ +public class NumbersBeanUnitTest { + + /** + * The bean to test. + */ + private NumbersBean bean = new NumbersBean(); + + /** + * Tests that when an even number is passed to + * {@link NumbersBean#isNumberEven(int)}, true is returned. + */ + @Test + void givenEvenNumber_whenCheckingIsNumberEven_thenTrue() { + boolean result = bean.isNumberEven(8); + + Assertions.assertTrue(result); + } + + /** + * Tests that when an odd number is passed to + * {@link NumbersBean#isNumberEven(int)}, false is returned. + */ + @Test + void givenOddNumber_whenCheckingIsNumberEven_thenFalse() { + boolean result = bean.isNumberEven(3); + + Assertions.assertFalse(result); + } + +} diff --git a/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/BDDMockitoTest.java b/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/BDDMockitoTest.java new file mode 100644 index 0000000000..9cc586fb84 --- /dev/null +++ b/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/BDDMockitoTest.java @@ -0,0 +1,104 @@ +package org.baeldung.bddmockito; + +import static org.junit.Assert.fail; +import static org.mockito.BDDMockito.*; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; + + +public class BDDMockitoTest { + + PhoneBookService phoneBookService; + PhoneBookRepository phoneBookRepository; + + String momContactName = "Mom"; + String momPhoneNumber = "01234"; + String xContactName = "x"; + String tooLongPhoneNumber = "01111111111111"; + + @Before + public void init() { + phoneBookRepository = Mockito.mock(PhoneBookRepository.class); + phoneBookService = new PhoneBookService(phoneBookRepository); + } + + @Test + public void givenValidContactName_whenSearchInPhoneBook_thenRetunPhoneNumber() { + given(phoneBookRepository.contains(momContactName)).willReturn(true); + given(phoneBookRepository.getPhoneNumberByContactName(momContactName)) + .will((InvocationOnMock invocation) -> { + if(invocation.getArgument(0).equals(momContactName)) { + return momPhoneNumber; + } else { + return null; + } + }); + + String phoneNumber = phoneBookService.search(momContactName); + + then(phoneBookRepository).should().contains(momContactName); + then(phoneBookRepository).should().getPhoneNumberByContactName(momContactName); + Assert.assertEquals(phoneNumber, momPhoneNumber); + } + + @Test + public void givenInvalidContactName_whenSearch_thenRetunNull() { + given(phoneBookRepository.contains(xContactName)).willReturn(false); + + String phoneNumber = phoneBookService.search(xContactName); + + then(phoneBookRepository).should().contains(xContactName); + then(phoneBookRepository).should(never()).getPhoneNumberByContactName(xContactName); + Assert.assertEquals(phoneNumber, null); + } + + @Test + public void givenValidContactNameAndPhoneNumber_whenRegister_thenSucceed() { + given(phoneBookRepository.contains(momContactName)).willReturn(false); + + phoneBookService.register(momContactName, momPhoneNumber); + + verify(phoneBookRepository).insert(momContactName, momPhoneNumber); + } + + @Test + public void givenEmptyPhoneNumber_whenRegister_thenFail() { + given(phoneBookRepository.contains(momContactName)).willReturn(false); + + phoneBookService.register(xContactName, ""); + + then(phoneBookRepository).should(never()).insert(momContactName, momPhoneNumber); + } + + @Test + public void givenLongPhoneNumber_whenRegister_thenFail() { + given(phoneBookRepository.contains(xContactName)).willReturn(false); + willThrow(new RuntimeException()) + .given(phoneBookRepository).insert(any(String.class), eq(tooLongPhoneNumber)); + + try { + phoneBookService.register(xContactName, tooLongPhoneNumber); + fail("Should throw exception"); + } catch (RuntimeException ex) { } + + then(phoneBookRepository).should(never()).insert(momContactName, tooLongPhoneNumber); + } + + @Test + public void givenExistentContactName_whenRegister_thenFail() { + given(phoneBookRepository.contains(momContactName)) + .willThrow(new RuntimeException("Name already exist")); + + try { + phoneBookService.register(momContactName, momPhoneNumber); + fail("Should throw exception"); + } catch(Exception ex) { } + + then(phoneBookRepository).should(never()).insert(momContactName, momPhoneNumber); + } + +} diff --git a/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/PhoneBookRepository.java b/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/PhoneBookRepository.java new file mode 100644 index 0000000000..b73a1d835c --- /dev/null +++ b/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/PhoneBookRepository.java @@ -0,0 +1,26 @@ +package org.baeldung.bddmockito; + +public interface PhoneBookRepository { + + /** + * Insert phone record + * @param name Contact name + * @param phone Phone number + */ + void insert(String name, String phone); + + /** + * Search for contact phone number + * @param name Contact name + * @return phone number + */ + String getPhoneNumberByContactName(String name); + + /** + * Check if the phonebook contains this contact + * @param name Contact name + * @return true if this contact name exists + */ + boolean contains(String name); + +} diff --git a/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/PhoneBookService.java b/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/PhoneBookService.java new file mode 100644 index 0000000000..645884af02 --- /dev/null +++ b/testing-modules/mockito/src/test/java/org/baeldung/bddmockito/PhoneBookService.java @@ -0,0 +1,34 @@ +package org.baeldung.bddmockito; + +public class PhoneBookService { + + private PhoneBookRepository phoneBookRepository; + + public PhoneBookService(PhoneBookRepository phoneBookRepository) { + this.phoneBookRepository = phoneBookRepository; + } + + /** + * Register a contact + * @param name Contact name + * @param phone Phone number + */ + public void register(String name, String phone) { + if(!name.isEmpty() && !phone.isEmpty() && !phoneBookRepository.contains(name)) { + phoneBookRepository.insert(name, phone); + } + } + + /** + * Search for a phone number by contact name + * @param name Contact name + * @return Phone number + */ + public String search(String name) { + if(!name.isEmpty() && phoneBookRepository.contains(name)) { + return phoneBookRepository.getPhoneNumberByContactName(name); + } + return null; + } + +} diff --git a/vavr/src/main/java/com/baeldung/vavr/future/Util.java b/vavr/src/main/java/com/baeldung/vavr/future/Util.java new file mode 100644 index 0000000000..790ef2bf88 --- /dev/null +++ b/vavr/src/main/java/com/baeldung/vavr/future/Util.java @@ -0,0 +1,20 @@ +package com.baeldung.vavr.future; + +public class Util { + + public static String appendData(String initial) { + return initial + "Baeldung!"; + } + + public static int divideByZero(int num) { + return num / 0; + } + + public static String getSubstringMinusOne(String s) { + return s.substring(-1); + } + + public static String getSubstringMinusTwo(String s) { + return s.substring(-2); + } +} diff --git a/vavr/src/test/java/com/baeldung/vavr/future/FutureTest.java b/vavr/src/test/java/com/baeldung/vavr/future/FutureTest.java new file mode 100644 index 0000000000..1f2a3761eb --- /dev/null +++ b/vavr/src/test/java/com/baeldung/vavr/future/FutureTest.java @@ -0,0 +1,177 @@ +package com.baeldung.vavr.future; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executors; + +import org.junit.Test; + +import io.vavr.Tuple; +import io.vavr.Tuple2; +import io.vavr.concurrent.Future; +import io.vavr.control.Option; +import io.vavr.control.Try; + +public class FutureTest { + + @Test + public void whenChangeExecutorService_thenCorrect() { + String initialValue = "Welcome to "; + Future resultFuture = Future.of( + Executors.newSingleThreadExecutor(), + () -> Util.appendData(initialValue)); + String result = resultFuture.get(); + + assertThat(result).isEqualTo("Welcome to Baeldung!"); + } + + @Test + public void whenAppendData_thenCorrect1() { + String initialValue = "Welcome to "; + Future resultFuture = Future.of(() -> Util.appendData(initialValue)); + String result = resultFuture.get(); + + assertThat(result).isEqualTo("Welcome to Baeldung!"); + } + + @Test + public void whenAppendData_thenCorrect2() { + String initialValue = "Welcome to "; + Future resultFuture = Future.of(() -> Util.appendData(initialValue)); + resultFuture.await(); + Option> futureOption = resultFuture.getValue(); + Try futureTry = futureOption.get(); + String result = futureTry.get(); + + assertThat(result).isEqualTo("Welcome to Baeldung!"); + } + + @Test + public void whenAppendData_thenSuccess() { + String initialValue = "Welcome to "; + Future resultFuture = Future.of(() -> Util.appendData(initialValue)) + .onSuccess(finalResult -> System.out.println("Successfully Completed - Result: " + finalResult)) + .onFailure(finalResult -> System.out.println("Failed - Result: " + finalResult)); + String result = resultFuture.get(); + + assertThat(result).isEqualTo("Welcome to Baeldung!"); + } + + @Test + public void whenChainingCallbacks_thenCorrect() { + String initialValue = "Welcome to "; + Future resultFuture = Future.of(() -> Util.appendData(initialValue)) + .andThen(finalResult -> System.out.println("Completed - 1: " + finalResult)) + .andThen(finalResult -> System.out.println("Completed - 2: " + finalResult)); + String result = resultFuture.get(); + + assertThat(result).isEqualTo("Welcome to Baeldung!"); + } + + @Test + public void whenCallAwait_thenCorrect() { + String initialValue = "Welcome to "; + Future resultFuture = Future.of(() -> Util.appendData(initialValue)); + resultFuture = resultFuture.await(); + String result = resultFuture.get(); + + assertThat(result).isEqualTo("Welcome to Baeldung!"); + } + + @Test + public void whenDivideByZero_thenGetThrowable1() { + Future resultFuture = Future.of(() -> Util.divideByZero(10)); + Future throwableFuture = resultFuture.failed(); + Throwable throwable = throwableFuture.get(); + + assertThat(throwable.getMessage()).isEqualTo("/ by zero"); + } + + @Test + public void whenDivideByZero_thenGetThrowable2() { + Future resultFuture = Future.of(() -> Util.divideByZero(10)); + resultFuture.await(); + Option throwableOption = resultFuture.getCause(); + Throwable throwable = throwableOption.get(); + + assertThat(throwable.getMessage()).isEqualTo("/ by zero"); + } + + @Test + public void whenDivideByZero_thenCorrect() throws InterruptedException { + Future resultFuture = Future.of(() -> Util.divideByZero(10)); + resultFuture.await(); + + assertThat(resultFuture.isCompleted()).isTrue(); + assertThat(resultFuture.isSuccess()).isFalse(); + assertThat(resultFuture.isFailure()).isTrue(); + } + + @Test + public void whenAppendData_thenFutureNotEmpty() { + String initialValue = "Welcome to "; + Future resultFuture = Future.of(() -> Util.appendData(initialValue)); + resultFuture.await(); + + assertThat(resultFuture.isEmpty()).isFalse(); + } + + @Test + public void whenCallZip_thenCorrect() { + Future> future = Future.of(() -> "John") + .zip(Future.of(() -> new Integer(5))); + future.await(); + + assertThat(future.get()).isEqualTo(Tuple.of("John", new Integer(5))); + } + + @Test + public void whenConvertToCompletableFuture_thenCorrect() throws InterruptedException, ExecutionException { + String initialValue = "Welcome to "; + Future resultFuture = Future.of(() -> Util.appendData(initialValue)); + CompletableFuture convertedFuture = resultFuture.toCompletableFuture(); + + assertThat(convertedFuture.get()).isEqualTo("Welcome to Baeldung!"); + } + + @Test + public void whenCallMap_thenCorrect() { + Future futureResult = Future.of(() -> new StringBuilder("from Baeldung")) + .map(a -> "Hello " + a); + futureResult.await(); + + assertThat(futureResult.get()).isEqualTo("Hello from Baeldung"); + } + + @Test + public void whenFutureFails_thenGetErrorMessage() { + Future resultFuture = Future.of(() -> Util.getSubstringMinusOne("Hello")); + Future errorMessageFuture = resultFuture.recover(Throwable::getMessage); + String errorMessage = errorMessageFuture.get(); + + assertThat(errorMessage).isEqualTo("String index out of range: -1"); + } + + @Test + public void whenFutureFails_thenGetAnotherFuture() { + Future resultFuture = Future.of(() -> Util.getSubstringMinusOne("Hello")); + Future errorMessageFuture = resultFuture.recoverWith(a -> Future.of(a::getMessage)); + String errorMessage = errorMessageFuture.get(); + + assertThat(errorMessage).isEqualTo("String index out of range: -1"); + } + + @Test + public void whenBothFuturesFail_thenGetErrorMessage() { + Future future1 = Future.of(() -> Util.getSubstringMinusOne("Hello")); + Future future2 = Future.of(() -> Util.getSubstringMinusTwo("Hello")); + Future errorMessageFuture = future1.fallbackTo(future2); + Future errorMessage = errorMessageFuture.failed(); + + assertThat( + errorMessage.get().getMessage()) + .isEqualTo("String index out of range: -1"); + } +} diff --git a/vavr/src/test/java/com/baeldung/vavr/future/FutureUnitTest.java b/vavr/src/test/java/com/baeldung/vavr/future/FutureUnitTest.java deleted file mode 100644 index 437742c964..0000000000 --- a/vavr/src/test/java/com/baeldung/vavr/future/FutureUnitTest.java +++ /dev/null @@ -1,289 +0,0 @@ -package com.baeldung.vavr.future; - -import static io.vavr.API.$; -import static io.vavr.API.Case; -import static io.vavr.API.Match; -import static io.vavr.Predicates.exists; -import static io.vavr.Predicates.forAll; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -import java.util.concurrent.CancellationException; -import java.util.function.Consumer; -import java.util.function.Predicate; - -import org.junit.Test; -import org.mockito.Mockito; -import org.mockito.internal.verification.VerificationModeFactory; -import org.mockito.verification.Timeout; - -import io.vavr.Tuple; -import io.vavr.Tuple2; -import io.vavr.collection.List; -import io.vavr.concurrent.Future; -import io.vavr.control.Try; - -public class FutureUnitTest { - - private final String SUCCESS = "Success"; - private final String FAILURE = "Failure"; - - @Test - public void givenFunctionReturnInteger_WhenCallWithFuture_ShouldReturnFunctionValue() { - Future future = Future.of(() -> 1); - - assertEquals(1, future.get().intValue()); - } - - @Test - public void givenFunctionGetRemoteHttpResourceAsString_WhenCallSuccessWithFuture_ShouldReturnContentValueAsString() { - String url = "http://resource"; - String content = "Content from " + url; - Future future = Future.of(() -> getResource(url)); - - assertEquals(content, future.get()); - } - - @Test - public void givenFunctionThrowException_WhenCallWithFuture_ShouldReturnFailure() { - Future future = Future.of(() -> getResourceThrowException("")); - future.await(); - - assertTrue(future.isFailure()); - } - - @Test - public void givenAFutureReturnZero_WhenCheckFutureWithExistEvenValue_ShouldReturnRight() { - Future future = Future.of(() -> 2); - boolean result = future.exists(i -> i % 2 == 0); - - assertTrue(result); - } - - @Test - public void givenFunction_WhenCallWithFutureAndRegisterConsumerForSuccess_ShouldCallConsumerToStoreValue() { - Future future = Future.of(() -> 1); - MockConsumer consumer = Mockito.mock(MockConsumer.class); - future.onSuccess(consumer); - Mockito.verify(consumer, new Timeout(1000, VerificationModeFactory.times(1))).accept(1); - } - - @Test - public void givenFunctionThrowException_WhenCallWithFutureAndRegisterConsumerForFailer_ShouldCallConsumerToStoreException() { - Future future = Future.of(() -> getResourceThrowException("")); - MockThrowableConsumer consumer = Mockito.mock(MockThrowableConsumer.class); - future.onFailure(consumer); - Mockito.verify(consumer, new Timeout(1000, VerificationModeFactory.times(1))).accept(Mockito.any()); - } - - @Test - public void givenAFuture_WhenAddAndThenConsumer_ShouldCallConsumerWithResultOfFutureAction() { - MockTryConsumer consumer1 = Mockito.mock(MockTryConsumer.class); - MockTryConsumer consumer2 = Mockito.mock(MockTryConsumer.class); - Future future = Future.of(() -> 1); - Future andThenFuture = future.andThen(consumer1).andThen(consumer2); - andThenFuture.await(); - Mockito.verify(consumer1, VerificationModeFactory.times(1)).accept(Try.success(1)); - Mockito.verify(consumer2, VerificationModeFactory.times(1)).accept(Try.success(1)); - } - - @Test - public void givenAFailureFuture_WhenCallOrElseFunction_ShouldReturnNewFuture() { - Future future = Future.failed(new RuntimeException()); - Future future2 = future.orElse(Future.of(() -> 2)); - - assertEquals(2, future2.get().intValue()); - } - - @Test(expected = CancellationException.class) - public void givenAFuture_WhenCallCancel_ShouldReturnCancellationException() { - long waitTime = 1000; - Future future = Future.of(() -> { - Thread.sleep(waitTime); - return 1; - }); - future.cancel(); - future.await(); - future.get(); - } - - @Test - public void givenAFuture_WhenCallFallBackWithSuccessFuture_ShouldReturnFutureResult() { - String expectedResult = "take this"; - Future future = Future.of(() -> expectedResult); - Future secondFuture = Future.of(() -> "take that"); - Future futureResult = future.fallbackTo(secondFuture); - futureResult.await(); - - assertEquals(expectedResult, futureResult.get()); - } - - @Test - public void givenAFuture_WhenCallFallBackWithFailureFuture_ShouldReturnValueOfFallBackFuture() { - String expectedResult = "take that"; - Future future = Future.failed(new RuntimeException()); - Future fallbackFuture = Future.of(() -> expectedResult); - Future futureResult = future.fallbackTo(fallbackFuture); - - assertEquals(expectedResult, futureResult.get()); - } - - @Test - public void givenAFuture_WhenTransformByAddingOne_ShouldReturn() { - Future future = Future.of(() -> 1).transformValue(f -> Try.of(() -> "Hello: " + f.get())); - - assertEquals("Hello: 1", future.get()); - } - - @Test - public void givenAFutureOfInt_WhenMapToString_ShouldCombineAndReturn() { - Future future = Future.of(()->1).map(i -> "Hello: " + i); - - assertEquals("Hello: 1", future.get()); - } - - @Test - public void givenAFutureOfInt_WhenFlatMapToString_ShouldCombineAndReturn() { - Future futureMap = Future.of(() -> 1).flatMap((i) -> Future.of(() -> "Hello: " + i)); - - assertEquals("Hello: 1", futureMap.get()); - } - - @Test - public void givenAFutureOf2String_WhenZip_ShouldReturnTupleOf2String() { - Future> future = Future.of(() -> "hello").zip(Future.of(() -> "world")); - - assertEquals(Tuple.of("hello", "world"), future.get()); - } - - @Test - public void givenGetResourceWithFuture_WhenWaitAndMatchWithPredicate_ShouldReturnSuccess() { - String url = "http://resource"; - Future future = Future.of(() -> getResource(url)); - future.await(); - String s = Match(future).of( - Case($(future0 -> future0.isSuccess()), SUCCESS), - Case($(), FAILURE)); - - assertEquals(SUCCESS, s); - } - - @Test - public void givenAFailedFuture_WhenWaitAndMatchWithPredicateCheckSuccess_ShouldReturnFailed() { - Future future = Future.failed(new RuntimeException()); - future.await(); - String s = Match(future).of( - Case($(future0 -> future0.isSuccess()), SUCCESS), - Case($(), FAILURE)); - - assertEquals(FAILURE, s); - } - - @Test - public void givenAFuture_WhenMatchWithFuturePredicate_ShouldReturnSuccess() { - Future future = Future.of(() -> { - Thread.sleep(10); - return 1; - }); - Predicate> predicate = f -> f.exists(i -> i % 2 == 1); - - String s = Match(future).of( - Case($(predicate), "Even"), - Case($(), "Odd")); - - assertEquals("Even", s); - } - - @Test - public void givenAListOfFutureReturnFist3Integers_WhenMatchWithExistEvenNumberPredicate_ShouldReturnSuccess() { - List> futures = getFutureOfFirst3Number(); - Predicate> predicate0 = future -> future.exists(i -> i % 2 == 0); - String s = Match(futures).of( - Case($(exists(predicate0)), "Even"), - Case($(), "Odd")); - - assertEquals("Even", s); - } - - @Test - public void givenAListOfFutureReturnFist3Integers_WhenMatchWithForAllNumberBiggerThanZeroPredicate_ShouldReturnSuccess() { - List> futures = getFutureOfFirst3Number(); - Predicate> predicate0 = future -> future.exists(i -> i > 0); - String s = Match(futures).of( - Case($(forAll(predicate0)), "Positive numbers"), - Case($(), "None")); - - assertEquals("Positive numbers", s); - } - - @Test - public void givenAListOfFutureReturnFist3Integers_WhenMatchWithForAllNumberSmallerThanZeroPredicate_ShouldReturnFailed() { - List> futures = getFutureOfFirst3Number(); - Predicate> predicate0 = future -> future.exists(i -> i < 0); - String s = Match(futures).of( - Case($(forAll(predicate0)), "Negative numbers"), - Case($(), "None")); - - assertEquals("None", s); - } - - private String getResource(String url) { - try { - Thread.sleep(10); - } catch (InterruptedException e) { - throw new RuntimeException(e); - } - return "Content from " + url; - } - - private String getResourceThrowException(String url) { - throw new RuntimeException("Exception when get resource " + url); - } - - private List> getFutureOfFirst3Number() { - List> futures = List.of(Future.of(() -> 1), Future.of(() -> 2), Future.of(() -> 3)); - return futures; - } - - private static void checkOnSuccessFunction() { - Future future = Future.of(() -> 1); - future.onSuccess(i -> System.out.println("Future finish with result: " + i)); - } - - private static void checkOnFailureFunction() { - Future future = Future.of(() -> {throw new RuntimeException("Failed");}); - future.onFailure(t -> System.out.println("Future failures with exception: " + t)); - } - - private static void runAndThenConsumer() { - Future future = Future.of(() -> 1); - future.andThen(i -> System.out.println("Do side-effect action 1 with input: " + i.get())). - andThen((i) -> System.out.println("Do side-effect action 2 with input: " + i.get())); - } - - public static void main(String[] args) throws InterruptedException { - checkOnSuccessFunction(); - checkOnFailureFunction(); - runAndThenConsumer(); - Thread.sleep(1000); - } -} - - -class MockConsumer implements Consumer { - @Override - public void accept(Integer t) { - } -} - -class MockTryConsumer implements Consumer> { - @Override - public void accept(Try t) { - } -} - -class MockThrowableConsumer implements Consumer { - @Override - public void accept(Throwable t) { - } -} diff --git a/xml/src/test/resources/example_dom4j_new.xml b/xml/src/test/resources/example_dom4j_new.xml new file mode 100644 index 0000000000..020760fdd3 --- /dev/null +++ b/xml/src/test/resources/example_dom4j_new.xml @@ -0,0 +1,10 @@ + + + + + XML with Dom4J + XML handling with Dom4J + 14/06/2016 + Dom4J tech writer + + diff --git a/xml/src/test/resources/example_jaxb_new.xml b/xml/src/test/resources/example_jaxb_new.xml new file mode 100644 index 0000000000..646d938869 --- /dev/null +++ b/xml/src/test/resources/example_jaxb_new.xml @@ -0,0 +1,9 @@ + + + + Jaxb author + 04/02/2015 + XML Binding with Jaxb + XML with Jaxb + +