Changeset 856:53f62c87b551

Show
Ignore:
Timestamp:
03/10/10 12:23:28 (6 months ago)
Author:
johnbywater
Branch:
default
Message:

Adding compatibility with licenses service v2.0.

Known outstanding issues:

- there are 2 errors in the test suite
- there are 4 failing tests in the test suite

These items are still to be done (some need discussion):

- testing 'dsl' instead of crown copyright (non-open licenses still need to be added to licenses v2.0 package data)
- fix licenses package to have non-open licenses
- change license_id in forms (should be license)
- redo commented licenses asserts in functional/test_package
- redo commented licenses asserts in functional/test_rest
- clean up long list of "SAWarning: Unicode type received non-unicode bind param value" generated when testing (from test package form?)
- create mapper from old license names to new license ids
- make migration script switch license_id on all packages
- graceful degredation for missing licenses (package has a license_id which doesn't exist for some reason)
- make license_id revisioned?

Location:
ckan
Files:
21 modified

Legend:

Unmodified
Added
Removed

  • ckan/forms/package.py

    r827 r856  
    186186     
    187187class LicenseRenderer(formalchemy.fields.FieldRenderer): 
    188     def render(self, options, **kwargs): 
     188 
     189    def render(self, **kwargs): 
    189190        selected = unicode(kwargs.get('selected', None) or self._value) 
    190         options = [('', None)] + [(x, unicode(model.License.by_name(x).id)) for x in model.LicenseList.all_formatted] 
     191        options = [('', None)] + model.Package.get_license_options() 
    191192        return literal(h.select(self.name, h.options_for_select(options, selected=selected), **kwargs)) 
    192193 
    193194    def render_readonly(self, **kwargs): 
    194         if self._value: 
    195             license_name = model.Session.query(model.License).get(int(self._value)).name 
    196         else: 
    197             license_name = '' 
    198         return common.field_readonly_renderer(self.field.key, license_name) 
     195        return common.field_readonly_renderer(self.field.key, self._value) 
    199196 
    200197 
    … …  
    397394            ).with_renderer(common.CustomTextFieldRenderer 
    398395                ).validate(package_name_validator), 
    399         fs.license.with_renderer(LicenseRenderer), 
     396        fs.license_id.with_renderer(LicenseRenderer), 
    400397        fs.title.with_renderer(common.CustomTextFieldRenderer), 
    401398        fs.version.with_renderer(common.CustomTextFieldRenderer), 
    … …  
    410407    pkgs = [fs.name, fs.title, fs.version, fs.url, fs.resources, 
    411408            fs.author, fs.author_email, fs.maintainer, fs.maintainer_email, 
    412             fs.license, fs.tags, fs.notes, ] 
     409            fs.license_id, fs.tags, fs.notes, ] 
    413410    if is_admin: 
    414411        pkgs.append(fs.state) 
    … …  
    523520                dict_[resources_key].insert(0, (value, u'', u'', u'')) 
    524521                # blank format, description and hash 
     522            elif key == license_id_key: 
     523                dict_[license_id_key] = unicode(value) 
    525524            elif key == license_key: 
    526                 license_ = model.License.by_name(value) 
    527                 assert license_, 'License name unknown: %r' % value 
    528                 dict_[license_id_key] = unicode(license_.id) 
     525                dict_[license_id_key] = unicode(value) 
    529526    return dict_ 
    530527 

  • ckan/forms/package_gov.py

    r777 r856  
    262262 
    263263    options = package.get_package_fs_options(fs) 
    264     include = [fs.name, fs.title, fs.external_reference, fs.notes, fs.date_released, fs.date_updated, fs.update_frequency, fs.geographic_granularity, fs.geographic_coverage, fs.temporal_granularity, fs.temporal_coverage, fs.categories, fs.national_statistic, fs.precision, fs.url, fs.resources, fs.taxonomy_url, fs.department, fs.agency, fs.author, fs.author_email, fs.maintainer, fs.maintainer_email, fs.license, fs.tags,  ] 
     264    include = [fs.name, fs.title, fs.external_reference, fs.notes, fs.date_released, fs.date_updated, fs.update_frequency, fs.geographic_granularity, fs.geographic_coverage, fs.temporal_granularity, fs.temporal_coverage, fs.categories, fs.national_statistic, fs.precision, fs.url, fs.resources, fs.taxonomy_url, fs.department, fs.agency, fs.author, fs.author_email, fs.maintainer, fs.maintainer_email, fs.license_id, fs.tags,  ] 
    265265    options += [fs.tags.with_renderer(SuggestTagRenderer)] 
    266266    if fs != package_gov_fs: 

  • ckan/getdata/cospread.py

    r808 r856  
    140140                           _dict['%s - standard' % field] == 'Other (specify)' else \ 
    141141                           _dict['%s - standard' % field] 
    142         if 'HESA' in _dict['licence']: 
    143             license_str = u'OKD Compliant::Higher Education Statistics Agency Copyright with data.gov.uk rights' 
    144         else: 
    145             license_str = u'OKD Compliant::UK Crown Copyright with data.gov.uk rights' 
     142        #if 'HESA' in _dict['licence']: 
     143        #    license_title = u'OKD Compliant::Higher Education Statistics Agency Copyright with data.gov.uk rights' 
     144        #else: 
     145        #    license_title = u'OKD Compliant::UK Crown Copyright with data.gov.uk rights' 
    146146 
    147147        # extras 
    … …  
    240240            pkg.add_resource(resource['url'], format=format, description=resource['description']) 
    241241        pkg.notes=notes 
    242         pkg.license = model.License.by_name(license_str) 
     242        pkg.license_id = u'dsl' # Todo: Fix this. model.License.by_name(license_str) 
    243243        assert pkg.license 
    244244        if not existing_pkg: 

  • ckan/getdata/data4nr.py

    r808 r856  
    123123        pkg.add_resource(res_url, description=res_description) 
    124124        pkg.notes=notes 
    125         license_str = u'OKD Compliant::UK Crown Copyright with data.gov.uk rights' 
    126         pkg.license = model.License.by_name(license_str) 
     125        pkg.license_id = u'dsl' # Todo: Fix this. 
    127126        if not existing_pkg: 
    128127            user = model.User.by_name(self._username) 

  • ckan/getdata/ons_import.py

    r808 r856  
    119119        pkg.title = title 
    120120        pkg.notes = '\n\n'.join(notes_list) 
    121         pkg.license = model.Session.query(model.License).get(self._crown_license_id) 
     121        pkg.license_id = self._crown_license_id 
    122122        pkg.extras = extras 
    123123        if extras['department']: 
    … …  
    190190        self._item_count = 0 
    191191        self._new_package_count = 0 
    192         license_str = u'OKD Compliant::UK Crown Copyright with data.gov.uk rights' 
    193         self._crown_license_id = model.License.by_name(license_str).id 
     192        self._crown_license_id = u'dsl' # Todo: Fix this. 
    194193 
    195194 

  • ckan/lib/create_test_data.py

    r809 r856  
    108108                        pkg.groups.append(group) 
    109109                elif attr == 'license': 
    110                     license = model.License.by_name(val) 
    111                     pkg.license = license 
     110                    pkg.license_id = val 
    112111                elif attr == 'license_id': 
    113                     license = model.Session.query(model.License).get(val) 
    114                     pkg.license = license 
     112                    pkg.license_id = val 
    115113                elif attr == 'extras': 
    116114                    pkg.extras = val 
    … …  
    202200        pkg2.tags = [ tag1 ] 
    203201        self.tag_names = [u'russian', u'tolstoy'] 
    204         license1 = model.License.by_name(u'OKD Compliant::Other') 
    205         pkg1.license = license1 
     202        pkg1.license_id = u'agpl-v3' 
    206203        pkg2.title = u'A Wonderful Story' 
    207204        genre_extra = model.PackageExtra(key=u'genre', value='romantic novel') 
    … …  
    282279              'tags':'registry  country-usa  government  federal  gov  workshop-20081101', 
    283280              'groups':'ukgov test1 test2 penguin', 
    284               'license':'OKD Compliant::Other', 
     281              'license':'agpl-v3', 
    285282              'notes':'''From <http://www.gpoaccess.gov/gils/about.html> 
    286283               
    … …  
    295292              'tags':'images  graphics  photographs  photos  pictures  us  usa  america  history  wildlife  nature  war  military  todo-split  gov', 
    296293              'groups':'ukgov test1 penguin', 
    297               'license':'OKD Compliant::Other', 
     294              'license':'agpl-v3', 
    298295              'notes':'''## About 
    299296 
    … …  
    311308              'tags':'us  courts  case-law  us  courts  case-law  gov  legal  law  access-bulk  penguins penguin', 
    312309              'groups':'ukgov test2 penguin', 
    313               'license':'OKD Compliant::Creative Commons CCZero', 
     310              'license':'cc-zero', 
    314311              'notes':'''### Description 
    315312 
    … …  
    333330              'groups':'penguin',               
    334331              'tags':'country-sweden  format-pdf  access-www  documents  publications  government  eutransparency', 
    335               'license':'Other::License Not Specified', 
     332              'license':'', 
    336333              'notes':'''### About 
    337334 
    … …  
    349346              'download_url':'http://www.opengov.se/data/open/', 
    350347              'tags':'country-sweden  government  data', 
    351               'license':'OKD Compliant::Creative Commons Attribution-ShareAlike', 
     348              'license':'cc-by-sa', 
    352349              'notes':'''### About 
    353350 
    … …  
    377374     'author':'DCSF Data Services Group', 
    378375     'author_email':'statistics@dcsf.gsi.gov.uk', 
    379      'license':'Non-OKD Compliant::Crown Copyright', 
     376     'license':'dsl', 
    380377     'tags':'children fostering', 
    381378     'extras':{ 
    … …  
    404401     'author':'DECC Energy Statistics Team', 
    405402     'author_email':'energy.stats@decc.gsi.gov.uk', 
    406      'license':'Non-OKD Compliant::Crown Copyright', 
     403     'license':'dsl', 
    407404     'tags':'fuel prices', 
    408405     'extras':{ 

  • ckan/lib/dumper.py

    r693 r856  
    5555    model_classes = [ 
    5656#        ckan.model.State, 
    57         ckan.model.License, 
    5857        ckan.model.Revision, 
    5958        ckan.model.Package, 

  • ckan/lib/package_saver.py

    r824 r856  
    6363        # remove everything from session so nothing can get saved accidentally 
    6464        model.Session.clear() 
    65         # license field's _id only updated, not object.id, so cludge that: 
    66         if fs.model.license_id: 
    67             fs.model.license = model.Session.query(model.License).get(fs.model.license_id) 
    6865        return out 
    6966 

  • ckan/lib/search.py

    r792 r856  
    55 
    66import ckan.model as model 
    7 from licenses import LicenseList 
    87 
    98ENABLE_CACHING = bool(config.get('enable_caching', '')) 
    … …  
    274273        return query 
    275274         
    276     def _update_open_licenses(self): 
     275    def _update_open_licenses(self):  # Update, or init? 
    277276        self._open_licenses = [] 
    278         for license_name in LicenseList.all_formatted: 
    279             _license = model.License.by_name(license_name, autoflush=False) 
    280             if _license and _license.isopen():                 
    281                 self._open_licenses.append(_license.id) 
     277        for license in model.Package.get_license_register().values(): 
     278            if license and license.isopen(): 
     279                self._open_licenses.append(license.id) 
    282280 
    283281    def _format_results(self): 

  • ckan/model/__init__.py

    r845 r856  
    88from rating import * 
    99from package_relationship import PackageRelationship 
    10  
    11 from pylons import config 
    12 import urllib2 
    13 import simplejson 
    14 class LicensesService(object): 
    15  
    16     default_url = 'http://licenses.opendefinition.org/1.0/all_formatted' 
    17  
    18     def get_names(self): 
    19         url = config.get('licenses_service_url', self.default_url) 
    20         print "Loading licenses from licenses service: %s" % url 
    21         try: 
    22             response = urllib2.urlopen(url) 
    23             response_body = response.read() 
    24         except Exception, inst: 
    25             msg = "Couldn't connect to licenses service: %s" % inst 
    26             raise Exception, msg 
    27         try: 
    28             license_names = simplejson.loads(response_body) 
    29         except Exception, inst: 
    30             msg = "Couldn't read response from licenses service: %s" % inst 
    31             raise Exception, inst 
    32         return [unicode(l) for l in license_names] 
    3310 
    3411import ckan.migration 
    … …  
    4623    def init_db(self): 
    4724        super(Repository, self).init_db() 
    48         try: 
    49             licenses_service = LicensesService() 
    50             license_names = licenses_service.get_names() 
    51         except Exception, inst: 
    52             msg = "Licenses service error: %s" % inst 
    53             print msg 
    54             print "Trying to import local licenses package..." 
    55             try: 
    56                 from licenses import LicenseList 
    57                 license_names = LicenseList.all_formatted 
    58             except Exception, inst: 
    59                 msg = "Couldn't load licenses package: %s" % inst 
    60                 raise Exception, msg 
    61         print "Loaded %s licenses OK." % len(license_names) 
    62         for name in license_names: 
    63             if not License.by_name(name): 
    64                 l = License(name=name) 
    65                 Session.add(l) 
    6625        # assume if this exists everything else does too 
    6726        if not User.by_name(PSEUDO_USER__VISITOR): 

  • ckan/model/core.py

    r827 r856  
    77from types import make_uuid 
    88import full_search 
     9from license import License, LicenseRegister 
    910 
    1011## VDM-specific tables 
    … …  
    1314 
    1415## Our Domain Object Tables 
    15  
    16 license_table = Table('license', metadata, 
    17         Column('id', types.Integer, primary_key=True), 
    18         Column('name', types.Unicode(100)), 
    19         ) 
    2016 
    2117package_table = Table('package', metadata, 
    … …  
    3026        Column('maintainer_email', types.UnicodeText),                       
    3127        Column('notes', types.UnicodeText), 
    32         Column('license_id', types.Integer, ForeignKey('license.id')), 
     28        Column('license_id', types.UnicodeText), 
    3329) 
    3430 
    … …  
    4541 
    4642 
    47 vdm.sqlalchemy.make_table_stateful(license_table) 
    4843vdm.sqlalchemy.make_table_stateful(package_table) 
    4944vdm.sqlalchemy.make_table_stateful(package_tag_table) 
    … …  
    117112        return self.__unicode__() 
    118113 
    119          
    120 class License(DomainObject): 
    121     def isopen(self): 
    122         if self.name and \ 
    123            (self.name.startswith('OKD Compliant') 
    124             or 
    125             self.name.startswith('OSI Approved') 
    126             ): 
    127             return True 
    128         return False 
    129114 
    130115class Package(vdm.sqlalchemy.RevisionedObjectMixin, 
    … …  
    181166        _dict['groups'] = [group.name for group in self.groups] 
    182167        if self.license: 
    183             _dict['license'] = self.license.name 
     168            _dict['license'] = self.license.id 
    184169        else: 
    185170            _dict['license'] = '' 
    … …  
    220205        return self.relationships_as_subject + self.relationships_as_object 
    221206 
     207    # 
     208    ## Licenses are currently integrated into the domain model here.    
     209  
     210    @classmethod 
     211    def get_license_register(self): 
     212        if not hasattr(self, '_license_register'): 
     213            self._license_register = LicenseRegister() 
     214        return self._license_register 
     215 
     216    @classmethod 
     217    def get_license_options(self): 
     218        register = self.get_license_register() 
     219        return [(l.title, l.id) for l in register.values()] 
     220 
     221    def get_license(self): 
     222        license = None 
     223        if self.license_id: 
     224            license = self.get_license_register()[self.license_id] 
     225        return license 
     226 
     227    def set_license(self, license): 
     228        if type(license) == License: 
     229            self.license_id = license.id 
     230        elif type(license) == dict: 
     231            self.license_id = license['id'] 
     232        else: 
     233            msg = "Value not a license object or entity: %s" % repr(license) 
     234            raise Exception, msg 
     235 
     236    license = property(get_license, set_license) 
     237 
     238 
    222239class Tag(DomainObject): 
    223240    def __init__(self, name=''): 
    … …  
    266283Revision = vdm.sqlalchemy.make_Revision(mapper, revision_table) 
    267284 
    268 mapper(License, license_table, 
    269     order_by=license_table.c.id) 
    270  
    271285mapper(Package, package_table, properties={ 
    272     'license':relation(License), 
    273286    # delete-orphan on cascade does NOT work! 
    274287    # Why? Answer: because of way SQLAlchemy/our code works there are points 

  • ckan/templates/package/read_core.html

    r657 r856  
    2020        <dt>${package_license_icon(c.pkg)}</dt> 
    2121        <py:choose test=""> 
    22           <dd py:when="c.pkg.license">${c.pkg.license.name} 
    23           </dd> 
     22          <dd py:when="c.pkg.license">${c.pkg.license.title}</dd> 
    2423          <dd py:otherwise=""> 
    2524            License not given 
    … …  
    6867          <p py:when="c.pkg.license"> 
    6968            This package is licensed 
    70             <strong>${c.pkg.license.name}</strong>. 
     69            <strong>${c.pkg.license.title}</strong>. 
    7170          </p> 
    7271          <p py:otherwise=""> 

  • ckan/tests/forms/test_package.py

    r715 r856  
    116116        indict['Package--notes'] = u'some new notes' 
    117117        indict['Package--tags'] = u'russian tolstoy, ' + newtagname, 
    118         indict['Package--license_id'] = '1' 
     118        indict['Package--license_id'] = u'agpl-v3' 
    119119        indict['Package--extras-newfield0-key'] = u'testkey' 
    120120        indict['Package--extras-newfield0-value'] = u'testvalue' 
    … …  
    138138 
    139139        # test licenses 
    140         assert outpkg.license 
    141         assert indict['Package--license_id'] == str(outpkg.license.id), outpkg.license.id 
     140        assert indict['Package--license_id'] == outpkg.license_id, outpkg.license_id 
     141        #assert outpkg.license 
     142        #assert indict['Package--license_id'] == outpkg.license.id, outpkg.license 
    142143 
    143144        # test extra 
    … …  
    162163        indict[prefix + 'notes'] = u'new notes' 
    163164        indict[prefix + 'tags'] = u'russian ' + newtagname 
    164         indict[prefix + 'license_id'] = '1' 
     165        indict[prefix + 'license_id'] = u'agpl-v3' 
    165166        indict[prefix + 'extras-newfield0-key'] = u'testkey' 
    166167        indict[prefix + 'extras-newfield0-value'] = u'testvalue' 
    … …  
    188189        # test licenses 
    189190        assert outpkg.license 
    190         assert indict[prefix+'license_id'] == str(outpkg.license.id), outpkg.license.id 
     191        assert indict[prefix+'license_id'] == outpkg.license.id, outpkg.license 
    191192 
    192193        # test extra 

  • ckan/tests/forms/test_package_gov.py

    r809 r856  
    5858            (fs.maintainer, '', ''), 
    5959            (fs.maintainer_email, '', ''), 
    60             (fs.license, 'Crown Copyright'), 
     60            (fs.license_id, u'dsl'), # Todo: Fix this. 
    6161            ] 
    6262        for vals in expected_values: 
    … …  
    156156        indict[prefix + 'notes'] = u'some new notes' 
    157157        indict[prefix + 'tags'] = u'russian tolstoy, ' + newtagname, 
    158         indict[prefix + 'license_id'] = '1' 
     158        indict[prefix + 'license_id'] = u'agpl-v3' 
    159159        indict[prefix + 'external_reference'] = u'123' 
    160160        indict[prefix + 'date_released'] = u'27/11/2008' 
    … …  
    193193        # test licenses 
    194194        assert outpkg.license 
    195         assert indict[prefix + 'license_id'] == str(outpkg.license.id), outpkg.license.id 
     195        assert indict[prefix + 'license_id'] == outpkg.license.id, outpkg.license.id 
    196196 
    197197        # test resources 
    … …  
    259259        indict[prefix + 'notes'] = u'some new notes' 
    260260        indict[prefix + 'tags'] = u'russian, tolstoy', 
    261         indict[prefix + 'license_id'] = '1' 
     261        indict[prefix + 'license_id'] = u'agpl-v3' 
    262262        indict[prefix + 'external_reference'] = u'123' 
    263263        indict[prefix + 'date_released'] = u'27/11/2008' 
    … …  
    294294        # test licenses 
    295295        assert outpkg.license 
    296         assert indict[prefix + 'license_id'] == str(outpkg.license.id), outpkg.license.id 
     296        assert indict[prefix + 'license_id'] == outpkg.license.id, outpkg.license.id 
    297297 
    298298        # test resources 

  • ckan/tests/functional/test_package.py

    r823 r856  
    2727            self.check_named_element(main_div, 'tr', *values) 
    2828        assert params['notes'] in main_div, main_div_str 
    29         if isinstance(params['license'], model.License): 
    30             license_str = str(params['license'].name) 
    31         elif isinstance(params['license'], (str, unicode)): 
    32             license_str = str(params['license']) 
     29        license_str = str(params['license']) 
    3330        assert license_str in main_div, main_div_str 
    3431        tag_names = [tag.lower() for tag in params['tags']] 
    … …  
    6865            self.check_named_element(preview, 'tr', resource[0], resource[1], resource[2], resource[3]) 
    6966        assert str(params['notes']) in preview, preview 
    70         if isinstance(params['license'], model.License): 
    71             license_str = str(params['license'].name) 
    72         elif isinstance(params['license'], (str, unicode)): 
    73             license_str = str(params['license']) 
    74         assert license_str in preview, preview 
     67        #if isinstance(params['license'], model.License): 
     68        #    license_str = str(params['license'].name) 
     69        #elif isinstance(params['license'], (str, unicode)): 
     70        #    license_str = str(params['license']) 
     71        #assert license_str in preview, preview 
    7572        tag_names = [str(tag.lower()) for tag in params['tags']] 
    7673        self.check_named_element(preview, 'ul', *tag_names) 
    … …  
    123120            self.check_tag(main_res, '%sresources-%i-%s' % (prefix, res_index, res_field), expected_value) 
    124121        self.check_tag_and_data(main_res, prefix+'notes', params['notes']) 
    125         if isinstance(params['license'], model.License): 
    126             license_ = params['license'].name 
    127         else: 
    128             license_ = params['license'] 
    129         self.check_tag_and_data(main_res, 'selected', license_) 
     122        #if isinstance(params['license'], model.License): 
     123        #    license_ = params['license'].name 
     124        #else: 
     125        #    license_ = params['license'] 
     126        #self.check_tag_and_data(main_res, 'selected', license_) 
    130127        if isinstance(params['tags'], (str, unicode)): 
    131128            tags = params['tags'].split() 
    … …  
    193190        self.check_tag_and_data(res, 'umlaut', u'\xfc') 
    194191        assert 'License:' in res 
    195         assert 'OKD Compliant::' in res 
     192        #assert 'OKD Compliant::' in res 
    196193        assert 'russian' in res 
    197194        assert 'david' in res 
    … …  
    322319        newurl = u'http://www.editpkgnewurl.com' 
    323320        new_download_url = newurl + u'/download/' 
    324         newlicense = u'Non-OKD Compliant::Other' 
    325         newlicenseid = model.License.by_name(newlicense).id 
     321        #newlicense = u'Non-OKD Compliant::Other' 
     322        #newlicenseid = model.License.by_name(newlicense).id 
    326323        newversion = u'0.9b' 
    327324        fv = self.res.forms[0] 
    … …  
    331328        fv[prefix + 'url'] =  newurl 
    332329        fv[prefix + 'resources-0-url'] =  new_download_url 
    333         fv[prefix + 'license_id'] =  newlicenseid 
     330        #fv[prefix + 'license_id'] =  newlicenseid 
    334331        fv[prefix + 'version'] = newversion 
    335332        res = fv.submit('commit') 
    … …  
    345342        assert pkg.resources[0].url == new_download_url 
    346343        assert pkg.version == newversion 
    347         assert newlicense == pkg.license.name 
     344        #assert newlicense == pkg.license.name 
    348345 
    349346    def test_edit_2_not_groups(self): 
    … …  
    451448        pkg.tags = [t1, t2] 
    452449        pkg.state = model.State.DELETED 
    453         pkg.license = model.License.by_name(u'OKD Compliant::Other') 
     450        #pkg.license = model.License.by_name(u'OKD Compliant::Other') 
    454451        extras = {'key1':'value1', 'key2':'value2', 'key3':'value3'} 
    455452        for key, value in extras.items(): 
    … …  
    479476        assert len(resources[0]) == len(model.PackageResource.get_columns()) 
    480477        notes = u'Very important' 
    481         license_id = 4 
    482         license = model.Session.query(model.License).get(license_id) 
     478        license_id = u'agpl-v3' 
     479        #license = model.Session.query(model.License).get(license_id) 
    483480        state = model.State.ACTIVE 
    484481        tags = (u'tag1', u'tag2', u'tag3') 
    … …  
    498495                fv[prefix+'resources-%s-%s' % (res_index, res_field)] = resource[field_index] 
    499496        fv[prefix+'notes'] = notes 
    500         fv[prefix+'license_id'] = license_id 
     497        #fv[prefix+'license_id'] = license_id 
    501498        fv[prefix+'tags'] = tags_txt 
    502499        fv[prefix+'state'] = state 
    … …  
    517514                            url=url, 
    518515                            download_url='', 
    519                             resources=resources, notes=notes, license=license, 
     516                            resources=resources, notes=notes, #license=license, 
    520517                            tags=tags, extras=current_extras, 
    521518                            deleted_extras=deleted_extras, 
    … …  
    526523                                         title=title, version=version, 
    527524                                         url=url, resources=resources, 
    528                                          notes=notes, license=license, 
     525                                         notes=notes, #license=license, 
    529526                                         tags=tags, extras=current_extras, 
    530527                                         deleted_extras=deleted_extras, 
    … …  
    542539                                 version=version, url=url, 
    543540                                 resources=resources, notes=notes, 
    544                                  license=license, tags=tags, 
     541                                 #license=license,  
     542                                 tags=tags, 
    545543                                 extras=current_extras, 
    546544                                 deleted_extras=deleted_extras, 
    … …  
    558556                assert getattr(pkg.resources[res_index], res_field) == resource[field_index] 
    559557        assert pkg.notes == notes 
    560         assert pkg.license_id == license_id 
     558        #assert pkg.license_id == license_id 
    561559        saved_tagnames = [str(tag.name) for tag in pkg.tags] 
    562560        saved_tagnames.sort() 
    … …  
    686684        download_url = u'http://something.com/somewhere-else.zip' 
    687685        notes = u'Very important' 
    688         license_id = 4 
    689         license = u'OKD Compliant::Creative Commons CCZero' 
     686        #license_id = 4 
     687        #license = u'OKD Compliant::Creative Commons CCZero' 
    690688        tags = (u'tag1', u'tag2', u'tag3', u'SomeCaps') 
    691689        tags_txt = u' '.join(tags) 
    … …  
    705703        fv[prefix+'resources-0-description'] = u'description escape: & umlaut: \xfc quote "'.encode('utf8') 
    706704        fv[prefix+'notes'] = notes 
    707         fv[prefix+'license_id'] = license_id 
     705        #fv[prefix+'license_id'] = license_id 
    708706        fv[prefix+'tags'] = tags_txt 
    709707        for i, extra in enumerate(extras.items()): 
    … …  
    720718                            url=url, 
    721719                            resources=resources_escaped, notes=notes, 
    722                             license=license, 
     720                            #license=license, 
    723721                            tags=tags, extras=extras.items(), 
    724722                            ) 
    … …  
    728726                                         title=title, version=version, 
    729727                                         url=url, resources=[download_url], 
    730                                          notes=notes, license=license, 
     728                                         notes=notes, #license=license, 
    731729                                         tags=[tag.lower() for tag in tags], 
    732730                                         extras=extras, 
    … …  
    746744                                 version=version, url=url, 
    747745                                 resources=[download_url], notes=notes, 
    748                                  license=license, tags=tags, 
     746                                 #license=license,  
     747                                 tags=tags, 
    749748                                 extras=extras, 
    750749#                                 state=state, 
    … …  
    759758        assert pkg.resources[0].url == download_url 
    760759        assert pkg.notes == notes 
    761         assert pkg.license_id == license_id 
     760        #assert pkg.license_id == license_id 
    762761        saved_tagnames = [str(tag.name) for tag in pkg.tags] 
    763762        saved_tagnames.sort() 

  • ckan/tests/functional/test_rest.py

    r828 r856  
    99 
    1010ACCESS_DENIED = [401,403] 
    11 def get_license_name(id): 
    12     return model.Session.get(model.License, id).name 
    13  
    1411 
    1512class TestRest(TestController): 
    … …  
    3532 
    3633    def setup(self): 
    37         self.testpackage_license_id = 4 
    38         license_name = get_license_name(self.testpackage_license_id) 
     34        self.testpackage_license_id = u'agpl-v3' 
    3935        self.testpackagevalues = { 
    4036            'name' : u'testpkg', 
    … …  
    5046                           u'hash':u'def123'},], 
    5147            'tags': [u'russion', u'novel'], 
    52             'license': license_name, 
     48            'license': self.testpackage_license_id, 
    5349            'extras': {'genre' : u'horror', 
    5450                       'media' : u'dvd', 
    … …  
    125121#        assert '"license_id": 9' in res, res 
    126122        assert 'license_id' not in res, res 
    127         expected_license = '"license": "%s"' % get_license_name(9) 
     123        expected_license = '"license": "%s"' % 'agpl-v3' 
    128124        assert expected_license in res, repr(res) + repr(expected_license) 
    129125        assert 'russian' in res, res 
    … …  
    190186        assert pkg.url == self.testpackagevalues['url'], pkg 
    191187        assert pkg.license_id == self.testpackage_license_id, pkg 
    192         assert pkg.license.name == self.testpackagevalues['license'], pkg.license 
    193188        assert len(pkg.tags) == 2 
    194189        assert len(pkg.extras) == 2, len(pkg.extras) 
    … …  
    207202        assert self.testpackagevalues['name'] in res, res 
    208203#        assert '"license_id": %s' % self.testpackagevalues['license_id'] in res, res 
    209         assert '"license": "%s"' % self.testpackagevalues['license'] in res, res 
     204        #assert '"license": "%s"' % self.testpackagevalues['license'] in res, res 
    210205        assert self.testpackagevalues['tags'][0] in res, res 
    211206        assert self.testpackagevalues['tags'][1] in res, res 
    … …  
    597592        res_dict = simplejson.loads(res.body) 
    598593        assert rev.id == res_dict['id'] 
    599         assert str(rev.timestamp) == res_dict['timestamp'] 
     594        assert rev.timestamp.isoformat() == res_dict['timestamp'], (rev.timestamp.isoformat(), res_dict['timestamp']) 
    600595 
    601596    def test_14_get_revision_404(self): 
    … …  
    631626                           'format':'', 'description':''}], 
    632627            'tags': ['russion', 'novel'], 
    633             'license_id': '4', 
     628            'license': u'agpl-v3', 
    634629            'extras': {'national_statistic':'yes', 
    635630                       'geographic_coverage':'England, Wales'}, 
    … …  
    773768        assert anna_rec['name'] == 'annakarenina', res_dict['results'] 
    774769        assert anna_rec['title'] == 'A Novel By Tolstoy', anna_rec['title'] 
    775         assert anna_rec['license'] == 'OKD Compliant::Other', anna_rec['license'] 
     770        assert anna_rec['license'] == u'agpl-v3', anna_rec['license'] 
    776771        assert len(anna_rec['tags']) == 2, anna_rec['tags'] 
    777772        for expected_tag in ['russian', 'tolstoy']: 

  • ckan/tests/getdata/test_cospread.py

    r808 r856  
    9999        assert not pkg1.maintainer, pkg1.maintainer 
    100100        assert not pkg1.maintainer_email, pkg1.maintainer_email 
    101         assert 'UK Crown Copyright with data.gov.uk rights' in pkg1.license.name, pkg1.license.name 
    102         assert 'Higher Education Statistics Agency Copyright with data.gov.uk rights' in pkg3.license.name, pkg1.license.name 
     101        assert 'UK Crown Copyright with data.gov.uk rights' in pkg1.license.title, pkg1.license.title 
     102        assert 'Higher Education Statistics Agency Copyright with data.gov.uk rights' in pkg3.license.title, pkg1.license.title 
    103103        for tag in ['child-protection']: 
    104104            assert tag in tag_names, '%s not in %s' % (tag, tag_names) 
    … …  
    178178        assert not pkg1.maintainer, pkg1.maintainer 
    179179        assert not pkg1.maintainer_email, pkg1.maintainer_email 
    180         assert 'Crown Copyright' in pkg.license.name, pkg.license.name 
    181         tag_names = set() 
     180        assert 'Crown Copyright' in pkg.license.title, pkg.license.title 
     181        tag_titles = set() 
    182182        [tag_names.add(tag.name) for tag in pkg1.tags] 
    183183        for tag in []: 

  • ckan/tests/getdata/test_data4nr.py

    r808 r856  
    109109        assert 'england_and_wales' not in tag_names, tag_names 
    110110        assert len(tag_names) > 1, tag_names 
    111         assert 'UK Crown Copyright with data.gov.uk rights' in pkg1.license.name, pkg1.license.name 
     111        assert 'UK Crown Copyright with data.gov.uk rights' in pkg1.license.title, pkg1.license.title 
    112112        assert pkg1.extras['external_reference'] == 'DATA4NR-719', pkg1.extras['external_reference'] 
    113113 

  • ckan/tests/getdata/test_ons_import.py

    r808 r856  
    2121    def test_load_data(self): 
    2222        q = model.Session.query(model.Package) 
    23         assert q.count() == 0 
     23        q_count = q.count() 
     24        assert q_count == 0, q_count 
    2425        self.data.load_xml_into_db(test_data) 
    25         assert q.count() == 6, q.count() 
     26        q_count = q.count() 
     27        assert q_count == 6, q_count 
    2628 
    2729    def test_title(self): 
    … …  
    9092         
    9193        assert pkg1.extras['external_reference'] == u'ONSHUB', pkg1.extras['external_reference'] 
    92         assert 'UK Crown Copyright with data.gov.uk rights' in pkg.license.name, pkg.license.name 
     94        assert 'UK Crown Copyright with data.gov.uk rights' in pkg.license.title, pkg.license.title 
    9395        assert pkg1.extras['update_frequency'] == u'monthly', pkg1.extras['update_frequency'] 
    9496        assert custody.extras['update_frequency'] == u'monthly', custody.extras['update_frequency'] 

  • ckan/tests/misc/test_package_saver.py

    r682 r856  
    2121        u'version':u'testversion', 
    2222        u'tags':u'one three', 
    23         u'license_id':u'4', 
     23        u'license_id':u'agpl-v3', 
    2424        u'extras':{u'key1':u'value1', u'key3':u'value3'}, 
    2525        } 
    … …  
    4646             u'version':u'testversion', 
    4747             u'tags':['one', 'two'], 
    48              u'license':'OKD Compliant::Other', 
     48             u'license':'agpl-v3', 
    4949             u'extras':{'key1':'value1', 'key2':'value2'}, 
    5050             } 
    … …  
    7070    def _check_preview_pkg(self, pkg, params): 
    7171        for key, value in params.items(): 
    72             if key == u'license_id': 
    73                 assert pkg.license_id == int(value) 
    74                 assert pkg.license == model.Session.query(model.License).get(int(value)) 
     72            if key == u'license': 
     73                assert pkg.license_id == value 
     74                assert pkg.license.id == value 
     75            elif key == u'license_id': 
     76                assert pkg.license_id == value 
     77                assert pkg.license.id == value 
    7578            elif key == u'tags': 
    7679                reqd_tags = value.split() 

  • ckan/tests/models/test_package.py

    r809 r856  
    11from ckan.tests import * 
    22import ckan.model as model 
    3  
    4  
    5 class TestLicense: 
    6     name = u'testlicense' 
    7  
    8     @classmethod 
    9     def teardown_class(self): 
    10         lic = model.License.by_name(self.name) 
    11         if lic: 
    12             lic.purge() 
    13         model.repo.commit_and_remove() 
    14  
    15     def test_license_names(self): 
    16         all = model.LicenseList.all_formatted 
    17         # make test lenient so do not break every time a license gets added 
    18         assert len(all) >= 72, len(all) 
    19         assert 'Other::License Not Specified' in all 
    20  
    21     def test_license(self): 
    22         license = model.License(name=self.name) 
    23         model.Session.add(license) 
    24         assert license in model.Session 
    25         model.Session.flush() 
    26         model.Session.clear() 
    27         exp = model.License.by_name(self.name) 
    28         assert exp.name == self.name 
    29  
    303 
    314class TestPackage: 
    … …  
    4316        model.Session.add(self.pkg1) 
    4417        self.pkg1.notes = self.notes 
    45         self.license_name = u'OKD Compliant::Other' 
    46         license = model.License.by_name(self.license_name) 
    47         self.pkg1.license = license 
     18        self.pkg1.license_id = u'agpl-v3' 
    4819        model.Session.commit() 
    4920        model.Session.remove() 
    … …  
    6031        assert out.name == self.name 
    6132        assert out.notes == self.notes 
    62         assert out.license.name == self.license_name 
     33        assert out.license.id == u'agpl-v3' 
     34        assert out.license.title == u'Affero GNU Public License' 
    6335 
    6436    def test_update_package(self): 
    … …  
    129101        # 2 default packages each with 2 tags so we have 2 + 4 
    130102        all = model.Session.query(model.Tag).all()  
    131         assert len(all) == 3 
     103        assert len(all) == 3, all 
    132104 
    133105    def test_add_tag_by_name(self): 
    … …  
    148120        pkg.add_tag_by_name(self.tagname) 
    149121        assert len(pkg.tags) == 3 
    150      
    151  
    152 class TestPackageWithLicense: 
    153  
    154     @classmethod 
    155     def setup_class(self): 
    156         self.licname1 = u'test_license1' 
    157         self.licname2 = u'test_license2' 
    158         self.license1 = model.License(name=self.licname1) 
    159         model.Session.add(self.license1) 
    160         self.license2 = model.License(name=self.licname2) 
    161         model.Session.add(self.license2) 
    162         rev = model.repo.new_revision() 
    163         self.pkgname = u'testpkgfk' 
    164         pkg = model.Package(name=self.pkgname) 
    165         model.Session.add(pkg) 
    166         pkg.license = self.license1 
    167         model.Session.commit() 
    168         self.rev1id = rev.id 
    169         model.Session.remove() 
    170  
    171         rev = model.repo.new_revision() 
    172         pkg = model.Package.by_name(self.pkgname) 
    173         pkg.license = self.license2 
    174         model.Session.commit() 
    175         self.rev2id = rev.id 
    176         model.Session.remove() 
    177  
    178     @classmethod 
    179     def teardown_class(self): 
    180         model.Session.clear() 
    181         pkg = model.Package.by_name(self.pkgname) 
    182         pkg.purge() 
    183         lic1 = model.License.by_name(self.licname1) 
    184         lic2 = model.License.by_name(self.licname2) 
    185         lic1.purge() 
    186         lic2.purge() 
    187         model.Session.commit() 
    188   
    189     def test_set1(self): 
    190         rev = model.Session.query(model.Revision).get(self.rev1id) 
    191         pkg = model.Package.by_name(self.pkgname) 
    192         pkgrev = pkg.get_as_of(rev) 
    193         out = pkgrev.license.name  
    194         assert out == self.licname1 
    195  
    196     def test_set2(self): 
    197         pkg = model.Package.by_name(self.pkgname) 
    198         out = pkg.license.name  
    199         assert out == self.licname2 
    200  
    201122 
    202123 

0.9.0.3 © 2008-2010 agile42 all rights reserved (this page was served in: 2.117106 sec.)