def testMapSecurity(self):
c1 = self.new_client(perms="rwr---")
u1 = c1.sf.getUpdateService()
a1 = c1.sf.getAdminService()
g1 = a1.getEventContext().groupName
m1 = omero.model.MapAnnotationI()
m1.setMapValue([NV("foo", "bar")])
m1 = u1.saveAndReturnObject(m1)
# Now create another user and try to edit
c2 = self.new_client(group=g1)
q2 = c2.sf.getQueryService()
u2 = c2.sf.getUpdateService()
m2 = q2.get("MapAnnotation", m1.id.val)
assert not m2.details.permissions.canEdit()
# Additions fail
m2.getMapValue().append(NV("edited-by", str(c2)))
with pytest.raises(omero.SecurityViolation):
u2.saveAndReturnObject(m2)
# Removals fail
m2.setMapValue([])
with pytest.raises(omero.SecurityViolation):
u2.saveAndReturnObject(m2)
# Also via a None
m2.setMapValue(None)
with pytest.raises(omero.SecurityViolation):
u2.saveAndReturnObject(m2)
# Alterations fail
m2.setMapValue([NV("foo", "WRONG")])
with pytest.raises(omero.SecurityViolation):
u2.saveAndReturnObject(m2)
def create_fileset(self, folder):
fileset = omero.model.FilesetI()
for f in folder.files():
entry = omero.model.FilesetEntryI()
entry.setClientPath(rstring(str(f.abspath())))
fileset.addFilesetEntry(entry)
# Fill version info
system, node, release, version, machine, processor = platform.uname()
clientVersionInfo = [
NV('omero.version', omero_version),
NV('os.name', system),
NV('os.version', release),
NV('os.architecture', machine)
]
try:
clientVersionInfo.append(NV('locale',
locale.getdefaultlocale()[0]))
except:
pass
upload = omero.model.UploadJobI()
upload.setVersionInfo(clientVersionInfo)
fileset.linkJob(upload)
return fileset
def testEmptyItem(self):
a = MapAnnotationI()
a.setMapValue([NV('Name1', 'Value1'), NV('Name2', 'Value2')])
a = self.update.saveAndReturnObject(a)
m = self.query.findAllByQuery((
"from MapAnnotation m "
"join fetch m.mapValue a "
"where a.name='Name2'"), None)[0]
l1 = m.getMapValue()
assert l1[0] is None
self.assertNV(l1[1], "Name2", "Value2")
assert {"Name2": "Value2"} == m.getMapValueAsMap()
def testAsMapMethod(self):
g = omero.model.ExperimenterGroupI()
g.setConfig(
[NV("foo", "bar")]
)
m = g.getConfigAsMap()
assert m["foo"] == "bar"
def on_go(self, ctx, args):
from omero.model import NamedValue as NV
argc = len(self.tx_cmd.arg_list)
if argc not in [4, 5]:
ctx.die(335, "usage: map-set OBJ FIELD KEY [VALUE]")
field = self.tx_cmd.arg_list[2]
current = getattr(self.obj, field)
if current is None:
setattr(self.obj, field, [])
if argc == 4:
name = self.tx_cmd.arg_list[3]
current = [nv for nv in current if nv and nv.name != name]
setattr(self.obj, field, current)
else:
name, value = self.tx_cmd.arg_list[3:]
state = None
for nv in current:
if nv and nv.name == name:
nv.value = value
state = "SET"
break
if state != "SET":
current.append(NV(name, value))
self.save_and_return(ctx)
def testMapStringField(self):
uuid = self.uuid()
queryService = self.root.getSession().getQueryService()
updateService = self.root.getSession().getUpdateService()
group = ExperimenterGroupI()
group.setName(rstring(uuid))
group.setLdap(rbool(False))
group.setConfig([NV("language", "python")])
group = updateService.saveAndReturnObject(group)
group = queryService.findByQuery(
("select g from ExperimenterGroup g join fetch g.config "
"where g.id = %s" % group.getId().getValue()), None)
self.assertNV(group.getConfig()[0], "language", "python")
def testGroupConfigEdit(self):
before = [
NV("a", "b"),
NV("c", "d"),
NV("e", "f")
]
remove_one = [
NV("a", "b"),
NV("e", "f")
]
swapped = [
NV("e", "f"),
NV("a", "b")
]
edited = [
NV("e", "f"),
NV("a", "x")
]
root_update = self.root.sf.getUpdateService()
group = self.new_group()
group.setConfig(before)
group = root_update.saveAndReturnObject(group)
self.assertNVs(before, group.getConfig())
del group.getConfig()[1]
group = root_update.saveAndReturnObject(group)
self.assertNVs(remove_one, group.getConfig())
old = list(group.getConfig())
self.assertNVs(old, remove_one)
group.setConfig([old[1], old[0]])
group = root_update.saveAndReturnObject(group)
self.assertNVs(swapped, group.getConfig())
group.getConfig()[1].value = "x"
group = root_update.saveAndReturnObject(group)
self.assertNVs(edited, group.getConfig())
def testBigKeys(self):
uuid = self.uuid()
big = uuid + "X" * 500
a = MapAnnotationI()
a.setMapValue([NV(big, big)])
a = self.update.saveAndReturnObject(a)
m = self.query.findAllByQuery((
"from MapAnnotation m "
"join fetch m.mapValue a "
"where a.name like :name"),
omero.sys.ParametersI().addString("name",
uuid + "%")
)[0]
l1 = m.getMapValue()
self.assertNV(l1[0], big, big)
def testMapEagerFetch(self):
m = omero.model.MapAnnotationI()
m.setMapValue(
[NV("foo", "bar")]
)
m = self.update.saveAndReturnObject(m)
anns = self.query.findAllByQuery(
"select m from MapAnnotation m ",
None)
self.assertMapAnnotation(anns, m.id.val)
# Add a second annotation and query both
c = omero.model.CommentAnnotationI()
c = self.update.saveAndReturnObject(c)
anns = self.query.findAllByQuery(
"select m from Annotation m ",
None)
self.assertMapAnnotation(anns, m.id.val)
# Now place both on an image and retry
i = omero.model.ImageI()
i.setName(omero.rtypes.rstring("testMapEagerFetch"))
i.linkAnnotation(m)
i.linkAnnotation(c)
i = self.update.saveAndReturnObject(i)
imgs = self.query.findByQuery(
("select i from Image i join fetch "
"i.annotationLinks l join fetch l.child "
"where i.id = :id"),
omero.sys.ParametersI().addId(i.id.val))
anns = imgs.linkedAnnotationList()
self.assertMapAnnotation(anns, m.id.val)
# And now load via IMetadata
meta = self.client.sf.getMetadataService()
anns = meta.loadAnnotations(
"omero.model.Image",
[i.id.val],
[], # Supported Annotation types
[], # Annotator IDs
None)
self.assertMapAnnotation(anns[i.id.val], m.id.val)
def on_go(self, ctx, args):
from omero.model import NamedValue as NV
if len(self.tx_cmd.arg_list) != 5:
ctx.die(335, "usage: map-set OBJ FIELD KEY VALUE")
field = self.tx_cmd.arg_list[2]
current = getattr(self.obj, field)
if current is None:
setattr(self.obj, field, [])
name, value = self.tx_cmd.arg_list[3:]
state = None
for nv in current:
if nv and nv.name == name:
nv.value = value
state = "SET"
break
if state != "SET":
current.append(NV(name, value))
self.save_and_return(ctx)
def testPolicyGroupRestriction(self, tmpdir, fixture):
parts = fixture.cfg.split(",")
config = [NV("omero.policy.binary_access", x) for x in parts]
group = self.new_group(perms='rwr---', config=config)
self.do_restrictions(fixture, tmpdir, group)
class TestMapAnnotation(lib.ITest):
def assertNV(self, nv, name, value):
assert name == nv.name
assert value == nv.value
def assertNVs(self, nvl1, nvl2):
for i in range(max(len(nvl1), len(nvl2))):
assert nvl1[i].name == nvl2[i].name
assert nvl1[i].value == nvl2[i].value
def testMapStringField(self):
uuid = self.uuid()
queryService = self.root.getSession().getQueryService()
updateService = self.root.getSession().getUpdateService()
group = ExperimenterGroupI()
group.setName(rstring(uuid))
group.setLdap(rbool(False))
group.setConfig([NV("language", "python")])
group = updateService.saveAndReturnObject(group)
group = queryService.findByQuery(
("select g from ExperimenterGroup g join fetch g.config "
"where g.id = %s" % group.getId().getValue()), None)
self.assertNV(group.getConfig()[0], "language", "python")
@pytest.mark.parametrize("data", (
([NV("a", "")], [NV("a", "")]),
([NV("a", "b")], [NV("a", "b")]),
))
def testGroupConfigA(self, data):
save_value, expect_value = data
LOAD = ("select g from ExperimenterGroup g "
"left outer join fetch g.config where g.id = :id")
queryService = self.root.sf.getQueryService()
updateService = self.root.sf.getUpdateService()
params = omero.sys.ParametersI()
def load_group(id):
params.addId(id)
return queryService.findByQuery(LOAD, params)
group = self.new_group()
gid = group.id.val
group.config = save_value
updateService.saveObject(group)
group = load_group(gid)
config = unwrap(group.config)
self.assertNVs(expect_value, config)
name, value = unwrap(queryService.projection(
"""
select m.name, m.value from ExperimenterGroup g
left outer join g.config m where m.name = 'a'
and g.id = :id
""", omero.sys.ParametersI().addId(gid))[0])
self.assertNV(expect_value[0], name, value)
def testGroupConfigEdit(self):
before = [
NV("a", "b"),
NV("c", "d"),
NV("e", "f")
]
remove_one = [
NV("a", "b"),
NV("e", "f")
]
swapped = [
NV("e", "f"),
NV("a", "b")
]
edited = [
NV("e", "f"),
NV("a", "x")
]
root_update = self.root.sf.getUpdateService()
group = self.new_group()
group.setConfig(before)
group = root_update.saveAndReturnObject(group)
self.assertNVs(before, group.getConfig())
del group.getConfig()[1]
group = root_update.saveAndReturnObject(group)
self.assertNVs(remove_one, group.getConfig())
old = list(group.getConfig())
self.assertNVs(old, remove_one)
group.setConfig([old[1], old[0]])
group = root_update.saveAndReturnObject(group)
self.assertNVs(swapped, group.getConfig())
group.getConfig()[1].value = "x"
group = root_update.saveAndReturnObject(group)
self.assertNVs(edited, group.getConfig())
def testEmptyItem(self):
a = MapAnnotationI()
a.setMapValue([NV('Name1', 'Value1'), NV('Name2', 'Value2')])
a = self.update.saveAndReturnObject(a)
m = self.query.findAllByQuery((
"from MapAnnotation m "
"join fetch m.mapValue a "
"where a.name='Name2'"), None)[0]
l1 = m.getMapValue()
assert l1[0] is None
self.assertNV(l1[1], "Name2", "Value2")
assert {"Name2": "Value2"} == m.getMapValueAsMap()
def testBigKeys(self):
uuid = self.uuid()
big = uuid + "X" * 500
a = MapAnnotationI()
a.setMapValue([NV(big, big)])
a = self.update.saveAndReturnObject(a)
m = self.query.findAllByQuery((
"from MapAnnotation m "
"join fetch m.mapValue a "
"where a.name like :name"),
omero.sys.ParametersI().addString("name",
uuid + "%")
)[0]
l1 = m.getMapValue()
self.assertNV(l1[0], big, big)
