add tests and docs and use test_msg

Author: oxinabox

Project.toml

@@ -1,6 +1,6 @@
 name = "ChainRulesTestUtils"
 uuid = "cdddcdb0-9152-4a09-a978-84456f9df70a"
-version = "1.3.1"
+version = "1.4.0"
 
 [deps]
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"

docs/src/index.md

@@ -9,7 +9,13 @@ For information about ChainRules, including how to write rules, refer to the gen
 [![](https://img.shields.io/badge/docs-main-blue.svg)](https://JuliaDiff.github.io/ChainRulesCore.jl/dev)
 [![](https://img.shields.io/badge/docs-stable-blue.svg)](https://JuliaDiff.github.io/ChainRulesCore.jl/stable)
 
-## Canonical example
+## Testing Method Table Sensibility
+A basic feature of ChainRulesTestUtils is it's ability to check that the method table for `rrule` and `frule` remains sensible.
+This searches the method table for methods that should not exist and when it fails tells you where they were defined.
+By calling [`test_method_tables_sensibility`](@ref) ChainRulesTestUtils will check for things such as having attracted a rule to `DataType` rather than attaching it to a constructor.
+Basically all packages using ChainRulesTestUtils can use [`test_method_tables_sensibility`](@ref), as it is independent of what rules you have written.
+
+## Canonical example of testing frule and rrule
 
 Let's suppose a custom transformation has been defined
 ```jldoctest ex
@@ -274,3 +280,4 @@ Test.DefaultTestSet("test_rrule: abs on Float64", Any[], 5, false, false)
 
 This behavior can also be overridden globally by setting the environment variable `CHAINRULES_TEST_INFERRED` before ChainRulesTestUtils is loaded or by changing `ChainRulesTestUtils.TEST_INFERRED[]` from inside Julia.
 ChainRulesTestUtils can detect whether a test is run as part of [PkgEval](https://github.com/JuliaCI/PkgEval.jl) and in this case disables inference tests automatically. Packages can use [`@maybe_inferred`](@ref) to get the same behavior for other inference tests.
+

src/global_checks.jl

@@ -19,7 +19,7 @@ This would then actually define `rrule(::DataType, x)`. (or `UnionAll` if `Foo`
 was parametric, or `Union` if `Foo` was a type alias for a `Union`)
 """
 function test_method_tables_sensibility()
-    @testset "Make sure methods haven't been added to DataType/UnionAll/Union" begin
+    @testset "Sensible Constructors" begin
         # if someone wrote e.g. `rrule(::typeof(Foo), x)` rather than
         # `rrule(::Type{<:Foo}, x)` then that would actually define `rrule(::DataType, x)`
         # which would be bad. This test checks for that and fails if such a method exists.
@@ -32,12 +32,11 @@ function test_method_tables_sensibility()
                 nothing
             end
 
-            if function_type ∈ (DataType, UnionAll Union)
-                @error "Bad constructor rrule. typeof(T)` not `Type{T}`" method
-                @test false
-            end
+            @test_msg(
+                "Bad constructor rrule. typeof(T) used rather than `Type{T}`. $method",
+                function_type ∉ (DataType, UnionAll, Union)
+            )
         end
-
         # frule
         for method in methods(frule)
             function_type = if method.sig <: Tuple{Any, RuleConfig, Any, Type, Vararg}
@@ -47,10 +46,11 @@ function test_method_tables_sensibility()
             else
                 nothing
             end
-            
-            if function_type ∈ (DataType, UnionAll Union)
-                @error "Bad constructor frule. typeof(T)` not `Type{T}`" method
-                @test false
-            end
+
+            @test_msg(
+                "Bad constructor frule. typeof(T) used rather than `Type{T}`. $method",
+                function_type ∉ (DataType, UnionAll, Union)
+            )
         end
+    end
 end

test/global_checks.jl

@@ -1,4 +1,29 @@
+struct BadConstructor
+    x
+end
+
 @testset "global_checks.jl" begin
-    # Just check it doesn't error.
     test_method_tables_sensibility()
+
+    ChainRulesCore.rrule(::typeof(BadConstructor), x) = nothing
+    @test fails(test_method_tables_sensibility)
+    Base.delete_method(Base.which(Tuple{typeof(rrule), DataType, Any}))
+    test_method_tables_sensibility()  # make sure delete worked
+
+    ChainRulesCore.rrule(::RuleConfig, ::typeof(BadConstructor), x) = nothing
+    @test fails(test_method_tables_sensibility)
+    Base.delete_method(Base.which(Tuple{typeof(rrule), RuleConfig, DataType, Any}))
+    test_method_tables_sensibility()  # make sure delete worked
+
+
+
+    ChainRulesCore.frule(::Any, ::typeof(BadConstructor), x) = nothing
+    @test fails(test_method_tables_sensibility)
+    Base.delete_method(Base.which(Tuple{typeof(frule), Any, DataType, Any}))
+    test_method_tables_sensibility()  # make sure delete worked
+
+    ChainRulesCore.frule(::RuleConfig, ::Any, ::typeof(BadConstructor), x) = nothing
+    @test fails(test_method_tables_sensibility)
+    Base.delete_method(Base.which(Tuple{typeof(frule), RuleConfig, Any, DataType, Any}))
+    test_method_tables_sensibility()  # make sure delete worked
 end