more tests

Author: thedavidmeister

src/abstract/OwnerFreezable.sol

@@ -105,7 +105,7 @@ abstract contract OwnerFreezable is Ownable, IOwnerFreezableV1 {
         // Emit the event with the new protected time. We do this even if the
         // protected time is unchanged so that we can track the history of
         // protections offchain.
-        emit OwnerFreezeAlwaysAllowedFrom(owner(), from, protectUntil);
+        emit OwnerFreezeAlwaysAllowedFrom(owner(), from, protectUntil, sAlwaysAllowedFroms[from]);
     }
 
     /// @inheritdoc IOwnerFreezableV1
@@ -117,7 +117,7 @@ abstract contract OwnerFreezable is Ownable, IOwnerFreezableV1 {
         }
 
         delete sAlwaysAllowedFroms[from];
-        emit OwnerFreezeAlwaysAllowedFrom(owner(), from, 0);
+        emit OwnerFreezeAlwaysAllowedFrom(owner(), from, 0, 0);
     }
 
     /// @inheritdoc IOwnerFreezableV1

src/interface/IOwnerFreezableV1.sol

@@ -48,9 +48,14 @@ interface IOwnerFreezableV1 is IERC5313 {
     /// Owner added a `from` address to the always allowed list.
     /// @param owner The address of the owner.
     /// @param from The address that is always allowed to send.
+    /// @param targetProtectedUntil The timestamp the owner attempted to protect
+    /// the `from` until. Can be less than the actual protection if a previous
+    /// call already set it higher.
     /// @param protectedUntil The timestamp until the `from` address is unable to
     /// be removed from the always allowed list.
-    event OwnerFreezeAlwaysAllowedFrom(address owner, address from, uint256 protectedUntil);
+    event OwnerFreezeAlwaysAllowedFrom(
+        address owner, address from, uint256 targetProtectedUntil, uint256 protectedUntil
+    );
 
     /// Owner added a `to` address to the always allowed list.
     /// @param owner The address of the owner.

test/abstract/OwnerFreezableOwnerFreezeUntilTest.sol

@@ -21,6 +21,14 @@ abstract contract OwnerFreezableOwnerFreezeUntilTest is Test {
         assertEq(sOwnerFreezable.ownerFrozenUntil(), expectedFreeze);
     }
 
+    function checkOwnerFreezeAlwaysAllowFrom(address from, uint256 protectUntil, uint256 expectedProtect) internal {
+        vm.prank(sAlice);
+        vm.expectEmit(true, true, true, true);
+        emit IOwnerFreezableV1.OwnerFreezeAlwaysAllowedFrom(sAlice, from, protectUntil, expectedProtect);
+        sOwnerFreezable.ownerFreezeAlwaysAllowFrom(from, protectUntil);
+        assertEq(sOwnerFreezable.ownerFreezeAlwaysAllowedFrom(from), expectedProtect);
+    }
+
     function testOwnerIsAlice() external {
         assertEq(sOwnerFreezable.owner(), sAlice);
     }
@@ -84,9 +92,7 @@ abstract contract OwnerFreezableOwnerFreezeUntilTest is Test {
         sOwnerFreezable.ownerFreezeAlwaysAllowFrom(from, protectUntil);
         assertEq(sOwnerFreezable.ownerFreezeAlwaysAllowedFrom(from), 0);
 
-        vm.prank(sAlice);
-        sOwnerFreezable.ownerFreezeAlwaysAllowFrom(from, protectUntil);
-        assertEq(sOwnerFreezable.ownerFreezeAlwaysAllowedFrom(from), protectUntil);
+        checkOwnerFreezeAlwaysAllowFrom(from, protectUntil, protectUntil);
     }
 
     /// Calling ownerFreezeAlwaysAllowFrom with a zero protectUntil reverts.
@@ -95,4 +101,22 @@ abstract contract OwnerFreezableOwnerFreezeUntilTest is Test {
         vm.prank(sAlice);
         sOwnerFreezable.ownerFreezeAlwaysAllowFrom(from, 0);
     }
+
+    /// Calling ownerFreezeAlwaysAllowFrom twice with increasing times always uses newer times.
+    function testOwnerFreezableAlwaysAllowFromIncrement(address from, uint256 a, uint256 b) external {
+        vm.assume(a != 0);
+        b = bound(b, a, type(uint256).max);
+
+        checkOwnerFreezeAlwaysAllowFrom(from, a, a);
+        checkOwnerFreezeAlwaysAllowFrom(from, b, b);
+    }
+
+    /// Calling ownerFreezeAlwaysAllowFrom twice with decreasing times retains the first time.
+    function testOwnerFreezableAlwaysAllowFromDecrement(address from, uint256 a, uint256 b) external {
+        vm.assume(a != 0);
+        b = bound(b, 1, a);
+
+        checkOwnerFreezeAlwaysAllowFrom(from, a, a);
+        checkOwnerFreezeAlwaysAllowFrom(from, b, a);
+    }
 }