fixed audit tests/implementation

dataserv/Audit.py

@@ -2,9 +2,12 @@
 from datetime import datetime
 from sqlalchemy import DateTime
 from btctxstore import BtcTxStore
-from dataserv.Farmer import Farmer, address2nodeid
+from dataserv.Farmer import Farmer, address2nodeid, NODEID_PATTERN
 from dataserv.Validator import is_sha256
 from dataserv.config import logging
+import re
+
+
 logger = logging.getLogger(__name__)
 is_btc_address = BtcTxStore().validate_address
 
@@ -17,45 +20,44 @@ class Audit(db.Model):
     submit_time = db.Column(DateTime, default=datetime.utcnow)
     response = db.Column(db.String(60))
 
-    def __init__(self, btc_addr, block, response=None):
-        if not is_btc_address(btc_addr):
-            msg = "Invalid BTC Address: {0}".format(btc_addr)
+    def __init__(self, nodeid, block, response=None):
+        if not re.match(NODEID_PATTERN, nodeid):
+            msg = "Invalid nodeid: {0}".format(nodeid)
             logger.warning(msg)
             raise ValueError(msg)
-        if not Farmer(address2nodeid(btc_addr)).exists():
-            msg = "Farmer Not Found: {0}".format(btc_addr)
+        if not Farmer(nodeid).exists():
+            msg = "Farmer Not Found: {0}".format(nodeid)
             logger.warning(msg)
             raise LookupError(msg)
         if response is not None and not is_sha256(response):
             msg = "Invalid Response: {0}".format(response)
             logger.warning(msg)
             raise TypeError(msg)
 
-        self.btc_addr = btc_addr
+        self.nodeid = nodeid
         self.block = block
         self.response = response
 
     def __eq__(self, other):
-        return self.btc_addr == other.btc_addr and self.block == other.block \
-               and self.response == other.response
+        return (self.nodeid == other.nodeid and self.block == other.block
+                and self.response == other.response)
 
     def save(self):
         db.session.add(self)
         db.session.commit()
 
     def exists(self):
         """Check to see if this address is already listed."""
-        response = Audit.query.filter(Audit.btc_addr == self.btc_addr,
+        response = Audit.query.filter(Audit.nodeid == self.nodeid,
                                       Audit.block == self.block).count() > 0
         return response
 
     def lookup(self):
         """Return the Farmer object for the bitcoin address passed."""
-        audit = Audit.query.filter_by(btc_addr=self.btc_addr,
+        audit = Audit.query.filter_by(nodeid=self.nodeid,
                                       block=self.block).first()
         if not audit:
-            msg = "Block {0} Audit Missing: {1}".format(self.block,
-                                                        self.btc_addr)
+            msg = "Block {0} Audit Missing: {1}".format(self.block, self.nodeid)
             logger.warning(msg)
             raise LookupError(msg)
 

dataserv/app.py

@@ -15,7 +15,6 @@
 from dataserv.Farmer import Farmer  # NOQA
 from dataserv.config import logging  # NOQA
 from dataserv.run import app, db, cache, manager  # NOQA
-from dataserv.Farmer import nodeid2address  # NOQA
 
 
 logger = logging.getLogger(__name__)
@@ -221,7 +220,7 @@ def audit(nodeid, block_height, response):
         user = Farmer(nodeid)
         user.authenticate(dict(request.headers))
 
-        audit_msg = Audit(nodeid2address(nodeid), block_height, response)
+        audit_msg = Audit(nodeid, block_height, response)
         if audit_msg.exists():
             msg = "Duplicate audit: Block {0}".format(block_height)
             logger.warning(msg)

tests/test_Audit.py

@@ -34,6 +34,7 @@ def test_register_audit(self):
         btc_addr = self.gen_btc_addr()
         btc_addr2 = self.gen_btc_addr()
         nodeid = addr2nodeid(btc_addr)
+        nodeid2 = addr2nodeid(btc_addr2)
 
         # register farmer and test db
         farmer1 = Farmer(nodeid)
@@ -46,16 +47,16 @@ def callback_a():
             Audit(self.bad_addr, 0)
 
         def callback_b():
-            Audit(btc_addr2, 0)
+            Audit(nodeid2, 0)
 
-        audit = Audit(btc_addr, 0)
+        audit = Audit(nodeid, 0)
         self.assertFalse(audit.exists())
         audit.save()
-        audit2 = Audit(btc_addr, 0)
+        audit2 = Audit(nodeid, 0)
         self.assertTrue(audit2.exists())
 
         def callback_c():
-            Audit(btc_addr, 1, 'invalid_sha')
+            Audit(nodeid, 1, 'invalid_sha')
 
         self.assertRaises(ValueError, callback_a)
         self.assertRaises(LookupError, callback_b)
@@ -66,14 +67,14 @@ def test_lookup(self):
         nodeid = addr2nodeid(btc_addr)
         Farmer(nodeid).register(btc_addr)
 
-        audit = Audit(btc_addr, 0)
+        audit = Audit(nodeid, 0)
         audit.save()
 
         def callback_a():
-            Audit(btc_addr, 1).lookup()
+            Audit(nodeid, 1).lookup()
 
         self.assertRaises(LookupError, callback_a)
 
-        audit2 = Audit(btc_addr, 0).lookup()
-        audit3 = Audit(btc_addr, 0)
+        audit2 = Audit(nodeid, 0).lookup()
+        audit3 = Audit(nodeid, 0)
         self.assertEqual(audit2, audit3)