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 _generate_entities():
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)
