def testCreateTable(self): """ 测试创建表单 :return: """ from model.task import Task Task.create_table()
def update_task(id_task): if request.method == "POST": # query for check id task query_db = db.read("tasks", "id", id_task) task = query_db[0] if len(query_db) == 1 else None if task == None: return jsonify(error(404, "Task not exists")) else: json = request.get_json() id = task["id"] title = json["title"] description = json["description"] date = task["date"] id_list = task["id_list"] status = json["status"] task = Task( id=id, id_list=id_list, title=title, description=description, date=date, status=status, ) if db.update("tasks", id_task, task.to_dict()): return jsonify(task.to_dict()) else: return jsonify(error(203, "Not Allowed"))
def testValidDescriptionProvided(self): task = Task("task a") task.setDescription("task b") self.assertEqual("task b", task.getDescription(), "checking description")
def get_task(id): try: if (id): task = Task.find_task(Task, id).json() else: task = Task.find_task(Task, request.json.get("id")).json() return {'sucess': True, 'erro': False, 'response': task} except Exception as e: return {'sucess': False, 'erro': True, 'response': str(e)}
def set_task(self, list_task): self.m_dictTasks = dict() for task in list_task: if task["taskstate"] == "1": t = Task() t.handle_info(task) self.m_dictTasks[t.type] = t
def testServiceVisitWithOneTaskThatDoesNotHaveTheSpecifiedId(self): task1 = Task("task a") task2 = Task("task b") visit = ServiceVisit("name", "address", "customer", [task1]) with self.assertRaises(ValueError): visit.getTaskById(task2.getTaskId())
def testServiceVisitWithOneTaskWithSpecifiedId(self): task1 = Task("task a") visit = ServiceVisit("name", "address", "customer", [task1]) result = visit.getTaskById(task1.getTaskId()) self.assertEqual(task1, result, "checking result")
def testValidStatusProvided(self): task = Task("task a") task.setStatus(TaskStatus.COMPLETE) self.assertEqual(TaskStatus.COMPLETE, task.getStatus(), "checking status")
def setUp(self): super(TestTasks, self).setUp() self.resource_name = 'task' self.resources_uri = self.root_uri + 'projects/1/sprints/1/stories/1/tasks' self.single_resource_uri = self.resources_uri + '/1' self.example_resource = Task(nr=1, description='some description', comment='some comment', status=1, progress=50, completion_date=None, owner=1, story_id=1, assigned_devs=[], id_=2) self.update_resource = Task(nr=7, description='some updated description', comment='some updated comment', status=2, progress=100, completion_date=None, owner=2, story_id=1, assigned_devs=[], id_=2)
def testValidMaterialProvidedToTaskWithOneMaterial(self): task = Task("task a", materials=["splitter"]) task.removeMaterial("splitter") self.assertEqual(0, len(task.getMaterials()), "checking number of materials")
def test_merge(self): tree = ElementTree.fromstring( '<omnifocus xmlns="http://www.omnigroup.com/namespace/OmniFocus/v1" app-id="com.omnigroup.OmniFocus.iPad" app-version="79.4.0.175422" os-name="iPhone OS" os-version="6.1" machine-model="iPad">' + '<task id="l5FczgWVl2S">' + '<task idref="gZW06uIszyr"/>' + '<added>2012-08-28T04:55:12.824Z</added>' + '<modified>2012-09-05T08:00:16.788Z</modified>' + '<name>Kill duplicates</name>' + '<rank>0</rank>' + '<order>parallel</order>' + '</task>' + '</omnifocus>') tree_upd = ElementTree.fromstring( '<omnifocus xmlns="http://www.omnigroup.com/namespace/OmniFocus/v1" app-id="com.omnigroup.OmniFocus.iPad" app-version="79.4.0.175422" os-name="iPhone OS" os-version="6.1" machine-model="iPad">' + '<task id="l5FczgWVl2S" op="update">' + '<task idref="gZW06uIszyr"/>' + '<added>2012-08-28T04:55:12.824Z</added>' + '<modified>2012-09-05T08:00:16.788Z</modified>' + '<name>Kill duplicates in bases</name>' + '<rank>0</rank>' + '<order>parallel</order>' + '</task>' + '</omnifocus>') task = Task() task.fromXmlNode(tree[0]) task.merge(tree_upd[0]) self.assertEquals(task.name, "Kill duplicates in bases")
def save_task(): try: task = Task(request.json.get("nome"), request.json.get("descricao"), 'aberto') #request.json.get("status")) task.save() return {'sucess': True, 'erro': False, 'response': task.json()} except Exception as e: return {'sucess': False, 'erro': True, 'response': str(e)}
def delete_task(id): try: #Task(request.json.get("id"), request.json.get("nome"), request.json.get("descricao"), request.json.get("status")).delete() if (id): Task.find_task(Task, id).delete() else: Task.find_task(Task, request.json.get("id")).delete() return {'sucess': True, 'erro': False, 'response': 'sucess'} except Exception as e: print(e) return {'sucess': False, 'erro': True, 'response': str(e)}
def testAddValidTaskToServiceVisitWithSomeTasks(self): task1 = Task("task a") visit = ServiceVisit("name", "address", "description", [task1]) task2 = Task("task b") visit.addTask(task2) self.assertEqual(2, len(visit.getTasks()), "checking number of tasks") self.assertTrue(task1 in visit.getTasks(), "checking for pre-existing task") self.assertTrue(task2 in visit.getTasks(), "checking for task added")
def testServiceVisitWithMultipleTasksAndLastHasSpecifiedId(self): task1 = Task("task a") task2 = Task("task b") task3 = Task("task c") visit = ServiceVisit("name", "address", "customer", [task1, task2, task3]) result = visit.getTaskById(task3.getTaskId()) self.assertEqual(task3, result, "checking result")
def game(): """ start (path with dialog) / \ w1 (m1) w2 (d1) \ / knot1 / | \ w3 w4 w5 <- with task t1,t2,t3 \ | end <- task from dialog td1 :return: game with described graph """ #TODO, check interaction model in waypoint dialog = Dialog() dialog_start = Mail(dialog.graph, 'start sub', 'start body') m1 = Mail(dialog.graph, 'second sub', 'second body') td1 = Task(None, 'some task 1', 'some task', 'some solution') d1 = Speech(dialog.graph, 'content', task=td1) game = Game('test') start = Waypoint(game.graph, 'start') w1 = Waypoint(game.graph, 'w1') w2 = Waypoint(game.graph, 'w2') knot = Waypoint(game.graph, 'knot') w3 = Waypoint(game.graph, 'w3') t1 = Task(w3, 'some task 1', 'some task') w4 = Waypoint(game.graph, 'w4') t2 = Task(w4, 'some task 2', 'some task') w5 = Waypoint(game.graph, 'w5') t3 = Task(w5, 'some task 3', 'some task') end = Waypoint(game.graph, 'end') start.add_destination(w1, 1.1) start.add_destination(w2) w1.add_destination(knot) w2.add_destination(knot) knot.add_task(t1) knot.add_task(t2) knot.add_task(t3) w3.add_destination(end) w4.add_destination(end) game.set_start(start) dialog_end = Speech(dialog.graph, 'next content', destination=end) dialog.set_start(dialog_start) dialog_start.add_follow_up(d1) dialog_start.add_follow_up(m1) dialog_start.waypoints.append(start) d1.add_follow_up(dialog_end, None) game.add_non_playable_character(NonPlayableCharacter( 'bob', 'test', dialog)) return game
def build_task(session,taskType,service,host,role,task): new_task = Task(taskType,service,host,role,task) if config.ansible_run == False : new_task.status = Task.STATUS_FINISH new_task.result = Task.RESULT_SUCCESS new_task.msg = "fade success" session.add(new_task) session.flush() newid = new_task.id session.commit() return newid
def build_task(session, taskType, service, host, role, task): new_task = Task(taskType, service, host, role, task) if config.ansible_run == False: new_task.status = Task.STATUS_FINISH new_task.result = Task.RESULT_SUCCESS new_task.msg = "fade success" session.add(new_task) session.flush() newid = new_task.id session.commit() return newid
def create_task(self, args): try: title = self.format_title(args.title) description = args.description if args.description else "" date = self.deserialize_date(args.date) time = self.deserialize_time(args.time) if args.time else None project = self.deserialize_project(args.project) if args.project else None task = Task(title, description, date, time, project) self.task_handler.add_task(task) print("Added task '{}' for {}".format(task.get_title(), task.get_date().toString("dddd, d. MMMM yy."))) except Exception as e: print(e) return True
def create_tables(): """ 初始化表结构 :return: """ Url.create_table() Task.create_table() User.create_table() UserTask.create_table() PluginInfo.create_table() Vulnerability.create_table() SystemConfig.create_table() PluginInfo.create_table() LdapConfig.create_table() NetWorkProxyConfig.create_table()
def set_step_completed_in_progress_ini(self, stack, step): """ Look up the lookup up from the step. Check if the stack already exists, if not, insert, otherwise, update Args: stack: string of the stack you are working on step: current step Returns: nothing, just merges """ try: lookup = self.session.query(ProgressLookup)\ .filter(ProgressLookup.original_step == step)\ .order_by(ProgressLookup.original_step.desc())\ .limit(1).one() except NoResultFound: print('No lookup for {} so we will enter one.'.format(step)) try: task = self.session.query(Task).filter(Task.lookup_id == lookup.id)\ .filter(Task.prep_id == stack).one() except NoResultFound: print('No step for {}'.format(step)) task = Task(stack, lookup.id, True) try: self.session.merge(task) self.session.commit() except: print('Bad lookup code for {}'.format(lookup.id)) self.session.rollback()
def createtasks(tasklistinput): """ Creates one class Task for every task in the input file. :param tasklistinput: Tasks from the input file. :return: List of classes Task. """ tasklist = [] for taskinput in tasklistinput: if "dependencies" in taskinput: task = Task(taskinput["name"], taskinput["type"], taskinput["arguments"], taskinput["dependencies"]) else: task = Task(taskinput["name"], taskinput["type"], taskinput["arguments"], None) tasklist.append(task) return tasklist
def __init__(self, config): self.config = config self.score_dir = config.get_argv().score_file self.benchmark_config = config.get_argv().benchmark_config self.task = Task(config) self.workspace = Workspace(config) self.ssh_user = config.get_value('User', 'SSH') self.ssh_passwd_file = config.get_value('PasswdFile', 'SSH') self.ssh_port = config.get_value('Port', 'SSH') self.subnet_ip = config.get_value('ip', 'Subnet') self.subnet_name = config.get_value('name', 'Subnet') self.mode = config.get_value('Mode') self.pwd = os.path.dirname(__file__) self.mq_tag = str(time.time()).replace('.', '_') self._benchmark_pressure_tag_id = None self.logs_dir = os.path.join(self.pwd, '../logs/') self.logger = logging.getLogger(__name__) self.lockfile = self.__lockfile() self.logger.setLevel(logging.DEBUG) handler = logging.FileHandler("log.txt") handler.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) self.logger.addHandler(handler)
def test_create(self): task = Task.create('test task') self.assertIsNotNone(task) self.assertRegex(task.uuid, r'%s' % UUID4_REGEX) self.assertEqual('test task', task.description) self.assertEqual(0, task.done)
def test_upload_does_nothing_if_task_is_stale(self, mockDropbox, mockUploadCursor): uploadSessionStarter = MagicMock() uploadSessionAppender = MagicMock() mockDropbox.return_value.files_upload_session_start = uploadSessionStarter mockDropbox.return_value.files_upload_session_finish = uploadSessionAppender testSecretData = b"secret test data" testFileHandle = BytesIO(testSecretData) testPartName = "testFile__1__1.enc" testClientModified = datetime.datetime(2020, 1, 1, 10, 5, 30) testFileData = { "userTimezone": "+0200", "utcModified": testClientModified.timestamp(), "path": "subDir" } testTask = Task(taskType=MessageTypes.UPLOAD_FILE, data=testFileData, stale=True) cloudAccount = DropboxAccountWrapper(self.testAccountData) result = cloudAccount.upload(testFileHandle, len(testSecretData), testPartName, testTask) self.assertEqual(uploadSessionStarter.call_count, 0) self.assertEqual(uploadSessionAppender.call_count, 0) self.assertIsNone(result)
def test_download_file_does_nothing_if_task_is_stale(self, mockRequest): secretData = b"secret test data" testEncoder = AES.new(self.testAccountData.cryptoKey.encode(), AES.MODE_CFB) testIV = testEncoder.iv ivResponse = MagicMock() ivResponse.content = testIV encryptedDataResponse = MagicMock() encryptedDataResponse.content = testEncoder.encrypt(secretData) mockRequest.side_effect = [ivResponse, encryptedDataResponse] testDownloadFileHandle = BytesIO() testFilePartInfo = FilePart( filename="apple.txt__1__1.enc", modified=int( datetime.datetime(2020, 1, 1, 10, 10, 30).timestamp()), size=len(encryptedDataResponse.content) + len(testIV), path="", fullPath="apple.txt__1__1.enc", storingAccountID=self.testAccountData.id, extraInfo={}) testDownloadFileTask = Task(taskType=MessageTypes.DOWNLOAD_FILE, stale=True) cloudAccount = DropboxAccountWrapper(self.testAccountData) cloudAccount.download(testDownloadFileHandle, testFilePartInfo, testDownloadFileTask) testDownloadFileHandle.seek(0) self.assertEqual(b"", testDownloadFileHandle.read())
def test_upload_writes_iv_and_encrypts_file_data(self, mockDropbox, mockUploadCursor): uploadSessionStarter = MagicMock() uploadSessionAppender = MagicMock() mockDropbox.return_value.files_upload_session_start = uploadSessionStarter mockDropbox.return_value.files_upload_session_finish = uploadSessionAppender testSecretData = b"secret test data" testFileHandle = BytesIO(testSecretData) testPartName = "testFile__1__1.enc" testClientModified = datetime.datetime(2020, 1, 1, 10, 5, 30) testFileData = { "userTimezone": "+0200", "utcModified": testClientModified.timestamp(), "path": "subDir" } testTask = Task(taskType=MessageTypes.UPLOAD_FILE, data=testFileData) cloudAccount = DropboxAccountWrapper(self.testAccountData) result = cloudAccount.upload(testFileHandle, len(testSecretData), testPartName, testTask) cipher = AES.new(self.testAccountData.cryptoKey.encode(), AES.MODE_CFB, iv=uploadSessionStarter.call_args[0][0]) encoded = mockDropbox.return_value.files_upload_session_finish.call_args[ 0][0] self.assertNotEqual(encoded, testSecretData) self.assertEqual(cipher.decrypt(encoded), testSecretData)
def parse(self, task: Task, content: str): data = json.loads(content) if data['code'] != 200: raise Exception(f'Failed to parse response {content}') content = data['content'] keyword = content['keyword'] news_items = content.get('results', []) need_next_page = False items = [] for news_item in news_items: item = XinHuaNewsItem() item.url = news_item['url'] item.keyword = keyword item.title = news_item['title'] item.abstract = news_item['des'] item.publish = datetime.datetime.strptime(news_item['pubtime'], '%Y-%m-%d %H:%M:%S') items.append(item) if item.publish >= config.BEGIN_DATE: need_next_page = True if need_next_page: params = task.params params['curPage'] += 1 yield Task(task.url, '', '', params=params, metadata=task.metadata) for item in items: yield item
def test_comment_parser(): with open('./test_files/shop_reviews.html', 'r') as html_file: data = html_file.read() url = 'https://www.dianping.com/shop/90556783/review_all' task = Task(url, '', '') parser = get_parser(url) _parse(parser, task, data)
def dispatchIncomingMessage(self, message): messageType = message.header.messageType task = Task(taskType=messageType, stale=False, uuid=message.header.uuid, data=message.data) if messageType in self.__INSTANT_TASK_TYPES: if messageType == MessageTypes.DELETE_FILE: path = message.data["fullPath"] self.__longFileTaskArchive.cancelTask(path) self.__longFileTaskArchive.removeTask(path) elif messageType == MessageTypes.MOVE_FILE: self.__longFileTaskArchive.cancelTask(message.data["source"]) self.__longFileTaskArchive.cancelTask(message.data["target"]["fullPath"]) self.__longFileTaskArchive.removeTask(message.data["source"]) self.__longFileTaskArchive.removeTask(message.data["target"]["fullPath"]) self.incoming_instant_task_queue.put(task) elif messageType in self.__SLOW_TASK_TYPES: key = task.data["fullPath"] self.__longFileTaskArchive.addTask(key, task) self.incoming_task_queue.put(task) elif messageType == MessageTypes.FILE_TASK_CANCELLED: self._logger.debug(f"Cancelling task for file: {message.data['fullPath']}") self.__longFileTaskArchive.cancelTask(message.data["fullPath"]) self.__longFileTaskArchive.removeTask(message.data["fullPath"]) else: self._logger.warning(f"Unknown message: {message}")
def test_handler_retrieves_accounts_from_database_and_sends_response( self, dispatchResponseMock): testAccounts = [ AccountData(id=1, identifier="testAccountID", accountType=AccountTypes.Dropbox, cryptoKey="sixteen byte key", data={"apiToken": "testApitoken"}) ] testTask = Task(taskType=MessageTypes.GET_ACCOUNT_LIST, uuid=uuid4().hex) self.fakeDB.getAllAccounts.return_value = testAccounts self.testHandler.setTask(testTask) self.testHandler.handle() self.assertEqual(self.fakeDB.getAllAccounts.call_count, 1) self.assertEqual(dispatchResponseMock.call_count, 1) self.assertEqual( dispatchResponseMock.call_args[0][0].header.messageType, MessageTypes.RESPONSE) self.assertEqual(dispatchResponseMock.call_args[0][0].header.uuid, testTask.uuid) self.assertEqual( type(dispatchResponseMock.call_args[0][0].data["accounts"]), list) self.assertEqual( len(dispatchResponseMock.call_args[0][0].data["accounts"]), len(testAccounts)) self.assertEqual( dispatchResponseMock.call_args[0][0].data["accounts"][0], testAccounts[0].serialize())
def update_task(self, task_id: int, new_task: Task): """ Update Task by id :param task_id: id of updating Task :param new_task: Task entity with updating info :return: True if entity was updated else >>> a = DataManager.load_from_file(test_suits_folder_path + "/test_suit3.json") >>> task = Task(1, "TEST val", "nothing", parser.parse("1999-08-28T21:03:05"), \ parser.parse("1999-08-28T05:55:23"), True) >>> a.update_task(1, task) True >>> a.get_by_id(1) == task True >>> task.name = "TEst N2" >>> a.update_task(1, task) True >>> a.get_by_id(1) == task True """ self.update_from_file(self.storage_path) new_task.task_id = task_id for i, task in enumerate(self.tasks): if task.task_id == task_id: self.tasks[i] = new_task self.save_to_file(self.storage_path) return True return False
def fromXml(self, tree): self._tree = tree root = tree self.tasks = dict() self.tasks_tree = dict() self.folders = dict() self.folders_tree = dict() self.contexts = dict() self.contexts_tree = dict() for e in root: tag = extract_tag(e.tag) if tag == 'task': task = Task() task.fromXmlNode(e) self.tasks[task.id] = task parent = task.parentRef or task.folderRef or "/" if not parent in self.tasks_tree: self.tasks_tree[parent] = [] self.tasks_tree[parent].append(task) elif tag == 'folder': folder = Folder() folder.fromXmlNode(e) self.folders[folder.id] = folder parent_folder = folder.parentRef or "/" if not parent_folder in self.folders_tree: self.folders_tree[parent_folder] = [] self.folders_tree[parent_folder].append(folder) elif tag == 'context': context = Context() context.fromXmlNode(e) self.contexts[context.id] = context parent_ctx = context.parentRef or "/" if not parent_ctx in self.contexts_tree: self.contexts_tree[parent_ctx] = [] self.contexts_tree[parent_ctx].append(context)
def get(self): type_ = self.get_argument('type') li = Task.select().where(Task.type == type_).order_by(Task.index) li = [o.to_dict() for o in li] self.finish(dict(data=li))
def post(self): type_ = self.get_argument('type') title = self.get_argument('title') Task.create(type=type_, title=title) self.finish()
def post(self, workspace, action): #logging.info("hello world") ##used for CRUD for tasks and dnd operations #if action not in self.__actions__: # raise WrongActionException("Action %s is not supported" % action) #if action != "create" and not id: # raise WrongActionException("Id should not be null for %s action" % action) logging.info("============= Doing %s ===============" % action) if action == "create": name = self.request.get("name") body = self.request.get("body") column = Column.gql("WHERE allow_create=TRUE").get() logging.info("column: %s, name: %s, body: %s" % (column, name, body)) task = Task(column=column, name=unicode(name), body=unicode(body)) task.put() if action == "dnd": task_id = self.request.get("task") dest_column_key = self.request.get("to") logging.info("task: %s" % task_id) logging.info("to: %s" % dest_column_key) task = Task.get(task_id) dest_column = Column.get(dest_column_key) task.column = dest_column task.put() if action == "delete": # #delete task id = self.request.get("taskId") task = Task.get(id) db.delete(task) if action == "edit": id = self.request.get("taskId") name = self.request.get("name") body = self.request.get("body") task = Task.get(id) task.name = name task.body = body task.put()