Python compare.version_int函数代码示例

def test_version_int():
    """Tests that version_int. Corrects our versions."""
    eq_(version_int('3.5.0a1pre2'), 3050000001002)
    eq_(version_int(''), 200100)
    eq_(version_int(sys.maxint), sys.maxint)
    eq_(version_int(sys.maxint + 1), sys.maxint)
    eq_(version_int('9999999'), sys.maxint)

def find_jetpacks(jp_version):
    """
    Find all jetpack files that aren't disabled.

    Files that should be upgraded will have needs_upgrade=True.
    """
    statuses = amo.VALID_STATUSES
    files = (File.objects.filter(jetpack_version__isnull=False,
                                 version__addon__status__in=statuses,
                                 version__addon__disabled_by_user=False)
             .exclude(status=amo.STATUS_DISABLED).no_cache()
             .select_related('version'))
    files = sorted(files, key=lambda f: (f.version.addon_id, f.version.id))

    # Figure out which files need to be upgraded.
    for file_ in files:
        file_.needs_upgrade = False
    # If any files for this add-on are reviewed, take the last reviewed file
    # plus all newer files.  Otherwise, only upgrade the latest file.
    for _, fs in groupby(files, key=lambda f: f.version.addon_id):
        fs = list(fs)
        if any(f.status in amo.REVIEWED_STATUSES for f in fs):
            for file_ in reversed(fs):
                file_.needs_upgrade = True
                if file_.status in amo.REVIEWED_STATUSES:
                    break
        else:
            fs[-1].needs_upgrade = True
    # Make sure only old files are marked.
    for file_ in [f for f in files if f.needs_upgrade]:
        if version_int(file_.jetpack_version) >= version_int(jp_version):
            file_.needs_upgrade = False
    return files

def test_version_int():
    """Tests that version_int. Corrects our versions."""
    eq_(version_int('3.5.0a1pre2'), 3050000001002)
    eq_(version_int(''), 200100)
    eq_(version_int(MAXVERSION), MAXVERSION)
    eq_(version_int(MAXVERSION + 1), MAXVERSION)
    eq_(version_int('9999999'), MAXVERSION)

 def __init__(self, request, platform, version):
     self.request = request
     self.platform = platform
     self.version = version
     self.compat_mode = 'strict'
     if version_int(self.version) >= version_int('10.0'):
         self.compat_mode = 'ignore'

 def test_bump_version_in_model(self, mock_sign_file):
     # We want to make sure each file has been signed.
     self.file2 = amo.tests.file_factory(version=self.version)
     self.file2.update(filename='jetpack-b.xpi')
     backup_file2_path = u'{0}.backup_signature'.format(
         self.file2.file_path)
     try:
         with amo.tests.copy_file('apps/files/fixtures/files/jetpack.xpi',
                                  self.file_.file_path):
             with amo.tests.copy_file(
                     'apps/files/fixtures/files/jetpack.xpi',
                     self.file2.file_path):
                 file_hash = self.file_.generate_hash()
                 file2_hash = self.file2.generate_hash()
                 assert self.version.version == '1.3'
                 assert self.version.version_int == version_int('1.3')
                 tasks.sign_addons([self.addon.pk])
                 assert mock_sign_file.call_count == 2
                 self.version.reload()
                 assert self.version.version == '1.3.1-signed'
                 assert self.version.version_int == version_int(
                     '1.3.1-signed')
                 assert file_hash != self.file_.generate_hash()
                 assert file2_hash != self.file2.generate_hash()
                 self.assert_backup()
                 assert os.path.exists(backup_file2_path)
     finally:
         if os.path.exists(backup_file2_path):
             os.unlink(backup_file2_path)

    def incompatible_latest_apps(self):
        """Returns a list of applications with which this add-on is
        incompatible (based on the latest version).

        """
        return [a for a, v in self.compatible_apps.items() if v and
                version_int(v.max.version) < version_int(a.latest_version)]

 def __init__(self, request, platform, version):
     self.request = request
     self.platform = platform
     self.version = version
     self.compat_mode = 'strict'
     if (waffle.switch_is_active('d2c-at-the-disco') and
         version_int(self.version) >= version_int('10.0')):
         self.compat_mode = 'ignore'

def get_compat_mode(version):
    # Returns appropriate compat mode based on app version.
    # Replace when we are ready to deal with bug 711698.
    vint = version_int(version)
    if waffle.switch_is_active("d2c-at-the-disco"):
        return "ignore" if vint >= version_int("10.0") else "strict"
    else:
        return "strict"

def check_jetpack_version(sender, **kw):
    import files.tasks
    from zadmin.models import get_config

    jetpack_version = get_config('jetpack_version')
    qs = File.objects.filter(version__addon=sender,
                             jetpack_version__isnull=False)
    ids = [f.id for f in qs
           if version_int(f.jetpack_version) < version_int(jetpack_version)]
    if ids:
        files.tasks.start_upgrade.delay(jetpack_version, ids, priority='high')

 def test_dont_sign_dont_bump_version_bad_zipfile(self, mock_sign_file):
     with amo.tests.copy_file(__file__, self.file_.file_path):
         file_hash = self.file_.generate_hash()
         assert self.version.version == '1.3'
         assert self.version.version_int == version_int('1.3')
         tasks.sign_addons([self.addon.pk])
         assert not mock_sign_file.called
         self.version.reload()
         assert self.version.version == '1.3'
         assert self.version.version_int == version_int('1.3')
         assert file_hash == self.file_.generate_hash()
         self.assert_no_backup()

def _filter_search(request,
                   qs,
                   query,
                   filters,
                   sorting,
                   sorting_default='-weekly_downloads',
                   types=[]):
    """Filter an ES queryset based on a list of filters."""
    APP = request.APP
    # Intersection of the form fields present and the filters we want to apply.
    show = [f for f in filters if query.get(f)]

    if query.get('q'):
        qs = qs.query(or_=name_query(query['q']))
    if 'platform' in show and query['platform'] in amo.PLATFORM_DICT:
        ps = (amo.PLATFORM_DICT[query['platform']].id, amo.PLATFORM_ALL.id)
        # If we've selected "All Systems" don't filter by platform.
        if ps[0] != ps[1]:
            qs = qs.filter(platform__in=ps)
    if 'appver' in show:
        # Get a min version less than X.0.
        low = version_int(query['appver'])
        # Get a max version greater than X.0a.
        high = version_int(query['appver'] + 'a')
        # If we're not using D2C then fall back to appversion checking.
        extensions_shown = (not query.get('atype')
                            or query['atype'] == amo.ADDON_EXTENSION)
        if not extensions_shown or low < version_int('10.0'):
            qs = qs.filter(
                **{
                    'appversion.%s.max__gte' % APP.id: high,
                    'appversion.%s.min__lte' % APP.id: low
                })
    if 'atype' in show and query['atype'] in amo.ADDON_TYPES:
        qs = qs.filter(type=query['atype'])
    else:
        qs = qs.filter(type__in=types)
    if 'cat' in show:
        cat = (Category.objects.filter(id=query['cat']).filter(
            Q(application=APP.id) | Q(type=amo.ADDON_SEARCH)))
        if not cat.exists():
            show.remove('cat')
        if 'cat' in show:
            qs = qs.filter(category=query['cat'])
    if 'tag' in show:
        qs = qs.filter(tag=query['tag'])
    if 'sort' in show:
        qs = qs.order_by(sorting[query['sort']])
    elif not query.get('q'):
        # Sort by a default if there was no query so results are predictable.
        qs = qs.order_by(sorting_default)

    return qs

 def test_dont_sign_dont_bump_sign_error(self, mock_sign_file):
     mock_sign_file.side_effect = IOError()
     with amo.tests.copy_file("apps/files/fixtures/files/jetpack.xpi", self.file_.file_path):
         file_hash = self.file_.generate_hash()
         assert self.version.version == "1.3"
         assert self.version.version_int == version_int("1.3")
         tasks.sign_addons([self.addon.pk])
         assert mock_sign_file.called
         self.version.reload()
         assert self.version.version == "1.3"
         assert self.version.version_int == version_int("1.3")
         assert file_hash == self.file_.generate_hash()
         self.assert_no_backup()

 def test_resign_bump_version_in_model_if_force(self, mock_sign_file):
     with amo.tests.copy_file("apps/files/fixtures/files/new-addon-signature.xpi", self.file_.file_path):
         self.file_.update(is_signed=True)
         file_hash = self.file_.generate_hash()
         assert self.version.version == "1.3"
         assert self.version.version_int == version_int("1.3")
         tasks.sign_addons([self.addon.pk], force=True)
         assert mock_sign_file.called
         self.version.reload()
         assert self.version.version == "1.3.1-signed"
         assert self.version.version_int == version_int("1.3.1-signed")
         assert file_hash != self.file_.generate_hash()
         self.assert_backup()

 def test_dont_bump_not_signed(self, mock_sign_file):
     mock_sign_file.return_value = None  # Pretend we didn't sign.
     with amo.tests.copy_file("apps/files/fixtures/files/jetpack.xpi", self.file_.file_path):
         file_hash = self.file_.generate_hash()
         assert self.version.version == "1.3"
         assert self.version.version_int == version_int("1.3")
         tasks.sign_addons([self.addon.pk])
         assert mock_sign_file.called
         self.version.reload()
         assert self.version.version == "1.3"
         assert self.version.version_int == version_int("1.3")
         assert file_hash == self.file_.generate_hash()
         self.assert_no_backup()

 def test_sign_bump_old_versions_default_compat(self, mock_sign_file):
     """Sign files which are old, but default to compatible."""
     with amo.tests.copy_file("apps/files/fixtures/files/jetpack.xpi", self.file_.file_path):
         file_hash = self.file_.generate_hash()
         assert self.version.version == "1.3"
         assert self.version.version_int == version_int("1.3")
         self.set_max_appversion(settings.MIN_D2C_VERSION)
         tasks.sign_addons([self.addon.pk])
         assert mock_sign_file.called
         self.version.reload()
         assert self.version.version == "1.3.1-signed"
         assert self.version.version_int == version_int("1.3.1-signed")
         assert file_hash != self.file_.generate_hash()
         self.assert_backup()