def GET(self, request):
"""
Get a particular page.
The handler will take anything after the base address and look for it
in the pages folder. This folder is stored in the :mod:`config` module
at::
config.getSettings("server")["pagedir"]
If a file is not found the handler will assume the address is a
directory and try to serve the file index.html from it.
:returns: The requested file.
:raises: :exc:`restlite.Status` 400 if the path contains ".."
:exc:`restlite.Status` 404 if the file is not found.
"""
authentication.login(request)
if '..' in request['PATH_INFO']:
raise restlite.Status, '400 Invalid Path'
page_file = os.path.join(
config.getSettings("global")["basedir"],
config.getSettings("server")["pagedir"],
request['PATH_INFO']
)
try:
return request.response(self.getPage(page_file), self.getType(page_file))
except restlite.Status:
index_page = os.path.join(page_file, 'index.html')
return request.response(self.getPage(index_page), 'text/html')
def GET(self, request):
"""
Get setting data from the :mod:`config`.
Parameters are expected to be part of the query string.
If the base of this address handler is called:
:returns: A list of sections in the :mod:`config`
:rtype: ``list``
If anything more than the base of this handler is called then the
excess is assumed to be a section name and:
:returns: A JSON representation of that particular section of the
:mod:`config`.
:rtype: ``json``
:raises: :exc:`restlite.Status` 404 if the section does not exist.
"""
authentication.login(request)
section = getSection(request['PATH_INFO'])
if section:
settings = config.getSettings(section, False)
if settings is None:
raise restlite.Status, "404 Not Found"
else:
return request.response(settings)
else:
return request.response(config.getSections())
def POST(request,entity):
authentication.login(request)
groups = config.getSettings("groups")
fields = parseMultipart(request, entity)
if fields is None:
raise restlite.Status, "400 Invalid SUE POST request - need parameters"
# Try to find what we should label the component
component_name = fields.getfirst("component_name")
if not component_name:
raise restlite.Status, "400 Must give the SUE component a name"
# Try to get the SUE component
try:
component_f = fields['component_file']
except KeyError:
raise restlite.Status, "400 Must provide a file when specifying a SUE component"
if component_f.file:
component = component_f.file.read()
saveSueComponent(component_name, component)
else:
raise restlite.Status, "400 The supplied \"component_file\" was not a file"
return request.response("", "text/plain")
def POST(request, entity):
authentication.login(request)
fields = parseMultipart(request, entity)
if fields is None:
raise restlite.Status, "400 Invalid Request"
# Try to pull a name
wkldname = fields.getfirst("wkld_name")
if not wkldname:
raise restlite.Status, "400 No Workload Name"
# Uncomment below to ban editing old workloads
#elif wkldname in config.getSettings("workloads")["defs"]:
# raise restlite.Status, "403 Name Reuse Forbidden"
# Try to get text for the workload
wkld = fields.getfirst("wkld_text")
if wkld is None:
# Couldn't so try to get text from file
try:
wkld_f = fields['wkld_file']
if wkld_f.file:
wkld = wkld_f.file.read()
except KeyError: pass
# Still couldn't get text
if wkld is None:
raise restlite.Status, "400 No Workload Supplied"
saveWorkload(wkldname, wkld)
return request.response("", "text/plain")
def POST(request,entity):
authentication.login(request)
existing_groups = config.getSettings("groups")
group_name = request['PATH_INFO']
args = urlparse.parse_qs(entity)
g_data = _getGroupDataFromArgs(args)
if group_name in existing_groups:
if "size" in g_data and g_data["size"] == 0:
# Delete the group
del existing_groups[group_name]
else:
existing_groups[group_name].update(g_data)
else:
# New group
n_group = __newGroup()
n_group["name"] = group_name
n_group.update(g_data)
if n_group["size"] != 0:
existing_groups[group_name] = n_group
#print config.getSettings
try:
return request.response(existing_groups[group_name])
except KeyError:
return request.response({"name":group_name, "size":0})
def POST(self, request, entity):
"""
Create a new or update an existing workload.
Anything requested after the base address of this handler is assumed to
be the workload name. This is expected to be called at the base address
of this handler with multipart form data encoding.
:param wkld_name: The name of the workload being modified.
:type wkld_name: ``str``
:param wkld_file: The workload file being uploaded.
:type wkld_file: As POSTed from a HTML file upload form.
:param wkld_text: Actual text for the workload being uploaded.
:type wkld_text: ``str``
Only one of ``wkld_file`` or ``wkld_text`` have to be given. If both are
received then the text will take priority.
:returns: The name of the modifed workload.
:raises: :exc:`restlite.Status` 400 if the entity could not be parsed.
:exc:`restlite.Status` 403 if editing of workload is not
permitted and you have tried to reuse a name.
:exc:`restlite.Status` 400 if valid workload content could
not be found.
"""
authentication.login(request)
fields = parseMultipart(request, entity)
if fields is None:
raise restlite.Status, "400 Invalid Request"
# Try to pull a name
wkldname = fields.getfirst("wkld_name")
if not wkldname:
raise restlite.Status, "400 No Workload Name"
# Uncomment below to ban editing old workloads
#elif wkldname in config.getSettings("workloads")["defs"]:
# raise restlite.Status, "403 Name Reuse Forbidden"
# Try to get text for the workload
wkld = fields.getfirst("wkld_text")
if wkld is None:
# Couldn't so try to get text from file
try:
wkld_f = fields['wkld_file']
if wkld_f.file:
wkld = wkld_f.file.read()
except KeyError: pass
# Still couldn't get text
if wkld is None:
raise restlite.Status, "400 No Workload Supplied"
saveWorkload(wkldname, wkld)
return request.response(wkldname, "text/html")
def POST(request, entity):
authentication.login(request)
section = getSection(request['PATH_INFO'])
# Uncomment below to disallow editing of new sections
#if not section:
# raise restlite.Status, '403 New Section Forbidden'
# Grab arguments
import urlparse
parsed = urlparse.parse_qs(entity, True) # Null value is kept as ''
used_names = [] # Names used
new_qs = {} # Values to add
rem_qs = [] # Values to delete
for key in parsed:
# Grab name and extension
name, ext = splitName(key)
# If name already used, ignore
if name in used_names:
continue
# If theres no extension ignore
if ext is None:
continue
# If there is no value at all, skip
if parsed[key] == []:
continue
# Otherwise take first value
q = parsed[key][0]
# If up for deletion
if ext is 'r':
# Check used_names here as we use key when deleting
# Or parsed name otherwise below
rem_qs += [name]
used_names += [name]
# Adding value
else:
# Try to convert to the correct format
func = funcFor(ext)
if func is None:
raise restlite.Status, "400 Invalid Action"
try:
q = func(q)
except:
raise restlite.Status, "400 Invalid Format"
new_qs[name] = q
used_names += [name]
# All settings are good to go
settings = config.getSettings(section)
# Add all new settings
settings.update(new_qs)
# Delete all new deletions
for key in rem_qs:
try:
del settings[key]
except KeyError: pass
# Make it permanent
config.saveConfig()
return request.response(settings)
def POST(request,entity):
authentication.login(request)
os_call_to_vazels = vazelsmanager.stopVazels()
if os_call_to_vazels is True :
return request.response("")
else :
raise restlite.Status("500 "+str(os_call_to_vazels))
def GET(request):
authentication.login(request)
runningState = vazelsmanager.vazelsRunning()
if runningState is True:
return request.response({"control_centre_status": "running"})
elif runningState is False:
return request.response({"control_centre_status": "ready"})
else:
return request.response({"control_centre_status": runningState})
def POST(request, entity):
authentication.login(request)
os_call_to_vazels = vazelsmanager.runVazels()
if os_call_to_vazels :
# Need to upadate client to handle 204 as a successful response
return request.response("")
else :
raise restlite.Status("500 Vazels Control Centre failed to start")
def GET(request):
authentication.login(request)
section = getSection(request['PATH_INFO'])
if section:
settings = config.getSettings(section, False)
if settings is None:
raise restlite.Status, "404 Not Found"
else:
return request.response(settings)
else:
return request.response(config.getSections())
def GET(request):
authentication.login(request)
# To find info on a group call /groups/groupName
group_name = request['PATH_INFO']
try:
group_settings = config.getSettings("groups",True)[group_name]
return request.response(group_settings)
# Return 404 if they use an invalid group name
except KeyError:
raise restlite.Status, "404 Group Not Found"
def GET(self, request):
"""
Check if the server is alive.
:returns: Code \"200 OK\" if alive.
Obviously if the server is down it will not respond.
"""
authentication.login(request)
return restlite.response("")
def cookie(self):
request_cookie = cherrypy.request.cookie
cookie_val = request_cookie.get(COOKIE_NAME).value.split('|')
if len(cookie_val) == 2:
username, cookie_id = cookie_val
user = UserDao.get_user(username)
if user.get('cookie_id') and user.get('cookie_expire'):
if user['cookie_id'] == cookie_id and datetime_to_unix(user.get('cookie_expire')) > time.time():
authentication.login(cherrypy.session, user)
return OkResponse('ok')
return ConflictResponse('error')
def GET(self, request):
"""
Get the list of groups on the server.
:returns: A list of groups.
:rtype: ``list``
"""
authentication.login(request)
group_data = config.getSettings("groups").keys()
return request.response(group_data)
def POST(self, request, entity):
"""
Create a new or edit an existing group.
The group name is taken to be anything in the requested path after
the base address of the handler.
Parameters are expected to be part of the POST entity.
:param size: Group size.
:type size: ``int``
:param workloads: Can be included any number of times, each should be
the name of an attached workload.
:type workloads: ``str``
:param filters: Can be included any number of times, each should be a
mapping restriction.
:type filters: ``str``
:returns: JSON representation of the new state of the group.
:rtype: ``dict``
:raises: :exc:`restlite.Status` 400 if the size is invalid.
:exc:`restlite.Status` 400 unrecognised parameters are
included.
"""
authentication.login(request)
existing_groups = config.getSettings("groups")
group_name = request['PATH_INFO']
args = urlparse.parse_qs(entity)
g_data = _getGroupDataFromArgs(args)
if group_name in existing_groups:
if "size" in g_data and g_data["size"] == 0:
# Delete the group
del existing_groups[group_name]
else:
existing_groups[group_name].update(g_data)
else:
# New group
n_group = Group(group_name)
n_group.update(g_data)
if n_group["size"] != 0:
existing_groups[group_name] = n_group
try:
return request.response(existing_groups[group_name])
except KeyError:
return request.response({"name":group_name, "size":0})
def GET(request):
authentication.login(request)
if ".." in request["PATH_INFO"]:
raise restlite.Status, "400 Invalid Path"
page_file = os.path.join(
config.getSettings("global")["basedir"], config.getSettings("server")["pagedir"], request["PATH_INFO"]
)
try:
return request.response(getPage(page_file), getType(page_file))
except restlite.Status:
index_page = os.path.join(page_file, "index.html")
return request.response(getPage(index_page), "text/html")
def GET(request):
authentication.login(request)
groups = config.getSettings("groups")
#component_info = {}
# For each component, build a list of groups to which it is assigned.
#for component_name in config.getSettings("SUE")["defs"]:
# assigned_groups = []
# for group in groups:
# if component_name in groups[group]["sue_components"]:
# assigned_groups.append(group)
# component_info[component_name] = assigned_groups
#return request.response(component_info)
return request.response(config.getSettings("SUE")["defs"].keys(), 'text/html')
def index():
if 'username' in session:
# If there is a next request use that. See issue #76
if 'next' in request.args:
response = redirect(request.values.get('next', ''))
return response
response = redirect(url_for('worksheet_listing.home', username=session['username']))
if 'remember' in request.args:
response.set_cookie('nb_session_%s'%g.notebook.port,
expires=(time.time() + 60 * 60 * 24 * 14))
else:
response.set_cookie('nb_session_%s'%g.notebook.port)
response.set_cookie('cookie_test_%s'%g.notebook.port, expires=1)
return response
from authentication import login
if current_app.startup_token is not None and 'startup_token' in request.args:
if request.args['startup_token'] == current_app.startup_token:
g.username = session['username'] = '******'
session.modified = True
current_app.startup_token = None
return index()
return login()
def index():
if 'username' in session:
# If there is a next request use that. See issue #76
if 'next' in request.args:
response = redirect(request.values.get('next', ''))
return response
response = redirect(url_for('worksheet_listing.home', username=session['username']))
if 'remember' in request.args:
response.set_cookie('nb_session_%s'%g.notebook.port,
expires=(time.time() + 60 * 60 * 24 * 14))
else:
response.set_cookie('nb_session_%s'%g.notebook.port)
response.set_cookie('cookie_test_%s'%g.notebook.port, expires=1)
return response
from authentication import login
if current_app.startup_token is not None and 'startup_token' in request.args:
if request.args['startup_token'] == current_app.startup_token:
g.username = session['username'] = '******'
session.modified = True
current_app.startup_token = None
return index()
return login()
def GET(self, request):
"""
Get either the list of actors or actor details.
If the base address of the handler is requested:
:returns: List of actors on the server.
If the base / actorname is requested:
:returns: JSON representation of the actor called actorname
:raises: :exc:`restlite.Status` 404 if the actor does not exist.
If the base / actorname.tar.gz is requested:
:returns: The contents of the actor file.
:raises: :exc:`restlite.Status` 404 if the actor does not exist.
:exc:`restlite.Status` 410 if the actor exists but the
file is missing.
:exc:`restlite.Status` 500 if the actor file could not
be read.
"""
authentication.login(request)
actor = request['PATH_INFO']
namemap = config.getSettings("actors")["defs"]
# Asking for names of actors
if not actor:
return request.response(namemap.keys())
# Asking for the file
if actor.endswith(".tar.gz"):
actorname = actor[:len(actor)-len(".tar.gz")]
return self.showActorFile(request, actorname)
# Asking for the actor info
if actor not in namemap:
raise restlite.Status, "404 Not Found"
actordata = namemap[actor].copy()
del actordata['file']
return request.response(actordata)
def POST(request, entity):
authentication.login(request)
import urlparse
args = urlparse.parse_qs(entity, True)
# Only accept a single value for any parameter
for key in args:
if len(args[key]) > 1:
raise restlite.Status, "400 Duplicate Arguments"
args[key] = args[key][0]
# Check for action
if "do" not in args:
raise restlite.Status, "400 Missing Action"
# Check for workload
if "workload" not in args:
raise restlite.Status, "400 Missing Workload"
# Check for actor
if "actor" not in args:
raise restlite.Status, "400 Missing Actor"
do = args["do"].lower()
workload = args["workload"]
actor = args["actor"]
# Validate workload
if workload not in config.getSettings("workloads")["defs"]:
raise restlite.Status, "404 Workload Not Found"
# Validate actor
if actor not in config.getSettings("actors")["defs"]:
raise restlite.Status, "404 Actor Not Found (" + actor + ")"
workload = config.getSettings("workloads")["defs"][workload]
try:
{"add": addActor, "rem": remActor}[do](workload, actor)
except KeyError:
raise restlite.Status, "400 Invalid Action"
config.saveConfig()
return request.response(workload)
def GET(self, request):
"""
Get the status of the vazels control centre.
:returns: The current control centre status, either
* ``"{'control_centre_status': 'running'}"``
* ``"{'control_centre_status': 'ready'}"``
* ``"{'control_centre_status': <somethingelse>}"``
where ``<somethingelse>`` is a return value of
:func:`vazelsmanager.vazelsRunning()`
"""
authentication.login(request)
return request.response({"control_centre_status": commandclient.vazelsPhase()})
def GET(self, request):
"""
Grab the latest output from the vazels experiment.
.. todo:: Make this POST!
.. todo:: Allow 204 as success in the client.
:raises: :exc:`restlite.Status` 400 if we could not start to
retrieve data.
"""
authentication.login(request)
if commandclient.getalloutput():
return request.response("")
else:
raise restlite.Status, "400 Failed to get output from Vazels - don't call this before starting the Control Center"
def POST(self, request, entity):
"""
Try to start a vazels experiment.
.. todo:: Make this POST!
.. todo:: Allow 204 as success in the client.
:raises: :exc:`restlite.Status` 400 if the attempt to start an
experiment failed immediately.
"""
authentication.login(request)
if commandclient.startexperiment():
return request.response("")
else:
raise restlite.Status, "400 Failed to start experiment - don't call this before starting the Control Center"
def POST(self, request, entity):
"""
Stop the control centre.
:raises: :exc:`restlite.Status` 500 if something went immediately
wrong while stopping the control centre.
.. todo:: Update client to handle 204 as a successful response.
Then we dont have to send 200 with a blank response.
"""
authentication.login(request)
if commandclient.stopVazels():
return request.response("")
else :
raise restlite.Status("500 Cannot Stop Non Running Control Centre")
def GET(self, request):
"""
Update the groups with host statuses.
.. todo:: Make this POST!
.. todo:: Allow 204 as success in the client.
:raises: :exc:`restlite.Status` 400 if we cannot initiate an attempt
to update.
"""
authentication.login(request)
if commandclient.updateStatuses():
return request.response("")
else:
raise restlite.Status, "400 Failed to send getallstatus request - don't call this before starting the Control Center"
def POST(self, request, entity):
"""
Start the control centre.
:raises: :exc:`restlite.Status` 500 if something went immediately
wrong while starting the control centre.
.. todo:: Update client to handle 204 as a successful response.
Then we dont have to send 200 with a blank response.
"""
authentication.login(request)
if not controlcentre.startVazels():
raise restlite.Status("500 Vazels Control Centre failed to start")
vazelsintegration.setupWhenReady()
return request.response("")
def auth():
username = request.form.get('username')
password = request.form.get('password')
is_successful, user = authentication.login(username, password)
app.logger.info('%s', is_successful)
if (is_successful):
session["user"] = user
return redirect('/')
else:
return render_template('login.html', error=True)
def GET(request):
authentication.login(request)
# We want the proper experiment path that vazelsmanager tells us
exp_dir = vazelsmanager.getExperimentPath()
path = os.path.join(exp_dir,"Output_Folder")
# Make a temporary file, fill it with the Output_Folder's contents.
with tempfile.SpooledTemporaryFile(1024) as temp:
tar = tarfile.open(fileobj=temp, mode="w:gz")
tar.add(name=path, arcname="Output_Folder")
tar.close()
temp.seek(0)
return_data = temp.read()
return request.response(return_data, "application/x-gzip")
raise restlite.Status, "500 Could Not Serve Data File"
def auth():
# replace with request.form in deployment
username = request.values["username"]
password = request.values["password"]
if authentication.login(username, password):
session['authenticated'] = True
session['username'] = username.lower()
return jsonify({"success": True, "username": username})
else:
return jsonify({"success": False})
def login():
if(request.method == "POST"):
success = authentication.login(server.usersCSVReader, request.form["username"], request.form["password"]) # Pass form information to authentication module
if (success):
userString = authentication.user_role.title()+"("+request.form["username"]+")"
server.user = eval(userString) # Create a User() object based on read-in role
coursesToUser(server.enrolmentsCSVReader, server.coursesCSVReader, server.user) # Load the course objects and survey forms associated to user
return redirect(url_for("landing"))
else:
flash("Incorrect Username or Password")
return render_template("login.html")
def auth():
username = request.form.get('username')
password = request.form.get('password')
is_successful, user = authentication.login(username, password)
app.logger.info('%s', is_successful)
if (is_successful):
session["user"] = user
return redirect('/')
else:
return "Invalid username or password please <a href='/login'>enter again</a>"
def GET(self, request):
"""
Grab the experiment output data.
:returns: JSON representation of the experiment output data.
:rtype: ``json``
:raises: :exc:`restlite.Status` 500 if the output could not be parsed.
"""
authentication.login(request)
# We want the proper experiment path that vazelsmanager tells us
exp_dir = controlcentre.getExperimentPath()
path = os.path.join(exp_dir,"Output_Folder")
parsed = pbparser.scan_output(path)
# If the parsing broke in any way we get back None
if parsed is None:
raise restlite.Status, "500 Could Not Read Output Data"
return request.response(parsed)
def auth():
username = request.form.get('username')
password = request.form.get('password')
is_successful, user = authentication.login(username, password)
app.logger.info('%s', is_successful)
if (is_successful):
session["user"] = user
return redirect('/')
else:
flash("Invalid username or password. Please try again.")
return redirect('/login')
def GET(request):
authentication.login(request)
actor = request['PATH_INFO']
namemap = config.getSettings("actors")["defs"]
# Asking for names of actors
if not actor:
return request.response(namemap.keys())
# Asking for the file
if actor.endswith(".tar.gz"):
actorname = actor[:len(actor)-len(".tar.gz")]
return showActorFile(request, actorname)
# Asking for the actor info
if actor not in namemap:
raise restlite.Status, "404 Not Found"
actordata = namemap[actor].copy()
del actordata['file']
return request.response(actordata)
def login():
if request.method == 'GET':
return render_template('login.html')
elif request.method == 'POST':
json_data = request.form
email = json_data.get('email')
password = json_data.get('password')
status = authentication.login(email, password)
if status:
session['logged_in'] = True
session['user'] = email
return redirect(url_for('main'))
else:
# TODO: Give message that login was incorrect
return redirect(url_for('login'))
def create_or_login(resp):
username = sanitize_openid(resp.identity_url)
if g.notebook.user_manager().user_exists(username):
session['username'] = g.username = username
session.modified = True
else:
from sagenb.notebook.user import User
new_user = User(username, '', email = resp.email, account_type='user')
try:
g.notebook.user_manager().add_user_object(new_user)
session['username'] = g.username = username
session.modified = True
except ValueError:
#add creation_error=True to the render dict somehow
from authentication import login
return login({'creation_error': True})
return redirect(request.values.get('next', url_for('base.index')))
def login():
if (request.method == "POST"):
if (request.form["bt"] == "login"):
# Pass form information to the authentication module.
success = authentication.login(request.form["username"],
request.form["password"])
if (success != 0 and success != -1):
# Create a User() object based on the read-in role.
server.user = success
return redirect(url_for("landing"))
elif (success == 0):
flash("Account Still Pending Approval")
else:
flash("Incorrect Username or Password")
if (request.form["bt"] == "requestaccess"):
return redirect(url_for("requestAccess"))
return render_template("login.html")
print("\n")
print(" HTTP Status Code - " + r.status_code)
d_sync_smartaccount_error_message = json.loads(r.content.decode('utf8'))
print(json.dumps(d_sync_smartaccount_error_message, indent=2, sort_keys=True))
exit()
d_sync_smart_account_status = json.loads(r.content.decode('utf8'))
for s_vss in d_sync_smart_account_status['data']:
if 'Success' in s_vss['status'] or 'Fail' in s_vss['status']:
c_tasks_status += 1
os.system("clear")
l_status_char_len = []
l_status_char_len.append(len(s_vss['action']))
l_status_char_len.append(len(s_vss['currentActivity']))
l_status_char_len.append(len(s_vss['status']))
l_status_char_len = sorted(l_status_char_len, reverse=True)
print(2 * '\n')
print(' ========= ', l_status_char_len[0] * '=')
print(' action: ', s_vss['action'])
print(' activity: ', s_vss['currentActivity'])
print(' status: ', s_vss['status'])
print(' ========= ', l_status_char_len[0] * '=')
del l_status_char_len[:]
print("\n")
# --- main menu --- #
os.system("clear")
if __name__ == "__main__":
gs_session, gd_conf = authentication.login()
smart_account_sync_vmanage_with_cisco__sync_smart_account(gs_session, gd_conf)
def test_login_bad_creds(self, mock_open):
# wrong arguments
mock_open.return_value.read.return_value = \
'netease|password'
self.assertFalse(auth.login('netease', 'badpassword'))
def test_login_error(self, mock_open):
# exceptions
mock_open.side_effect = IOError()
self.assertFalse(auth.login('netease', 'badpassword'))
def test_login(self, mock_open):
# correct arguments
mock_open.return_value.read.read_value = \
'netease|password\n'
self.assertTrue(auth.login('netease', 'password'))
def test_login1():
result = authentication.login('ABC','1234')
assert result =={'result': True,'message': "authentication failed, password incorrect."}
def test_login():
result = authentication.login('ABC','123')
assert result =={'result': True,'message': "User is successfully login."}
import authentication as a
input_id = input("Please insert your ID. \n아이디를 입력해주세요. \n")
if a.login(input_id):
print('Welcome ' + input_id + "\n")
input_pw = input("password: "******"Wrong login ID or password, please check")
#Version 3
# input_id = input("Please insert your ID. \n아이디를 입력해주세요. \n")
# def login(_id):
# members = ['mdoubleu', 'egoing', 'flamewndls']
# for member in members:
# if member == _id:
# return True
# return False
# if login(input_id): #since the function "login" is already a boolean type, we can directly use in the if/else
# print ('Welcome, ' + input_id)
# else:
# print("Wrong login ID or password, please check")
#Version 2
# input_id = input("아이디를 입력해주세요.\n")
# members = ['mdoubleu', 'egoing', 'flamewndls']
#
# for member in members:
# if member == input_id:
# print("Welcome!, " + member)
# import sys
# sys.exit()
print("4. Install Requirements")
print("5. Check for updates\n")
print("0. Exit\n")
choice = input("> ").lower().strip()
if choice == "1": # TODO catch KeyboardInterrupt at search
series = search(
) # BUG Searching for 'one punc' causes a keyerror when reading the 'data' key
if series != None:
download(series)
wait()
elif choice == "2":
clear_screen()
clear_downloads()
wait()
elif choice == "3": # TODO add a printout that tells the user who is currently logged in
clear_screen()
login()
wait()
elif choice == "4":
# installReqs()
print("Not implemented")
wait()
elif choice == "5":
# update()
print("Not implemented")
wait()
elif choice == "0":
exit()
def test_login_error(self, mock_open):
"""Test the login function when an error happens."""
mock_open.side_effect = IOError()
self.assertFalse(auth.login('george', 'bosco'))
def test_login_bad_creds(self, mock_open):
"""Test the login function when bad creds are passed."""
mock_open.return_value.read.return_value = "george|bosco"
self.assertFalse(auth.login('george', 'marbleRye'))
def test_login_success(self, mock_open):
"""Test the login function when things go right."""
mock_open.return_value.read.return_value = "george|bosco"
self.assertTrue(auth.login('george', 'bosco'))
import logging
import authentication as auth
import configuration as config
# logging config
logging.basicConfig(format='%(levelname)s: main.py %(message)s',
level=config.LOGGING_LEVEL)
if __name__ == "__main__":
# create auth obj
auth = auth.Authentication()
# login
auth.login()
# logout
auth.logout()
