class TestBisector(unittest.TestCase):
def setUp(self):
self.handler = MagicMock(find_fix=False, ensure_good_and_bad=False)
self.test_runner = Mock()
self.bisector = Bisector(Mock(), self.test_runner,
Mock(),
dl_in_background=False)
self.bisector.download_background = False
def test__bisect_no_data(self):
build_range = MyBuildData()
result = self.bisector._bisect(self.handler, build_range)
# test that handler methods where called
self.handler.set_build_range.assert_called_with(build_range)
self.handler.no_data.assert_called_once_with()
# check return code
self.assertEqual(result, Bisection.NO_DATA)
def test__bisect_finished(self):
build_range = MyBuildData([1])
result = self.bisector._bisect(self.handler, build_range)
# test that handler methods where called
self.handler.set_build_range.assert_called_with(build_range)
self.handler.finished.assert_called_once_with()
# check return code
self.assertEqual(result, Bisection.FINISHED)
def do__bisect(self, build_range, verdicts):
iter_verdict = iter(verdicts)
def evaluate(build_info, allow_back=False):
verdict = iter_verdict.next()
if isinstance(verdict, Exception):
raise verdict
return verdict
self.test_runner.evaluate = Mock(side_effect=evaluate)
result = self.bisector._bisect(self.handler, build_range)
return {
'result': result,
}
def test_ensure_good_bad_invalid(self):
self.handler.ensure_good_and_bad = True
with self.assertRaisesRegexp(MozRegressionError,
"expected to be good"):
self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['b'])
with self.assertRaisesRegexp(MozRegressionError,
"expected to be bad"):
self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'g'])
def test_ensure_good_bad(self):
self.handler.ensure_good_and_bad = True
data = MyBuildData([1, 2, 3, 4, 5])
self.do__bisect(data,
['s', 'r', 'g', 'b', 'e'])
self.test_runner.evaluate.assert_has_calls([
call(data[0]), # tested good (then skip)
call(data[0]), # tested good (then retry)
call(data[0]), # tested good
call(data[-1]), # tested bad
])
self.assertEqual(
self.bisector.download_manager.download_in_background.call_count,
0
)
def test_ensure_good_bad_with_bg_dl(self):
self.handler.ensure_good_and_bad = True
self.bisector.dl_in_background = True
data = MyBuildData([1, 2, 3, 4, 5])
self.do__bisect(data,
['s', 'r', 'g', 'e'])
self.test_runner.evaluate.assert_has_calls([
call(data[0]), # tested good (then skip)
call(data[0]), # tested good (then retry)
call(data[0]), # tested good
call(data[-1]), # tested bad
])
self.bisector.download_manager.download_in_background.assert_has_calls(
[call(data[-1]), # bad in backgound
call(data[data.mid_point()])] # and mid build
)
def test_ensure_good_bad_with_find_fix(self):
self.handler.ensure_good_and_bad = True
self.handler.find_fix = True
data = MyBuildData([1, 2, 3, 4, 5])
self.do__bisect(data, ['g', 'e'])
self.test_runner.evaluate.assert_has_calls([
call(data[-1]), # tested good (then skip)
call(data[0]), # tested bad
])
def test__bisect_case1(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# we answered bad
call(MyBuildData([3, 4])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_bad.assert_called_with(1, MyBuildData([3, 4]))
self.assertTrue(self.handler.build_range.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_with_launcher_exception(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]),
['g', LauncherError("err")])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# launcher exception, equivalent to a skip
call(MyBuildData([3, 5])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_skip.assert_called_with(1)
self.assertTrue(self.handler.build_range.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_case1_hunt_fix(self):
self.handler.find_fix = True
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([1, 2, 3])),
# we answered bad
call(MyBuildData([2, 3])),
])
# ensure that we called the handler's methods
self.assertEqual(self.handler.initialize.mock_calls, [call()]*3)
self.handler.build_good. \
assert_called_once_with(2, MyBuildData([1, 2, 3]))
self.handler.build_bad.assert_called_once_with(1, MyBuildData([2, 3]))
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_case2(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3]), ['r', 's'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3])),
# we asked for a retry
call(MyBuildData([1, 2, 3])),
# we skipped one
call(MyBuildData([1, 3])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_retry.assert_called_with(1)
self.handler.build_skip.assert_called_with(1)
self.assertTrue(self.handler.build_range.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_with_back(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]),
['g', 'back', 'b', 'g'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# oups! let's go back
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered bad this time
call(MyBuildData([1, 2, 3])),
# then good
call(MyBuildData([2, 3])),
])
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_user_exit(self):
test_result = self.do__bisect(MyBuildData(range(20)), ['e'])
# check that set_build_range was called
self.handler.set_build_range.\
assert_has_calls([call(MyBuildData(range(20)))])
# ensure that we called the handler's method
self.handler.initialize.assert_called_once_with()
self.handler.user_exit.assert_called_with(10)
# user exit
self.assertEqual(test_result['result'], Bisection.USER_EXIT)
def test__bisect_with_background_download(self):
self.bisector.dl_in_background = True
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
call(MyBuildData([1, 2, 3, 4, 5])), # first call
call(MyBuildData([3, 4, 5])), # we answered good
call(MyBuildData([3, 4])) # we answered bad
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_bad.assert_called_with(1, MyBuildData([3, 4]))
self.assertTrue(self.handler.build_range.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
@patch('mozregression.bisector.Bisector._bisect')
def test_bisect(self, _bisect):
_bisect.return_value = 1
build_range = Mock()
create_range = Mock(return_value=build_range)
self.handler.create_range = create_range
result = self.bisector.bisect(self.handler, 'g', 'b', s=1)
create_range.assert_called_with(self.bisector.fetch_config,
'g', 'b', s=1)
self.assertFalse(build_range.reverse.called)
_bisect.assert_called_with(self.handler, build_range)
self.assertEqual(result, 1)
@patch('mozregression.bisector.Bisector._bisect')
def test_bisect_reverse(self, _bisect):
build_range = Mock()
create_range = Mock(return_value=build_range)
self.handler.create_range = create_range
self.handler.find_fix = True
self.bisector.bisect(self.handler, 'g', 'b', s=1)
create_range.assert_called_with(self.bisector.fetch_config,
'b', 'g', s=1)
_bisect.assert_called_with(self.handler, build_range)
class TestBisector(unittest.TestCase):
def setUp(self):
self.handler = MagicMock(find_fix=False)
self.test_runner = Mock()
self.bisector = Bisector(Mock(), self.test_runner,
dl_in_background=False)
self.bisector.download_background = False
@patch("mozregression.bisector.BuildDownloadManager")
def test__bisect_no_data(self, dl):
build_data = MyBuildData()
result = self.bisector._bisect(self.handler, build_data)
# test that handler methods where called
self.handler.set_build_data.assert_called_with(build_data)
self.handler.no_data.assert_called_once_with()
# check return code
self.assertEqual(result, Bisection.NO_DATA)
@patch("mozregression.bisector.BuildDownloadManager")
def test__bisect_finished(self, dl):
build_data = MyBuildData([1])
result = self.bisector._bisect(self.handler, build_data)
# test that handler methods where called
self.handler.set_build_data.assert_called_with(build_data)
self.handler.finished.assert_called_once_with()
# check return code
self.assertEqual(result, Bisection.FINISHED)
@patch("mozregression.bisector.BuildDownloadManager")
def do__bisect(self, build_data, verdicts, dl):
iter_verdict = iter(verdicts)
def evaluate(build_info, allow_back=False):
return iter_verdict.next(), {
'application_changeset': 'unused',
'application_repository': 'unused'
}
self.test_runner.evaluate = Mock(side_effect=evaluate)
result = self.bisector._bisect(self.handler, build_data)
return {
'result': result,
}
def test__bisect_case1(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# we answered bad
call(MyBuildData([3, 4])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_bad.assert_called_with(1, MyBuildData([3, 4]))
self.assertTrue(self.handler.build_data.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_case1_hunt_fix(self):
self.handler.find_fix = True
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([1, 2, 3])),
# we answered bad
call(MyBuildData([2, 3])),
])
# ensure that we called the handler's methods
self.assertEqual(self.handler.initialize.mock_calls, [call()]*3)
self.handler.build_good. \
assert_called_once_with(2, MyBuildData([1, 2, 3]))
self.handler.build_bad.assert_called_once_with(1, MyBuildData([2, 3]))
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_case2(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3]), ['r', 's'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3])),
# we asked for a retry
call(MyBuildData([1, 2, 3])),
# we skipped one
call(MyBuildData([1, 3])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_retry.assert_called_with(1)
self.handler.build_skip.assert_called_with(1)
self.assertTrue(self.handler.build_data.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_with_back(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]),
['g', 'back', 'b', 'g'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# oups! let's go back
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered bad this time
call(MyBuildData([1, 2, 3])),
# then good
call(MyBuildData([2, 3])),
])
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_user_exit(self):
test_result = self.do__bisect(MyBuildData(range(20)), ['e'])
# check that set_build_data was called
self.handler.set_build_data.\
assert_has_calls([call(MyBuildData(range(20)))])
# ensure that we called the handler's method
self.handler.initialize.assert_called_once_with()
self.handler.user_exit.assert_called_with(10)
# user exit
self.assertEqual(test_result['result'], Bisection.USER_EXIT)
def test__bisect_with_background_download(self):
self.bisector.dl_in_background = True
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
call(MyBuildData([1, 2, 3, 4, 5])), # first call
call(MyBuildData([3, 4, 5])), # download backgound
call(MyBuildData([1, 2, 3, 4, 5])), # put back the right data
call(MyBuildData([1, 2, 3])), # download backgound
call(MyBuildData([1, 2, 3, 4, 5])), # put back the right data
call(MyBuildData([3, 4, 5])), # we answered good
call(MyBuildData([4, 5])), # download backgound
call(MyBuildData([3, 4, 5])), # put back the right data
call(MyBuildData([3, 4])), # download backgound
call(MyBuildData([3, 4, 5])), # put back the right data
call(MyBuildData([3, 4])) # we answered bad
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_bad.assert_called_with(1, MyBuildData([3, 4]))
self.assertTrue(self.handler.build_data.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
@patch('mozregression.bisector.Bisector._bisect')
def test_bisect(self, _bisect):
_bisect.return_value = 1
build_data = Mock()
build_data_class = Mock(return_value=build_data)
self.handler.build_data_class = build_data_class
result = self.bisector.bisect(self.handler, 'g', 'b', s=1)
build_data_class.assert_called_with(self.bisector.fetch_config,
'g', 'b', s=1)
self.assertFalse(build_data.reverse.called)
_bisect.assert_called_with(self.handler, build_data)
self.assertEqual(result, 1)
@patch('mozregression.bisector.Bisector._bisect')
def test_bisect_reverse(self, _bisect):
build_data = Mock()
build_data_class = Mock(return_value=build_data)
self.handler.build_data_class = build_data_class
self.handler.find_fix = True
self.bisector.bisect(self.handler, 'g', 'b', s=1)
build_data_class.assert_called_with(self.bisector.fetch_config,
'b', 'g', s=1)
_bisect.assert_called_with(self.handler, build_data)
class TestBisector(unittest.TestCase):
def setUp(self):
self.handler = Mock(find_fix=False)
self.test_runner = Mock()
self.bisector = Bisector(Mock(), self.test_runner)
def test__bisect_no_data(self):
build_data = MyBuildData()
result = self.bisector._bisect(self.handler, build_data)
# test that handler methods where called
self.handler.set_build_data.assert_called_with(build_data)
self.handler.no_data.assert_called_once_with()
# check return code
self.assertEqual(result, Bisector.NO_DATA)
def test__bisect_finished(self):
build_data = MyBuildData([1])
result = self.bisector._bisect(self.handler, build_data)
# test that handler methods where called
self.handler.set_build_data.assert_called_with(build_data)
self.handler.finished.assert_called_once_with()
# check return code
self.assertEqual(result, Bisector.FINISHED)
def do__bisect(self, build_data, verdicts):
iter_verdict = iter(verdicts)
def evaluate(build_info, allow_back=False):
return iter_verdict.next(), {
'application_changeset': 'unused',
'application_repository': 'unused'
}
self.test_runner.evaluate = Mock(side_effect=evaluate)
result = self.bisector._bisect(self.handler, build_data)
return {
'result': result,
}
def test__bisect_case1(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# we answered bad
call(MyBuildData([3, 4])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_bad.assert_called_with(1, MyBuildData([3, 4]))
self.assertTrue(self.handler.build_data.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisector.FINISHED)
def test__bisect_case1_hunt_fix(self):
self.handler.find_fix = True
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([1, 2, 3])),
# we answered bad
call(MyBuildData([2, 3])),
])
# ensure that we called the handler's methods
self.assertEqual(self.handler.initialize.mock_calls, [call()]*3)
self.handler.build_good. \
assert_called_once_with(2, MyBuildData([1, 2, 3]))
self.handler.build_bad.assert_called_once_with(1, MyBuildData([2, 3]))
# bisection is finished
self.assertEqual(test_result['result'], Bisector.FINISHED)
def test__bisect_case2(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3]), ['r', 's'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3])),
# we asked for a retry
call(MyBuildData([1, 2, 3])),
# we skipped one
call(MyBuildData([1, 3])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_retry.assert_called_with(1)
self.handler.build_skip.assert_called_with(1)
self.assertTrue(self.handler.build_data.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisector.FINISHED)
def test__bisect_with_back(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]),
['g', 'back', 'b', 'g'])
# check that set_build_data was called
self.handler.set_build_data.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# oups! let's go back
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered bad this time
call(MyBuildData([1, 2, 3])),
# then good
call(MyBuildData([2, 3])),
])
# bisection is finished
self.assertEqual(test_result['result'], Bisector.FINISHED)
def test__bisect_user_exit(self):
test_result = self.do__bisect(MyBuildData(range(20)), ['e'])
# check that set_build_data was called
self.handler.set_build_data.\
assert_has_calls([call(MyBuildData(range(20)))])
# ensure that we called the handler's method
self.handler.initialize.assert_called_once_with()
self.handler.user_exit.assert_called_with(10)
# user exit
self.assertEqual(test_result['result'], Bisector.USER_EXIT)
@patch('mozregression.bisector.Bisector._bisect')
def test_bisect(self, _bisect):
_bisect.return_value = 1
build_data = Mock()
build_data_class = Mock(return_value=build_data)
self.handler.build_data_class = build_data_class
result = self.bisector.bisect(self.handler, 'g', 'b', s=1)
build_data_class.assert_called_with(self.bisector.fetch_config,
'g', 'b', s=1)
self.assertFalse(build_data.reverse.called)
_bisect.assert_called_with(self.handler, build_data)
self.assertEqual(result, 1)
@patch('mozregression.bisector.Bisector._bisect')
def test_bisect_reverse(self, _bisect):
build_data = Mock()
build_data_class = Mock(return_value=build_data)
self.handler.build_data_class = build_data_class
self.handler.find_fix = True
self.bisector.bisect(self.handler, 'g', 'b', s=1)
build_data_class.assert_called_with(self.bisector.fetch_config,
'b', 'g', s=1)
_bisect.assert_called_with(self.handler, build_data)
class TestBisector(unittest.TestCase):
def setUp(self):
self.handler = MagicMock(find_fix=False, ensure_good_and_bad=False)
self.test_runner = Mock()
self.bisector = Bisector(Mock(),
self.test_runner,
Mock(),
dl_in_background=False)
self.bisector.download_background = False
def test__bisect_no_data(self):
build_range = MyBuildData()
result = self.bisector._bisect(self.handler, build_range)
# test that handler methods where called
self.handler.set_build_range.assert_called_with(build_range)
self.handler.no_data.assert_called_once_with()
# check return code
self.assertEqual(result, Bisection.NO_DATA)
def test__bisect_finished(self):
build_range = MyBuildData([1])
result = self.bisector._bisect(self.handler, build_range)
# test that handler methods where called
self.handler.set_build_range.assert_called_with(build_range)
self.handler.finished.assert_called_once_with()
# check return code
self.assertEqual(result, Bisection.FINISHED)
def do__bisect(self, build_range, verdicts):
iter_verdict = iter(verdicts)
def evaluate(build_info, allow_back=False):
verdict = next(iter_verdict)
if isinstance(verdict, Exception):
raise verdict
return verdict
self.test_runner.evaluate = Mock(side_effect=evaluate)
result = self.bisector._bisect(self.handler, build_range)
return {
'result': result,
}
def test_ensure_good_bad_invalid(self):
self.handler.ensure_good_and_bad = True
with self.assertRaisesRegexp(MozRegressionError,
"expected to be good"):
self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['b'])
with self.assertRaisesRegexp(MozRegressionError, "expected to be bad"):
self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'g'])
def test_ensure_good_bad(self):
self.handler.ensure_good_and_bad = True
data = MyBuildData([1, 2, 3, 4, 5])
self.do__bisect(data, ['s', 'r', 'g', 'b', 'e'])
self.test_runner.evaluate.assert_has_calls([
call(data[0]), # tested good (then skip)
call(data[0]), # tested good (then retry)
call(data[0]), # tested good
call(data[-1]), # tested bad
])
self.assertEqual(
self.bisector.download_manager.download_in_background.call_count,
0)
def test_ensure_good_bad_with_bg_dl(self):
self.handler.ensure_good_and_bad = True
self.bisector.dl_in_background = True
data = MyBuildData([1, 2, 3, 4, 5])
self.do__bisect(data, ['s', 'r', 'g', 'e'])
self.test_runner.evaluate.assert_has_calls([
call(data[0]), # tested good (then skip)
call(data[0]), # tested good (then retry)
call(data[0]), # tested good
call(data[-1]), # tested bad
])
self.bisector.download_manager.download_in_background.assert_has_calls(
[
call(data[-1]), # bad in backgound
call(data[data.mid_point()])
] # and mid build
)
def test_ensure_good_bad_with_find_fix(self):
self.handler.ensure_good_and_bad = True
self.handler.find_fix = True
data = MyBuildData([1, 2, 3, 4, 5])
self.do__bisect(data, ['g', 'e'])
self.test_runner.evaluate.assert_has_calls([
call(data[-1]), # tested good (then skip)
call(data[0]), # tested bad
])
def test__bisect_case1(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# we answered bad
call(MyBuildData([3, 4])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_bad.assert_called_with(1, MyBuildData([3, 4]))
self.assertTrue(self.handler.build_range.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_with_launcher_exception(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]),
['g', LauncherError("err")])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# launcher exception, equivalent to a skip
call(MyBuildData([3, 5])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_skip.assert_called_with(1)
self.assertTrue(self.handler.build_range.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_case1_hunt_fix(self):
self.handler.find_fix = True
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([1, 2, 3])),
# we answered bad
call(MyBuildData([2, 3])),
])
# ensure that we called the handler's methods
self.assertEqual(self.handler.initialize.mock_calls, [call()] * 3)
self.handler.build_good. \
assert_called_once_with(2, MyBuildData([1, 2, 3]))
self.handler.build_bad.assert_called_once_with(1, MyBuildData([2, 3]))
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_case2(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3]), ['r', 's'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3])),
# we asked for a retry
call(MyBuildData([1, 2, 3])),
# we skipped one
call(MyBuildData([1, 3])),
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_retry.assert_called_with(1)
self.handler.build_skip.assert_called_with(1)
self.assertTrue(self.handler.build_range.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_with_back(self):
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]),
['g', 'back', 'b', 'g'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
# first call
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered good
call(MyBuildData([3, 4, 5])),
# oups! let's go back
call(MyBuildData([1, 2, 3, 4, 5])),
# we answered bad this time
call(MyBuildData([1, 2, 3])),
# then good
call(MyBuildData([2, 3])),
])
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
def test__bisect_user_exit(self):
test_result = self.do__bisect(MyBuildData(list(range(20))), ['e'])
# check that set_build_range was called
self.handler.set_build_range.\
assert_has_calls([call(MyBuildData(list(range(20))))])
# ensure that we called the handler's method
self.handler.initialize.assert_called_once_with()
self.handler.user_exit.assert_called_with(10)
# user exit
self.assertEqual(test_result['result'], Bisection.USER_EXIT)
def test__bisect_with_background_download(self):
self.bisector.dl_in_background = True
test_result = self.do__bisect(MyBuildData([1, 2, 3, 4, 5]), ['g', 'b'])
# check that set_build_range was called
self.handler.set_build_range.assert_has_calls([
call(MyBuildData([1, 2, 3, 4, 5])), # first call
call(MyBuildData([3, 4, 5])), # we answered good
call(MyBuildData([3, 4])) # we answered bad
])
# ensure that we called the handler's methods
self.handler.initialize.assert_called_with()
self.handler.build_good.assert_called_with(2, MyBuildData([3, 4, 5]))
self.handler.build_bad.assert_called_with(1, MyBuildData([3, 4]))
self.assertTrue(self.handler.build_range.ensure_limits_called)
# bisection is finished
self.assertEqual(test_result['result'], Bisection.FINISHED)
@patch('mozregression.bisector.Bisector._bisect')
def test_bisect(self, _bisect):
_bisect.return_value = 1
build_range = Mock()
create_range = Mock(return_value=build_range)
self.handler.create_range = create_range
result = self.bisector.bisect(self.handler, 'g', 'b', s=1)
create_range.assert_called_with(self.bisector.fetch_config,
'g',
'b',
s=1)
self.assertFalse(build_range.reverse.called)
_bisect.assert_called_with(self.handler, build_range)
self.assertEqual(result, 1)
@patch('mozregression.bisector.Bisector._bisect')
def test_bisect_reverse(self, _bisect):
build_range = Mock()
create_range = Mock(return_value=build_range)
self.handler.create_range = create_range
self.handler.find_fix = True
self.bisector.bisect(self.handler, 'g', 'b', s=1)
create_range.assert_called_with(self.bisector.fetch_config,
'b',
'g',
s=1)
_bisect.assert_called_with(self.handler, build_range)
