def test_query_filter_with_greater_than_operator(self):
model_list = [BarModel(prop=1), BarModel(prop=2), BarModel(prop=3)]
job_utils.apply_query_to_models(
self.make_query(filters=[('prop', '>', 2)]), model_list)
self.assertEqual(model_list, [BarModel(prop=3)])
def test_query_with_limit(self):
model_list = [BarModel(prop=i) for i in python_utils.RANGE(10)]
job_utils.apply_query_to_models(self.make_query(limit=3), model_list)
self.assertEqual(model_list,
[BarModel(prop=i) for i in python_utils.RANGE(3)])
def _read_from_datastore_handler(self, pickled_query):
"""XML-RPC handler for a ReadFromDatastore request.
Args:
pickled_query: str. The encoded Apache Beam query to respect.
Returns:
str. The list of all models encoded as a pickled list of Apache Beam
entities.
"""
with self._datastore_lock:
# TODO(#11475): This is very wasteful and inefficient, but good
# enough for unit tests and local development. When we move to Cloud
# NDB we'll have the genuine datastoreio module, and we'll be able
# to delete this code entirely, so it's OK to depend on this
# implementation until then.
ndb_models = list(datastore_services.query_everything().iter())
beam_query = pickle.loads(pickled_query)
job_utils.apply_query_to_models(beam_query, ndb_models)
return pickle.dumps([
job_utils.get_beam_entity_from_ndb_model(model)
for model in ndb_models
])
def test_query_with_filter(self):
model_list = [BarModel(prop=i) for i in python_utils.RANGE(1, 10)]
job_utils.apply_query_to_models(
self.make_query(filters=[('prop', '>=', 3), ('prop', '<', 6)]),
model_list)
self.assertEqual(model_list,
[BarModel(prop=i) for i in python_utils.RANGE(3, 6)])
def test_query_by_project(self):
project_a_model = FooModel(app='a')
project_b_model = FooModel(app='b')
model_list = [project_a_model, project_b_model]
job_utils.apply_query_to_models(self.make_query(project='a'),
model_list)
self.assertEqual(model_list, [project_a_model])
def test_query_by_namespace(self):
namespace_a_model = FooModel(namespace='a')
namespace_b_model = FooModel(namespace='b')
model_list = [namespace_a_model, namespace_b_model]
job_utils.apply_query_to_models(self.make_query(namespace='a'),
model_list)
self.assertEqual(model_list, [namespace_a_model])
def test_query_by_kind(self):
foo_model = FooModel()
bar_model = BarModel()
model_list = [foo_model, bar_model]
job_utils.apply_query_to_models(self.make_query(kind='FooModel'),
model_list)
self.assertEqual(model_list, [foo_model])
def test_query_with_order_by_property_descending(self):
model_a = FooModel(prop='a')
model_b = FooModel(prop='b')
model_c = FooModel(prop='c')
model_list = [model_c, model_a, model_b]
job_utils.apply_query_to_models(
self.make_query(kind='FooModel', order=('-prop', )), model_list)
self.assertEqual(model_list, [model_c, model_b, model_a])
def test_query_filter_with_unsupported_operator_raises_value_error(self):
model_list = [BarModel(prop=1), BarModel(prop=2), BarModel(prop=3)]
with self.assertRaisesRegexp(ValueError, 'Unsupported comparison'):
job_utils.apply_query_to_models(
self.make_query(filters=[('prop', '!=', 2)]), model_list)
def test_query_with_no_kind_and_wrong_order_raises_value_error(self):
self.assertRaisesRegexp(
ValueError,
r'Query\(kind=None\) must also have order=\(\'__key__\',\)',
lambda: job_utils.apply_query_to_models(
self.make_query(kind=None, order=('prop', )), []))
