def test_multiple_upstream_jobs_recursive(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
parent_job_name = "test_multiple_upstream_jobs_recursive1"
jb = jk.create_job(parent_job_name, FreestyleJob)
with clean_job(jb):
expected_name1 = "test_multiple_upstream_jobs_recursive2"
jb2 = jk.create_job(expected_name1, FreestyleJob)
with clean_job(jb2):
expected_name2 = "test_multiple_upstream_jobs_recursive3"
jb3 = jk.create_job(expected_name2, FreestyleJob)
with clean_job(jb3):
publisher1 = BuildTriggerPublisher.instantiate([expected_name1])
jb.add_publisher(publisher1)
publisher2 = BuildTriggerPublisher.instantiate([expected_name2])
jb2.add_publisher(publisher2)
async_assert(lambda: len(jb3.all_upstream_jobs) == 2)
res = jb3.all_upstream_jobs
all_names = [parent_job_name, expected_name1]
assert isinstance(res, list)
assert len(res) == 2
assert res[0].name in all_names
assert res[1].name in all_names
assert isinstance(res[0], FreestyleJob)
assert isinstance(res[1], FreestyleJob)
def test_build_blocker_functionality(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
job_name1 = "test_build_blocker_functionality1"
jb1 = jk.create_job(job_name1, FreestyleJob)
with clean_job(jb1):
job_name2 = "test_build_blocker_functionality2"
jb2 = jk.create_job(job_name2, FreestyleJob)
with clean_job(jb2):
expected_jobs = job_name2
build_blocker = BuildBlockerProperty.instantiate(expected_jobs)
jb1.quiet_period = 0
jb1.add_property(build_blocker)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(job_name1).properties)
build_step = ShellBuilder.instantiate("sleep 10")
jb2.quiet_period = 0
jb2.add_builder(build_step)
async_assert(lambda: jb2.builders)
queue2 = jb2.start_build()
async_assert(lambda: not queue2.waiting)
queue1 = jb1.start_build()
assert job_name2 in queue1.reason
queue2.build.abort()
assert queue1.waiting is False
def test_artifacts_archived(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
job_name = "test_artifacts_archived_job"
jb = jk.create_job(job_name, FreestyleJob)
with clean_job(jb):
publisher = ArtifactArchiverPublisher.instantiate("*.txt")
jb.add_publisher(publisher)
# Wait until our publisher config get's applied
async_assert(lambda: jk.find_job(job_name).publishers)
expected_file = "test_artifacts_archived_job.txt"
shell_builder = ShellBuilder.instantiate("echo hello > " + expected_file)
jb.add_builder(shell_builder)
# Wait until our builder get's applied
async_assert(lambda: jk.find_job(job_name).builders)
# Next, trigger a build
jb.start_build()
async_assert(lambda: len(jb.all_builds) == 1)
# finally, make sure the list or archived artifacts looks correct
bld = jb.all_builds[0]
results = bld.artifact_urls
assert isinstance(results, list)
assert len(results) == 1
assert expected_file in results[0]
def test_basic_publisher(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
upstream_name = "test_basic_publisher"
jb = jk.create_job(upstream_name, FreestyleJob)
with clean_job(jb):
expected_regex = "*.log"
new_condition = AlwaysRun.instantiate()
new_pub = ArtifactArchiverPublisher.instantiate(expected_regex)
new_action = ConditionalAction.instantiate(new_condition, [new_pub])
pub = FlexiblePublisher.instantiate([new_action])
jb.add_publisher(pub)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(upstream_name).publishers)
pubs = jk.find_job(upstream_name).publishers
assert isinstance(pubs, list)
assert len(pubs) == 1
cur_pub = pubs[0]
assert isinstance(cur_pub, FlexiblePublisher)
assert isinstance(cur_pub.actions, list)
assert len(cur_pub.actions) == 1
cur_action = cur_pub.actions[0]
assert isinstance(cur_action, ConditionalAction)
assert isinstance(cur_action.publishers, list)
assert len(cur_action.publishers) == 1
cur_nested_pub = cur_action.publishers[0]
assert isinstance(cur_nested_pub, ArtifactArchiverPublisher)
assert cur_nested_pub.artifact_regex == expected_regex
def test_never_run_condition(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_job_name = "test_never_run_condition"
jb = jk.create_job(expected_job_name, FreestyleJob)
with clean_job(jb):
expected_output = "Here is my sample output..."
shell_builder = ShellBuilder.instantiate("echo " + expected_output)
condition = NeverRun.instantiate()
conditional_builder = ConditionalBuilder.instantiate(condition, shell_builder)
jb.add_builder(conditional_builder)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(expected_job_name).builders)
builders = jk.find_job(expected_job_name).builders
# Make sure the builder was correctly configured
assert builders[0].condition is not None
assert isinstance(builders[0].condition, NeverRun)
assert builders[0].condition.get_friendly_name() == "never"
# Finally, just to be sure our build actually did something relevant
# we make sure the output from our shell command appears in the
# build output for a build (ie: to ensure the conditional build step
# actually ran)
jb.start_build()
async_assert(lambda: jb.last_build)
assert expected_output not in jb.last_build.console_output
def test_one_downstream_job(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_one_downstream_job1", FreestyleJob)
with clean_job(jb):
expected_name = "test_one_downstream_job2"
jb2 = jk.create_job(expected_name, FreestyleJob)
with clean_job(jb2):
publisher = BuildTriggerPublisher.instantiate([expected_name])
jb.add_publisher(publisher)
async_assert(lambda: jb.downstream_jobs)
res = jb.downstream_jobs
assert isinstance(res, list)
assert len(res) == 1
assert res[0].name == expected_name
def test_add_artifact_deployer_publisher_entry(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
job_name = "test_add_artifact_deployer_publisher_entry"
jb = jk.create_job(job_name, FreestyleJob)
with clean_job(jb):
publisher = ArtifactDeployer.instantiate()
jb.add_publisher(publisher)
expected_regex = "*.txt"
expected_path = "/bin/data"
entry = ArtifactDeployerEntry.instantiate(expected_regex, expected_path)
publisher.add_entry(entry)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(job_name).publishers)
pubs = jk.find_job(job_name).publishers
assert len(pubs) == 1
cur_pub = pubs[0]
assert isinstance(cur_pub, ArtifactDeployer)
assert isinstance(cur_pub.entries, list)
assert len(cur_pub.entries) == 1
cur_entry = cur_pub.entries[0]
assert isinstance(cur_entry, ArtifactDeployerEntry)
assert cur_entry.includes == expected_regex
assert cur_entry.remote == expected_path
def test_add_conditional_builder(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_job_name = "test_add_conditional_builder"
jb = jk.create_job(expected_job_name, FreestyleJob)
with clean_job(jb):
expected_output = "Here is my sample output..."
expected_cmd = "echo " + expected_output
shell_builder = ShellBuilder.instantiate(expected_cmd)
condition = AlwaysRun.instantiate()
conditional_builder = ConditionalBuilder.instantiate(condition, shell_builder)
jb.add_builder(conditional_builder)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(expected_job_name).builders)
builders = jk.find_job(expected_job_name).builders
# Make sure the builder was successfully added and it's response
# data can be parsed correctly
assert isinstance(builders, list)
assert len(builders) == 1
assert isinstance(builders[0], ConditionalBuilder)
assert builders[0].builder is not None
assert isinstance(builders[0].builder, ShellBuilder)
assert builders[0].builder.script == expected_cmd
assert_elements_equal(builders[0].builder.node, shell_builder.node)
def test_add_then_edit_build_blocker(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
job_name = "test_add_then_edit_build_blocker"
jb = jk.create_job(job_name, FreestyleJob)
with clean_job(jb):
build_blocker = BuildBlockerProperty.instantiate("MyCoolJob")
jb.add_property(build_blocker)
# edit the original build blocker object - changes should still get
# applied to the underlying Jenkins job
expected_job_names = ["SomeOtherJob1", "SomeOtherJob2"]
build_blocker.blockers = expected_job_names
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(job_name).properties)
# Now, get a clean reference to the job
jb2 = jk.find_job(job_name)
props = jb2.properties
blockers = props[0].blockers
assert isinstance(blockers, list)
assert len(blockers) == 2
assert expected_job_names[0] in blockers
assert expected_job_names[1] in blockers
def test_build_git_scm(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
job_name = "test_build_git_scm"
jb = jk.create_job(job_name, FreestyleJob)
with clean_job(jb):
jb.quiet_period = 0
expected_url = "https://github.com/TheFriendlyCoder/pyjen.git"
test_scm = GitSCM.instantiate(expected_url)
jb.scm = test_scm
async_assert(lambda: isinstance(jb.scm, GitSCM))
# If the Git SCM was set up correctly, the job should check out the
# source code for pyjen into the workspace when building. That being
# the case there should be a setup.py script in the root folder. We
# can therefore check to see if the SCM operation completed successfully
# by looking for that file and setting a non-zero error code as part
# of a shell builder operation
shell_builder = ShellBuilder.instantiate("[ -f setup.py ]")
jb.add_builder(shell_builder)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(job_name).builders)
jb.start_build()
async_assert(lambda: jb.last_good_build or jb.last_failed_build)
assert jb.last_good_build is not None
def test_delete_job(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_name = "test_delete_job"
jb = jk.create_job(expected_name, FreestyleJob)
jb.delete()
res = jk.find_job(expected_name)
assert res is None
def test_create_multijob_job(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_name = "test_create_multijob_job"
jb = jk.create_job(expected_name, MultiJob)
with clean_job(jb):
assert jb is not None
assert jb.name == expected_name
def test_param_trigger(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
upstream_name = "test_param_trigger"
jb = jk.create_job(upstream_name, FreestyleJob)
with clean_job(jb):
downstream_name = "sample_job"
new_trigger = BuildTriggerConfig.instantiate([downstream_name])
pub = ParameterizedBuildTrigger.instantiate([new_trigger])
jb.add_publisher(pub)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(upstream_name).publishers)
pubs = jk.find_job(upstream_name).publishers
assert isinstance(pubs, list)
assert len(pubs) == 1
assert isinstance(pubs[0], ParameterizedBuildTrigger)
triggers = pubs[0].triggers
assert isinstance(triggers, list)
assert len(triggers) == 1
names = triggers[0].job_names
assert isinstance(names, list)
assert len(names) == 1
assert names[0] == downstream_name
assert triggers[0].condition == "SUCCESS"
def test_enable(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_enable", FreestyleJob)
with clean_job(jb):
jb.disable()
jb.enable()
assert not jb.is_disabled
def test_clone_job(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_clone_job", FreestyleJob)
with clean_job(jb):
# add a builder to our source job so we can check to make sure the
# configuration has been properly cloned
expected_script = "echo Hello From TestCloneJob"
failing_step = ShellBuilder.instantiate(expected_script)
jb.add_builder(failing_step)
async_assert(lambda: jb.builders)
# now, clone our job configuration and make sure the entire config
# has been cloned correctly
expected_name = "test_clone_job2"
jb_clone = jb.clone(expected_name)
with clean_job(jb_clone):
assert jb_clone is not None
assert jb_clone.name == expected_name
assert jb_clone.is_disabled
results = jb_clone.builders
assert results is not None
assert isinstance(results, list)
assert len(results) == 1
assert isinstance(results[0], ShellBuilder)
assert results[0].script == expected_script
def test_trigger_with_current_build_params(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
upstream_name = "test_trigger_with_current_build_params"
jb = jk.create_job(upstream_name, FreestyleJob)
with clean_job(jb):
downstream_name = "sample_job"
new_trigger = BuildTriggerConfig.instantiate([downstream_name])
cur_bld_params = CurrentBuildParams.instantiate()
new_trigger.add_build_param(cur_bld_params)
new_pub = ParameterizedBuildTrigger.instantiate([new_trigger])
jb.add_publisher(new_pub)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(upstream_name).publishers)
pubs = jk.find_job(upstream_name).publishers
assert len(pubs) == 1
cur_pub = pubs[0]
assert len(cur_pub.triggers) == 1
cur_trig = cur_pub.triggers[0]
assert len(cur_trig.build_params) == 1
cur_param_cfg = cur_trig.build_params[0]
assert isinstance(cur_param_cfg, CurrentBuildParams)
def test_wait_for_idle(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
node = jk.nodes[0]
expected_job_name = "test_wait_for_idle_job"
jb = jk.create_job(expected_job_name, FreestyleJob)
with clean_job(jb):
jb.quiet_period = 0
shell_builder = ShellBuilder.instantiate("sleep 2")
jb.add_builder(shell_builder)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(expected_job_name).builders)
# Trigger a build
jb.start_build()
# The 'last_build' reference becomes available as soon as the previously
# triggered build exits the queue and starts running. So we wait for the
# last build to become valid before checking the node activity
async_assert(lambda: jb.last_build)
assert node.is_idle is False
assert node.wait_for_idle()
assert node.is_idle
def test_quiet_period(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_quiet_period", FreestyleJob)
with clean_job(jb):
jb.quiet_period = 0
# first set our quiet period
expected_duration = 10
jb.quiet_period = expected_duration
expected_output = "Testing my quiet period"
failing_step = ShellBuilder.instantiate("echo " + expected_output)
jb.add_builder(failing_step)
async_assert(lambda: jb.builders)
assert jb.quiet_period_enabled is True
assert jb.quiet_period == expected_duration
# Launch a build and time how long it takes to complete
start = timeit.default_timer()
jb.start_build()
async_assert(lambda: jb.last_build, expected_duration + 5)
duration = timeit.default_timer() - start
assert duration >= expected_duration
bld = jb.last_build
assert expected_output in bld.console_output
def test_always_run_condition(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_job_name = "test_always_run_condition"
jb = jk.create_job(expected_job_name, FreestyleJob)
with clean_job(jb):
expected_output = "Here is my sample output..."
expected_cmd = "echo " + expected_output
shell_builder = ShellBuilder.instantiate(expected_cmd)
condition = AlwaysRun.instantiate()
conditional_builder = ConditionalBuilder.instantiate(condition, shell_builder)
jb.add_builder(conditional_builder)
# Wait until our job config has been applied successfully
async_assert(lambda: jk.find_job(expected_job_name).builders)
# Make sure the condition is loaded correctly
builders = jk.find_job(expected_job_name).builders
assert isinstance(builders[0].condition, AlwaysRun)
assert builders[0].condition.get_friendly_name() == "always"
# Run a build and make sure the build operation actually executed
jb.start_build()
async_assert(lambda: jb.last_build)
assert expected_output in jb.last_build.console_output
def test_clone_job_enabled(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_clone_job_enabled", FreestyleJob)
with clean_job(jb):
jb_clone = jb.clone("test_clone_job2", False)
with clean_job(jb_clone):
assert jb_clone is not None
assert jb_clone.is_disabled is False
def test_get_one_job(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_get_one_job", FreestyleJob)
with clean_job(jb):
res = jk.jobs
assert len(res) == 1
assert res[0] == jb
def test_disable_all_jobs(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_job_name = "test_disable_all_jobs_job"
jb = jk.create_job(expected_job_name, FreestyleJob)
with clean_job(jb):
vw = jk.default_view
vw.disable_all_jobs()
assert jb.is_disabled
def test_disable_assigned_node(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_disable_assigned_node", FreestyleJob)
with clean_job(jb):
jb.assigned_node = "MyNodeLabel && UnknownLabel"
jb2 = jk.find_job(jb.name)
jb2.assigned_node = ""
assert jb2.assigned_node_enabled is False
def test_create_folder_job_with_subjob(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_create_folder_job_with_subjob", FolderJob)
with clean_job(jb):
expected_name = "test_create_folder_job_with_subjob2"
jb2 = jb.create_job(expected_name, FreestyleJob)
assert jb2 is not None
with clean_job(jb2):
assert jb2.name == expected_name
def test_disable_custom_workspace(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_disable_custom_workspace", FreestyleJob)
with clean_job(jb):
jb.custom_workspace = "/delme"
jb2 = jk.find_job(jb.name)
jb2.custom_workspace = ""
assert jb2.custom_workspace_enabled is False
def test_assigned_node(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_assigned_node", FreestyleJob)
with clean_job(jb):
expected_label = "MyNodeLabel && UnknownLabel"
jb.assigned_node = expected_label
jb2 = jk.find_job(jb.name)
assert jb2.assigned_node_enabled is True
assert jb2.assigned_node == expected_label
def test_disable_quiet_period(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_disable_quiet_period", FreestyleJob)
with clean_job(jb):
jb.quiet_period = 0
jb2 = jk.find_job(jb.name)
assert jb2 is not None
jb2.quiet_period = -1
assert jb2.quiet_period_enabled is False
def test_get_builds_in_time_range_no_builds(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_get_builds_in_time_range_no_builds", FreestyleJob)
with clean_job(jb):
jb.quiet_period = 0
start_time = datetime.now() - timedelta(days=1)
end_time = datetime.now() + timedelta(days=1)
builds = jb.get_builds_in_time_range(start_time, end_time)
assert len(builds) == 0
def test_get_branch_jobs(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_name = "test_get_branch_jobs"
jb = jk.create_job(expected_name, MultibranchPipelineJob)
with clean_job(jb):
res = jb.jobs
assert res is not None
assert isinstance(res, list)
assert len(res) == 0
def test_start_build_returned_queue_item(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
queue = jk.build_queue
jb = jk.create_job("test_start_build_returned_queue_item", FreestyleJob)
with clean_job(jb):
jb.quiet_period = 1
item = jb.start_build()
assert item is not None
assert isinstance(item, QueueItem)
assert queue.items[0] == item
def test_get_multi_nested_job_recursive(jenkins_env):
jk = Jenkins(jenkins_env["url"],
(jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb1 = jk.create_job("test_get_multi_nested_job_recursive_1", FolderJob)
with clean_job(jb1):
jb2 = jb1.create_job("test_get_multi_nested_job_recursive_2",
FreestyleJob)
with clean_job(jb2):
jb3 = jb1.create_job("test_get_multi_nested_job_recursive_3",
FolderJob)
with clean_job(jb3):
jb4 = jb3.create_job("test_get_multi_nested_job_recursive_4",
FreestyleJob)
with clean_job(jb4):
res = jk.all_jobs
assert len(res) == 4
assert jb1 in res
assert jb2 in res
assert jb3 in res
assert jb4 in res
def test_job(request, jenkins_env):
"""Test fixture that creates a Jenkins Freestyle job for testing purposes
The generated job is automatically cleaned up at the end of the test
suite, which is defined as all of the methods contained within the same
class.
The expectation here is that tests that share this generated job will
only perform read operations on the job and will not change it's state.
This will ensure the tests within the suite don't affect one another.
"""
jk = Jenkins(jenkins_env["url"],
(jenkins_env["admin_user"], jenkins_env["admin_token"]))
request.cls.jenkins = jk
request.cls.job = jk.create_job(request.cls.__name__ + "Job", FreestyleJob)
assert request.cls.job is not None
yield
request.cls.job.delete()
def test_get_last_unsuccessful_build(jenkins_env):
jk = Jenkins(jenkins_env["url"],
(jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_get_last_unsuccessful_build", FreestyleJob)
with clean_job(jb):
jb.quiet_period = 0
rcode = 12
failing_step = ShellBuilder.instantiate("exit " + str(rcode))
failing_step.unstable_return_code = rcode
jb.add_builder(failing_step)
async_assert(lambda: jb.builders)
jb.start_build()
async_assert(lambda: jb.last_unsuccessful_build)
bld = jb.last_unsuccessful_build
assert bld is not None
assert isinstance(bld, Build)
assert bld.number == 1
assert bld.result == "UNSTABLE"
def test_get_view_metrics(jenkins_env):
jk = Jenkins(jenkins_env["url"],
(jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_job_name = "test_get_view_metrics_job"
jb = jk.create_job(expected_job_name, FreestyleJob)
with clean_job(jb):
jb.disable()
result = jk.default_view.view_metrics
expected_keys = [
'unstable_jobs', 'unstable_jobs_count', 'broken_jobs_count',
'disabled_jobs', 'disabled_jobs_count', 'broken_jobs'
]
for cur_key in expected_keys:
assert cur_key in result.keys()
assert result['broken_jobs_count'] == 0
assert result['disabled_jobs_count'] == 1
assert result['unstable_jobs_count'] == 0
assert isinstance(result['disabled_jobs'], list)
assert len(result['disabled_jobs']) == 1
assert result['disabled_jobs'][0].name == expected_job_name
def test_rename_job(jenkins_env):
jk = Jenkins(jenkins_env["url"],
(jenkins_env["admin_user"], jenkins_env["admin_token"]))
original_job_name = "test_rename_job1"
new_job_name = "test_rename_job2"
jb = jk.create_job(original_job_name, FreestyleJob)
try:
jb.rename(new_job_name)
assert jk.find_job(original_job_name) is None
jb_copy = jk.find_job(new_job_name)
assert jb_copy is not None
assert jb.name == new_job_name
assert jb_copy == jb
finally:
tmp = jk.find_job(original_job_name)
if tmp:
tmp.delete()
tmp = jk.find_job(new_job_name)
if tmp:
tmp.delete()
def test_multiple_blocking_jobs(jenkins_env):
jk = Jenkins(jenkins_env["url"],
(jenkins_env["admin_user"], jenkins_env["admin_token"]))
job_name = "test_multiple_blocking_jobs"
jb = jk.create_job(job_name, FreestyleJob)
with clean_job(jb):
expected_jobs = ["MyCoolJob1", "MyCoolJob2"]
build_blocker = BuildBlockerProperty.create(["ShouldNotSeeMe"])
build_blocker.blockers = expected_jobs
jb.add_property(build_blocker)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(job_name).properties)
properties = jk.find_job(job_name).properties
prop = properties[0]
blockers = prop.blockers
assert isinstance(blockers, list)
assert len(blockers) == 2
assert expected_jobs[0] in blockers
assert expected_jobs[1] in blockers
def test_rename_job(jenkins_env):
jk = Jenkins(jenkins_env["url"],
(jenkins_env["admin_user"], jenkins_env["admin_token"]))
parent = jk.create_job("test_rename_job_parent", FolderJob)
with clean_job(parent):
original_job_name = "test_rename_job1"
new_job_name = "test_rename_job2"
jb = parent.create_job(original_job_name, FreestyleJob)
try:
jb.rename(new_job_name)
assert parent.find_job(original_job_name) is None
jb_copy = parent.find_job(new_job_name)
assert jb_copy is not None
assert jb.name == new_job_name
assert jb_copy == jb
finally:
tmp = parent.find_job(original_job_name)
if tmp:
tmp.delete()
tmp = parent.find_job(new_job_name)
if tmp:
tmp.delete()
def test_abort(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
expected_job_name = "test_abort"
jb = jk.create_job(expected_job_name, FreestyleJob)
with clean_job(jb):
jb.quiet_period = 0
shell_builder = ShellBuilder.instantiate("echo 'waiting for sleep' && sleep 40")
jb.add_builder(shell_builder)
# Get a fresh copy of our job to ensure we have an up to date
# copy of the config.xml for the job
async_assert(lambda: jk.find_job(expected_job_name).builders)
# Trigger a build and wait for it to complete
jb.start_build()
async_assert(lambda: jb.last_build)
async_assert(lambda: "waiting for sleep" in jb.last_build.console_output)
jb.last_build.abort()
assert jb.last_build.is_building is False
assert jb.last_build.result == "ABORTED"
def test_create_pipeline_job(jenkins_env):
jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"]))
jb = jk.create_job("test_create_pipeline_job", PipelineJob)
with clean_job(jb):
assert jb is not None
