def test_unique(self):
job = Job()
softwareA = Software()
softwareB = Software()
softwareA.jobs = [job]
softwareA.software = "foo"
softwareB.jobs = [job]
softwareB.software = "foo"
db.session.add_all([job, softwareA, softwareB])
with self.assertRaises(DatabaseError):
db.session.commit()
def test_software_unique(self):
for agent_foobar in self.models(limit=1):
softwareA = Software()
softwareA.agent = [agent_foobar]
softwareA.software = "foo"
softwareA.version = "1.0.0"
softwareB = Software()
softwareB.agent = [agent_foobar]
softwareB.software = "foo"
softwareB.version = "1.0.0"
db.session.add_all([softwareA, softwareB])
with self.assertRaises(DatabaseError):
db.session.commit()
db.session.rollback()
def test_software_unique(self):
for agent_foobar in self.models(limit=1):
softwareA = Software()
softwareA.agent = [agent_foobar]
softwareA.software = "foo"
softwareA.version = "1.0.0"
softwareB = Software()
softwareB.agent = [agent_foobar]
softwareB.software = "foo"
softwareB.version = "1.0.0"
db.session.add_all([softwareA, softwareB])
with self.assertRaises(DatabaseError):
db.session.commit()
db.session.rollback()
def test_software(self):
for agent_foobar in self.models(limit=1):
db.session.add(agent_foobar)
# create some software version tags
software_version_objects = []
for software_name in ("foo", "bar", "baz"):
software = Software()
software.agents = [agent_foobar]
software.software = software_name
software_version = SoftwareVersion()
software_version.software = software
software_version.version = "1"
software_version.rank = 1
software_version_objects.append(
(software.software, software_version.version))
agent_foobar.software_versions.append(software_version)
db.session.commit()
agent_id = agent_foobar.id
db.session.remove()
agent = Agent.query.filter_by(id=agent_id).first()
self.assertIsNotNone(agent)
agent_software_versions = list(
(str(i.software.software), str(i.version))
for i in agent.software_versions)
software_version_objects.sort()
agent_software_versions.sort()
self.assertListEqual(agent_software_versions,
software_version_objects)
def test_insert(self):
# A job can not be created without a jobtype, create one first
jobtype = JobType()
jobtype.name = "foo"
jobtype.description = "this is a job type"
jobtype.classname = "Foobar"
jobtype.code = dedent("""
class Foobar(JobType):
pass""").encode("utf-8")
jobtype.mode = JobTypeLoadMode.OPEN
db.session.add(jobtype)
job = Job()
job.job_type = jobtype
software = Software()
software.jobs = [job]
software.software = "foo"
db.session.add_all([job, software])
db.session.commit()
job_id = job.id
software_id = software.id
db.session.remove()
software = Software.query.filter_by(id=software_id).first()
self.assertEqual(software.jobs[0].id, job_id)
self.assertEqual(software.software, "foo")
self.assertEqual(software.version, "any")
def test_software(self):
for agent_foobar in self.models(limit=1):
db.session.add(agent_foobar)
# create some software version tags
software_version_objects = []
for software_name in ("foo", "bar", "baz"):
software = Software()
software.agents = [agent_foobar]
software.software = software_name
software_version = SoftwareVersion()
software_version.software = software
software_version.version = "1"
software_version.rank = 1
software_version_objects.append((software.software,
software_version.version))
agent_foobar.software_versions.append(software_version)
db.session.commit()
agent_id = agent_foobar.id
db.session.remove()
agent = Agent.query.filter_by(id=agent_id).first()
self.assertIsNotNone(agent)
agent_software_versions = list(
(str(i.software.software), str(i.version))
for i in agent.software_versions)
software_version_objects.sort()
agent_software_versions.sort()
self.assertListEqual(agent_software_versions,
software_version_objects)
def test_unique(self):
# A job can not be created without a jobtype, create one first
jobtype = JobType()
jobtype.name = "foo"
jobtype.description = "this is a job type"
jobtype.classname = "Foobar"
jobtype.code = dedent("""
class Foobar(JobType):
pass""").encode("utf-8")
db.session.add(jobtype)
job = Job()
job.job_type = jobtype
software = Software()
software.software = "foo"
requirementA = JobSoftwareRequirement()
requirementB = JobSoftwareRequirement()
requirementA.job = job
requirementA.software = software
requirementB.job = job
requirementB.software = software
db.session.add_all([job, requirementA, requirementB])
with self.assertRaises(DatabaseError):
db.session.commit()
def test_null(self):
with self.assertRaises(DatabaseError):
model = Software()
db.session.add(model)
db.session.commit()
db.session.remove()
with self.assertRaises(DatabaseError):
tag = Software()
tag.software = "foo"
db.session.add(model)
db.session.commit()
def test_null(self):
with self.assertRaises(DatabaseError):
model = JobSoftwareRequirement()
db.session.add(model)
db.session.commit()
db.session.remove()
with self.assertRaises(DatabaseError):
software = Software()
software.software = "foo"
requirement = JobSoftwareRequirement()
requirement.software = software
db.session.add(requirement)
db.session.commit()
def test_insert(self):
# A job can not be created without a jobtype, create one first
jobtype = JobType()
jobtype.name = "foo"
jobtype.description = "this is a job type"
jobtype_version = JobTypeVersion()
jobtype_version.jobtype = jobtype
jobtype_version.version = 1
jobtype_version.classname = "Foobar"
jobtype_version.code = ("""
class Foobar(JobType):
pass""").encode("utf-8")
db.session.add(jobtype_version)
queue = JobQueue()
queue.name = "FooQueue"
job = Job()
job.title = "Test Job"
job.jobtype_version = jobtype_version
job.queue = queue
# Software requirement needs a software first
software = Software()
software.software = "foo"
requirement = JobSoftwareRequirement()
requirement.job = job
requirement.software = software
db.session.add(job)
db.session.commit()
job_id = job.id
requirement_id = requirement.id
requirement2 = JobSoftwareRequirement.query.\
filter_by(id=requirement_id).first()
self.assertEqual(requirement.job.id, job_id)
self.assertEqual(requirement2.software.software, "foo")
self.assertEqual(requirement2.min_version, None)
self.assertEqual(requirement2.max_version, None)
def put(self, software_rq):
"""
A ``PUT`` to this endpoint will create a new software tag under the
given URI or update an existing software tag if one exists.
Renaming existing software tags via this call is supported, but when
creating new ones, the included software name must be equal to the one in
the URI.
You should only call this by id for overwriting an existing software tag
or if you have a reserved software id. There is currently no way to
reserve a tag id.
.. http:put:: /api/v1/software/<str:softwarename> HTTP/1.1
**Request**
.. sourcecode:: http
PUT /api/v1/software/blender HTTP/1.1
Accept: application/json
{
"software": "blender"
}
**Response**
.. sourcecode:: http
HTTP/1.1 201 CREATED
Content-Type: application/json
{
"id": 4,
"software": "blender",
"versions": []
}
**Request**
.. sourcecode:: http
PUT /api/v1/software/blender HTTP/1.1
Accept: application/json
{
"software": "blender",
"version": [
{
"version": "1.69"
}
]
}
**Response**
.. sourcecode:: http
HTTP/1.1 201 CREATED
Content-Type: application/json
{
"id": 4,
"software": "blender",
"versions": [
{
"version": "1.69",
"id": 1,
"rank": 100
}
]
}
:statuscode 200: an existing software tag was updated
:statuscode 201: a new software tag was created
:statuscode 400: there was something wrong with the request (such as
invalid columns being included)
"""
if isinstance(software_rq, STRING_TYPES):
if g.json["software"] != software_rq:
return jsonify(error="""The name of the software must be equal
to the one in the URI."""), BAD_REQUEST
software = Software.query.filter_by(software=software_rq).first()
else:
software = Software.query.filter_by(id=software_rq).first()
new = False if software else True
if not software:
software = Software()
# This is only checked when creating new software. Otherwise,
# renaming is allowed
if g.json["software"] != software_rq:
return jsonify(error="""The name of the software must be equal
to the one in the URI."""), BAD_REQUEST
# If this endpoint specified by id, make sure to create the new
# software under this same id, too
if isinstance(software_rq, int):
software.id = software_rq
software.software = g.json["software"]
if "versions" in g.json:
software.versions = []
db.session.flush()
versions = extract_version_dicts(g.json)
current_rank = 100
for version_dict in versions:
version_dict.setdefault("rank", current_rank)
version = SoftwareVersion(**version_dict)
version.software = software
current_rank = max(version.rank, current_rank) + 100
db.session.add(software)
try:
db.session.commit()
except DatabaseError:
return jsonify(error="Database error"), INTERNAL_SERVER_ERROR
software_data = software.to_dict()
logger.info("created software %s: %r", software.id, software_data)
return jsonify(software_data), CREATED if new else OK