def test_upload_size_quote(self) -> None: """ User quote for uploading should not be exceeded """ self.login(self.example_email("hamlet")) d1 = StringIO("zulip!") d1.name = "dummy_1.txt" result = self.client_post("/json/user_uploads", {'file': d1}) d1_path_id = re.sub('/user_uploads/', '', result.json()['uri']) d1_attachment = Attachment.objects.get(path_id = d1_path_id) self.assert_json_success(result) """ Below we set size quota to the limit without 1 upload(1GB - 11 bytes). """ d1_attachment.size = UserProfile.DEFAULT_UPLOADS_QUOTA - 11 d1_attachment.save() d2 = StringIO("zulip!") d2.name = "dummy_2.txt" result = self.client_post("/json/user_uploads", {'file': d2}) self.assert_json_success(result) d3 = StringIO("zulip!") d3.name = "dummy_3.txt" result = self.client_post("/json/user_uploads", {'file': d3}) self.assert_json_error(result, "Upload would exceed your maximum quota.")
def test_delete_old_unclaimed_attachments(self) -> None: # Upload some files and make them older than a weeek self.login(self.example_email("hamlet")) d1 = StringIO("zulip!") d1.name = "dummy_1.txt" result = self.client_post("/json/user_uploads", {'file': d1}) d1_path_id = re.sub('/user_uploads/', '', result.json()['uri']) d2 = StringIO("zulip!") d2.name = "dummy_2.txt" result = self.client_post("/json/user_uploads", {'file': d2}) d2_path_id = re.sub('/user_uploads/', '', result.json()['uri']) two_week_ago = timezone_now() - datetime.timedelta(weeks=2) d1_attachment = Attachment.objects.get(path_id = d1_path_id) d1_attachment.create_time = two_week_ago d1_attachment.save() self.assertEqual(str(d1_attachment), u'<Attachment: dummy_1.txt>') d2_attachment = Attachment.objects.get(path_id = d2_path_id) d2_attachment.create_time = two_week_ago d2_attachment.save() # Send message referring only dummy_1 self.subscribe(self.example_user("hamlet"), "Denmark") body = "Some files here ...[zulip.txt](http://localhost:9991/user_uploads/" + d1_path_id + ")" self.send_stream_message(self.example_email("hamlet"), "Denmark", body, "test") # dummy_2 should not exist in database or the uploads folder do_delete_old_unclaimed_attachments(2) self.assertTrue(not Attachment.objects.filter(path_id = d2_path_id).exists()) self.assertTrue(not delete_message_image(d2_path_id))
def parse_attachment(message_part): '''Parse an email message part into an attachment object.''' content_disposition = message_part.get("Content-Disposition", None) if content_disposition: dispositions = content_disposition.strip().split(";") if bool(content_disposition and dispositions[0].lower() == "attachment"): file_data = message_part.get_payload(decode=True) attachment = StringIO(file_data) attachment.content_type = message_part.get_content_type() attachment.size = len(file_data) attachment.name = message_part.get_filename() attachment.create_date = None attachment.mod_date = None attachment.read_date = None for param in dispositions[1:]: name,value = param.split("=") name = name.lower() if name == "filename": attachment.name = value elif name == "create-date": attachment.create_date = value attachment.ctime = parse_time(value) elif name == "modification-date": attachment.mod_date = value attachment.mtime = parse_time(value) elif name == "read-date": attachment.read_date = value attachment.atime = parse_time(value) return attachment return None
def test_check_attachment_reference_update(self) -> None: f1 = StringIO("file1") f1.name = "file1.txt" f2 = StringIO("file2") f2.name = "file2.txt" f3 = StringIO("file3") f3.name = "file3.txt" self.login(self.example_email("hamlet")) result = self.client_post("/json/user_uploads", {'file': f1}) f1_path_id = re.sub('/user_uploads/', '', result.json()['uri']) result = self.client_post("/json/user_uploads", {'file': f2}) f2_path_id = re.sub('/user_uploads/', '', result.json()['uri']) self.subscribe(self.example_user("hamlet"), "test") body = ("[f1.txt](http://localhost:9991/user_uploads/" + f1_path_id + ")" "[f2.txt](http://localhost:9991/user_uploads/" + f2_path_id + ")") msg_id = self.send_stream_message(self.example_email("hamlet"), "test", body, "test") result = self.client_post("/json/user_uploads", {'file': f3}) f3_path_id = re.sub('/user_uploads/', '', result.json()['uri']) new_body = ("[f3.txt](http://localhost:9991/user_uploads/" + f3_path_id + ")" "[f2.txt](http://localhost:9991/user_uploads/" + f2_path_id + ")") result = self.client_patch("/json/messages/" + str(msg_id), { 'message_id': msg_id, 'content': new_body }) self.assert_json_success(result) message = Message.objects.get(id=msg_id) f1_attachment = Attachment.objects.get(path_id=f1_path_id) f2_attachment = Attachment.objects.get(path_id=f2_path_id) f3_attachment = Attachment.objects.get(path_id=f3_path_id) self.assertTrue(message not in f1_attachment.messages.all()) self.assertTrue(message in f2_attachment.messages.all()) self.assertTrue(message in f3_attachment.messages.all()) # Delete all the attachments from the message new_body = "(deleted)" result = self.client_patch("/json/messages/" + str(msg_id), { 'message_id': msg_id, 'content': new_body }) self.assert_json_success(result) message = Message.objects.get(id=msg_id) f1_attachment = Attachment.objects.get(path_id=f1_path_id) f2_attachment = Attachment.objects.get(path_id=f2_path_id) f3_attachment = Attachment.objects.get(path_id=f3_path_id) self.assertTrue(message not in f1_attachment.messages.all()) self.assertTrue(message not in f2_attachment.messages.all()) self.assertTrue(message not in f3_attachment.messages.all())
def test_multiple_upload_failure(self) -> None: """ Attempting to upload two files should fail. """ self.login(self.example_email("hamlet")) fp = StringIO("bah!") fp.name = "a.txt" fp2 = StringIO("pshaw!") fp2.name = "b.txt" result = self.client_post("/json/user_uploads", {'f1': fp, 'f2': fp2}) self.assert_json_error(result, "You may only upload one file at a time")
def test_extract_param_encoding(self): fake_f = StringIO(""" <html> <head> <meta charset="utf-8"> <meta name="haystack-test" content="test 1234"> <title>Test Title ☃☃</title> </head> <body>foobar</body> </html> """) fake_f.name = "test.html" # Insert a doc with extra metadata ascii_value = u'aeiou' nonascii_value = u'áéëíóúüñÁÉËÍÓÚÜ' extracted = self.solr.extract(fake_f, extractOnly=False, **{ 'literal.id': '29A', 'literal.title': nonascii_value, 'literal.subject': ascii_value, 'commit': 'true', }) res = self.solr.search('id:29A') # Check if document are added self.assertEqual(len(res), 1) # Check for ascii and non-ascii values doc = res.docs[0] self.assertEqual(doc['id'], '29A') self.assertEqual(doc['subject'], ascii_value) self.assertEqual(doc['title'], [nonascii_value])
def test_multiple_claim_attachments_different_owners(self) -> None: """This test tries to claim the same attachment more than once, first with a private stream and then with different recipients.""" self.login(self.example_email("hamlet")) d1 = StringIO("zulip!") d1.name = "dummy_1.txt" result = self.client_post("/json/user_uploads", {'file': d1}) d1_path_id = re.sub('/user_uploads/', '', result.json()['uri']) self.make_stream("private_stream", invite_only=True) self.subscribe(self.example_user("hamlet"), "private_stream") # First, send the mesasge to the new private stream. body = "First message ...[zulip.txt](http://localhost:9991/user_uploads/" + d1_path_id + ")" self.send_stream_message(self.example_email("hamlet"), "private_stream", body, "test") self.assertFalse(Attachment.objects.get(path_id=d1_path_id).is_realm_public) self.assertEqual(Attachment.objects.get(path_id=d1_path_id).messages.count(), 1) # Then, try having a user who didn't receive the message try to publish it, and fail body = "Illegal message ...[zulip.txt](http://localhost:9991/user_uploads/" + d1_path_id + ")" self.send_stream_message(self.example_email("cordelia"), "Denmark", body, "test") self.assertEqual(Attachment.objects.get(path_id=d1_path_id).messages.count(), 1) self.assertFalse(Attachment.objects.get(path_id=d1_path_id).is_realm_public) # Then, have the owner PM it to another user, giving that other user access. body = "Second message ...[zulip.txt](http://localhost:9991/user_uploads/" + d1_path_id + ")" self.send_personal_message(self.example_email("hamlet"), self.example_email("othello"), body) self.assertEqual(Attachment.objects.get(path_id=d1_path_id).messages.count(), 2) self.assertFalse(Attachment.objects.get(path_id=d1_path_id).is_realm_public) # Then, have that new recipient user publish it. body = "Third message ...[zulip.txt](http://localhost:9991/user_uploads/" + d1_path_id + ")" self.send_stream_message(self.example_email("othello"), "Denmark", body, "test") self.assertEqual(Attachment.objects.get(path_id=d1_path_id).messages.count(), 3) self.assertTrue(Attachment.objects.get(path_id=d1_path_id).is_realm_public)
def test_arc_v2_writer(): "Try writing records to an ARC V2 file. This is what API will feel like to a user of the library" now = "20120302193210" file_headers = dict(ip_address = "127.0.0.1", date = now, org = "Internet Archive") opfile = StringIO() opfile.name = "sample.arc" # Necessary since only file objects in Python have names. f = arc.ARCFile(fileobj = opfile, file_headers = file_headers) for payload in "Payload1 Payload2".split(): header = arc.ARCHeader(url = "http://archive.org", ip_address = "127.0.0.1", date = "20120301093000", content_type = "text/html", length = "500", result_code = "200", checksum = "a123456", location = "http://www.archive.org", offset = "300", filename = "sample.arc.gz") r = arc.ARCRecord(headers = header, payload = payload) f.write(r) assert opfile.getvalue() == "filedesc://sample.arc 127.0.0.1 20120302193210 text/plain 200 - - 0 sample.arc 113\n2 0 Internet Archive\nURL IP-address Archive-date Content-type Result-code Checksum Location Offset Filename Archive-length\n\nhttp://archive.org 127.0.0.1 20120301093000 text/html 200 a123456 http://www.archive.org 300 sample.arc.gz 500\nPayload1\n\nhttp://archive.org 127.0.0.1 20120301093000 text/html 200 a123456 http://www.archive.org 300 sample.arc.gz 500\nPayload2\n\n" f.close()
def test_with_thumbor_disabled(self) -> None: self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.jpeg" result = self.client_post("/json/user_uploads", {'file': fp}) self.assert_json_success(result) json = ujson.loads(result.content) self.assertIn("uri", json) uri = json["uri"] base = '/user_uploads/' self.assertEqual(base, uri[:len(base)]) quoted_uri = urllib.parse.quote(uri[1:], safe='') with self.settings(THUMBOR_URL=''): result = self.client_get("/thumbnail?url=%s&size=original" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) self.assertEqual(uri, result.url) uri = 'https://www.google.com/images/srpr/logo4w.png' quoted_uri = urllib.parse.quote(uri, safe='') with self.settings(THUMBOR_URL=''): result = self.client_get("/thumbnail?url=%s&size=original" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) self.assertEqual(uri, result.url) uri = 'http://www.google.com/images/srpr/logo4w.png' quoted_uri = urllib.parse.quote(uri, safe='') with self.settings(THUMBOR_URL=''): result = self.client_get("/thumbnail?url=%s&size=original" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) base = 'https://external-content.zulipcdn.net/7b6552b60c635e41e8f6daeb36d88afc4eabde79/687474703a2f2f7777772e676f6f676c652e636f6d2f696d616765732f737270722f6c6f676f34772e706e67' self.assertEqual(base, result.url)
def test_simple(self, config_mock, savefig_mock): config_mock.return_value = self.config amino_csv = StringIO("""\ seed,region,q-cutoff,query.aa.pos,refseq.aa.pos,\ A,C,D,E,F,G,H,I,K,L,M,N,P,Q,R,S,T,V,W,Y,*,X,partial,del,ins,clip,v3_overlap R1-seed,R1,15,100,1,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 R1-seed,R1,15,101,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0 R1-seed,R1,15,102,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0 """) expected_scores = """\ project,region,seed,q.cut,min.coverage,which.key.pos,off.score,on.score R1,R1,R1-seed,15,5,1,-1,1 R1-and-R2,R1,R1-seed,15,5,1,-1,1 """ scores_csv = StringIO() amino_csv.name = 'E1234.amino.csv' expected_calls = [call('E1234.R1.R1.png'), call('E1234.R1.R1.details.png'), call('E1234.R1-and-R2.R1.png'), call('E1234.R1-and-R2.R1.details.png')] coverage_plot(amino_csv, coverage_scores_csv=scores_csv, coverage_maps_prefix='E1234') self.assertEqual(expected_calls, savefig_mock.mock_calls) self.assertEqual(expected_scores, scores_csv.getvalue())
def test_file_upload_authed(self) -> None: """ A call to /json/user_uploads should return a uri and actually create an entry in the database. This entry will be marked unclaimed till a message refers it. """ self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.txt" result = self.client_post("/json/user_uploads", {'file': fp}) self.assert_json_success(result) self.assertIn("uri", result.json()) uri = result.json()["uri"] base = '/user_uploads/' self.assertEqual(base, uri[:len(base)]) # In the future, local file requests will follow the same style as S3 # requests; they will be first authenthicated and redirected self.assert_url_serves_contents_of_file(uri, b"zulip!") # check if DB has attachment marked as unclaimed entry = Attachment.objects.get(file_name='zulip.txt') self.assertEqual(entry.is_claimed(), False) self.subscribe(self.example_user("hamlet"), "Denmark") body = "First message ...[zulip.txt](http://localhost:9991" + uri + ")" self.send_stream_message(self.example_email("hamlet"), "Denmark", body, "test") self.assertIn('title="zulip.txt"', self.get_last_message().rendered_content)
def test_file_upload_authed(self) -> None: """ A call to /json/user_uploads should return a uri and actually create an object. """ conn = S3Connection(settings.S3_KEY, settings.S3_SECRET_KEY) conn.create_bucket(settings.S3_AUTH_UPLOADS_BUCKET) self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.txt" result = self.client_post("/json/user_uploads", {'file': fp}) self.assert_json_success(result) self.assertIn("uri", result.json()) base = '/user_uploads/' uri = result.json()['uri'] self.assertEqual(base, uri[:len(base)]) response = self.client_get(uri) redirect_url = response['Location'] self.assertEqual(b"zulip!", urllib.request.urlopen(redirect_url).read().strip()) self.subscribe(self.example_user("hamlet"), "Denmark") body = "First message ...[zulip.txt](http://localhost:9991" + uri + ")" self.send_stream_message(self.example_email("hamlet"), "Denmark", body, "test") self.assertIn('title="zulip.txt"', self.get_last_message().rendered_content)
def test_extract(self): fake_f = StringIO(""" <html> <head> <meta charset="utf-8"> <meta name="haystack-test" content="test 1234"> <title>Test Title ☃☃</title> </head> <body>foobar</body> </html> """) fake_f.name = "test.html" extracted = yield self.solr.extract(fake_f) # Verify documented response structure: self.assertIn('contents', extracted) self.assertIn('metadata', extracted) self.assertIn('foobar', extracted['contents']) m = extracted['metadata'] self.assertEqual([fake_f.name], m['stream_name']) self.assertIn('haystack-test', m, "HTML metadata should have been extracted!") self.assertEqual(['test 1234'], m['haystack-test']) # Note the underhanded use of a double snowman to verify both that Tika # correctly decoded entities and that our UTF-8 characters survived the # round-trip: self.assertEqual(['Test Title ☃☃'], m['title'])
def setUp(self): map_content = StringIO("3 2\n. # &\n+ . *") map_content.name = "map0.txt" self.world = World(map_content, False) self.player1 = Player(1, self.world) self.world.add_player(self.player1) self.world.game_start()
def test_delete_message_image_local(self) -> None: self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.txt" result = self.client_post("/json/user_uploads", {'file': fp}) path_id = re.sub('/user_uploads/', '', result.json()['uri']) self.assertTrue(delete_message_image(path_id))
def create_run_command(): """ Create the remote_run command to be executed """ puts("Creating run_server.") with lcd(env.localfolder): with cd(env.REPOSITORY_FOLDER): run_temp_file = StringIO(run_command_content()) run_temp_file.name = "run_server" # to show it as fabric file representation put(run_temp_file, posixpath.join(env.REPOSITORY_FOLDER, 'run_server')) run('chmod +x run_server')
def setUp(self): map_content = StringIO("3 2\n& & &\n& & &") map_content.name = "map0.txt" self.world = World(map_content, False) self.player1 = Player(1, self.world) self.player2 = Player(2, self.world) self.player3 = Player(3, self.world) self.player4 = Player(4, self.world) self.test_team = Team() self.test_team2 = Team()
def get_file(self): self._update_object() response = requests.get(self._list_object.SITE + self.location) response = requests.get(response.content.decode()) buff = StringIO() buff.content_type = response.headers['content-type'] buff.name = self.filename buff.write(response.content.decode()) buff.seek(0) #buff.close() return buff
def test_file_name(self) -> None: """ Unicode filenames should be processed correctly. """ self.login(self.example_email("hamlet")) for expected in ["Здравейте.txt", "test"]: fp = StringIO("bah!") fp.name = urllib.parse.quote(expected) result = self.client_post("/json/user_uploads", {'f1': fp}) assert sanitize_name(expected) in result.json()['uri']
def test_file_download_unauthed(self) -> None: self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.txt" result = self.client_post("/json/user_uploads", {'file': fp}) uri = result.json()["uri"] self.logout() response = self.client_get(uri) self.assert_json_error(response, "Not logged in: API authentication or user session required", status_code=401)
def test_s3_source_type(self) -> None: def get_file_path_urlpart(uri: str, size: str='') -> str: base = '/user_uploads/' url_in_result = 'smart/filters:no_upscale()/%s/source_type/s3' if size: url_in_result = '/%s/%s' % (size, url_in_result) upload_file_path = uri[len(base):] hex_uri = base64.urlsafe_b64encode(upload_file_path.encode()).decode('utf-8') return url_in_result % (hex_uri) conn = S3Connection(settings.S3_KEY, settings.S3_SECRET_KEY) conn.create_bucket(settings.S3_AUTH_UPLOADS_BUCKET) self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.jpeg" result = self.client_post("/json/user_uploads", {'file': fp}) self.assert_json_success(result) json = ujson.loads(result.content) self.assertIn("uri", json) uri = json["uri"] base = '/user_uploads/' self.assertEqual(base, uri[:len(base)]) quoted_uri = urllib.parse.quote(uri[1:], safe='') # Test original image size. result = self.client_get("/thumbnail?url=%s&size=original" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) expected_part_url = get_file_path_urlpart(uri) self.assertIn(expected_part_url, result.url) # Test thumbnail size. result = self.client_get("/thumbnail?url=%s&size=thumbnail" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) expected_part_url = get_file_path_urlpart(uri, '0x100') self.assertIn(expected_part_url, result.url) # Tests the /api/v1/thumbnail api endpoint with standard API auth self.logout() result = self.api_get( self.example_email("hamlet"), '/thumbnail?url=%s&size=original' % (quoted_uri,)) self.assertEqual(result.status_code, 302, result) expected_part_url = get_file_path_urlpart(uri) self.assertIn(expected_part_url, result.url) # Test with another user trying to access image using thumbor. self.login(self.example_email("iago")) result = self.client_get("/thumbnail?url=%s&size=original" % (quoted_uri)) self.assertEqual(result.status_code, 403, result) self.assert_in_response("You are not authorized to view this file.", result)
def lbcb(name, doc): # This only applies to 'start' Documents. if name != 'start': return plan_name = doc.get('plan_name', '') body = long_dispatch[plan_name] desc = desc_dispatch[plan_name] atch = StringIO(body.render(start=doc)) # monkey-patch a 'name' attribute onto StringIO atch.name = 'long_description.txt' desc = desc.render(start=doc) logbook_func(text=desc, attachments=[atch], ensure=True)
def test_illuminafastq(self): fastq_file = StringIO( u"@M03543:47:C8LJ2ANXX:1:2209:1084:2044 1:N:0:NNNNNNNN+NNNNNNNN") fastq_filepath = ( "Miseq/160511_M03543_0047_000000000-APE6Y/Data/Intensities/" "BaseCalls/Undetermined_S0_L001_R1_001.fastq.gz") fastq_file.name = fastq_filepath fq = IlluminaFastq(fastq_file) self.assertEqual(fq.machine_type, "Illumina-MiSeq") self.assertEqual(fq.date, "2016-05-11") self.assertEqual(fq.lane, "1") self.assertEqual(fq.filepath, fastq_filepath)
def test_realm_quota(self) -> None: """ Realm quota for uploading should not be exceeded. """ self.login(self.example_email("hamlet")) d1 = StringIO("zulip!") d1.name = "dummy_1.txt" result = self.client_post("/json/user_uploads", {'file': d1}) d1_path_id = re.sub('/user_uploads/', '', result.json()['uri']) d1_attachment = Attachment.objects.get(path_id = d1_path_id) self.assert_json_success(result) realm = get_realm("zulip") realm.upload_quota_gb = 1 realm.save(update_fields=['upload_quota_gb']) # The size of StringIO("zulip!") is 6 bytes. Setting the size of # d1_attachment to realm.upload_quota_bytes() - 11 should allow # us to upload only one more attachment. quota = realm.upload_quota_bytes() assert(quota is not None) d1_attachment.size = quota - 11 d1_attachment.save(update_fields=['size']) d2 = StringIO("zulip!") d2.name = "dummy_2.txt" result = self.client_post("/json/user_uploads", {'file': d2}) self.assert_json_success(result) d3 = StringIO("zulip!") d3.name = "dummy_3.txt" result = self.client_post("/json/user_uploads", {'file': d3}) self.assert_json_error(result, "Upload would exceed your organization's upload quota.") realm.upload_quota_gb = None realm.save(update_fields=['upload_quota_gb']) result = self.client_post("/json/user_uploads", {'file': d3}) self.assert_json_success(result)
def test_removed_file_download(self) -> None: ''' Trying to download deleted files should return 404 error ''' self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.txt" result = self.client_post("/json/user_uploads", {'file': fp}) destroy_uploads() response = self.client_get(result.json()["uri"]) self.assertEqual(response.status_code, 404)
def test_file_too_big_failure(self) -> None: """ Attempting to upload big files should fail. """ self.login(self.example_email("hamlet")) fp = StringIO("bah!") fp.name = "a.txt" # Use MAX_FILE_UPLOAD_SIZE of 0, because the next increment # would be 1MB. with self.settings(MAX_FILE_UPLOAD_SIZE=0): result = self.client_post("/json/user_uploads", {'f1': fp}) self.assert_json_error(result, 'Uploaded file is larger than the allowed limit of 0 MB')
def test_opt_cmd(self): config = StringIO(u"""[hubble] name=Test opt-cmd={0} ${{opt.option}} ${{name}} [dfw] cmd={1} SOME=Thing""".format(self.opt_cmd, self.cmd)) config.name = "test.conf" ret, out, err = run_main(config, ["hubble", "-o", "my-option", "dfw", "--debug"]) self.assertEqual(ret, 0) self.assertEqual(out['SOME'], "Thing") self.assertEqual(out['opt-injected-key'], "value")
def test_import_gmf_scenario_csv(self): test_data = StringIO(unicode('''\ SA 0.025 5.0 {0.2} POINT(0.0 0.0) SA 0.025 5.0 {1.4} POINT(1.0 0.0) SA 0.025 5.0 {0.6} POINT(0.0 1.0) PGA \N \N {0.2,0.3} POINT(0.0 0.0) PGA \N \N {1.4,1.5} POINT(1.0 0.0) PGA \N \N {0.6,0.7} POINT(0.0 1.0) PGV \N \N {0.2} POINT(0.0 0.0) PGV \N \N {1.4} POINT(1.0 0.0) ''')) test_data.name = 'test_data' out = import_gmf_scenario.import_gmf_scenario(test_data) n = models.GmfData.objects.filter(gmf__output=out).count() assert_equal(n, 8) # 8 rows entered
def upload_file(client): # type: (Client) -> None fp = StringIO("zulip") fp.name = "zulip.txt" # {code_example|start} # Upload a file # (Make sure that 'fp' is a file object) result = client.call_endpoint( 'user_uploads', method='POST', files=[fp] ) # {code_example|end} validate_against_openapi_schema(result, '/user_uploads', 'post', '200')
def test_with_different_sizes(self) -> None: def get_file_path_urlpart(uri: str, size: str='') -> str: base = '/user_uploads/' url_in_result = 'smart/filters:no_upscale()/%s/source_type/local_file' if size: url_in_result = '/%s/%s' % (size, url_in_result) upload_file_path = uri[len(base):] hex_uri = base64.urlsafe_b64encode(upload_file_path.encode()).decode('utf-8') return url_in_result % (hex_uri) self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.jpeg" result = self.client_post("/json/user_uploads", {'file': fp}) self.assert_json_success(result) json = ujson.loads(result.content) self.assertIn("uri", json) uri = json["uri"] base = '/user_uploads/' self.assertEqual(base, uri[:len(base)]) # Test with size supplied as a query parameter. # size=thumbnail should return a 0x100 sized image. # size=original should return the original resolution image. quoted_uri = urllib.parse.quote(uri[1:], safe='') result = self.client_get("/thumbnail?url=%s&size=thumbnail" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) expected_part_url = get_file_path_urlpart(uri, '0x100') self.assertIn(expected_part_url, result.url) result = self.client_get("/thumbnail?url=%s&size=original" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) expected_part_url = get_file_path_urlpart(uri) self.assertIn(expected_part_url, result.url) # Test with size supplied as a query parameter where size is anything # else than original or thumbnail. Result should be an error message. result = self.client_get("/thumbnail?url=%s&size=480x360" % (quoted_uri)) self.assertEqual(result.status_code, 403, result) self.assert_in_response("Invalid size.", result) # Test with no size param supplied. In this case as well we show an # error message. result = self.client_get("/thumbnail?url=%s" % (quoted_uri)) self.assertEqual(result.status_code, 400, "Missing 'size' argument")
def test_update_gha_python_versions_zopefoundation(): tests_yml = StringIO( textwrap.dedent("""\ jobs: build: strategy: matrix: config: # [Python version, tox env] - ["3.8", "lint"] - ["2.7", "py27"] - ["3.5", "py35"] - ["3.6", "py36"] - ["3.7", "py37"] - ["3.8", "py38"] - ["3.9", "py39"] - ["pypy2", "pypy"] - ["pypy3", "pypy3"] - ["3.8", "coverage"] steps: - ... """)) tests_yml.name = '.github/workflows/tests.yml' result = update_gha_python_versions(tests_yml, v(["2.7", "3.8", "3.9"])) assert "".join(result) == textwrap.dedent("""\ jobs: build: strategy: matrix: config: # [Python version, tox env] - ["3.8", "lint"] - ["2.7", "py27"] - ["3.8", "py38"] - ["3.9", "py39"] - ["pypy2", "pypy"] - ["pypy3", "pypy3"] - ["3.8", "coverage"] steps: - ... """)
def run(self): failed = [] for library in self._options.libraries: try: xml_doc = StringIO() # LibraryDocumentation().save() calls close() for the underlying # file but closing StringIO object discards its data. # This is why close() is overridden below. xml_doc.original_close = xml_doc.close try: try: if library.endswith('.xml'): with open(library) as xml_file: xml_doc.write(xml_file.read()) else: xml_doc.close = lambda: None LibraryDocumentation(library).save(xml_doc, 'xml') except DataError as e: message = "Library not found" if 'ImportError' in e.message else e.message failed.append(library) sys.stderr.write( "Skipping '%s' due to an error: %s.\n" % (library, message)) continue xml_doc.name = library self._uploader.upload_file(xml_doc, self._options.lib_name, self._options.lib_version) sys.stdout.write("Updated documentation for '%s'.\n" % library) finally: xml_doc.original_close() except DataError as e: failed.append(library) sys.stderr.write('%s: Remote error: %s\n' % (os.path.basename(__file__), e.message)) if failed: sys.stderr.write('\nERROR: Uploading %d file(s) failed:\n' % len(failed)) for name in failed: sys.stderr.write('* %s\n' % name) exit(1)
def test_extract(self): fake_f = StringIO(""" <html> <head> <meta charset="utf-8"> <meta name="haystack-test" content="test 1234"> <title>Test Title ☃☃</title> </head> <body>foobar</body> </html> """) fake_f.name = "test.html" extracted = self.solr.extract(fake_f) # extract should default to 'update/extract' handler args, kwargs = self.solr._send_request.call_args self.assertTrue(args[1].startswith('update/extract')) # extract should support custom handlers with self.assertRaises(SolrError): self.solr.extract(fake_f, handler='fakehandler') args, kwargs = self.solr._send_request.call_args self.assertTrue(args[1].startswith('fakehandler')) # Verify documented response structure: self.assertIn('contents', extracted) self.assertIn('metadata', extracted) self.assertIn('foobar', extracted['contents']) m = extracted['metadata'] self.assertEqual([fake_f.name], m['stream_name']) self.assertIn('haystack-test', m, "HTML metadata should have been extracted!") self.assertEqual(['test 1234'], m['haystack-test']) # Note the underhanded use of a double snowman to verify both that Tika # correctly decoded entities and that our UTF-8 characters survived the # round-trip: self.assertEqual(['Test Title ☃☃'], m['title'])
def test_read_error(self): # given that there is no generic parser, emulate one like so def parser(text): raise ECMASyntaxError('Illegal input') def not_a_parser(text): raise Exception('Illegal input') stream = StringIO('var foo = "bar";') stream.name = 'somefile.js' with self.assertRaises(Exception) as e: io.read(parser, stream) self.assertEqual("Illegal input in 'somefile.js'", e.exception.args[0]) stream = StringIO('var foo = "bar";') with self.assertRaises(Exception) as e: io.read(not_a_parser, stream) self.assertNotEqual("Illegal input in 'somefile.js'", e.exception.args[0])
def test_update_travis_yml_python_versions_3_10(): travis_yml = StringIO(textwrap.dedent("""\ language: python python: - 3.4 - pypy3 install: pip install -e . script: pytest tests """)) travis_yml.name = '.travis.yml' result = update_travis_yml_python_versions(travis_yml, v(["3.9", "3.10"])) # Note: we cannot say '- 3.10', that's a float and evaluates to 3.1! assert "".join(result) == textwrap.dedent("""\ language: python python: - 3.9 - "3.10" - pypy3 install: pip install -e . script: pytest tests """)
def test_update_travis_yml_some_python_versions_as_strings(): travis_yml = StringIO(textwrap.dedent("""\ language: python python: - 3.9 - "3.10" - pypy3 install: pip install -e . script: pytest tests """)) travis_yml.name = '.travis.yml' result = update_travis_yml_python_versions(travis_yml, v(["3.9", "3.10"])) assert "".join(result) == textwrap.dedent("""\ language: python python: - 3.9 - "3.10" - pypy3 install: pip install -e . script: pytest tests """)
def test_update_travis_yml_python_versions_drops_sudo(): travis_yml = StringIO(textwrap.dedent("""\ language: python sudo: false dist: xenial python: - 2.7 install: pip install -e . script: pytest tests """)) travis_yml.name = '.travis.yml' result = update_travis_yml_python_versions(travis_yml, v(["2.7", "3.7"])) assert "".join(result) == textwrap.dedent("""\ language: python dist: xenial python: - 2.7 - 3.7 install: pip install -e . script: pytest tests """)
def test_update_travis_yml_python_versions_keeps_dev(): travis_yml = StringIO( textwrap.dedent("""\ language: python python: - 3.7 - 3.8 - 3.9-dev install: pip install -e . script: pytest tests """)) travis_yml.name = '.travis.yml' result = update_travis_yml_python_versions(travis_yml, ["3.8"]) assert "".join(result) == textwrap.dedent("""\ language: python python: - 3.8 - 3.9-dev install: pip install -e . script: pytest tests """)
def convert(source_path, dest_path, sra_settings=None, validate_first=True): isa_json = isatab2json.convert(source_path, validate_first=validate_first) isa_json_fp = StringIO(json.dumps(isa_json)) isa_json_fp.name = "BII-S-3.json" json2sra.convert(isa_json_fp, dest_path, sra_settings=sra_settings, validate_first=False) logging.info("Conversion complete...") buffer = BytesIO() if os.path.isdir(dest_path): with ZipFile(buffer, 'w') as zip_file: # use relative dir_name to avoid absolute path on file names zipdir(dest_path, zip_file) print(zip_file.namelist()) # clean up the target directory after the ZIP file has been closed # rmtree(sra_dir) buffer.seek(0) return buffer
def test_multiple_claim_attachments(self) -> None: """ This test tries to claim the same attachment twice. The messages field in the Attachment model should have both the messages in its entry. """ self.login(self.example_email("hamlet")) d1 = StringIO("zulip!") d1.name = "dummy_1.txt" result = self.client_post("/json/user_uploads", {'file': d1}) d1_path_id = re.sub('/user_uploads/', '', result.json()['uri']) self.subscribe(self.example_user("hamlet"), "Denmark") body = "First message ...[zulip.txt](http://localhost:9991/user_uploads/" + d1_path_id + ")" self.send_stream_message(self.example_email("hamlet"), "Denmark", body, "test") body = "Second message ...[zulip.txt](http://localhost:9991/user_uploads/" + d1_path_id + ")" self.send_stream_message(self.example_email("hamlet"), "Denmark", body, "test") self.assertEqual( Attachment.objects.get(path_id=d1_path_id).messages.count(), 2)
def _document_load_by_url(loader, url, loadingOptions): # type: (_Loader, str, LoadingOptions) -> Any if url in loadingOptions.idx: return _document_load(loader, loadingOptions.idx[url], url, loadingOptions) text = loadingOptions.fetcher.fetch_text(url) if isinstance(text, bytes): textIO = StringIO(text.decode("utf-8")) else: textIO = StringIO(text) textIO.name = str(url) yaml = yaml_no_ts() result = yaml.load(textIO) add_lc_filename(result, url) loadingOptions.idx[url] = result loadingOptions = LoadingOptions(copyfrom=loadingOptions, fileuri=url) return _document_load(loader, result, url, loadingOptions)
def test_update_travis_yml_python_versions(): travis_yml = StringIO( textwrap.dedent("""\ language: python python: - 2.7 - pypy install: pip install -e . script: pytest tests """)) travis_yml.name = '.travis.yml' result = update_travis_yml_python_versions(travis_yml, ["2.7", "3.4"]) assert "".join(result) == textwrap.dedent("""\ language: python python: - 2.7 - 3.4 - pypy install: pip install -e . script: pytest tests """)
def fetch( self, url: str, inject_ids: bool = True, content_types: Optional[List[str]] = None, ) -> IdxResultType: if url in self.idx: return self.idx[url] try: text = self.fetch_text(url, content_types=content_types) if isinstance(text, bytes): textIO = StringIO(text.decode("utf-8")) else: textIO = StringIO(text) textIO.name = str(url) yaml = YAML() yaml.preserve_quotes = True # type: ignore attachments = yaml.load_all(textIO) result = cast(Union[CommentedSeq, CommentedMap], next(attachments)) if self.allow_attachments is not None and self.allow_attachments( result): i = 1 for a in attachments: self.idx[f"{url}#attachment-{i}"] = a i += 1 add_lc_filename(result, url) except MarkedYAMLError as e: raise to_validation_exception(e) from e if isinstance(result, CommentedMap) and inject_ids and bool( self.identifiers): for identifier in self.identifiers: if identifier not in result: result[identifier] = url self.idx[self.expand_url(result[identifier], url, scoped_id=True)] = result self.idx[url] = result return result
def test_update_travis_yml_python_versions_drops_pypy3(): # yes this test case is massively unrealistic travis_yml = StringIO(textwrap.dedent("""\ language: python python: - 2.7 - 3.4 - pypy - pypy3 install: pip install -e . script: pytest tests """)) travis_yml.name = '.travis.yml' result = update_travis_yml_python_versions(travis_yml, v(["2.7"])) assert "".join(result) == textwrap.dedent("""\ language: python python: - 2.7 - pypy install: pip install -e . script: pytest tests """)
def convert(source_path, dest_path, sra_settings=None, validate_first=True): log.info("Converting ISA-Tab to JSON for %s", source_path) isa_json = isatab2json.convert(source_path, validate_first=validate_first) log.debug("Writing JSON to memory file") isa_json_fp = StringIO(json.dumps(isa_json)) isa_json_fp.name = "BII-S-3.json" log.info("Converting JSON to SRA, writing to %s", dest_path) log.info("Using SRA settings %s", sra_settings) json2sra.convert(isa_json_fp, dest_path, sra_settings=sra_settings, validate_first=False) log.info("Conversion from ISA-Tab to SRA complete") buffer = BytesIO() if os.path.isdir(dest_path): log.info("Zipping SRA files") with ZipFile(buffer, 'w') as zip_file: zipdir(dest_path, zip_file) log.debug("Zipped %s", zip_file.namelist()) buffer.seek(0) log.info("Returning zipped files as memory file") return buffer
def check_xsend_links(name: Text, name_str_for_test: Text, content_disposition: Text='') -> None: with self.settings(SENDFILE_BACKEND='sendfile.backends.nginx'): _get_sendfile.clear() # To clearout cached version of backend from djangosendfile self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = name result = self.client_post("/json/user_uploads", {'file': fp}) uri = result.json()['uri'] fp_path_id = re.sub('/user_uploads/', '', uri) fp_path = os.path.split(fp_path_id)[0] response = self.client_get(uri) _get_sendfile.clear() test_upload_dir = os.path.split(settings.LOCAL_UPLOADS_DIR)[1] self.assertEqual(response['X-Accel-Redirect'], '/serve_uploads/../../' + test_upload_dir + '/files/' + fp_path + '/' + name_str_for_test) if content_disposition != '': self.assertIn('attachment;', response['Content-disposition']) self.assertIn(content_disposition, response['Content-disposition']) else: self.assertEqual(response.get('Content-disposition'), None)
def test_thumbnail_redirect(self) -> None: self.login("hamlet") fp = StringIO("zulip!") fp.name = "zulip.jpeg" result = self.client_post("/json/user_uploads", {"file": fp}) self.assert_json_success(result) json = orjson.loads(result.content) self.assertIn("uri", json) uri = json["uri"] base = "/user_uploads/" self.assertEqual(base, uri[: len(base)]) result = self.client_get("/thumbnail", {"url": uri[1:], "size": "full"}) self.assertEqual(result.status_code, 302, result) self.assertEqual(uri, result["Location"]) self.login("iago") result = self.client_get("/thumbnail", {"url": uri[1:], "size": "full"}) self.assertEqual(result.status_code, 403, result) self.assert_in_response("You are not authorized to view this file.", result) uri = "https://www.google.com/images/srpr/logo4w.png" result = self.client_get("/thumbnail", {"url": uri, "size": "full"}) self.assertEqual(result.status_code, 302, result) base = "https://external-content.zulipcdn.net/external_content/56c362a24201593891955ff526b3b412c0f9fcd2/68747470733a2f2f7777772e676f6f676c652e636f6d2f696d616765732f737270722f6c6f676f34772e706e67" self.assertEqual(base, result["Location"]) uri = "http://www.google.com/images/srpr/logo4w.png" result = self.client_get("/thumbnail", {"url": uri, "size": "full"}) self.assertEqual(result.status_code, 302, result) base = "https://external-content.zulipcdn.net/external_content/7b6552b60c635e41e8f6daeb36d88afc4eabde79/687474703a2f2f7777772e676f6f676c652e636f6d2f696d616765732f737270722f6c6f676f34772e706e67" self.assertEqual(base, result["Location"]) uri = "//www.google.com/images/srpr/logo4w.png" result = self.client_get("/thumbnail", {"url": uri, "size": "full"}) self.assertEqual(result.status_code, 302, result) base = "https://external-content.zulipcdn.net/external_content/676530cf4b101d56f56cc4a37c6ef4d4fd9b0c03/2f2f7777772e676f6f676c652e636f6d2f696d616765732f737270722f6c6f676f34772e706e67" self.assertEqual(base, result["Location"])
def test_with_different_THUMBOR_URL(self) -> None: self.login('hamlet') fp = StringIO("zulip!") fp.name = "zulip.jpeg" result = self.client_post("/json/user_uploads", {'file': fp}) self.assert_json_success(result) json = ujson.loads(result.content) self.assertIn("uri", json) uri = json["uri"] base = '/user_uploads/' self.assertEqual(base, uri[:len(base)]) quoted_uri = urllib.parse.quote(uri[1:], safe='') hex_uri = base64.urlsafe_b64encode(uri.encode()).decode('utf-8') with self.settings(THUMBOR_URL='http://test-thumborhost.com'): result = self.client_get(f"/thumbnail?url={quoted_uri}&size=full") self.assertEqual(result.status_code, 302, result) base = 'http://test-thumborhost.com/' self.assertEqual(base, result.url[:len(base)]) expected_part_url = '/smart/filters:no_upscale()/' + hex_uri + '/source_type/local_file' self.assertIn(expected_part_url, result.url)
def test_write_error_handled_callable_closed(self): # streams root = mktemp() output_stream = StringIO() output_stream.name = join(root, 'packed.js') closed = [] def close(): closed.append(True) output_stream.close = close def f_output_stream(): return output_stream def f_error(): raise IOError('some error happened') definitions = { 'Node': ( Attr(attr='text'), Text(value=';'), ) } # the program node; attributes are assigned to mimic a real one program = Node() program.text = 'hello' program.sourcepath = join(root, 'program.js') program._token_map = {'hello': [(0, 1, 1)]} unparser = BaseUnparser(definitions) with self.assertRaises(IOError): io.write(unparser, [program], f_output_stream, f_error) self.assertEqual(1, len(closed)) self.assertEqual('hello;', output_stream.getvalue()) self.assertNotIn('program.js', output_stream.getvalue())
def test_file_download_authorization_invite_only(self) -> None: subscribed_users = [self.example_email("hamlet"), self.example_email("iago")] unsubscribed_users = [self.example_email("othello"), self.example_email("prospero")] realm = get_realm("zulip") for email in subscribed_users: self.subscribe(get_user(email, realm), "test-subscribe") # Make the stream private stream = Stream.objects.get(name='test-subscribe') stream.invite_only = True stream.save() self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.txt" result = self.client_post("/json/user_uploads", {'file': fp}) uri = result.json()['uri'] fp_path_id = re.sub('/user_uploads/', '', uri) body = "First message ...[zulip.txt](http://localhost:9991/user_uploads/" + fp_path_id + ")" self.send_stream_message(self.example_email("hamlet"), "test-subscribe", body, "test") self.logout() # Subscribed user should be able to view file for user in subscribed_users: self.login(user) response = self.client_get(uri) self.assertEqual(response.status_code, 200) data = b"".join(response.streaming_content) self.assertEqual(b"zulip!", data) self.logout() # Unsubscribed user should not be able to view file for user in unsubscribed_users: self.login(user) response = self.client_get(uri) self.assertEqual(response.status_code, 403) self.assert_in_response("You are not authorized to view this file.", response) self.logout()
def test_update_travis_yml_python_versions_drops_dist_trusty(monkeypatch): monkeypatch.setitem( XENIAL_SUPPORTED_PYPY_VERSIONS, 'pypy', 'pypy2.7-6.0.0') travis_yml = StringIO(textwrap.dedent("""\ language: python dist: trusty python: - 2.7 - pypy install: pip install -e . script: pytest tests """)) travis_yml.name = '.travis.yml' result = update_travis_yml_python_versions(travis_yml, v(["2.7", "3.7"])) assert "".join(result) == textwrap.dedent("""\ language: python python: - 2.7 - 3.7 - pypy2.7-6.0.0 install: pip install -e . script: pytest tests """)
def test_update_travis_yml_python_versions_matrix_preserve_quotes(): travis_yml = StringIO(textwrap.dedent("""\ language: python matrix: include: - python: "2.7" - python: "3.3" - language: c install: pip install tox script: tox -e py """)) travis_yml.name = '.travis.yml' result = update_travis_yml_python_versions(travis_yml, v(["3.8", "3.9"])) assert "".join(result) == textwrap.dedent("""\ language: python matrix: include: - python: "3.8" - python: "3.9" - language: c install: pip install tox script: tox -e py """)
def test_add_recipients_from_csv(self, end): user = self.login() mlist = MailingList.objects.create(user=user, name='ml01') url = reverse('emails__add_recipients_from_csv', args=(mlist.id,)) self.assertGET200(url) # TODO: it seems django validator does not manages address with unicode chars: # is it a problem # recipients = ['*****@*****.**', 'jet.blä[email protected]'] recipient1 = '*****@*****.**' recipient2 = '*****@*****.**' csvfile = StringIO(end.join([' ' + recipient1, recipient2 + ' ']) + ' ') csvfile.name = 'recipients.csv' # Django uses this self.assertNoFormError(self.client.post(url, data={'recipients': csvfile})) self.assertSetEqual( {recipient1, recipient2}, {r.address for r in mlist.emailrecipient_set.all()} ) csvfile.close()
def test_testgroup_set_group(self): # mostly to test the testing user = User.objects.get(username = '******') user2 = User.objects.create_user('user2', '*****@*****.**', 'demo') user2.mat_number = 22222 user2.groups.add(self.testgroup) user2.save() f = StringIO("11111\n33333") f.name="foo.txt" response = self.client.post( reverse('admin:import_matriculation_list', args=[self.testgroup.id]), { 'mat_number_file': f, 'remove_others' : True, 'create_users': True}, follow=True) self.assertContains(response, "2 users added to group test, 1 removed, 0 already in group. 1 new users created.") user3 = User.objects.get(mat_number = 33333) self.assertEqual(set( u.mat_number for u in User.objects.filter(groups = self.testgroup)), set( u.mat_number for u in [user, user3]))
def test_get_environments(self): parser = argparse.ArgumentParser() parser.add_argument('env') parser.add_argument('--user', default='', required=False) parser.add_argument('--option') args = parser.parse_args(['blah']) file = StringIO(u"[hubble]\n" "name=My name is ${FIRST} ${last}\n" "[prod-meta]\n" "meta=['name', 'place']\n" "[name]\n" "FIRST=Derrick\n" "last=Wippler\n") file.name = "test-config.ini" config = parse_configs([file], default_section='hubble') env = get_environments(args, 'name', config) self.assertIn('name', env[0]) self.assertEqual(env[0]['name'].value, 'My name is Derrick Wippler') self.assertIn('FIRST', env[0]) self.assertIn('last', env[0])
def test_update_appveyor_yml_leave_unknown_python_versions_alone(): appveyor_yml = StringIO( textwrap.dedent("""\ environment: matrix: - PYTHON: c:\\python27 - PYTHON: c:\\python36 - PYTHON: c:\\custompython """)) appveyor_yml.name = 'appveyor.yml' result = update_appveyor_yml_python_versions(appveyor_yml, v([ '3.6', '3.7', ])) assert result is not None assert ''.join(result) == textwrap.dedent("""\ environment: matrix: - PYTHON: c:\\python36 - PYTHON: c:\\python37 - PYTHON: c:\\custompython """)
def test_update_appveyor_yml_python_versions(): appveyor_yml = StringIO( textwrap.dedent(r""" environment: matrix: - PYTHON: "c:\\python27" - PYTHON: "c:\\python36" """).lstrip('\n')) appveyor_yml.name = 'appveyor.yml' result = update_appveyor_yml_python_versions(appveyor_yml, v([ '2.7', '3.7', '3.10', ])) assert result is not None assert ''.join(result) == textwrap.dedent(r""" environment: matrix: - PYTHON: "c:\\python27" - PYTHON: "c:\\python37" - PYTHON: "c:\\python310" """.lstrip('\n'))
def test_config_inventory_fail_script_noexec(netcfgbu_envars, tmpdir): """ Test the case where an [[inventory]] section defines a script, the script file exists, but the script file is not executable. """ fake_script = tmpdir.join("dummy-script.sh") fake_script.ensure() config_data = {"inventory": [{"name": "foo", "script": str(fake_script)}]} strio = StringIO() strio.name = "fake-file" toml.dump(config_data, strio) strio.seek(0) with pytest.raises(RuntimeError) as excinfo: load(fileio=strio) exc_errmsgs = excinfo.value.args[0].splitlines() found = first( [line for line in exc_errmsgs if "inventory.0.script" in line]) assert found assert "is not executable" in found
def test_with_thumbor_disabled(self) -> None: self.login(self.example_email("hamlet")) fp = StringIO("zulip!") fp.name = "zulip.jpeg" result = self.client_post("/json/user_uploads", {'file': fp}) self.assert_json_success(result) json = ujson.loads(result.content) self.assertIn("uri", json) uri = json["uri"] base = '/user_uploads/' self.assertEqual(base, uri[:len(base)]) quoted_uri = urllib.parse.quote(uri[1:], safe='') with self.settings(THUMBOR_URL=''): result = self.client_get("/thumbnail?url=%s&size=full" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) self.assertEqual(uri, result.url) uri = 'https://www.google.com/images/srpr/logo4w.png' quoted_uri = urllib.parse.quote(uri, safe='') with self.settings(THUMBOR_URL=''): result = self.client_get("/thumbnail?url=%s&size=full" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) self.assertEqual(uri, result.url) uri = 'http://www.google.com/images/srpr/logo4w.png' quoted_uri = urllib.parse.quote(uri, safe='') with self.settings(THUMBOR_URL=''): result = self.client_get("/thumbnail?url=%s&size=full" % (quoted_uri)) self.assertEqual(result.status_code, 302, result) base = 'https://external-content.zulipcdn.net/external_content/7b6552b60c635e41e8f6daeb36d88afc4eabde79/687474703a2f2f7777772e676f6f676c652e636f6d2f696d616765732f737270722f6c6f676f34772e706e67' self.assertEqual(base, result.url)
def __init__(self, stream): with create_session() as session: airflow_variables = { var.key: var.val for var in session.query(Variable) } self._root = os.path.split(stream.name)[0] ctx = { "env": os.environ, "airflow_variables": airflow_variables, "pytz": {name: getattr(pytz, name) for name in pytz.__all__}, "datetime": { name: getattr(datetime, name) for name in ["date", "datetime", "time", "timedelta", "tzinfo"] }, "re": {name: getattr(re, name) for name in re.__all__}, } # Enable Jinja2 in the yaml files yaml_stream = StringIO(Template(stream.read()).render(ctx)) yaml_stream.name = stream.name super().__init__(yaml_stream)