view release on metacpan or  search on metacpan

xt/165-incomplete-walks-for.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict; use warnings;
no warnings 'once'; # local *glob = sub {} overrides below are single-use by design

BEGIN { $ENV{DANCER_ENVDIR} = '/dev/null'; }

use Test::More 0.88;
use Test::File::ShareDir::Dist { 'App-Netdisco' => 'share/' };

use lib 'xt/lib';

use App::Netdisco;
use App::Netdisco::DB; # fake device/deviceport rows
use App::Netdisco::Backend::Job;
use App::Netdisco::Transport::SNMP ();
use App::Netdisco::Util::SNMP qw/walk_mark incomplete_walks_for
  incomplete_walk_level incomplete_walk_message/;
use App::Netdisco::Worker::Plugin::Discover::Properties ();
use App::Netdisco::Worker::Plugin::Discover::Properties::Tags ();

use Try::Tiny;
use Dancer qw/:moose :script !pass/;

# The Properties worker tests stub SNMP and storage as xt/51-updated-device-hook.t
# does. The unit tests use a fake SNMP::Info that keeps the two walk records
# the installed SNMP::Info (3.979000) lacks.

my $CONFIG = config();
$CONFIG->{logger} = 'console';
$CONFIG->{log} = ($ENV{'DANCER_DEBUG'} ? 'debug' : 'error');
Dancer::Logger->init('console', $CONFIG);

{
  package MyWorker;
  use Moo;
  with 'App::Netdisco::Worker::Runner';
}

config->{'device_auth'} = [{driver => 'snmp'}];
config->{'enable_field_protection'} = 0;
config->{'enable_incomplete_walk_protection'} = 1;
config->{'ignore_deviceports'} = [];
config->{'dns'}->{'no'} = ['0.0.0.0/0'];

package RecordingSNMP; # keeps walk_failures and walk_status
# the port tags worker runs inside discover::properties; its clear writes nothing here
{ package NoopTagsSchema; sub resultset { return $_[0] } sub search { return $_[0] } sub update { return 0 } }

sub new { my ($class, %vals) = @_; return bless { walk_failures => [], walk_status => {}, %vals }, $class; }
sub walk_failures { $_[0]{walk_failures} }
sub walk_status { $_[0]{walk_status}{$_[1]} }

package PlainSNMP; # an SNMP::Info with no walk record
sub new { return bless {}, shift }

package FakeSNMP;
our $AUTOLOAD;
sub new { my ($class, %vals) = @_; return bless {%vals}, $class; }
sub AUTOLOAD {
  my $self = shift;
  (my $method = $AUTOLOAD) =~ s/.*:://;
  return if $method eq 'DESTROY';
  return $self->{$method};
}
sub walk_failures { $_[0]{walk_failures} ||= [] }
# the walk records its failure while it runs, as SNMP::Info does
sub interfaces {
  my $self = shift;
  push @{ $self->walk_failures }, @{ $self->{interfaces_fails} || [] };
  return $self->{interfaces};
}

package FakePortsRS;
sub new { my ($class, @rows) = @_; return bless { rows => [@rows] }, $class; }
sub reset { return $_[0] }
sub all { return @{ $_[0]->{rows} } }

package FakeLockedRow;
sub new { return bless {}, shift }
sub first { return $_[0] }

package FakeSchema;
sub txn_do { my ($self, $code) = @_; return $code->() }
sub resultset { my ($self, $name) = @_; return App::Netdisco::DB->resultset($name) }

package main;

sub outcome {
  my ($method, %extra) = @_;
  return { method => $method, leaf => "MIB::$method", reason => 'timeout',
           rows => 1, walk => 'bulkwalk', complete => 0, %extra };
}

my $device = App::Netdisco::DB->resultset('Device')->new_result({ ip => '192.0.2.1' });
my $other_device = App::Netdisco::DB->resultset('Device')->new_result({ ip => '192.0.2.2' });

subtest 'incomplete_walks_for__failure_since_mark__returned' => sub {
  my $snmp = RecordingSNMP->new;
  my $mark = walk_mark($snmp);
  my $failure = outcome('i_index');
  push @{ $snmp->walk_failures }, $failure;
  is_deeply [ incomplete_walks_for($device, $snmp, $mark) ], [ $failure ];
};

subtest 'incomplete_walks_for__failure_before_mark_on_named_method__returned' => sub {
  my $failure = outcome('ip_index');
  my $snmp = RecordingSNMP->new(