[2225_xfrout] s/counter/counters/

Due to the class name changed

src/bin/xfrout/tests/xfrout_test.py.in

@@ -291,7 +291,7 @@ class TestXfroutSessionBase(unittest.TestCase):
         # the XfroutSession object.  We check the condition here.
         self.assertEqual(0, self.xfrsess._server.transfer_counter)
         # clear statistics counters
-        self.xfrsess._counter.clear_counters()
+        self.xfrsess._counters.clear_counters()
 
 class TestXfroutSession(TestXfroutSessionBase):
     def test_quota_error(self):
@@ -380,7 +380,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         ]))
         # check the 'xfrrej' counter initially
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.xfrsess._counter.get, 'zones',
+                          self.xfrsess._counters.get, 'zones',
                           TEST_ZONE_NAME_STR, 'xfrrej')
         # Localhost (the default in this test) is accepted
         rcode, msg = self.xfrsess._parse_query_message(self.mdata)
@@ -396,7 +396,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         rcode, msg = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(self.xfrsess._counter.get(
+        self.assertEqual(self.xfrsess._counters.get(
                 'zones', TEST_ZONE_NAME_STR, 'xfrrej'), 1)
 
         # TSIG signed request
@@ -427,7 +427,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         [rcode, msg] = self.xfrsess._parse_query_message(request_data)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(self.xfrsess._counter.get(
+        self.assertEqual(self.xfrsess._counters.get(
                 'zones', TEST_ZONE_NAME_STR, 'xfrrej'), 2)
 
         # ACL using TSIG: no TSIG; should be rejected
@@ -437,7 +437,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         [rcode, msg] = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(self.xfrsess._counter.get(
+        self.assertEqual(self.xfrsess._counters.get(
                 'zones', TEST_ZONE_NAME_STR, 'xfrrej'), 3)
 
         #
@@ -459,7 +459,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         [rcode, msg] = self.xfrsess._parse_query_message(request_data)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(self.xfrsess._counter.get(
+        self.assertEqual(self.xfrsess._counters.get(
                 'zones', TEST_ZONE_NAME_STR, 'xfrrej'), 4)
         # Address matches, but TSIG doesn't (not included)
         self.xfrsess._remote = (socket.AF_INET, socket.SOCK_STREAM,
@@ -467,7 +467,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         [rcode, msg] = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(self.xfrsess._counter.get(
+        self.assertEqual(self.xfrsess._counters.get(
                 'zones', TEST_ZONE_NAME_STR, 'xfrrej'), 5)
         # Neither address nor TSIG matches
         self.xfrsess._remote = (socket.AF_INET, socket.SOCK_STREAM,
@@ -475,7 +475,7 @@ class TestXfroutSession(TestXfroutSessionBase):
         [rcode, msg] = self.xfrsess._parse_query_message(self.mdata)
         self.assertEqual(rcode.to_text(), "REFUSED")
         # check the 'xfrrej' counter after incrementing
-        self.assertEqual(self.xfrsess._counter.get(
+        self.assertEqual(self.xfrsess._counters.get(
                 'zones', TEST_ZONE_NAME_STR, 'xfrrej'), 6)
 
     def test_transfer_acl(self):
@@ -860,10 +860,10 @@ class TestXfroutSession(TestXfroutSessionBase):
 
         self.xfrsess._reply_xfrout_query = myreply
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.xfrsess._counter.get,
+                          self.xfrsess._counters.get,
                           'socket', 'unixdomain', 'senderr')
         self.xfrsess.dns_xfrout_start(self.sock, self.mdata)
-        self.assertEqual(self.xfrsess._counter.get(
+        self.assertEqual(self.xfrsess._counters.get(
                 'socket', 'unixdomain', 'senderr'), 1)
 
     def test_dns_xfrout_start_noerror(self):
@@ -875,12 +875,12 @@ class TestXfroutSession(TestXfroutSessionBase):
             self.sock.send(b"success")
 
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.xfrsess._counter.get,
+                          self.xfrsess._counters.get,
                           'zones', TEST_ZONE_NAME_STR, 'xfrreqdone')
         self.xfrsess._reply_xfrout_query = myreply
         self.xfrsess.dns_xfrout_start(self.sock, self.mdata)
         self.assertEqual(self.sock.readsent(), b"success")
-        self.assertGreater(self.xfrsess._counter.get(
+        self.assertGreater(self.xfrsess._counters.get(
             'zones', TEST_ZONE_NAME_STR, 'xfrreqdone'), 0)
 
     def test_reply_xfrout_query_axfr(self):
@@ -1138,7 +1138,7 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
 
     def test_axfr_normal_session(self):
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.xfrsess._counter.get, 'axfr_running')
+                          self.xfrsess._counters.get, 'axfr_running')
         XfroutSession._handle(self.xfrsess)
         response = self.sock.read_msg(Message.PRESERVE_ORDER);
         self.assertEqual(Rcode.NOERROR(), response.get_rcode())
@@ -1146,8 +1146,8 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
         self.assertEqual(self.xfrsess._request_type, RRType.AXFR())
         self.assertNotEqual(self.xfrsess._request_type, RRType.IXFR())
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.xfrsess._counter.get, 'ixfr_running')
-        self.assertEqual(self.xfrsess._counter.get('axfr_running'), 0)
+                          self.xfrsess._counters.get, 'ixfr_running')
+        self.assertEqual(self.xfrsess._counters.get('axfr_running'), 0)
 
     def test_ixfr_to_axfr(self):
         self.xfrsess._request_data = \
@@ -1167,9 +1167,9 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
         self.xfrsess._request_data = \
             self.create_request_data(ixfr=IXFR_OK_VERSION)
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.xfrsess._counter.get, 'axfr_running')
+                          self.xfrsess._counters.get, 'axfr_running')
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.xfrsess._counter.get, 'ixfr_running')
+                          self.xfrsess._counters.get, 'ixfr_running')
         XfroutSession._handle(self.xfrsess)
         response = self.sock.read_msg(Message.PRESERVE_ORDER)
         actual_records = response.get_section(Message.SECTION_ANSWER)
@@ -1188,8 +1188,8 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
         self.assertNotEqual(self.xfrsess._request_type, RRType.AXFR())
         self.assertEqual(self.xfrsess._request_type, RRType.IXFR())
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.xfrsess._counter.get, 'axfr_running')
-        self.assertEqual(self.xfrsess._counter.get('ixfr_running'), 0)
+                          self.xfrsess._counters.get, 'axfr_running')
+        self.assertEqual(self.xfrsess._counters.get('ixfr_running'), 0)
 
     def ixfr_soa_only_common_checks(self, request_serial):
         self.xfrsess._request_data = \
@@ -1217,7 +1217,7 @@ class MyUnixSockServer(UnixSockServer):
         self._common_init()
         self._cc = MyCCSession()
         self.update_config_data(self._cc.get_full_config())
-        self._counter = xfrout.Counter(xfrout.SPECFILE_LOCATION)
+        self._counters = xfrout.Counters(xfrout.SPECFILE_LOCATION)
 
 class TestUnixSockServer(unittest.TestCase):
     def setUp(self):
@@ -1578,57 +1578,57 @@ class TestUnixSockServerForCounter(unittest.TestCase):
             super,
             self.orig_process_request,
             self.orig_select )
-        self.unix._counter.clear_counters()
+        self.unix._counters.clear_counters()
 
     def test_open(self):
         # open
         self.assertEqual(
-            self.unix._counter.get('socket', 'unixdomain', 'open'), 1)
+            self.unix._counters.get('socket', 'unixdomain', 'open'), 1)
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.unix._counter.get,
+                          self.unix._counters.get,
                           'socket', 'unixdomain', 'openfail')
         xfrout.ThreadingUnixStreamServer = DummySocketserverException
         self.unix = UnixSockServer(None, None, None, None, None)
         self.assertEqual(
-            self.unix._counter.get('socket', 'unixdomain', 'open'), 1)
+            self.unix._counters.get('socket', 'unixdomain', 'open'), 1)
         self.assertEqual(
-            self.unix._counter.get('socket', 'unixdomain', 'openfail'), 1)
+            self.unix._counters.get('socket', 'unixdomain', 'openfail'), 1)
 
     def test_close(self):
         # close
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.unix._counter.get,
+                          self.unix._counters.get,
                           'socket','unixdomain', 'close')
         self.unix.shutdown()
         self.assertEqual(
-            self.unix._counter.get('socket', 'unixdomain', 'close'), 1)
+            self.unix._counters.get('socket', 'unixdomain', 'close'), 1)
 
     def test_bindfail(self):
         # bindfail
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.unix._counter.get,
+                          self.unix._counters.get,
                           'socket', 'unixdomain', 'bindfail')
         self.assertRaises(Exception, self.unix.server_bind)
         self.assertEqual(
-            self.unix._counter.get('socket', 'unixdomain', 'bindfail'), 1)
+            self.unix._counters.get('socket', 'unixdomain', 'bindfail'), 1)
 
     def test_accept(self):
         # accept
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.unix._counter.get,
+                          self.unix._counters.get,
                           'socket', 'unixdomain', 'accept')
         self.unix.get_request()
         self.assertEqual(
-            self.unix._counter.get('socket', 'unixdomain', 'accept'), 1)
+            self.unix._counters.get('socket', 'unixdomain', 'accept'), 1)
         # acceptfail
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.unix._counter.get,
+                          self.unix._counters.get,
                           'socket', 'unixdomain', 'acceptfail')
         xfrout.super = lambda : DummyClassException()
         self.unix = UnixSockServer(None, None, None, None, None)
         self.assertRaises(Exception, self.unix.get_request)
         self.assertEqual(
-            self.unix._counter.get('socket', 'unixdomain', 'acceptfail'), 1)
+            self.unix._counters.get('socket', 'unixdomain', 'acceptfail'), 1)
 
     def test_senderr(self):
         # do inside of above TestXfroutSession
@@ -1637,13 +1637,13 @@ class TestUnixSockServerForCounter(unittest.TestCase):
     def test_recverr(self):
         # recverr
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self.unix._counter.get,
+                          self.unix._counters.get,
                           'socket', 'unixdomain', 'recverr')
         def raise_socketerror(x,y):
             raise socket.error
         self.unix.process_request = raise_socketerror
         self.unix._select_loop(None)
-        self.assertEqual(self.unix._counter.get(
+        self.assertEqual(self.unix._counters.get(
                 'socket', 'unixdomain', 'recverr'), 1)
 
 class TestInitialization(unittest.TestCase):
@@ -1694,7 +1694,7 @@ class MyXfroutServer(XfroutServer):
         self._wait_for_threads = lambda : None
         self._cc.get_module_spec = lambda:\
             isc.config.module_spec_from_file(xfrout.SPECFILE_LOCATION)
-        self._counter = xfrout.Counter(xfrout.SPECFILE_LOCATION)
+        self._counters = xfrout.Counters(xfrout.SPECFILE_LOCATION)
 
 class TestXfroutServer(unittest.TestCase):
     def setUp(self):

src/bin/xfrout/xfrout.py.in

@@ -27,7 +27,7 @@ from socketserver import *
 import os
 from isc.config.ccsession import *
 from isc.cc import SessionError, SessionTimeout
-from isc.statistics import Counter
+from isc.statistics import Counters
 from isc.notify import notify_out
 import isc.util.process
 import socket
@@ -169,9 +169,9 @@ class XfroutSession():
         self.ClientClass = client_class # parameterize this for testing
         self._soa = None # will be set in _xfrout_setup or in tests
         self._jnl_reader = None # will be set to a reader for IXFR
-        # Creation of self.counter should be done before of
+        # Creation of self.counters should be done before of
         # invoking self._handle()
-        self._counter = Counter(SPECFILE_LOCATION)
+        self._counters = Counters(SPECFILE_LOCATION)
         self._handle()
 
     def create_tsig_ctx(self, tsig_record, tsig_key_ring):
@@ -275,7 +275,7 @@ class XfroutSession():
             return None, None
         elif acl_result == REJECT:
             # count rejected Xfr request by each zone name
-            self._counter.inc('zones', zone_name.to_text(), 'xfrrej')
+            self._counters.inc('zones', zone_name.to_text(), 'xfrrej')
             logger.debug(DBG_XFROUT_TRACE, XFROUT_QUERY_REJECTED,
                          self._request_type, format_addrinfo(self._remote),
                          format_zone_str(zone_name, zone_class))
@@ -527,25 +527,25 @@ class XfroutSession():
         try:
             # increment Xfr starts by RRType
             if self._request_type == RRType.AXFR():
-                self._counter.inc('axfr_running')
+                self._counters.inc('axfr_running')
             else:
-                self._counter.inc('ixfr_running')
+                self._counters.inc('ixfr_running')
             logger.info(XFROUT_XFR_TRANSFER_STARTED, self._request_typestr,
                         format_addrinfo(self._remote), zone_str)
             self._reply_xfrout_query(msg, sock_fd)
         except Exception as err:
             # count unixsockets send errors
-            self._counter.inc('socket', 'unixdomain', 'senderr')
+            self._counters.inc('socket', 'unixdomain', 'senderr')
             logger.error(XFROUT_XFR_TRANSFER_ERROR, self._request_typestr,
                     format_addrinfo(self._remote), zone_str, err)
         finally:
             # decrement Xfr starts by RRType
             if self._request_type == RRType.AXFR():
-                self._counter.dec('axfr_running')
+                self._counters.dec('axfr_running')
             else:
-                self._counter.dec('ixfr_running')
+                self._counters.dec('ixfr_running')
         # count done Xfr requests by each zone name
-        self._counter.inc('zones', zone_name.to_text(), 'xfrreqdone')
+        self._counters.inc('zones', zone_name.to_text(), 'xfrreqdone')
         logger.info(XFROUT_XFR_TRANSFER_DONE, self._request_typestr,
                     format_addrinfo(self._remote), zone_str)
 
@@ -659,14 +659,14 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
         self._remove_unused_sock_file(sock_file)
         self._sock_file = sock_file
         socketserver_mixin.NoPollMixIn.__init__(self)
-        self._counter = Counter(SPECFILE_LOCATION)
+        self._counters = Counters(SPECFILE_LOCATION)
         try:
             ThreadingUnixStreamServer.__init__(self, sock_file, \
                                                    handle_class)
         except:
-            self._counter.inc('socket', 'unixdomain', 'openfail')
+            self._counters.inc('socket', 'unixdomain', 'openfail')
         else:
-            self._counter.inc('socket', 'unixdomain', 'open')
+            self._counters.inc('socket', 'unixdomain', 'open')
         self._shutdown_event = shutdown_event
         self._write_sock, self._read_sock = socket.socketpair()
         self._common_init()
@@ -683,7 +683,7 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
             return super().server_bind()
         except:
             # count bind failed unixsockets
-            self._counter.inc('socket', 'unixdomain', 'bindfail')
+            self._counters.inc('socket', 'unixdomain', 'bindfail')
             raise
 
     def get_request(self):
@@ -695,11 +695,11 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
             # ThreadingUnixStreamServer
             ret = super().get_request()
             # count successfully accepted unixsockets
-            self._counter.inc('socket', 'unixdomain', 'accept')
+            self._counters.inc('socket', 'unixdomain', 'accept')
             return ret
         except:
             # count failed accepted unixsockets
-            self._counter.inc('socket', 'unixdomain', 'acceptfail')
+            self._counters.inc('socket', 'unixdomain', 'acceptfail')
             raise
 
     def _common_init(self):
@@ -769,7 +769,7 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
                     break
             except Exception as pre:
                 # count unixsockets receive errors
-                self._counter.inc('socket', 'unixdomain', 'recverr')
+                self._counters.inc('socket', 'unixdomain', 'recverr')
                 logger.error(XFROUT_PROCESS_REQUEST_ERROR, pre)
                 break
 
@@ -896,7 +896,7 @@ class UnixSockServer(socketserver_mixin.NoPollMixIn,
         super().shutdown() # call the shutdown() of class socketserver_mixin.NoPollMixIn
         try:
             # count closed unixsockets
-            self._counter.inc('socket', 'unixdomain', 'close')
+            self._counters.inc('socket', 'unixdomain', 'close')
             os.unlink(self._sock_file)
         except Exception as e:
             logger.error(XFROUT_REMOVE_UNIX_SOCKET_FILE_ERROR, self._sock_file, str(e))
@@ -999,7 +999,7 @@ class XfroutServer:
         isc.server_common.tsig_keyring.init_keyring(self._cc)
         self._start_xfr_query_listener()
         self._start_notifier()
-        self._counter = Counter(SPECFILE_LOCATION)
+        self._counters = Counters(SPECFILE_LOCATION)
 
     def _start_xfr_query_listener(self):
         '''Start a new thread to accept xfr query. '''
@@ -1095,7 +1095,7 @@ class XfroutServer:
             # The log level is here set to debug in order to avoid
             # that a log becomes too verbose. Because the b10-stats
             # daemon is periodically asking to the b10-xfrout daemon.
-            answer = create_answer(0, self._counter.dump_statistics())
+            answer = create_answer(0, self._counters.dump_statistics())
             logger.debug(DBG_XFROUT_TRACE, \
                              XFROUT_RECEIVED_GETSTATS_COMMAND, \
                              str(answer))

src/lib/python/isc/notify/notify_out.py

@@ -25,7 +25,7 @@ from isc.datasrc import DataSourceClient
 from isc.net import addr
 import isc
 from isc.log_messages.notify_out_messages import *
-from isc.statistics import Counter
+from isc.statistics import Counters
 
 logger = isc.log.Logger("notify_out")
 
@@ -143,7 +143,7 @@ class NotifyOut:
         # Use nonblock event to eliminate busy loop
         # If there are no notifying zones, clear the event bit and wait.
         self._nonblock_event = threading.Event()
-        self._counter = Counter()
+        self._counters = Counters()
 
     def _init_notify_out(self, datasrc_file):
         '''Get all the zones name and its notify target's address.
@@ -482,10 +482,10 @@ class NotifyOut:
             sock.sendto(render.get_data(), 0, addrinfo)
             # count notifying by IPv4 or IPv6 for statistics
             if zone_notify_info.get_socket().family == socket.AF_INET:
-                self._counter.inc('zones', zone_notify_info.zone_name,
+                self._counters.inc('zones', zone_notify_info.zone_name,
                                   'notifyoutv4')
             elif zone_notify_info.get_socket().family == socket.AF_INET6:
-                self._counter.inc('zones', zone_notify_info.zone_name,
+                self._counters.inc('zones', zone_notify_info.zone_name,
                                   'notifyoutv6')
             logger.info(NOTIFY_OUT_SENDING_NOTIFY, addrinfo[0],
                         addrinfo[1])

src/lib/python/isc/notify/tests/notify_out_test.py

@@ -112,7 +112,7 @@ class TestNotifyOut(unittest.TestCase):
         com_ch_info.notify_slaves.append(('1.1.1.1', 5353))
 
     def tearDown(self):
-        self._notify._counter.clear_counters()
+        self._notify._counters.clear_counters()
 
     def test_send_notify(self):
         notify_out._MAX_NOTIFY_NUM = 2
@@ -267,10 +267,10 @@ class TestNotifyOut(unittest.TestCase):
         example_com_info = self._notify._notify_infos[('example.net.', 'IN')]
 
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self._notify._counter.get,
+                          self._notify._counters.get,
                           'zones', 'example.net.', 'notifyoutv4')
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self._notify._counter.get,
+                          self._notify._counters.get,
                           'zones', 'example.net.', 'notifyoutv6')
 
         example_com_info.prepare_notify_out()
@@ -278,38 +278,38 @@ class TestNotifyOut(unittest.TestCase):
                                                     ('192.0.2.1', 53))
         self.assertTrue(ret)
         self.assertEqual(socket.AF_INET, example_com_info.sock_family)
-        self.assertEqual(self._notify._counter.get(
+        self.assertEqual(self._notify._counters.get(
                 'zones', 'example.net.', 'notifyoutv4'), 1)
-        self.assertEqual(self._notify._counter.get(
+        self.assertEqual(self._notify._counters.get(
                 'zones', 'example.net.', 'notifyoutv6'), 0)
 
     def test_send_notify_message_udp_ipv6(self):
         example_com_info = self._notify._notify_infos[('example.net.', 'IN')]
 
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self._notify._counter.get,
+                          self._notify._counters.get,
                           'zones', 'example.net.', 'notifyoutv4')
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self._notify._counter.get,
+                          self._notify._counters.get,
                           'zones', 'example.net.', 'notifyoutv6')
 
         ret = self._notify._send_notify_message_udp(example_com_info,
                                                     ('2001:db8::53', 53))
         self.assertTrue(ret)
         self.assertEqual(socket.AF_INET6, example_com_info.sock_family)
-        self.assertEqual(self._notify._counter.get(
+        self.assertEqual(self._notify._counters.get(
                 'zones', 'example.net.', 'notifyoutv4'), 0)
-        self.assertEqual(self._notify._counter.get(
+        self.assertEqual(self._notify._counters.get(
                 'zones', 'example.net.', 'notifyoutv6'), 1)
 
     def test_send_notify_message_with_bogus_address(self):
         example_com_info = self._notify._notify_infos[('example.net.', 'IN')]
 
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self._notify._counter.get,
+                          self._notify._counters.get,
                           'zones', 'example.net.', 'notifyoutv4')
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self._notify._counter.get,
+                          self._notify._counters.get,
                           'zones', 'example.net.', 'notifyoutv6')
 
         # As long as the underlying data source validates RDATA this shouldn't
@@ -321,10 +321,10 @@ class TestNotifyOut(unittest.TestCase):
         self.assertFalse(ret)
 
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self._notify._counter.get,
+                          self._notify._counters.get,
                           'zones', 'example.net.', 'notifyoutv4')
         self.assertRaises(isc.cc.data.DataNotFoundError,
-                          self._notify._counter.get,
+                          self._notify._counters.get,
                           'zones', 'example.net.', 'notifyoutv4')
 
     def test_zone_notify_handler(self):