Merge 5647ec6 into 08e3c2e

Author: NHDaly

stdlib/Test/src/logging.jl

@@ -170,14 +170,22 @@ pairwise; use `:any` to check that the pattern matches at least once somewhere
 in the sequence.)
 
 The most useful log pattern is a simple tuple of the form `(level,message)`.
-A different number of tuple elements may be used to match other log metadata,
+A different number of tuple elements may also be used to match other log metadata,
 corresponding to the arguments to passed to `AbstractLogger` via the
-`handle_message` function: `(level,message,module,group,id,file,line)`.
+`handle_message` function: `(level,message,module,group,id,file,line,kwargs)`.
 Elements which are present will be matched pairwise with the log record fields
 using `==` by default, with the special cases that `Symbol`s may be used for
 the standard log levels, and `Regex`s in the pattern will match string or
 Symbol fields using `occursin`.
 
+Individual pieces of a log record can be matched by passing a NamedTuple pattern,
+matching fields from log metadata, such as: `(;message="...")` or
+`(level=:info, kwargs=(;a=1, b=2))`.
+
+To match a log record's keyword arguments, you can use the kwargs field in the pattern,
+and provide a NamedTuple or Dict of key-value pairs. The supplied kwargs can be a partial
+set, and the log record's kwargs are matched against the provided pairs.
+
 # Examples
 
 Consider a function which logs a warning, and several debug messages:
@@ -219,6 +227,19 @@ patterns and set the `min_level` accordingly:
 
 If you want to test the absence of warnings (or error messages) in
 [`stderr`](@ref) which are not generated by `@warn`, see [`@test_nowarn`](@ref).
+
+If you only want to test for a given field, and don't care about the others, you can do
+this by passing a NamedTuple for the pattern. (Don't forget the `;` if you only have a
+single field).  For example, if you only want to match the message:
+
+    @test_logs (; message="hi") @info "hi"
+    @test_logs (; message="hi") @warn "hi"
+
+To test a log message's key=value pairs, you can use the `kwargs` field. Only supplied
+key,value pairs are tested:
+
+    @test_logs (level=:info, message="hi", kwargs=(; x=2)) @info("hi", x=2)
+    @test_logs (level=:info, message="hi", kwargs=(; x=2)) @info("hi", x=2, y=3)
 """
 macro test_logs(exs...)
     length(exs) >= 1 || throw(ArgumentError("""`@test_logs` needs at least one arguments.
@@ -285,12 +306,33 @@ logfield_contains(a, r::Regex) = occursin(r, a)
 logfield_contains(a::Symbol, r::Regex) = occursin(r, String(a))
 logfield_contains(a::LogLevel, b::Symbol) = a == parse_level(b)
 logfield_contains(a, b::Ignored) = true
+logfield_contains(a::NamedTuple, b) = logfield_contains(pairs(a), b)
+logfield_contains(a::NamedTuple, b::Ignored) = true  # method amibguity resolution
+function logfield_contains(a::Base.Pairs, pattern)
+    pattern = pairs(pattern)
+    for (k, bv) in pattern
+        av = get(a, k, :__test_logfield_key_not_found)
+        if av === :__test_logfield_key_not_found
+            return false
+        end
+        logfield_contains(av, bv) || return false
+    end
+    return true
+end
 
 function occursin(pattern::Tuple, r::LogRecord)
-    stdfields = (r.level, r.message, r._module, r.group, r.id, r.file, r.line)
+    stdfields = (r.level, r.message, r._module, r.group, r.id, r.file, r.line, r.kwargs)
     all(logfield_contains(f, p) for (f, p) in zip(stdfields[1:length(pattern)], pattern))
 end
 
+function occursin(pattern::NamedTuple, r::LogRecord)
+    fieldnames = keys(pattern)
+    stdfields = getfield.(Ref(r), fieldnames)
+    vals = values(pattern)
+    all(logfield_contains(f, p) for (f, p) in zip(stdfields, vals))
+end
+
+
 """
     @test_deprecated [pattern] expression
 

stdlib/Test/test/runtests.jl

@@ -1002,6 +1002,83 @@ erronce() = @error "an error" maxlog=1
     @test startswith(fails[4].value, "ErrorException")
 end
 
+@testset "@test_logs named tuple patterns" begin
+    @test_logs (;level=:info) @info("hi")
+    @test_logs (;message="hi") @info("hi")
+    @test_logs (;level=:info, message="hi") @info("hi")
+
+    fails = @testset NoThrowTestSet "test failures" begin
+        @test_logs (;level=:warn) @info("hi")
+        @test_logs (;message="hey") @info("hi")
+        @test_logs (;level=:info, message="hey") @info("hi")
+        @test_logs (;level=:warn, message="hi") @info("hi")
+    end
+    @test all(f->f isa Test.LogTestFailure, fails)
+
+    fails = @testset NoThrowTestSet "badly constructed patterns" begin
+        # Bad field names:
+        @test_logs (;nonexistant=:warn, message="hi") @info("hi")
+        @test_logs (;nonexistant=:warn) @info("hi")
+        # Forgot semicolon with single-field pattern:
+        @test_logs (message=2) @info("2")
+        # Wrong pattern type
+        @test_logs (:message => 2) @info("2")
+        @test_logs Dict(:message => 2) @info("2")
+    end
+    # These are all "Error During Test"s
+    @test all(f->!(f isa Test.LogTestFailure), fails)
+end
+
+@testset "@test_logs kwargs" begin
+    function foo1()
+        @info("hi", x=2, y=3)
+    end
+    @test_logs (;level=:info, kwargs=(;x=2, y=3)) foo1()
+    @test_logs (;level=:info, kwargs=(;x=2)) foo1()
+
+    @test_logs (;kwargs=(;x=2)) foo1()
+
+    # Test with the fully specified LogRecord pattern:
+    @test_logs (:info, "hi", @__MODULE__, Test.Ignored(), Test.Ignored(), r"", Test.Ignored(), (;y=3)) foo1()
+
+    # Test using Dict pattern instead of NamedTuple:
+    @test_logs (;kwargs=Dict(:x => 2)) foo1()
+    @test_logs (;kwargs=Dict(:x => 2, :y => 3)) foo1()
+
+    function foo2()
+        @info("hi", x=2, y=3)
+        @warn("bye", x=2, y=10)
+    end
+    @test_logs (;level=:info, kwargs=(;x=2, y=3)) match_mode=:any foo2()
+    @test_logs (;level=:info, kwargs=(;x=2)) match_mode=:any foo2()
+    @test_logs (;level=:warn, kwargs=(;x=2, y=10)) match_mode=:any foo2()
+    @test_logs (;level=:warn, kwargs=(;x=2)) match_mode=:any foo2()
+
+    # Both logs have x=2
+    @test_logs (;kwargs=(;x=2)) (;kwargs=(;x=2)) match_mode=:all foo2()
+    @test_logs (;kwargs=(;x=2)) (;kwargs=(;x=2, y=10)) match_mode=:all foo2()
+    @test_logs (;kwargs=(;x=2, y=3)) (;kwargs=(;x=2, y=10)) match_mode=:all foo2()
+
+    # Test failures
+    fails = @testset NoThrowTestSet "test failures" begin
+        function foo3()
+            @info("hi", x=2, y=3)
+        end
+
+        # Expecting log z=0, but not found:
+        @test_logs (;level=:info, kwargs=(;x=2, y=3, z=0)) foo3()
+        @test_logs (;level=:info, kwargs=(;z=0)) foo3()
+        # Wrong values for kwargs:
+        @test_logs (;level=:info, kwargs=(;x=1, y=3)) foo3()
+        @test_logs (;level=:info, kwargs=(;x=1)) foo3()
+        @test_logs (;kwargs=(;x=1, y=3)) foo3()
+        @test_logs (;kwargs=(;x=1)) foo3()
+        # Wrong message, correct kwargs:
+        @test_logs (;message="hey", kwargs=(;x=1)) foo3()
+    end
+    @test all(f->f isa Test.LogTestFailure, fails)
+end
+
 let code = quote
         function newfunc()
             42