From 1b24399a41f01d7e346ccc7f36f884efdfbf40d5 Mon Sep 17 00:00:00 2001 From: Angelika Tyborska Date: Sat, 10 Jul 2021 09:00:47 +0200 Subject: [PATCH] Run common checks for every single solution; Add common check for snake_case (#102) Co-authored-by: Tim Austin --- README.md | 4 +- lib/elixir_analyzer.ex | 18 +- lib/elixir_analyzer/comment.ex | 3 +- lib/elixir_analyzer/constants.ex | 2 + lib/elixir_analyzer/exercise_test.ex | 3 + .../exercise_test/common_checks.ex | 18 ++ .../common_checks/function_names.ex | 63 +++++++ .../common_checks/module_attribute_names.ex | 61 ++++++ lib/elixir_analyzer/test_suite/default.ex | 10 + .../common_checks/function_names_test.exs | 177 ++++++++++++++++++ .../module_attribute_names_test.exs | 95 ++++++++++ .../exercise_test/common_checks_test.exs | 130 +++++++++++++ test/elixir_analyzer/exercise_test_test.exs | 2 + test/elixir_analyzer_test.exs | 11 +- .../two_fer/imperfect_solution/lib/two_fer.ex | 2 + 15 files changed, 582 insertions(+), 17 deletions(-) create mode 100644 lib/elixir_analyzer/exercise_test/common_checks.ex create mode 100644 lib/elixir_analyzer/exercise_test/common_checks/function_names.ex create mode 100644 lib/elixir_analyzer/exercise_test/common_checks/module_attribute_names.ex create mode 100644 lib/elixir_analyzer/test_suite/default.ex create mode 100644 test/elixir_analyzer/exercise_test/common_checks/function_names_test.exs create mode 100644 test/elixir_analyzer/exercise_test/common_checks/module_attribute_names_test.exs create mode 100644 test/elixir_analyzer/exercise_test/common_checks_test.exs diff --git a/README.md b/README.md index fee2b24c..614a8ad3 100644 --- a/README.md +++ b/README.md @@ -57,7 +57,7 @@ As a demonstration, once iex loads with `iex -S mix` you can type `ElixirAnalyze ### `ElixirAnalyzer` - The is the main application module. A function call to `start_analyze/3` begins the analysis (either through IEX or the CLI escript [if generated]). -- A configuation in `config/config.exs` holds data for each exercise supported +- A configuration in `config/config.exs` holds data for each exercise supported ```elixir config :elixir_analyzer, @@ -110,7 +110,7 @@ Contains macro to generate a function returning the comment path on the `exercis ### `ElixirAnalyzer.CLI` -This module is a module for the CLI escript to parse the command line arguements and start the processing +This module is a module for the CLI escript to parse the command line arguments and start the processing ### `ElixirAnalyzer.ExerciseTest.________` diff --git a/lib/elixir_analyzer.ex b/lib/elixir_analyzer.ex index e3ac545c..d548bf40 100644 --- a/lib/elixir_analyzer.ex +++ b/lib/elixir_analyzer.ex @@ -134,15 +134,6 @@ defmodule ElixirAnalyzer do analysis_module: analysis_module } rescue - e in ArgumentError -> - Logger.warning("TestSuite halted, ArgumentError", error_message: e.message) - - submission - |> Submission.halt() - |> Submission.set_halt_reason( - "Analysis skipped, no analysis suite exists for this exercise" - ) - e in File.Error -> Logger.warning("Unable to decode 'config.json'", error_message: e.message) @@ -156,6 +147,13 @@ defmodule ElixirAnalyzer do submission |> Submission.halt() |> Submission.set_halt_reason("Analysis skipped, not able to decode solution config.") + + e -> + Logger.warning("TestSuite halted, #{e.__struct__}", error_message: e.message) + + submission + |> Submission.halt() + |> Submission.set_halt_reason("Analysis skipped, unexpected error #{e.__struct__}") end end @@ -168,7 +166,7 @@ defmodule ElixirAnalyzer do code_path = Path.dirname(full_code_path) code_file = Path.basename(full_code_path) - {code_path, code_file, exercise_config[:analyzer_module]} + {code_path, code_file, exercise_config[:analyzer_module] || ElixirAnalyzer.TestSuite.Default} end # Else, use passed in params to analyze diff --git a/lib/elixir_analyzer/comment.ex b/lib/elixir_analyzer/comment.ex index ded1ca5e..c674f68b 100644 --- a/lib/elixir_analyzer/comment.ex +++ b/lib/elixir_analyzer/comment.ex @@ -11,6 +11,7 @@ defmodule ElixirAnalyzer.Comment do comment: String.t(), type: :essential | :actionable | :informative | :celebratory, status: :skip | :test, - suppress_if: false | {String.t(), :pass | :fail} + suppress_if: false | {String.t(), :pass | :fail}, + params: map() } end diff --git a/lib/elixir_analyzer/constants.ex b/lib/elixir_analyzer/constants.ex index f6ea94e3..c3ee4873 100644 --- a/lib/elixir_analyzer/constants.ex +++ b/lib/elixir_analyzer/constants.ex @@ -18,6 +18,8 @@ defmodule ElixirAnalyzer.Constants do solution_use_moduledoc: "elixir.solution.use_module_doc", solution_use_specification: "elixir.solution.use_specification", solution_raise_fn_clause_error: "elixir.solution.raise_fn_clause_error", + solution_module_attribute_name_snake_case: "elixir.solution.module_attribute_name_snake_case", + solution_function_name_snake_case: "elixir.solution.function_name_snake_case", # Concept exercises diff --git a/lib/elixir_analyzer/exercise_test.ex b/lib/elixir_analyzer/exercise_test.ex index c0a7bca7..db4d0b66 100644 --- a/lib/elixir_analyzer/exercise_test.ex +++ b/lib/elixir_analyzer/exercise_test.ex @@ -3,6 +3,7 @@ defmodule ElixirAnalyzer.ExerciseTest do alias ElixirAnalyzer.ExerciseTest.Feature.Compiler, as: FeatureCompiler alias ElixirAnalyzer.ExerciseTest.AssertCall.Compiler, as: AssertCallCompiler + alias ElixirAnalyzer.ExerciseTest.CommonChecks alias ElixirAnalyzer.Submission alias ElixirAnalyzer.Constants @@ -45,10 +46,12 @@ defmodule ElixirAnalyzer.ExerciseTest do {:ok, code_ast} -> feature_results = unquote(feature_tests) |> filter_suppressed_results() assert_call_results = unquote(assert_call_tests) |> filter_suppressed_results() + common_checks_results = CommonChecks.run(code_ast, code_as_string) submission |> append_test_comments(feature_results) |> append_test_comments(assert_call_results) + |> append_test_comments(common_checks_results) {:error, e} -> append_analysis_failure(submission, e) diff --git a/lib/elixir_analyzer/exercise_test/common_checks.ex b/lib/elixir_analyzer/exercise_test/common_checks.ex new file mode 100644 index 00000000..01017b8a --- /dev/null +++ b/lib/elixir_analyzer/exercise_test/common_checks.ex @@ -0,0 +1,18 @@ +defmodule ElixirAnalyzer.ExerciseTest.CommonChecks do + @moduledoc """ + This module aggregates all common checks that should be run on every single solution. + """ + + alias ElixirAnalyzer.ExerciseTest.CommonChecks.FunctionNames + alias ElixirAnalyzer.ExerciseTest.CommonChecks.ModuleAttributeNames + alias ElixirAnalyzer.Comment + + @spec run(Macro.t(), String.t()) :: [{:pass | :fail | :skip, %Comment{}}] + def run(code_ast, code_as_string) when is_binary(code_as_string) do + [ + FunctionNames.run(code_ast), + ModuleAttributeNames.run(code_ast) + ] + |> List.flatten() + end +end diff --git a/lib/elixir_analyzer/exercise_test/common_checks/function_names.ex b/lib/elixir_analyzer/exercise_test/common_checks/function_names.ex new file mode 100644 index 00000000..15a37616 --- /dev/null +++ b/lib/elixir_analyzer/exercise_test/common_checks/function_names.ex @@ -0,0 +1,63 @@ +defmodule ElixirAnalyzer.ExerciseTest.CommonChecks.FunctionNames do + @moduledoc """ + Reports the first function/macro/guard with a name that's not snake_case. + + Doesn't report more if there are more. + A single comment should be enough for the student to know what to fix. + + Common check to be run on every single solution. + """ + + alias ElixirAnalyzer.Constants + alias ElixirAnalyzer.Comment + + @def_ops [:def, :defp, :defmacro, :defmacrop, :defguard, :defguardp] + + @spec run(Macro.t()) :: [{:pass | :fail | :skip, %Comment{}}] + def run(ast) do + {_, names} = Macro.prewalk(ast, [], &traverse/2) + wrong_name = List.last(names) + + if wrong_name do + wrong_name = to_string(wrong_name) + correct_name = to_snake_case(wrong_name) + + [ + {:fail, + %Comment{ + type: :actionable, + comment: Constants.solution_function_name_snake_case(), + params: %{ + expected: correct_name, + actual: wrong_name + } + }} + ] + else + [] + end + end + + defp traverse({op, _meta, [{name, _meta2, _arguments} | _]} = ast, names) when op in @def_ops do + if snake_case?(name) do + {ast, names} + else + {ast, [name | names]} + end + end + + defp traverse(ast, names) do + {ast, names} + end + + defp snake_case?(name) do + # the code had to compile and pass all the tests to get to the analyzer + # so we can assume the name is otherwise valid + to_snake_case(name) == to_string(name) + end + + defp to_snake_case(name) do + # Macro.underscore is good enough because a module attribute name must be a valid Elixir identifier anyway + Macro.underscore(to_string(name)) + end +end diff --git a/lib/elixir_analyzer/exercise_test/common_checks/module_attribute_names.ex b/lib/elixir_analyzer/exercise_test/common_checks/module_attribute_names.ex new file mode 100644 index 00000000..3cb7904a --- /dev/null +++ b/lib/elixir_analyzer/exercise_test/common_checks/module_attribute_names.ex @@ -0,0 +1,61 @@ +defmodule ElixirAnalyzer.ExerciseTest.CommonChecks.ModuleAttributeNames do + @moduledoc """ + Reports the first module attribute with a name that's not snake_case. + + Doesn't report more if there are more. + A single comment should be enough for the student to know what to fix. + + Common check to be run on every single solution. + """ + + alias ElixirAnalyzer.Constants + alias ElixirAnalyzer.Comment + + @spec run(Macro.t()) :: [{:pass | :fail | :skip, %Comment{}}] + def run(ast) do + {_, names} = Macro.prewalk(ast, [], &traverse/2) + wrong_name = List.last(names) + + if wrong_name do + wrong_name = to_string(wrong_name) + correct_name = to_snake_case(wrong_name) + + [ + {:fail, + %Comment{ + type: :actionable, + comment: Constants.solution_module_attribute_name_snake_case(), + params: %{ + expected: correct_name, + actual: wrong_name + } + }} + ] + else + [] + end + end + + defp traverse({:@, _meta, [{name, _meta2, _arguments}]} = ast, names) do + if snake_case?(name) do + {ast, names} + else + {ast, [name | names]} + end + end + + defp traverse(ast, names) do + {ast, names} + end + + defp snake_case?(name) do + # the code had to compile and pass all the tests to get to the analyzer + # so we can assume the name is otherwise valid + to_snake_case(name) == to_string(name) + end + + defp to_snake_case(name) do + # Macro.underscore is good enough because a module attribute name must be a valid Elixir identifier anyway + Macro.underscore(to_string(name)) + end +end diff --git a/lib/elixir_analyzer/test_suite/default.ex b/lib/elixir_analyzer/test_suite/default.ex new file mode 100644 index 00000000..eb5a7186 --- /dev/null +++ b/lib/elixir_analyzer/test_suite/default.ex @@ -0,0 +1,10 @@ +defmodule ElixirAnalyzer.TestSuite.Default do + @moduledoc """ + This is the default exercise analyzer extension module. + + It will be run for any exercise submission that doesn't have its own extension module. + It's intentionally empty, which means it will only run the common checks. + """ + + use ElixirAnalyzer.ExerciseTest +end diff --git a/test/elixir_analyzer/exercise_test/common_checks/function_names_test.exs b/test/elixir_analyzer/exercise_test/common_checks/function_names_test.exs new file mode 100644 index 00000000..6283ef0c --- /dev/null +++ b/test/elixir_analyzer/exercise_test/common_checks/function_names_test.exs @@ -0,0 +1,177 @@ +# credo:disable-for-this-file Credo.Check.Readability.FunctionNames + +defmodule ElixirAnalyzer.ExerciseTest.CommonChecks.FunctionNamesTest do + use ExUnit.Case + alias ElixirAnalyzer.Comment + alias ElixirAnalyzer.Constants + alias ElixirAnalyzer.ExerciseTest.CommonChecks.FunctionNames + + test "returns empty list if there are functions, macros, or guards" do + code = + quote do + defmodule User do + defstruct(:name, :email) + end + end + + assert FunctionNames.run(code) == [] + end + + test "doesn't crash when a variable is named def" do + code = + quote do + defmodule User do + def name(user) do + def = user.first_name + defmacro = user.last_name + def <> " " <> defmacro + end + end + end + + assert FunctionNames.run(code) == [] + end + + test "returns empty list if all names are correct" do + code = + quote do + defmodule User do + def first_name(user), do: user.first_name + defp registered_in_last_quarter?(user), do: true + defmacro validate_user!, do: true + defmacrop do_validate_user, do: true + defguard(is_user, do: true) + defguardp(is_registered_user, do: true) + end + end + + assert FunctionNames.run(code) == [] + end + + test "returns an actionable comment with params" do + code = + quote do + defmodule User do + def firstName(user), do: user.first_name + end + end + + assert FunctionNames.run(code) == [ + {:fail, + %Comment{ + type: :actionable, + comment: Constants.solution_function_name_snake_case(), + params: %{ + expected: "first_name", + actual: "firstName" + } + }} + ] + end + + test "works for def, defp, defmacro, defmacrop, defguard, and defguardp" do + get_result = fn expected, actual -> + [ + {:fail, + %Comment{ + type: :actionable, + comment: Constants.solution_function_name_snake_case(), + params: %{ + expected: expected, + actual: actual + } + }} + ] + end + + code = + quote do + defmodule User do + defp registeredInLastQuarter?(user), do: true + end + end + + assert FunctionNames.run(code) == + get_result.("registered_in_last_quarter?", "registeredInLastQuarter?") + + code = + quote do + defmodule User do + defmacro validateUser!, do: true + end + end + + assert FunctionNames.run(code) == get_result.("validate_user!", "validateUser!") + + code = + quote do + defmodule User do + defmacrop doValidateUser, do: true + end + end + + assert FunctionNames.run(code) == get_result.("do_validate_user", "doValidateUser") + + code = + quote do + defmodule User do + defguard(isUser, do: true) + end + end + + assert FunctionNames.run(code) == get_result.("is_user", "isUser") + + code = + quote do + defmodule User do + defguardp(isRegisteredUser, do: true) + end + end + + assert FunctionNames.run(code) == get_result.("is_registered_user", "isRegisteredUser") + end + + test "only reports the first wrong name" do + code = + quote do + defmodule User do + def first_name(user), do: getFirstName(user) + defguard(isRegisteredUser(user), do: true) + defp getFirstName(user), do: user.first_name + end + end + + assert FunctionNames.run(code) == [ + {:fail, + %Comment{ + type: :actionable, + comment: Constants.solution_function_name_snake_case(), + params: %{ + expected: "is_registered_user", + actual: "isRegisteredUser" + } + }} + ] + end + + test "can handle function heads" do + code = + quote do + defmodule User do + def getName(user, fallback \\ "Doe") + end + end + + assert FunctionNames.run(code) == [ + {:fail, + %Comment{ + type: :actionable, + comment: Constants.solution_function_name_snake_case(), + params: %{ + expected: "get_name", + actual: "getName" + } + }} + ] + end +end diff --git a/test/elixir_analyzer/exercise_test/common_checks/module_attribute_names_test.exs b/test/elixir_analyzer/exercise_test/common_checks/module_attribute_names_test.exs new file mode 100644 index 00000000..e8df0635 --- /dev/null +++ b/test/elixir_analyzer/exercise_test/common_checks/module_attribute_names_test.exs @@ -0,0 +1,95 @@ +# credo:disable-for-this-file Credo.Check.Readability.ModuleAttributeNames + +defmodule ElixirAnalyzer.ExerciseTest.CommonChecks.ModuleAttributeNamesTest do + use ExUnit.Case + alias ElixirAnalyzer.Comment + alias ElixirAnalyzer.Constants + alias ElixirAnalyzer.ExerciseTest.CommonChecks.ModuleAttributeNames + + test "returns empty list if there are no module attributes" do + code = + quote do + defmodule Factorial do + def calculate(1), do: 1 + + def calculate(n) do + n * calculate(n - 1) + end + end + end + + assert ModuleAttributeNames.run(code) == [] + end + + test "returns empty list if there are no module attributes with camelCase names" do + code = + quote do + defmodule Factorial do + @initial_value 1 + @spec calculate(integer) :: integer + def calculate(1), do: @initial_value + + def calculate(n) do + n * calculate(n - 1) + end + end + end + + assert ModuleAttributeNames.run(code) == [] + end + + test "returns an actionable comment with params" do + code = + quote do + defmodule Factorial do + @initialValue 1 + @spec calculate(integer) :: integer + def calculate(1), do: @initialValue + + def calculate(n) do + n * calculate(n - 1) + end + end + end + + assert ModuleAttributeNames.run(code) == [ + {:fail, + %Comment{ + type: :actionable, + comment: Constants.solution_module_attribute_name_snake_case(), + params: %{ + expected: "initial_value", + actual: "initialValue" + } + }} + ] + end + + test "only reports the first module attribute" do + code = + quote do + defmodule Factorial do + @somethingElseCamelCase + @initialValue 1 + @spec calculate(integer) :: integer + def calculate(1), do: @initialValue + + def calculate(n) do + n * calculate(n - 1) + end + end + end + + assert ModuleAttributeNames.run(code) == [ + {:fail, + %Comment{ + type: :actionable, + comment: Constants.solution_module_attribute_name_snake_case(), + params: %{ + expected: "something_else_camel_case", + actual: "somethingElseCamelCase" + } + }} + ] + end +end diff --git a/test/elixir_analyzer/exercise_test/common_checks_test.exs b/test/elixir_analyzer/exercise_test/common_checks_test.exs new file mode 100644 index 00000000..ce449d2b --- /dev/null +++ b/test/elixir_analyzer/exercise_test/common_checks_test.exs @@ -0,0 +1,130 @@ +# credo:disable-for-this-file Credo.Check.Readability.ModuleAttributeNames +# credo:disable-for-this-file Credo.Check.Readability.FunctionNames + +defmodule ElixirAnalyzer.ExerciseTestTest.Empty do + use ElixirAnalyzer.ExerciseTest +end + +defmodule ElixirAnalyzer.ExerciseTest.CommonChecksTest do + alias ElixirConstants.Constants + + use ElixirAnalyzer.ExerciseTestCase, + exercise_test_module: ElixirAnalyzer.ExerciseTestTest.Empty + + describe "function, guard, macro names" do + test_exercise_analysis "doesn't report correct names", + comments_exclude: [Constants.solution_function_name_snake_case()] do + [ + defmodule SomeModule do + def foo_bar, do: 1 + + def foo_bar_baz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defp foo_bar, do: 1 + + defp foo_bar_baz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defmacro foo_bar, do: 1 + + defmacro foo_bar_baz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defmacrop foo_bar, do: 1 + + defmacrop foo_bar_baz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defguard(foo_bar, do: 1) + + defguard foo_bar_baz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defguardp(foo_bar, do: 1) + + defguardp foo_bar_baz do + foo_bar + 8 + end + end + ] + end + + test_exercise_analysis "reports incorrect names", + comments_include: [Constants.solution_function_name_snake_case()] do + [ + defmodule SomeModule do + def fooBarBaz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defp fooBarBaz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defmacro fooBarBaz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defmacrop fooBarBaz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defguard fooBarBaz do + foo_bar + 8 + end + end, + defmodule SomeModule do + defguardp fooBarBaz do + foo_bar + 8 + end + end + ] + end + end + + describe "module attribute names" do + test_exercise_analysis "doesn't report correct module attribute names", + comments_exclude: [Constants.solution_module_attribute_name_snake_case()] do + [ + defmodule SomeModule do + @foo_bar + end, + defmodule SomeModule do + @foo_bar1 + @foo_bar2 + end, + defmodule SomeModule do + @foo_bar1 5 + @foo_bar2 2 + end + ] + end + + test_exercise_analysis "reports a module attribute that doesn't use snake_case", + comments_include: [Constants.solution_module_attribute_name_snake_case()] do + [ + defmodule SomeModule do + @fooBar + end, + defmodule SomeModule do + @someValue 3 + end + ] + end + end +end diff --git a/test/elixir_analyzer/exercise_test_test.exs b/test/elixir_analyzer/exercise_test_test.exs index ab43f572..c5679df1 100644 --- a/test/elixir_analyzer/exercise_test_test.exs +++ b/test/elixir_analyzer/exercise_test_test.exs @@ -47,6 +47,8 @@ defmodule ElixirAnalyzer.ExerciseTestTest.SameComment do end defmodule ElixirAnalyzer.ExerciseTestTest do + alias ElixirConstants.Constants + use ElixirAnalyzer.ExerciseTestCase, exercise_test_module: ElixirAnalyzer.ExerciseTestTest.SameComment diff --git a/test/elixir_analyzer_test.exs b/test/elixir_analyzer_test.exs index 6e41ca9a..baa09e4c 100644 --- a/test/elixir_analyzer_test.exs +++ b/test/elixir_analyzer_test.exs @@ -29,7 +29,7 @@ defmodule ElixirAnalyzerTest do analyzed_exercise = ElixirAnalyzer.analyze_exercise(exercise, path, path, @options) expected_output = """ - {\"comments\":[{\"comment\":\"elixir.solution.use_module_doc\",\"type\":\"informative\"},{\"comment\":\"elixir.solution.raise_fn_clause_error\",\"type\":\"actionable\"},{\"comment\":\"elixir.two-fer.use_of_function_header\",\"type\":\"actionable\"},{\"comment\":\"elixir.solution.use_specification\",\"type\":\"actionable\"}],\"summary\":\"Check the comments for some code suggestions. 📣\"} + {\"comments\":[{\"comment\":\"elixir.solution.use_module_doc\",\"type\":\"informative\"},{\"comment\":\"elixir.solution.raise_fn_clause_error\",\"type\":\"actionable\"},{\"comment\":\"elixir.two-fer.use_of_function_header\",\"type\":\"actionable\"},{\"comment\":\"elixir.solution.use_specification\",\"type\":\"actionable\"},{\"comment\":\"elixir.solution.module_attribute_name_snake_case\",\"params\":{\"actual\":\"someUnusedModuleAttribute\",\"expected\":\"some_unused_module_attribute\"},\"type\":\"actionable\"}],\"summary\":\"Check the comments for some code suggestions. 📣\"} """ assert Submission.to_json(analyzed_exercise) == String.trim(expected_output) @@ -63,15 +63,15 @@ defmodule ElixirAnalyzerTest do assert Submission.to_json(analyzed_exercise) == String.trim(expected_output) end - test "solution for an exercise with no analyzer module" do + test "solution for an exercise with no analyzer module uses the default module" do exercise = "not-a-real-exercise" - path = "./test_data/two_fer/error_solution/" + path = "./test_data/two_fer/imperfect_solution/" capture_log(fn -> analyzed_exercise = ElixirAnalyzer.analyze_exercise(exercise, path, path, @options) expected_output = """ - {\"comments\":[],\"summary\":\"Analysis was halted. Analysis skipped, no analysis suite exists for this exercise\"} + {\"comments\":[{\"comment\":\"elixir.solution.module_attribute_name_snake_case\",\"params\":{\"actual\":\"someUnusedModuleAttribute\",\"expected\":\"some_unused_module_attribute\"},\"type\":\"actionable\"}],\"summary\":\"Check the comments for some code suggestions. 📣\"} """ assert Submission.to_json(analyzed_exercise) == String.trim(expected_output) @@ -97,6 +97,9 @@ defmodule ElixirAnalyzerTest do unused_available_test_suites = all_available_test_suites -- test_suites_referenced_in_config + unused_available_test_suites = + unused_available_test_suites -- [ElixirAnalyzer.TestSuite.Default] + unavailable_test_suites_referenced_in_config = test_suites_referenced_in_config -- all_available_test_suites diff --git a/test_data/two_fer/imperfect_solution/lib/two_fer.ex b/test_data/two_fer/imperfect_solution/lib/two_fer.ex index bd4dfe6a..d96a8770 100644 --- a/test_data/two_fer/imperfect_solution/lib/two_fer.ex +++ b/test_data/two_fer/imperfect_solution/lib/two_fer.ex @@ -1,4 +1,6 @@ defmodule TwoFer do + @someUnusedModuleAttribute 1 + @doc """ Two-fer or 2-fer is short for two for one. One for you and one for me. """