def initial_data(self, clean_db):
ctd.CreateTestData.create()
self.sysadmin_user = factories.Sysadmin()
self.sysadmin_token = factories.APIToken(
user=self.sysadmin_user["id"])["token"]
self.normal_user = factories.User()
self.normal_user_token = factories.APIToken(
user=self.normal_user["id"])["token"]
set_url_type(
model.Package.get("annakarenina").resources, self.sysadmin_user)
def create_test_data(self, clean_datastore, test_request_context):
ctd.CreateTestData.create()
self.sysadmin_user = factories.Sysadmin()
self.sysadmin_token = factories.APIToken(user=self.sysadmin_user)
self.normal_user = factories.User()
self.normal_user_token = factories.APIToken(user=self.normal_user)
engine = db.get_write_engine()
self.Session = orm.scoped_session(orm.sessionmaker(bind=engine))
with test_request_context():
set_url_type(
model.Package.get("annakarenina").resources, self.sysadmin_user
)
def initial_data(self, clean_datastore, app, test_request_context):
self.app = app
ctd.CreateTestData.create()
self.sysadmin_user = factories.Sysadmin()
self.sysadmin_token = factories.APIToken(user=self.sysadmin_user["id"])
self.sysadmin_token = self.sysadmin_token["token"]
self.normal_user = factories.User()
self.normal_user_token = factories.APIToken(
user=self.normal_user["id"])
self.normal_user_token = self.normal_user_token["token"]
resource = model.Package.get("annakarenina").resources[0]
self.data = {
"resource_id":
resource.id,
"aliases":
u"b\xfck2",
"fields": [
{
"id": "book",
"type": "text"
},
{
"id": "author",
"type": "text"
},
{
"id": "rating with %",
"type": "text"
},
],
"records": [
{
"book": "annakarenina",
"author": "tolstoy",
"rating with %": "90%",
},
{
"book": "warandpeace",
"author": "tolstoy",
"rating with %": "42%",
},
],
}
engine = db.get_write_engine()
self.Session = orm.scoped_session(orm.sessionmaker(bind=engine))
with test_request_context():
set_url_type(
model.Package.get("annakarenina").resources,
self.sysadmin_user)
def test_read(app):
user = factories.User()
user_token = factories.APIToken(user=user["id"])
dataset = factories.Dataset(creator_user_id=user["id"])
resource = factories.Resource(package_id=dataset["id"],
creator_user_id=user["id"])
data = {
u"resource_id":
resource["id"],
u"force":
True,
u"records": [
{
u"from": u"Brazil",
u"to": u"Brazil",
u"num": 2
},
{
u"from": u"Brazil",
u"to": u"Italy",
u"num": 22
},
],
}
helpers.call_action(u"datastore_create", **data)
auth = {u"Authorization": user_token["token"]}
app.get(
url=u"/dataset/{id}/dictionary/{resource_id}".format(
id=str(dataset["name"]), resource_id=str(resource["id"])),
extra_environ=auth,
)
def test_membership_list(self, app):
"""List group admins and members"""
user_one = factories.User(fullname="User One")
user_two = factories.User(fullname="User Two")
user_one_token = factories.APIToken(user=user_one["name"])
env = {"Authorization": user_one_token["token"]}
other_users = [{"name": user_two["id"], "capacity": "member"}]
group = self._create_group(user_one["name"], other_users)
member_list_url = url_for("group.members", id=group["id"])
member_list_response = app.get(member_list_url, extra_environ=env)
assert "2 members" in member_list_response
member_response_html = BeautifulSoup(member_list_response.body)
user_names = [
u.string
for u in member_response_html.select("#member-table td.media a")
]
roles = [
r.next_sibling.next_sibling.string
for r in member_response_html.select("#member-table td.media")
]
user_roles = dict(zip(user_names, roles))
assert user_roles["User One"] == "Admin"
assert user_roles["User Two"] == "Member"
def test_apitoken_in_x_ckan_header(app):
user = factories.Sysadmin()
user_token = factories.APIToken(user=user["id"], context={})
# non-standard header name is defined in test-core.ini
request_headers = {"X-Non-Standard-CKAN-API-Key": user_token}
app.get("/dataset/new", headers=request_headers)
def test_user_last_active(self, app):
import datetime
from ckan.lib.helpers import url_for
from freezegun import freeze_time
frozen_time = datetime.datetime.utcnow()
data = factories.User()
dataset = factories.Dataset()
user_token = factories.APIToken(user=data["name"])
env = {"Authorization": user_token["token"]}
with freeze_time(frozen_time):
user = model.User.get(data["id"])
assert user.last_active is None
app.get(url_for("dataset.search"), extra_environ=env)
assert isinstance(user.last_active, datetime.datetime)
assert user.last_active == datetime.datetime.utcnow()
with freeze_time(frozen_time + datetime.timedelta(seconds=540)):
user = model.User.get(data["id"])
app.get(url_for("user.read", id=user.id), extra_environ=env)
assert user.last_active != datetime.datetime.utcnow()
with freeze_time(frozen_time + datetime.timedelta(seconds=660)):
user = model.User.get(data["id"])
app.get(url_for("dataset.read", id=dataset["id"]),
extra_environ=env)
assert user.last_active == datetime.datetime.utcnow()
def test_resource_create_upload_file(self, app, monkeypatch, tmpdir,
ckan_config):
monkeypatch.setitem(ckan_config, u"ckan.storage_path", str(tmpdir))
user = factories.User()
user_token = factories.APIToken(user=user["name"])
pkg = factories.Dataset(creator_user_id=user["id"])
url = url_for(
"api.action",
logic_function="resource_create",
ver=3,
)
env = {"Authorization": user_token["token"]}
content = six.ensure_binary('upload-content')
upload_content = BytesIO(content)
postparams = {
"name": "test-flask-upload",
"package_id": pkg["id"],
"upload": (upload_content, "test-upload.txt"),
}
resp = app.post(
url,
extra_environ=env,
data=postparams,
content_type="multipart/form-data",
)
result = resp.json["result"]
assert "upload" == result["url_type"]
assert len(content) == result["size"]
def test_original_translations(self, app, url, breadcrumb, button):
user = factories.User(password="******")
user_token = factories.APIToken(user=user["name"])
env = {"Authorization": user_token["token"]}
res = app.get(url, environ_overrides=env)
page = bs4.BeautifulSoup(res.body)
assert page.select_one(u'.toolbar .active').text == breadcrumb
page.select_one(u'.page_primary_action').text.strip() == button
def test_email_address_no_nag(self, app):
user = factories.User(email="*****@*****.**")
user_token = factories.APIToken(user=user["name"])
env = {"Authorization": user_token["token"]}
response = app.get(url=url_for("home.index"), extra_environ=env)
assert "add your email address" not in response
def test_resource_download_iuploader_called(send_file, app, monkeypatch,
tmpdir, ckan_config):
monkeypatch.setitem(ckan_config, u'ckan.storage_path', str(tmpdir))
user = factories.User()
user_token = factories.APIToken(user=user["name"])
env = {"Authorization": user_token["token"]}
url = url_for("dataset.new")
dataset_name = u"package_with_resource"
form = {"name": dataset_name, "save": "", "_ckan_phase": 1}
response = app.post(url,
data=form,
extra_environ=env,
follow_redirects=False)
location = response.headers['location']
location = urlparse(location)._replace(scheme='', netloc='').geturl()
# Mock the plugin's ResourceUploader, returning the same value, but
# tracking it's calls to make sure IUpload is being called.
with patch.object(
plugin.ResourceUpload,
"get_path",
side_effect=plugin.ResourceUpload.get_path,
autospec=True,
) as mock_get_path:
response = app.post(location,
extra_environ=env,
data={
"id": "",
"url": "http://example.com/resource",
"save": "go-metadata",
"upload": ("README.rst", CONTENT)
})
assert mock_get_path.call_count == 3
assert isinstance(mock_get_path.call_args[0][0], plugin.ResourceUpload)
pkg = model.Package.by_name(dataset_name)
assert mock_get_path.call_args[0][1] == pkg.resources[0].id
assert pkg.resources[0].url_type == u"upload"
assert pkg.state == "active"
url = url_for("resource.download",
id=pkg.id,
resource_id=pkg.resources[0].id)
# Mock the plugin's ResourceUploader again
with patch.object(
plugin.ResourceUpload,
"get_path",
side_effect=plugin.ResourceUpload.get_path,
autospec=True,
) as mock_get_path:
response = app.get(url)
assert mock_get_path.call_count == 1
assert isinstance(mock_get_path.call_args[0][0], plugin.ResourceUpload)
assert mock_get_path.call_args[0][1] == pkg.resources[0].id
assert CONTENT == response.body
def test_config_option_list_access_sysadmin(self, app):
user = factories.Sysadmin()
user_token = factories.APIToken(user=user["name"])
url = url_for(
"api.action",
logic_function="config_option_list",
ver=3,
)
env = {"Authorization": user_token["token"]}
app.get(url=url, extra_environ=env, query_string={}, status=200)
def test_fallback_to_placeholder_if_gravatar_disabled(self, app):
user = factories.User(image_url=None, password="******")
url = url_for("user.read", id=user["name"])
user_token = factories.APIToken(user=user["name"])
env = {"Authorization": user_token["token"]}
res = app.get(url, environ_overrides=env)
res_html = BeautifulSoup(res.data)
user_images = res_html.select("img.user-image")
assert len(user_images) == 2 # Logged in header + profile pic
for img in user_images:
assert img.attrs["src"] == "/base/images/placeholder-user.png"
def test_email_address_nag(self, app):
# before CKAN 1.6, users were allowed to have no email addresses
# can't use factory to create user as without email it fails validation
from ckan import model
user = model.User(name="has-no-email", password="******")
model.Session.add(user)
model.Session.commit()
user_token = factories.APIToken(user=user.id)
env = {"Authorization": user_token["token"]}
response = app.get(url=url_for("home.index"), extra_environ=env)
assert "update your profile" in response.body
assert str(url_for("user.edit")) in response.body
assert " and add your email address." in response.body
def test_image_url_is_shown(self, app):
user = factories.User(
image_url="https://example.com/mypic.png", password="******")
url = url_for("user.read", id=user["name"])
user_token = factories.APIToken(user=user["name"])
env = {"Authorization": user_token["token"]}
res = app.get(url, environ_overrides=env)
res_html = BeautifulSoup(res.data)
user_images = res_html.select("img.user-image")
assert len(user_images) == 2 # Logged in header + profile pic
for img in user_images:
assert img.attrs["src"] == "https://example.com/mypic.png"
def test_create_user_as_sysadmin(self, app):
admin_pass = "******"
sysadmin = factories.Sysadmin(password=admin_pass)
sysadmin_token = factories.APIToken(user=sysadmin["name"])
env = {"Authorization": sysadmin_token["token"]}
stub = factories.User.stub()
app.post(
url_for("user.register"),
data={
"name": stub.name,
"fullname": "Newest User",
"email": stub.email,
"password1": "NewPassword1",
"password2": "NewPassword1",
"save": "",
},
extra_environ=env,
follow_redirects=False,
)
def test_apitoken_in_authorization_header(app):
user = factories.Sysadmin()
user_token = factories.APIToken(user=user["id"], context={})
request_headers = {"Authorization": user_token}
app.get("/dataset/new", headers=request_headers)
def test_import_v2_style_register_i18n(app):
sysadmin = factories.Sysadmin(password="******")
sysadmin_token = factories.APIToken(user=sysadmin["name"])
env = {"Authorization": sysadmin_token["token"]}
resp = app.get("/dataset/new", environ_overrides=env)
assert "Altres (Oberta)" in resp.body
