def GetEntities(project_id, json_lines, outer_parent_key=None, namespace=None):
"""Create gcloud entities from json string entries.
project_id: String gcloud project id that entities are for.
json_lines: File or other line-by-line iterator of json strings to turn into
entities.
outer_parent_key: Optional datastore.Key instance to act as the parent_key
of all top level entities.
namespace: Optional string namespace for entities.
"""
entity_keys = {}
for line in json_lines:
item = json.loads(line)
kind, idx = item.pop('id')
parent = item.pop('parent', None)
if (kind, idx) in entity_keys:
raise DuplicateKeyError(
'Duplicate entities with id (%s, %s)' % (kind, idx))
if parent:
parent_key = entity_keys[tuple(parent)]
else:
parent_key = outer_parent_key
key = datastore.Key(
kind, idx, project=project_id, parent=parent_key, namespace=namespace)
e = datastore.Entity(key=key)
e.update(item)
entity_keys[(kind, idx)] = key
entity_keys[idx] = key
yield e
def test_save_key_self_reference(self):
parent_key = datastore.Key('Residence', 'NewYork')
key = datastore.Key('Person', 'name', parent=parent_key)
entity = datastore.Entity(key=key)
entity['fullName'] = u'Full name'
entity['linkedTo'] = key # Self reference.
datastore.put([entity])
self.case_entities_to_delete.append(entity)
query = datastore.Query(kind='Person')
# Adding ancestor to ensure consistency.
query.ancestor = parent_key
query.add_filter('linkedTo', '=', key)
stored_persons = list(query.fetch(limit=2))
self.assertEqual(stored_persons, [entity])
def post(self):
entity = datastore.Entity(key=datastore.Key(ENTITY_KIND, project=PROJECT))
data = json.loads(self.request.body)
data['status'] = REQUEST_RECEIVED
entity['data'] = json.dumps(data)
ds.put(entity)
publish_msg(str(entity.key.id))
self.response.write(format_entity(entity))
def test_query___key___filter(self):
rickard_key = datastore.Key(*populate_datastore.RICKARD)
query = self._base_query()
query.add_filter('__key__', '=', rickard_key)
expected_matches = 1
# We expect 1, but allow the query to get 1 extra.
entities = list(query.fetch(limit=expected_matches + 1))
self.assertEqual(len(entities), expected_matches)
def add_characters():
with datastore.Transaction() as xact:
for key_path, character in zip(KEY_PATHS, CHARACTERS):
if key_path[-1] != character['name']:
raise ValueError(
('Character and key don\'t agree', key_path, character))
entity = datastore.Entity(key=datastore.Key(*key_path))
entity.update(character)
xact.put(entity)
print('Adding Character %s %s' %
(character['name'], character['family']))
def test_allocate_ids(self):
num_ids = 10
allocated_keys = datastore.allocate_ids(datastore.Key('Kind'), num_ids)
self.assertEqual(len(allocated_keys), num_ids)
unique_ids = set()
for key in allocated_keys:
unique_ids.add(key.id)
self.assertEqual(key.name, None)
self.assertNotEqual(key.id, None)
self.assertEqual(len(unique_ids), num_ids)
def test_mass_delete(self):
datastore_mock = Mock()
storage = DatastoreStorage(datastore_mock)
q_mock = Mock()
q_mock.fetch.return_value = [
Mock(key=datastore.Key('task', n, project='test'))
for n in range(102)
]
datastore_mock.query.return_value = q_mock
storage.delete_tasks()
assert datastore_mock.delete_multi.call_count == 2
def test_transaction(self):
entity = datastore.Entity(key=datastore.Key('Company', 'Google'))
entity['url'] = u'www.google.com'
with datastore.Transaction() as xact:
results = datastore.get([entity.key])
if len(results) == 0:
xact.put(entity)
self.case_entities_to_delete.append(entity)
# This will always return after the transaction.
retrieved_entity, = datastore.get([entity.key])
self.case_entities_to_delete.append(retrieved_entity)
self.assertEqual(retrieved_entity, entity)
def _get_post(self, id_or_name=None, post_content=None):
post_content = post_content or {
'title': u'How to make the perfect pizza in your grill',
'tags': [u'pizza', u'grill'],
'publishedAt': datetime.datetime(2001, 1, 1, tzinfo=pytz.utc),
'author': u'Silvano',
'isDraft': False,
'wordCount': 400,
'rating': 5.0,
}
# Create an entity with the given content.
entity = datastore.Entity(key=datastore.Key('Post'))
entity.update(post_content)
# Update the entity key.
if id_or_name is not None:
entity.key = entity.key.completed_key(id_or_name)
return entity
def test_save_key_self_reference(self):
key = datastore.Key('Person', 'name')
entity = datastore.Entity(key=key)
entity['fullName'] = u'Full name'
entity['linkedTo'] = key # Self reference.
with datastore.Transaction():
datastore.put([entity])
self.case_entities_to_delete.append(entity)
query = datastore.Query(kind='Person')
query.add_filter('linkedTo', '=', key)
stored_persons = list(query.fetch(limit=2))
self.assertEqual(len(stored_persons), 1)
stored_person = stored_persons[0]
self.assertEqual(stored_person['fullName'], entity['fullName'])
self.assertEqual(stored_person.key.path, key.path)
self.assertEqual(stored_person.key.namespace, key.namespace)
# See the License for the specific language governing permissions and
# limitations under the License.
# Welcome to the gCloud Datastore Demo! (hit enter)
# We're going to walk through some of the basics...
# Don't worry though. You don't need to do anything, just keep hitting enter...
# Let's start by importing the demo module and initializing our connection.
from gcloud import datastore
from gcloud.datastore import demo
demo.initialize()
# Let's import the package containing our helper classes:
# Let's create a new entity of type "Thing" and name it 'Toy':
key = datastore.Key('Thing')
toy = datastore.Entity(key)
toy.update({'name': 'Toy'})
# Now let's save it to our datastore:
datastore.put([toy])
# If we look it up by its key, we should find it...
print(datastore.get([toy.key]))
# And we should be able to delete it...
datastore.delete([toy.key])
# Since we deleted it, if we do another lookup it shouldn't be there again:
print(datastore.get([toy.key]))
class TestDatastoreSave(TestDatastore):
PARENT = datastore.Key('Blog', 'PizzaMan')
def _get_post(self, id_or_name=None, post_content=None):
post_content = post_content or {
'title': u'How to make the perfect pizza in your grill',
'tags': [u'pizza', u'grill'],
'publishedAt': datetime.datetime(2001, 1, 1, tzinfo=pytz.utc),
'author': u'Silvano',
'isDraft': False,
'wordCount': 400,
'rating': 5.0,
}
# Create an entity with the given content.
# NOTE: Using a parent to ensure consistency for query
# in `test_empty_kind`.
key = datastore.Key('Post', parent=self.PARENT)
entity = datastore.Entity(key=key)
entity.update(post_content)
# Update the entity key.
if id_or_name is not None:
entity.key = entity.key.completed_key(id_or_name)
return entity
def _generic_test_post(self, name=None, key_id=None):
entity = self._get_post(id_or_name=(name or key_id))
datastore.put([entity])
# Register entity to be deleted.
self.case_entities_to_delete.append(entity)
if name is not None:
self.assertEqual(entity.key.name, name)
if key_id is not None:
self.assertEqual(entity.key.id, key_id)
retrieved_entity, = datastore.get([entity.key])
# Check the given and retrieved are the the same.
self.assertEqual(retrieved_entity, entity)
def test_post_with_name(self):
self._generic_test_post(name='post1')
def test_post_with_id(self):
self._generic_test_post(key_id=123456789)
def test_post_with_generated_id(self):
self._generic_test_post()
def test_save_multiple(self):
with datastore.Transaction() as xact:
entity1 = self._get_post()
xact.put(entity1)
# Register entity to be deleted.
self.case_entities_to_delete.append(entity1)
second_post_content = {
'title': u'How to make the perfect homemade pasta',
'tags': [u'pasta', u'homemade'],
'publishedAt': datetime.datetime(2001, 1, 1),
'author': u'Silvano',
'isDraft': False,
'wordCount': 450,
'rating': 4.5,
}
entity2 = self._get_post(post_content=second_post_content)
xact.put(entity2)
# Register entity to be deleted.
self.case_entities_to_delete.append(entity2)
keys = [entity1.key, entity2.key]
matches = datastore.get(keys)
self.assertEqual(len(matches), 2)
def test_empty_kind(self):
query = datastore.Query(kind='Post')
query.ancestor = self.PARENT
posts = list(query.fetch(limit=2))
self.assertEqual(posts, [])
def setUpClass(cls):
super(TestDatastoreQuery, cls).setUpClass()
cls.CHARACTERS = populate_datastore.CHARACTERS
cls.ANCESTOR_KEY = datastore.Key(*populate_datastore.ANCESTOR)
