624 lines
18 KiB
Ruby
624 lines
18 KiB
Ruby
require './parser'
|
|
|
|
class QueryParserTester
|
|
describe 'Testing the Parser' do
|
|
before do
|
|
@evaluator = Query.new
|
|
end
|
|
|
|
it 'tests query with only one search term without quotes and without column name' do
|
|
@result = @evaluator.parse('-123')
|
|
|
|
expect(@result[:DEFAULT_COLUMN]).to eq '-123'
|
|
end
|
|
|
|
it 'tests query with only one search term with quotes and without column name' do
|
|
@result = @evaluator.parse('"OR 128"')
|
|
|
|
expect(@result[:DEFAULT_COLUMN]).to eq '"OR 128"'
|
|
end
|
|
|
|
it 'tests query with one column and search term without quotes' do
|
|
@result = @evaluator.parse('tag:mta')
|
|
|
|
expect(@result['tag']).to eq 'mta'
|
|
end
|
|
|
|
it 'tests query with one column and search term with quotes' do
|
|
@result = @evaluator.parse('tag:"tag 120"')
|
|
|
|
expect(@result['tag']).to eq '"tag 120"'
|
|
end
|
|
|
|
it 'tests query with two columns connected with OR and search terms without quotes' do
|
|
@result = @evaluator.parse('tag:mta OR tag:12')
|
|
|
|
@expected_array = [
|
|
{ 'tag' => 'mta' },
|
|
{ 'tag' => '12' }
|
|
]
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two columns connected with OR and search terms with quotes' do
|
|
@result = @evaluator.parse('tag:mta OR tag:"tag 12"')
|
|
|
|
@expected_array = [
|
|
{ 'tag' => 'mta' },
|
|
{ 'tag' => '"tag 12"' }
|
|
]
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two columns connected with AND and search terms without quotes' do
|
|
@result = @evaluator.parse('tag:mta AND tag:12')
|
|
|
|
@expected_array = [
|
|
{ 'tag' => 'mta' },
|
|
{ 'tag' => '12' }
|
|
]
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result[:OPERATOR_AND]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two columns connected with AND and search terms with quotes' do
|
|
@result = @evaluator.parse('tag:mta and tag:"tag 12"')
|
|
|
|
@expected_array = [
|
|
{ 'tag' => 'mta' },
|
|
{ 'tag' => '"tag 12"' }
|
|
]
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result[:OPERATOR_AND]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests simple query with brackets' do
|
|
@result = @evaluator.parse('(123)')
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq '123'
|
|
end
|
|
|
|
it 'tests simple query with brackets and with a column name' do
|
|
@result = @evaluator.parse('(name:JF)')
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result['name']).to eq 'JF'
|
|
end
|
|
|
|
it 'tests query with OR operator in brackets' do
|
|
@result = @evaluator.parse('(name:JF or tag:mta)')
|
|
|
|
@expected_array = [
|
|
{ 'name' => 'JF' },
|
|
{ 'tag' => 'mta' }
|
|
]
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two simple brackets expressions' do
|
|
@result = @evaluator.parse('(name:JF) and (-456)')
|
|
|
|
@expected_array = [
|
|
{ 'name' => 'JF' },
|
|
{ :DEFAULT_COLUMN => '-456' }
|
|
]
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result[:OPERATOR_AND]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two brackets expressions' do
|
|
@result = @evaluator.parse('(name:JF or tag:"tag 0") and (-456)')
|
|
|
|
@expected_array_part_1 = [
|
|
{ 'name' => 'JF' },
|
|
{ 'tag' => '"tag 0"' }
|
|
]
|
|
|
|
@expected_array_total = [
|
|
{:OPERATOR_OR => @expected_array_part_1},
|
|
{:DEFAULT_COLUMN => '-456'}
|
|
]
|
|
|
|
expect(@result.count).to eq 1
|
|
expect(@result[:OPERATOR_AND]).to eq @expected_array_total
|
|
end
|
|
|
|
it 'tests operator precedence, or - and' do
|
|
@result1 = @evaluator.parse('tag:mta or name:JF and 12_4')
|
|
@result2 = @evaluator.parse('tag:mta or (name:JF and 12_4)')
|
|
|
|
expect(@result1).to eq @result2
|
|
|
|
expect(@result1.length).to eq 1
|
|
|
|
@expected_array_part_2 = [
|
|
{'name' => 'JF'},
|
|
{:DEFAULT_COLUMN => '12_4'}
|
|
]
|
|
|
|
@expected_array_total = [
|
|
{'tag' => 'mta'},
|
|
{:OPERATOR_AND => @expected_array_part_2}
|
|
]
|
|
|
|
expect(@result1[:OPERATOR_OR]).to eq @expected_array_total
|
|
|
|
end
|
|
|
|
it 'tests operator precedence, and - or' do
|
|
@result1 = @evaluator.parse('tag:mta and name:JF or 12_4')
|
|
@result2 = @evaluator.parse('(tag:mta and name:JF) or 12_4')
|
|
|
|
expect(@result1).to eq @result2
|
|
|
|
expect(@result1.length).to eq 1
|
|
|
|
@expected_array_part_2 = [
|
|
{'tag' => 'mta'},
|
|
{'name' => 'JF'}
|
|
]
|
|
|
|
@expected_array_total = [
|
|
{:OPERATOR_AND => @expected_array_part_2},
|
|
{:DEFAULT_COLUMN => '12_4'}
|
|
]
|
|
|
|
expect(@result1[:OPERATOR_OR]).to eq @expected_array_total
|
|
|
|
end
|
|
|
|
it 'tests simple query with not operator' do
|
|
@result = @evaluator.parse('not -54')
|
|
|
|
expect(@result.length).to be 1
|
|
expect(@result[:OPERATOR_NOT][:DEFAULT_COLUMN]).to eq '-54'
|
|
end
|
|
|
|
it 'tests query with mixed NOT and AND logic operator' do
|
|
@result = @evaluator.parse('name:"some wild name" and not -123-456')
|
|
|
|
@expected_and_array = [
|
|
{'name' => '"some wild name"'},
|
|
{:OPERATOR_NOT => {:DEFAULT_COLUMN => '-123-456'}}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_AND]).to eq @expected_and_array
|
|
end
|
|
|
|
it 'tests query with mixed NOT, AND and OR logic operators' do
|
|
@result = @evaluator.parse('name:"some wild name" or not (tag:mta and -123-456)')
|
|
|
|
@expected_and_array_operands = [
|
|
{'tag' => 'mta'},
|
|
{:DEFAULT_COLUMN => '-123-456'}
|
|
]
|
|
|
|
@expected_or_array_operands = [
|
|
{'name' => '"some wild name"'},
|
|
{:OPERATOR_NOT => {:OPERATOR_AND => @expected_and_array_operands}}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_or_array_operands
|
|
end
|
|
|
|
it 'tests query with two default column search terms without quotes and without logical operators' do
|
|
@result = @evaluator.parse('id-5 -456')
|
|
|
|
@expected_array = [
|
|
{:DEFAULT_COLUMN => 'id-5'},
|
|
{:DEFAULT_COLUMN => '-456'}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two default column search terms with quotes and without logical operators' do
|
|
@result = @evaluator.parse('"id-5 no Q" -456')
|
|
|
|
@expected_array = [
|
|
{:DEFAULT_COLUMN => '"id-5 no Q"'},
|
|
{:DEFAULT_COLUMN => '-456'}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two default column search terms with quotes on both terms and without logical operators' do
|
|
@result = @evaluator.parse('"id-5 no Q" "wild id -456"')
|
|
|
|
@expected_array = [
|
|
{:DEFAULT_COLUMN => '"id-5 no Q"'},
|
|
{:DEFAULT_COLUMN => '"wild id -456"'}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with one default column and one non defualt column, search terms without quotes and without logical operators' do
|
|
@result = @evaluator.parse('tag:mta -456')
|
|
|
|
@expected_array = [
|
|
{'tag' => 'mta'},
|
|
{:DEFAULT_COLUMN => '-456'}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with one default column and one non defualt column, search terms with quotes and without logical operators' do
|
|
@result = @evaluator.parse('-1-23 name:"WILD name"')
|
|
|
|
@expected_array = [
|
|
{:DEFAULT_COLUMN => '-1-23'},
|
|
{'name' => '"WILD name"'}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two columns, search terms with quotes and without logical operators' do
|
|
@result = @evaluator.parse('tag:-1-23 name:"WILD name"')
|
|
|
|
@expected_array = [
|
|
{'tag' => '-1-23'},
|
|
{'name' => '"WILD name"'}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with two columns, search terms with quotes on both and without logical operators' do
|
|
@result = @evaluator.parse('tag:"1 2 3" name:"WILD name"')
|
|
|
|
@expected_array = [
|
|
{'tag' => '"1 2 3"'},
|
|
{'name' => '"WILD name"'}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests query with three columns, search terms with quotes on both and without logical operators' do
|
|
@result = @evaluator.parse('tag:"1 2 3" name:"WILD name" name:"ANOTHER wild name"')
|
|
|
|
@expected_array = [
|
|
{'tag' => '"1 2 3"'},
|
|
{:OPERATOR_OR => [
|
|
{'name' => '"WILD name"'},
|
|
{'name' => '"ANOTHER wild name"'}
|
|
]}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_array
|
|
end
|
|
|
|
it 'tests complex query' do
|
|
@result = @evaluator.parse('(device-id:"with space" tag:mta no-quotes-id-123)'\
|
|
'or "id with quotes-5" and ( ("id with q 10" or "id with q 20")'\
|
|
'and ("id with Q 30" "id with Q 40") and not id-without-Q-50)')
|
|
|
|
# (device-id:"with space" tag:mta no-quotes-id-123) or "id with quotes-5" and ( ("id with q 10" or "id with q 20") and ("id with Q 30" "id with Q 40") and not id-without-Q-50)
|
|
# _____________________A___________________________ or _______B___________ and __________________________________________________C______________________________________________
|
|
# (____A1________________ ___A2__ ______A3________) or _______B___________ and ( ____________C1____________________ and ______________C2_______________ and ______C3___________)
|
|
|
|
|
|
@A = {:OPERATOR_OR => [
|
|
{'device-id' => '"with space"'},
|
|
{:OPERATOR_OR => [
|
|
{'tag' => 'mta'},
|
|
{:DEFAULT_COLUMN => 'no-quotes-id-123'}]
|
|
}
|
|
]}
|
|
|
|
@B = {:DEFAULT_COLUMN => '"id with quotes-5"'}
|
|
|
|
|
|
@C1 = {:OPERATOR_OR => [
|
|
{:DEFAULT_COLUMN => '"id with q 10"'},
|
|
{:DEFAULT_COLUMN => '"id with q 20"'}
|
|
]}
|
|
|
|
|
|
@C2 = {:OPERATOR_OR => [
|
|
{:DEFAULT_COLUMN => '"id with Q 30"'},
|
|
{:DEFAULT_COLUMN => '"id with Q 40"'}
|
|
]}
|
|
|
|
@C3 = {:OPERATOR_NOT => {:DEFAULT_COLUMN => 'id-without-Q-50'}}
|
|
|
|
@C = {:OPERATOR_AND => [
|
|
{:OPERATOR_AND => [
|
|
@C1,
|
|
@C2
|
|
]},
|
|
@C3
|
|
]}
|
|
|
|
@expected_final_array_result = [
|
|
@A,
|
|
{:OPERATOR_AND => [
|
|
@B,
|
|
@C
|
|
]}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @expected_final_array_result
|
|
end
|
|
|
|
it 'tests query without column name containing AND word inside without quotes' do
|
|
@result = @evaluator.parse('land')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq 'land'
|
|
end
|
|
|
|
it 'tests query without column name containing AND word inside with quotes' do
|
|
@result = @evaluator.parse('"land"')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq '"land"'
|
|
end
|
|
|
|
it 'tests query without column name and with word starting with AND without quotes' do
|
|
@result = @evaluator.parse('andromeda')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq 'andromeda'
|
|
end
|
|
|
|
it 'tests query without column name and with word starting with AND with quotes' do
|
|
@result = @evaluator.parse('"andromeda"')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq '"andromeda"'
|
|
end
|
|
|
|
it 'tests query with column name containing AND word inside' do
|
|
@result = @evaluator.parse('land:some-search-term')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result['land']).to eq 'some-search-term'
|
|
end
|
|
|
|
it 'tests query with column name starting with AND' do
|
|
@result = @evaluator.parse('andromeda:some-search-term')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result['andromeda']).to eq 'some-search-term'
|
|
end
|
|
|
|
it 'tests query with search term without quotes containing AND word inside' do
|
|
@result = @evaluator.parse('name:land')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result['name']).to eq 'land'
|
|
end
|
|
|
|
it 'tests query with search term with quotes containing AND word inside' do
|
|
@result = @evaluator.parse('name:"land"')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result['name']).to eq '"land"'
|
|
end
|
|
|
|
it 'tests query with search term without quotes and search term starting with AND without quotes' do
|
|
@result = @evaluator.parse('name:andromeda')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result['name']).to eq 'andromeda'
|
|
end
|
|
|
|
it 'tests query with search term without quotes and search term starting with AND with quotes' do
|
|
@result = @evaluator.parse('name:"andrew"')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result['name']).to eq '"andrew"'
|
|
end
|
|
|
|
it 'tests query with search term in brackets with AND inside word' do
|
|
@result = @evaluator.parse('(land)')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq 'land'
|
|
end
|
|
|
|
it 'tests query with search term in brackets starting with AND' do
|
|
@result = @evaluator.parse('(andromeda)')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq 'andromeda'
|
|
end
|
|
|
|
it 'tests query with multiple search terms with mixed and-or-not after dash and underscore' do
|
|
@result = @evaluator.parse('123-and-456 -or-2 -not_not_1')
|
|
|
|
@or_array_1 = [
|
|
{:DEFAULT_COLUMN => '-or-2'},
|
|
{:DEFAULT_COLUMN => '-not_not_1'}
|
|
]
|
|
|
|
@last_or_array = [
|
|
{:DEFAULT_COLUMN => '123-and-456'},
|
|
{:OPERATOR_OR => @or_array_1}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @last_or_array
|
|
end
|
|
|
|
it 'tests query with search term in brackets with AND inside word with quotes' do
|
|
@result = @evaluator.parse('("land")')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq '"land"'
|
|
end
|
|
|
|
it 'tests query with search term in brackets starting with AND with quotes' do
|
|
@result = @evaluator.parse('("andromeda")')
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:DEFAULT_COLUMN]).to eq '"andromeda"'
|
|
end
|
|
|
|
it 'tests query with multiple search terms starting with AND' do
|
|
@result = @evaluator.parse('land andrew and andromeda or orlando')
|
|
|
|
@and_array = [
|
|
{:DEFAULT_COLUMN=>'andrew'},
|
|
{:DEFAULT_COLUMN=>'andromeda'}
|
|
]
|
|
|
|
@last_or_array = [
|
|
{:OPERATOR_AND => @and_array},
|
|
{:DEFAULT_COLUMN => 'orlando'}
|
|
]
|
|
|
|
@main_or_array = [
|
|
{:DEFAULT_COLUMN => 'land'},
|
|
{:OPERATOR_OR => @last_or_array}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @main_or_array
|
|
end
|
|
|
|
it 'tests query with multiple search terms with dash and underscore chars' do
|
|
@result = @evaluator.parse('land 123-andrew or -andrew- and not _ornela_ or ornela')
|
|
|
|
@and_array = [
|
|
{:DEFAULT_COLUMN=>'-andrew-'},
|
|
{:OPERATOR_NOT=>{:DEFAULT_COLUMN => '_ornela_'}}
|
|
]
|
|
|
|
@intra_or_array = [
|
|
{:DEFAULT_COLUMN => '123-andrew'},
|
|
{:OPERATOR_AND => @and_array}
|
|
]
|
|
|
|
@last_or_array = [
|
|
{:OPERATOR_OR => @intra_or_array},
|
|
{:DEFAULT_COLUMN => 'ornela'}
|
|
]
|
|
|
|
@main_or_array = [
|
|
{:DEFAULT_COLUMN => 'land'},
|
|
{:OPERATOR_OR => @last_or_array}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @main_or_array
|
|
|
|
end
|
|
|
|
it 'tests query with multiple search terms with dash and underscore chars under quotes' do
|
|
@result = @evaluator.parse('"land" "123-andrew" or "-andrew-"')
|
|
|
|
|
|
@last_or_array = [
|
|
{:DEFAULT_COLUMN => '"123-andrew"'},
|
|
{:DEFAULT_COLUMN => '"-andrew-"'}
|
|
]
|
|
|
|
@main_or_array = [
|
|
{:DEFAULT_COLUMN => '"land"'},
|
|
{:OPERATOR_OR => @last_or_array}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @main_or_array
|
|
end
|
|
|
|
it 'tests query with multiple search terms with mixed and-or-not on start' do
|
|
@result = @evaluator.parse('sindy andora ornoty notary')
|
|
|
|
@or_array_1 = [
|
|
{:DEFAULT_COLUMN=>'ornoty'},
|
|
{:DEFAULT_COLUMN=>'notary'}
|
|
]
|
|
|
|
@or_array_2 = [
|
|
{:DEFAULT_COLUMN => 'andora'},
|
|
{:OPERATOR_OR => @or_array_1}
|
|
]
|
|
|
|
@main_or_array = [
|
|
{:DEFAULT_COLUMN => 'sindy'},
|
|
{:OPERATOR_OR => @or_array_2}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @main_or_array
|
|
end
|
|
|
|
it 'tests query with multiple search terms with mixed and-or-not on start and with logical operators between' do
|
|
@result = @evaluator.parse('sindy and andora-notary or not ornoty notary')
|
|
|
|
@and_array = [
|
|
{:DEFAULT_COLUMN=>'sindy'},
|
|
{:DEFAULT_COLUMN=>'andora-notary'}
|
|
]
|
|
|
|
@not_or_array = [
|
|
{:DEFAULT_COLUMN => 'ornoty'},
|
|
{:DEFAULT_COLUMN => 'notary'}
|
|
]
|
|
|
|
@main_or_array = [
|
|
{:OPERATOR_AND => @and_array},
|
|
{:OPERATOR_NOT => {
|
|
:OPERATOR_OR => @not_or_array
|
|
}}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_OR]).to eq @main_or_array
|
|
end
|
|
|
|
it 'tests query with multiple search terms with mixed and-or-not on start and with logical operators between' do
|
|
@result = @evaluator.parse('(sindy or andora-notary)and not(ornoty notary)')
|
|
|
|
@or_array_1 = [
|
|
{:DEFAULT_COLUMN=>'sindy'},
|
|
{:DEFAULT_COLUMN=>'andora-notary'}
|
|
]
|
|
|
|
@not_or_array = [
|
|
{:DEFAULT_COLUMN => 'ornoty'},
|
|
{:DEFAULT_COLUMN => 'notary'}
|
|
]
|
|
|
|
@main_and_array = [
|
|
{:OPERATOR_OR => @or_array_1},
|
|
{:OPERATOR_NOT => {
|
|
:OPERATOR_OR => @not_or_array
|
|
}}
|
|
]
|
|
|
|
expect(@result.length).to eq 1
|
|
expect(@result[:OPERATOR_AND]).to eq @main_and_array
|
|
end
|
|
|
|
end
|
|
end
|