def load_target(pid, psid, did, dsid, spnid):
store = IStore(Product)
p, ps, d, ds, spn = map(
lambda (cls, id): store.get(cls, id) if id is not None else None,
zip((Product, ProductSeries, Distribution, DistroSeries,
SourcePackageName), (pid, psid, did, dsid, spnid)))
return bug_target_from_key(p, ps, d, ds, spn)
def findFromMany(self, object_ids, types=None):
from lp.registry.model.person import Person
object_ids = list(object_ids)
if not object_ids:
return {}
store = IStore(XRef)
extract_type = lambda id: id[0]
rows = list(
store.using(XRef).find(
(XRef.from_type, XRef.from_id, XRef.to_type, XRef.to_id,
XRef.creator_id, XRef.date_created, XRef.metadata),
Or(*[
And(XRef.from_type == from_type,
XRef.from_id.is_in([id[1] for id in group]))
for from_type, group in groupby(
sorted(object_ids, key=extract_type), extract_type)
]),
XRef.to_type.is_in(types) if types is not None else True))
bulk.load(Person, [row[4] for row in rows])
result = {}
for row in rows:
result.setdefault((row[0], row[1]), {})[(row[2], row[3])] = {
"creator": store.get(Person, row[4]) if row[4] else None,
"date_created": row[5],
"metadata": row[6]
}
return result
def _preloadProcessors(self, rows):
# Grab (Builder.id, Processor.id) pairs and stuff them into the
# Builders' processor caches.
store = IStore(BuilderProcessor)
pairs = list(
store.using(BuilderProcessor, Processor).find(
(BuilderProcessor.builder_id, BuilderProcessor.processor_id),
BuilderProcessor.processor_id == Processor.id,
BuilderProcessor.builder_id.is_in([
b.id for b in rows
])).order_by(BuilderProcessor.builder_id, Processor.name))
load(Processor, [pid for bid, pid in pairs])
for row in rows:
get_property_cache(row)._processors_cache = []
for bid, pid in pairs:
cache = get_property_cache(store.get(Builder, bid))
cache._processors_cache.append(store.get(Processor, pid))
def load_target(pid, psid, did, dsid, spnid):
store = IStore(Product)
p, ps, d, ds, spn = map(
lambda (cls, id): store.get(cls, id) if id is not None else None,
zip((Product, ProductSeries, Distribution, DistroSeries,
SourcePackageName),
(pid, psid, did, dsid, spnid)))
return bug_target_from_key(p, ps, d, ds, spn)
def _resolve(row):
store = IStore(SourcePackagePublishingHistory)
return tuple(
(value if cls is None else store.get(cls, value))
for value, cls in zip(row, lookups))
def _resolve(row):
store = IStore(SourcePackagePublishingHistory)
return tuple(
(value if cls is None else store.get(cls, value))
for value, cls in zip(row, lookups))
def test_createMultiple_defaults_requester_to_None(self):
store = IStore(Job)
job = store.get(Job, Job.createMultiple(store, 1)[0])
self.assertEqual(None, job.requester)
def test_createMultiple_sets_requester(self):
store = IStore(Job)
requester = self.factory.makePerson()
job = store.get(Job, Job.createMultiple(store, 1, requester)[0])
self.assertEqual(requester, job.requester)
def test_createMultiple_sets_status_to_WAITING(self):
store = IStore(Job)
job = store.get(Job, Job.createMultiple(store, 1)[0])
self.assertEqual(JobStatus.WAITING, job.status)
def test_createMultiple_returns_valid_job_ids(self):
job_ids = list(Job.createMultiple(IStore(Job), 3))
store = IStore(Job)
for job_id in job_ids:
self.assertIsNot(None, store.get(Job, job_id))
