def test_process_failure_missing_package(self):
build_output = _setup_build_output("create_missing_package.json")
with database.session_scope() as session:
build = util.create_build(dict())
session.add(build)
session.commit()
build_id = build.id
manager.process_failure(build_id, build_output)
with database.session_scope() as session:
build = session.query(
database.Build).filter_by(id=build_id).first()
self.assertEqual(1, len(build.missing_packages))
package = build.missing_packages[0]
self.assertEqual("d057732059ea44a47760900cb5e4855d2bea8714",
package.package_id)
recipe_revision = package.recipe_revision
self.assertIsNotNone(recipe_revision)
self.assertEqual("f5c1ba6f1af634f500f7e0255619fecf4777965f",
recipe_revision.revision)
recipe = recipe_revision.recipe
self.assertIsNotNone(recipe)
self.assertEqual("base", recipe.name)
self.assertEqual("1.2.3", recipe.version)
self.assertEqual("mycompany", recipe.user)
self.assertEqual("stable", recipe.channel)
def test_complete_build_https(self):
with database.session_scope() as session:
session.add(util.create_build({"repo.https": True}))
self.agent.start()
self.assertEquals(
self.__wait_for_build_status(database.BuildStatus.success, 15),
database.BuildStatus.success)
def test_start_build(self):
with database.session_scope() as session:
session.add(util.create_build(dict()))
self.agent.start()
self.assertEquals(
self.__wait_for_build_status(database.BuildStatus.active, 15),
database.BuildStatus.active)
def test_start_new_builds(self):
with database.session_scope() as session:
session.add(util.create_build(dict()))
self.scheduler.start()
time.sleep(1)
self.scheduler.cancel()
self.scheduler.join()
self.assertTrue(self.linux_agent.process_builds.called)
self.assertTrue(self.windows_agent.process_builds.called)
def setUp(self):
super().setUp()
self.login()
with database.session_scope() as session:
build = util.create_build({
"build.with_dependencies": True,
"build.with_missing": True
})
session.add(build)
def _create_waiting_build(session,
ecosystem,
missing_packages=[],
missing_recipes=[]):
build = util.create_build({"ecosystem": ecosystem})
build.status = database.BuildStatus.error
build.missing_packages = missing_packages
build.missing_recipes = missing_recipes
session.add(build)
session.commit()
return build.id
def test_stop_build(self):
with database.session_scope() as session:
build = util.create_build({"repo.deadlock": True})
session.add(build)
self.agent.start()
self.__wait_for_build_status(database.BuildStatus.active, 15)
with database.session_scope() as session:
build = session.query(database.Build).first()
build.status = database.BuildStatus.stopping
self.assertEqual(
self.__wait_for_build_status(database.BuildStatus.stopped, 15),
database.BuildStatus.stopped)
def test_create_build_with_missing_recipe(self):
with database.session_scope() as session:
build = util.create_build(dict())
recipe = util.create_recipe(dict())
build.missing_recipes = [recipe]
session.add(build)
with database.session_scope() as session:
num_recipes = session.query(database.Recipe).count()
self.assertEqual(1, num_recipes)
recipe = session.query(database.Recipe).first()
self.assertEqual(1, len(recipe.waiting_builds))
def test_create_build_with_missing_package(self):
with database.session_scope() as session:
build = util.create_build(dict())
package = util.create_package(dict())
build.missing_packages = [package]
session.add(build)
with database.session_scope() as session:
num_packages = session.query(database.Package).count()
self.assertEqual(1, num_packages)
package = session.query(database.Package).first()
self.assertEqual(1, len(package.waiting_builds))
def test_complete_build_with_dependency(self):
with database.session_scope() as session:
session.add(
util.create_build({
"repo.dependent": True,
"ecosystem.empty_remote": True
}))
self.agent.start()
self.assertEquals(
self.__wait_for_build_status(database.BuildStatus.error, 15),
database.BuildStatus.error)
with database.session_scope() as session:
build = session.query(database.Build).first()
self.assertEquals(1, len(build.missing_recipes))
def test_process_success_remove_missing_items(self):
build_output = _setup_build_output("create.json")
with database.session_scope() as session:
build = util.create_build(dict())
build.missing_recipes = [util.create_recipe(dict())]
build.missing_packages = [util.create_package(dict())]
session.add(build)
session.commit()
build_id = build.id
manager.process_success(build_id, build_output)
with database.session_scope() as session:
build = session.query(
database.Build).filter_by(id=build_id).first()
self.assertEqual(0, len(build.missing_recipes))
self.assertEqual(0, len(build.missing_packages))
def test_process_failure_missing_package_no_revision(self):
build_output = _setup_build_output(
"create_missing_package_no_revision.json")
with database.session_scope() as session:
build = util.create_build(dict())
session.add(build)
session.commit()
build_id = build.id
manager.process_failure(build_id, build_output)
with database.session_scope() as session:
build = session.query(
database.Build).filter_by(id=build_id).first()
self.assertEqual(1, len(build.missing_packages))
recipe_revision = build.missing_packages[0].recipe_revision
self.assertIsNotNone(recipe_revision)
self.assertEqual("", recipe_revision.revision)
def test_process_failure_missing_recipe(self):
build_output = _setup_build_output("create_missing_recipe.json")
with database.session_scope() as session:
build = util.create_build(dict())
session.add(build)
session.commit()
build_id = build.id
manager.process_failure(build_id, build_output)
with database.session_scope() as session:
build = session.query(
database.Build).filter_by(id=build_id).first()
self.assertEqual(1, len(build.missing_recipes))
recipe = build.missing_recipes[0]
self.assertEqual("base", recipe.name)
self.assertEqual("1.2.3", recipe.version)
self.assertEqual("mycompany", recipe.user)
self.assertEqual("stable", recipe.channel)
def test_process_failure_missing_package_twice(self):
build_output_missing_package = _setup_build_output(
"create_missing_package.json")
build_output_missing_recipe = _setup_build_output(
"create_missing_recipe.json")
with database.session_scope() as session:
build = util.create_build(dict())
session.add(build)
session.commit()
build_id = build.id
manager.process_failure(build_id, build_output_missing_package)
manager.process_failure(build_id, build_output_missing_recipe)
with database.session_scope() as session:
build = session.query(
database.Build).filter_by(id=build_id).first()
self.assertEqual(0, len(build.missing_packages))
self.assertEqual(1, len(build.missing_recipes))
def test_process_success_existing_package(self):
build_output = _setup_build_output()
with database.session_scope() as session:
parameters = dict()
package = util.create_package(parameters)
session.add(package)
build = util.create_build(parameters)
session.add(build)
session.commit()
build_id = build.id
manager.process_success(build_id, build_output)
with database.session_scope() as session:
build = session.query(
database.Build).filter_by(id=build_id).first()
packages = session.query(database.Package).all()
self.assertEqual(1, len(packages))
self.assertEqual(1, build.package.id)
def test_process_success(self):
build_output = _setup_build_output()
with database.session_scope() as session:
build = util.create_build(dict())
session.add(build)
session.commit()
build_id = build.id
result = manager.process_success(build_id, build_output)
self.assertFalse("new_builds" in result.keys())
with database.session_scope() as session:
build = session.query(
database.Build).filter_by(id=build_id).first()
self.assertIsNotNone(build.package)
self.assertEqual("227220812d7ea3aa060187bae41abbc9911dfdfd",
build.package.package_id)
self.assertEqual("app", build.package.recipe_revision.recipe.name)
self.assertEqual("2b44d2dde63878dd279ebe5d38c60dfaa97153fb",
build.package.recipe_revision.revision)
def _create_build(session, ecosystem):
build = util.create_build({"ecosystem": ecosystem})
session.add(build)
session.commit()
return build.id
