Unit testing basic workflows

2025-06-04 11:47:49 -04:00
parent 1c31de2bb4
commit 05fc8f9a46
22 changed files with 477 additions and 223 deletions
--- a/test/Mine/TestMine.py
+++ b/test/Mine/TestMine.py
@@ -0,0 +1,261 @@
+import json
+import os
+import requests
+import sys
+import unittest
+import uuid
+
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives import serialization
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'wikideck')))
+
+from Mine.Block import Block
+from Mine.Transaction import Transaction
+
+WIKIDECK_URL = os.getenv('WIKIDECK_URL', 'http://localhost:8080/')
+
+class TestMine(unittest.TestCase):
+    def test_mine_block_send_card_mine_another_block(self):
+        # Create two users
+        privateKeyA = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=4096
+            )
+        privateKeyB = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=4096
+            )
+        # Mine a block with privateKeyA
+        response = requests.get(f"{WIKIDECK_URL}/blocks")
+        self.assertEqual(response.status_code, 200)
+        newBlockA = Block(
+            data = response.json()
+            )
+        newBlockA.mine(privateKeyA)
+        response = requests.post(f"{WIKIDECK_URL}/blocks", json=newBlockA.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Send card from newBlockA to privateKeyB
+        newTransaction = Transaction(
+            cardId = newBlockA.card.cardId,
+            sender = privateKeyA.public_key(),
+            receiver = privateKeyB.public_key(),
+            authorPrivateKey = privateKeyA
+            )
+        response = requests.post(f"{WIKIDECK_URL}/transactions", json=newTransaction.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Mine a block with privateKeyB
+        response = requests.get(f"{WIKIDECK_URL}/blocks")
+        self.assertEqual(response.status_code, 200)
+        newBlockB = Block(
+            data = response.json()
+            )
+        newBlockB.mine(privateKeyB)
+        self.assertEqual(newBlockA.blockHash.hexdigest(), newBlockB.previousHash)
+        self.assertTrue(newBlockA.timestamp < newBlockB.timestamp)
+        self.assertTrue(newBlockB.height == newBlockA.height + 1)
+        response = requests.post(f"{WIKIDECK_URL}/blocks", json=newBlockB.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Validate decks
+        response = requests.get(f"{WIKIDECK_URL}/cards", params={
+            'publicKey': privateKeyA.public_key().public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                ).decode('utf-8')
+            })
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 0)
+        response = requests.get(f"{WIKIDECK_URL}/cards", params={
+            'publicKey': privateKeyB.public_key().public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                ).decode('utf-8')
+            })
+        self.assertEqual(response.json()[0]['cardId'], str(newBlockA.card.cardId))
+        self.assertEqual(response.json()[0]['pageId'], newBlockA.card.pageId)
+        self.assertEqual(response.json()[1]['cardId'], str(newBlockB.card.cardId))
+        self.assertEqual(response.json()[1]['pageId'], newBlockB.card.pageId)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 2)
+
+    def test_invalid_block_modified_transaction(self):
+        # Create two users
+        privateKeyA = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=4096
+            )
+        privateKeyB = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=4096
+            )
+        # Mine a block with privateKeyA
+        response = requests.get(f"{WIKIDECK_URL}/blocks")
+        self.assertEqual(response.status_code, 200)
+        newBlockA = Block(
+            data = response.json()
+            )
+        newBlockA.mine(privateKeyA)
+        response = requests.post(f"{WIKIDECK_URL}/blocks", json=newBlockA.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Send card from newBlockA to privateKeyB
+        newTransaction = Transaction(
+            cardId = newBlockA.card.cardId,
+            sender = privateKeyA.public_key(),
+            receiver = privateKeyB.public_key(),
+            authorPrivateKey = privateKeyA
+            )
+        response = requests.post(f"{WIKIDECK_URL}/transactions", json=newTransaction.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Mine a block with privateKeyB
+        response = requests.get(f"{WIKIDECK_URL}/blocks")
+        self.assertEqual(response.status_code, 200)
+        newBlockB = Block(
+            data = response.json()
+            )
+        # Modify transactions
+        newBlockB.transactions[0].sender = privateKeyB.public_key()
+        newBlockB.transactions[0].receiver = privateKeyA.public_key()
+        newBlockB.mine(privateKeyB)
+        self.assertEqual(newBlockA.blockHash.hexdigest(), newBlockB.previousHash)
+        self.assertTrue(newBlockA.timestamp < newBlockB.timestamp)
+        self.assertTrue(newBlockB.height == newBlockA.height + 1)
+        response = requests.post(f"{WIKIDECK_URL}/blocks", json=newBlockB.as_dict())
+        self.assertEqual(response.status_code, 400)
+        # Validate decks
+        response = requests.get(f"{WIKIDECK_URL}/cards", params={
+            'publicKey': privateKeyA.public_key().public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                ).decode('utf-8')
+            })
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 1)
+        self.assertEqual(response.json()[0]['cardId'], str(newBlockA.card.cardId))
+        self.assertEqual(response.json()[0]['pageId'], newBlockA.card.pageId)
+        response = requests.get(f"{WIKIDECK_URL}/cards", params={
+            'publicKey': privateKeyB.public_key().public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                ).decode('utf-8')
+            })
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 0)
+        # Mine a block with privateKeyB
+        response = requests.get(f"{WIKIDECK_URL}/blocks")
+        self.assertEqual(response.status_code, 200)
+        newBlockB = Block(
+            data = response.json()
+            )
+        newBlockB.mine(privateKeyB)
+        self.assertEqual(newBlockA.blockHash.hexdigest(), newBlockB.previousHash)
+        self.assertTrue(newBlockA.timestamp < newBlockB.timestamp)
+        self.assertTrue(newBlockB.height == newBlockA.height + 1)
+        response = requests.post(f"{WIKIDECK_URL}/blocks", json=newBlockB.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Validate decks
+        response = requests.get(f"{WIKIDECK_URL}/cards", params={
+            'publicKey': privateKeyA.public_key().public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                ).decode('utf-8')
+            })
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 0)
+        response = requests.get(f"{WIKIDECK_URL}/cards", params={
+            'publicKey': privateKeyB.public_key().public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                ).decode('utf-8')
+            })
+        self.assertEqual(response.json()[0]['cardId'], str(newBlockA.card.cardId))
+        self.assertEqual(response.json()[0]['pageId'], newBlockA.card.pageId)
+        self.assertEqual(response.json()[1]['cardId'], str(newBlockB.card.cardId))
+        self.assertEqual(response.json()[1]['pageId'], newBlockB.card.pageId)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 2)
+
+    def test_invalid_transaction(self):
+        # Create three users
+        privateKeyA = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=4096
+            )
+        privateKeyB = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=4096
+            )
+        privateKeyC = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=4096
+            )
+        # Mine a block with privateKeyA
+        response = requests.get(f"{WIKIDECK_URL}/blocks")
+        self.assertEqual(response.status_code, 200)
+        newBlockA = Block(
+            data = response.json()
+            )
+        newBlockA.mine(privateKeyA)
+        response = requests.post(f"{WIKIDECK_URL}/blocks", json=newBlockA.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Send card from newBlockA to privateKeyB
+        newTransaction = Transaction(
+            cardId = newBlockA.card.cardId,
+            sender = privateKeyA.public_key(),
+            receiver = privateKeyB.public_key(),
+            authorPrivateKey = privateKeyA
+            )
+        # Invalidate transaction
+        newTransaction.cardId = uuid.uuid4()
+        response = requests.post(f"{WIKIDECK_URL}/transactions", json=newTransaction.as_dict())
+        self.assertEqual(response.status_code, 400)
+        newTransaction.cardId = newBlockA.card.cardId
+        newTransaction.sender = privateKeyC.public_key()
+        response = requests.post(f"{WIKIDECK_URL}/transactions", json=newTransaction.as_dict())
+        self.assertEqual(response.status_code, 400)
+        newTransaction.sender = privateKeyA.public_key()
+        newTransaction.receiver = privateKeyC.public_key()
+        response = requests.post(f"{WIKIDECK_URL}/transactions", json=newTransaction.as_dict())
+        self.assertEqual(response.status_code, 400)
+        newTransaction.receiver = privateKeyB.public_key()
+        newTransaction.sign(privateKeyC)
+        response = requests.post(f"{WIKIDECK_URL}/transactions", json=newTransaction.as_dict())
+        self.assertEqual(response.status_code, 400)
+        newTransaction.sign(privateKeyA)
+        response = requests.post(f"{WIKIDECK_URL}/transactions", json=newTransaction.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Mine a block with privateKeyB
+        response = requests.get(f"{WIKIDECK_URL}/blocks")
+        self.assertEqual(response.status_code, 200)
+        newBlockB = Block(
+            data = response.json()
+            )
+        newBlockB.mine(privateKeyB)
+        self.assertEqual(newBlockA.blockHash.hexdigest(), newBlockB.previousHash)
+        self.assertTrue(newBlockA.timestamp < newBlockB.timestamp)
+        self.assertTrue(newBlockB.height == newBlockA.height + 1)
+        response = requests.post(f"{WIKIDECK_URL}/blocks", json=newBlockB.as_dict())
+        self.assertEqual(response.status_code, 200)
+        # Validate decks
+        response = requests.get(f"{WIKIDECK_URL}/cards", params={
+            'publicKey': privateKeyA.public_key().public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                ).decode('utf-8')
+            })
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 0)
+        response = requests.get(f"{WIKIDECK_URL}/cards", params={
+            'publicKey': privateKeyB.public_key().public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+                ).decode('utf-8')
+            })
+        self.assertEqual(response.json()[0]['cardId'], str(newBlockA.card.cardId))
+        self.assertEqual(response.json()[0]['pageId'], newBlockA.card.pageId)
+        self.assertEqual(response.json()[1]['cardId'], str(newBlockB.card.cardId))
+        self.assertEqual(response.json()[1]['pageId'], newBlockB.card.pageId)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 2)
+
+if __name__ == '__main__':
+    unittest.main()
--- a/test/init.py
+++ b/test/init.py
--- a/test/test.py
+++ b/test/test.py
@@ -0,0 +1,10 @@
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+from Mine.TestMine import TestMine
+
+if __name__ == '__main__':
+    unittest.main()