Added tests for Terminus pool approvals

That approved/unapproved operator has appropriate mint/burn permissions
on a Terminus pool.

dao/TerminusFacet.py

@@ -342,6 +342,12 @@ class TerminusFacet:
         self.assert_contract_is_instantiated()
         return self.contract.totalPools.call(block_identifier=block_number)
 
+    def unapprove_for_pool(
+        self, pool_id: int, operator: ChecksumAddress, transaction_config
+    ) -> Any:
+        self.assert_contract_is_instantiated()
+        return self.contract.unapproveForPool(pool_id, operator, transaction_config)
+
     def uri(
         self, pool_id: int, block_number: Optional[Union[str, int]] = "latest"
     ) -> Any:
@@ -819,6 +825,20 @@ def handle_total_pools(args: argparse.Namespace) -> None:
     print(result)
 
 
+def handle_unapprove_for_pool(args: argparse.Namespace) -> None:
+    network.connect(args.network)
+    contract = TerminusFacet(args.address)
+    transaction_config = get_transaction_config(args)
+    result = contract.unapprove_for_pool(
+        pool_id=args.pool_id,
+        operator=args.operator,
+        transaction_config=transaction_config,
+    )
+    print(result)
+    if args.verbose:
+        print(result.info())
+
+
 def handle_uri(args: argparse.Namespace) -> None:
     network.connect(args.network)
     contract = TerminusFacet(args.address)
@@ -1144,6 +1164,16 @@ def generate_cli() -> argparse.ArgumentParser:
     add_default_arguments(total_pools_parser, False)
     total_pools_parser.set_defaults(func=handle_total_pools)
 
+    unapprove_for_pool_parser = subcommands.add_parser("unapprove-for-pool")
+    add_default_arguments(unapprove_for_pool_parser, True)
+    unapprove_for_pool_parser.add_argument(
+        "--pool-id", required=True, help="Type: uint256", type=int
+    )
+    unapprove_for_pool_parser.add_argument(
+        "--operator", required=True, help="Type: address"
+    )
+    unapprove_for_pool_parser.set_defaults(func=handle_unapprove_for_pool)
+
     uri_parser = subcommands.add_parser("uri")
     add_default_arguments(uri_parser, False)
     uri_parser.add_argument("--pool-id", required=True, help="Type: uint256", type=int)

dao/test_terminus.py

@@ -1,3 +1,4 @@
+from re import I
 from typing import List
 import unittest
 
@@ -737,6 +738,167 @@ class TestPoolOperations(TerminusTestCase):
         self.assertEqual(final_pool_supply, initial_pool_supply)
         self.assertEqual(final_owner_balance, initial_owner_balance)
 
+    def test_pool_approval(self):
+        controller = accounts[1]
+        operator = accounts[2]
+        user = accounts[3]
+
+        self.diamond_terminus.create_pool_v1(100, True, True, {"from": controller})
+        pool_id = self.diamond_terminus.total_pools()
+        self.diamond_terminus.mint(
+            controller.address, pool_id, 5, "", {"from": controller}
+        )
+        self.diamond_terminus.mint(
+            operator.address, pool_id, 5, "", {"from": controller}
+        )
+        self.diamond_terminus.mint(user.address, pool_id, 5, "", {"from": controller})
+
+        controller_balance_0 = self.diamond_terminus.balance_of(
+            controller.address, pool_id
+        )
+        operator_balance_0 = self.diamond_terminus.balance_of(operator.address, pool_id)
+        user_balance_0 = self.diamond_terminus.balance_of(user.address, pool_id)
+
+        self.assertFalse(self.diamond_terminus.is_approved_for_pool(pool_id, operator))
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.mint(
+                controller.address, pool_id, 1, "", {"from": operator}
+            )
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.mint(
+                operator.address, pool_id, 1, "", {"from": operator}
+            )
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.mint(user.address, pool_id, 1, "", {"from": operator})
+
+        controller_balance_1 = self.diamond_terminus.balance_of(
+            controller.address, pool_id
+        )
+        operator_balance_1 = self.diamond_terminus.balance_of(operator.address, pool_id)
+        user_balance_1 = self.diamond_terminus.balance_of(user.address, pool_id)
+
+        self.assertEqual(controller_balance_1, controller_balance_0)
+        self.assertEqual(operator_balance_1, operator_balance_0)
+        self.assertEqual(user_balance_1, user_balance_0)
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.burn(
+                controller.address, pool_id, 1, {"from": operator}
+            )
+
+        self.diamond_terminus.burn(operator.address, pool_id, 1, {"from": operator})
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.burn(user.address, pool_id, 1, {"from": operator})
+
+        controller_balance_2 = self.diamond_terminus.balance_of(
+            controller.address, pool_id
+        )
+        operator_balance_2 = self.diamond_terminus.balance_of(operator.address, pool_id)
+        user_balance_2 = self.diamond_terminus.balance_of(user.address, pool_id)
+
+        self.assertEqual(controller_balance_2, controller_balance_1)
+        self.assertEqual(operator_balance_2, operator_balance_1 - 1)
+        self.assertEqual(user_balance_2, user_balance_1)
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.approve_for_pool(
+                pool_id, operator, {"from": operator}
+            )
+
+        self.diamond_terminus.approve_for_pool(pool_id, operator, {"from": accounts[1]})
+
+        self.assertTrue(self.diamond_terminus.is_approved_for_pool(pool_id, operator))
+
+        self.diamond_terminus.mint(
+            controller.address, pool_id, 1, "", {"from": operator}
+        )
+        self.diamond_terminus.mint(operator.address, pool_id, 1, "", {"from": operator})
+        self.diamond_terminus.mint(user.address, pool_id, 1, "", {"from": operator})
+
+        controller_balance_3 = self.diamond_terminus.balance_of(
+            controller.address, pool_id
+        )
+        operator_balance_3 = self.diamond_terminus.balance_of(operator.address, pool_id)
+        user_balance_3 = self.diamond_terminus.balance_of(user.address, pool_id)
+
+        self.assertEqual(controller_balance_3, controller_balance_2 + 1)
+        self.assertEqual(operator_balance_3, operator_balance_2 + 1)
+        self.assertEqual(user_balance_3, user_balance_2 + 1)
+
+        self.diamond_terminus.burn(controller.address, pool_id, 1, {"from": operator})
+        self.diamond_terminus.burn(operator.address, pool_id, 1, {"from": operator})
+        self.diamond_terminus.burn(user.address, pool_id, 1, {"from": operator})
+
+        controller_balance_4 = self.diamond_terminus.balance_of(
+            controller.address, pool_id
+        )
+        operator_balance_4 = self.diamond_terminus.balance_of(operator.address, pool_id)
+        user_balance_4 = self.diamond_terminus.balance_of(user.address, pool_id)
+
+        self.assertEqual(controller_balance_4, controller_balance_3 - 1)
+        self.assertEqual(operator_balance_4, operator_balance_3 - 1)
+        self.assertEqual(user_balance_4, user_balance_3 - 1)
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.unapprove_for_pool(
+                pool_id, operator, {"from": operator}
+            )
+
+        self.assertTrue(self.diamond_terminus.is_approved_for_pool(pool_id, operator))
+
+        self.diamond_terminus.unapprove_for_pool(
+            pool_id, operator, {"from": controller}
+        )
+
+        self.assertFalse(self.diamond_terminus.is_approved_for_pool(pool_id, operator))
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.mint(
+                controller.address, pool_id, 1, "", {"from": operator}
+            )
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.mint(
+                operator.address, pool_id, 1, "", {"from": operator}
+            )
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.mint(user.address, pool_id, 1, "", {"from": operator})
+
+        controller_balance_5 = self.diamond_terminus.balance_of(
+            controller.address, pool_id
+        )
+        operator_balance_5 = self.diamond_terminus.balance_of(operator.address, pool_id)
+        user_balance_5 = self.diamond_terminus.balance_of(user.address, pool_id)
+
+        self.assertEqual(controller_balance_5, controller_balance_4)
+        self.assertEqual(operator_balance_5, operator_balance_4)
+        self.assertEqual(user_balance_5, user_balance_4)
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.burn(
+                controller.address, pool_id, 1, {"from": operator}
+            )
+
+        self.diamond_terminus.burn(operator.address, pool_id, 1, {"from": operator})
+
+        with self.assertRaises(VirtualMachineError):
+            self.diamond_terminus.burn(user.address, pool_id, 1, {"from": operator})
+
+        controller_balance_6 = self.diamond_terminus.balance_of(
+            controller.address, pool_id
+        )
+        operator_balance_6 = self.diamond_terminus.balance_of(operator.address, pool_id)
+        user_balance_6 = self.diamond_terminus.balance_of(user.address, pool_id)
+
+        self.assertEqual(controller_balance_6, controller_balance_5)
+        self.assertEqual(operator_balance_6, operator_balance_5 - 1)
+        self.assertEqual(user_balance_6, user_balance_5)
+
 
 class TestCreatePoolV1(TestPoolOperations):
     def setUp(self):