Question

The apply phase of save may fail and/or is still being done asynchronously before next not strongly-consistent read — non ancestor query.

Based on local testing article I have wrote a test that should simulate inconsistent reads:

import dev_appserver

dev_appserver.fix_sys_path()

import unittest
from google.appengine.ext import ndb
from google.appengine.ext import testbed
from google.appengine.datastore import datastore_stub_util

class SomeModel(ndb.Model):
    pass

class SingleEntityConsistency(unittest.TestCase):
    def setUp(self):
        # Setup AppEngine env
        self.testbed = testbed.Testbed()
        self.testbed.activate()
        self.policy = datastore_stub_util.PseudoRandomHRConsistencyPolicy(probability=0)
        self.testbed.init_datastore_v3_stub(consistency_policy=self.policy)
        self.testbed.init_memcache_stub()
        # A test key
        self.key = ndb.Key('SomeModel', 'test')

    def tearDown(self):
        self.testbed.deactivate()

    def test_tx_get_or_insert(self):
        p = SomeModel.get_or_insert('test')
        self.assertEqual(0, SomeModel.query().count(1), "Shouldn't be applied yet")
        self.assertEqual(1, SomeModel.query(ancestor=self.key).count(1), "Ancestor query read should be consistent")

    def test_no_tx_insert(self):
        p = SomeModel(id='test')
        p.put()
        self.assertEqual(0, SomeModel.query().count(2), "Shouldn't be applied yet")
        self.assertEqual(1, SomeModel.query(ancestor=self.key).count(1), "Ancestor query read should be consistent")

    def test_with_ancestor(self):
        p = SomeModel(id='test')
        p.put()
        self.assertEqual(p, SomeModel.query(ancestor=self.key).get())

    def test_key(self):
        p = SomeModel(id='test')
        p.put()
        self.assertEqual(p, self.key.get())

if __name__ == '__main__':
    unittest.main()

Actual questions…

1. Does wrapping put() in transaction change behaviour described in the beginning? Do I still need a strongly consistent query to make a sure that I’ll read was was written in the txn? (tests suggest that, I still need strongly consistent query)

2. Is key.get() considered to be strongly-consistent? (tests suggest that, it is)

UPDATE

I have updated test code as Guido mentioned, now all test pass:

self.testbed.init_datastore_v3_stub(consistency_policy=self.policy)

Answer 1

I believe you must do something to activate the policy. That would explain the test failures. Also I believe only queries are affected and a lone put is effectively a transaction. Finally beware of NDB’s caches.