def test_adds_local_urls(self):
descriptor = {
'name': 'test',
'resources': [{
'name': 'first'
}, {
'name': 'second'
}]
}
with self.app.app_context():
db.drop_all()
db.create_all()
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client.get('/api/package/%s/%s'%\
(self.publisher, self.package))
catalog = Catalog(json.loads(response.data))
dataset = catalog.construct_dataset('http://example.com/')
self.assertEqual(dataset.\
get('resources')[0].get('localurl'),
'http://example.com/api/dataproxy/demo/demo-package/r/first.csv')
self.assertEqual(dataset.\
get('resources')[1].get('localurl'),
'http://example.com/api/dataproxy/demo/demo-package/r/second.csv')
def test_data_package_page_load_without_views(self):
descriptor = {"data": [], "resources": []}
with self.app.app_context():
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
rv = self.client.get('/{publisher}/{package}'.\
format(publisher=self.publisher,
package=self.package))
self.assertNotEqual(404, rv.status_code)
self.assertIn('Data Files', rv.data.decode("utf8"))
# cheks handsontable load
self.assertIn('handsontable', rv.data.decode("utf8"))
# cheks Vega graph load
self.assertIn('vega', rv.data.decode("utf8"))
rv = self.client.get('/non-existing/demo-package')
self.assertEqual(404, rv.status_code)
# cheks handsontable not loaded
self.assertNotIn('handsontable', rv.data)
# cheks graph not loaded
self.assertNotIn('vega', rv.data)
def setUp(self):
self.publisher_one = 'test_publisher1'
self.publisher_two = 'test_publisher2'
self.package_one = 'test_package1'
self.package_two = 'test_package2'
self.app = create_app()
self.app.app_context().push()
with self.app.test_request_context():
db.drop_all()
db.create_all()
user1 = User(name=self.publisher_one)
publisher1 = Publisher(name=self.publisher_one)
association1 = PublisherUser(role="OWNER")
association1.publisher = publisher1
user1.publishers.append(association1)
user2 = User(name=self.publisher_two)
publisher2 = Publisher(name=self.publisher_two)
association2 = PublisherUser(role="OWNER")
association2.publisher = publisher2
user2.publishers.append(association2)
metadata1 = MetaDataDB(name=self.package_one)
metadata1.descriptor = json.dumps(dict(name='test_one'))
publisher1.packages.append(metadata1)
metadata2 = MetaDataDB(name=self.package_two)
metadata2.descriptor = json.dumps(dict(name='test_two'))
publisher1.packages.append(metadata2)
metadata3 = MetaDataDB(name=self.package_one)
metadata3.descriptor = json.dumps(dict(name='test_three'))
publisher2.packages.append(metadata3)
metadata4 = MetaDataDB(name=self.package_two)
metadata4.descriptor = json.dumps(dict(name='test_four'))
publisher2.packages.append(metadata4)
db.session.add(user1)
db.session.add(user2)
db.session.commit()
def test_return_200_if_meta_data_found(self):
descriptor = {'name': 'test description'}
with self.app.app_context():
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client.\
get('/api/package/%s/%s' % (self.publisher, self.package))
data = json.loads(response.data)
self.assertEqual(response.status_code, 200)
def test_return_generic_error_if_descriptor_is_not_json(self):
descriptor = 'test description'
with self.app.app_context():
publisher = Publisher(name='pub')
metadata = MetaDataDB(name=self.package)
metadata.descriptor = descriptor
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client\
.get('/api/package/%s/%s' % ('pub', self.package))
data = json.loads(response.data)
self.assertEqual(response.status_code, 500)
self.assertEqual(data['error_code'], 'GENERIC_ERROR')
def test_return_empty_string_if_readme_not_there(self):
descriptor = {'name': 'test description'}
with self.app.app_context():
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client.get('/api/package/%s/%s'%\
(self.publisher, self.package))
data = json.loads(response.data)
self.assertEqual(response.status_code, 200)
self.assertEqual(data['readme'], '')
def test_adds_empty_readme_if_there_is_not(self):
descriptor = {'name': 'test', 'resources': []}
with self.app.app_context():
db.drop_all()
db.create_all()
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client.get('/api/package/%s/%s'%\
(self.publisher, self.package))
catalog = Catalog(json.loads(response.data))
dataset = catalog.construct_dataset()
self.assertEqual(dataset.get('readme'), '')
def test_get_views_if_views_dont_exist(self):
descriptor = {'name': 'test', 'resources': []}
with self.app.app_context():
db.drop_all()
db.create_all()
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client.get('/api/package/%s/%s'%\
(self.publisher, self.package))
catalog = Catalog(json.loads(response.data))
views = catalog.get_views()
self.assertEqual(views, [])
def populate_data(publisher_name):
data = json.loads(open('fixtures/datapackage.json').read())
data_csv = open('fixtures//data/demo-resource.csv').read()
readme = open('fixtures/README.md').read()
publisher = Publisher.query.filter_by(name=publisher_name).one()
metadata = MetaDataDB(name="demo-package")
metadata.descriptor, metadata.status, metadata.private, metadata.readme \
= json.dumps(data), 'active', False, readme
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
bitstore = BitStore(publisher_name, package='demo-package')
key = bitstore.build_s3_key('demo-resource.csv')
bucket_name = app.config['S3_BUCKET_NAME']
s3_client = app.config['S3']
s3_client.put_object(Bucket=bucket_name, Key=key, Body=data_csv)
def test_construct_dataset(self):
descriptor = json.loads(open('fixtures/datapackage.json').read())
with self.app.app_context():
db.drop_all()
db.create_all()
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client.get('/api/package/%s/%s'%\
(self.publisher, self.package))
catalog = Catalog(json.loads(response.data))
dataset = catalog.construct_dataset()
self.assertEqual(dataset.get('name'), descriptor.get('name'))
self.assertIn('localurl', dataset.get('resources')[0])
self.assertNotEqual(len(dataset.get('views')), 0)
def test_return_all_metadata_is_there(self):
descriptor = {'name': 'test description'}
readme = 'README'
with self.app.app_context():
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
metadata.readme = readme
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client.get('/api/package/%s/%s'%\
(self.publisher, self.package))
data = json.loads(response.data)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(data), 5)
self.assertEqual(data['descriptor']['name'], 'test description')
self.assertEqual(data['readme'], 'README')
self.assertEqual(data['id'], 1)
self.assertEqual(data['name'], self.package)
self.assertEqual(data['publisher'], self.publisher)
def test_get_views(self):
descriptor = {
'name': 'test',
'resources': [],
'views': [{"type": "graph"}]
}
with self.app.app_context():
db.drop_all()
db.create_all()
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
metadata.descriptor = json.dumps(descriptor)
publisher.packages.append(metadata)
db.session.add(publisher)
db.session.commit()
response = self.client.get('/api/package/%s/%s'%\
(self.publisher, self.package))
catalog = Catalog(json.loads(response.data))
views = catalog.get_views()
self.assertNotEqual(len(views), 0)
self.assertEqual(views[0].get('type'), 'graph')
def test_publish_end_to_end(self, save, signed_url, get_s3_object,
get_metadata_body, create_or_update,
get_readme_object_key):
# Sending Username & Secret key
rv = self.client.post(self.auth_token_url,
data=json.dumps({
'username': '******',
'email': None,
'secret': 'super_secret'
}),
content_type='application/json')
# Testing Token received
self.assertIn('token', rv.data)
self.assertEqual(200, rv.status_code)
# Sending recived token to server with Authentication Header
token = json.loads(rv.data)['token']
self.auth = "bearer %s" % token # Saving token for future use
save.return_value = None
rv = self.client.put(self.meta_data_url,
headers=dict(Authorization=self.auth),
data=json.dumps(self.test_data_package))
# Testing Authentication status
self.assertEqual({'status': 'OK'}, json.loads(rv.data))
self.assertEqual(200, rv.status_code)
# Adding to Meta Data
descriptor = {'name': 'test description'}
with self.app.app_context():
publisher = Publisher(name=self.publisher)
metadata = MetaDataDB(name=self.package)
publisher.packages.append(metadata)
metadata.descriptor = json.dumps(descriptor)
db.session.add(publisher)
db.session.commit()
rv = self.client.get('/api/package/%s' % (self.publisher, ))
data = json.loads(rv.data)
# Testing Meta Data
self.assertEqual(len(data['data']), 1)
self.assertEqual(rv.status_code, 200)
# Get S3 link for uploading Data file
signed_url.return_value = 'https://trial_url'
rv = self.client.post(self.bitstore_url,
data=json.dumps({
'publisher': self.publisher,
'package': self.package,
'md5': ''
}),
content_type='application/json')
# Testing S3 link
self.assertEqual({'key': 'https://trial_url'}, json.loads(rv.data))
self.assertEqual(200, rv.status_code)
# Finalize
get_metadata_body.return_value = json.dumps(dict(name='package'))
create_or_update.return_value = None
get_readme_object_key.return_value = ''
get_s3_object.return_value = ''
rv = self.client.post(self.finalize_url,
data=json.dumps(dict()),
headers=dict(Authorization=self.auth))
# Test Data
self.assertEqual(200, rv.status_code)
