From ce6df283f94e788382e51a6ac74a71410eb756ad Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Mon, 19 Feb 2024 17:15:04 -0300 Subject: [PATCH 1/8] Adding analyzer for log-levels concept exercise --- src/main/java/analyzer/AnalyzerRoot.java | 2 + .../loglevels/AvoidUsingStringFormat.java | 19 +++++ .../loglevels/DoNotHardcodeLogLevels.java | 19 +++++ .../loglevels/LogLevelsAnalyzer.java | 81 +++++++++++++++++++ .../exercises/loglevels/ReuseCode.java | 36 +++++++++ .../loglevels/UseSubstringMethod.java | 37 +++++++++ .../analyzer/AnalyzerIntegrationTest.java | 23 +++++- ...st.loglevels.ExemplarSolution.approved.txt | 11 +++ ...loglevels.HardCodingLogLevels.approved.txt | 22 +++++ ...est.loglevels.NoReuseLogLevel.approved.txt | 17 ++++ ...Test.loglevels.NoReuseMessage.approved.txt | 17 ++++ ...oglevels.NoReuseOfBothMethods.approved.txt | 25 ++++++ ...s.NotUsingSubstringOnLogLevel.approved.txt | 17 ++++ ...ls.NotUsingSubstringOnMessage.approved.txt | 17 ++++ ...t.loglevels.UsingStringFormat.approved.txt | 14 ++++ .../log-levels/ExemplarSolution.java | 15 ++++ .../log-levels/HardCodingLogLevels.java | 23 ++++++ .../scenarios/log-levels/NoReuseLogLevel.java | 15 ++++ .../scenarios/log-levels/NoReuseMessage.java | 15 ++++ .../log-levels/NoReuseOfBothMethods.java | 15 ++++ .../NotUsingSubstringOnLogLevel.java | 15 ++++ .../NotUsingSubstringOnMessage.java | 16 ++++ .../log-levels/UsingStringFormat.java | 15 ++++ .../examplar-solution/.meta/config.json | 23 ++++++ .../examplar-solution/expected_analysis.json | 11 +++ .../examplar-solution/expected_tags.json | 3 + .../src/main/java/LogLevels.java | 13 +++ .../hardcode-log-levels/.meta/config.json | 23 ++++++ .../expected_analysis.json | 22 +++++ .../hardcode-log-levels/expected_tags.json | 3 + .../src/main/java/LogLevels.java | 21 +++++ .../no-reuse-code/.meta/config.json | 23 ++++++ .../no-reuse-code/expected_analysis.json | 17 ++++ .../no-reuse-code/expected_tags.json | 3 + .../src/main/java/LogLevels.java | 13 +++ .../no-substring-used/.meta/config.json | 23 ++++++ .../no-substring-used/expected_analysis.json | 17 ++++ .../no-substring-used/expected_tags.json | 3 + .../src/main/java/LogLevels.java | 14 ++++ .../using-string-format/.meta/config.json | 23 ++++++ .../expected_analysis.json | 14 ++++ .../using-string-format/expected_tags.json | 3 + .../src/main/java/LogLevels.java | 13 +++ 43 files changed, 769 insertions(+), 2 deletions(-) create mode 100644 src/main/java/analyzer/exercises/loglevels/AvoidUsingStringFormat.java create mode 100644 src/main/java/analyzer/exercises/loglevels/DoNotHardcodeLogLevels.java create mode 100644 src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java create mode 100644 src/main/java/analyzer/exercises/loglevels/ReuseCode.java create mode 100644 src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.ExemplarSolution.approved.txt create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt create mode 100644 src/test/resources/scenarios/log-levels/ExemplarSolution.java create mode 100644 src/test/resources/scenarios/log-levels/HardCodingLogLevels.java create mode 100644 src/test/resources/scenarios/log-levels/NoReuseLogLevel.java create mode 100644 src/test/resources/scenarios/log-levels/NoReuseMessage.java create mode 100644 src/test/resources/scenarios/log-levels/NoReuseOfBothMethods.java create mode 100644 src/test/resources/scenarios/log-levels/NotUsingSubstringOnLogLevel.java create mode 100644 src/test/resources/scenarios/log-levels/NotUsingSubstringOnMessage.java create mode 100644 src/test/resources/scenarios/log-levels/UsingStringFormat.java create mode 100644 tests/log-levels/examplar-solution/.meta/config.json create mode 100644 tests/log-levels/examplar-solution/expected_analysis.json create mode 100644 tests/log-levels/examplar-solution/expected_tags.json create mode 100644 tests/log-levels/examplar-solution/src/main/java/LogLevels.java create mode 100644 tests/log-levels/hardcode-log-levels/.meta/config.json create mode 100644 tests/log-levels/hardcode-log-levels/expected_analysis.json create mode 100644 tests/log-levels/hardcode-log-levels/expected_tags.json create mode 100644 tests/log-levels/hardcode-log-levels/src/main/java/LogLevels.java create mode 100644 tests/log-levels/no-reuse-code/.meta/config.json create mode 100644 tests/log-levels/no-reuse-code/expected_analysis.json create mode 100644 tests/log-levels/no-reuse-code/expected_tags.json create mode 100644 tests/log-levels/no-reuse-code/src/main/java/LogLevels.java create mode 100644 tests/log-levels/no-substring-used/.meta/config.json create mode 100644 tests/log-levels/no-substring-used/expected_analysis.json create mode 100644 tests/log-levels/no-substring-used/expected_tags.json create mode 100644 tests/log-levels/no-substring-used/src/main/java/LogLevels.java create mode 100644 tests/log-levels/using-string-format/.meta/config.json create mode 100644 tests/log-levels/using-string-format/expected_analysis.json create mode 100644 tests/log-levels/using-string-format/expected_tags.json create mode 100644 tests/log-levels/using-string-format/src/main/java/LogLevels.java diff --git a/src/main/java/analyzer/AnalyzerRoot.java b/src/main/java/analyzer/AnalyzerRoot.java index 42937686..ecb0815e 100644 --- a/src/main/java/analyzer/AnalyzerRoot.java +++ b/src/main/java/analyzer/AnalyzerRoot.java @@ -6,6 +6,7 @@ import analyzer.exercises.hamming.HammingAnalyzer; import analyzer.exercises.lasagna.LasagnaAnalyzer; import analyzer.exercises.leap.LeapAnalyzer; +import analyzer.exercises.loglevels.LogLevelsAnalyzer; import analyzer.exercises.needforspeed.NeedForSpeedAnalyzer; import analyzer.exercises.twofer.TwoferAnalyzer; @@ -51,6 +52,7 @@ private static List createAnalyzers(String slug) { case "hamming" -> analyzers.add(new HammingAnalyzer()); case "lasagna" -> analyzers.add(new LasagnaAnalyzer()); case "leap" -> analyzers.add(new LeapAnalyzer()); + case "log-levels" -> analyzers.add(new LogLevelsAnalyzer()); case "need-for-speed" -> analyzers.add(new NeedForSpeedAnalyzer()); case "two-fer" -> analyzers.add(new TwoferAnalyzer()); } diff --git a/src/main/java/analyzer/exercises/loglevels/AvoidUsingStringFormat.java b/src/main/java/analyzer/exercises/loglevels/AvoidUsingStringFormat.java new file mode 100644 index 00000000..e346b1b9 --- /dev/null +++ b/src/main/java/analyzer/exercises/loglevels/AvoidUsingStringFormat.java @@ -0,0 +1,19 @@ +package analyzer.exercises.loglevels; + +import analyzer.Comment; + +/** + * @see Markdown Template + */ +class AvoidUsingStringFormat extends Comment { + + @Override + public String getKey() { + return "java.log-levels.avoid_using_string_format"; + } + + @Override + public Type getType() { + return Type.INFORMATIVE; + } +} diff --git a/src/main/java/analyzer/exercises/loglevels/DoNotHardcodeLogLevels.java b/src/main/java/analyzer/exercises/loglevels/DoNotHardcodeLogLevels.java new file mode 100644 index 00000000..2454f7e5 --- /dev/null +++ b/src/main/java/analyzer/exercises/loglevels/DoNotHardcodeLogLevels.java @@ -0,0 +1,19 @@ +package analyzer.exercises.loglevels; + +import analyzer.Comment; + +/** + * @see Markdown Template + */ +class DoNotHardcodeLogLevels extends Comment{ + + @Override + public String getKey() { + return "java.log-levels.do_not_hardcode_log_levels"; + } + + @Override + public Type getType() { + return Type.ESSENTIAL; + } +} diff --git a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java new file mode 100644 index 00000000..cbd89c04 --- /dev/null +++ b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java @@ -0,0 +1,81 @@ +package analyzer.exercises.loglevels; + +import com.github.javaparser.ast.CompilationUnit; +import com.github.javaparser.ast.body.MethodDeclaration; +import com.github.javaparser.ast.expr.MethodCallExpr; +import com.github.javaparser.ast.expr.StringLiteralExpr; +import com.github.javaparser.ast.visitor.VoidVisitorAdapter; + +import analyzer.Analyzer; +import analyzer.OutputCollector; +import analyzer.Solution; +import analyzer.comments.ExemplarSolution; + +import java.util.List; + +/** + * The {@link LogLevelsAnalyzer} is the analyzer implementation for the {@code log-levels} practice exercise. + * It extends from the {@link VoidVisitorAdapter} and uses the visitor pattern to traverse each compilation unit. + * + * @see The log-levels exercise on the Java track + */ +public class LogLevelsAnalyzer extends VoidVisitorAdapter implements Analyzer { + private static final String EXERCISE_NAME = "Log Levels"; + private static final String REFORMAT = "reformat"; + private static final String MESSAGE = "message"; + private static final String LOG_LEVEL = "logLevel"; + private static final String SUBSTRING = "substring"; + private static final String FORMAT = "format"; + + @Override + public void analyze(Solution solution, OutputCollector output) { + for (CompilationUnit compilationUnit : solution.getCompilationUnits()) { + compilationUnit.accept(this, output); + } + + if (output.getComments().isEmpty()) { + output.addComment(new ExemplarSolution(EXERCISE_NAME)); + } + } + + @Override + public void visit(MethodDeclaration node, OutputCollector output) { + if (containsHarcodedString(node)) { + output.addComment(new DoNotHardcodeLogLevels()); + } + + if (node.getNameAsString().equals(REFORMAT) && doesNotCallMethod(node, MESSAGE)) { + output.addComment(new ReuseCode(REFORMAT, MESSAGE)); + } + + if (node.getNameAsString().equals(REFORMAT) && doesNotCallMethod(node, LOG_LEVEL)) { + output.addComment(new ReuseCode(REFORMAT, LOG_LEVEL)); + } + + if (node.getNameAsString().equals(MESSAGE) && doesNotCallMethod(node, SUBSTRING)) { + output.addComment(new UseSubstringMethod(MESSAGE, SUBSTRING)); + } + + if (node.getNameAsString().equals(LOG_LEVEL) && doesNotCallMethod(node, SUBSTRING)) { + output.addComment(new UseSubstringMethod(LOG_LEVEL, SUBSTRING)); + } + + if (node.getNameAsString().equals(REFORMAT) && !doesNotCallMethod(node, FORMAT)) { + output.addComment(new AvoidUsingStringFormat()); + } + + super.visit(node, output); + } + + private static boolean containsHarcodedString(MethodDeclaration node) { + List hardcodedStrings = node.findAll(StringLiteralExpr.class, + x -> x.getValue().equals("[ERROR]:") || x.getValue().equals("[WARNING]:") + || x.getValue().equals("[INFO]:")); + + return hardcodedStrings.size() > 1; + } + + private static boolean doesNotCallMethod(MethodDeclaration node, String otherMethodName) { + return node.findAll(MethodCallExpr.class, x -> x.getNameAsString().contains(otherMethodName)).isEmpty(); + } +} diff --git a/src/main/java/analyzer/exercises/loglevels/ReuseCode.java b/src/main/java/analyzer/exercises/loglevels/ReuseCode.java new file mode 100644 index 00000000..40961021 --- /dev/null +++ b/src/main/java/analyzer/exercises/loglevels/ReuseCode.java @@ -0,0 +1,36 @@ +package analyzer.exercises.loglevels; + +import analyzer.Comment; + +import java.util.Map; + +/** + * @see Markdown Template + */ +class ReuseCode extends Comment { + private final String callingMethod; + private final String methodToCall; + + ReuseCode(String callingMethod, String methodToCall) { + this.callingMethod = callingMethod; + this.methodToCall = methodToCall; + } + + @Override + public String getKey() { + return "java.log-levels.reuse_code"; + } + + @Override + public Map getParameters() { + return Map.of( + "callingMethod", this.callingMethod, + "methodToCall", this.methodToCall + ); + } + + @Override + public Type getType() { + return Type.ACTIONABLE; + } +} diff --git a/src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java b/src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java new file mode 100644 index 00000000..9abad723 --- /dev/null +++ b/src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java @@ -0,0 +1,37 @@ +package analyzer.exercises.loglevels; + +import analyzer.Comment; + +import java.util.Map; + +/** + * @see Markdown Template + */ +class UseSubstringMethod extends Comment { + private final String callingMethod; + private final String methodToCall; + + + UseSubstringMethod(String callingMethod, String methodToCall) { + this.callingMethod = callingMethod; + this.methodToCall = methodToCall; + } + + @Override + public String getKey() { + return "java.log-levels.use_substring_method"; + } + + @Override + public Map getParameters() { + return Map.of( + "callingMethod", this.callingMethod, + "methodToCall", this.methodToCall + ); + } + + @Override + public Type getType() { + return Type.ACTIONABLE; + } +} diff --git a/src/test/java/analyzer/AnalyzerIntegrationTest.java b/src/test/java/analyzer/AnalyzerIntegrationTest.java index 17af176d..3c65cd31 100644 --- a/src/test/java/analyzer/AnalyzerIntegrationTest.java +++ b/src/test/java/analyzer/AnalyzerIntegrationTest.java @@ -113,7 +113,7 @@ public void annalynsinfiltration(String scenario) throws IOException { Approvals.verify(serialize(output.analysis()), Approvals.NAMES.withParameters(scenario)); } - + @ParameterizedTest @ValueSource(strings = { "ExemplarSolution", @@ -126,7 +126,26 @@ void needforspeed(String scenario) throws IOException { var path = Path.of("need-for-speed", scenario + ".java"); var solution = new SolutionFromFiles("need-for-speed", SCENARIOS.resolve(path)); var output = AnalyzerRoot.analyze(solution); - + + Approvals.verify(serialize(output.analysis()), Approvals.NAMES.withParameters(scenario)); + } + + @ParameterizedTest + @ValueSource(strings = { + "ExemplarSolution", + "HardCodingLogLevels", + "NoReuseLogLevel", + "NoReuseMessage", + "NoReuseOfBothMethods", + "NotUsingSubstringOnLogLevel", + "NotUsingSubstringOnMessage", + "UsingStringFormat" + }) + void loglevels(String scenario) throws IOException { + var path = Path.of("log-levels", scenario + ".java"); + var solution = new SolutionFromFiles("log-levels", SCENARIOS.resolve(path)); + var output = AnalyzerRoot.analyze(solution); + Approvals.verify(serialize(output.analysis()), Approvals.NAMES.withParameters(scenario)); } } diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.ExemplarSolution.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.ExemplarSolution.approved.txt new file mode 100644 index 00000000..e8df7b83 --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.ExemplarSolution.approved.txt @@ -0,0 +1,11 @@ +{ + "comments": [ + { + "comment": "java.general.exemplar", + "params": { + "exerciseName": "Log Levels" + }, + "type": "celebratory" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt new file mode 100644 index 00000000..c89f0beb --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt @@ -0,0 +1,22 @@ +{ + "comments": [ + { + "comment": "java.log-levels.do_not_hardcode_log_levels", + "params": {}, + "type": "essential" + }, + { + "comment": "java.log-levels.use_substring_method", + "params": { + "callingMethod": "message", + "methodToCall": "substring" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt new file mode 100644 index 00000000..a06e48f5 --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt @@ -0,0 +1,17 @@ +{ + "comments": [ + { + "comment": "java.log-levels.reuse_code", + "params": { + "callingMethod": "reformat", + "methodToCall": "logLevel" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt new file mode 100644 index 00000000..828b0c45 --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt @@ -0,0 +1,17 @@ +{ + "comments": [ + { + "comment": "java.log-levels.reuse_code", + "params": { + "callingMethod": "reformat", + "methodToCall": "message" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt new file mode 100644 index 00000000..f0c86366 --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt @@ -0,0 +1,25 @@ +{ + "comments": [ + { + "comment": "java.log-levels.reuse_code", + "params": { + "callingMethod": "reformat", + "methodToCall": "message" + }, + "type": "actionable" + }, + { + "comment": "java.log-levels.reuse_code", + "params": { + "callingMethod": "reformat", + "methodToCall": "logLevel" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt new file mode 100644 index 00000000..d266bd5d --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt @@ -0,0 +1,17 @@ +{ + "comments": [ + { + "comment": "java.log-levels.use_substring_method", + "params": { + "callingMethod": "logLevel", + "methodToCall": "substring" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt new file mode 100644 index 00000000..ff235c4f --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt @@ -0,0 +1,17 @@ +{ + "comments": [ + { + "comment": "java.log-levels.use_substring_method", + "params": { + "callingMethod": "message", + "methodToCall": "substring" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt new file mode 100644 index 00000000..24409217 --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt @@ -0,0 +1,14 @@ +{ + "comments": [ + { + "comment": "java.log-levels.avoid_using_string_format", + "params": {}, + "type": "informative" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/scenarios/log-levels/ExemplarSolution.java b/src/test/resources/scenarios/log-levels/ExemplarSolution.java new file mode 100644 index 00000000..854765fd --- /dev/null +++ b/src/test/resources/scenarios/log-levels/ExemplarSolution.java @@ -0,0 +1,15 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLevel(logLine) + ")"; + } +} diff --git a/src/test/resources/scenarios/log-levels/HardCodingLogLevels.java b/src/test/resources/scenarios/log-levels/HardCodingLogLevels.java new file mode 100644 index 00000000..6ca112ed --- /dev/null +++ b/src/test/resources/scenarios/log-levels/HardCodingLogLevels.java @@ -0,0 +1,23 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + if (logLine.contains("[ERROR]:")) { + return logLine.replace("[ERROR]:", "").trim(); + } else if (logLine.contains("[WARNING]:")) { + return logLine.replace("[WARNING]:", "").trim(); + } else if (logLine.contains("[INFO]:")) { + return logLine.replace("[INFO]:", "").trim(); + } else { + return ""; + } + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLevel(logLine) + ")"; + } +} diff --git a/src/test/resources/scenarios/log-levels/NoReuseLogLevel.java b/src/test/resources/scenarios/log-levels/NoReuseLogLevel.java new file mode 100644 index 00000000..0c69218a --- /dev/null +++ b/src/test/resources/scenarios/log-levels/NoReuseLogLevel.java @@ -0,0 +1,15 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLine.substring(1, logLine.indexOf("]")).toLowerCase() + ")"; + } +} diff --git a/src/test/resources/scenarios/log-levels/NoReuseMessage.java b/src/test/resources/scenarios/log-levels/NoReuseMessage.java new file mode 100644 index 00000000..48b169e6 --- /dev/null +++ b/src/test/resources/scenarios/log-levels/NoReuseMessage.java @@ -0,0 +1,15 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim() + " (" + logLevel(logLine) + ")"; + } +} diff --git a/src/test/resources/scenarios/log-levels/NoReuseOfBothMethods.java b/src/test/resources/scenarios/log-levels/NoReuseOfBothMethods.java new file mode 100644 index 00000000..85afdaf0 --- /dev/null +++ b/src/test/resources/scenarios/log-levels/NoReuseOfBothMethods.java @@ -0,0 +1,15 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim() + " (" + logLine.substring(1, logLine.indexOf("]")).toLowerCase() + ")"; + } +} diff --git a/src/test/resources/scenarios/log-levels/NotUsingSubstringOnLogLevel.java b/src/test/resources/scenarios/log-levels/NotUsingSubstringOnLogLevel.java new file mode 100644 index 00000000..c66e22dc --- /dev/null +++ b/src/test/resources/scenarios/log-levels/NotUsingSubstringOnLogLevel.java @@ -0,0 +1,15 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.split("]: ")[0].replace("[", "").toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLevel(logLine) + ")"; + } +} diff --git a/src/test/resources/scenarios/log-levels/NotUsingSubstringOnMessage.java b/src/test/resources/scenarios/log-levels/NotUsingSubstringOnMessage.java new file mode 100644 index 00000000..a3c49ed7 --- /dev/null +++ b/src/test/resources/scenarios/log-levels/NotUsingSubstringOnMessage.java @@ -0,0 +1,16 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + return logLine.split("]: ")[1] + .trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLevel(logLine) + ")"; + } +} diff --git a/src/test/resources/scenarios/log-levels/UsingStringFormat.java b/src/test/resources/scenarios/log-levels/UsingStringFormat.java new file mode 100644 index 00000000..5e0b3228 --- /dev/null +++ b/src/test/resources/scenarios/log-levels/UsingStringFormat.java @@ -0,0 +1,15 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return String.format("%s (%s)", message(logLine), logLevel(logLine)); + } +} diff --git a/tests/log-levels/examplar-solution/.meta/config.json b/tests/log-levels/examplar-solution/.meta/config.json new file mode 100644 index 00000000..637efd79 --- /dev/null +++ b/tests/log-levels/examplar-solution/.meta/config.json @@ -0,0 +1,23 @@ +{ + "authors": [ + "mirkoperillo" + ], + "files": { + "solution": [ + "src/main/java/LogLevels.java" + ], + "test": [ + "src/test/java/LogLevelsTest.java" + ], + "exemplar": [ + ".meta/src/reference/java/LogLevels.java" + ], + "invalidator": [ + "build.gradle" + ] + }, + "forked_from": [ + "csharp/log-levels" + ], + "blurb": "Learn about strings by processing logs." +} \ No newline at end of file diff --git a/tests/log-levels/examplar-solution/expected_analysis.json b/tests/log-levels/examplar-solution/expected_analysis.json new file mode 100644 index 00000000..8901e1b8 --- /dev/null +++ b/tests/log-levels/examplar-solution/expected_analysis.json @@ -0,0 +1,11 @@ +{ + "comments": [ + { + "comment": "java.general.exemplar", + "params": { + "exerciseName": "Log Levels" + }, + "type": "celebratory" + } + ] +} \ No newline at end of file diff --git a/tests/log-levels/examplar-solution/expected_tags.json b/tests/log-levels/examplar-solution/expected_tags.json new file mode 100644 index 00000000..eb25b190 --- /dev/null +++ b/tests/log-levels/examplar-solution/expected_tags.json @@ -0,0 +1,3 @@ +{ + "tags": [] +} \ No newline at end of file diff --git a/tests/log-levels/examplar-solution/src/main/java/LogLevels.java b/tests/log-levels/examplar-solution/src/main/java/LogLevels.java new file mode 100644 index 00000000..4f16871b --- /dev/null +++ b/tests/log-levels/examplar-solution/src/main/java/LogLevels.java @@ -0,0 +1,13 @@ +class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLevel(logLine) + ")"; + } +} diff --git a/tests/log-levels/hardcode-log-levels/.meta/config.json b/tests/log-levels/hardcode-log-levels/.meta/config.json new file mode 100644 index 00000000..637efd79 --- /dev/null +++ b/tests/log-levels/hardcode-log-levels/.meta/config.json @@ -0,0 +1,23 @@ +{ + "authors": [ + "mirkoperillo" + ], + "files": { + "solution": [ + "src/main/java/LogLevels.java" + ], + "test": [ + "src/test/java/LogLevelsTest.java" + ], + "exemplar": [ + ".meta/src/reference/java/LogLevels.java" + ], + "invalidator": [ + "build.gradle" + ] + }, + "forked_from": [ + "csharp/log-levels" + ], + "blurb": "Learn about strings by processing logs." +} \ No newline at end of file diff --git a/tests/log-levels/hardcode-log-levels/expected_analysis.json b/tests/log-levels/hardcode-log-levels/expected_analysis.json new file mode 100644 index 00000000..353f8e09 --- /dev/null +++ b/tests/log-levels/hardcode-log-levels/expected_analysis.json @@ -0,0 +1,22 @@ +{ + "comments": [ + { + "comment": "java.log-levels.do_not_hardcode_log_levels", + "params": {}, + "type": "essential" + }, + { + "comment": "java.log-levels.use_substring_method", + "params": { + "callingMethod": "message", + "methodToCall": "substring" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/tests/log-levels/hardcode-log-levels/expected_tags.json b/tests/log-levels/hardcode-log-levels/expected_tags.json new file mode 100644 index 00000000..eb25b190 --- /dev/null +++ b/tests/log-levels/hardcode-log-levels/expected_tags.json @@ -0,0 +1,3 @@ +{ + "tags": [] +} \ No newline at end of file diff --git a/tests/log-levels/hardcode-log-levels/src/main/java/LogLevels.java b/tests/log-levels/hardcode-log-levels/src/main/java/LogLevels.java new file mode 100644 index 00000000..ea1272ef --- /dev/null +++ b/tests/log-levels/hardcode-log-levels/src/main/java/LogLevels.java @@ -0,0 +1,21 @@ +class LogLevels { + public static String message(String logLine) { + if (logLine.contains("[ERROR]:")) { + return logLine.replace("[ERROR]:", "").trim(); + } else if (logLine.contains("[WARNING]:")) { + return logLine.replace("[WARNING]:", "").trim(); + } else if (logLine.contains("[INFO]:")) { + return logLine.replace("[INFO]:", "").trim(); + } else { + return ""; + } + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLevel(logLine) + ")"; + } +} diff --git a/tests/log-levels/no-reuse-code/.meta/config.json b/tests/log-levels/no-reuse-code/.meta/config.json new file mode 100644 index 00000000..637efd79 --- /dev/null +++ b/tests/log-levels/no-reuse-code/.meta/config.json @@ -0,0 +1,23 @@ +{ + "authors": [ + "mirkoperillo" + ], + "files": { + "solution": [ + "src/main/java/LogLevels.java" + ], + "test": [ + "src/test/java/LogLevelsTest.java" + ], + "exemplar": [ + ".meta/src/reference/java/LogLevels.java" + ], + "invalidator": [ + "build.gradle" + ] + }, + "forked_from": [ + "csharp/log-levels" + ], + "blurb": "Learn about strings by processing logs." +} \ No newline at end of file diff --git a/tests/log-levels/no-reuse-code/expected_analysis.json b/tests/log-levels/no-reuse-code/expected_analysis.json new file mode 100644 index 00000000..970dc07a --- /dev/null +++ b/tests/log-levels/no-reuse-code/expected_analysis.json @@ -0,0 +1,17 @@ +{ + "comments": [ + { + "comment": "java.log-levels.reuse_code", + "params": { + "callingMethod": "reformat", + "methodToCall": "logLevel" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/tests/log-levels/no-reuse-code/expected_tags.json b/tests/log-levels/no-reuse-code/expected_tags.json new file mode 100644 index 00000000..eb25b190 --- /dev/null +++ b/tests/log-levels/no-reuse-code/expected_tags.json @@ -0,0 +1,3 @@ +{ + "tags": [] +} \ No newline at end of file diff --git a/tests/log-levels/no-reuse-code/src/main/java/LogLevels.java b/tests/log-levels/no-reuse-code/src/main/java/LogLevels.java new file mode 100644 index 00000000..4703671c --- /dev/null +++ b/tests/log-levels/no-reuse-code/src/main/java/LogLevels.java @@ -0,0 +1,13 @@ +class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLine.substring(1, logLine.indexOf("]")).toLowerCase() + ")"; + } +} diff --git a/tests/log-levels/no-substring-used/.meta/config.json b/tests/log-levels/no-substring-used/.meta/config.json new file mode 100644 index 00000000..637efd79 --- /dev/null +++ b/tests/log-levels/no-substring-used/.meta/config.json @@ -0,0 +1,23 @@ +{ + "authors": [ + "mirkoperillo" + ], + "files": { + "solution": [ + "src/main/java/LogLevels.java" + ], + "test": [ + "src/test/java/LogLevelsTest.java" + ], + "exemplar": [ + ".meta/src/reference/java/LogLevels.java" + ], + "invalidator": [ + "build.gradle" + ] + }, + "forked_from": [ + "csharp/log-levels" + ], + "blurb": "Learn about strings by processing logs." +} \ No newline at end of file diff --git a/tests/log-levels/no-substring-used/expected_analysis.json b/tests/log-levels/no-substring-used/expected_analysis.json new file mode 100644 index 00000000..ff131087 --- /dev/null +++ b/tests/log-levels/no-substring-used/expected_analysis.json @@ -0,0 +1,17 @@ +{ + "comments": [ + { + "comment": "java.log-levels.use_substring_method", + "params": { + "callingMethod": "message", + "methodToCall": "substring" + }, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/tests/log-levels/no-substring-used/expected_tags.json b/tests/log-levels/no-substring-used/expected_tags.json new file mode 100644 index 00000000..eb25b190 --- /dev/null +++ b/tests/log-levels/no-substring-used/expected_tags.json @@ -0,0 +1,3 @@ +{ + "tags": [] +} \ No newline at end of file diff --git a/tests/log-levels/no-substring-used/src/main/java/LogLevels.java b/tests/log-levels/no-substring-used/src/main/java/LogLevels.java new file mode 100644 index 00000000..3ada8452 --- /dev/null +++ b/tests/log-levels/no-substring-used/src/main/java/LogLevels.java @@ -0,0 +1,14 @@ +class LogLevels { + public static String message(String logLine) { + return logLine.split("]: ")[1] + .trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLevel(logLine) + ")"; + } +} diff --git a/tests/log-levels/using-string-format/.meta/config.json b/tests/log-levels/using-string-format/.meta/config.json new file mode 100644 index 00000000..637efd79 --- /dev/null +++ b/tests/log-levels/using-string-format/.meta/config.json @@ -0,0 +1,23 @@ +{ + "authors": [ + "mirkoperillo" + ], + "files": { + "solution": [ + "src/main/java/LogLevels.java" + ], + "test": [ + "src/test/java/LogLevelsTest.java" + ], + "exemplar": [ + ".meta/src/reference/java/LogLevels.java" + ], + "invalidator": [ + "build.gradle" + ] + }, + "forked_from": [ + "csharp/log-levels" + ], + "blurb": "Learn about strings by processing logs." +} \ No newline at end of file diff --git a/tests/log-levels/using-string-format/expected_analysis.json b/tests/log-levels/using-string-format/expected_analysis.json new file mode 100644 index 00000000..39065925 --- /dev/null +++ b/tests/log-levels/using-string-format/expected_analysis.json @@ -0,0 +1,14 @@ +{ + "comments": [ + { + "comment": "java.log-levels.avoid_using_string_format", + "params": {}, + "type": "informative" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/tests/log-levels/using-string-format/expected_tags.json b/tests/log-levels/using-string-format/expected_tags.json new file mode 100644 index 00000000..eb25b190 --- /dev/null +++ b/tests/log-levels/using-string-format/expected_tags.json @@ -0,0 +1,3 @@ +{ + "tags": [] +} \ No newline at end of file diff --git a/tests/log-levels/using-string-format/src/main/java/LogLevels.java b/tests/log-levels/using-string-format/src/main/java/LogLevels.java new file mode 100644 index 00000000..626d614d --- /dev/null +++ b/tests/log-levels/using-string-format/src/main/java/LogLevels.java @@ -0,0 +1,13 @@ +class LogLevels { + public static String message(String logLine) { + return logLine.substring(logLine.indexOf(":") + 1).trim(); + } + + public static String logLevel(String logLine) { + return logLine.substring(1, logLine.indexOf("]")).toLowerCase(); + } + + public static String reformat(String logLine) { + return String.format("%s (%s)", message(logLine), logLevel(logLine)); + } +} From 417ce30241ad2d10c5208f23982bec48ca944ea4 Mon Sep 17 00:00:00 2001 From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com> Date: Wed, 21 Feb 2024 10:25:23 -0300 Subject: [PATCH 2/8] Update src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java Co-authored-by: Sander Ploegsma --- .../java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java index cbd89c04..789467cf 100644 --- a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java +++ b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java @@ -69,8 +69,8 @@ public void visit(MethodDeclaration node, OutputCollector output) { private static boolean containsHarcodedString(MethodDeclaration node) { List hardcodedStrings = node.findAll(StringLiteralExpr.class, - x -> x.getValue().equals("[ERROR]:") || x.getValue().equals("[WARNING]:") - || x.getValue().equals("[INFO]:")); + x -> x.getValue().contains("ERROR") || x.getValue().contains("WARNING") + || x.getValue().contains("INFO")); return hardcodedStrings.size() > 1; } From 01161d986cdae365d61a46e832e05d71661581bd Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Wed, 21 Feb 2024 10:46:39 -0300 Subject: [PATCH 3/8] Apllying suggestions Renaming comment of string format to prefer_string_concatenation Adding another helper method callsMethod Making comment about substrings general Adding another tests case for when substring is not being used in both methods Making the analyzer to return only the hardcode and substring method if those trigger, so we do not overload the student of comments --- .../loglevels/AvoidUsingStringFormat.java | 19 ---------------- .../loglevels/LogLevelsAnalyzer.java | 22 ++++++++++--------- .../loglevels/UseSubstringMethod.java | 18 --------------- .../analyzer/AnalyzerIntegrationTest.java | 1 + ...loglevels.HardCodingLogLevels.approved.txt | 8 ------- ...s.NotUsingSubstringOnLogLevel.approved.txt | 5 +---- ...ls.NotUsingSubstringOnMessage.approved.txt | 5 +---- ...t.loglevels.UsingStringFormat.approved.txt | 2 +- .../NotUsingSubstringOnMessage.java | 3 +-- .../expected_analysis.json | 2 +- 10 files changed, 18 insertions(+), 67 deletions(-) delete mode 100644 src/main/java/analyzer/exercises/loglevels/AvoidUsingStringFormat.java diff --git a/src/main/java/analyzer/exercises/loglevels/AvoidUsingStringFormat.java b/src/main/java/analyzer/exercises/loglevels/AvoidUsingStringFormat.java deleted file mode 100644 index e346b1b9..00000000 --- a/src/main/java/analyzer/exercises/loglevels/AvoidUsingStringFormat.java +++ /dev/null @@ -1,19 +0,0 @@ -package analyzer.exercises.loglevels; - -import analyzer.Comment; - -/** - * @see Markdown Template - */ -class AvoidUsingStringFormat extends Comment { - - @Override - public String getKey() { - return "java.log-levels.avoid_using_string_format"; - } - - @Override - public Type getType() { - return Type.INFORMATIVE; - } -} diff --git a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java index 789467cf..7e93e3be 100644 --- a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java +++ b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java @@ -42,6 +42,12 @@ public void analyze(Solution solution, OutputCollector output) { public void visit(MethodDeclaration node, OutputCollector output) { if (containsHarcodedString(node)) { output.addComment(new DoNotHardcodeLogLevels()); + return; + } + + if (!node.getNameAsString().equals(REFORMAT) && doesNotCallMethod(node, SUBSTRING)) { + output.addComment(new UseSubstringMethod()); + return; } if (node.getNameAsString().equals(REFORMAT) && doesNotCallMethod(node, MESSAGE)) { @@ -52,16 +58,8 @@ public void visit(MethodDeclaration node, OutputCollector output) { output.addComment(new ReuseCode(REFORMAT, LOG_LEVEL)); } - if (node.getNameAsString().equals(MESSAGE) && doesNotCallMethod(node, SUBSTRING)) { - output.addComment(new UseSubstringMethod(MESSAGE, SUBSTRING)); - } - - if (node.getNameAsString().equals(LOG_LEVEL) && doesNotCallMethod(node, SUBSTRING)) { - output.addComment(new UseSubstringMethod(LOG_LEVEL, SUBSTRING)); - } - - if (node.getNameAsString().equals(REFORMAT) && !doesNotCallMethod(node, FORMAT)) { - output.addComment(new AvoidUsingStringFormat()); + if (node.getNameAsString().equals(REFORMAT) && callsMethod(node, FORMAT)) { + output.addComment(new PreferStringConcatenation()); } super.visit(node, output); @@ -78,4 +76,8 @@ private static boolean containsHarcodedString(MethodDeclaration node) { private static boolean doesNotCallMethod(MethodDeclaration node, String otherMethodName) { return node.findAll(MethodCallExpr.class, x -> x.getNameAsString().contains(otherMethodName)).isEmpty(); } + + private static boolean callsMethod(MethodDeclaration node, String otherMethodName) { + return !node.findAll(MethodCallExpr.class, x -> x.getNameAsString().contains(otherMethodName)).isEmpty(); + } } diff --git a/src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java b/src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java index 9abad723..c7388bf9 100644 --- a/src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java +++ b/src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java @@ -2,34 +2,16 @@ import analyzer.Comment; -import java.util.Map; - /** * @see Markdown Template */ class UseSubstringMethod extends Comment { - private final String callingMethod; - private final String methodToCall; - - - UseSubstringMethod(String callingMethod, String methodToCall) { - this.callingMethod = callingMethod; - this.methodToCall = methodToCall; - } @Override public String getKey() { return "java.log-levels.use_substring_method"; } - @Override - public Map getParameters() { - return Map.of( - "callingMethod", this.callingMethod, - "methodToCall", this.methodToCall - ); - } - @Override public Type getType() { return Type.ACTIONABLE; diff --git a/src/test/java/analyzer/AnalyzerIntegrationTest.java b/src/test/java/analyzer/AnalyzerIntegrationTest.java index 3c65cd31..d81f363b 100644 --- a/src/test/java/analyzer/AnalyzerIntegrationTest.java +++ b/src/test/java/analyzer/AnalyzerIntegrationTest.java @@ -139,6 +139,7 @@ void needforspeed(String scenario) throws IOException { "NoReuseOfBothMethods", "NotUsingSubstringOnLogLevel", "NotUsingSubstringOnMessage", + "NotUsingSubstringOnBothMethods", "UsingStringFormat" }) void loglevels(String scenario) throws IOException { diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt index c89f0beb..a78ee576 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt @@ -5,14 +5,6 @@ "params": {}, "type": "essential" }, - { - "comment": "java.log-levels.use_substring_method", - "params": { - "callingMethod": "message", - "methodToCall": "substring" - }, - "type": "actionable" - }, { "comment": "java.general.feedback_request", "params": {}, diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt index d266bd5d..4874f89c 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt @@ -2,10 +2,7 @@ "comments": [ { "comment": "java.log-levels.use_substring_method", - "params": { - "callingMethod": "logLevel", - "methodToCall": "substring" - }, + "params": {}, "type": "actionable" }, { diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt index ff235c4f..4874f89c 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt @@ -2,10 +2,7 @@ "comments": [ { "comment": "java.log-levels.use_substring_method", - "params": { - "callingMethod": "message", - "methodToCall": "substring" - }, + "params": {}, "type": "actionable" }, { diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt index 24409217..19e8bdef 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.avoid_using_string_format", + "comment": "java.log-levels.prefer_string_concatenation", "params": {}, "type": "informative" }, diff --git a/src/test/resources/scenarios/log-levels/NotUsingSubstringOnMessage.java b/src/test/resources/scenarios/log-levels/NotUsingSubstringOnMessage.java index a3c49ed7..79ae75cc 100644 --- a/src/test/resources/scenarios/log-levels/NotUsingSubstringOnMessage.java +++ b/src/test/resources/scenarios/log-levels/NotUsingSubstringOnMessage.java @@ -2,8 +2,7 @@ public class LogLevels { public static String message(String logLine) { - return logLine.split("]: ")[1] - .trim(); + return logLine.split("]: ")[1].trim(); } public static String logLevel(String logLine) { diff --git a/tests/log-levels/using-string-format/expected_analysis.json b/tests/log-levels/using-string-format/expected_analysis.json index 39065925..265a2966 100644 --- a/tests/log-levels/using-string-format/expected_analysis.json +++ b/tests/log-levels/using-string-format/expected_analysis.json @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.avoid_using_string_format", + "comment": "java.log-levels.prefer_string_concatenation", "params": {}, "type": "informative" }, From daa8d03426dcd6cc5ac5b1fbb88eac673c814105 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Wed, 21 Feb 2024 10:48:47 -0300 Subject: [PATCH 4/8] Adding missing files --- .../loglevels/PreferStringConcatenation.java | 19 +++++++++++++++++++ ...otUsingSubstringOnBothMethods.approved.txt | 14 ++++++++++++++ .../NotUsingSubstringOnBothMethods.java | 15 +++++++++++++++ 3 files changed, 48 insertions(+) create mode 100644 src/main/java/analyzer/exercises/loglevels/PreferStringConcatenation.java create mode 100644 src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnBothMethods.approved.txt create mode 100644 src/test/resources/scenarios/log-levels/NotUsingSubstringOnBothMethods.java diff --git a/src/main/java/analyzer/exercises/loglevels/PreferStringConcatenation.java b/src/main/java/analyzer/exercises/loglevels/PreferStringConcatenation.java new file mode 100644 index 00000000..0ec847c2 --- /dev/null +++ b/src/main/java/analyzer/exercises/loglevels/PreferStringConcatenation.java @@ -0,0 +1,19 @@ +package analyzer.exercises.loglevels; + +import analyzer.Comment; + +/** + * @see Markdown Template + */ +class PreferStringConcatenation extends Comment { + + @Override + public String getKey() { + return "java.log-levels.prefer_string_concatenation"; + } + + @Override + public Type getType() { + return Type.INFORMATIVE; + } +} diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnBothMethods.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnBothMethods.approved.txt new file mode 100644 index 00000000..4874f89c --- /dev/null +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnBothMethods.approved.txt @@ -0,0 +1,14 @@ +{ + "comments": [ + { + "comment": "java.log-levels.use_substring_method", + "params": {}, + "type": "actionable" + }, + { + "comment": "java.general.feedback_request", + "params": {}, + "type": "informative" + } + ] +} \ No newline at end of file diff --git a/src/test/resources/scenarios/log-levels/NotUsingSubstringOnBothMethods.java b/src/test/resources/scenarios/log-levels/NotUsingSubstringOnBothMethods.java new file mode 100644 index 00000000..987a15cb --- /dev/null +++ b/src/test/resources/scenarios/log-levels/NotUsingSubstringOnBothMethods.java @@ -0,0 +1,15 @@ +package scenarios.loglevels; + +public class LogLevels { + public static String message(String logLine) { + return logLine.split("]: ")[1].trim(); + } + + public static String logLevel(String logLine) { + return logLine.split("]: ")[0].replace("[", "").toLowerCase(); + } + + public static String reformat(String logLine) { + return message(logLine) + " (" + logLevel(logLine) + ")"; + } +} From cf8d13188a5856c4a74333b0252a216972f7c960 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Wed, 21 Feb 2024 10:51:22 -0300 Subject: [PATCH 5/8] Fixing smoke tests --- .../log-levels/hardcode-log-levels/expected_analysis.json | 8 -------- tests/log-levels/no-substring-used/expected_analysis.json | 5 +---- 2 files changed, 1 insertion(+), 12 deletions(-) diff --git a/tests/log-levels/hardcode-log-levels/expected_analysis.json b/tests/log-levels/hardcode-log-levels/expected_analysis.json index 353f8e09..fe70df8e 100644 --- a/tests/log-levels/hardcode-log-levels/expected_analysis.json +++ b/tests/log-levels/hardcode-log-levels/expected_analysis.json @@ -5,14 +5,6 @@ "params": {}, "type": "essential" }, - { - "comment": "java.log-levels.use_substring_method", - "params": { - "callingMethod": "message", - "methodToCall": "substring" - }, - "type": "actionable" - }, { "comment": "java.general.feedback_request", "params": {}, diff --git a/tests/log-levels/no-substring-used/expected_analysis.json b/tests/log-levels/no-substring-used/expected_analysis.json index ff131087..0e0173d7 100644 --- a/tests/log-levels/no-substring-used/expected_analysis.json +++ b/tests/log-levels/no-substring-used/expected_analysis.json @@ -2,10 +2,7 @@ "comments": [ { "comment": "java.log-levels.use_substring_method", - "params": { - "callingMethod": "message", - "methodToCall": "substring" - }, + "params": {}, "type": "actionable" }, { From c707caae73db6499e581cb98618c04be66846d60 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Wed, 28 Feb 2024 10:37:16 -0300 Subject: [PATCH 6/8] Applying suggestions Using general comment for hardcoded tests Updating prefer string concatenation comment to be a general one --- .../loglevels/DoNotHardcodeLogLevels.java | 19 ------------------- .../loglevels/LogLevelsAnalyzer.java | 4 +++- .../loglevels/PreferStringConcatenation.java | 19 ------------------- ...loglevels.HardCodingLogLevels.approved.txt | 2 +- ...t.loglevels.UsingStringFormat.approved.txt | 2 +- .../expected_analysis.json | 2 +- .../expected_analysis.json | 2 +- 7 files changed, 7 insertions(+), 43 deletions(-) delete mode 100644 src/main/java/analyzer/exercises/loglevels/DoNotHardcodeLogLevels.java delete mode 100644 src/main/java/analyzer/exercises/loglevels/PreferStringConcatenation.java diff --git a/src/main/java/analyzer/exercises/loglevels/DoNotHardcodeLogLevels.java b/src/main/java/analyzer/exercises/loglevels/DoNotHardcodeLogLevels.java deleted file mode 100644 index 2454f7e5..00000000 --- a/src/main/java/analyzer/exercises/loglevels/DoNotHardcodeLogLevels.java +++ /dev/null @@ -1,19 +0,0 @@ -package analyzer.exercises.loglevels; - -import analyzer.Comment; - -/** - * @see Markdown Template - */ -class DoNotHardcodeLogLevels extends Comment{ - - @Override - public String getKey() { - return "java.log-levels.do_not_hardcode_log_levels"; - } - - @Override - public Type getType() { - return Type.ESSENTIAL; - } -} diff --git a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java index 7e93e3be..8ff18100 100644 --- a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java +++ b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java @@ -9,7 +9,9 @@ import analyzer.Analyzer; import analyzer.OutputCollector; import analyzer.Solution; +import analyzer.comments.AvoidHardCodedTestCases; import analyzer.comments.ExemplarSolution; +import analyzer.comments.PreferStringConcatenation; import java.util.List; @@ -41,7 +43,7 @@ public void analyze(Solution solution, OutputCollector output) { @Override public void visit(MethodDeclaration node, OutputCollector output) { if (containsHarcodedString(node)) { - output.addComment(new DoNotHardcodeLogLevels()); + output.addComment(new AvoidHardCodedTestCases()); return; } diff --git a/src/main/java/analyzer/exercises/loglevels/PreferStringConcatenation.java b/src/main/java/analyzer/exercises/loglevels/PreferStringConcatenation.java deleted file mode 100644 index 0ec847c2..00000000 --- a/src/main/java/analyzer/exercises/loglevels/PreferStringConcatenation.java +++ /dev/null @@ -1,19 +0,0 @@ -package analyzer.exercises.loglevels; - -import analyzer.Comment; - -/** - * @see Markdown Template - */ -class PreferStringConcatenation extends Comment { - - @Override - public String getKey() { - return "java.log-levels.prefer_string_concatenation"; - } - - @Override - public Type getType() { - return Type.INFORMATIVE; - } -} diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt index a78ee576..723cbd96 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.do_not_hardcode_log_levels", + "comment": "java.general.avoid_hard_coded_test_cases", "params": {}, "type": "essential" }, diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt index 19e8bdef..b01ad7f7 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.UsingStringFormat.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.prefer_string_concatenation", + "comment": "java.general.prefer_string_concatenation", "params": {}, "type": "informative" }, diff --git a/tests/log-levels/hardcode-log-levels/expected_analysis.json b/tests/log-levels/hardcode-log-levels/expected_analysis.json index fe70df8e..e5fab09b 100644 --- a/tests/log-levels/hardcode-log-levels/expected_analysis.json +++ b/tests/log-levels/hardcode-log-levels/expected_analysis.json @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.do_not_hardcode_log_levels", + "comment": "java.general.avoid_hard_coded_test_cases", "params": {}, "type": "essential" }, diff --git a/tests/log-levels/using-string-format/expected_analysis.json b/tests/log-levels/using-string-format/expected_analysis.json index 265a2966..2b150682 100644 --- a/tests/log-levels/using-string-format/expected_analysis.json +++ b/tests/log-levels/using-string-format/expected_analysis.json @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.prefer_string_concatenation", + "comment": "java.general.prefer_string_concatenation", "params": {}, "type": "informative" }, From 4196108a5a17286048cc973b8c1c6690a808aeef Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Wed, 28 Feb 2024 10:37:31 -0300 Subject: [PATCH 7/8] Adding missing files --- .../comments/PreferStringConcatenation.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 src/main/java/analyzer/comments/PreferStringConcatenation.java diff --git a/src/main/java/analyzer/comments/PreferStringConcatenation.java b/src/main/java/analyzer/comments/PreferStringConcatenation.java new file mode 100644 index 00000000..03e7ea0f --- /dev/null +++ b/src/main/java/analyzer/comments/PreferStringConcatenation.java @@ -0,0 +1,19 @@ +package analyzer.comments; + +import analyzer.Comment; + +/** + * @see Markdown Template + */ +public class PreferStringConcatenation extends Comment { + + @Override + public String getKey() { + return "java.general.prefer_string_concatenation"; + } + + @Override + public Type getType() { + return Type.INFORMATIVE; + } +} From ebb6d0fe42a94d032862db94fad69c94339506d2 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Wed, 28 Feb 2024 17:31:20 -0300 Subject: [PATCH 8/8] Making ReuseCode a general comment and updating its usage from lasagna and log-levels analyzers --- .../lasagna => comments}/ReuseCode.java | 10 +++--- .../exercises/lasagna/LasagnaAnalyzer.java | 2 ++ .../loglevels/LogLevelsAnalyzer.java | 1 + .../exercises/loglevels/ReuseCode.java | 36 ------------------- ....lasagna.NoReuseOfBothMethods.approved.txt | 4 +-- ...oReuseOfExpectedMinutesInOven.approved.txt | 2 +- ...useOfPreparationTimeInMinutes.approved.txt | 2 +- ...est.loglevels.NoReuseLogLevel.approved.txt | 2 +- ...Test.loglevels.NoReuseMessage.approved.txt | 2 +- ...oglevels.NoReuseOfBothMethods.approved.txt | 4 +-- .../no-code-reuse/expected_analysis.json | 4 +-- .../no-reuse-code/expected_analysis.json | 2 +- 12 files changed, 19 insertions(+), 52 deletions(-) rename src/main/java/analyzer/{exercises/lasagna => comments}/ReuseCode.java (72%) delete mode 100644 src/main/java/analyzer/exercises/loglevels/ReuseCode.java diff --git a/src/main/java/analyzer/exercises/lasagna/ReuseCode.java b/src/main/java/analyzer/comments/ReuseCode.java similarity index 72% rename from src/main/java/analyzer/exercises/lasagna/ReuseCode.java rename to src/main/java/analyzer/comments/ReuseCode.java index 7a2fdf89..8119b342 100644 --- a/src/main/java/analyzer/exercises/lasagna/ReuseCode.java +++ b/src/main/java/analyzer/comments/ReuseCode.java @@ -1,24 +1,24 @@ -package analyzer.exercises.lasagna; +package analyzer.comments; import analyzer.Comment; import java.util.Map; /** - * @see Markdown Template + * @see Markdown Template */ -class ReuseCode extends Comment { +public class ReuseCode extends Comment { private final String callingMethod; private final String methodToCall; - ReuseCode(String callingMethod, String methodToCall) { + public ReuseCode(String callingMethod, String methodToCall) { this.callingMethod = callingMethod; this.methodToCall = methodToCall; } @Override public String getKey() { - return "java.lasagna.reuse_code"; + return "java.general.reuse_code"; } @Override diff --git a/src/main/java/analyzer/exercises/lasagna/LasagnaAnalyzer.java b/src/main/java/analyzer/exercises/lasagna/LasagnaAnalyzer.java index 3efd5fc7..325c720d 100644 --- a/src/main/java/analyzer/exercises/lasagna/LasagnaAnalyzer.java +++ b/src/main/java/analyzer/exercises/lasagna/LasagnaAnalyzer.java @@ -5,6 +5,8 @@ import analyzer.Solution; import analyzer.comments.ExemplarSolution; import analyzer.comments.RemoveTodoComments; +import analyzer.comments.ReuseCode; + import com.github.javaparser.ast.CompilationUnit; import com.github.javaparser.ast.body.MethodDeclaration; import com.github.javaparser.ast.comments.LineComment; diff --git a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java index 8ff18100..7107f522 100644 --- a/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java +++ b/src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java @@ -12,6 +12,7 @@ import analyzer.comments.AvoidHardCodedTestCases; import analyzer.comments.ExemplarSolution; import analyzer.comments.PreferStringConcatenation; +import analyzer.comments.ReuseCode; import java.util.List; diff --git a/src/main/java/analyzer/exercises/loglevels/ReuseCode.java b/src/main/java/analyzer/exercises/loglevels/ReuseCode.java deleted file mode 100644 index 40961021..00000000 --- a/src/main/java/analyzer/exercises/loglevels/ReuseCode.java +++ /dev/null @@ -1,36 +0,0 @@ -package analyzer.exercises.loglevels; - -import analyzer.Comment; - -import java.util.Map; - -/** - * @see Markdown Template - */ -class ReuseCode extends Comment { - private final String callingMethod; - private final String methodToCall; - - ReuseCode(String callingMethod, String methodToCall) { - this.callingMethod = callingMethod; - this.methodToCall = methodToCall; - } - - @Override - public String getKey() { - return "java.log-levels.reuse_code"; - } - - @Override - public Map getParameters() { - return Map.of( - "callingMethod", this.callingMethod, - "methodToCall", this.methodToCall - ); - } - - @Override - public Type getType() { - return Type.ACTIONABLE; - } -} diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfBothMethods.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfBothMethods.approved.txt index f9f74609..7070ea23 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfBothMethods.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfBothMethods.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.lasagna.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "remainingMinutesInOven", "methodToCall": "expectedMinutesInOven" @@ -9,7 +9,7 @@ "type": "actionable" }, { - "comment": "java.lasagna.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "totalTimeInMinutes", "methodToCall": "preparationTimeInMinutes" diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfExpectedMinutesInOven.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfExpectedMinutesInOven.approved.txt index d5dcc6e9..76eed184 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfExpectedMinutesInOven.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfExpectedMinutesInOven.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.lasagna.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "remainingMinutesInOven", "methodToCall": "expectedMinutesInOven" diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfPreparationTimeInMinutes.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfPreparationTimeInMinutes.approved.txt index 3ad37e36..f80fd3e7 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfPreparationTimeInMinutes.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfPreparationTimeInMinutes.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.lasagna.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "totalTimeInMinutes", "methodToCall": "preparationTimeInMinutes" diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt index a06e48f5..fe5b1056 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "reformat", "methodToCall": "logLevel" diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt index 828b0c45..88b0b3bd 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "reformat", "methodToCall": "message" diff --git a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt index f0c86366..6ea6c232 100644 --- a/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt +++ b/src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "reformat", "methodToCall": "message" @@ -9,7 +9,7 @@ "type": "actionable" }, { - "comment": "java.log-levels.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "reformat", "methodToCall": "logLevel" diff --git a/tests/lasagna/no-code-reuse/expected_analysis.json b/tests/lasagna/no-code-reuse/expected_analysis.json index f9f74609..7070ea23 100644 --- a/tests/lasagna/no-code-reuse/expected_analysis.json +++ b/tests/lasagna/no-code-reuse/expected_analysis.json @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.lasagna.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "remainingMinutesInOven", "methodToCall": "expectedMinutesInOven" @@ -9,7 +9,7 @@ "type": "actionable" }, { - "comment": "java.lasagna.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "totalTimeInMinutes", "methodToCall": "preparationTimeInMinutes" diff --git a/tests/log-levels/no-reuse-code/expected_analysis.json b/tests/log-levels/no-reuse-code/expected_analysis.json index 970dc07a..d9db4feb 100644 --- a/tests/log-levels/no-reuse-code/expected_analysis.json +++ b/tests/log-levels/no-reuse-code/expected_analysis.json @@ -1,7 +1,7 @@ { "comments": [ { - "comment": "java.log-levels.reuse_code", + "comment": "java.general.reuse_code", "params": { "callingMethod": "reformat", "methodToCall": "logLevel"