def test_fetch_account():
print('test that requests sends get request to verify user account')
r = Registrar()
r.email = '*****@*****.**'
requests.get = unittest.mock.MagicMock()
r.fetch_account()
requests.get.assert_called_once()
def test_set_email_valid(monkeypatch):
print('an email is set if one is passed')
test_email = '*****@*****.**'
monkeypatch.setattr('builtins.input', lambda: test_email)
r = Registrar()
r.set_email()
assert r.email == test_email
def test_create_account(monkeypatch):
print(
'test requests sends a post action to the endpoint for account creation'
)
r = Registrar()
r.is_registered = False
requests.post = unittest.mock.MagicMock()
r.create_account()
requests.post.assert_called_once()
def test_fetch_account_sets_is_registered(monkeypatch):
def mock_call(path=None):
return {'full_name': 'John Smith'}
monkeypatch.setattr(Util, 'res_to_json', mock_call)
r = Registrar()
r.fetch_account()
assert r.is_registered == True
assert r.name == mock_call()['full_name']
def run() -> None:
course_codes = []
courses_dict = {}
uci_registrar = Registrar()
for dept in uci_registrar:
for code, course_id, course_name, instructor, class_type in dept:
courses_dict[code] = [
course_id, course_name, instructor, class_type
]
course_codes.append(code)
uci_registrar.end_driver()
update_course_codes(course_codes)
update_course_info(courses_dict)
def startup(config_path=DEFAULT_SETTINGS_FILE):
#init logging
config = ConfigParser.ConfigParser()
config.read(config_path)
setup_logging(config)
#load the config file and start the listener, daemon
logging.debug('reading setting from: %s' % config_path)
#Load the plugin manager to get a handle to the plugins.
_plugin_manager = PluginManager(config)
locator = _plugin_manager.get_resource_locator()
datastore = _plugin_manager.get_datastore()
driver = _plugin_manager.get_driver()
_registrar = Registrar(datastore, driver)
#should the listener be started?
start_server = config.getboolean('DEFAULT', 'start_server')
if start_server:
server.set_registrar(registrar)
Thread.start(server.start())
#start looking for backends and updating the driver
#THIS CALL WILL NOT RETURN
daemon.start(_registrar, locator, config)
def build(self):
manager = ScreenManager()
manager.add_widget(Inicio(name='inicio'))
manager.add_widget(Login(name='login'))
manager.add_widget(Registrar(name='registrar'))
manager.add_widget(Connected(name='connected'))
return manager
class TestDogWalking(unittest.TestCase):
@classmethod
def setUpClass(self):
self.bob = User("Bob", "Roberts", "*****@*****.**", "bobbytables")
self.jane = User("Jane", "Jetson", "*****@*****.**", "janejetson")
# self.pickles = Dog("pickles", "Jack Russell")
# self.scheduler = Scheduler()
self.registrar = Registrar()
def test_user_can_register(self):
self.assertIsInstance(self.bob, User)
self.registrar.register_user(self.bob)
self.assertTrue(self.registrar.user_is_registered(self.bob))
def test_user_can_register_dog(self):
self.registrar.register_dog(self.bob, self.pickles)
self.assertIn(self.pickles, self.bob.get_dogs())
def test_user_can_set_available_walking_time(self):
self.scheduler.add_walk_time(self.pickles, "11:00a", "12:00p")
available_times = self.pickles.get_walk_times()
time_was_recorded = False
for time in available_times:
if time[1] == "11:00a" and time[2] == "12:00p":
time_was_recorded = True
self.assertTrue(time_was_recorded)
def test_user_can_select_dog_to_walk(self):
self.registrar.register_user(self.jane)
available_times = self.pickles.get_walk_times()
# [ (1, "11:00a", "12:00p", 1), (2, "4:00p", "6:00p", 1) ]
self.scheduler.schedule_walk(self.jane, available_times[0][0])
schedules = self.scheduler.get_user_schedule(self.jane)
# pk, user_id, time_id
# [ (1, 2, 1) ]
walk_is_scheduled = False
for time in schedules:
if time[2] == available_times[0][0]:
walk_is_scheduled = True
self.assertTrue(walk_is_scheduled)
from registrar import Registrar
if __name__ == '__main__':
Registrar()
def setUpClass(self):
self.bob = User("Bob", "Roberts", "*****@*****.**", "bobbytables")
self.jane = User("Jane", "Jetson", "*****@*****.**", "janejetson")
# self.pickles = Dog("pickles", "Jack Russell")
# self.scheduler = Scheduler()
self.registrar = Registrar()
import readline
import requests
import time
from registrar import Registrar
from offer_chooser import OfferChooser
from random_number_offer import RandomNumberOffer
from choose_number_offer import ChooseNumberOffer
readline.parse_and_bind('tab: complete')
readline.parse_and_bind('set editing-mode vi')
if __name__ == '__main__':
registrar = Registrar()
registrar.start()
if not registrar.quit:
offer_chooser = OfferChooser(registrar.name)
offer_chooser.start()
if offer_chooser.option == 'random_number':
offer_type = RandomNumberOffer(registrar, offer_chooser.zip_code)
offer_type.start()
if offer_chooser.option == 'select_number':
offer_type = ChooseNumberOffer(registrar.email)
offer_type.start()
def test_set_name(monkeypatch):
test_name = 'John Smith'
monkeypatch.setattr('builtins.input', lambda: test_name)
r = Registrar()
r.set_name()
assert r.name == test_name
def test_parent_class():
print('class inherits from NetworkingBase')
r = Registrar()
assert r.__class__.__base__ == NetworkingBase