Improved logic for 'allow_offline' and 'offline subkey writes'

veilid-python/tests/test_dht.py

@@ -253,6 +253,130 @@ async def test_open_writer_dht_value(api_connection: veilid.VeilidAPI):
         await rc.delete_dht_record(key)
 
 
+@pytest.mark.asyncio
+async def test_open_writer_dht_value_no_offline(api_connection: veilid.VeilidAPI):
+    rc = await api_connection.new_routing_context()
+    async with rc:
+        rec = await rc.create_dht_record(veilid.DHTSchema.dflt(2))
+        key = rec.key
+        owner = rec.owner
+        secret = rec.owner_secret
+        #print(f"key:{key}")
+
+        cs = await api_connection.get_crypto_system(rec.key.kind())
+        async with cs:
+            assert await cs.validate_key_pair(owner, secret)
+            other_keypair = await cs.generate_key_pair()
+
+        va = b"Qwertyuiop Asdfghjkl Zxcvbnm"
+        vb = b"1234567890"
+        vc = b"!@#$%^&*()"
+
+        # Test subkey writes
+        vdtemp = await rc.set_dht_value(key, ValueSubkey(1), va, veilid.SetDHTValueOptions(None, False))
+        assert vdtemp is None
+
+        vdtemp = await rc.get_dht_value(key, ValueSubkey(1), False)
+        assert vdtemp.data == va
+        assert vdtemp.seq == 0
+        assert vdtemp.writer == owner
+
+        vdtemp = await rc.get_dht_value(key, ValueSubkey(0), False)
+        assert vdtemp is None
+
+        vdtemp = await rc.set_dht_value(key, ValueSubkey(0), vb, veilid.SetDHTValueOptions(None, False))
+        assert vdtemp is None
+
+        await sync(rc, [rec])
+
+        vdtemp = await rc.get_dht_value(key, ValueSubkey(0), True)
+        assert vdtemp.data == vb
+
+        vdtemp = await rc.get_dht_value(key, ValueSubkey(1), True)
+        assert vdtemp.data == va
+
+        # Equal value should not trigger sequence number update
+        vdtemp = await rc.set_dht_value(key, ValueSubkey(1), va, veilid.SetDHTValueOptions(None, False))
+        assert vdtemp is None
+
+        # Different value should trigger sequence number update
+        vdtemp = await rc.set_dht_value(key, ValueSubkey(1), vb, veilid.SetDHTValueOptions(None, False))
+        assert vdtemp is None
+
+        # Now that we initialized some subkeys
+        # and verified they stored correctly
+        # Delete things locally and reopen and see if we can write
+        # with the same writer key
+
+        await rc.close_dht_record(key)
+        await rc.delete_dht_record(key)
+
+        rec = await rc.open_dht_record(key, veilid.KeyPair.from_parts(owner, secret))
+        assert rec is not None
+        assert rec.key == key
+        assert rec.owner == owner
+        assert rec.owner_secret == secret
+        assert rec.schema.kind == veilid.DHTSchemaKind.DFLT
+        assert rec.schema.o_cnt == 2
+
+        # Verify subkey 1 can be set before it is get but newer is available online
+        vdtemp = await rc.set_dht_value(key, ValueSubkey(1), vc, veilid.SetDHTValueOptions(None, False))
+        assert vdtemp is not None
+        assert vdtemp.data == vb
+        assert vdtemp.seq == 1
+        assert vdtemp.writer == owner
+
+        # Verify subkey 1 can be set a second time and it updates because seq is newer
+        vdtemp = await rc.set_dht_value(key, ValueSubkey(1), vc, veilid.SetDHTValueOptions(None, False))
+        assert vdtemp is None
+
+        # Verify the network got the subkey update with a refresh check
+        vdtemp = await rc.get_dht_value(key, ValueSubkey(1), True)
+        assert vdtemp is not None
+        assert vdtemp.data == vc
+        assert vdtemp.seq == 2
+        assert vdtemp.writer == owner
+
+        # Delete things locally and reopen and see if we can write
+        # with a different writer key (should fail)
+
+        await rc.close_dht_record(key)
+        await rc.delete_dht_record(key)
+
+        rec = await rc.open_dht_record(key, other_keypair)
+        assert rec is not None
+        assert rec.key == key
+        assert rec.owner == owner
+        assert rec.owner_secret is None
+        assert rec.schema.kind == veilid.DHTSchemaKind.DFLT
+        assert rec.schema.o_cnt == 2
+
+        # Verify subkey 1 can NOT be set because we have the wrong writer
+        with pytest.raises(veilid.VeilidAPIError):
+            await rc.set_dht_value(key, ValueSubkey(1), va, veilid.SetDHTValueOptions(None, False))
+
+        # Verify subkey 0 can NOT be set because we have the wrong writer
+        with pytest.raises(veilid.VeilidAPIError):
+            await rc.set_dht_value(key, ValueSubkey(0), va, veilid.SetDHTValueOptions(None, False))
+
+        # Verify subkey 0 can be set because override with the right writer
+        # Should have prior sequence number as its returned value because it exists online at seq 0
+        vdtemp = await rc.set_dht_value(key, ValueSubkey(0), va, veilid.SetDHTValueOptions(veilid.KeyPair.from_parts(owner, secret), False))
+        assert vdtemp is not None
+        assert vdtemp.data == vb
+        assert vdtemp.seq == 0
+        assert vdtemp.writer == owner
+
+        # Should update the second time to seq 1
+        vdtemp = await rc.set_dht_value(key, ValueSubkey(0), va, veilid.SetDHTValueOptions(veilid.KeyPair.from_parts(owner, secret), False))
+        assert vdtemp is None
+
+        # Clean up
+        await rc.close_dht_record(key)
+        await rc.delete_dht_record(key)
+
+
+
 @pytest.mark.skipif(os.getenv("INTEGRATION") != "1", reason="integration test requires two servers running")
 @pytest.mark.asyncio
 async def test_watch_dht_values():
@@ -793,7 +917,7 @@ async def test_dht_write_read_full_subkeys_local():
             # Secret to encrypt test data
             SECRET = veilid.SharedSecret.from_bytes(b"A"*32)
             # Max subkey size
-            MAX_SUBKEY_SIZE = min(32768, 1024*1024/SUBKEY_COUNT)
+            MAX_SUBKEY_SIZE = min(32768, 1024*1024//SUBKEY_COUNT)
             # MAX_SUBKEY_SIZE = 256
 
             # write dht records on server 0