def setup(self):
        # need to do this for every test since we mess with System rights
        CreateTestData.create()
        model.repo.new_revision()
        model.Session.add(model.User(name=u'testadmin'))
        model.Session.add(model.User(name=u'testsysadmin'))
        model.Session.add(model.User(name=u'notadmin'))
        model.repo.commit_and_remove()

        pkg = model.Package.by_name(u'annakarenina')
        admin = model.User.by_name(u'testadmin')
        sysadmin = model.User.by_name(u'testsysadmin')
        model.add_user_to_role(admin, model.Role.ADMIN, pkg)
        model.add_user_to_role(sysadmin, model.Role.ADMIN, model.System())
        model.repo.commit_and_remove()

        self.pkg = model.Package.by_name(u'annakarenina')
        self.admin = model.User.by_name(u'testadmin')
        self.sysadmin = model.User.by_name(u'testsysadmin')
        self.notadmin = model.User.by_name(u'notadmin')

        self.package_fillers = {'title': 'test title',
                                'notes': 'test notes',
                                'license_id': 'mit-license',
                                }
Example #2
0
def user(ctx):
    flask_app = ctx.obj.app.apps[u'flask_app']._wsgi_app
    with flask_app.test_request_context():
        CreateTestData.create_test_user()
    click.echo(
        u'Created user {0} with password {0} and apikey {0}'.format(u'tester')
    )
    def setup_class(cls):
        harvest_model.setup()
        CreateTestData.create()

        sysadmin_user = ckan.model.User.get('testsysadmin')
        cls.sysadmin = {
                'id': sysadmin_user.id,
                'apikey': sysadmin_user.apikey,
                'name': sysadmin_user.name,
                }


        cls.app = paste.fixture.TestApp(pylons.test.pylonsapp)

        cls.default_source_dict =  {
          "url": "http://test.action.com",
          "name": "test-source-action",
          "title": "Test source action",
          "notes": "Test source action desc",
          "source_type": "test-for-action",
          "frequency": "MANUAL",
          "config": json.dumps({"custom_option":["a","b"]})
        }

        if not p.plugin_loaded('test_action_harvester'):
            p.load('test_action_harvester')
 def teardown(self):
     """
     Cleanup the Gov3Fixtures
     """
     self.fixtures.delete()
     _drop_sysadmin()
     CreateTestData.delete()
 def test_new_package_without_resources(self):
     self._mark_the_time()
     CreateTestData.create_arbitrary({'name': 'testpkg'})
     pkg = model.Package.get('testpkg')
     assert pkg
     assert self._has_modification_time_been_updated_since_the_mark(pkg)
     self._assert_post_determined_modification_time_is_correct(pkg)
Example #6
0
 def setup_class(cls):
     model.repo.rebuild_db()
     search.clear_all()
     CreateTestData.create()
     cls.sysadmin_user = model.User.get('testsysadmin')
     cls.normal_user = model.User.get('annafan')
     CreateTestData.make_some_vocab_tags()
Example #7
0
    def setup_class(self):
        model.Session.remove()
        CreateTestData.create()
        self.name = u"revisiontest1"

        # create pkg
        self.description = [
            u"Written by Puccini",
            u"Written by Rossini",
            u"Not written at all",
            u"Written again",
            u"Written off",
        ]
        rev = model.repo.new_revision()
        self.grp = model.Group(name=self.name)
        self.grp.description = self.description[0]
        model.Session.add(self.grp)
        model.setup_default_user_roles(self.grp)
        model.repo.commit_and_remove()

        # edit pkg
        for i in range(5)[1:]:
            rev = model.repo.new_revision()
            grp = model.Group.by_name(self.name)
            grp.description = self.description[i]
            model.repo.commit_and_remove()

        self.grp = model.Group.by_name(self.name)
 def setup_class(self):
     # create test data
     CreateTestData.create()
     username = '******'
     user = model.User.by_name(unicode(username))
     assert user
     self.testclient = WsgiCkanClient(self.app, api_key=user.apikey, base_location='/api/2')
Example #9
0
    def setup_class(cls):
        model.repo.rebuild_db()
        CreateTestData.create()
        plugins.load('drupal')
        from ckan.plugins import PluginImplementations
        from ckan.plugins.interfaces import IConfigurer
        for plugin in PluginImplementations(IConfigurer):
            plugin.update_config(config)

        url = config['drupal.db_url'] 
        cls.engine = create_engine(url, echo=True)
        cls.metadata = MetaData(cls.engine)
        cls.node = Table('node',
                          cls.metadata,
                          autoload = True)
        cls.node = Table('node_revisions',
                          cls.metadata,
                          autoload = True)
        cls.package_table = Table('ckan_package',
                                  cls.metadata,
                                  autoload = True)
        cls.extra_table = Table('ckan_package_extra',
                                  cls.metadata,
                                  autoload = True)
        cls.resource_table = Table('ckan_resource',
                                  cls.metadata,
                                  autoload = True)
        cls.engine.execute('delete from ckan_package')
        cls.engine.execute('delete from ckan_resource')
        cls.engine.execute('delete from ckan_package_extra')
        cls.engine.execute('delete from ckan_package_tag')
        cls.engine.execute('delete from node')
        cls.engine.execute('delete from node_revisions')
Example #10
0
    def test_8_geo_coverage(self):
        # create initial package
        pkg_name = u"test_coverage"
        init_data = [
            {
                "name": pkg_name,
                "title": "test_title",
                "extras": {"geographic_coverage": "001000: England, Scotland, Wales"},
            }
        ]
        CreateTestData.create_arbitrary(init_data)
        pkg = model.Package.by_name(pkg_name)
        assert pkg

        # edit it with form parameters
        fs = get_fieldset()
        indict = ckan.forms.get_package_dict(pkg, fs=fs)
        prefix = "Package-%s-" % pkg.id
        indict[prefix + "geographic_coverage-england"] = u"True"
        indict[prefix + "geographic_coverage-wales"] = u"True"
        indict[prefix + "geographic_coverage-scotland"] = u"True"
        indict[prefix + "geographic_coverage-global"] = u"True"
        fs = fs.bind(pkg, data=indict)

        model.repo.new_revision()
        fs.sync()
        model.repo.commit_and_remove()

        outpkg = model.Package.by_name(pkg_name)
        assert_equal(outpkg.extras["geographic_coverage"], "111001: Global, Great Britain (England, Scotland, Wales)")
Example #11
0
    def setup_class(cls):
        super(TestAuthorisation, cls).setup_class()
        model.repo.new_revision()
        model.Session.commit()

        users = [
            {'name': 'test_sysadmin',
             'sysadmin': True,
             'apikey': 'test_sysadmin',
             'password': '******'},
            {'name': 'test_user',
             'sysadmin': False,
             'apikey': 'test_user',
             'password': '******'},
            {'name': 'test_user2',
             'sysadmin': False,
             'apikey': 'test_user2',
             'password': '******'}
        ]
        CreateTestData.create_users(users)
        cls.test_user = user_model.User.get('test_user')
        cls.test_sysadmin = user_model.User.get('test_sysadmin')
        cls.api_test_sysadmin = ckanapi.TestAppCKAN(cls.app, apikey=cls.test_sysadmin.apikey)
        cls.api_test_user = ckanapi.TestAppCKAN(cls.app, apikey=cls.test_user.apikey)
        org_dict = {'name': 'test_organisation', 'title': 'Test Organisation'}
        cls.api_test_sysadmin.action.organization_create(**org_dict)
        cls.TEST_DATADICT = copy.deepcopy(TEST_DATADICT)
        cls.TEST_DATADICT['owner_org'] = 'test_organisation'
Example #12
0
    def setup_class(self):
        model.repo.init_db()
        CreateTestData.create_test_user()
#        self.admin = model.User.by_name(u'russianfan')

#        self.extra_environ_admin = {'REMOTE_USER': self.admin.name.encode('utf8')}
        self.extra_environ_tester = {'REMOTE_USER': '******'}
Example #13
0
    def test_edit(self):
        CreateTestData.create_arbitrary(
            {u'name':u'name_before',
             u'title':u'title_before',
             u'url':u'testurl',
             u'resources':[{'url':'dlu1', 'format':'tf1'},
                           ],
             u'notes':u'testnotes',
             u'version':u'testversion',
             u'tags':['one', 'two'],
             u'license':'gpl-3.0',
             u'extras':{'key1':'value1', 'key2':'value2'},
             }
            )

        pkg = model.Package.by_name(u'name_before')
        fs = ckan.forms.get_standard_fieldset(is_admin=False, user_editable_groups=[])
        data =  ckan.forms.add_to_package_dict(
                ckan.forms.get_package_dict(pkg=pkg, fs=fs, user_editable_groups=[]), self.params,
                    pkg.id)
        fs = fs.bind(pkg, data=data)
        pkg2 = PackageSaver()._preview_pkg(fs, u'name_before', pkg.id)
        self._check_preview_pkg(pkg2, self.params)

        # Check nothing has changed in the model
        assert model.Package.by_name(u'name_before')
        assert not model.Package.by_name(u'name_after')
        assert not model.Tag.by_name(u'three')
        resources = model.Session.query(model.PackageResource).filter_by(url=u'dlu2c').first()
        assert resources is None, resources
Example #14
0
    def setup_class(cls):
        """Setup for all tests."""

        model.repo.rebuild_db()
        kata_model.setup()
        CreateTestData.create()

        cls.user_sysadmin = model.User.get('testsysadmin')  # Org admin
        cls.user_normal = model.User.get('tester')          # Org editor
        cls.user_anna = model.User.get('annafan')
        cls.user_joe = model.User.get('joeadmin')           # Org member

        wsgiapp = make_app(config['global_conf'], **config['app_conf'])
        cls.app = paste.fixture.TestApp(wsgiapp)

        # Set up API callers

        cls.api_user_normal = ckanapi.TestAppCKAN(cls.app, apikey=cls.user_normal.apikey)
        cls.api_user_sysadmin = ckanapi.TestAppCKAN(cls.app, apikey=cls.user_sysadmin.apikey)
        cls.api_user_anna = ckanapi.TestAppCKAN(cls.app, apikey=cls.user_anna.apikey)
        cls.api_user_joe = ckanapi.TestAppCKAN(cls.app, apikey=cls.user_joe.apikey)
        cls.api = ckanapi.TestAppCKAN(cls.app)

        cls.TEST_DATADICT = copy.deepcopy(TEST_DATADICT)

        try:
            output = cls.api_user_sysadmin.action.organization_create(**TEST_ORGANIZATION_COMMON)
            cls.TEST_DATADICT['owner_org'] = output.get('id')
        except AppError:
            print 'Failed to create a common organization. Perhaps it exists already.'
Example #15
0
    def setup_class(cls):
        MockVocabTagsPlugin().set_active(True)
        CreateTestData.create(package_type='mock_vocab_tags_plugin')
        cls.sysadmin_user = model.User.get('testsysadmin')
        cls.dset = model.Package.get('warandpeace')
        cls.tag1_name = 'vocab-tag-1'
        cls.tag2_name = 'vocab-tag-2'

        # use our custom select class for this test suite
        cls.old_select = paste.fixture.Field.classes['select']
        paste.fixture.Field.classes['select'] = Select

        # create a test vocab
        params = json.dumps({'name': TEST_VOCAB_NAME})
        extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
        response = cls.app.post('/api/action/vocabulary_create', params=params,
                                extra_environ=extra_environ)
        assert json.loads(response.body)['success']
        vocab_id = json.loads(response.body)['result']['id']

        # add tags to the vocab
        extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
        params = json.dumps({'name': cls.tag1_name, 'vocabulary_id': vocab_id})
        response = cls.app.post('/api/action/tag_create', params=params,
                                 extra_environ=extra_environ)
        assert json.loads(response.body)['success']
        params = json.dumps({'name': cls.tag2_name, 'vocabulary_id': vocab_id})
        response = cls.app.post('/api/action/tag_create', params=params,
                                 extra_environ=extra_environ)
        assert json.loads(response.body)['success']
Example #16
0
    def test_4_new_duplicate_package(self):
        prefix = ''

        # Create group
        group_name = u'testgrp4'
        CreateTestData.create_groups([{'name': group_name,
                                       'packages': [self.packagename]}],
                                     admin_user_name='testsysadmin')

        # Add same package again
        offset = url_for(controller='group', action='edit', id=group_name)
        res = self.app.get(offset, status=200,
                           extra_environ={'REMOTE_USER': '******'})
        fv = res.forms['group-edit']
        fv['packages__1__name'] = self.packagename
        res = fv.submit('save', status=302,
                        extra_environ={'REMOTE_USER': '******'})
        res = res.follow()
        assert group_name in res, res
        model.Session.remove()

        # check package only added to the group once
        group = model.Group.by_name(group_name)
        pkg_names = [pkg.name for pkg in group.packages()]
        assert_equal(pkg_names, [self.packagename])
Example #17
0
    def test_delete(self):
        group_name = 'deletetest'
        CreateTestData.create_groups([{'name': group_name,
                                       'packages': [self.packagename]}],
                                     admin_user_name='testsysadmin')

        group = model.Group.by_name(group_name)
        offset = url_for(controller='group', action='edit', id=group_name)
        res = self.app.get(offset, status=200,
                           extra_environ={'REMOTE_USER': '******'})
        main_res = self.main_div(res)
        assert 'Edit: %s' % group.title in main_res, main_res
        assert 'value="active" selected' in main_res, main_res

        # delete
        form = res.forms['group-edit']
        form['state'] = 'deleted'
        res = form.submit('save', status=302,
                          extra_environ={'REMOTE_USER': '******'})

        group = model.Group.by_name(group_name)
        assert_equal(group.state, 'deleted')
        res = self.app.get(offset, status=302)
        res = res.follow()
        assert res.request.url.startswith('/user/login'), res.request.url
Example #18
0
 def test_mapper_plugin_fired_on_insert(self):
     with plugins.use_plugin('mapper_plugin') as mapper_plugin:
         CreateTestData.create_arbitrary([{'name': u'testpkg'}])
         assert mapper_plugin.calls == [
             ('before_insert', 'testpkg'),
             ('after_insert', 'testpkg'),
             ]
Example #19
0
 def setup_class(cls):
     search.clear()
     CreateTestData.create()
     cls.testsysadmin = model.User.by_name(u"testsysadmin")
     cls.comment = u"Comment umlaut: \xfc."
     cls.user_name = u"annafan"  # created in CreateTestData
     cls.init_extra_environ(cls.user_name)
Example #20
0
 def setup_class(self):
     CreateTestData.create()
     self.ab = 'http://site.com/a/b.txt'
     self.cd = 'http://site.com/c/d.txt'
     self.package_fixture_data = {
         'name' : u'testpkg',
         'title': 'Some Title',
         'url': u'http://blahblahblah.mydomain',
         'resources':[
             {'url':self.ab,
              'description':'This is site ab.',
              'format':'Excel spreadsheet',
              'alt_url':'alt',
              'extras':{'size':'100'},
              'hash':'abc-123'},
             {'url':self.cd,
              'description':'This is site cd.',
              'format':'Office spreadsheet',
              'alt_url':'alt',
              'extras':{'size':'100'},
              'hash':'qwe-456'},
             ],
         'tags': ['russion', 'novel'],
         'license_id': u'gpl-3.0',
         'extras': {'national_statistic':'yes',
                    'geographic_coverage':'England, Wales'},
     }
     CreateTestData.create_arbitrary(self.package_fixture_data)
     self.base_url = self.offset('/search/resource')
Example #21
0
 def setup_class(cls):
     search.clear_all()
     CreateTestData.create()
     cls.testsysadmin = model.User.by_name(u'testsysadmin')
     cls.comment = u'Comment umlaut: \xfc.'
     cls.user_name = u'annafan' # created in CreateTestData
     cls.init_extra_environ(cls.user_name)
Example #22
0
    def test_2_field_publisher_none(self):
        # Create package
        CreateTestData.create_arbitrary({"name": u"test2", "title": u"Test2", "license": u"odc-pddl", "notes": u"some"})

        pkg = model.Package.by_name(u"test2")
        fs = get_fieldset()
        fs = fs.bind(pkg)
        out = fs.render()
        assert out

        for field, should_have_null_value in [(fs.published_by, False), (fs.published_via, True)]:
            pub_options = field.render()
            pub_options_readonly = field.render_readonly()
            assert "<select" in pub_options, pub_options
            assert_equal(
                ('<option selected="selected" value="">(None)</option>' in pub_options),
                should_have_null_value,
                "%s %r" % (field, pub_options),
            )
            if should_have_null_value:
                # published_by field is blank anyway because no value set.
                assert_equal("<p></p>", pub_options_readonly, "%s %r" % (field, pub_options_readonly))

        indict = ckan.forms.get_package_dict(pkg, fs=fs)
        fs = get_fieldset().bind(pkg, data=indict)
        assert not fs.validate()
        assert len(fs.errors) == 1, fs.errors
        assert fs.errors.has_key(fs.published_by), fs.errors.keys()
    def setup_class(self):
        if not is_search_supported():
            raise SkipTest("Search not supported")

        indexer = TestSearchIndexer()
        model.Session.remove()
        CreateTestData.create_search_test_data()

        # now remove a tag so we can test search with deleted tags
        model.repo.new_revision()
        gils = model.Package.by_name(u'gils')
        # an existing tag used only by gils
        self.tagname = u'registry'
        # we aren't guaranteed it is last ...
        idx = [ t.name for t in gils.tags].index(self.tagname)
        del gils.tags[idx]
        model.repo.commit_and_remove()
        indexer.index()

        self.gils = model.Package.by_name(u'gils')
        self.war = model.Package.by_name(u'warandpeace')
        self.russian = model.Tag.by_name(u'russian')
        self.tolstoy = model.Tag.by_name(u'tolstoy')
        
        self.backend = get_backend(backend='sql')
Example #24
0
 def test_mapper_plugin_fired(self):
     with plugins.use_plugin('mapper_plugin') as mapper_plugin:
         CreateTestData.create_arbitrary([{'name':u'testpkg'}])
         # remove this data
         CreateTestData.delete()
         assert len(mapper_plugin.added) == 2 # resource group table added automatically
         assert mapper_plugin.added[0].name == 'testpkg'
Example #25
0
 def test_mapper_plugin_fired(self):
     config['ckan.plugins'] = 'mapper_plugin'
     plugins.load_all(config)
     CreateTestData.create_arbitrary([{'name':u'testpkg'}])
     mapper_plugin = PluginGlobals.env().plugin_registry['MapperPlugin'].__instance__
     assert len(mapper_plugin.added) == 2 # resource group table added automatically
     assert mapper_plugin.added[0].name == 'testpkg'
Example #26
0
 def setup_class(cls):
     MockPackageSearchPlugin().activate()
     MockPackageSearchPlugin().enable()
     setup_test_search_index()
     CreateTestData.create()
     MockPackageSearchPlugin().disable()
     cls.sysadmin_user = model.User.get('testsysadmin')
Example #27
0
    def _reset_data(self):
        model.Session.remove()
        model.repo.rebuild_db()
        CreateTestData.create()
        CreateTestData.create_arbitrary(
            {'name':self.editpkg_name,
             'url':u'editpkgurl.com',
             'tags':[u'mytesttag'],
             'resources':[{'url':u'url escape: & umlaut: \xfc quote: "',
                          'description':u'description escape: & umlaut: \xfc quote "',
                          }],
             'admins':[u'testadmin'],
             })

        self.editpkg = model.Package.by_name(self.editpkg_name)
        self.pkgid = self.editpkg.id
        self.offset = url_for(controller='package', action='edit', id=self.editpkg_name)

        self.editpkg = model.Package.by_name(self.editpkg_name)
        self.admin = model.User.by_name(u'testsysadmin')

        self.extra_environ_admin = {'REMOTE_USER': self.admin.name.encode('utf8')}
        self.extra_environ_russianfan = {'REMOTE_USER': '******'}
        self.res = None #get's refreshed by setup
        model.Session.remove()
    def setup_class(self):
        if not is_search_supported():
            raise SkipTest("Search not supported")

        self.ab = 'http://site.com/a/b.txt'
        self.cd = 'http://site.com/c/d.txt'
        self.ef = 'http://site.com/e/f.txt'
        self.pkgs = [
            {
                'name':
                'pkg1',
                'resources': [
                    {
                        'url': self.ab,
                        'description': 'This is site ab.',
                        'format': 'Excel spreadsheet',
                        'hash': 'abc-123',
                        'alt_url': 'alt1',
                        'extras': {
                            'size_extra': '100'
                        },
                    },
                    {
                        'url': self.cd,
                        'description': 'This is site cd.',
                        'format': 'Office spreadsheet',
                        'hash': 'qwe-456',
                        'alt_url': 'alt2',
                        'extras': {
                            'size_extra': '200'
                        },
                    },
                ]
            },
            {
                'name':
                'pkg2',
                'resources': [
                    {
                        'url': self.cd,
                        'alt_url': 'alt1',
                        'description': 'This is site cd.'
                    },
                    {
                        'url': self.ef,
                        'description': 'This is site ef.'
                    },
                    {
                        'url': self.ef,
                        'description': 'This is site gh.'
                    },
                    {
                        'url': self.ef,
                        'description': 'This is site ij.'
                    },
                ]
            },
        ]
        CreateTestData.create_arbitrary(self.pkgs)
 def setup_class(self):
     # create test data
     username = '******'
     self.pkgs = [
         {'name': "ons_pkg",
          "extras": {
              "import_source": "ONS-ons_data_7_days_to_2011-05-10",
              "notes": "<p>Designation: National Statistics\n</p>",
              "national_statistic": "yes",
              }
          },
         {'name': "ons_but_not_ns",
          "extras": {
              "import_source": "ONS-ons_data_7_days_to_2011-05-10",
              "notes": "<p>Designation: Excellent Statistics\n</p>",
              "national_statistic": "yes",
              }
          },
         {'name': "not_ns_or_ons",
          "extras": {
              "import_source": "ONS-ons_data_7_days_to_2011-05-10",
              "national_statistic": "no",
              }
          },
         {'name': "not_ns",
          "extras": {
              "import_source": "",
              "national_statistic": "no",
              }
          },
         {'name': "local-authority-spend-over-500-london-borough-of-hackney",
          "title": "Payments to suppliers with a value over \u00a3500 from London Borough of Hackney",
          "extras": {
              "temporal_coverage-to": "2011-06-30",
              "temporal_coverage-from": "2010-09-01",
              "temporal_granularity": "month",
              "date_released": "2010-09-14",
              "geographic_coverage": "000000: ",
              "taxonomy_url": "",
              "openness_score": "0",
              "external_reference": "",
              "date_updated": "2011-07-26",
              "published_via": "", "agency": "",
              "precision": "per cent to two decimal places",
              "geographic_granularity": "local authority",
              "department": "London Borough of Hackney",
              "published_by": "London Borough of Hackney [15165]",
              "national_statistic": "yes",
              "openness_score_last_checked": "2011-06-06T17:02:46.802271",
              "mandate": "", "date_update_future": "",
              "update_frequency": "monthly",
              "categories": "Government"}
          },            
         ]
     CreateTestData.create_arbitrary(self.pkgs,
                                     extra_user_names=[username])
     user = model.User.by_name(unicode(username))
     assert user
     self.testclient = WsgiCkanClient(self.app, api_key=user.apikey)
Example #30
0
    def setup_class(self):
        model.Session.remove()
        CreateTestData.create()

        self.packagename = u'testpkg'
        model.repo.new_revision()
        model.Session.add(model.Package(name=self.packagename))
        model.repo.commit_and_remove()