diff --git a/parameter-object/README.md b/parameter-object/README.md new file mode 100644 index 000000000..9783879f1 --- /dev/null +++ b/parameter-object/README.md @@ -0,0 +1,138 @@ +--- +layout: pattern +title: Parameter Object +folder: parameter-object +permalink: /patterns/parameter-object/ +categories: Behavioral +tags: + - Extensibility +--- + +## Intent + +The syntax of Java language doesn’t allow you to declare a method with a predefined value +for a parameter. Probably the best option to achieve default method parameters in Java is +by using the method overloading. Method overloading allows you to declare several methods +with the same name but with a different number of parameters. But the main problem with +method overloading as a solution for default parameter values reveals itself when a method +accepts multiple parameters. Creating an overloaded method for each possible combination of +parameters might be cumbersome. To deal with this issue, the Parameter Object pattern is used. + +## Explanation + +The Parameter Object is simply a wrapper object for all parameters of a method. +It is nothing more than just a regular POJO. The advantage of the Parameter Object over a +regular method parameter list is the fact that class fields can have default values. +Once the wrapper class is created for the method parameter list, a corresponding builder class +is also created. Usually it's an inner static class. The final step is to use the builder +to construct a new parameter object. For those parameters that are skipped, +their default values are going to be used. + + +**Programmatic Example** + +Here's the simple `SearchService` class where Method Overloading is used to default values here. To use method overloading, either the number of arguments or argument type has to be different. + +```java +public class SearchService { + //Method Overloading example. SortOrder is defaulted in this method + public String search(String type, String sortBy) { + return getQuerySummary(type, sortBy, SortOrder.DESC); + } + + /* Method Overloading example. SortBy is defaulted in this method. Note that the type has to be + different here to overload the method */ + public String search(String type, SortOrder sortOrder) { + return getQuerySummary(type, "price", sortOrder); + } + + private String getQuerySummary(String type, String sortBy, SortOrder sortOrder) { + return "Requesting shoes of type \"" + type + "\" sorted by \"" + sortBy + "\" in \"" + + sortOrder.getValue() + "ending\" order..."; + } +} + +``` + +Next we present the `SearchService` with `ParameterObject` created with Builder pattern. + +```java +public class SearchService { + + /* Parameter Object example. Default values are abstracted into the Parameter Object + at the time of Object creation */ + public String search(ParameterObject parameterObject) { + return getQuerySummary(parameterObject.getType(), parameterObject.getSortBy(), + parameterObject.getSortOrder()); + } + + private String getQuerySummary(String type, String sortBy, SortOrder sortOrder) { + return "Requesting shoes of type \"" + type + "\" sorted by \"" + sortBy + "\" in \"" + + sortOrder.getValue() + "ending\" order..."; + } +} + +public class ParameterObject { + public static final String DEFAULT_SORT_BY = "price"; + public static final SortOrder DEFAULT_SORT_ORDER = SortOrder.ASC; + + private String type; + private String sortBy = DEFAULT_SORT_BY; + private SortOrder sortOrder = DEFAULT_SORT_ORDER; + + private ParameterObject(Builder builder) { + type = builder.type; + sortBy = builder.sortBy != null && !builder.sortBy.isBlank() ? builder.sortBy : sortBy; + sortOrder = builder.sortOrder != null ? builder.sortOrder : sortOrder; + } + + public static Builder newBuilder() { + return new Builder(); + } + + //Getters and Setters... + + public static final class Builder { + + private String type; + private String sortBy; + private SortOrder sortOrder; + + private Builder() { + } + + public Builder withType(String type) { + this.type = type; + return this; + } + + public Builder sortBy(String sortBy) { + this.sortBy = sortBy; + return this; + } + + public Builder sortOrder(SortOrder sortOrder) { + this.sortOrder = sortOrder; + return this; + } + + public ParameterObject build() { + return new ParameterObject(this); + } + } +} + + +``` + +## Class diagram + +![alt text](./etc/parameter-object.png "Parameter Object") + +## Applicability + +This pattern shows us the way to have default parameters for a method in Java as the language doesn't default parameters feature out of the box. + +## Credits + +- [Does Java have default parameters?](http://dolszewski.com/java/java-default-parameters) diff --git a/parameter-object/etc/parameter-object.png b/parameter-object/etc/parameter-object.png new file mode 100644 index 000000000..661c3488a Binary files /dev/null and b/parameter-object/etc/parameter-object.png differ diff --git a/parameter-object/etc/parameter-object.urm.puml b/parameter-object/etc/parameter-object.urm.puml new file mode 100644 index 000000000..6cdab2141 --- /dev/null +++ b/parameter-object/etc/parameter-object.urm.puml @@ -0,0 +1,52 @@ +@startuml +package com.iluwatar.parameter.object { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class ParameterObject { + + DEFAULT_SORT_BY : String {static} + + DEFAULT_SORT_ORDER : SortOrder {static} + - sortBy : String + - sortOrder : SortOrder + - type : String + - ParameterObject(builder : Builder) + + getSortBy() : String + + getSortOrder() : SortOrder + + getType() : String + + newBuilder() : Builder {static} + + setSortBy(sortBy : String) + + setSortOrder(sortOrder : SortOrder) + + setType(type : String) + } + class Builder { + - sortBy : String + - sortOrder : SortOrder + - type : String + - Builder() + + build() : ParameterObject + + sortBy(sortBy : String) : Builder + + sortOrder(sortOrder : SortOrder) : Builder + + withType(type : String) : Builder + } + class SearchService { + + SearchService() + - getQuerySummary(type : String, sortBy : String, sortOrder : SortOrder) : String + + search(parameterObject : ParameterObject) : String + + search(type : String, sortBy : String) : String + + search(type : String, sortOrder : SortOrder) : String + } + enum SortOrder { + + ASC {static} + + DESC {static} + - value : String + + getValue() : String + + valueOf(name : String) : SortOrder {static} + + values() : SortOrder[] {static} + } +} +Builder --> "-sortOrder" SortOrder +Builder ..+ ParameterObject +ParameterObject --> "-DEFAULT_SORT_ORDER" SortOrder +@enduml diff --git a/parameter-object/pom.xml b/parameter-object/pom.xml new file mode 100644 index 000000000..be64d62df --- /dev/null +++ b/parameter-object/pom.xml @@ -0,0 +1,61 @@ + + + + 4.0.0 + + com.iluwatar + java-design-patterns + 1.24.0-SNAPSHOT + + parameter-object + + + org.junit.jupiter + junit-jupiter-engine + test + + + + + + org.apache.maven.plugins + maven-assembly-plugin + + + + + + com.iluwatar.parameter.object.App + + + + + + + + + diff --git a/parameter-object/src/main/java/com/iluwatar/parameter/object/App.java b/parameter-object/src/main/java/com/iluwatar/parameter/object/App.java new file mode 100644 index 000000000..7d4f600e2 --- /dev/null +++ b/parameter-object/src/main/java/com/iluwatar/parameter/object/App.java @@ -0,0 +1,62 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.parameter.object; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * The syntax of Java language doesn’t allow you to declare a method with a predefined value + * for a parameter. Probably the best option to achieve default method parameters in Java is + * by using the method overloading. Method overloading allows you to declare several methods + * with the same name but with a different number of parameters. But the main problem with + * method overloading as a solution for default parameter values reveals itself when a method + * accepts multiple parameters. Creating an overloaded method for each possible combination of + * parameters might be cumbersome. To deal with this issue, the Parameter Object pattern is used. + * The Parameter Object is simply a wrapper object for all parameters of a method. + * It is nothing more than just a regular POJO. The advantage of the Parameter Object over a + * regular method parameter list is the fact that class fields can have default values. + * Once the wrapper class is created for the method parameter list, a corresponding builder class + * is also created. Usually it's an inner static class. The final step is to use the builder + * to construct a new parameter object. For those parameters that are skipped, + * their default values are going to be used. + */ +public class App { + + private static final Logger LOGGER = LoggerFactory.getLogger(App.class); + + /** + * Program entry point. + * + * @param args command line args + */ + public static void main(String[] args) { + ParameterObject params = ParameterObject.newBuilder() + .withType("sneakers") + .sortBy("brand") + .build(); + LOGGER.info(params.toString()); + LOGGER.info(new SearchService().search(params)); + } +} diff --git a/parameter-object/src/main/java/com/iluwatar/parameter/object/ParameterObject.java b/parameter-object/src/main/java/com/iluwatar/parameter/object/ParameterObject.java new file mode 100644 index 000000000..65f636191 --- /dev/null +++ b/parameter-object/src/main/java/com/iluwatar/parameter/object/ParameterObject.java @@ -0,0 +1,113 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.parameter.object; + +public class ParameterObject { + + /** + * Default values are defined here. + */ + public static final String DEFAULT_SORT_BY = "price"; + public static final SortOrder DEFAULT_SORT_ORDER = SortOrder.ASC; + + private String type; + + /** + * Default values are assigned here. + */ + private String sortBy = DEFAULT_SORT_BY; + private SortOrder sortOrder = DEFAULT_SORT_ORDER; + + /** + * Overriding default values on object creation only when builder object has a valid value. + */ + private ParameterObject(Builder builder) { + setType(builder.type); + setSortBy(builder.sortBy != null && !builder.sortBy.isBlank() ? builder.sortBy : sortBy); + setSortOrder(builder.sortOrder != null ? builder.sortOrder : sortOrder); + } + + public static Builder newBuilder() { + return new Builder(); + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public String getSortBy() { + return sortBy; + } + + public void setSortBy(String sortBy) { + this.sortBy = sortBy; + } + + public SortOrder getSortOrder() { + return sortOrder; + } + + public void setSortOrder(SortOrder sortOrder) { + this.sortOrder = sortOrder; + } + + @Override + public String toString() { + return String.format("ParameterObject[type='%s', sortBy='%s', sortOrder='%s']", + type, sortBy, sortOrder); + } + + public static final class Builder { + + private String type; + private String sortBy; + private SortOrder sortOrder; + + private Builder() { + } + + public Builder withType(String type) { + this.type = type; + return this; + } + + public Builder sortBy(String sortBy) { + this.sortBy = sortBy; + return this; + } + + public Builder sortOrder(SortOrder sortOrder) { + this.sortOrder = sortOrder; + return this; + } + + public ParameterObject build() { + return new ParameterObject(this); + } + } +} diff --git a/parameter-object/src/main/java/com/iluwatar/parameter/object/SearchService.java b/parameter-object/src/main/java/com/iluwatar/parameter/object/SearchService.java new file mode 100644 index 000000000..62acc840d --- /dev/null +++ b/parameter-object/src/main/java/com/iluwatar/parameter/object/SearchService.java @@ -0,0 +1,60 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.parameter.object; + +public class SearchService { + + /** + * Below two methods of name `search` is overloaded so that we can send a default value for + * one of the criteria and call the final api. A default SortOrder is sent in the first method + * and a default SortBy is sent in the second method. So two separate method definitions are + * needed for having default values for one argument in each case. Hence multiple overloaded + * methods are needed as the number of argument increases. + */ + public String search(String type, String sortBy) { + return getQuerySummary(type, sortBy, SortOrder.ASC); + } + + public String search(String type, SortOrder sortOrder) { + return getQuerySummary(type, "price", sortOrder); + } + + + /** + * The need for multiple method definitions can be avoided by the Parameter Object pattern. + * Below is the example where only one method is required and all the logic for having default + * values are abstracted into the Parameter Object at the time of object creation. + */ + public String search(ParameterObject parameterObject) { + return getQuerySummary(parameterObject.getType(), parameterObject.getSortBy(), + parameterObject.getSortOrder()); + } + + private String getQuerySummary(String type, String sortBy, SortOrder sortOrder) { + return String.format("Requesting shoes of type \"%s\" sorted by \"%s\" in \"%sending\" order..", + type, + sortBy, + sortOrder.getValue()); + } +} diff --git a/parameter-object/src/main/java/com/iluwatar/parameter/object/SortOrder.java b/parameter-object/src/main/java/com/iluwatar/parameter/object/SortOrder.java new file mode 100644 index 000000000..6420ca9e1 --- /dev/null +++ b/parameter-object/src/main/java/com/iluwatar/parameter/object/SortOrder.java @@ -0,0 +1,39 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.parameter.object; + +public enum SortOrder { + ASC("asc"), + DESC("desc"); + + private String value; + + SortOrder(String value) { + this.value = value; + } + + public String getValue() { + return value; + } +} diff --git a/parameter-object/src/test/java/com/iluwatar/parameter/object/AppTest.java b/parameter-object/src/test/java/com/iluwatar/parameter/object/AppTest.java new file mode 100644 index 000000000..809e41f36 --- /dev/null +++ b/parameter-object/src/test/java/com/iluwatar/parameter/object/AppTest.java @@ -0,0 +1,41 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.parameter.object; + +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Application test + */ +class AppTest { + private static final Logger LOGGER = LoggerFactory.getLogger(AppTest.class); + + @Test + void shouldExecuteApplicationWithoutException() { + App.main(new String[]{}); + LOGGER.info("Executed successfully without exception."); + } +} diff --git a/parameter-object/src/test/java/com/iluwatar/parameter/object/ParameterObjectTest.java b/parameter-object/src/test/java/com/iluwatar/parameter/object/ParameterObjectTest.java new file mode 100644 index 000000000..05907b9c6 --- /dev/null +++ b/parameter-object/src/test/java/com/iluwatar/parameter/object/ParameterObjectTest.java @@ -0,0 +1,63 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.parameter.object; + +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class ParameterObjectTest { + + private static final Logger LOGGER = LoggerFactory.getLogger(ParameterObjectTest.class); + + @Test + public void testForDefaultSortBy() { + //Creating parameter object with default value for SortBy set + ParameterObject params = ParameterObject.newBuilder() + .withType("sneakers") + .sortOrder(SortOrder.DESC) + .build(); + + assertEquals(ParameterObject.DEFAULT_SORT_BY, params.getSortBy(), + "Default SortBy is not set."); + LOGGER.info("{} Default parameter value is set during object creation as no value is passed." + , "SortBy"); + } + + @Test + public void testForDefaultSortOrder() { + //Creating parameter object with default value for SortOrder set + ParameterObject params = ParameterObject.newBuilder() + .withType("sneakers") + .sortBy("brand") + .build(); + + assertEquals(ParameterObject.DEFAULT_SORT_ORDER, params.getSortOrder(), + "Default SortOrder is not set."); + LOGGER.info("{} Default parameter value is set during object creation as no value is passed." + , "SortOrder"); + } +} diff --git a/parameter-object/src/test/java/com/iluwatar/parameter/object/SearchServiceTest.java b/parameter-object/src/test/java/com/iluwatar/parameter/object/SearchServiceTest.java new file mode 100644 index 000000000..d7633f0e3 --- /dev/null +++ b/parameter-object/src/test/java/com/iluwatar/parameter/object/SearchServiceTest.java @@ -0,0 +1,63 @@ +/* + * The MIT License + * Copyright © 2014-2019 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.parameter.object; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class SearchServiceTest { + private static final Logger LOGGER = LoggerFactory.getLogger(SearchServiceTest.class); + private ParameterObject parameterObject; + private SearchService searchService; + + @BeforeEach + public void setUp() { + //Creating parameter object with default values set + parameterObject = ParameterObject.newBuilder() + .withType("sneakers") + .build(); + + searchService = new SearchService(); + } + + /** + * Testing parameter object against the overloaded method to verify if the behaviour is same. + */ + @Test + public void testDefaultParametersMatch() { + assertEquals(searchService.search(parameterObject), searchService.search("sneakers", + SortOrder.ASC), "Default Parameter values do not not match."); + LOGGER.info("SortBy Default parameter value matches."); + + assertEquals(searchService.search(parameterObject), searchService.search("sneakers", + "price"), "Default Parameter values do not not match."); + LOGGER.info("SortOrder Default parameter value matches."); + + LOGGER.info("testDefaultParametersMatch executed successfully without errors."); + } +} diff --git a/pom.xml b/pom.xml index c7d61a12b..48fa6fdcf 100644 --- a/pom.xml +++ b/pom.xml @@ -208,6 +208,7 @@ factory separated-interface special-case + parameter-object