From 8ccd79aa913b519c9fd282f7c31d8429ab41f5ea Mon Sep 17 00:00:00 2001 From: carlosdelest Date: Wed, 23 Apr 2025 09:08:15 +0200 Subject: [PATCH 1/7] Fix synonyms IT tests --- muted-tests.yml | 6 ------ .../synonyms/SynonymsManagementAPIServiceIT.java | 13 +++++++++---- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/muted-tests.yml b/muted-tests.yml index d7f4fa7211169..df8ad9079cbfe 100644 --- a/muted-tests.yml +++ b/muted-tests.yml @@ -441,12 +441,6 @@ tests: - class: org.elasticsearch.xpack.esql.plugin.DataNodeRequestSenderIT method: testSearchWhileRelocating issue: https://github.com/elastic/elasticsearch/issues/127188 -- class: org.elasticsearch.synonyms.SynonymsManagementAPIServiceIT - method: testUpdateRuleWithMaxSynonyms - issue: https://github.com/elastic/elasticsearch/issues/127195 -- class: org.elasticsearch.synonyms.SynonymsManagementAPIServiceIT - method: testCreateRuleWithMaxSynonyms - issue: https://github.com/elastic/elasticsearch/issues/127203 # Examples: # diff --git a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java index 9b428321fa6a7..7a93554826d32 100644 --- a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java +++ b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java @@ -9,6 +9,8 @@ package org.elasticsearch.synonyms; +import com.carrotsearch.randomizedtesting.annotations.Repeat; + import org.apache.logging.log4j.Logger; import org.elasticsearch.action.ActionListener; import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; @@ -127,6 +129,7 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } + @Repeat(iterations=1000) public void testCreateTooManySynonymsUsingRuleUpdates() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); int rulesToUpdate = randomIntBetween(1, 10); @@ -135,7 +138,7 @@ public void testCreateTooManySynonymsUsingRuleUpdates() throws InterruptedExcept synonymsManagementAPIService.putSynonymsSet( synonymSetId, randomSynonymsSet(synonymsToCreate), - randomBoolean(), + true, new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { @@ -143,7 +146,7 @@ public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonym SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); for (int i = 0; i < rulesToUpdate; i++) { - synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], true, new ActionListener<>() { + synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { updatedRulesLatch.countDown(); @@ -203,6 +206,7 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } + @Repeat(iterations=1000) public void testUpdateRuleWithMaxSynonyms() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); String synonymSetId = randomIdentifier(); @@ -238,16 +242,17 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } + @Repeat(iterations=1000) public void testCreateRuleWithMaxSynonyms() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); String synonymSetId = randomIdentifier(); String ruleId = randomIdentifier(); SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); - synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, randomBoolean(), new ActionListener<>() { + synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { // Updating a rule fails - synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), true, new ActionListener<>() { + synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), randomBoolean(), new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { fail("Should not create a new rule that does not exist when at max capacity"); From e334330b1f79a5c52b85d39bc8f20dbe636b809f Mon Sep 17 00:00:00 2001 From: carlosdelest Date: Wed, 23 Apr 2025 09:11:46 +0200 Subject: [PATCH 2/7] Reduce iterations --- .../synonyms/SynonymsManagementAPIServiceIT.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java index 7a93554826d32..0d62f99c86446 100644 --- a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java +++ b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java @@ -129,7 +129,7 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } - @Repeat(iterations=1000) + @Repeat(iterations=500) public void testCreateTooManySynonymsUsingRuleUpdates() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); int rulesToUpdate = randomIntBetween(1, 10); @@ -206,7 +206,7 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } - @Repeat(iterations=1000) + @Repeat(iterations=500) public void testUpdateRuleWithMaxSynonyms() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); String synonymSetId = randomIdentifier(); @@ -242,7 +242,7 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } - @Repeat(iterations=1000) + @Repeat(iterations=500) public void testCreateRuleWithMaxSynonyms() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); String synonymSetId = randomIdentifier(); From 0b97e99aaf823457bef04d171387f5cbb4a7a613 Mon Sep 17 00:00:00 2001 From: elasticsearchmachine Date: Wed, 23 Apr 2025 07:22:23 +0000 Subject: [PATCH 3/7] [CI] Auto commit changes from spotless --- .../SynonymsManagementAPIServiceIT.java | 134 +++++++++--------- 1 file changed, 67 insertions(+), 67 deletions(-) diff --git a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java index 0d62f99c86446..f825a9bc4e789 100644 --- a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java +++ b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java @@ -129,84 +129,79 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } - @Repeat(iterations=500) + @Repeat(iterations = 500) public void testCreateTooManySynonymsUsingRuleUpdates() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); int rulesToUpdate = randomIntBetween(1, 10); int synonymsToCreate = maxSynonymSets - rulesToUpdate; String synonymSetId = randomIdentifier(); - synonymsManagementAPIService.putSynonymsSet( - synonymSetId, - randomSynonymsSet(synonymsToCreate), - true, - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Create as many rules as should fail - SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); - CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); - for (int i = 0; i < rulesToUpdate; i++) { - synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { + synonymsManagementAPIService.putSynonymsSet(synonymSetId, randomSynonymsSet(synonymsToCreate), true, new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Create as many rules as should fail + SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); + CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); + for (int i = 0; i < rulesToUpdate; i++) { + synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + updatedRulesLatch.countDown(); + } + + @Override + public void onFailure(Exception e) { + fail(e); + } + }); + } + try { + updatedRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { + fail(e); + } + + // Updating more rules fails + int rulesToInsert = rules.length - rulesToUpdate; + CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); + for (int i = rulesToUpdate; i < rulesToInsert; i++) { + synonymsManagementAPIService.putSynonymRule( + // Error here + synonymSetId, + rules[i], + randomBoolean(), + new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - updatedRulesLatch.countDown(); + fail("Shouldn't have been able to update a rule"); } @Override public void onFailure(Exception e) { - fail(e); - } - }); - } - try { - updatedRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } - - // Updating more rules fails - int rulesToInsert = rules.length - rulesToUpdate; - CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); - for (int i = rulesToUpdate; i < rulesToInsert; i++) { - synonymsManagementAPIService.putSynonymRule( - // Error here - synonymSetId, - rules[i], - randomBoolean(), - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Shouldn't have been able to update a rule"); - } - - @Override - public void onFailure(Exception e) { - if (e instanceof IllegalArgumentException == false) { - fail(e); - } - updatedRulesLatch.countDown(); + if (e instanceof IllegalArgumentException == false) { + fail(e); } + updatedRulesLatch.countDown(); } - ); - } - try { - insertRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } + } + ); } - - @Override - public void onFailure(Exception e) { + try { + insertRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { fail(e); } } - ); + + @Override + public void onFailure(Exception e) { + fail(e); + } + }); latch.await(5, TimeUnit.SECONDS); } - @Repeat(iterations=500) + @Repeat(iterations = 500) public void testUpdateRuleWithMaxSynonyms() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); String synonymSetId = randomIdentifier(); @@ -242,7 +237,7 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } - @Repeat(iterations=500) + @Repeat(iterations = 500) public void testCreateRuleWithMaxSynonyms() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); String synonymSetId = randomIdentifier(); @@ -252,17 +247,22 @@ public void testCreateRuleWithMaxSynonyms() throws InterruptedException { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { // Updating a rule fails - synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), randomBoolean(), new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Should not create a new rule that does not exist when at max capacity"); - } + synonymsManagementAPIService.putSynonymRule( + synonymSetId, + randomSynonymRule(ruleId), + randomBoolean(), + new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + fail("Should not create a new rule that does not exist when at max capacity"); + } - @Override - public void onFailure(Exception e) { - latch.countDown(); + @Override + public void onFailure(Exception e) { + latch.countDown(); + } } - }); + ); } @Override From 616f3c7c02c3fbc09daaa05a861436318d61aab3 Mon Sep 17 00:00:00 2001 From: carlosdelest Date: Wed, 23 Apr 2025 09:42:52 +0200 Subject: [PATCH 4/7] Remove Repeat annotation as it's forbidden --- .../SynonymsManagementAPIServiceIT.java | 232 +++++++++--------- 1 file changed, 117 insertions(+), 115 deletions(-) diff --git a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java index 0d62f99c86446..9d3dcfcd65eff 100644 --- a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java +++ b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java @@ -9,8 +9,6 @@ package org.elasticsearch.synonyms; -import com.carrotsearch.randomizedtesting.annotations.Repeat; - import org.apache.logging.log4j.Logger; import org.elasticsearch.action.ActionListener; import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; @@ -129,149 +127,153 @@ public void onFailure(Exception e) { latch.await(5, TimeUnit.SECONDS); } - @Repeat(iterations=500) public void testCreateTooManySynonymsUsingRuleUpdates() throws InterruptedException { - CountDownLatch latch = new CountDownLatch(1); - int rulesToUpdate = randomIntBetween(1, 10); - int synonymsToCreate = maxSynonymSets - rulesToUpdate; - String synonymSetId = randomIdentifier(); - synonymsManagementAPIService.putSynonymsSet( - synonymSetId, - randomSynonymsSet(synonymsToCreate), - true, - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Create as many rules as should fail - SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); - CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); - for (int i = 0; i < rulesToUpdate; i++) { - synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - updatedRulesLatch.countDown(); - } - - @Override - public void onFailure(Exception e) { - fail(e); - } - }); - } - try { - updatedRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } - - // Updating more rules fails - int rulesToInsert = rules.length - rulesToUpdate; - CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); - for (int i = rulesToUpdate; i < rulesToInsert; i++) { - synonymsManagementAPIService.putSynonymRule( - // Error here - synonymSetId, - rules[i], - randomBoolean(), - new ActionListener<>() { + for (int iters = 0; iters < 500; iters++) { + CountDownLatch latch = new CountDownLatch(1); + int rulesToUpdate = randomIntBetween(1, 10); + int synonymsToCreate = maxSynonymSets - rulesToUpdate; + String synonymSetId = randomIdentifier(); + synonymsManagementAPIService.putSynonymsSet( + synonymSetId, + randomSynonymsSet(synonymsToCreate), + true, + new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Create as many rules as should fail + SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); + CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); + for (int i = 0; i < rulesToUpdate; i++) { + synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Shouldn't have been able to update a rule"); + updatedRulesLatch.countDown(); } @Override public void onFailure(Exception e) { - if (e instanceof IllegalArgumentException == false) { - fail(e); + fail(e); + } + }); + } + try { + updatedRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { + fail(e); + } + + // Updating more rules fails + int rulesToInsert = rules.length - rulesToUpdate; + CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); + for (int i = rulesToUpdate; i < rulesToInsert; i++) { + synonymsManagementAPIService.putSynonymRule( + // Error here + synonymSetId, + rules[i], + randomBoolean(), + new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + fail("Shouldn't have been able to update a rule"); + } + + @Override + public void onFailure(Exception e) { + if (e instanceof IllegalArgumentException == false) { + fail(e); + } + updatedRulesLatch.countDown(); } - updatedRulesLatch.countDown(); } - } - ); + ); + } + try { + insertRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { + fail(e); + } } - try { - insertRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { + + @Override + public void onFailure(Exception e) { fail(e); } } + ); + + latch.await(5, TimeUnit.SECONDS); + } + } + + public void testUpdateRuleWithMaxSynonyms() throws InterruptedException { + for (int iters = 0; iters < 500; iters++) { + + CountDownLatch latch = new CountDownLatch(1); + String synonymSetId = randomIdentifier(); + SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); + synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Updating a rule fails + synonymsManagementAPIService.putSynonymRule( + synonymSetId, + synonymsSet[randomIntBetween(0, maxSynonymSets - 1)], + randomBoolean(), + new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + latch.countDown(); + } + + @Override + public void onFailure(Exception e) { + fail("Should update a rule that already exists at max capcity"); + } + } + ); + } @Override public void onFailure(Exception e) { fail(e); } - } - ); + }); - latch.await(5, TimeUnit.SECONDS); + latch.await(5, TimeUnit.SECONDS); + } } - @Repeat(iterations=500) - public void testUpdateRuleWithMaxSynonyms() throws InterruptedException { - CountDownLatch latch = new CountDownLatch(1); - String synonymSetId = randomIdentifier(); - SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); - synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Updating a rule fails - synonymsManagementAPIService.putSynonymRule( - synonymSetId, - synonymsSet[randomIntBetween(0, maxSynonymSets - 1)], - randomBoolean(), - new ActionListener<>() { + public void testCreateRuleWithMaxSynonyms() throws InterruptedException { + for (int iters = 0; iters < 500; iters++) { + CountDownLatch latch = new CountDownLatch(1); + String synonymSetId = randomIdentifier(); + String ruleId = randomIdentifier(); + SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); + synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Updating a rule fails + synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), randomBoolean(), new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - latch.countDown(); + fail("Should not create a new rule that does not exist when at max capacity"); } @Override public void onFailure(Exception e) { - fail("Should update a rule that already exists at max capcity"); + latch.countDown(); } - } - ); - } - - @Override - public void onFailure(Exception e) { - fail(e); - } - }); - - latch.await(5, TimeUnit.SECONDS); - } - - @Repeat(iterations=500) - public void testCreateRuleWithMaxSynonyms() throws InterruptedException { - CountDownLatch latch = new CountDownLatch(1); - String synonymSetId = randomIdentifier(); - String ruleId = randomIdentifier(); - SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); - synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Updating a rule fails - synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), randomBoolean(), new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Should not create a new rule that does not exist when at max capacity"); - } - - @Override - public void onFailure(Exception e) { - latch.countDown(); - } - }); - } + }); + } - @Override - public void onFailure(Exception e) { - fail(e); - } - }); + @Override + public void onFailure(Exception e) { + fail(e); + } + }); - latch.await(5, TimeUnit.SECONDS); + latch.await(5, TimeUnit.SECONDS); + } } public void testTooManySynonymsOnIndexTriggersWarning() throws InterruptedException { From bff1cf6cf9c0ba0219cef41417da60b7a1a4ed52 Mon Sep 17 00:00:00 2001 From: elasticsearchmachine Date: Wed, 23 Apr 2025 07:51:42 +0000 Subject: [PATCH 5/7] [CI] Auto commit changes from spotless --- .../SynonymsManagementAPIServiceIT.java | 128 +++++++++--------- 1 file changed, 64 insertions(+), 64 deletions(-) diff --git a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java index 9d3dcfcd65eff..a22eb6700c1e0 100644 --- a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java +++ b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java @@ -133,73 +133,68 @@ public void testCreateTooManySynonymsUsingRuleUpdates() throws InterruptedExcept int rulesToUpdate = randomIntBetween(1, 10); int synonymsToCreate = maxSynonymSets - rulesToUpdate; String synonymSetId = randomIdentifier(); - synonymsManagementAPIService.putSynonymsSet( - synonymSetId, - randomSynonymsSet(synonymsToCreate), - true, - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Create as many rules as should fail - SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); - CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); - for (int i = 0; i < rulesToUpdate; i++) { - synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { + synonymsManagementAPIService.putSynonymsSet(synonymSetId, randomSynonymsSet(synonymsToCreate), true, new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Create as many rules as should fail + SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); + CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); + for (int i = 0; i < rulesToUpdate; i++) { + synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + updatedRulesLatch.countDown(); + } + + @Override + public void onFailure(Exception e) { + fail(e); + } + }); + } + try { + updatedRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { + fail(e); + } + + // Updating more rules fails + int rulesToInsert = rules.length - rulesToUpdate; + CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); + for (int i = rulesToUpdate; i < rulesToInsert; i++) { + synonymsManagementAPIService.putSynonymRule( + // Error here + synonymSetId, + rules[i], + randomBoolean(), + new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - updatedRulesLatch.countDown(); + fail("Shouldn't have been able to update a rule"); } @Override public void onFailure(Exception e) { - fail(e); - } - }); - } - try { - updatedRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } - - // Updating more rules fails - int rulesToInsert = rules.length - rulesToUpdate; - CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); - for (int i = rulesToUpdate; i < rulesToInsert; i++) { - synonymsManagementAPIService.putSynonymRule( - // Error here - synonymSetId, - rules[i], - randomBoolean(), - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Shouldn't have been able to update a rule"); - } - - @Override - public void onFailure(Exception e) { - if (e instanceof IllegalArgumentException == false) { - fail(e); - } - updatedRulesLatch.countDown(); + if (e instanceof IllegalArgumentException == false) { + fail(e); } + updatedRulesLatch.countDown(); } - ); - } - try { - insertRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } + } + ); } - - @Override - public void onFailure(Exception e) { + try { + insertRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { fail(e); } } - ); + + @Override + public void onFailure(Exception e) { + fail(e); + } + }); latch.await(5, TimeUnit.SECONDS); } @@ -253,17 +248,22 @@ public void testCreateRuleWithMaxSynonyms() throws InterruptedException { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { // Updating a rule fails - synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), randomBoolean(), new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Should not create a new rule that does not exist when at max capacity"); - } + synonymsManagementAPIService.putSynonymRule( + synonymSetId, + randomSynonymRule(ruleId), + randomBoolean(), + new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + fail("Should not create a new rule that does not exist when at max capacity"); + } - @Override - public void onFailure(Exception e) { - latch.countDown(); + @Override + public void onFailure(Exception e) { + latch.countDown(); + } } - }); + ); } @Override From e7737b00135408c4e682efe72bc3be0eac762d84 Mon Sep 17 00:00:00 2001 From: carlosdelest Date: Wed, 23 Apr 2025 10:55:22 +0200 Subject: [PATCH 6/7] Remove repetitions --- .../SynonymsManagementAPIServiceIT.java | 227 +++++++++--------- 1 file changed, 110 insertions(+), 117 deletions(-) diff --git a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java index 9d3dcfcd65eff..c5d2863e9ac74 100644 --- a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java +++ b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java @@ -128,152 +128,145 @@ public void onFailure(Exception e) { } public void testCreateTooManySynonymsUsingRuleUpdates() throws InterruptedException { - for (int iters = 0; iters < 500; iters++) { - CountDownLatch latch = new CountDownLatch(1); - int rulesToUpdate = randomIntBetween(1, 10); - int synonymsToCreate = maxSynonymSets - rulesToUpdate; - String synonymSetId = randomIdentifier(); - synonymsManagementAPIService.putSynonymsSet( - synonymSetId, - randomSynonymsSet(synonymsToCreate), - true, - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Create as many rules as should fail - SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); - CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); - for (int i = 0; i < rulesToUpdate; i++) { - synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { + CountDownLatch latch = new CountDownLatch(1); + int rulesToUpdate = randomIntBetween(1, 10); + int synonymsToCreate = maxSynonymSets - rulesToUpdate; + String synonymSetId = randomIdentifier(); + synonymsManagementAPIService.putSynonymsSet( + synonymSetId, + randomSynonymsSet(synonymsToCreate), + true, + new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Create as many rules as should fail + SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); + CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); + for (int i = 0; i < rulesToUpdate; i++) { + synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + updatedRulesLatch.countDown(); + } + + @Override + public void onFailure(Exception e) { + fail(e); + } + }); + } + try { + updatedRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { + fail(e); + } + + // Updating more rules fails + int rulesToInsert = rules.length - rulesToUpdate; + CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); + for (int i = rulesToUpdate; i < rulesToInsert; i++) { + synonymsManagementAPIService.putSynonymRule( + // Error here + synonymSetId, + rules[i], + randomBoolean(), + new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - updatedRulesLatch.countDown(); + fail("Shouldn't have been able to update a rule"); } @Override public void onFailure(Exception e) { - fail(e); - } - }); - } - try { - updatedRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } - - // Updating more rules fails - int rulesToInsert = rules.length - rulesToUpdate; - CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); - for (int i = rulesToUpdate; i < rulesToInsert; i++) { - synonymsManagementAPIService.putSynonymRule( - // Error here - synonymSetId, - rules[i], - randomBoolean(), - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Shouldn't have been able to update a rule"); - } - - @Override - public void onFailure(Exception e) { - if (e instanceof IllegalArgumentException == false) { - fail(e); - } - updatedRulesLatch.countDown(); + if (e instanceof IllegalArgumentException == false) { + fail(e); } + updatedRulesLatch.countDown(); } - ); - } - try { - insertRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } + } + ); } - - @Override - public void onFailure(Exception e) { + try { + insertRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { fail(e); } } - ); - - latch.await(5, TimeUnit.SECONDS); - } - } - - public void testUpdateRuleWithMaxSynonyms() throws InterruptedException { - for (int iters = 0; iters < 500; iters++) { - - CountDownLatch latch = new CountDownLatch(1); - String synonymSetId = randomIdentifier(); - SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); - synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Updating a rule fails - synonymsManagementAPIService.putSynonymRule( - synonymSetId, - synonymsSet[randomIntBetween(0, maxSynonymSets - 1)], - randomBoolean(), - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - latch.countDown(); - } - - @Override - public void onFailure(Exception e) { - fail("Should update a rule that already exists at max capcity"); - } - } - ); - } @Override public void onFailure(Exception e) { fail(e); } - }); + } + ); - latch.await(5, TimeUnit.SECONDS); - } + latch.await(5, TimeUnit.SECONDS); } - public void testCreateRuleWithMaxSynonyms() throws InterruptedException { - for (int iters = 0; iters < 500; iters++) { - CountDownLatch latch = new CountDownLatch(1); - String synonymSetId = randomIdentifier(); - String ruleId = randomIdentifier(); - SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); - synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Updating a rule fails - synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), randomBoolean(), new ActionListener<>() { + public void testUpdateRuleWithMaxSynonyms() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + String synonymSetId = randomIdentifier(); + SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); + synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Updating a rule fails + synonymsManagementAPIService.putSynonymRule( + synonymSetId, + synonymsSet[randomIntBetween(0, maxSynonymSets - 1)], + randomBoolean(), + new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Should not create a new rule that does not exist when at max capacity"); + latch.countDown(); } @Override public void onFailure(Exception e) { - latch.countDown(); + fail("Should update a rule that already exists at max capcity"); } - }); - } + } + ); + } - @Override - public void onFailure(Exception e) { - fail(e); - } - }); + @Override + public void onFailure(Exception e) { + fail(e); + } + }); + + latch.await(5, TimeUnit.SECONDS); + } + + public void testCreateRuleWithMaxSynonyms() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + String synonymSetId = randomIdentifier(); + String ruleId = randomIdentifier(); + SynonymRule[] synonymsSet = randomSynonymsSet(maxSynonymSets, maxSynonymSets); + synonymsManagementAPIService.putSynonymsSet(synonymSetId, synonymsSet, true, new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Updating a rule fails + synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), randomBoolean(), new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + fail("Should not create a new rule that does not exist when at max capacity"); + } - latch.await(5, TimeUnit.SECONDS); - } + @Override + public void onFailure(Exception e) { + latch.countDown(); + } + }); + } + + @Override + public void onFailure(Exception e) { + fail(e); + } + }); + + latch.await(5, TimeUnit.SECONDS); } public void testTooManySynonymsOnIndexTriggersWarning() throws InterruptedException { From 57445949f6506459cd594ff31dd1b7033275ad31 Mon Sep 17 00:00:00 2001 From: elasticsearchmachine Date: Wed, 23 Apr 2025 09:11:51 +0000 Subject: [PATCH 7/7] [CI] Auto commit changes from spotless --- .../SynonymsManagementAPIServiceIT.java | 128 +++++++++--------- 1 file changed, 64 insertions(+), 64 deletions(-) diff --git a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java index c5d2863e9ac74..1872714b51820 100644 --- a/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java +++ b/server/src/internalClusterTest/java/org/elasticsearch/synonyms/SynonymsManagementAPIServiceIT.java @@ -132,73 +132,68 @@ public void testCreateTooManySynonymsUsingRuleUpdates() throws InterruptedExcept int rulesToUpdate = randomIntBetween(1, 10); int synonymsToCreate = maxSynonymSets - rulesToUpdate; String synonymSetId = randomIdentifier(); - synonymsManagementAPIService.putSynonymsSet( - synonymSetId, - randomSynonymsSet(synonymsToCreate), - true, - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - // Create as many rules as should fail - SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); - CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); - for (int i = 0; i < rulesToUpdate; i++) { - synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { + synonymsManagementAPIService.putSynonymsSet(synonymSetId, randomSynonymsSet(synonymsToCreate), true, new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + // Create as many rules as should fail + SynonymRule[] rules = randomSynonymsSet(atLeast(rulesToUpdate + 1)); + CountDownLatch updatedRulesLatch = new CountDownLatch(rulesToUpdate); + for (int i = 0; i < rulesToUpdate; i++) { + synonymsManagementAPIService.putSynonymRule(synonymSetId, rules[i], randomBoolean(), new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + updatedRulesLatch.countDown(); + } + + @Override + public void onFailure(Exception e) { + fail(e); + } + }); + } + try { + updatedRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { + fail(e); + } + + // Updating more rules fails + int rulesToInsert = rules.length - rulesToUpdate; + CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); + for (int i = rulesToUpdate; i < rulesToInsert; i++) { + synonymsManagementAPIService.putSynonymRule( + // Error here + synonymSetId, + rules[i], + randomBoolean(), + new ActionListener<>() { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - updatedRulesLatch.countDown(); + fail("Shouldn't have been able to update a rule"); } @Override public void onFailure(Exception e) { - fail(e); - } - }); - } - try { - updatedRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } - - // Updating more rules fails - int rulesToInsert = rules.length - rulesToUpdate; - CountDownLatch insertRulesLatch = new CountDownLatch(rulesToInsert); - for (int i = rulesToUpdate; i < rulesToInsert; i++) { - synonymsManagementAPIService.putSynonymRule( - // Error here - synonymSetId, - rules[i], - randomBoolean(), - new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Shouldn't have been able to update a rule"); - } - - @Override - public void onFailure(Exception e) { - if (e instanceof IllegalArgumentException == false) { - fail(e); - } - updatedRulesLatch.countDown(); + if (e instanceof IllegalArgumentException == false) { + fail(e); } + updatedRulesLatch.countDown(); } - ); - } - try { - insertRulesLatch.await(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - fail(e); - } + } + ); } - - @Override - public void onFailure(Exception e) { + try { + insertRulesLatch.await(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { fail(e); } } - ); + + @Override + public void onFailure(Exception e) { + fail(e); + } + }); latch.await(5, TimeUnit.SECONDS); } @@ -247,17 +242,22 @@ public void testCreateRuleWithMaxSynonyms() throws InterruptedException { @Override public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { // Updating a rule fails - synonymsManagementAPIService.putSynonymRule(synonymSetId, randomSynonymRule(ruleId), randomBoolean(), new ActionListener<>() { - @Override - public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { - fail("Should not create a new rule that does not exist when at max capacity"); - } + synonymsManagementAPIService.putSynonymRule( + synonymSetId, + randomSynonymRule(ruleId), + randomBoolean(), + new ActionListener<>() { + @Override + public void onResponse(SynonymsManagementAPIService.SynonymsReloadResult synonymsReloadResult) { + fail("Should not create a new rule that does not exist when at max capacity"); + } - @Override - public void onFailure(Exception e) { - latch.countDown(); + @Override + public void onFailure(Exception e) { + latch.countDown(); + } } - }); + ); } @Override