def test_load_languages(self, mocked_language_fileops, mocked_languages_get_filepath, mocked_get_prev_extension, mocked_language_load_from_dict): """ Ensure Languages.load_languages properly delegates to Language's load from dict """ raise DeprecatedTest mocked_language_fileops.get_json_dict.return_value = { 'languages' : [ { 'block' : 1 }, { 'block' : 2 } ] } mocked_languages_get_filepath.return_value = 'path' mocked_get_prev_extension.side_effect = lambda x : 'ext1' if x == { 'block' : 1} else 'ext2' mocked_language_load_from_dict.return_value = 'haha' Languages.load_languages() self.assertEqual(Languages._languagesDict, {'ext1' : 'haha', 'ext2' : 'haha'}) mocked_language_fileops.get_json_dict.assert_called_with('path') mocked_get_prev_extension.assert_called_any({'block' : 1}) mocked_get_prev_extension.assert_called_any({'block' : 2}) mocked_language_load_from_dict.assert_called_any({'block' : 1}) mocked_language_load_from_dict.assert_called_any({'block' : 2})
def test_get_prev_extension_from_block(self): """ Ensure Languages.get_prevalent_extension_from_block works as intended """ block = {'compileExtension' : 'cpp', 'runExtension' : 'o'} self.assertEqual(Languages.get_prevalent_extension_from_block(block), 'cpp') block = { 'runExtension' : 'o'} self.assertEqual(Languages.get_prevalent_extension_from_block(block), 'o') block = {'compileExtension' : 'cpp'} self.assertEqual(Languages.get_prevalent_extension_from_block(block), 'cpp')
def test_get_language_from_extension(self, mocked_load_languages): """ Ensure Languages.get_language_from_extension properly gets a language from ext """ def populateDict(): Languages._languagesDict = {'ext1' : 'lang1', 'ext2' : 'lang2'} mocked_load_languages.side_effect = populateDict self.assertEqual(Languages.get_language_from_extension('ext1'), 'lang1') mocked_load_languages.assert_called_with() self.assertEqual(Languages.get_language_from_extension('ext3'), None)
def count_assignments(self): """ Looks through all writers' assigned solutions and counts which have been assigned and how many times they have """ problemsAssignedDict = {} # Maps specificProblems to completed counts writersAssignedDict = {} for writer in Writers.get_all_writers(): for (problemNumber, problemLanguage) in writer.assignedProblems: languageObject = Languages.get_language_by_name(problemLanguage) # Only consider the languages and problems sent into the object if (not problemNumber in self.allowedProblemNumbers or not languageObject in self.allowedLanguages): continue specificInstance = SpecificProblem(problemNumber, languageObject) if not specificInstance in problemsAssignedDict: problemsAssignedDict[specificInstance] = 1 else: problemsAssignedDict[specificInstance] += 1 if writer in self.writers: writersAssignedDict[writer] = len(writer.assignedProblems) return (problemsAssignedDict, writersAssignedDict)
def _add_known_language_from_name(self, languageName): language = Languages.get_language_by_name(languageName) if language is None: raise PyCException('Error: {} is not a valid language'.format(languageName)) self._add_known_language(language)
def test_get_language_by_name(self, mocked_load_languages): """ Ensure Languages.get_language_by_name properly gets a language from name """ mockedLangOne = mock.MagicMock(spec=Language) mockedLangTwo = mock.MagicMock(spec=Language) mockedLangOne.name = 'Python' mockedLangTwo.name = 'C++' def populateDict(): Languages._languagesDict = {'ext1' :mockedLangOne, 'ext2' : mockedLangTwo} mocked_load_languages.side_effect = populateDict self.assertEqual(Languages.get_language_by_name('C++'), mockedLangTwo) mocked_load_languages.assert_called_with() self.assertEqual(Languages.get_language_by_name('non'), None)
def test_get_languages_filepath(self, mocked_get_config_path): """ Ensure Languages.get_languages_filepath properly delegates to PathMapper """ mocked_get_config_path.return_value = 'confPath' self.assertEqual(Languages.get_languages_filepath(), os.path.join( 'confPath', Languages.LANGUAGES_FILE))
def operate(args): """ Takes the passed in args and delegates to proper functionality. This is set as the executable function when the `writers assign` subparser is used. Arguments: args: Namespace - The arguments passed via CLI """ # If the user specified a problem list, use that as the list of problems. problemParser = NumberParse() if not args.problems is None: specifiedProblems = problemParser.str_list_to_uniq_range(args.problems) else: specifiedProblems = problemParser.str_list_to_uniq_range(['1+']) specifiedLanguages = [] if not args.language is None: for languageName in args.language: loadedLanguage = Languages.get_language_by_name(languageName) if loadedLanguage is None: raise PyCException('Error: {} is an invalid language'.format(languageName)) specifiedLanguages.append(loadedLanguage) else: specifiedLanguages = [Languages.get_language_by_name(name) for name in Languages.get_all_language_names()] specifiedWriters = [] if not args.full and not args.writer_names is None and len(args.writer_names) > 0: for writerName in args.writer_names: loadedWriter = Writer.load_from_folder(writerName) if loadedWriter is None: raise PyCException('Error: {} is an invalid writer'.format(writerName)) specifiedWriters.append(loadedWriter) else: specifiedWriters = Writers.get_all_writers() allocator = AssignmentAllocator(specifiedProblems, specifiedLanguages, specifiedWriters, fromScratch=args.full) allocator.do_assignment(Definitions.get_value('complete_threshold'), overflow=args.overallocate)
def load_from_path(path): """ Creates a new Solution object from a file at path and returns it """ newSolution = Solution(solutionPath=path) filename = fileops.get_basename_less_extension(path) filenameMatcher = Definitions.get_value_matcher(Solution.NAMING_DEFINITION_KEY) newSolution.problemNumber = filenameMatcher.get_variable_value( filename, Variables.get_variable_key_name(Variables.NAME_PROBLEM_NUMBER) ) from util.writer import Writer newSolution.solutionWriter = fileops.get_basename(fileops.get_parent_dir(path)) newSolution.solutionLanguage = Languages.get_language_from_extension(fileops.get_extension(path)) return newSolution
def load_from_path(cls, path): """ Loads a writer and all their solutions from a specified path """ # Check if writer directoroy exists. If not, return nothing if not fileops.exists(path, fileops.FileType.DIRECTORY): return None loadedWriter = Writer(writerPath=path) # Load the user data from the data file dataDictionary = fileops.get_json_dict(loadedWriter._get_datafile_path()) # Populate the data if available # Load name if cls.DATAFILE_NAME_FIELD in dataDictionary: loadedWriter.name = dataDictionary[cls.DATAFILE_NAME_FIELD] # Load email if cls.DATAFILE_EMAIL_FIELD in dataDictionary: loadedWriter.email = dataDictionary[cls.DATAFILE_EMAIL_FIELD] # Load languages if cls.DATAFILE_LANGS_FIELD in dataDictionary: for languageName in dataDictionary[cls.DATAFILE_LANGS_FIELD]: loadedWriter._add_known_language_from_name(languageName) # Load assigned if cls.DATAFILE_ASSIGNED_PROBLEMS in dataDictionary: for assignedProblem in dataDictionary[cls.DATAFILE_ASSIGNED_PROBLEMS]: loadedWriter._add_assigned_problem(assignedProblem[0], assignedProblem[1]) # Load all solutions for possibleSolution in fileops.get_files_in_dir(path): if Solution.is_solution_file(possibleSolution): if not Languages.is_prevalent_extension(fileops.get_extension(possibleSolution)): continue solutionObject = Solution.load_from_path(possibleSolution) loadedWriter._add_solution(solutionObject) return loadedWriter