def check(bot, update):
model = Model()
if model.check_is_exist_chat_id(update.message.chat_id):
starter = Starter()
starter.start(parameters=['-silent', '-report'], send_to=update.message.chat_id)
else:
bot.sendMessage(chat_id=update.message.chat_id, text="Тебя тут не ждали...")
def executer(self, args):
print('''Serveur PyUPnP ({})
'''.format(helper.VERSION))
s = Starter()
s.parametrer(**vars(args))
s.executer()
def setUp(self):
self.mock_config = MagicMock(config.Config)
self.mock_config.indexer_delay.return_value = 999
self.mock_config.usb_mount_points.return_value = ['/media']
self.mock_config.usb_devices_to_ignore.return_value = ['ignore-me']
self.mock_scheduler = MagicMock(spec=sched.scheduler)
self.mock_mtp_device = MagicMock(spec=mtp_device.MTPDevice)
self.mock_usb_device_manager = MagicMock(spec=usb_device_manager.USBDeviceManager)
self.mock_usb_device_manager.get_devices_to_index.return_value = [('/media/dev1', 'dev1'),
('/media/dev2', 'dev2')]
self.mock_usb_device = MagicMock(spec=usb_device.USBDevice)
self.mock_indexer = MagicMock(spec=indexer.Indexer)
self.test_model = Starter(self.mock_config, self.mock_scheduler, self.mock_mtp_device,
self.mock_usb_device_manager, self.mock_usb_device, self.mock_indexer)
class Learner(Cmd):
prompt = "learnBash>"
intro = "let's learnBash"
courses = Starter([BasicCourse])
def __init__(self):
Cmd.__init__(self)
# Operations
def learn(self):
self.cmdloop()
# need to wipe out cmdqueue to ignore cmd line args
def preloop(self):
self.cmdqueue = []
# Commands
def do_quit(self, line):
"""Quit learnBash"""
print("Quitting.")
return True
def do_courses(self, line):
"""List available courses"""
print("Available courses:")
print("\n".join(self.courses.names()))
def do_start(self, line):
"""Start a course"""
if not self.courses.start(line):
print("No such course!")
def complete_start(self, text, line, begidx, endidx):
return self.courses.matching(text)
class Course(Cmd):
name = "GenericCourse"
lessons = Starter([])
def __init__(self):
Cmd.__init__(self)
self.prompt = "{}>".format(self.name)
self.intro = "Starting {}".format(self.name)
def start(self):
self.cmdloop()
# need to wipe out cmdqueue to ignore cmd line args
def preloop(self):
self.cmdqueue = []
def do_hello(self, line):
print("Course says hello")
def do_quit(self, line):
print("Quitting course: {}".format(self.name))
return True
def do_lessons(self, line):
"""List lessons in course"""
for pos, name in enumerate(self.lessons.names(), start=1):
print("{}. {}".format(pos, name))
def do_start(self, line):
if not self.lessons.start(line):
print("No such lesson!")
def complete_start(self, text, line, begidx, endidx):
return self.lessons.matching(text)
def test_day():
input = Starter(2018, 1).read_from_input_file()
if test_solution1(input):
test_solution2(input)
class BasicCourse(Course):
name = "BasicCourse"
lessons = Starter([EchoLesson])
def test_foo():
s = Starter()
result = s.foo()
assert 'foo' == result
def test_baz():
s = Starter()
result = s._baz('banana')
assert 'baz' == result
def test_bar():
s = Starter()
result = s.bar()
assert 'bar' == result
def __init__(self):
self.__starter = Starter()
self.__monitor = Monitor()
self.__register_url_rules()
class RemoteStartAPI:
app = Flask(__name__)
def __init__(self):
self.__starter = Starter()
self.__monitor = Monitor()
self.__register_url_rules()
def __register_url_rules(self):
self.app.add_url_rule("/", "hello", self.root)
self.app.add_url_rule("/ignition_on", "ignition_on", self.ignition_on)
self.app.add_url_rule("/ignition_off", "ignition_off", self.ignition_off)
self.app.add_url_rule("/doors_open", "doors_open", self.doors_open)
self.app.add_url_rule("/doors_close", "doors_close", self.doors_close)
self.app.add_url_rule("/neutral_gear", "neutral_gear", self.neutral_gear)
self.app.add_url_rule("/engine_start", "engine_start", self.engine_start)
self.app.add_url_rule("/speed", "speed", self.speed)
self.app.add_url_rule("/rpm", "rpm", self.rpm)
@staticmethod
def root():
return "Rzabol says hello."
@staticmethod
def run_with_connection_error_check(f, *args, **kwargs):
try:
return f(*args, **kwargs), 200
except ConnectionError as e:
return {"Error": str(e)}, 500
def ignition_on(self):
return self.run_with_connection_error_check(self.__starter.ignition_on)
def ignition_off(self):
return self.run_with_connection_error_check(self.__starter.ignition_off)
def doors_open(self):
return self.run_with_connection_error_check(self.__starter.doors_open)
def doors_close(self):
return self.run_with_connection_error_check(self.__starter.doors_close)
def neutral_gear(self):
try:
neutral = self.__starter.is_on_neutral_gear()
return {"Neutral": bool(neutral)}
except ConnectionError as e:
return {"Error": str(e)}, 500
def engine_start(self):
time = request.args.get("time", None)
try:
if time is not None:
self.__starter.engine_start(time)
else:
self.__starter.engine_start()
except ConnectionError as e:
return {"Error": str(e)}, 500
except OnGearError:
return {"Error": "Car is on gear!"}, 409
else:
return
def speed(self):
return {"speed": self.__monitor.get_speed()}
def rpm(self):
return {"rpm": self.__monitor.get_rpm()}
def run(self):
self.app.run()
def __del__(self):
self.__monitor.close()
self.__starter.close_conn()
class TestStarter(unittest.TestCase):
def setUp(self):
self.mock_config = MagicMock(config.Config)
self.mock_config.indexer_delay.return_value = 999
self.mock_config.usb_mount_points.return_value = ['/media']
self.mock_config.usb_devices_to_ignore.return_value = ['ignore-me']
self.mock_scheduler = MagicMock(spec=sched.scheduler)
self.mock_mtp_device = MagicMock(spec=mtp_device.MTPDevice)
self.mock_usb_device_manager = MagicMock(spec=usb_device_manager.USBDeviceManager)
self.mock_usb_device_manager.get_devices_to_index.return_value = [('/media/dev1', 'dev1'),
('/media/dev2', 'dev2')]
self.mock_usb_device = MagicMock(spec=usb_device.USBDevice)
self.mock_indexer = MagicMock(spec=indexer.Indexer)
self.test_model = Starter(self.mock_config, self.mock_scheduler, self.mock_mtp_device,
self.mock_usb_device_manager, self.mock_usb_device, self.mock_indexer)
def test_it_should_transfer_media_from_an_mtp_device(self):
self.test_model.start()
self.mock_mtp_device.transfer_media.assert_called_once_with()
def test_it_should_use_the_right_mount_points_for_usb_devices(self):
self.test_model.start()
self.mock_usb_device_manager.get_devices_to_index.assert_called_once_with(['/media'], ANY)
def test_it_should_use_the_right_ignore_list_for_usb_devices(self):
self.test_model.start()
self.mock_usb_device_manager.get_devices_to_index.assert_called_once_with(ANY, ['ignore-me'])
def test_it_should_transfer_media_from_usb_devices(self):
self.test_model.start()
calls = [call('/media/dev1', 'dev1'), call('/media/dev2', 'dev2')]
self.mock_usb_device.transfer_media.assert_has_calls(calls)
def test_it_should_start_the_indexer(self):
self.test_model.start()
self.mock_indexer.run.assert_called_once_with()
def test_it_should_catch_errors_in_the_indexer(self):
self.mock_indexer.run.side_effect = RuntimeError
self.test_model.start()
def test_it_should_use_the_config_value_to_schedule_jobs(self):
self.test_model.start()
self.mock_scheduler.enter.assert_called_once_with(999, ANY, ANY, argument=ANY)
def test_it_should_use_a_zero_priority_when_scheduling_jobs(self):
self.test_model.start()
self.mock_scheduler.enter.assert_called_once_with(ANY, 0, ANY, argument=ANY)
def test_it_should_not_include_any_arguments(self):
self.test_model.start()
self.mock_scheduler.enter.assert_called_once_with(ANY, ANY, ANY, argument=())
def test_it_should_run_the_scheduler(self):
self.test_model.start()
self.mock_scheduler.run.assert_called_once_with()
