def test_notes(self):
"""
Should split notes into new features and known issues.
"""
new_feature_1 = Mock(**{
'is_known_issue_for.return_value': False,
'tag': 'Changed'
})
new_feature_2 = Mock(**{'is_known_issue_for.return_value': False})
dot_fix = Mock(
**{
'is_known_issue_for.return_value': False,
'tag': 'Fixed',
'note': '42.0.1 rendering glitches'
})
known_issue_1 = Mock(**{'is_known_issue_for.return_value': True})
known_issue_2 = Mock(**{'is_known_issue_for.return_value': True})
with patch.object(models.Release, 'note_set') as note_set:
release = models.Release()
note_set.order_by.return_value = [
new_feature_2, new_feature_1, dot_fix, known_issue_1,
known_issue_2
]
new_features, known_issues = release.notes()
note_set.order_by.assert_called_with('-sort_num', 'created')
eq_(new_features, [dot_fix, new_feature_2, new_feature_1])
eq_(known_issues, [known_issue_1, known_issue_2])
def test_unicode(self):
"""
Should equal name
"""
release = models.Release(product='Firefox',
channel='Release',
version='12.0.1')
eq_(unicode(release), 'Firefox 12.0.1 Release')
def test_is_known_issue_for(self):
"""
Should be False if is_known_issue is True and fixed_in_release
matches the given release.
"""
release = Mock(spec=models.Release())
note = models.Note(is_known_issue=True, fixed_in_release=release)
eq_(note.is_known_issue_for(release), False)
def test_equivalent_release_for_product_33_1(self):
"""
Should order by 2nd version # for 33.1 after applying other
sorting criteria
"""
release = models.Release(version='33.1', channel='Release')
release._default_manager = Mock()
mock_order_by = release._default_manager.filter.return_value.order_by
mock_public_filter = Mock(return_value=[
models.Release(version='33.0.3'),
models.Release(version='33.1')
])
mock_order_by.return_value = Mock(filter=mock_public_filter)
eq_(release.equivalent_release_for_product('Firefox').version, '33.1')
release._default_manager.filter.assert_called_once_with(
version__startswith='33.', channel='Release', product='Firefox')
mock_public_filter.assert_called_once_with(is_public=True)
def test_get_bug_search_url(self):
"""
Should return self.bug_search_url
"""
eq_(
models.Release(
bug_search_url='http://example.com').get_bug_search_url(),
'http://example.com')
def test_equivalent_desktop_release_non_firefox_product(self):
"""
Should not call equivalent_release_for_product if
self.product does not equal 'Firefox for Android'
"""
release = models.Release(product='Firefox OS')
release.equivalent_release_for_product = Mock()
eq_(release.equivalent_desktop_release(), None)
eq_(release.equivalent_release_for_product.called, 0)
def test_no_equivalent_release_for_product(self):
"""
Should return None for empty querysets
"""
release = models.Release(version='42.0', channel='Release')
release._default_manager = Mock()
release._default_manager.filter.return_value.order_by.return_value = \
models.Release.objects.none()
eq_(release.equivalent_release_for_product('Firefox'), None)
def test_equivalent_release_for_product_dev(self):
"""
Should return the release for the specified product with
the same channel and major version
"""
release = models.Release(version='42.0', channel='Release')
release._default_manager = Mock()
mock_order_by = release._default_manager.filter.return_value.order_by
mock_order_by.return_value = [
models.Release(version='42.0'),
models.Release(version='42.0.1')
]
eq_(
release.equivalent_release_for_product('Firefox').version,
'42.0.1')
release._default_manager.filter.assert_called_once_with(
version__startswith='42.', channel='Release', product='Firefox')
mock_order_by.assert_called_once_with('-version')
def test_notes_public_only(self):
"""
Should filter notes based on is_public attr.
"""
with patch.object(models.Release, 'note_set') as note_set:
release = models.Release()
release.notes(public_only=True)
note_set.order_by.return_value.filter.assert_called_with(
is_public=True)
def test_equivalent_desktop_release(self):
"""
Should return the equivalent_release_for_product where the
product is 'Firefox'
"""
release = models.Release(product='Firefox for Android')
release.equivalent_release_for_product = Mock()
eq_(release.equivalent_desktop_release(),
release.equivalent_release_for_product.return_value)
release.equivalent_release_for_product.assert_called_once_with(
'Firefox')
def test_get_bug_search_url_thunderbird(self):
"""
Should construct based on major version
"""
eq_(
models.Release(version='42.0',
product='Thunderbird').get_bug_search_url(),
'https://bugzilla.mozilla.org/buglist.cgi?'
'classification=Client%20Software&query_format=advanced&'
'bug_status=RESOLVED&bug_status=VERIFIED&bug_status=CLOSED&'
'target_milestone=Thunderbird%2042.0&product=Thunderbird'
'&resolution=FIXED')
def test_get_bug_search_url_default(self):
"""
Should construct based on major version
"""
eq_(
models.Release(version='42.0').get_bug_search_url(),
'https://bugzilla.mozilla.org/buglist.cgi?'
'j_top=OR&f1=target_milestone&o3=equals&v3=Firefox%2042&'
'o1=equals&resolution=FIXED&o2=anyexact&query_format=advanced&'
'f3=target_milestone&f2=cf_status_firefox42&'
'bug_status=RESOLVED&bug_status=VERIFIED&bug_status=CLOSED&'
'v1=mozilla42&v2=fixed%2Cverified&limit=0')
def test_major_version(self):
"""
Should return the version up to, but not including, the first dot
"""
eq_(models.Release(version='42.0').major_version(), '42')
