Zonemaster/Engine/Test/Basic.pm untested

filter: Statementstmt 0.0% 0 / 438 Branchbran 0.0% 0 / 150 Conditioncond 0.0% 0 / 104 MC/DCmcdc 0.0% 0 / 58 Subroutinesub 0.0% 0 / 24 Podpod 0.0% 0 / 11 totaltotal 0.0% 0 / 785 CC 76 SCAR 70.2
CC
76
Cov
0%
basic01
2256.0
basic02
272.0
all
42.0
CRAP 1120.2
1 package Zonemaster::Engine::Test::Basic;
2  
3 use v5.16.0;
4 use warnings;
5  
6 use version; our $VERSION = version->declare("v1.0.19");
7  
8 use Carp;
9 use List::MoreUtils qw[any none uniq];
10 use Locale::TextDomain qw[Zonemaster-Engine];
11 use Readonly;
12  
13 use Zonemaster::Engine::Profile;
14 use Zonemaster::Engine::Constants qw[:ip :name];
15 use Zonemaster::Engine::Test::Address;
16 use Zonemaster::Engine::Test::Syntax;
17 use Zonemaster::Engine::TestMethods;
18 use Zonemaster::Engine::Util qw[info name ns should_run_test];
19  
20 =head1 NAME
21  
22 Zonemaster::Engine::Test::Basic - Module implementing tests focused on basic zone functionality
23  
24 =head1 SYNOPSIS
25  
26 my @results = Zonemaster::Engine::Test::Basic->all( $zone );
27  
28 =head1 METHODS
29  
30 =over
31  
32 =item all()
33  
34 my @logentries = Zonamester::Engine::Test::Basic->all( $zone );
35  
36 Runs the test cases in the Basic test module.
37 A test is skipped if it is not included in
38 L<Zonemaster::Engine::Profile/"test_cases"> or if a previous test case has found
39 a condition that renders it superfluous.
40  
41 Takes a L<Zonemaster::Engine::Zone> object.
42  
43 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
44  
45 =back
46  
47 =cut
48  
49 sub all {
50 my ( $class, $zone ) = @_;
51  
52 my @results;
53  
54 if ( should_run_test( q{basic01} ) ) {
55 push @results, $class->basic01( $zone );
56 if ( none { $_->tag eq q{B01_CHILD_FOUND} } @results ) {
57 return @results;
58 }
59 }
60  
61 my $auth_response_soa = 0;
62 if ( should_run_test( q{basic02} ) ) {
63 push @results, $class->basic02( $zone );
64 $auth_response_soa = any { $_->tag eq q{B02_AUTH_RESPONSE_SOA} } @results;
65 }
66  
67 if ( should_run_test( q{basic03} ) ) {
68 # Perform BASIC3 if BASIC2 failed
69 if ( $auth_response_soa ) {
70 push @results,
71 _emit_log(
72 HAS_NAMESERVER_NO_WWW_A_TEST => {
73 zname => $zone->name,
74 }
75 );
76 }
77 else {
78 push @results, $class->basic03( $zone );
79 }
80 }
81  
82 return @results;
83 } ## end sub all
84  
85 =over
86  
87 =item can_continue()
88  
89 my $bool = can_continue( $zone, @logentry_array );
90  
91 Determines if further evaluation of the given zone is possible based on the results from the Basic Test Cases.
92  
93 Takes a L<Zonemaster::Engine::Zone> object and an array of L<Zonemaster::Engine::Logger::Entry> objects.
94  
95 Returns a boolean.
96  
97 =back
98  
99 =cut
100  
101 sub can_continue {
102 my ( $class, $zone, @results ) = @_;
103  
104 if ( should_run_test( 'basic02' ) ) {
105 my %tag = map { $_->tag => 1 } @results;
106 return !$tag{B02_NO_DELEGATION} && $tag{B02_AUTH_RESPONSE_SOA};
107 }
108  
109 return 1;
110 }
111  
112 =over
113  
114 =item metadata()
115  
116 my $hash_ref = metadata();
117  
118 Returns a reference to a hash, the keys of which are the names of all Test Cases in the module, and the corresponding values are references to
119 an array containing all the message tags that the Test Case can use in L<log entries|Zonemaster::Engine::Logger::Entry>.
120  
121 =back
122  
123 =cut
124  
125 sub metadata {
126 my ( $class ) = @_;
127  
128 return {
129 basic01 => [
130 qw(
131 B01_CHILD_IS_ALIAS
132 B01_CHILD_FOUND
133 B01_INCONSISTENT_ALIAS
134 B01_INCONSISTENT_DELEGATION
135 B01_NO_CHILD
136 B01_PARENT_DISREGARDED
137 B01_PARENT_FOUND
138 B01_PARENT_NOT_FOUND
139 B01_PARENT_UNDETERMINED
140 B01_ROOT_HAS_NO_PARENT
141 B01_SERVER_ZONE_ERROR
142 TEST_CASE_END
143 TEST_CASE_START
144 )
145 ],
146 basic02 => [
147 qw(
148 B02_AUTH_RESPONSE_SOA
149 B02_NO_DELEGATION
150 B02_NO_WORKING_NS
151 B02_NS_BROKEN
152 B02_NS_NOT_AUTH
153 B02_NS_NO_IP_ADDR
154 B02_NS_NO_RESPONSE
155 B02_UNEXPECTED_RCODE
156 IPV4_DISABLED
157 IPV6_DISABLED
158 IPV4_ENABLED
159 IPV6_ENABLED
160 TEST_CASE_END
161 TEST_CASE_START
162 )
163 ],
164 basic03 => [
165 qw(
166 A_QUERY_NO_RESPONSES
167 HAS_A_RECORDS
168 IPV4_DISABLED
169 IPV4_ENABLED
170 IPV6_DISABLED
171 IPV6_ENABLED
172 NO_A_RECORDS
173 TEST_CASE_END
174 TEST_CASE_START
175 )
176 ],
177 };
178 } ## end sub metadata
179  
180 Readonly my %TAG_DESCRIPTIONS => (
181 BASIC01 => sub {
182 __x # BASIC:BASIC01
183 'The domain must have a parent domain';
184 },
185 BASIC02 => sub {
186 __x # BASIC:BASIC02
187 'The domain must have at least one working name server';
188 },
189 BASIC03 => sub {
190 __x # BASIC:BASIC03
191 'The Broken but functional test';
192 },
193 A_QUERY_NO_RESPONSES => sub {
194 __x # BASIC:A_QUERY_NO_RESPONSES
195 'Nameservers did not respond to A query.';
196 },
197 B01_CHILD_IS_ALIAS => sub {
198 __x # BASIC:B01_CHILD_IS_ALIAS
199 '"{domain_child}" is not a zone. It is an alias for "{domain_target}". Run a test for "{domain_target}" instead. '
200 . 'Returned from name servers "{ns_list}".', @_;
201 },
202 B01_CHILD_FOUND => sub {
203 __x # BASIC:B01_CHILD_FOUND
204 'The zone "{domain}" is found.', @_;
205 },
206 B01_INCONSISTENT_ALIAS => sub {
207 __x # BASIC:B01_INCONSISTENT_ALIAS
208 'The alias for "{domain}" is inconsistent between name servers.', @_;
209 },
210 B01_INCONSISTENT_DELEGATION => sub {
211 __x # BASIC:B01_INCONSISTENT_DELEGATION
212 'The name servers for parent zone "{domain_parent}" give inconsistent delegation of "{domain_child}". '
213 . 'Returned from name servers "{ns_list}".', @_;
214 },
215 B01_NO_CHILD => sub {
216 __x # BASIC:B01_NO_CHILD
217 '"{domain_child}" does not exist as a DNS zone. Try to test "{domain_super}" instead.', @_;
218 },
219 B01_PARENT_DISREGARDED => sub {
220 __x # BASIC:B01_PARENT_DISREGARDED
221 'This is a test of an undelegated domain so finding the parent zone is disregarded.';
222 },
223 B01_PARENT_FOUND => sub {
224 __x # BASIC:B01_PARENT_FOUND
225 'The parent zone is "{domain}" as returned from name servers "{ns_list}".', @_;
226 },
227 B01_PARENT_NOT_FOUND => sub {
228 __x # BASIC:B01_PARENT_NOT_FOUND
229 'The parent zone cannot be found.';
230 },
231 B01_PARENT_UNDETERMINED => sub {
232 __x # BASIC:B01_PARENT_UNDETERMINED
233 'The parent zone cannot be determined on name servers "{ns_list}".', @_;
234 },
235 B01_ROOT_HAS_NO_PARENT => sub {
236 __x # BASIC:B01_ROOT_HAS_NO_PARENT
237 'This is a test of the root zone which has no parent zone.';
238 },
239 B01_SERVER_ZONE_ERROR => sub {
240 __x # BASIC:B01_SERVER_ZONE_ERROR
241 'Unexpected response on query for "{query_name}" with query type "{rrtype}" to "{ns}".', @_;
242 },
243 B02_AUTH_RESPONSE_SOA => sub {
244 __x # BASIC:B02_AUTH_RESPONSE_SOA
245 'Authoritative answer on SOA query for "{domain}" is returned by name servers "{ns_list}".', @_;
246 },
247 B02_NO_DELEGATION => sub {
248 __x # BASIC:B02_NO_DELEGATION
249 'There is no delegation (name servers) for "{domain}" which means it does not exist as a zone.', @_;
250 },
251 B02_NO_WORKING_NS => sub {
252 __x # BASIC:B02_NO_WORKING_NS
253 'There is no working name server for "{domain}" so it is unreachable.', @_;
254 },
255 B02_NS_BROKEN => sub {
256 __x # BASIC:B02_NS_BROKEN
257 'Broken response from name server "{ns}" on an SOA query.', @_;
258 },
259 B02_NS_NOT_AUTH => sub {
260 __x # BASIC:B02_NS_NOT_AUTH
261 'Name server "{ns}" does not give an authoritative answer on an SOA query.', @_;
262 },
263 B02_NS_NO_IP_ADDR => sub {
264 __x # BASIC:B02_NS_NO_IP_ADDR
265 'Name server "{nsname}" cannot be resolved into an IP address.', @_;
266 },
267 B02_NS_NO_RESPONSE => sub {
268 __x # BASIC:B02_NS_NO_RESPONSE
269 'Name server "{ns}" does not respond to an SOA query.', @_;
270 },
271 B02_UNEXPECTED_RCODE => sub {
272 __x # BASIC:B02_UNEXPECTED_RCODE
273 'Name server "{ns}" responds with an unexpected RCODE name ("{rcode}") on an SOA query.', @_;
274 },
275 DOMAIN_NAME_LABEL_TOO_LONG => sub {
276 __x # BASIC:DOMAIN_NAME_LABEL_TOO_LONG
277 'Domain name ({domain}) has a label ({label}) too long ({dlength}/{max}).', @_;
278 },
279 DOMAIN_NAME_TOO_LONG => sub {
280 __x # BASIC:DOMAIN_NAME_TOO_LONG
281 'Domain name is too long ({fqdnlength}/{max}).', @_;
282 },
283 DOMAIN_NAME_ZERO_LENGTH_LABEL => sub {
284 __x # BASIC:DOMAIN_NAME_ZERO_LENGTH_LABEL
285 'Domain name ({domain}) has a zero-length label.', @_;
286 },
287 HAS_A_RECORDS => sub {
288 __x # BASIC:HAS_A_RECORDS
289 'Nameserver {ns} returned "A" record(s) for {domain}.', @_;
290 },
291 HAS_NAMESERVER_NO_WWW_A_TEST => sub {
292 __x # BASIC:HAS_NAMESERVER_NO_WWW_A_TEST
293 'Functional nameserver found. "A" query for www.{zname} test skipped.', @_;
294 },
295 IPV4_DISABLED => sub {
296 __x # BASIC:IPV4_DISABLED
297 'IPv4 is disabled, not sending "{rrtype}" query to {ns}.', @_;
298 },
299 IPV4_ENABLED => sub {
300 __x # BASIC:IPV4_ENABLED
301 'IPv4 is enabled, can send "{rrtype}" query to {ns}.', @_;
302 },
303 IPV6_DISABLED => sub {
304 __x # BASIC:IPV6_DISABLED
305 'IPv6 is disabled, not sending "{rrtype}" query to {ns}.', @_;
306 },
307 IPV6_ENABLED => sub {
308 __x # BASIC:IPV6_ENABLED
309 'IPv6 is enabled, can send "{rrtype}" query to {ns}.', @_;
310 },
311 NO_A_RECORDS => sub {
312 __x # BASIC:NO_A_RECORDS
313 'Nameserver {ns} did not return "A" record(s) for {domain}.', @_;
314 },
315 TEST_CASE_END => sub {
316 __x # BASIC:TEST_CASE_END
317 'TEST_CASE_END {testcase}.', @_;
318 },
319 TEST_CASE_START => sub {
320 __x # BASIC:TEST_CASE_START
321 'TEST_CASE_START {testcase}.', @_;
322 },
323 );
324  
325 =over
326  
327 =item tag_descriptions()
328  
329 my $hash_ref = tag_descriptions();
330  
331 Used by the L<built-in translation system|Zonemaster::Engine::Translator>.
332  
333 Returns a reference to a hash, the keys of which are the message tags and the corresponding values are strings (message IDs).
334  
335 =back
336  
337 =cut
338  
339 sub tag_descriptions {
340 return \%TAG_DESCRIPTIONS;
341 }
342  
343 =over
344  
345 =item version()
346  
347 my $version_string = version();
348  
349 Returns a string containing the version of the current module.
350  
351 =back
352  
353 =cut
354  
355 sub version {
356 return "$Zonemaster::Engine::Test::Basic::VERSION";
357 }
358  
359 =head1 INTERNAL METHODS
360  
361 =over
362  
363 =item _emit_log()
364  
365 my $log_entry = _emit_log( $message_tag_string, $hash_ref );
366  
367 Adds a message to the L<logger|Zonemaster::Engine::Logger> for this module.
368 See L<Zonemaster::Engine::Logger::Entry/add($tag, $argref, $module, $testcase)> for more details.
369  
370 Takes a string (message tag) and a reference to a hash (arguments).
371  
372 Returns a L<Zonemaster::Engine::Logger::Entry> object.
373  
374 =back
375  
376 =cut
377  
378 sub _emit_log { my ( $tag, $argref ) = @_; return Zonemaster::Engine->logger->add( $tag, $argref, 'Basic' ); }
379  
380 =over
381  
382 =item _ip_disabled_message()
383  
384 my $bool = _ip_disabled_message( $logentry_array_ref, $ns, @query_type_array );
385  
386 Checks if the IP version of a given name server is allowed to be queried. If not, it adds a logging message and returns true. Else, it returns false.
387 Used in Test Cases in combination with L<_ip_enabled_message()>.
388  
389 Takes a reference to an array of L<Zonemaster::Engine::Logger::Entry> objects, a L<Zonemaster::Engine::Nameserver> object and an array of strings (query type).
390  
391 Returns a boolean.
392  
393 =back
394  
395 =cut
396  
397 sub _ip_disabled_message {
398 my ( $results_array, $ns, @rrtypes ) = @_;
399  
400 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv4}) and $ns->address->version == $IP_VERSION_4 ) {
401 push @$results_array, map {
402 _emit_log(
403 IPV4_DISABLED => {
404 ns => $ns->string,
405 rrtype => $_,
406 }
407 )
408 } @rrtypes;
409 return 1;
410 }
411  
412 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv6}) and $ns->address->version == $IP_VERSION_6 ) {
413 push @$results_array, map {
414 _emit_log(
415 IPV6_DISABLED => {
416 ns => $ns->string,
417 rrtype => $_,
418 }
419 )
420 } @rrtypes;
421 return 1;
422 }
423 return 0;
424 }
425  
426 =over
427  
428 =item _ip_enabled_message()
429  
430 _ip_enabled_message( $array_ref, $ns, @query_type_array );
431  
432 Adds a logging message if the IP version of a given name server is allowed to be queried.
433 Used in Test Cases in combination with L<_ip_disabled_message()>.
434  
435 Takes a reference to an array of L<Zonemaster::Engine::Logger::Entry> objects, a L<Zonemaster::Engine::Nameserver> object and an array of strings (query type).
436  
437 =back
438  
439 =cut
440  
441 sub _ip_enabled_message {
442 my ( $results_array, $ns, @rrtypes ) = @_;
443  
444 if ( Zonemaster::Engine::Profile->effective->get(q{net.ipv4}) and $ns->address->version == $IP_VERSION_4 ) {
445 push @$results_array, map {
446 _emit_log(
447 IPV4_ENABLED => {
448 ns => $ns->string,
449 rrtype => $_,
450 }
451 )
452 } @rrtypes;
453 }
454  
455 if ( Zonemaster::Engine::Profile->effective->get(q{net.ipv6}) and $ns->address->version == $IP_VERSION_6 ) {
456 push @$results_array, map {
457 _emit_log(
458 IPV6_ENABLED => {
459 ns => $ns->string,
460 rrtype => $_,
461 }
462 )
463 } @rrtypes;
464 }
465 }
466  
467 =head1 TESTS
468  
469 =over
470  
471 =item basic01()
472  
473 my @logentry_array = basic01( $zone );
474  
475 Runs the L<Basic01 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Basic-TP/basic01.md>.
476  
477 Takes a L<Zonemaster::Engine::Zone> object.
478  
479 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
480  
481 =back
482  
483 =cut
484  
485 sub basic01 {
486 my ( $class, $zone ) = @_;
487 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Basic01';
488  
489 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
490  
491 if ( $zone->name eq '.' ) {
492 push @results,
493 _emit_log(
494 B01_CHILD_FOUND => {
495 domain => $zone->name->string
496 }
497 );
498  
499 push @results,
500 _emit_log(
501 B01_ROOT_HAS_NO_PARENT => {}
502 );
503  
504 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
505 }
506  
507 if ( Zonemaster::Engine::Recursor->has_fake_addresses( $zone->name->string ) ) {
508 push @results,
509 _emit_log(
510 B01_CHILD_FOUND => {
511 domain => $zone->name->string
512 }
513 );
514  
515 push @results,
516 _emit_log(
517 B01_PARENT_DISREGARDED => {}
518 );
519  
520 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
521 }
522  
523 my %handled_servers;
524 my %parent_found;
525 my %delegation_found;
526 my %aa_nxdomain;
527 my %aa_soa;
528 my %aa_cname;
529 my %cname_with_referral;
530 my %aa_dname;
531 my %aa_nodata;
532  
533 my %rrs_ns;
534 my $type_soa = q{SOA};
535 my $type_ns = q{NS};
536 my $type_dname = q{DNAME};
537  
538 my %all_servers = ( '.' => [ Zonemaster::Engine::Recursor->root_servers ] );
539 my @all_labels = ( '.' );
540 my @remaining_labels = ( '.' );
541  
542 while ( my $zone_name = shift @remaining_labels ) {
543 my @remaining_servers = @{ $all_servers{$zone_name} };
544  
545 CUR_SERVERS:
546 while ( my $ns = shift @remaining_servers ) {
547 next CUR_SERVERS if grep { $_ eq $ns->address->short } @{ $handled_servers{$zone_name} };
548 push @{ $handled_servers{$zone_name} }, $ns->address->short;
549  
550 if ( _ip_disabled_message( \@results, $ns, ( $type_soa, $type_ns, $type_dname ) ) ) {
551 next CUR_SERVERS;
552 }
553 _ip_enabled_message( \@results, $ns, ( $type_soa, $type_ns, $type_dname ) );
554  
555 my $p_soa = $ns->query( $zone_name, $type_soa );
556  
557 unless ( $p_soa and $p_soa->rcode eq 'NOERROR' and $p_soa->aa and scalar $p_soa->get_records_for_name( $type_soa, $zone_name, 'answer' ) == 1 ) {
558 push @results,
559 _emit_log(
560 B01_SERVER_ZONE_ERROR => {
561 query_name => $zone_name,
562 rrtype => $type_soa,
563 ns => $ns->string
564 }
565 );
566  
567 next CUR_SERVERS;
568 }
569  
570 my $p_ns = $ns->query( $zone_name, $type_ns );
571  
572 unless ( $p_ns and $p_ns->rcode eq 'NOERROR' and $p_ns->aa and scalar $p_ns->get_records( $type_ns, 'answer' ) > 0
573 and scalar $p_ns->get_records( $type_ns, 'answer' ) == scalar $p_ns->get_records_for_name( $type_ns, $zone_name, 'answer' )
574 ) {
575 push @results,
576 _emit_log(
577 B01_SERVER_ZONE_ERROR => {
578 query_name => $zone_name,
579 rrtype => $type_ns,
580 ns => $ns->string
581 }
582 );
583  
584 next CUR_SERVERS;
585 }
586  
587 $rrs_ns{name( $_->nsdname )->string} = [] for $p_ns->get_records_for_name( $type_ns, $zone_name, 'answer' );
588  
589 foreach my $rr ( $p_ns->get_records( 'A', 'additional' ), $p_ns->get_records( 'AAAA', 'additional' ) ) {
590 if ( exists $rrs_ns{name( $rr->owner )->string} ) {
591 push @{ $rrs_ns{name( $rr->owner )->string} }, $rr->address;
592 }
593 }
594  
595 foreach my $ns_name ( keys %rrs_ns ) {
596 unless ( scalar @{ $rrs_ns{$ns_name} } ) {
597 my $p_a = Zonemaster::Engine::Recursor->recurse( $ns_name, q{A} );
598  
599 if ( $p_a and $p_a->rcode eq 'NOERROR' ) {
600 push @{ $rrs_ns{$ns_name} }, $_->address for $p_a->get_records_for_name( 'A', $ns_name );
601 }
602  
603 my $p_aaaa = Zonemaster::Engine::Recursor->recurse( $ns_name, q{AAAA} );
604  
605 if ( $p_aaaa and $p_aaaa->rcode eq 'NOERROR' ) {
606 push @{ $rrs_ns{$ns_name} }, $_->address for $p_aaaa->get_records_for_name( 'AAAA', $ns_name );
607 }
608 }
609  
610 foreach my $ns_ip ( @{ $rrs_ns{$ns_name} } ) {
611 unless ( grep { $_ eq $ns_ip } @{ $handled_servers{$zone_name} } ) {
612 push @{ $all_servers{$zone_name} }, ns( $ns_name, $ns_ip );
613  
614 unless ( grep { $_ eq $zone_name } @all_labels ) {
615 push @remaining_labels, $zone_name;
616 push @all_labels, $zone_name;
617 }
618 }
619 }
620 }
621  
622 my $intermediate_query_name = name( $zone_name );
623 my $loop_zone_name = $zone_name;
624 my $loop_counter = 0;
625  
626 LOOP:
627 while() {
628 $loop_counter += 1;
629 if ( $loop_counter >= 1000 ) {
630 Zonemaster::Engine->logger->add( LOOP_PROTECTION => {
631 caller => 'Zonemaster::Engine::Test::Basic->basic01',
632 child_zone_name => $zone->name,
633 name => $loop_zone_name,
634 intermediate_query_name => $intermediate_query_name
635 }
636 );
637  
638 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
639 }
640  
641 last if scalar @{ $intermediate_query_name->labels } >= scalar @{ $zone->name->labels };
642 $intermediate_query_name = name( @{ $zone->name->labels }[ ( scalar @{ $zone->name->labels } - scalar @{ $intermediate_query_name->labels } ) - 1 ] . '.' . $intermediate_query_name->string );
643  
644 $p_soa = $ns->query( $intermediate_query_name, $type_soa );
645  
646 unless ( $p_soa ) {
647 push @results,
648 _emit_log(
649 B01_SERVER_ZONE_ERROR => {
650 query_name => $intermediate_query_name,
651 rrtype => $type_soa,
652 ns => $ns->string
653 }
654 );
655  
656 next CUR_SERVERS;
657 }
658  
659 if ( $p_soa->rcode eq 'NOERROR' and $p_soa->aa and scalar $p_soa->get_records_for_name( $type_soa, $intermediate_query_name, 'answer' ) == 1 ) {
660 if ( $intermediate_query_name->string eq $zone->name->string ) {
661 push @{ $parent_found{$loop_zone_name} }, $ns->string;
662 push @{ $aa_soa{$loop_zone_name} }, $ns->string;
663 }
664 else {
665 $p_ns = $ns->query( $intermediate_query_name, $type_ns );
666  
667 unless ( $p_ns and $p_ns->rcode eq 'NOERROR' and $p_ns->aa and scalar $p_ns->get_records( $type_ns, 'answer' ) > 0
668 and scalar $p_ns->get_records( $type_ns, 'answer' ) == scalar $p_ns->get_records_for_name( $type_ns, $intermediate_query_name, 'answer' )
669 ) {
670 push @results,
671 _emit_log(
672 B01_SERVER_ZONE_ERROR => {
673 query_name => $intermediate_query_name,
674 rrtype => $type_ns,
675 ns => $ns->string
676 }
677 );
678  
679 next CUR_SERVERS;
680 }
681  
682 my %rrs_ns_bis;
683 $rrs_ns_bis{name( $_->nsdname )->string} = [] for $p_ns->get_records_for_name( $type_ns, $intermediate_query_name, 'answer' );
684  
685 foreach my $rr ( $p_ns->get_records( 'A', 'additional' ), $p_ns->get_records( 'AAAA', 'additional' ) ) {
686 if ( exists $rrs_ns_bis{name( $rr->owner )->string} ) {
687 push @{ $rrs_ns_bis{name( $rr->owner )->string} }, $rr->address;
688 }
689 }
690  
691 foreach my $ns_name ( keys %rrs_ns_bis ) {
692 unless ( scalar @{ $rrs_ns_bis{$ns_name} } > 0 ) {
693 my $p_a = Zonemaster::Engine::Recursor->recurse( $ns_name, q{A} );
694  
695 if ( $p_a and $p_a->rcode eq 'NOERROR' ) {
696 push @{ $rrs_ns_bis{$ns_name} }, $_->address for $p_a->get_records_for_name( 'A', $ns_name );
697 }
698  
699 my $p_aaaa = Zonemaster::Engine::Recursor->recurse( $ns_name, q{AAAA} );
700  
701 if ( $p_aaaa and $p_aaaa->rcode eq 'NOERROR' ) {
702 push @{ $rrs_ns_bis{$ns_name} }, $_->address for $p_aaaa->get_records_for_name( 'AAAA', $ns_name );
703 }
704 }
705  
706 foreach my $ns_ip ( @{ $rrs_ns_bis{$ns_name} } ) {
707 unless ( grep { $_ eq $ns_ip } @{ $handled_servers{$intermediate_query_name} } ) {
708 push @{ $all_servers{$intermediate_query_name} }, ns( $ns_name, $ns_ip );
709  
710 unless ( grep { $_ eq $intermediate_query_name } @all_labels ) {
711 push @remaining_labels, $intermediate_query_name;
712 push @all_labels, $intermediate_query_name;
713 }
714 }
715 }
716 }
717  
718 $loop_zone_name = $intermediate_query_name->string;
719 next LOOP;
720 }
721 }
722 elsif ( $p_soa->rcode eq 'NXDOMAIN' and $p_soa->aa ) {
723 push @{ $parent_found{$loop_zone_name} }, $ns->string;
724 push @{ $aa_nxdomain{$loop_zone_name} }, $ns->string;
725 }
726 elsif ( $p_soa->is_redirect and scalar $p_soa->get_records_for_name( $type_ns, $intermediate_query_name, 'authority' ) ) {
727 if ( $intermediate_query_name->string eq $zone->name->string ) {
728 push @{ $parent_found{$loop_zone_name} }, $ns->string;
729 push @{ $delegation_found{$loop_zone_name} }, $ns->string;
730 }
731 else {
732 my %rrs_ns_bis;
733 $rrs_ns_bis{name( $_->nsdname )->string} = [] for $p_soa->get_records_for_name( $type_ns, $intermediate_query_name, 'authority' );
734  
735 foreach my $rr ( $p_soa->get_records( 'A', 'additional' ), $p_soa->get_records( 'AAAA', 'additional' ) ) {
736 if ( exists $rrs_ns_bis{name( $rr->owner )->string} ) {
737 push @{ $rrs_ns_bis{name( $rr->owner )->string} }, $rr->address;
738 }
739 }
740  
741 foreach my $ns_name ( keys %rrs_ns_bis ) {
742 unless ( scalar @{ $rrs_ns_bis{$ns_name} } > 0 ) {
743 my $p_a = Zonemaster::Engine::Recursor->recurse( $ns_name, q{A} );
744  
745 if ( $p_a and $p_a->rcode eq 'NOERROR' ) {
746 push @{ $rrs_ns_bis{$ns_name} }, $_->address for $p_a->get_records_for_name( 'A', $ns_name );
747 }
748  
749 my $p_aaaa = Zonemaster::Engine::Recursor->recurse( $ns_name, q{AAAA} );
750  
751 if ( $p_aaaa and $p_aaaa->rcode eq 'NOERROR' ) {
752 push @{ $rrs_ns_bis{$ns_name} }, $_->address for $p_aaaa->get_records_for_name( 'AAAA', $ns_name );
753 }
754 }
755  
756 foreach my $ns_ip ( @{ $rrs_ns_bis{$ns_name} } ) {
757 unless ( grep { $_ eq $ns_ip } @{ $handled_servers{$intermediate_query_name} } ) {
758 push @{ $all_servers{$intermediate_query_name} }, ns( $ns_name, $ns_ip );
759  
760 unless ( grep { $_ eq $intermediate_query_name } @all_labels ) {
761 push @remaining_labels, $intermediate_query_name;
762 push @all_labels, $intermediate_query_name;
763 }
764 }
765 }
766 }
767 }
768 }
769 elsif ( $p_soa->rcode eq 'NOERROR' and $p_soa->aa ) {
770 next LOOP if $intermediate_query_name->string ne $zone->name->string;
771  
772 if ( scalar $p_soa->get_records_for_name( 'CNAME', $zone->name, 'answer' ) ) {
773 push @{ $parent_found{$loop_zone_name} }, $ns->string;
774 push @{ $aa_cname{$loop_zone_name} }, $ns->string;
775 }
776 else {
777 my $p_dname = $ns->query( $zone->name->string , $type_dname );
778  
779 if ( $p_dname and $p_dname->aa and $p_dname->rcode eq 'NOERROR' and scalar $p_dname->get_records_for_name( $type_dname, $zone->name, 'answer' ) == 1 ) {
780 push @{ $parent_found{$loop_zone_name} }, $ns->string;
781 push @{ $aa_dname{($p_dname->get_records_for_name( $type_dname, $zone->name, 'answer' ))[0]->dname}{$loop_zone_name} }, $ns->string;
782 }
783 else {
784 push @{ $parent_found{$loop_zone_name} }, $ns->string;
785 push @{ $aa_nodata{$loop_zone_name} }, $ns->string;
786 }
787 }
788 }
789 elsif ( $p_soa->is_redirect and scalar $p_soa->get_records_for_name( 'CNAME', $zone->name, 'answer' ) ) {
790 push @{ $parent_found{$loop_zone_name} }, $ns->string;
791 push @{ $cname_with_referral{$loop_zone_name} }, $ns->string;
792 }
793 else {
794 push @results,
795 _emit_log(
796 B01_SERVER_ZONE_ERROR => {
797 query_name => $intermediate_query_name,
798 rrtype => $type_soa,
799 ns => $ns->string
800 }
801 );
802 }
803  
804 next CUR_SERVERS;
805 }
806 }
807 }
808  
809 if ( scalar keys %parent_found ) {
810 push @results, map {
811 _emit_log(
812 B01_PARENT_FOUND => {
813 domain => $_,
814 ns_list => join( q{;}, uniq sort @{ $parent_found{$_} } )
815 }
816 )
817 } keys %parent_found;
818  
819 if ( scalar keys %parent_found > 1 ) {
820 push @results,
821 _emit_log(
822 B01_PARENT_UNDETERMINED => {
823 ns_list => join( q{;}, uniq sort map { @{ $parent_found{$_} } } keys %parent_found )
824 }
825 );
826 }
827 }
828 else {
829 push @results,
830 _emit_log(
831 B01_PARENT_NOT_FOUND => {}
832 );
833 }
834  
835 if ( scalar keys %delegation_found or scalar keys %aa_soa ) {
836 push @results,
837 _emit_log(
838 B01_CHILD_FOUND => {
839 domain => $zone->name->string
840 }
841 );
842  
843 unless ( Zonemaster::Engine::Recursor->has_fake_addresses( $zone->name->string ) ) {
844 my @hash_refs = ( \%aa_nxdomain, \%aa_cname, \%cname_with_referral, values %aa_dname, \%aa_nodata );
845 foreach my $parent_domain ( uniq map { keys %$_ } @hash_refs ) {
846 push @results,
847 _emit_log(
848 B01_INCONSISTENT_DELEGATION => {
849 domain_parent => $parent_domain,
850 domain_child => $zone->name->string,
851 ns_list => join( q{;}, uniq sort map { @{ $_->{$parent_domain} // [] } } @hash_refs )
852 }
853 );
854 }
855 }
856 }
857  
858 if ( not scalar keys %delegation_found and not scalar keys %aa_soa ) {
859 if ( Zonemaster::Engine::Recursor->has_fake_addresses( $zone->name->string ) ) {
860 push @results,
861 _emit_log(
862 B01_CHILD_NOT_EXIST => {
863 domain => $zone->name->string
864 }
865 );
866 }
867 else {
868 push @results,
869 _emit_log(
870 B01_NO_CHILD => {
871 domain_child => $zone->name->string,
872 domain_super => $zone->name->next_higher
873 }
874 );
875 }
876 }
877  
878 if ( scalar keys %aa_dname ) {
879 push @results, map { my $target = $_;
880 _emit_log(
881 B01_CHILD_IS_ALIAS => {
882 domain_child => $zone->name->string,
883 domain_target => $target,
884 ns_list => join( q{;}, uniq sort map { @{ $aa_dname{$target}{$_} } } keys %{ $aa_dname{$target} } )
885 }
886 )
887 } keys %aa_dname;
888  
889 if ( scalar keys %aa_dname > 1 ) {
890 push @results,
891 _emit_log(
892 B01_INCONSISTENT_ALIAS => {
893 domain => $zone->name->string
894 }
895 );
896 }
897 }
898  
899 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
900 } ## end sub basic01
901  
902 =over
903  
904 =item basic02()
905  
906 my @logentry_array = basic02( $zone );
907  
908 Runs the L<Basic02 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Basic-TP/basic02.md>.
909  
910 Takes a L<Zonemaster::Engine::Zone> object.
911  
912 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
913  
914 =back
915  
916 =cut
917  
918 sub basic02 {
919 my ( $class, $zone ) = @_;
920 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Basic02';
921  
922 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
923  
924 my $query_type = q{SOA};
925  
926 my %auth_response_soa;
927 my %ns_broken;
928 my %ns_not_auth;
929 my %ns_cant_resolve;
930 my %ns_no_response;
931 my %unexpected_rcode;
932  
933 my @ns_names = @{ Zonemaster::Engine::TestMethods->method2( $zone ) };
934 my @ns = @{ Zonemaster::Engine::TestMethods->method4( $zone ) };
935  
936 if ( not scalar @ns_names ) {
937 push @results,
938 _emit_log(
939 B02_NO_DELEGATION => {
940 domain => $zone->name
941 }
942 );
943  
944 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
945 }
946  
947 if ( not scalar @ns ) {
948 my %found_ip;
949 my @ns_ips = @{ $zone->glue_addresses };
950  
951 foreach my $ns_name ( @ns_names ) {
952 $found_ip{$ns_name->string} = 0;
953  
954 foreach my $rr ( @ns_ips ) {
955 if ( $rr->owner eq $ns_name ) {
956 $found_ip{$ns_name->string} = 1;
957 push @ns, Zonemaster::Engine::Nameserver->new({ name => $ns_name, address => $rr->address });
958 }
959 }
960 }
961  
962 foreach my $ns_name ( keys %found_ip ) {
963 if ( $found_ip{$ns_name} == 0 ) {
964 $ns_cant_resolve{$ns_name} = 1;
965 }
966 }
967 }
968  
969 foreach my $ns ( @ns ) {
970 if ( _ip_disabled_message( \@results, $ns, $query_type ) ) {
971 next;
972 }
973 _ip_enabled_message( \@results, $ns, $query_type );
974  
975 my $p = $ns->query( $zone->name, $query_type );
976  
977 if ( $p ) {
978 if ( $p->rcode ne 'NOERROR' ) {
979 $unexpected_rcode{$ns->string} = $p->rcode;
980 }
981 elsif ( not $p->aa ) {
982 $ns_not_auth{$ns->string} = 1;
983 }
984 else {
985 if ( $p->get_records_for_name( $query_type, $zone->name, q{answer} ) ) {
986 $auth_response_soa{$ns->string} = 1;
987 }
988 else {
989 $ns_broken{$ns->string} = 1;
990 }
991 }
992 }
993 else {
994 $ns_no_response{$ns->string} = 1;
995 }
996 }
997  
998 if ( scalar keys %auth_response_soa ) {
999 push @results,
1000 _emit_log(
1001 B02_AUTH_RESPONSE_SOA => {
1002 domain => $zone->name,
1003 ns_list => join( q{;}, sort keys %auth_response_soa )
1004 }
1005 );
1006 }
1007 else {
1008 push @results,
1009 _emit_log(
1010 B02_NO_WORKING_NS => {
1011 domain => $zone->name
1012 }
1013 );
1014  
1015 if ( scalar keys %ns_broken ) {
1016 push @results, map {
1017 _emit_log(
1018 B02_NS_BROKEN => {
1019 ns => $_
1020 }
1021 )
1022 } keys %ns_broken;
1023 }
1024  
1025 if ( scalar keys %ns_not_auth ) {
1026 push @results, map {
1027 _emit_log(
1028 B02_NS_NOT_AUTH => {
1029 ns => $_
1030 }
1031 )
1032 } keys %ns_not_auth;
1033 }
1034  
1035 if ( scalar keys %ns_cant_resolve ) {
1036 push @results, map {
1037 _emit_log(
1038 B02_NS_NO_IP_ADDR => {
1039 nsname => $_
1040 }
1041 )
1042 } keys %ns_cant_resolve;
1043 }
1044  
1045 if ( scalar keys %ns_no_response ) {
1046 push @results, map {
1047 _emit_log(
1048 B02_NS_NO_RESPONSE => {
1049 ns => $_
1050 }
1051 )
1052 } keys %ns_no_response;
1053 }
1054  
1055 if ( scalar keys %unexpected_rcode ) {
1056 push @results, map {
1057 _emit_log(
1058 B02_UNEXPECTED_RCODE => {
1059 rcode => $unexpected_rcode{$_},
1060 ns => $_
1061 }
1062 )
1063 } keys %unexpected_rcode;
1064 }
1065 }
1066  
1067 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1068 } ## end sub basic02
1069  
1070 =over
1071  
1072 =item basic03()
1073  
1074 my @logentry_array = basic03( $zone );
1075  
1076 Runs the L<Basic03 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Basic-TP/basic03.md>.
1077  
1078 Takes a L<Zonemaster::Engine::Zone> object.
1079  
1080 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1081  
1082 =back
1083  
1084 =cut
1085  
1086 sub basic03 {
1087 my ( $class, $zone ) = @_;
1088 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Basic03';
1089  
1090 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1091 my $query_type = q{A};
1092  
1093 my $name = q{www.} . $zone->name;
1094 my $response_nb = 0;
1095 foreach my $ns ( @{ Zonemaster::Engine::TestMethods->method4( $zone ) } ) {
1096 if ( _ip_disabled_message( \@results, $ns, $query_type ) ) {
1097 next;
1098 }
1099 _ip_enabled_message( \@results, $ns, $query_type );
1100  
1101 my $p = $ns->query( $name, $query_type );
1102 next if not $p;
1103 $response_nb++;
1104 if ( $p->has_rrs_of_type_for_name( $query_type, $name ) ) {
1105 push @results,
1106 _emit_log(
1107 HAS_A_RECORDS => {
1108 ns => $ns->string,
1109 domain => $name,
1110 }
1111 );
1112 }
1113 else {
1114 push @results,
1115 _emit_log(
1116 NO_A_RECORDS => {
1117 ns => $ns->string,
1118 domain => $name,
1119 }
1120 );
1121 }
1122 } ## end foreach my $ns ( @{ Zonemaster::Engine::TestMethods...})
1123  
1124 if ( scalar( @{ Zonemaster::Engine::TestMethods->method4( $zone ) } ) and not $response_nb ) {
1125 push @results, _emit_log( A_QUERY_NO_RESPONSES => {} );
1126 }
1127  
1128 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1129 } ## end sub basic03
1130  
1131 1;