Add separate analysis options file for tests (#5)

* Add separate analysis options file for tests

* Bump version, update changelog

* Update usage doc

* Remove no-magic-number ignore

* Explain `late` keyword disabled in test rules

* Add a more elaborate rationale to disable `late` lint in tests

Author: solid-yuriiprykhodko

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.0.6
+
+- Add a separate anayisis options file for tests
+
 ## 0.0.5
 
 - Remove the `sort_constructors_first` rule

README.md

@@ -18,6 +18,13 @@ And then include `solid_lints` into your project top-level `analysis_options.yam
 include: package:solid_lints/analysis_options.yaml
 ```
 
+Also you can use a specialized rule set designed for Dart tests.
+Add an `analysis_options.yaml` file under the `test/` directory, and include the ruleset:
+
+```yaml
+include: package:solid_lints/analysis_options_test.yaml
+```
+
 Then you can see suggestions in your IDE or you can run checks manually:
 
 ```bash

lib/analysis_options_test.yaml

@@ -0,0 +1,40 @@
+include: package:solid_lints/analysis_options.yaml
+
+dart_code_metrics:
+  rules:
+  
+# Late keyword is allowed in tests in order to enable the use of custom mocks and
+# fakes.
+
+# It has several benefits over its alternatives (see below):
+
+# - Allows initialising the mocks inside the `setUp` method.
+# - Allows resetting mocks by re-initialising them inside `setUp`
+# - Allows passing the mock inside functions that require non-null params,
+#   without any extra force-unwraps or null checks.
+# - Uninitialized test mocks are clearly traceable.
+# - Prodices minimal visual clutter.
+
+# Alternatives considered:
+
+# 1. Making the mocks `final` and non-nullable, and adding a `reset()` method
+#    to them, which would return the mock/fake to its initial state.
+#    - Works well with generated code from testing libraries like `mockito`.
+#    - It's less practical with hand-written mocks, where it's possible to add a
+#      piece of state and forget to reset it, which might lead to hard-to-trace
+#      errors. Usually re-instantiating a test mock simplifies its code and
+#      prevents such errors altogether, but that requires making the field
+#      non-final, as well as delegating its initialisation to the `setUp` method.
+# 2. Making the mocks nullable, and using `.?` access syntax.
+#    - In many cases will cause harder-to-trace testcase failures, if a mock was
+#      not initialised.
+#    - Does not allow passing the nullable mock into constructors/methods that
+#      require a non-nullable input.
+# 3. Making the mocks nullable, and adding null-checks in test code.
+#    - Will lead to significant code bloat, without much benefit, as a null mock
+#      will still usually lead to a failed test.
+# 4. Making the mocks nullable and using the "bang" operator (`!`):
+#    - In terms of behavior similar to `late`, but requires using the operator in
+#      many places inside the test code, adding uninformative visual noise.
+#    - The use of this operator is also discouraged by the main ruleset.
+    avoid-late-keyword: false

pubspec.yaml

@@ -1,6 +1,6 @@
 name: solid_lints
 description: Lints for Dart and Flutter based on software industry standards and best practices.
-version: 0.0.5
+version: 0.0.6
 homepage: https://github.com/solid-software/solid_lints/
 
 environment: