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_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_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_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 add_software():
software = Software(software=request.form["software"])
db.session.add(software)
db.session.commit()
flash("Software %s created" % software.software)
return redirect(url_for("single_software_ui", software_id=software.id),
SEE_OTHER)
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)
