def test_find_job_no_jobs(self): mock_data_io = MagicMock() mock_data_io.get_api_data.return_value = {'jobs':{}} j = Jenkins(mock_data_io) njob = j.find_job("MyJob") self.assertEqual(njob, None, "No jobs should be found by the search method")
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_find_node(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) expected_name = "master" result = jk.find_node(expected_name) assert result is not None assert result.name == expected_name
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_prepare_shutdown(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) try: jk.prepare_shutdown() assert jk.is_shutting_down finally: jk.cancel_shutdown()
def test_find_view(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) expected_name = "all" v = jk.find_view(expected_name) assert v is not None assert v.name == expected_name
def test_get_user_id(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) user = jk.find_user("admin") result = user.user_id assert result is not None assert result == "admin"
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_get_jobs_no_jobs(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) vw = jk.create_view("test_get_jobs_no_jobs_views", ListView) with clean_view(vw): jobs = vw.jobs assert isinstance(jobs, list) assert len(jobs) == 0
def test_rename_view(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) original_view_name = "test_rename_view" v = jk.create_view(original_view_name, SectionedView) try: expected_section_name = "MyNewSection" v.add_section("hudson.plugins.sectioned_view.TextSection", expected_section_name) expected_view_name = "test_rename_view2" v.rename(expected_view_name) assert jk.find_view(original_view_name) is None finally: tmp = jk.find_view(original_view_name) if tmp: tmp.delete() with clean_view(v): assert v.name == expected_view_name tmp_view = jk.find_view(expected_view_name) assert tmp_view is not None assert tmp_view.name == expected_view_name result = tmp_view.sections assert result is not None assert isinstance(result, list) assert len(result) == 1 assert result[0].name == expected_section_name
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_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_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_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_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_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_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_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_find_multiple_nested_sub_views(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) parent1 = jk.create_view("test_find_multiple_nested_sub_views_parent1", NestedView) with clean_view(parent1): parent2 = parent1.create_view("test_find_multiple_nested_sub_views_parent2", NestedView) with clean_view(parent2): expected_view_name = "test_find_multiple_nested_sub_views_child" # Views in Jenkins must be unique within the same parent view, but # nested views may contain sub-views with the same name as their # ancestors / siblings. So we create 2 views with the same name in # each of our parent views to make sure they get resolved correctly child1 = parent1.create_view(expected_view_name, ListView) assert child1 is not None with clean_view(child1): child2 = parent2.create_view(expected_view_name, ListView) assert child2 is not None with clean_view(child2): results = parent1.find_all_views(expected_view_name) assert results is not None assert isinstance(results, list) assert len(results) == 2 assert results[0].name == expected_view_name assert results[1].name == expected_view_name
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_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_find_missing_view(self): # test logic j = Jenkins(self.mock_jenkins_data_io) View = j.find_view("DoesNotExist") # verification self.assertEqual(View, None, "No valid view should have been found.")
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_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_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_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_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_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_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_create_status_view(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) expected_view_name = "test_create_status_view" v = jk.create_view(expected_view_name, StatusView) assert v is not None with clean_view(v): assert isinstance(v, StatusView) assert v.name == expected_view_name
def test_is_unstable(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) jb = jk.create_job("test_is_unstable_job", 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) assert jb.is_unstable
def test_find_nested_sub_view(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) parent = jk.create_view("test_find_nested_sub_view", NestedView) with clean_view(parent): child1 = parent.create_view("test_find_nested_sub_view1", NestedView) with clean_view(child1): expected_view_name = "test_find_nested_sub_view2" child2 = child1.create_view(expected_view_name, ListView) assert child2 is not None with clean_view(child2): result = parent.find_all_views(expected_view_name) assert result is not None assert isinstance(result, list) assert len(result) == 1 assert result[0].name == expected_view_name
def test_get_build_after_queued(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) queue = jk.build_queue jb = jk.create_job("test_get_build_after_queued", FreestyleJob) with clean_job(jb): jb.quiet_period = 1 jb.start_build() res = queue.items item = res[0] assert item.build is None async_assert(lambda: jb.last_build) assert item.build is not None assert item.build == jb.last_build
def test_out_of_queue(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) queue = jk.build_queue jb = jk.create_job("test_waiting_build_queue", FreestyleJob) with clean_job(jb): jb.quiet_period = 1 jb.start_build() res = queue.items assert isinstance(res, list) assert len(res) == 1 item = res[0] assert item.waiting is True async_assert(lambda: jb.last_build) assert item.waiting is False
def test_build_queue(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) queue = jk.build_queue assert queue is not None assert isinstance(queue.items, list) assert len(queue.items) == 0
def test_build_inequality(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) jb = jk.create_job("test_build_inequality_job", FreestyleJob) with clean_job(jb): jb.quiet_period = 0 jb.start_build() async_assert(lambda: len(jb.all_builds) == 1) jb.start_build() async_assert(lambda: len(jb.all_builds) == 2) bld1 = jb.all_builds[0] bld2 = jb.all_builds[1] assert bld1 != bld2 assert not bld1 == bld2 assert bld1 != 1
def test_add_git_scm(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) job_name = "test_add_git_scm" jb = jk.create_job(job_name, FreestyleJob) with clean_job(jb): 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)) jb2 = jk.find_job(job_name) result = jb2.scm assert result is not None assert isinstance(result, GitSCM)
def test_delete_all_jobs(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) expected_job_name = "test_delete_all_jobs_job" jb = jk.create_job(expected_job_name, FreestyleJob) try: vw = jk.default_view assert len(vw.jobs) == 1 vw.delete_all_jobs() assert len(vw.jobs) == 0 except: # In case our delete operation doesn't complete successfully, we do # a manual deletion here to keep our test environment clean jb.delete() raise
def test_disable_build_blocker(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) job_name = "test_disable_build_blocker" jb = jk.create_job(job_name, FreestyleJob) with clean_job(jb): build_blocker = BuildBlockerProperty.create("MyJob") build_blocker.disable() jb.quiet_period = 0 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 assert properties[0].is_enabled is False
def test_get_no_jobs_recursive(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) res = jk.all_jobs assert res is not None assert isinstance(res, list) assert len(res) == 0
def test_one_upstream_job(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) parent_job_name = "test_one_upstream_job1" jb = jk.create_job(parent_job_name, FreestyleJob) with clean_job(jb): child_job_name = "test_one_upstream_job2" jb2 = jk.create_job(child_job_name, FreestyleJob) with clean_job(jb2): publisher = BuildTriggerPublisher.instantiate([child_job_name]) jb.add_publisher(publisher) async_assert(lambda: jb2.upstream_jobs) res = jb2.upstream_jobs assert isinstance(res, list) assert len(res) == 1 assert res[0].name == parent_job_name
def test_get_nodes(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) result = jk.nodes assert result is not None assert isinstance(result, list) assert len(result) == 1
def test_default_block_level(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) job_name = "test_default_block_level" jb = jk.create_job(job_name, FreestyleJob) with clean_job(jb): expected_jobs = ["MyCoolJob1", "MyCoolJob2"] build_blocker = BuildBlockerProperty.create(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] assert prop.level == "GLOBAL"
def test_find_plugin_by_shortname(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) result = jk.plugin_manager.find_plugin_by_shortname( jenkins_env["plugins"][0].split(":")[0]) assert result is not None assert result.short_name == jenkins_env["plugins"][0].split(":")[0]
def test_plugin_enabled(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) results = jk.plugin_manager.plugins assert results[0].enabled is not None assert isinstance(results[0].enabled, bool) assert results[0].enabled is True
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.create([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_get_plugins(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) results = jk.plugin_manager.plugins assert results is not None assert isinstance(results, list) assert len(results) >= len(jenkins_env["plugins"])
def test_cancel_shutdown(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) try: jk.prepare_shutdown() assert jk.is_shutting_down jk.cancel_shutdown() assert not jk.is_shutting_down finally: jk.cancel_shutdown()
def test_get_views(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) v = jk.views assert v is not None assert isinstance(v, list) assert len(v) == 1 assert v[0].name == "all"
def test_add_build_blocker(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) job_name = "test_add_build_blocker" jb = jk.create_job(job_name, FreestyleJob) with clean_job(jb): expected_job_name = "MyCoolJob" build_blocker = BuildBlockerProperty.create(expected_job_name) 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 assert isinstance(properties, list) assert len(properties) == 1 assert isinstance(properties[0], BuildBlockerProperty)
def test_get_last_failed_build(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) jb = jk.create_job("test_get_last_failed_build", FreestyleJob) with clean_job(jb): jb.quiet_period = 0 failing_step = ShellBuilder.create("exit -1") jb.add_builder(failing_step) async_assert(lambda: jb.builders) jb.start_build() async_assert(lambda: jb.last_build) bld = jb.last_failed_build assert bld is not None assert isinstance(bld, Build) assert bld.number == 1 assert bld.result == "FAILURE"
def test_all_views_nested_sub_view(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) parent = jk.create_view("test_all_views_nested_sub_view_parent", NestedView) with clean_view(parent): expected_view_name1 = "test_all_views_nested_sub_view_child1" child1 = parent.create_view(expected_view_name1, NestedView) with clean_view(child1): expected_view_name2 = "test_all_views_nested_sub_view_child2" child2 = child1.create_view(expected_view_name2, ListView) assert child2 is not None with clean_view(child2): results = parent.all_views assert results is not None assert isinstance(results, list) assert len(results) == 2 assert results[0].name in [expected_view_name1, expected_view_name2] assert results[1].name in [expected_view_name1, expected_view_name2]
def test_get_nodes(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) nodes = jk.nodes assert nodes is not None assert isinstance(nodes, list) assert len(nodes) == 1 assert nodes[0].name == "master"
def test_overwrite_definition(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) jb = jk.create_job("test_overwrite_definition", PipelineJob) with clean_job(jb): expected_url = "*****@*****.**" scm = GitSCM.instantiate(expected_url) jb.scm_definition(scm) jb.quiet_period = 0 expected_output = "hello" expected_cmd = 'echo "{}"'.format(expected_output) jb.script_definition(expected_cmd) jb.start_build() async_assert(lambda: jb.last_good_build) assert jb.script == expected_cmd assert jb.scm is None assert expected_output in jb.last_build.console_output
def test_download_plugin_no_overwrite(jenkins_env, tmp_path): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) results = jk.plugin_manager.plugins results[0].download(str(tmp_path)) assert len(os.listdir(str(tmp_path))) == 1 with pytest.raises(Exception): results[0].download(str(tmp_path))
def test_add_artifact_deployer_publisher(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) job_name = "test_add_artifact_deployer_publisher" jb = jk.create_job(job_name, FreestyleJob) with clean_job(jb): publisher = ArtifactDeployer.instantiate() jb.add_publisher(publisher) # 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 isinstance(pubs, list) assert len(pubs) == 1 assert isinstance(pubs[0], ArtifactDeployer) assert isinstance(pubs[0].entries, list) assert len(pubs[0].entries) == 0
def test_plugin_latest_download_url(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) results = jk.plugin_manager.plugins assert results[0].latest_download_url is not None assert isinstance(results[0].latest_download_url, str) assert results[0].latest_download_url.startswith( "http://updates.jenkins-ci.org/latest/") assert results[0].latest_download_url.endswith(".hpi")
def test_unstable_return_code(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) job_name = "test_unstable_return_code" jb = jk.create_job(job_name, FreestyleJob) with clean_job(jb): rcode = 12 failing_step = ShellBuilder.create("exit " + str(rcode)) failing_step.unstable_return_code = rcode jb.add_builder(failing_step) async_assert(lambda: jb.builders) # 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) builders = jk.find_job(job_name).builders assert isinstance(builders, list) assert len(builders) == 1 assert builders[0].unstable_return_code == rcode
def test_add_simple_shell_builder(jenkins_env): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) job_name = "test_add_simple_shell_builder" jb = jk.create_job(job_name, FreestyleJob) with clean_job(jb): expected_script = "echo hello" shell_builder = ShellBuilder.create(expected_script) 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) builders = jk.find_job(job_name).builders assert isinstance(builders, list) assert len(builders) == 1 assert isinstance(builders[0], ShellBuilder) assert builders[0].script == expected_script assert builders[0].unstable_return_code is None
def test_download_plugin_overwrite(jenkins_env, tmp_path): jk = Jenkins(jenkins_env["url"], (jenkins_env["admin_user"], jenkins_env["admin_token"])) results = jk.plugin_manager.plugins results[0].download(str(tmp_path)) assert len(os.listdir(str(tmp_path))) == 1 results[0].download(str(tmp_path), overwrite=True) assert len(os.listdir(str(tmp_path))) == 1