Differential D1031

Trigger changes for the task-discover functinality (docker/distgit testing)
ClosedPublic
Actions

Authored by jskladan on Oct 18 2016, 12:01 PM.

Details

Reviewers
• ralph2
tflink
mkrizek
Group Reviewers
taskotron-trigger
Maniphest Tasks
T856: Implement the 'discover' functionality in Trigger (and probably other parts of Taskotron stack)
Commits
rTRGR182546e00df6: Trigger changes for the task-discover functinality (docker/distgit testing)
Summary

Split-up and rewrite of the discover_tasks() method, so the logical steps
are not all tied together, and so we have better starting place for further
changes.

The discover 'reaction' in the task configuration can now be like:

 {discover: {
     repo: 'URL of the git branch to clone',
     branch: 'branch to clone, master by default',
     fallback_branch: 'what branch to clone if `branch` can not be cloned',
     base_dir: 'relative path to a directory in the repo. The path is used as root for the task discovery'
     }
}

I'm not sure the fallback_branch is necessary, but the previous code had
a concept of checking out 'master' when the provided branch could not be cloned
so I wanted to introduce a way to do the same, but explicitly.

Test Plan

Unittests

Diff Detail

Repository
rTRGR taskotron-trigger
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.
jskladan retitled this revision from to Trigger changes for the task-discover functinality (docker/distgit testing).Oct 18 2016, 12:01 PM
jskladan updated this object.
jskladan edited the test plan for this revision. (Show Details)
jskladan added a reviewer: taskotron-trigger.
jskladan updated this object.Oct 18 2016, 1:56 PM

I have also tested the functionality locally with docker - the trigger correctly crawls a repo, finds all the instances of runtask.yml and schedules tasks.
There are buildbot related changes necessary, those will be in another diff

jskladan added reviewers: tflink, mkrizek, • ralph2.Dec 6 2016, 3:50 PM

Guys, could you have a look at this? It's been quite a while, and is still rather relevant... @tflink @mkrizek

mkrizek accepted this revision.Dec 12 2016, 10:51 AM

Didn't look at the tests, code looks good to me.

This revision is now accepted and ready to land.Dec 12 2016, 10:51 AM
Closed by commit rTRGR182546e00df6: Trigger changes for the task-discover functinality (docker/distgit testing) (authored by Josef Skladanka <jskladan@redhat.com>). · Explain WhyDec 12 2016, 1:50 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 2720

View Options

jobtriggers/jobtrigger.py

1​import os
1import copy 2​import copy
2import yaml 3​import yaml
3import itertools 4​import itertools
4import fedmsg.consumers 5​import fedmsg.consumers
5from mongoquery import Query, QueryError 6​from mongoquery import Query, QueryError
6 7​
7from . import config, runners, utils 8​from . import config, runners, utils
8from . import exceptions as exc 9​from . import exceptions as exc
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Line(s)45 def _tasks_from_rule(self, rule, message_data):
62 for item in rule['do']: 63​ for item in rule['do']:
63 # TODO: make this more efficient 64​ # TODO: make this more efficient
64 task = copy.deepcopy(task_template) 65​ task = copy.deepcopy(task_template)
65 66​
66 if 'tasks' in item: 67​ if 'tasks' in item:
67 task['tasks'] = item['tasks'] 68​ task['tasks'] = item['tasks']
68 elif 'discover' in item: 69​ elif 'discover' in item:
69 discover = item['discover'] 70​ discover = item['discover']
71​
72​ # clone the repo (or fail)
70 repo = discover['repo'] 73​ repo = discover['repo']
71 branch = discover.get('branch', 'master') 74​ branch = discover.get('branch', 'master').strip() or 'master'
72 task['tasks'] = utils.discover_tasks(task['item_type'], repo, branch) 75​ fallback = discover.get('fallback_branch', '').strip()
76​ repo_dir, branch = utils.clone_repo(repo, branch, fallback)
77​
78​ # append base_dir, if specified
79​ base_dir = discover.get('base_dir', '').strip()
80​ repo_dir = os.path.join(repo_dir, base_dir)
81​ # fill the task details
82​ recursive = discover.get('recursive', False)
73 task['repo'] = repo 83​ task['repo'] = repo
74 task['branch'] = branch 84​ task['branch'] = branch
85​ task['tasks'] = utils.discover_tasks(repo_dir, task['item_type'], recursive)
75 else: 86​ else:
76 self.log.error("Rule has invalid `do` section: %r", rule) 87​ self.log.error("Rule has invalid `do` section: %r", rule)
77 88​
78 tasks.append(task) 89​ tasks.append(task)
79 90​
80 return tasks 91​ return tasks
81 92​
82 def _load_rules(self, template, data): 93​ def _load_rules(self, template, data):
Show All 38 Lines
View Options

jobtriggers/utils.py

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Line(s)76 for url in urls:
77 if '@sha' not in url: 77​ if '@sha' not in url:
78 return url 78​ return url
79 except KeyError: 79​ except KeyError:
80 pass 80​ pass
81 81​
82 raise exc.TriggerMsgError('Could not get docker registry url from %d' % build_id) 82​ raise exc.TriggerMsgError('Could not get docker registry url from %d' % build_id)
83 83​
84 84​
85def discover_tasks(item_type, repo, branch='master'): 85​def clone_repo(repo, branch='master', fallback=None):
86​ """Clones the repo & branch. If the branch can not be cloned, and fallback
87​ is set, it tries to clone fallback. If repo can not be cloned, raises exception.
88​ Returns full path to the cloned repo, and the cloned branch."""
86 dirname = repo.split('/')[-1] 89​ dirname = repo.split('/')[-1]
87 if dirname.endswith('.git'): 90​ if dirname.endswith('.git'):
88 dirname = dirname[:-len(".git")] 91​ dirname = dirname[:-len(".git")]
89 92​
90 tasks_dir = os.path.join(config.git_cache_dir, dirname) 93​ repo_dir = os.path.join(config.git_cache_dir, dirname)
91 94​
92 # for now, just delete the repo and make a new shallow copy 95​ # for now, just delete the repo and make a new shallow copy
93 if os.path.exists(tasks_dir): 96​ if os.path.exists(repo_dir):
94 shutil.rmtree(tasks_dir) 97​ shutil.rmtree(repo_dir)
95 98​
96 cmd = ['git', 'clone', '--branch', branch, '--depth', '1', repo, tasks_dir] 99​ cmd = ['git', 'clone', '--branch', branch, '--depth', '1', repo, repo_dir]
97 100​
98 try: 101​ try:
99 subprocess.check_output(cmd, stderr=subprocess.STDOUT) 102​ subprocess.check_output(cmd, stderr=subprocess.STDOUT)
100 except subprocess.CalledProcessError as e: 103​ except subprocess.CalledProcessError as e:
101 # FIXME: this does not really work, since the change in branch is not propagated 104​ if fallback and branch != fallback:
102 # back, but leaving here for completeness for now 105​ if 'Could not find remote branch' in e.output:
103 if 'Could not find remote branch' in e.output and branch != 'master': 106​ return clone_repo(repo, branch=fallback)
104 return discover_tasks(item_type, repo, branch='master') ​
105 raise exc.TriggerError(e.output) 107​ raise exc.TriggerError(e.output)
106 108​
107 tasks = [] 109​ return repo_dir, branch
108 for task in os.listdir(tasks_dir): 110​
109 if task.startswith('.'): 111​
110 continue 112​def _discover_formulae(directory, recursive=False):
111 taskdir = os.path.join(tasks_dir, task) 113​ """Returns a list of relative paths to 'runtask.yml' files
112 formula_file = os.path.join(taskdir, 'runtask.yml') 114​ in the directory.
113 if os.path.isdir(taskdir) and _should_schedule(formula_file, item_type): 115​ Search is recursive, as long as recursive is set to True.
114 tasks.append(task) 116​ """
117​ formulae = []
118​ # remove trailing slashes
119​ directory = directory.strip().rstrip('/')
120​
121​ for dirpath, dirs, files in os.walk(directory):
122​ if 'runtask.yml' in files:
123​ formula = os.path.join(dirpath, 'runtask.yml')
124​ # remove the base directory path
125​ formulae.append(formula[len(directory)+1:])
126​ if not recursive:
127​ break
128​ # remove hidden dirs
129​ # dirs needs to be updated in-place
130​ dirs[:] = [d for d in dirs if not d.startswith('.')]
131​
132​ return formulae
133​
134​
135​def discover_tasks(directory, item_type, recursive=False):
136​ """Returns a list of relative paths to 'runtask.yml' files in the directory.
137​ Only formulae that are relevant for the item_type are returned.
138​ """
139​ formulae = _discover_formulae(directory, recursive)
140​ tasks = [f for f in formulae if _should_schedule(os.path.join(directory, f), item_type)]
115 141​
116 return tasks 142​ return tasks
View Options

testing/test_dist_git_trigger.py

1import pytest 1​import pytest
2import mock 2​import mock
3from dingus import Dingus 3​from dingus import Dingus
4from munch import Munch 4​from munch import Munch
5 5​
6from jobtriggers import dist_git_commit_msg 6​from jobtriggers import dist_git_commit_msg
7from jobtriggers import utils 7​from jobtriggers import utils
8 8​
9​def mock_clone_repo(repo, branch='master', fallback=None):
10​ return '/tmp/path_to_repo', branch
9 11​
10@pytest.mark.usefixtures('prepare') 12​@pytest.mark.usefixtures('prepare')
11class TestDistGitCommitJobTrigger(): 13​class TestDistGitCommitJobTrigger():
12 14​
13 @pytest.fixture 15​ @pytest.fixture
14 def prepare(self, monkeypatch): 16​ def prepare(self, monkeypatch):
15 self.item_type = 'dist_git_commit' 17​ self.item_type = 'dist_git_commit'
16 self.ref_message = self._create_msg() 18​ self.ref_message = self._create_msg()
Show All 15 Lines33 do:
32 - {discover: {repo: 'http://foo/test-modules/${name}.git'}} 34​ - {discover: {repo: 'http://foo/test-modules/${name}.git'}}
33 - {tasks: [modlint]} # modlint is a real thing :) 35​ - {tasks: [modlint]} # modlint is a real thing :)
34""" 36​"""
35 37​
36 dist_git_commit_msg.config.job_logging = False 38​ dist_git_commit_msg.config.job_logging = False
37 39​
38 mock_discover_tasks = mock.Mock(return_value=[]) 40​ mock_discover_tasks = mock.Mock(return_value=[])
39 monkeypatch.setattr(utils, 'discover_tasks', mock_discover_tasks) 41​ monkeypatch.setattr(utils, 'discover_tasks', mock_discover_tasks)
42​ monkeypatch.setattr(utils, 'clone_repo', mock_clone_repo)
40 43​
41 mock_critpath = {"pkgs": {"f18": [], "master": []}} 44​ mock_critpath = {"pkgs": {"f18": [], "master": []}}
42 mock_get_critpath = mock.Mock(return_value=mock_critpath) 45​ mock_get_critpath = mock.Mock(return_value=mock_critpath)
43 monkeypatch.setattr(utils, 'parse_yaml_from_file', mock_get_critpath) 46​ monkeypatch.setattr(utils, 'parse_yaml_from_file', mock_get_critpath)
44 47​
45 def _create_msg(self): 48​ def _create_msg(self):
46 return Munch(body={ 49​ return Munch(body={
47 "i": 1, 50​ "i": 1,
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines
View Options

testing/test_jobtrigger.py

1import pytest 1​import pytest
2import mock 2​import mock
3import copy 3​import copy
4from dingus import Dingus 4​from dingus import Dingus
5from munch import Munch 5​from munch import Munch
6 6​
7from jobtriggers import jobtrigger 7​from jobtriggers import jobtrigger
8from jobtriggers import utils 8​from jobtriggers import utils
9from jobtriggers import exceptions as exc 9​from jobtriggers import exceptions as exc
10 10​
11 11​
12class BogusJobTrigger(jobtrigger.JobTrigger): 12​class BogusJobTrigger(jobtrigger.JobTrigger):
13 config_key = 'taskotron.bogusjobtrigger.enabled' 13​ config_key = 'taskotron.bogusjobtrigger.enabled'
14 14​
15​def mock_clone_repo(repo, branch='master', fallback=None):
16​ return '/tmp/path_to_repo', branch
17​
15 18​
16@pytest.mark.usefixtures('prepare') 19​@pytest.mark.usefixtures('prepare')
17class TestJobtrigger(): 20​class TestJobtrigger():
18 21​
19 @pytest.fixture 22​ @pytest.fixture
20 def prepare(self, monkeypatch): 23​ def prepare(self, monkeypatch):
21 stub_hub = Munch(config=Munch(get=0)) 24​ stub_hub = Munch(config=Munch(get=0))
22 self.helper = BogusJobTrigger(stub_hub) 25​ self.helper = BogusJobTrigger(stub_hub)
23 self.helper.runner = Dingus() 26​ self.helper.runner = Dingus()
24 27​
25 self.ref_discovered_tasks = ['discovered_task_1'] 28​ self.ref_discovered_tasks = ['discovered_task_1']
26 mock_discover_tasks = mock.Mock(return_value=self.ref_discovered_tasks) 29​ mock_discover_tasks = mock.Mock(return_value=self.ref_discovered_tasks)
27 monkeypatch.setattr(utils, 'discover_tasks', mock_discover_tasks) 30​ monkeypatch.setattr(utils, 'discover_tasks', mock_discover_tasks)
28 31​
32​ monkeypatch.setattr(utils, 'clone_repo', mock_clone_repo)
33​
29 self.ref_item = "package_foobar-1.0.8-fc18" 34​ self.ref_item = "package_foobar-1.0.8-fc18"
30 self.ref_item_type = "bar" 35​ self.ref_item_type = "bar"
31 self.ref_name = "package_foobar" 36​ self.ref_name = "package_foobar"
32 self.ref_message_data = { 37​ self.ref_message_data = {
33 "item": self.ref_item, "item_type": self.ref_item_type, "name": self.ref_name} 38​ "item": self.ref_item, "item_type": self.ref_item_type, "name": self.ref_name}
34 self.ref_default_arches = ['i386', 'x86_64'] 39​ self.ref_default_arches = ['i386', 'x86_64']
35 40​
36 self.ref_tasks = ['ref_task1', 'ref_task2'] 41​ self.ref_tasks = ['ref_task1', 'ref_task2']
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Line(s)91 def test__tasks_from_rule_discover_set_branch(self):
89 tasks = self.helper._tasks_from_rule(rule, self.ref_message_data) 94​ tasks = self.helper._tasks_from_rule(rule, self.ref_message_data)
90 assert len(tasks) == 1 95​ assert len(tasks) == 1
91 assert tasks[0]['tasks'] == self.ref_discovered_tasks 96​ assert tasks[0]['tasks'] == self.ref_discovered_tasks
92 assert tasks[0]['item'] == self.ref_message_data['item'] 97​ assert tasks[0]['item'] == self.ref_message_data['item']
93 assert tasks[0]['item_type'] == self.ref_message_data['item_type'] 98​ assert tasks[0]['item_type'] == self.ref_message_data['item_type']
94 assert tasks[0]['repo'] == ref_repo 99​ assert tasks[0]['repo'] == ref_repo
95 assert tasks[0]['branch'] == 'mybranch' 100​ assert tasks[0]['branch'] == 'mybranch'
96 101​
102​ def test__tasks_from_rule_discover_recursive(self, monkeypatch):
103​ utils_dingus = Dingus(discover_tasks__returns=self.ref_discovered_tasks)
104​ monkeypatch.setattr(utils, 'discover_tasks', utils_dingus.discover_tasks)
105​
106​ ref_repo = 'http://bogus.repo/firefox.git'
107​ rule = {'do': [{'discover': {'repo': ref_repo, 'recursive': True}}]}
108​ tasks = self.helper._tasks_from_rule(rule, self.ref_message_data)
109​
110​ discover_calls = utils_dingus.calls()
111​ assert len(discover_calls) == 1
112​ assert discover_calls[0][0] == 'discover_tasks'
113​ assert discover_calls[0][1][0] == '/tmp/path_to_repo/'
114​ assert discover_calls[0][1][1] == self.ref_message_data['item_type']
115​ assert discover_calls[0][1][2] == True
116​
97 def test_do_trigger_runtasks(self, monkeypatch): 117​ def test_do_trigger_runtasks(self, monkeypatch):
98 mock__load_rules = mock.Mock(return_value=self.ref_rules) 118​ mock__load_rules = mock.Mock(return_value=self.ref_rules)
99 monkeypatch.setattr(self.helper, '_load_rules', mock__load_rules) 119​ monkeypatch.setattr(self.helper, '_load_rules', mock__load_rules)
100 120​
101 message_data = copy.deepcopy(self.ref_message_data) 121​ message_data = copy.deepcopy(self.ref_message_data)
102 message_data['message_type'] = 'RunTasks' 122​ message_data['message_type'] = 'RunTasks'
103 123​
104 self.helper.do_trigger(message_data) 124​ self.helper.do_trigger(message_data)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines
View Options

testing/test_koji_build_trigger.py

1import koji 1​import koji
2import pytest 2​import pytest
3import mock 3​import mock
4from dingus import Dingus 4​from dingus import Dingus
5from munch import Munch 5​from munch import Munch
6 6​
7from jobtriggers import koji_build_msg 7​from jobtriggers import koji_build_msg
8from jobtriggers import utils 8​from jobtriggers import utils
9 9​
10params = [('someowner', koji_build_msg.ITEM_TYPE_PACKAGE, "KojiBuildPackageCompleted"), 10​params = [('someowner', koji_build_msg.ITEM_TYPE_PACKAGE, "KojiBuildPackageCompleted"),
11 ('containerbuild', koji_build_msg.ITEM_TYPE_DOCKER, "KojiBuildDockerCompleted")] 11​ ('containerbuild', koji_build_msg.ITEM_TYPE_DOCKER, "KojiBuildDockerCompleted")]
12 12​
13​def mock_clone_repo(repo, branch='master', fallback=None):
14​ return '/tmp/path_to_repo', branch
15​
13@pytest.mark.usefixtures('prepare') 16​@pytest.mark.usefixtures('prepare')
14@pytest.mark.parametrize('buildtype', params) 17​@pytest.mark.parametrize('buildtype', params)
15class TestKojiBuildCompletedJobTrigger(): 18​class TestKojiBuildCompletedJobTrigger():
16 19​
17 @pytest.fixture 20​ @pytest.fixture
18 def prepare(self, monkeypatch, buildtype): 21​ def prepare(self, monkeypatch, buildtype):
19 self.ref_instance = 'primary' 22​ self.ref_instance = 'primary'
20 self.ref_new = koji.BUILD_STATES['COMPLETE'] 23​ self.ref_new = koji.BUILD_STATES['COMPLETE']
Show All 31 Lines
52""" % (self.ref_tasks, self.message_type, self.ref_tasks_docker, self.message_type) 55​""" % (self.ref_tasks, self.message_type, self.ref_tasks_docker, self.message_type)
53 56​
54 koji_build_msg.config.valid_arches = self.ref_validarches 57​ koji_build_msg.config.valid_arches = self.ref_validarches
55 koji_build_msg.config.job_logging = False 58​ koji_build_msg.config.job_logging = False
56 59​
57 mock_discover_tasks = mock.Mock(return_value=[]) 60​ mock_discover_tasks = mock.Mock(return_value=[])
58 monkeypatch.setattr(utils, 'discover_tasks', mock_discover_tasks) 61​ monkeypatch.setattr(utils, 'discover_tasks', mock_discover_tasks)
59 62​
63​ monkeypatch.setattr(utils, 'clone_repo', mock_clone_repo)
64​
60 mock_critpath = {"pkgs": {"f18": [], "master": []}} 65​ mock_critpath = {"pkgs": {"f18": [], "master": []}}
61 mock_get_critpath = mock.Mock(return_value=mock_critpath) 66​ mock_get_critpath = mock.Mock(return_value=mock_critpath)
62 monkeypatch.setattr(utils, 'parse_yaml_from_file', mock_get_critpath) 67​ monkeypatch.setattr(utils, 'parse_yaml_from_file', mock_get_critpath)
63 68​
64 stub_session = mock.MagicMock() 69​ stub_session = mock.MagicMock()
65 stub_session.listArchives.return_value = [ 70​ stub_session.listArchives.return_value = [
66 {'extra': {'docker': {'repositories': ['image@shaXXX', self.ref_nvr]}}}] 71​ {'extra': {'docker': {'repositories': ['image@shaXXX', self.ref_nvr]}}}]
67 stub_session.listTags.return_value = [{'name': 'ubuntu-docker'}, {'name': 'f24-docker'}] 72​ stub_session.listTags.return_value = [{'name': 'ubuntu-docker'}, {'name': 'f24-docker'}]
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines
View Options

testing/test_utils.py

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Line(s)76 input:
77 args: 77​ args:
78 - koji_tag 78​ - koji_tag
79 ''' 79​ '''
80 mocked_open = mock.mock_open(read_data=file_data) 80​ mocked_open = mock.mock_open(read_data=file_data)
81 81​
82 with mock.patch('__builtin__.open', mocked_open): 82​ with mock.patch('__builtin__.open', mocked_open):
83 assert not utils._should_schedule('mocked_filename', 'koji_build') 83​ assert not utils._should_schedule('mocked_filename', 'koji_build')
84 84​
85 def test_distgit_tasks(self, monkeypatch): 85​ def test_clone_repo(self, monkeypatch):
86​ mock_path_exists = mock.Mock(return_value=False)
86 mock_check_output = mock.Mock(return_value='') 87​ mock_check_output = mock.Mock(return_value='')
87 mock__should_schedule = mock.Mock(return_value=True) 88​
89​ monkeypatch.setattr(os.path, 'exists', mock_path_exists)
90​ monkeypatch.setattr(config, 'git_cache_dir', '/path/to')
88 monkeypatch.setattr(subprocess, 'check_output', mock_check_output) 91​ monkeypatch.setattr(subprocess, 'check_output', mock_check_output)
89 monkeypatch.setattr(utils, '_should_schedule', mock__should_schedule) 92​
90 monkeypatch.setattr(os, 'listdir', lambda x: ['rpmlint']) 93​ repo_dir, branch = utils.clone_repo('http://bogus.url/repo')
91 monkeypatch.setattr(os.path, 'isdir', lambda x: True) 94​ assert repo_dir == '/path/to/repo'
95​ assert branch == 'master'
96​
97​ repo_dir, branch = utils.clone_repo('http://bogus.url/repo.git', branch='develop')
98​ assert repo_dir == '/path/to/repo'
99​ assert branch == 'develop'
100​
101​ repo_dir, branch = utils.clone_repo('http://bogus.url/repo', fallback='fallback')
102​ assert repo_dir == '/path/to/repo'
103​ assert branch == 'master'
104​
105​ def test_clone_repo_missing_brach(self, monkeypatch):
106​ mock_path_exists = mock.Mock(return_value=False)
107​ def mock_check_output(params, *args, **kwargs):
108​ if 'ok_branch' not in params:
109​ exc = subprocess.CalledProcessError(None, None, 'Could not find remote branch')
110​ raise exc
111​ return
112​
113​ monkeypatch.setattr(os.path, 'exists', mock_path_exists)
92 monkeypatch.setattr(config, 'git_cache_dir', '/path/to') 114​ monkeypatch.setattr(config, 'git_cache_dir', '/path/to')
115​ monkeypatch.setattr(subprocess, 'check_output', mock_check_output)
93 116​
94 repo = 'http://pkgs.fedoraproject.org/git/test-rpms/firefox.git' 117​ # sanity check to be sure the mock_check_output works
95 tasks = utils.discover_tasks('koji_build', repo) 118​ repo_dir, branch = utils.clone_repo('/repo', branch='ok_branch')
96 import pprint 119​ assert repo_dir == '/path/to/repo'
97 pprint.pprint(mock_check_output.call_args) 120​ assert branch == 'ok_branch'
98 pprint.pprint(mock__should_schedule.call_args) 121​ with pytest.raises(exc.TriggerError):
99 assert mock_check_output.call_args[0][0][6] == repo 122​ utils.clone_repo('', branch='missing_branch')
100 assert mock_check_output.call_args[0][0][ 123​
101 7] == os.path.join('/path/to', 'firefox') 124​ # actual check
102 assert mock__should_schedule.call_args[0][0] == os.path.join('/path/to', 125​ repo_dir, branch = utils.clone_repo('/repo', branch='master', fallback='ok_branch')
103 'firefox', 126​ assert repo_dir == '/path/to/repo'
104 'rpmlint', 127​ assert branch == 'ok_branch'
105 'runtask.yml') 128​
106 assert mock__should_schedule.call_args[0][1] == 'koji_build' 129​ with pytest.raises(exc.TriggerError):
107 assert tasks == ['rpmlint'] 130​ utils.clone_repo('', branch='missing_branch', fallback='master')
131​
132​ def test__discover_formulae(self, monkeypatch):
133​ def mock_os_walk(directory):
134​ yield (directory, ['task_1', 'nontask'], ['runtask.yml'])
135​ yield ('%s/nontask' % directory, [], [])
136​ yield ('%s/task_1' % directory, [], ['runtask.yml'])
137​
138​ monkeypatch.setattr(os, 'walk', mock_os_walk)
139​
140​ formulae = utils._discover_formulae(' /path/to/ ', recursive=True)
141​ assert len(formulae) == 2
142​ assert formulae == ['runtask.yml', 'task_1/runtask.yml']
143​
144​ formulae = utils._discover_formulae('/path/to')
145​ assert len(formulae) == 1
146​ assert formulae == ['runtask.yml']
147​
148​ def test_discover_tasks(self, monkeypatch):
149​ mock__discover_formulae = mock.Mock(return_value=['task1.yml', 'task2.yml'])
150​ def mock__should_schedule(task, item_type):
151​ return task == '/path/to/git/task2.yml' and item_type == 'fake_type'
152​
153​ monkeypatch.setattr(utils, '_discover_formulae', mock__discover_formulae)
154​ monkeypatch.setattr(utils, '_should_schedule', mock__should_schedule)
108 155​
156​ tasks = utils.discover_tasks('/path/to/git', 'fake_type')
157​ assert len(tasks) == 1
158​ assert tasks == ['task2.yml']
109 159​
110class TestGetBranch(object): 160​class TestGetBranch(object):
111 161​
112 def test_nvrs(self): 162​ def test_nvrs(self):
113 assert utils.get_distgit_branch('foo-1.2-3.fc20') == 'f20' 163​ assert utils.get_distgit_branch('foo-1.2-3.fc20') == 'f20'
114 assert utils.get_distgit_branch('foo-1.2-3.fc20.1') == 'f20' 164​ assert utils.get_distgit_branch('foo-1.2-3.fc20.1') == 'f20'
115 assert utils.get_distgit_branch('foo-1.2-3.fc22hashgit.fc20') == 'f20' 165​ assert utils.get_distgit_branch('foo-1.2-3.fc22hashgit.fc20') == 'f20'
116 assert utils.get_distgit_branch('foo-1.2-3.fc22hashgit.fc20.1') == 'f20' 166​ assert utils.get_distgit_branch('foo-1.2-3.fc22hashgit.fc20.1') == 'f20'
117 167​
118 def test_unsupported_dist_tag(self): 168​ def test_unsupported_dist_tag(self):
119 with pytest.raises(exc.TriggerMsgError): 169​ with pytest.raises(exc.TriggerMsgError):
120 utils.get_distgit_branch('foo-1.2-3.el7') 170​ utils.get_distgit_branch('foo-1.2-3.el7')