def test_settings_from_json(self):
settings = SearchSettings()
json = '''{
"startpath": "~/src/xsearch/",
"in-ext": ["js","ts"],
"out-dirpattern": "node_module",
"out-filepattern": ["temp"],
"search": "Searcher",
"linesbefore": 2,
"linesafter": 2,
"debug": true,
"allmatches": false,
"includehidden": true
}'''
self.searchoptions.settings_from_json(json, settings)
self.assertEqual(settings.startpath, '~/src/xsearch/')
for x in {'js', 'ts'}:
self.assertIn(x, settings.in_extensions)
self.assertEqual(list(settings.searchpatterns)[0].pattern, 'Searcher')
self.assertEqual(list(settings.out_dirpatterns)[0].pattern, 'node_module')
self.assertEqual(list(settings.out_filepatterns)[0].pattern, 'temp')
self.assertEqual(settings.linesbefore, 2)
self.assertEqual(settings.linesafter, 2)
self.assertTrue(settings.debug)
self.assertTrue(settings.verbose)
self.assertTrue(settings.firstmatch)
self.assertFalse(settings.excludehidden)
def test_singleline_longer_colorize_searchresult(self):
formatter = SearchResultFormatter(
SearchSettings(colorize=True, maxlinelength=100))
pattern = 'maxlen'
filename = 'maxlen.txt'
sf = SearchFile(path='.', filename=filename, filetype=FileType.TEXT)
linenum = 10
match_start_index = 53
match_end_index = 59
line = '0123456789012345678901234567890123456789012345678901' + \
'maxlen' + \
'8901234567890123456789012345678901234567890123456789'
linesbefore = []
linesafter = []
searchresult = SearchResult(pattern=pattern,
file=sf,
linenum=linenum,
match_start_index=match_start_index,
match_end_index=match_end_index,
line=line,
lines_before=linesbefore,
lines_after=linesafter)
expectedline = '...89012345678901234567890123456789012345678901' + \
Color.GREEN + 'maxlen' + Color.RESET + \
'89012345678901234567890123456789012345678901...'
expectedoutput = "{0:s}: {1:d}: [{2:d}:{3:d}]: {4:s}".format(
os.path.join('.', filename), linenum, match_start_index,
match_end_index, expectedline)
output = formatter.format(searchresult)
self.assertEqual(expectedoutput, output)
def test_singleline_searchresult(self):
formatter = SearchResultFormatter(SearchSettings(colorize=False))
pattern = "Search"
filename = 'Searcher.cs'
sf = SearchFile(path=self.cssearch_path,
filename=filename,
filetype=FileType.CODE)
linenum = 10
match_start_index = 15
match_end_index = 23
line = "\tpublic class Searcher\n"
linesbefore = []
linesafter = []
searchresult = SearchResult(pattern=pattern,
file=sf,
linenum=linenum,
match_start_index=match_start_index,
match_end_index=match_end_index,
line=line,
lines_before=linesbefore,
lines_after=linesafter)
expectedoutput = "{0:s}: {1:d}: [{2:d}:{3:d}]: {4:s}".format(
os.path.join(self.cssearch_path, filename), linenum,
match_start_index, match_end_index, line.strip())
output = formatter.format(searchresult)
self.assertEqual(expectedoutput, output)
def test_multiline_searchresult(self):
formatter = SearchResultFormatter(SearchSettings(colorize=False))
pattern = "Search"
filename = 'Searcher.cs'
sf = SearchFile(path=self.cssearch_path,
filename=filename,
filetype=FileType.TEXT)
linenum = 10
match_start_index = 15
match_end_index = 23
line = "\tpublic class Searcher\n"
linesbefore = ["namespace CsSearch\n", "{\n"]
linesafter = ["\t{\n", "\t\tprivate readonly FileTypes _fileTypes;\n"]
searchresult = SearchResult(pattern=pattern,
file=sf,
linenum=linenum,
match_start_index=match_start_index,
match_end_index=match_end_index,
line=line,
lines_before=linesbefore,
lines_after=linesafter)
expectedoutput = "================================================================================\n" + \
'{0:s}: {1:d}: [{2:d}:{3:d}]\n'.format(os.path.join(self.cssearch_path, filename), linenum, match_start_index, match_end_index) + \
"""--------------------------------------------------------------------------------
8 | namespace CsSearch
9 | {
> 10 | \tpublic class Searcher
11 | \t{
12 | \t\tprivate readonly FileTypes _fileTypes;
"""
output = formatter.format(searchresult)
self.assertEqual(expectedoutput, output)
def test_binaryfile_searchresult(self):
formatter = SearchResultFormatter(SearchSettings())
pattern = "Search"
filename = 'Searcher.exe'
sf = SearchFile(path=self.cssearch_path,
filename=filename,
filetype=FileType.BINARY)
linenum = 0
match_start_index = 0
match_end_index = 0
line = ''
linesbefore = []
linesafter = []
searchresult = SearchResult(pattern=pattern,
file=sf,
linenum=linenum,
match_start_index=match_start_index,
match_end_index=match_end_index,
line=line,
lines_before=linesbefore,
lines_after=linesafter)
expectedoutput = "{0:s} matches at [{1:d}:{2:d}]".format(
os.path.join(self.cssearch_path, filename), match_start_index,
match_end_index)
output = formatter.format(searchresult)
self.assertEqual(expectedoutput, output)
def setUp(self):
self.settings = SearchSettings()
class SearchSettingsTest(unittest.TestCase):
def setUp(self):
self.settings = SearchSettings()
def test_default_settings(self):
# test the props
self.assertFalse(self.settings.archivesonly)
self.assertFalse(self.settings.debug)
self.assertFalse(self.settings.firstmatch)
self.assertTrue(self.settings.excludehidden)
self.assertEqual(0, self.settings.linesafter)
self.assertEqual(0, self.settings.linesbefore)
self.assertFalse(self.settings.listdirs)
self.assertFalse(self.settings.listfiles)
self.assertFalse(self.settings.listlines)
self.assertEqual(150, self.settings.maxlinelength)
self.assertFalse(self.settings.multilinesearch)
self.assertTrue(self.settings.printresults)
self.assertFalse(self.settings.printusage)
self.assertFalse(self.settings.printversion)
self.assertTrue(self.settings.recursive)
self.assertFalse(self.settings.searcharchives)
self.assertFalse(self.settings.uniquelines)
self.assertFalse(self.settings.verbose)
# test the extension and pattern sets
self.assertFalse(self.settings.in_archiveextensions)
self.assertFalse(self.settings.in_archivefilepatterns)
self.assertFalse(self.settings.in_dirpatterns)
self.assertFalse(self.settings.in_filepatterns)
self.assertFalse(self.settings.in_linesafterpatterns)
self.assertFalse(self.settings.in_linesbeforepatterns)
self.assertFalse(self.settings.linesaftertopatterns)
self.assertFalse(self.settings.linesafteruntilpatterns)
self.assertFalse(self.settings.out_archiveextensions)
self.assertFalse(self.settings.out_archivefilepatterns)
self.assertFalse(self.settings.out_dirpatterns)
self.assertFalse(self.settings.out_filepatterns)
self.assertFalse(self.settings.out_linesafterpatterns)
self.assertFalse(self.settings.out_linesbeforepatterns)
self.assertFalse(self.settings.searchpatterns)
def test_set_properties(self):
props = {
'archivesonly': True,
'debug': True,
'firstmatch': True,
'excludehidden': False,
'linesafter': 5,
'linesbefore': 5,
'listdirs': True,
'listfiles': True,
'listlines': True,
'maxlinelength': 155,
'multilinesearch': True,
'printresults': False,
'printusage': True,
'printversion': True,
'recursive': False,
'searcharchives': True,
'uniquelines': True,
'verbose': True,
}
self.settings.set_properties(props)
self.assertEqual(True, self.settings.archivesonly)
self.assertEqual(True, self.settings.debug)
self.assertEqual(True, self.settings.firstmatch)
self.assertEqual(False, self.settings.excludehidden)
self.assertEqual(5, self.settings.linesafter)
self.assertEqual(5, self.settings.linesbefore)
self.assertEqual(True, self.settings.listdirs)
self.assertEqual(True, self.settings.listfiles)
self.assertEqual(True, self.settings.listlines)
self.assertEqual(155, self.settings.maxlinelength)
self.assertEqual(True, self.settings.multilinesearch)
self.assertEqual(False, self.settings.printresults)
self.assertEqual(True, self.settings.printusage,)
self.assertEqual(True, self.settings.printversion)
self.assertEqual(False, self.settings.recursive)
self.assertEqual(True, self.settings.searcharchives)
self.assertEqual(True, self.settings.uniquelines)
self.assertEqual(True, self.settings.verbose)
def test_add_single_extension(self):
self.settings.add_exts('py', 'in_extensions')
self.assertEqual(1, len(self.settings.in_extensions))
self.assertIn('py', self.settings.in_extensions)
def test_add_comma_delimited_extensions(self):
self.settings.add_exts('py,rb,scala', 'in_extensions')
self.assertEqual(3, len(self.settings.in_extensions))
for x in {'py', 'rb', 'scala'}:
self.assertIn(x, self.settings.in_extensions)
def test_add_extensions_set(self):
extensions_set = {'py','rb','scala'}
self.settings.add_exts(extensions_set, 'in_extensions')
self.assertEqual(3, len(self.settings.in_extensions))
for x in extensions_set:
self.assertIn(x, self.settings.in_extensions)
def test_add_single_pattern(self):
p = 'Search'
self.settings.add_patterns(p, 'searchpatterns')
self.assertEqual(1, len(self.settings.searchpatterns))
self.assertEqual(p, list(self.settings.searchpatterns)[0].pattern)
def test_add_patterns_set(self):
patterns_set = {'Search', 'Test'}
self.settings.add_patterns(patterns_set, 'searchpatterns')
self.assertEqual(len(patterns_set), len(self.settings.searchpatterns))
for p in self.settings.searchpatterns:
self.assertIn(p.pattern, patterns_set)
def get_settings(self):
settings = SearchSettings()
settings.startpath = '.'
settings.add_patterns('Searcher', 'searchpatterns')
settings.debug = True
return settings