public void DoubleOperatorsIsNotValid()
        {
            var sut = new LuceneQueryParser();

            Assert.Throws <FormatException>(() => {
                var result = sut.Parse("something AND OR otherthing");
                var ast    = DebugQueryVisitor.Run(result);
            });
        }
        public void CanGenerateQuery(string query)
        {
            var parser = new QueryParser();
            var result = parser.Parse(query);

            Debug.WriteLine(DebugQueryVisitor.Run(result));
            var generatedQuery = GenerateQueryVisitor.Run(result);

            Assert.Equal(query, generatedQuery);
        }
        public void CanHandleUnterminatedRegex()
        {
            var sut = new LuceneQueryParser();

            var ex = Assert.Throws <FormatException>(() => {
                var result = sut.Parse(@"/\(\[A-Za-z\/\]+\).*?");
                var ast    = DebugQueryVisitor.Run(result);
            });

            Assert.Contains("Unterminated regex", ex.Message);
        }
        public void DoubleUnterminatedQuotedStringIsNotValid()
        {
            var sut = new LuceneQueryParser();

            var ex = Assert.Throws <FormatException>(() => {
                var result = sut.Parse("\"something\"\"");
                var ast    = DebugQueryVisitor.Run(result);
            });

            Assert.Contains("Unexpected character", ex.Message);
        }
        public void PrefixWithoutImmediateExpressionIsInvalid()
        {
            var sut = new LuceneQueryParser();

            var ex = Assert.Throws <FormatException>(() => {
                var result = sut.Parse("something + other");
                var ast    = DebugQueryVisitor.Run(result);
            });

            Assert.Contains("Unexpected character '+'.", ex.Message);
        }
        public void CanParseNotBeforeParens()
        {
            var sut = new LuceneQueryParser();

            var result = sut.Parse("NOT (dog parrot)");
            var ast    = DebugQueryVisitor.Run(result);

            Assert.IsType <GroupNode>(result.Left);
            Assert.True((result.Left as GroupNode).HasParens);
            Assert.True((result.Left as GroupNode).IsNegated);
        }
        public async Task CanGenerateSingleQueryAsync()
        {
            string query  = "datehistogram:(date~2^-5\\:30 min:date max:date)";
            var    parser = new LuceneQueryParser();

            var result = await parser.ParseAsync(query);

            _logger.LogInformation(await DebugQueryVisitor.RunAsync(result));
            string generatedQuery = await GenerateQueryVisitor.RunAsync(result);

            Assert.Equal(query, generatedQuery);

            await new AssignAggregationTypeVisitor().AcceptAsync(result, null);
            _logger.LogInformation(DebugQueryVisitor.Run(result));
        }