def test_step6(): """6. Remove suffix if it exists and isn't the whole string.""" assert check(["basename", "///a/b/owo.ext//", ".ext"]).stdout == "owo\n" assert check(["basename", "///a/b/owo.ext2//", ".ext"]).stdout == "owo.ext2\n" assert check(["basename", "///a/b/owo.ext", ".ext"]).stdout == "owo\n" assert check(["basename", "///a/b/owo.ex", ".ext"]).stdout == "owo.ex\n"
def test_dash_i(): lines = check(["env", "-i", "a=b", "c=d", "E=F G H I"]).stdout.split("\n") assert "a=b" in lines assert "c=d" in lines assert "E=F G H I" in lines # NOTE: This next test may be fragile, since it relies on a functioning `sh`. assert check(["env", "-i", "foo=bar", "sh", "-c", "echo ${foo}"]).stdout == "bar\n"
def test_step5(): """5. If there are remaining slash characters, remove everything up to and including the last slash.""" assert check(["basename", "/a/b/c/d/owo"]).stdout == "owo\n" # ! Potential edge case exercising steps 4+5 together. assert check(["basename", "/a/b/c/d/owo///"]).stdout == "owo\n" assert check(["basename", "///a/b/c/d/owo///"]).stdout == "owo\n"
def test_file(): """Passing file paths should read from file.""" path1 = Path("src/basename.c").resolve() lines = path1.read_text().splitlines() expected = "\n".join(lines[-10:]) + "\n" assert check(["tail", str(path1)]).stdout == expected expected = "\n".join(lines[-3:]) + "\n" assert check(["tail", "-n", "3", str(path1)]).stdout == expected expected = "\n".join(lines[3:]) + "\n" assert check(["tail", "-n", "+3", str(path1)]).stdout == expected
def test_f(tree): """Test with -f.""" data, a, b = tree ret = check(["rm", "-f", str(data)]) assert len(ret.stdout) == 0 assert len(ret.stderr) == 0 assert data.exists() assert a.exists() assert b.exists() ret = check(["rm", "-f", str(a)]) assert len(ret.stdout) == 0 assert len(ret.stderr) == 0
def test_absolute_paths(tmpdir_factory): """mkdir can create absolute paths""" data = Path(tmpdir_factory.mktemp("data")) a = data / "a" b = data / "b" / "b2" # c = data / "c" assert not a.exists() assert check(["mkdir", str(a)]) assert a.is_dir() assert not b.exists() assert check(["mkdir", "-p", str(b)]) assert b.is_dir()
def test_file_n11(): """Passing `-n 11` and file paths should read 11 lines from the files.""" path1 = Path("src/basename.c").resolve() path2 = Path("src/cal.c").resolve() path3 = Path("src/head.c").resolve() expected_path1 = "\n".join(path1.read_text().splitlines()[0:11]) + "\n" expected_path2 = "\n".join(path2.read_text().splitlines()[0:11]) + "\n" expected_path3 = "\n".join(path3.read_text().splitlines()[0:11]) + "\n" expected_all = \ f"==> {path1} <==\n" + expected_path1 + \ f"\n==> {path2} <==\n" + expected_path2 + \ f"\n==> {path3} <==\n" + expected_path3 assert check(["head", "-n", "11", str(path1)]).stdout == expected_path1 assert check(["head", "-n", "11", str(path1), str(path2), str(path3)]).stdout == expected_all
def test_relative_paths(tmpdir_factory): """mkdir can create relative paths.""" data = Path(tmpdir_factory.mktemp("data")) a = data / "a" b = data / "b" / "b2" # c = data / "c" with chdir(data): assert not a.exists() assert check(["mkdir", "a"]) assert a.is_dir() assert not b.exists() assert check(["mkdir", "-p", "b/b2"]) assert b.is_dir()
def check(self): if self.value is not None: return self.value self.value = check(self.fields) return self.value
def input(): if request.method == "POST": # upload gpx file and get name of uploaded file (could be different from original filename) file = request.files["gpx"] if check(file, app, "gpx"): gpxname = upload(file, app, "gpx") message = "" else: message = "Something went wrong. Please check if file extension was gpx" return render_template("input.html", message=message) # open and parse gpx file path = os.path.join(app.config["UPLOADED_GPXUPLOAD_DEST"], gpxname) gpxfile = open(path, "r") gpx = gpxpy.parse(gpxfile) trackdata = gpx.tracks[0].segments[0].points # calculate length length = 0 for i in range(len(trackdata)): if i == 0: pass else: length = length + haversine( trackdata[i - 1].longitude, trackdata[i - 1].latitude, trackdata[i].longitude, trackdata[i].latitude) length = round(length, 2) # data for save to database name = request.form.get("name") description = request.form.get("description") difficulty = request.form.get("difficulty") start = request.form.get("start") db.execute( "INSERT INTO hikes (name, desc, gpx, laenge, difficulty, start) VALUES (?,?,?,?,?,?)", name, description, gpxname, length, difficulty, start) return render_template("input.html")
def download(bot, update): try: try: text = update.callback_query.data update = update.callback_query except: text = update.message.text if not helpers.check(text): bot_msg = bot.send_message(chat_id=update.message.chat_id, text=usage_msg) time.sleep(20) bot.delete_message(chat_id=update.message.chat_id, message_id=bot_msg.message_id) else: sent_msg = bot.send_message(chat_id=update.message.chat_id, text=dwn_msg) url = helpers.get_url(text) vId = helpers.get_vId(url) sys.stdout.write("New song request client username %s\n" % update.message.chat.username) audio_info = downloader.download_audio(vId, url) bot.delete_message(chat_id=update.message.chat_id, message_id=sent_msg.message_id) try: bot.delete_message(chat_id=update.message.chat_id, message_id=update.message.message_id) except: pass if not audio_info["status"]: msg = "Something went wrong: %s" % audio_info["error"] return bot.send_message(chat_id=update.message.chat_id, text=msg) audio = open(audio_info["path"], 'rb') bot.send_audio(chat_id=update.message.chat_id, audio=audio, duration=audio_info["duration"], title=audio_info["title"], timeout=999) except: pass
def test_i(tree): """Test with -i, all negative responses.""" data, a, b = tree ret = check(["rm", "-i", str(a)], input="n\n") assert len(ret.stdout) == 0 assert len(ret.stderr) > 0 assert data.exists() assert a.exists() assert b.exists() ret = check(["rm", "-ri", str(a), str(b), str(data)], input="n\n") assert len(ret.stdout) == 0 assert len(ret.stderr) > 0 assert data.exists() assert a.exists() assert b.exists()
def test_main(): """Running `date` should print the current date, using the appropriate format string. TODO: The same tests, but UTC (with -u).""" # Default format string. assert check(["date"]).stdout == time.strftime("%a %b %e %H:%M:%S %Z %Y\n") assert len(check(["date"]).stderr) == 0 # Format string for ISO 8601. assert check(["date", "+%FT%TZ"]).stdout == time.strftime("%FT%TZ\n") assert len(check(["date", "+%FT%TZ"]).stderr) == 0 # Example without a leading + sign. assert len(check_fail(["date", "%H:%M:%S"]).stdout) == 0 assert "Invalid date string" in check_fail(["date", "%H:%M:%S"]).stderr
async def _add_role(self, ctx, *args): if not helpers.check(ctx): return print("Received command ADD ROLE from", ctx.message.author) if (len(args)) < 1: return guild: discord.Guild = ctx.guild await guild.create_role(name=args[0], color=discord.Color(0x000000))
def test_i3(tree): """Test with -i, mixed responses.""" data, a, b = tree ret = check(["rm", "-f", "-i", str(data), str(b)], input="n\ny\n") assert len(ret.stdout) == 0 assert len(ret.stderr) > 0 assert data.exists() assert a.exists() assert not b.exists()
def test_r__file(tree): """Test with -r.""" data, a, b = tree ret = check(["rm", "-r", str(a)]) assert len(ret.stdout) == 0 assert len(ret.stderr) == 0 assert data.exists() assert not a.exists() assert b.exists()
def test_main(): """Running `man PAGE` should print the contents of that file""" pages = [ "basename", "cal", "cat", "date", "dirname", "echo", "false", "ish", "man", "pwd", "true", "tty", "whoami", "yes" ] for page in pages: assert check(["man", page]).stdout == (Path("doc") / page).with_suffix(".rst").read_text()
async def _add(self, ctx, *args): if not helpers.check(ctx): return if len(args) <= 0: return print("Received command ADD from", ctx.message.author) sql_db.update_entry(helpers.conn, ctx.author.id, ctx.guild.id, float(args[0])) await ctx.send('Added balance of ' + str(args[0]) + ' to ' + str(helpers.disp_name(ctx.author)))
def test_main(): """Test that uname returns the correct values, and errors when appropriate.""" uname = os.uname() uname_smr = f"{uname.sysname} {uname.release} {uname.machine}\n" uname_a = f"{uname.sysname} {uname.nodename} {uname.release} {uname.version} {uname.machine}\n" assert check(["uname"]).stdout == uname.sysname + "\n" assert check(["uname", "-m"]).stdout == uname.machine + "\n" assert check(["uname", "-n"]).stdout == uname.nodename + "\n" assert check(["uname", "-r"]).stdout == uname.release + "\n" assert check(["uname", "-s"]).stdout == uname.sysname + "\n" assert check(["uname", "-v"]).stdout == uname.version + "\n" assert check(["uname", "-smr"]).stdout == uname_smr assert check(["uname", "-mnrsv"]).stdout == uname_a assert check(["uname", "-a"]).stdout == uname_a assert check_fail(["uname", "-x"]).stderr.startswith("uname: Invalid") assert check_fail(["uname", "x"]).stderr.startswith("uname: Invalid")
def test_no_flags(tree): """Test without -f, -i, or -r/-R.""" data, a, b = tree assert f"cannot remove '{data}': " in check_fail(["rm", str(data)]).stderr assert data.exists() assert a.exists() assert b.exists() ret = check(["rm", str(a)]) assert len(ret.stdout) == 0 assert len(ret.stderr) == 0
def test_main(tmpdir_factory): """Passing an existing filepath removes it.""" data = Path(tmpdir_factory.mktemp("data")) path = data / "file1.txt" text = "hello, world!" path.write_text(text) assert path.read_text() == text ret = check(["unlink", str(path)]) assert ret.stdout == "" assert ret.stderr == "" assert not path.exists()
def index(): if request.method == "POST": email = request.form.get("email") list = db.execute("SELECT * FROM email_list") for row in list: if email == row['email']: return redirect("/") if check(email) == True: db.execute("INSERT INTO email_list (name, email) VALUES (?,?)", request.form.get("name"), email) return render_template("subscribed.html") else: return render_template("notsubscribed.html") else: return render_template("index.html")
def test_main(tmpdir_factory): """Passing an existing filepath and non-existent filepath creates a link.""" data = Path(tmpdir_factory.mktemp("data")) file1 = data / "file1.txt" file2 = data / "file2.txt" text = "hello, world!" file1.write_text(text) assert file1.read_text() == text assert not file2.exists() ret = check(["link", str(file1), str(file2)]) assert ret.stdout == "" assert ret.stderr == "" assert file1.read_text() == text assert file2.read_text() == text
def share(): if request.method == "POST": email = request.form.get("email") story = request.form.get("story") storytype = request.form.get("type") name = request.form.get("name") if name == '': name = "Anonymous" if story != '' and check(email) == True and storytype != 'select': db.execute( "INSERT INTO stories (story, name, email, college, type) VALUES (?,?,?,?,?)", story, name, email, request.form.get("college"), storytype) return render_template("shared.html") else: return render_template("notshared.html") else: return render_template("share.html")
def test_main(): """Running `which <program>` should show the first instance of <program>. Adding -a should show all matching executables. Adding -s should return 0 if all <program>s were found, 1 otherwise.""" # One program, no -a, no -s. result = check(["which", "dir"]) assert result.stdout == str(Path("bin/dir").resolve()) + "\n" assert len(result.stderr) == 0 # One program, -a, no -s. result = check(["which", "-a", "env"]) lines = result.stdout.split("\n") assert str(Path("bin/env").resolve()) in lines assert "/usr/bin/env" in lines # One program, no -a, -s. result = check(["which", "-s", "env"]) assert len(result.stdout) == 0 assert len(result.stderr) == 0 # One program, -a, -s. result = check(["which", "-a", "-s", "env"]) assert len(result.stdout) == 0 assert len(result.stderr) == 0 # One program, -as result = check(["which", "-as", "env"]) assert len(result.stdout) == 0 assert len(result.stderr) == 0 # One program, -sa result = check(["which", "-sa", "env"]) assert len(result.stdout) == 0 assert len(result.stderr) == 0 # Four programs, no -a, no -s. result = check(["which", "dir", "cat", "echo", "which"]) lines = result.stdout.split("\n") assert str(Path("bin/dir").resolve()) in lines assert str(Path("bin/cat").resolve()) in lines assert str(Path("bin/echo").resolve()) in lines assert str(Path("bin/which").resolve()) in lines assert len(result.stderr) == 0
def newphoto(): tracklist, pointlist = get_tracks() if request.method == "POST": file = request.files["photo"] if check(file, app, "image"): picname = upload(file, app, "image") message = "" else: message = "Something went wrong. Please check if file extension was jpg, jpeg or png" allhikes = db.execute("SELECT name FROM hikes") return render_template("newphoto.html", allhikes=allhikes, message=message) # get info for db trackid = request.form.get("tracks") #trackid = db.execute("SELECT ID FROM hikes WHERE name=?", track) #picname = request.files["photo"].filename if request.form.get("lat") == "" or request.form.get("lon") == "": errormsg = "Please pick a location for your photo using right click!" return render_template("error.html", errormsg=errormsg) lat = request.form.get("lat") lon = request.form.get("lon") # write into pic table db.execute( "INSERT INTO pictures (track_id, pic_name, lat, lon) VALUES (?,?,?,?)", trackid, picname, lat, lon) # get info for GET method to reload page return render_template("newphoto.html", tracks=pointlist, tracklist=tracklist, message=message) else: # method = GET message = "" return render_template("newphoto.html", tracks=pointlist, tracklist=tracklist, message=message)
def test_main(tmpdir_factory): """Passing an existing, empty directory removes it.""" data = Path(tmpdir_factory.mktemp("data")) dir1 = data / "dir1" dir2 = data / "dir2" dir3 = data / "dir3" dir1.mkdir() dir2.mkdir() dir3.mkdir() assert dir1.is_dir() assert dir2.is_dir() assert dir3.is_dir() with chdir(data): ret = check(["rmdir", str(dir1), str(dir2)]) assert ret.stdout == "" assert ret.stderr == "" assert not dir1.exists() assert not dir2.exists() assert dir3.exists()
def main(): for entity in _generate_entities(): helpers.check(entity)
def test_print(): assert check(["env"], env={"a": "b", "FOO": "BAR"}).stdout == "a=b\nFOO=BAR\n"
def test_exec(): """Test that specifying a utility will run it.""" assert check(["env", "echo"]).stdout == "\n" assert check(["env", "echo", "hi"]).stdout == "hi\n" assert check(["env", "echo", "hello,", "world!"]).stdout == "hello, world!\n"
def main(): for url in URLS: main_obj = get_all_persons(url) for entity in get_entities(main_obj): helpers.check(entity)
def main(): main_obj = get_tables(_base_url) for entity in get_entities(main_obj): helpers.check(entity)
def main(): main_obj = get_all_persons(_DOMAIN) for entity in get_entities(main_obj): # helpers.emit(entity) helpers.check(entity)
def main(): for entity in _get_scrape_urls(): helpers.check(entity)
def main(): main_obj = get_all_persons(MAIN_URL) for entity in get_entities(main_obj): helpers.check(entity)