def test_relational_operator_exacted_false_not_exacted(): """Check to see if the exacted relational operator returns False, no exacting.""" relation_boolean, relation_value = util.greater_than_equal_exacted(10, 100) assert relation_boolean is False assert relation_value == 10 relation_boolean, relation_value = util.greater_than_equal_exacted( 10, 100, False) assert relation_boolean is False assert relation_value == 10
def commits_greater_than_count(path, expected_count, exact=False): """Returns count and true if count of commits is greater than limit, else False""" # extract the commit log and then count the commits commits = get_commmits(path) number_commits = count_commits(commits) # check the condition and also return number_commits return util.greater_than_equal_exacted(number_commits, expected_count, exact)
def specified_tag_greater_than_count( chosen_tag, checking_function, expected_count, given_file, containing_directory, exact=False, ): """Determine if the tag count is greater than expected in given file(s).""" # Use these two variables to keep track of tag counts for multiple files. # The idea is that file_tags_count_dictionary will store (key, value) pairs # where the key is the file and the count is the number of entities in that file. file_tags_count = 0 file_tags_count_dictionary = {} # Create a Path object to the chosen file in the containing directory, accounting # for the fact that a wildcard like "*.md" will create multiple paths. Note that # the create_paths function can only return valid paths, regardless of input. for file_for_checking in files.create_paths( file=given_file, home=containing_directory ): file_tag_count = 0 # since the specified file must be valid and thus suitable for checking, # read the contents of the file and then check for the chosen tag file_contents = file_for_checking.read_text() file_tag_count = checking_function(file_contents, chosen_tag) file_tags_count_dictionary[file_for_checking.name] = file_tag_count # return the minimum value and the entire dictionary of counts minimum_pair = util.get_first_minimum_value(file_tags_count_dictionary) file_tags_count = minimum_pair[1] # check the condition and also return file_tags_count return ( util.greater_than_equal_exacted(file_tags_count, expected_count, exact), file_tags_count_dictionary, )
def entity_greater_than_count(given_file, containing_directory, expected_count, checking_function, exact=False): """Return count and determines if the entity count is greater than expected""" file_entity_count = count_entities(given_file, containing_directory, checking_function) # check the condition and also return file_entity_count return util.greater_than_equal_exacted(file_entity_count, expected_count, exact)
def invoke_all_total_word_count_checks(filecheck, directory, expected_count, count_function, conclusion, exact=False): """Perform the word count check and return the results.""" met_or_exceeded_count = False ( met_or_exceeded_count, actual_count, actual_count_dictionary, ) = entities.entity_greater_than_count_total(filecheck, directory, expected_count, count_function, exact) met_or_exceeded_count = util.greater_than_equal_exacted( actual_count, expected_count, exact)[0] # create the message and the diagnostic if not exact: # create an "at least" message, which is the default message = ("The " + filecheck + " in " + directory + " has at least " + str(expected_count) + constants.markers.Space + conclusion) else: # create an "exact" message, which is an opt-in message = ("The " + filecheck + " in " + directory + " has exactly " + str(expected_count) + constants.markers.Space + conclusion) # create a diagnostic message and report the result word_diagnostic, filename = util.get_word_diagnostic( actual_count_dictionary, expected_count) # there is no need for a filename diagnostic unless there are multiple results filename_diagnostic = constants.markers.Nothing # there is a filename, which means that there was a wildcard specified # and thus this diagnostic is for one file; give name at the end filename_count = expected_count if filename: filename_diagnostic = (constants.markers.Of_File + constants.markers.Space + filename) sum_actual_count_dictionary = util.sum_dictionary_values( actual_count_dictionary) filename_count = sum_actual_count_dictionary[filename] if filename_diagnostic is not constants.markers.Nothing: diagnostic = ("Found " + str(filename_count) + constants.markers.Space + conclusion + constants.markers.Space + filename_diagnostic) else: diagnostic = ("Did not find " + str(filename_count) + constants.markers.Space + conclusion + constants.markers.Space + constants.words.In_The + constants.markers.Space + constants.markers.Unknown_File + constants.markers.Space + constants.markers.File) report_result(met_or_exceeded_count, message, diagnostic) return met_or_exceeded_count
def entity_greater_than_count_total( given_file, containing_directory, expected_count, checking_function, exact=False ): """Return a count and determination if entity count is greater than expected.""" # call the count_entities function in this module file_entity_count, file_entity_count_dictionary = count_entities( given_file, containing_directory, checking_function ) count_status_list = util.greater_than_equal_exacted( expected_count, file_entity_count, exact ) count_status = count_status_list[0] return count_status, file_entity_count, file_entity_count_dictionary
def specified_source_greater_than_count( expected_count, given_file=NOTHING, containing_directory=NOTHING, contents=NOTHING, exact=False, ): """Determines if the line count is greater than expected""" # count the fragments in either a file in a directory or String contents file_line_count = count_lines(given_file, containing_directory, contents) # the fragment count is at or above the threshold # check the condition and also return file_fragment_count return util.greater_than_equal_exacted(file_line_count, expected_count, exact)
def specified_entity_greater_than_count( chosen_fragment, checking_function, expected_count, given_file=NOTHING, containing_directory=NOTHING, contents=NOTHING, exact=False, ): """Determines if the entity count is greater than expected""" # count the fragments/regex in either a file in a directory or String contents file_entity_count = count_entities(chosen_fragment, checking_function, given_file, containing_directory, contents) # check the condition and also return file_entity_count return util.greater_than_equal_exacted(file_entity_count, expected_count, exact)
def specified_tag_greater_than_count( chosen_tag, checking_function, expected_count, given_file, containing_directory, exact=False, ): """Determines if the tag count is greater than expected in a given file""" file_for_checking = Path(containing_directory + FILE_SEPARATOR + given_file) file_tag_count = 0 if file_for_checking.is_file(): file_contents = file_for_checking.read_text() file_tag_count = checking_function(file_contents, chosen_tag) # check the condition and also return file_tag_count return util.greater_than_equal_exacted(file_tag_count, expected_count, exact)
def specified_entity_greater_than_count( chosen_fragment, checking_function, expected_count, given_file=constants.markers.Nothing, containing_directory=constants.markers.Nothing, contents=constants.markers.Nothing, exact=False, ): """Determine if the entity count is greater than expected.""" # count the fragments/regex in either a file in a directory or String contents file_entity_count, file_entity_count_dictionary = count_entities( chosen_fragment, checking_function, given_file, containing_directory, contents) # check the condition and also return file_entity_count condition_truth, value = util.greater_than_equal_exacted( file_entity_count, expected_count, exact) # also return an empty dictionary since this function does not # need to count details about multiple entities return condition_truth, value, file_entity_count_dictionary
def specified_source_greater_than_count( expected_count, given_file=constants.markers.Nothing, containing_directory=constants.markers.Nothing, contents=constants.markers.Nothing, exact=False, ): """Determine if the line count is greater than expected.""" # count the fragments in either a file in a directory or str contents, # with the str contents coming from the output from running a command file_lines_count, file_contents_count_dictionary = count_lines( given_file, containing_directory, contents) # the fragment count is at or above the threshold # check the condition and also return the file_lines_count # and the dictionary itself so as to support good diagnostics return ( ( util.greater_than_equal_exacted(file_lines_count, expected_count, exact), file_lines_count, ), file_contents_count_dictionary, )
def test_relational_operator_exacted_true_exacted(): """Check to see if the exacted relational operator returns True.""" relation_boolean, relation_value = util.greater_than_equal_exacted( 100, 100, True) assert relation_boolean is True assert relation_value == 100