def _create_form(app_id, xmlns, with_attachment):
xml = FORM_XML.format(doc_id=random_hex(), xmlns=xmlns)
attachments = {}
if with_attachment:
attachment = open(
'./corehq/ex-submodules/casexml/apps/case/tests/data/attachments/fruity.jpg',
'rb')
attachments = {'pic.jpg': UploadedFile(attachment, 'pic.jpg')}
submit_form_locally(xml,
domain=DOMAIN,
app_id=app_id,
attachments=attachments)
def test_uploaded_logo(self):
logo_src = os.path.join(askbot.get_install_directory(), 'tests',
'images', 'logo.gif')
logo_file = open(logo_src, 'r')
new_logo = UploadedFile(file=logo_file)
askbot_settings.update('SITE_LOGO_URL', new_logo)
logo_url = askbot_settings.SITE_LOGO_URL
self.assertTrue(
logo_url.startswith('/' +
django_settings.ASKBOT_UPLOADED_FILES_URL))
response = self.client.get(logo_url)
self.assertTrue(response.status_code == 200)
def attach_images_to_case(case_id, files):
"""
Handle case submission for the vscan endpoint
"""
xform = render_vscan_xform(case_id, files)
file_dict = {}
for f in files:
identifier = os.path.split(f)[-1]
file_dict[identifier] = UploadedFile(files[f], identifier)
submit_form_locally(xform, attachments=file_dict, domain=UTH_DOMAIN)
def download_incoming_media(self, media_url):
file_id = media_url.rsplit('/', 1)[-1]
headers = {
'Authorization': f'App {self.config.auth_token}',
'Accept': 'application/json'
}
response = requests.get(media_url, headers=headers)
uploaded_file = UploadedFile(
BytesIO(response.content),
file_id,
content_type=response.headers.get('content-type'))
return file_id, uploaded_file
def test_storage_content_type_long_name(storage):
data = b"some initial byte data"
test_file = io.BytesIO(data)
file_name = 't' * (settings.MINIO_STORAGE_MAX_FILE_NAME_LEN + 100) + '.jpg'
upload_file = UploadedFile(file=test_file, name=file_name, size=len(data))
file_i = file_info(upload_file)
storage.file_put(file_i)
file_resp = storage.file_get(file_i.path)
assert file_resp.headers.get('Content-Type') == 'image/jpeg'
def test_file_is_not_a_zip(self):
"""
Test that the uploaded file has the .zip extension.
"""
upload = {
"workspace": self.workspace,
"local": UploadedFile(name="SWAT_Model.tar.gz"),
"aws": {}
}
with self.assertRaises(NotAZipError):
SWATModelZip(upload)
def test_metadata_on_content_file_delete(self):
# test that some of the metadata is not deleted on content file deletion
# adding a valid netcdf file should generate some core metadata and all extended metadata
files = [
UploadedFile(file=self.netcdf_file_obj, name=self.netcdf_file_name)
]
utils.resource_file_add_pre_process(resource=self.resNetcdf,
files=files,
user=self.user,
extract_metadata=False)
utils.resource_file_add_process(resource=self.resNetcdf,
files=files,
user=self.user,
extract_metadata=True)
# there should be 1 content files
self.assertEqual(self.resNetcdf.files.all().count(), 2)
# there should be 1 format elements
self.assertEqual(self.resNetcdf.metadata.formats.all().count(), 2)
# delete content file that we added above
hydroshare.delete_resource_file(self.resNetcdf.short_id,
self.netcdf_file_name, self.user)
# there should no content file
self.assertEqual(self.resNetcdf.files.all().count(), 0)
# there should be a title element
self.assertNotEquals(self.resNetcdf.metadata.title, None)
# there should be abstract element
self.assertNotEquals(self.resNetcdf.metadata.description, None)
# there should be 2 creator element
self.assertEqual(self.resNetcdf.metadata.creators.all().count(), 2)
# there should be 1 contributor element
self.assertEqual(self.resNetcdf.metadata.contributors.all().count(), 1)
# there should be no coverage element
self.assertEqual(self.resNetcdf.metadata.coverages.all().count(), 0)
# there should be no format element
self.assertEqual(self.resNetcdf.metadata.formats.all().count(), 0)
# there should be subject element
self.assertNotEquals(self.resNetcdf.metadata.subjects.all().count(), 0)
# testing extended metadata elements
self.assertEqual(self.resNetcdf.metadata.ori_coverage.all().count(), 0)
self.assertEqual(self.resNetcdf.metadata.variables.all().count(), 0)
def setUpTestData(cls):
star_wars = m.Account.objects.create(name="Star Wars")
sw_source = m.DataSource.objects.create(name="Evil Empire")
cls.sw_source = sw_source
sw_version = m.SourceVersion.objects.create(data_source=sw_source,
number=1)
star_wars.default_version = sw_version
star_wars.save()
cls.yoda = cls.create_user_with_profile(username="******",
account=star_wars,
permissions=["iaso_forms"])
cls.jedi_council = m.OrgUnitType.objects.create(name="Jedi Council",
short_name="Cnc")
cls.jedi_council_corruscant = m.OrgUnit.objects.create(
name="Corruscant Jedi Council")
cls.project = m.Project.objects.create(
name="Hydroponic gardens",
app_id="stars.empire.agriculture.hydroponics",
account=star_wars)
cls.form_1 = m.Form.objects.create(name="Hydroponics study",
form_id="hydro_1",
period_type=m.MONTH,
single_per_period=True)
cls.form_version_1 = m.FormVersion.objects.create(
form=cls.form_1,
version_id="1",
file=UploadedFile(
open("iaso/tests/fixtures/hydroponics_test_upload.xml")))
cls.create_form_instance(form=cls.form_1,
period="202001",
org_unit=cls.jedi_council_corruscant,
project=cls.project,
uuid="uuid-1")
cls.project.unit_types.add(cls.jedi_council)
cls.project.forms.add(cls.form_1)
cls.project.save()
cls.maxDiff = None
with open("iaso/tests/fixtures/hydroponics_test_upload.xml"
) as modified_xml:
instance = cls.form_1.instances.first()
instance.file = SimpleUploadedFile("file.txt",
modified_xml.read().encode())
instance.get_and_save_json_of_xml()
def test_currupt_image_file(self):
"""
Test that when corrupt file is provided to validate_video_image, it gives proper error message.
"""
with open(settings.MEDIA_ROOT + '/test-corrupt-image.png', 'w+') as file:
image_file = UploadedFile(
file,
content_type='image/png',
size=settings.VIDEO_IMAGE_SETTINGS['VIDEO_IMAGE_MIN_BYTES']
)
error = validate_video_image(image_file)
self.assertEquals(error, 'There is a problem with this image file. Try to upload a different file.')
def setUpClass(cls):
super().setUpClass()
cls.catalog = Catalog.objects.create(name="Catalogue de vêtements", )
cls.image = UploadedFile()
cls.product = Product.objects.create(
name="Débardeur homme",
image=cls.image,
is_available=True,
is_free=False,
price=25,
catalog=cls.catalog,
)
def test_schema_after_version_change(client):
data = SuppliedData.objects.create()
with open(
os.path.join(
"tests",
"fixtures",
"tenders_releases_1_release_with_invalid_extensions.json",
)) as fp:
data.original_file.save("test.json", UploadedFile(fp))
resp = client.post(data.get_absolute_url(), {"version": "1.1"})
assert resp.status_code == 200
with open(os.path.join(data.upload_dir(),
"extended_schema.json")) as extended_release_fp:
assert ("mainProcurementCategory" in json.load(extended_release_fp)
["definitions"]["Tender"]["properties"])
with open(
os.path.join(data.upload_dir(),
"validation_errors-3.json")) as validation_errors_fp:
assert "'version' is missing but required" in validation_errors_fp.read(
)
# test link is still there.
resp = client.get(data.get_absolute_url())
assert resp.status_code == 200
assert "extended_schema.json" in resp.content.decode()
with open(os.path.join(data.upload_dir(),
"extended_schema.json")) as extended_release_fp:
assert ("mainProcurementCategory" in json.load(extended_release_fp)
["definitions"]["Tender"]["properties"])
with open(
os.path.join(data.upload_dir(),
"validation_errors-3.json")) as validation_errors_fp:
assert "'version' is missing but required" in validation_errors_fp.read(
)
resp = client.post(data.get_absolute_url(), {"version": "1.0"})
assert resp.status_code == 200
with open(os.path.join(data.upload_dir(),
"extended_schema.json")) as extended_release_fp:
assert ("mainProcurementCategory" not in json.load(extended_release_fp)
["definitions"]["Tender"]["properties"])
with open(
os.path.join(data.upload_dir(),
"validation_errors-3.json")) as validation_errors_fp:
assert "'version' is missing but required" not in validation_errors_fp.read(
)
def multiuploader(request):
if request.method == 'POST':
log.info('received POST to main multiuploader view')
if request.FILES == None:
return HttpResponseBadRequest('Must have files attached!')
#getting file data for farther manipulations
file = request.FILES[u'files[]']
wrapped_file = UploadedFile(file)
filename = wrapped_file.name
file_size = wrapped_file.file.size
log.info('Got file: "' + str(filename) + '"')
#writing file manually into model
#because we don't need form of any type.
image = Image()
image.title = str(filename)
image.image = file
image.save()
log.info('File saving done')
#getting url for photo deletion
file_delete_url = '/delete/'
#getting file url here
file_url = '/'
#getting thumbnail url using sorl-thumbnail
im = get_thumbnail(image, "80x80", quality=50)
thumb_url = im.url
#generating json response array
result = []
result.append({
"name": filename,
"size": file_size,
"url": file_url,
"thumbnail_url": thumb_url,
"delete_url": file_delete_url + str(image.pk) + '/',
"delete_type": "POST",
})
response_data = simplejson.dumps(result)
return HttpResponse(response_data, content_type='application/json')
else: #GET
return render_to_response(
'multiuploader_main.html',
{
'static_url': settings.MEDIA_URL,
'open_tv': u'{{',
'close_tv': u'}}'
},
)
def test_metadata_extraction_on_content_file_add(self):
# test the core metadata at this point
self.assertEqual(
self.resNetcdf.metadata.title.value,
'Snow water equivalent estimation at TWDEF site from Oct 2009 to June 2010'
)
# there shouldn't any abstract element
self.assertEqual(self.resNetcdf.metadata.description, None)
# there shouldn't any coverage element
self.assertEqual(self.resNetcdf.metadata.coverages.all().count(), 0)
# there shouldn't any format element
self.assertEqual(self.resNetcdf.metadata.formats.all().count(), 0)
# there shouldn't any subject element
self.assertEqual(self.resNetcdf.metadata.subjects.all().count(), 0)
# there shouldn't any contributor element
self.assertEqual(self.resNetcdf.metadata.contributors.all().count(), 0)
# there shouldn't any source element
self.assertEqual(self.resNetcdf.metadata.sources.all().count(), 0)
# there shouldn't any relation element
self.assertEqual(
self.resNetcdf.metadata.relations.all().filter(
type='cites').count(), 0)
# there should be 1 creator
self.assertEqual(self.resNetcdf.metadata.creators.all().count(), 1)
# there shouldn't any extended metadata
self.assertEqual(self.resNetcdf.metadata.ori_coverage.all().count(), 0)
self.assertEqual(self.resNetcdf.metadata.variables.all().count(), 0)
# adding a valid netcdf file should generate some core metadata and all extended metadata
files = [
UploadedFile(file=self.netcdf_file_obj, name=self.netcdf_file_name)
]
utils.resource_file_add_pre_process(resource=self.resNetcdf,
files=files,
user=self.user,
extract_metadata=False)
utils.resource_file_add_process(resource=self.resNetcdf,
files=files,
user=self.user,
extract_metadata=False)
super(TestNetcdfMetaData,
self).netcdf_metadata_extraction(expected_creators_count=2)
def save_attachments(post, path, filename):
"""Create zip file of all attachments of post."""
if not os.path.exists(path):
os.makedirs(path)
my_file = SimpleUploadedFile(path / filename, '')
uploaded = UploadedFile(file=my_file)
with ZipFile(uploaded.file, 'w') as z:
for file in post.attachments.all():
filename = pathlib.PurePosixPath(file.file.path).name
z.write(file.file.path, filename)
return uploaded
def test_max_upload_size_fail(self):
document = base.create_document()
file_field = self.FileField(document.file.field)
file_size = file_field.get_max_upload_size()-1
document.file.file = \
UploadedFile(file=document.file.file, name=document.title, content_type='txt', size=file_size)
# fudge the max_upload_size to fall below file size.
file_field.set_max_upload_size(document.file.size - 1)
with self.assertRaises(forms.ValidationError):
file_field.field.clean(value=document.file, model_instance=document)
# Cleanup
file_field.restore_max_upload_size()
os.remove(document.file.path)
def new_file(self,
field_name,
file_name,
content_type,
content_length,
charset=None):
self.md5 = hashlib.md5()
self.data = ''
self.file = UploadedFile(name=file_name,
content_type=content_type,
charset=charset)
self.file.size = 0
self.file.hashmap = []
def get_step_files(self, step):
wizard_files = self.data[self.step_files_key].get(step, {})
if wizard_files and not self.file_storage:
raise NoFileStorageConfigured
files = {}
for field, field_dict in six.iteritems(wizard_files):
field_dict = field_dict.copy()
tmp_name = field_dict.pop('tmp_name')
files[field] = UploadedFile(file=self.file_storage.open(tmp_name),
**field_dict)
return files or None
def test_file_does_not_exist(self):
"""
Test that the uploaded file exists.
"""
# "workspace" key points to file that does not exist
upload = {
"workspace": os.path.join(self.workspace),
"local": UploadedFile(name="SWAT_Model_Does_Not_Exist.zip"),
"aws": {}
}
with self.assertRaises(FileNotFoundError):
SWATModelZip(upload)
def _create_composite_resource(self, file_obj):
uploaded_file = UploadedFile(file=file_obj,
name=os.path.basename(file_obj.name))
self.composite_resource = hydroshare.create_resource(
resource_type='CompositeResource',
owner=self.user,
title='Test Raster File Type Metadata',
files=(uploaded_file,)
)
# set the generic logical file type
resource_post_create_actions(resource=self.composite_resource, user=self.user,
metadata=self.composite_resource.metadata)
def create_css_from_manifest(tmp_dir, theme, manifest):
for item in manifest:
if "url" in item:
theme.css.create(**item, order=theme.css.count())
else:
with open(item["path"], "rb") as fp:
file_obj = UploadedFile(
fp,
name=item["name"],
content_type="text/css",
size=os.path.getsize(item["path"]),
)
create_css(theme, file_obj)
def handle(self, *args, **options):
all_products = Product.objects.all()
for product in all_products:
if product.image:
image = UploadedFile(product.image.file,
product.image.file.name)
product.cloudinary_image = image
product.save()
print(f"Product image for {product.name} migrated")
else:
print(f"No Product image for {product.name} to migrate")
def test_pd_compare(self):
df = []
for fn in self.files:
with open(fn,'rb') as fh:
fu = UploadedFile(fh)
fm = FileModel(imported_file=fu)
df.append(pd_read(fm.imported_file))
res_a = pd_compare(df[0], df[0])
self.assertEquals(res_a, 'ok')
res_b = pd_compare(df[0], df[1])
self.assertEquals(res_b, expected_diff)
def new_file(self,
field_name,
file_name,
content_type,
content_length,
charset=None):
self.checksum_compute = NoChecksum() if not UPDATE_MD5 else Checksum()
self.data = ''
self.file = UploadedFile(name=file_name,
content_type=content_type,
charset=charset)
self.file.size = 0
self.file.hashmap = []
def test_thumbnail(self):
file_name = 'test_image.jpg'
with open(os.path.join(os.path.dirname(__file__), file_name),
'rb') as f:
test_image = UploadedFile(File(f), content_type='image/jpeg')
category = Category.objects.create(name='Test Category',
slug='test-category',
thumbnail=test_image)
self.assertEqual(category.pk, 1)
self.assertEqual(category.thumbnail_width, 640)
self.assertEqual(category.thumbnail_height, 480)
def test_post_second_step_local_invalid(self):
with open('./texts/test_input/test_upload.txt', 'rb') as file:
uf = UploadedFile(file=file, name='namestring')
valid_data = {
'1-uri': 'uristring',
'0-method': 'local',
'text_wizard-current_step': 4
}
response = self.client.post(add_path, valid_data)
observed_error = response.context['form']._errors
expected_error = {}
self.assertEqual(expected_error, observed_error)
def _create_composite_resource(self, title='Test Ref Time Series File Type Metadata'):
uploaded_file = UploadedFile(file=self.refts_file_obj,
name=os.path.basename(self.refts_file_obj.name))
self.composite_resource = hydroshare.create_resource(
resource_type='CompositeResource',
owner=self.user,
title=title,
files=(uploaded_file,)
)
# set the generic logical file as part of resource post create signal
resource_post_create_actions(resource=self.composite_resource, user=self.user,
metadata=self.composite_resource.metadata)
def test_metadata_file_hash(self):
self._publish_transportation_form()
src = os.path.join(self.this_directory, "fixtures", "transportation",
"screenshot.png")
uf = UploadedFile(file=open(src), content_type='image/png')
count = MetaData.objects.count()
MetaData.media_upload(self.xform, uf)
# assert successful insert of new metadata record
self.assertEqual(MetaData.objects.count(), count + 1)
md = MetaData.objects.get(xform=self.xform,
data_value='screenshot.png')
# assert checksum string has been generated, hash length > 1
self.assertTrue(len(md.hash) > 16)
def test_add_xml_file_one(self):
# test that if a .xml file gets added then the resource abstract and keywords get
# updated. Abstract gets updated only if the there is no abstract already
# this zip file has only the required 3 files (.shp, .shx and .dbf)
files = []
target = 'hs_geographic_feature_resource/tests/states_required_files.zip'
files.append(UploadedFile(file=open(target, 'r'), name='states_required_files.zip'))
self.resGeoFeature = hydroshare.create_resource(
resource_type='GeographicFeatureResource',
owner=self.user,
title='Test Geographic Feature (shapefiles)',
keywords=['kw1', 'kw2'],
files=files
)
# uploaded file validation and metadata extraction happens in post resource
# creation handler
hydroshare.utils.resource_post_create_actions(resource=self.resGeoFeature, user=self.user,
metadata=[])
# check that the resource has 3 files
self.assertEqual(self.resGeoFeature.files.count(), 3)
# there should not be any abstract
self.assertEqual(self.resGeoFeature.metadata.description, None)
# there should be 2 keywords
self.assertEqual(self.resGeoFeature.metadata.subjects.count(), 2)
# now add the .shp.xml file
files = []
target = 'hs_geographic_feature_resource/tests/states.shp.xml'
files.append(UploadedFile(file=open(target, 'r'),
name='states.shp.xml'))
hydroshare.utils.resource_file_add_process(self.resGeoFeature, files, self.user)
# check that the resource has 4 files
self.assertEqual(self.resGeoFeature.files.count(), 4)
# there should be abstract now (abstract came from the xml file)
self.assertNotEqual(self.resGeoFeature.metadata.description, None)
# there should be 4 (2 keywords came from the xml file) keywords
self.assertEqual(self.resGeoFeature.metadata.subjects.count(), 4)
self.resGeoFeature.delete()
def setUp(self):
super().setUp()
# create a dummy image file in memory for upload
image_file = BytesIO()
image = Image.new('RGBA', size=(50, 50), color=(256, 0, 0))
image.save(image_file, 'png')
image_file.seek(0)
self.profile.image = UploadedFile(image_file, "filename.png",
"image/png",
len(image_file.getvalue()))
self.profile.save(update_image=True)
def _process_uploaded_file(resource, validate_files_dict):
log = logging.getLogger()
res_file = resource.files.all().first()
if res_file:
# get the file from irods to temp dir
temp_file = utils.get_file_from_irods(res_file)
# validate the file
error_info, files_to_add_to_resource = raster.raster_file_validation(
raster_file=temp_file)
if not error_info:
log.info("Geo raster file validation successful.")
# extract metadata
temp_dir = os.path.dirname(temp_file)
temp_vrt_file_path = [
os.path.join(temp_dir, f) for f in os.listdir(temp_dir)
if '.vrt' == os.path.splitext(f)[1]
].pop()
metadata = raster.extract_metadata(temp_vrt_file_path)
# delete the original resource file
file_name = delete_resource_file_only(resource, res_file)
delete_format_metadata_after_delete_file(resource, file_name)
# add all extracted files (tif and vrt)
for f in files_to_add_to_resource:
uploaded_file = UploadedFile(file=open(f, 'rb'),
name=os.path.basename(f))
utils.add_file_to_resource(resource, uploaded_file)
# use the extracted metadata to populate resource metadata
for element in metadata:
# here k is the name of the element
# v is a dict of all element attributes/field names and field values
k, v = element.items()[0]
resource.metadata.create_element(k, **v)
log_msg = "Geo raster resource (ID:{}) - extracted metadata was saved to DB"
log_msg = log_msg.format(resource.short_id)
log.info(log_msg)
else:
# delete the invalid file just uploaded
delete_resource_file_only(resource, res_file)
validate_files_dict['are_files_valid'] = False
err_msg = "Uploaded file was not added to the resource. "
err_msg += ", ".join(msg for msg in error_info)
validate_files_dict['message'] = err_msg
log_msg = "File validation failed for raster resource (ID:{})."
log_msg = log_msg.format(resource.short_id)
log.error(log_msg)
# cleanup the temp file directory
if os.path.exists(temp_file):
shutil.rmtree(os.path.dirname(temp_file))
