List<Input> makeInputs(String inputsStr) { List<Input> result = new LinkedList<>(); for (String inputStr : inputsStr.split(",")) { inputsStr = inputsStr.trim(); if (inputStr.length() > 0) { List<querqy.rewrite.commonrules.model.Term> terms = new LinkedList<>(); for (String termStr : inputStr.split("\\s+")) { if (termStr.length() > 0) { terms.add(new querqy.rewrite.commonrules.model.Term(termStr.toCharArray(), 0, termStr.length(), null)); } } if (!terms.isEmpty()) { result.add(new Input(terms)); } } } return result; }
@Test public void testGetInputSequencesForSingleTermWithFieldName() { char[] s1 = "test".toCharArray(); Term term1 = new Term(s1, 0, s1.length, Arrays.asList("name1")); Input input = new Input(Arrays.asList(term1), false, false); List<ComparableCharSequence> sequences = input.getInputSequences(false); assertNotNull(sequences); assertEquals(1, sequences.size()); ComparableCharSequence seq = sequences.get(0); assertNotNull(seq); assertEquals(0, seq.compareTo("name1:test")); }
@Test public void testGetInputSequencesForTermsWithAndWithoutFieldNames() { char[] s1 = "test".toCharArray(); Term term1 = new Term(s1, 0, s1.length, Arrays.asList("name1", "name2")); char[] s2 = "test2".toCharArray(); Term term2 = new Term(s2, 0, s2.length, null); Input input = new Input(Arrays.asList(term1, term2), false, false); List<ComparableCharSequence> sequences = input.getInputSequences(false); assertNotNull(sequences); assertEquals(2, sequences.size()); ComparableCharSequence seq = sequences.get(0); assertNotNull(seq); assertEquals("name1:test test2", seq.toString()); seq = sequences.get(1); assertNotNull(seq); assertEquals("name2:test test2", seq.toString()); }
@Test public void testGetInputSequencesForSingleTermWithoutFieldName() { char[] s1 = "test".toCharArray(); Term term1 = new Term(s1, 0, s1.length, null); Input input = new Input(Arrays.asList(term1), false, false); List<ComparableCharSequence> sequences = input.getInputSequences(false); assertNotNull(sequences); assertEquals(1, sequences.size()); ComparableCharSequence seq = sequences.get(0); assertNotNull(seq); assertEquals(0, seq.compareTo("test")); }
@SuppressWarnings("unchecked") @Test public void testThatSingleDecorationIsEmitted() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); DecorateInstruction deco = new DecorateInstruction("deco1"); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) deco))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("a x"); Map<String, Object> context = new HashMap<>(); rewriter.rewrite(query, context); assertThat((Set<Object>)context.get(DecorateInstruction.CONTEXT_KEY), contains( equalTo((Object) "deco1") )); }
@Test public void testGetInputSequencesForTermsWithoutFieldName() { char[] s1 = "test".toCharArray(); Term term1 = new Term(s1, 0, s1.length, null); char[] s2 = "test2".toCharArray(); Term term2 = new Term(s2, 0, s2.length, null); Input input = new Input(Arrays.asList(term1, term2), false, false); List<ComparableCharSequence> sequences = input.getInputSequences(false); assertNotNull(sequences); assertEquals(1, sequences.size()); ComparableCharSequence seq = sequences.get(0); assertNotNull(seq); assertEquals(0, seq.compareTo("test test2")); }
@Test public void testGetInputSequencesForSingleTermWithFieldNames() { char[] s1 = "test".toCharArray(); Term term1 = new Term(s1, 0, s1.length, Arrays.asList("name1", "name2")); Input input = new Input(Arrays.asList(term1), false, false); List<ComparableCharSequence> sequences = input.getInputSequences(false); assertNotNull(sequences); assertEquals(2, sequences.size()); ComparableCharSequence seq = sequences.get(0); assertNotNull(seq); assertEquals(0, seq.compareTo("name1:test")); seq = sequences.get(1); assertNotNull(seq); assertEquals(0, seq.compareTo("name2:test")); }
@Test public void testThatTermIsNotRemovedOnceIfThereASecondDMQWithTheSameTermAndNoOtherTermExists() throws Exception { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); DeleteInstruction delete = new DeleteInstruction(Arrays.asList(mkTerm("a"))); builder.addRule(new Input(Arrays.asList(mkTerm("a")), false, false), new Instructions(Arrays.asList((Instruction) delete))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); Query rewritten = (Query) rewriter.rewrite(makeQuery("a a"), EMPTY_CONTEXT).getUserQuery(); assertThat(rewritten, bq( dmq( term("a") ) )); }
@Test public void testThatTermIsRemovedIfThereASecondDMQWithoutTheTerm() throws Exception { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); DeleteInstruction delete = new DeleteInstruction(Arrays.asList(mkTerm("a"))); builder.addRule(new Input(Arrays.asList(mkTerm("a")), false, false), new Instructions(Arrays.asList((Instruction) delete))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); Query rewritten = (Query) rewriter.rewrite(makeQuery("a b"), EMPTY_CONTEXT).getUserQuery(); assertThat(rewritten, bq( dmq( term("b") ) )); }
@Test public void testThatNothingIsDeletedIfWeWouldEndUpWithAnEmptyQuery() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); DeleteInstruction delete = new DeleteInstruction(Arrays.asList(mkTerm("a"))); builder.addRule(new Input(Arrays.asList(mkTerm("a")), false, false), new Instructions(Arrays.asList((Instruction) delete))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("a"); Query rewritten = (Query) rewriter.rewrite(query, EMPTY_CONTEXT).getUserQuery(); assertThat(rewritten, bq( dmq( term("a") ) )); }
@Test public void testThatFilterQueriesAreMarkedAsGenerated() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); FilterInstruction filterInstruction = new FilterInstruction(makeQuery("a").getUserQuery()); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) filterInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<QuerqyQuery<?>> filterQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getFilterQueries(); QuerqyQuery<?> qq = filterQueries.iterator().next(); assertTrue(qq instanceof BooleanQuery); assertThat((BooleanQuery) qq, bq( dmq(must(), term("a", true)) ) ); }
@Test public void testThatSingleTermIsExpandedWithSingleTerm() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); SynonymInstruction synInstruction = new SynonymInstruction(Arrays.asList(mkTerm("s1"))); builder.addRule(new Input(Arrays.asList(mkTerm("a"))), new Instructions(Arrays.asList((Instruction) synInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("a"); Query rewritten = (Query) rewriter.rewrite(query, EMPTY_CONTEXT).getUserQuery(); assertThat(rewritten, bq( dmq( term("a", false), term("s1", true) ) )); }
public void testThatMainQueryIsNotMarkedAsGenerated() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("-a b").getUserQuery(), BoostDirection.UP, 0.5f); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); QuerqyQuery<?> mainQuery = rewriter.rewrite(query, EMPTY_CONTEXT).getUserQuery(); assertFalse(mainQuery.isGenerated()); }
@Test public void testThatMainQueryIsNotMarkedAsGenerated() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); FilterInstruction filterInstruction = new FilterInstruction(makeQuery("a").getUserQuery()); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) filterInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); QuerqyQuery<?> mainQuery = rewriter.rewrite(query, EMPTY_CONTEXT).getUserQuery(); assertFalse(mainQuery.isGenerated()); }
@Test public void testThatBoostQueriesWithMustClauseUseMM100ByDefault() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); FilterInstruction filterInstruction = new FilterInstruction(makeQuery("a b").getUserQuery()); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) filterInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<QuerqyQuery<?>> filterQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getFilterQueries(); QuerqyQuery<?> qq = filterQueries.iterator().next(); assertTrue(qq instanceof BooleanQuery); assertThat((BooleanQuery) qq, bq( dmq(must(), term("a", true)), dmq(must(), term("b", true)) ) ); }
@Test public void testSingeInputSingleInstruction() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); String s1 = "test"; Input input = new Input(inputTerms(null, s1), false, false); Instructions instructions = instructions("instruction1"); builder.addRule(input, instructions); RulesCollection rulesCollection = builder.build(); PositionSequence<InputSequenceElement> sequence = new PositionSequence<>(); sequence.nextPosition(); sequence.addElement(new Term(null, s1)); List<Action> actions = rulesCollection.getRewriteActions(sequence); assertThat(actions, contains(new Action(Arrays.asList(instructions), termMatches(s1), 0, 1))); }
@Test public void testSingleInputTwoInstructionsFromSameRule() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); String s1 = "test"; Input input = new Input(inputTerms(null, s1), false, false); Instructions instructions = instructions("instruction1", "instruction2"); builder.addRule(input, instructions); RulesCollection rulesCollection = builder.build(); PositionSequence<InputSequenceElement> sequence = new PositionSequence<>(); sequence.nextPosition(); sequence.addElement(new Term(null, s1)); List<Action> actions = rulesCollection.getRewriteActions(sequence); assertThat(actions, contains(new Action(Arrays.asList(instructions), termMatches(s1), 0, 1))); }
@Test public void testThatBoostQueriesAreMarkedAsGenerated() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("a").getUserQuery(), BoostDirection.UP, 0.5f); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<BoostQuery> upQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getBoostUpQueries(); assertThat(upQueries, contains( boostQ( bq( dmq(must(), term("a", true)) ), 0.5f ))); }
@Test public void testThatUpQueriesAreOfTypeQuery() throws Exception { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); BoostInstruction boostInstruction = new BoostInstruction(makeQuery("a b").getUserQuery(), BoostDirection.UP, 0.5f); builder.addRule(new Input(Arrays.asList(mkTerm("x")), false, false), new Instructions(Arrays.asList((Instruction) boostInstruction))); RulesCollection rules = builder.build(); CommonRulesRewriter rewriter = new CommonRulesRewriter(rules); ExpandedQuery query = makeQuery("x"); Collection<BoostQuery> upQueries = rewriter.rewrite(query, EMPTY_CONTEXT).getBoostUpQueries(); for (BoostQuery bq : upQueries) { Assert.assertTrue(bq.getQuery() instanceof Query); } }
@Test public void testSameInputTwoInstructionsFromDiffentRules() { RulesCollectionBuilder builder = new TrieMapRulesCollectionBuilder(false); String s1 = "test"; Input input = new Input(inputTerms(null, s1), false, false); Instructions instructions1 = instructions("instruction1"); builder.addRule(input, instructions1); Instructions instructions2 = instructions("instruction2"); builder.addRule(input, instructions2); RulesCollection rulesCollection = builder.build(); PositionSequence<InputSequenceElement> sequence = new PositionSequence<>(); sequence.nextPosition(); sequence.addElement(new Term(null, s1)); List<Action> actions = rulesCollection.getRewriteActions(sequence); assertThat(actions, contains(new Action(Arrays.asList(instructions1, instructions2), termMatches(s1), 0, 1))); }