Skip to content

Syed irtaza code clone fix #23

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
irtaza780 wants to merge 11 commits into from
Closed

Syed irtaza code clone fix #23

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
cb430a2
Replacing multiline string concatenation with Text block
Selleen Mar 9, 2026
e0a0369
Merge pull request #9 from devdutt13/syed-development-branch
irtaza780 Mar 9, 2026
d9d00fb
Merge pull request #10 from devdutt13/roxana-develop-branch
devdutt13 Mar 10, 2026
e0285f9
Update TestDefinitionParserTest.java
devdutt13 Apr 7, 2026
8532459
fix #12: remove duplicated rule extraction logic
devdutt13 Apr 7, 2026
b33e9b1
fix #11: remove duplicated rule extraction logic
devdutt13 Apr 7, 2026
35b1941
Merge pull request #12 from devdutt13/devdutt-clone-removal
devdutt13 Apr 7, 2026
409db4a
Refactor NotificationFilterManager tests to remove code duplication
RollingJungle Apr 7, 2026
11577e9
Merge remote-tracking branch 'origin/master'
RollingJungle Apr 7, 2026
9a33ac7
Merge branch 'rilling:master' into master
Selleen Apr 7, 2026
39c7802
Add ResourceTestUtils for streamlined REST resource testing setup
irtaza780 Apr 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 7 additions & 5 deletions ...inminutes-ui/src/test/java/org/xwikiplatform/appwithinminutes/ClassEditSheetPageTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -92,12 +92,14 @@ void displayFieldPalette() throws Exception

XWikiDocument xwikiDocument =
this.xwiki.getDocument(new DocumentReference("xwiki", "Space", "Page"), this.context);

xwikiDocument.setContent("""
{include reference="AppWithinMinutes.ClassEditSheet" /}

xwikiDocument.setContent("{{include reference=\"AppWithinMinutes.ClassEditSheet\" /}}\n"
+ "\n"
+ "{{velocity}}\n"
+ "#displayFieldPalette()\n"
+ "{{/velocity}}\n");
{{velocity}}
#displayFieldPalette()
{{/velocity}}
""");
xwikiDocument.setSyntax(Syntax.XWIKI_2_1);
this.xwiki.saveDocument(xwikiDocument, this.context);

Expand Down
278 changes: 12 additions & 266 deletions .../org/xwiki/notifications/filters/internal/LegacyDefaultNotificationFilterManagerTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,303 +31,49 @@

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.xwiki.component.manager.ComponentManager;
import org.xwiki.model.ModelContext;
import org.xwiki.model.reference.DocumentReference;
import org.xwiki.model.reference.WikiReference;
import org.xwiki.notifications.NotificationConfiguration;
import org.xwiki.notifications.filters.NotificationFilter;
import org.xwiki.notifications.preferences.NotificationPreference;
import org.xwiki.test.junit5.mockito.ComponentTest;
import org.xwiki.test.junit5.mockito.InjectMockComponents;
import org.xwiki.test.junit5.mockito.MockComponent;
import org.xwiki.wiki.descriptor.WikiDescriptorManager;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

/**
* Unit tests for {@link LegacyDefaultNotificationFilterManager}
* Unit tests for {@link LegacyDefaultNotificationFilterManager}.
*
* @version $Id$
* @since 15.5RC1
*/
@ComponentTest
public class LegacyDefaultNotificationFilterManagerTest
public class LegacyDefaultNotificationFilterManagerTest extends AbstractNotificationFilterManagerTest
{
@InjectMockComponents
private LegacyDefaultNotificationFilterManager filterManager;

@MockComponent
private ComponentManager componentManager;

@MockComponent
private WikiDescriptorManager wikiDescriptorManager;

@MockComponent
private DocumentReference testUser;

@MockComponent
@Named("cached")
private FilterPreferencesModelBridge filterPreferencesModelBridge;

@MockComponent
private ModelContext modelContext;

@MockComponent
private NotificationConfiguration configuration;

@BeforeEach
void setUp() throws Exception
{
testUser = new DocumentReference("wiki", "test", "user");

// Set a default comportment for the wikiDescriptorManager
when(wikiDescriptorManager.getMainWikiId()).thenReturn("wiki");
when(wikiDescriptorManager.getCurrentWikiId()).thenReturn("currentWikiId");
when(wikiDescriptorManager.getAllIds()).thenReturn(Arrays.asList("wiki", "currentWikiId"));
}

@Test
void getAllNotificationsFiltersWithSubWiki() throws Exception
{
NotificationFilter fakeFilter1 = mock(NotificationFilter.class);
NotificationFilter fakeFilter2 = mock(NotificationFilter.class);

when(wikiDescriptorManager.getMainWikiId()).thenReturn("somethingElseThanwiki");

when(componentManager.getInstanceList(NotificationFilter.class))
.thenReturn(Arrays.asList(fakeFilter1, fakeFilter2));

Collection<NotificationFilter> filters = this.filterManager.getAllFilters(testUser, false);

assertEquals(2, filters.size());
assertTrue(filters.contains(fakeFilter1));
assertTrue(filters.contains(fakeFilter2));
}

@Test
void getAllFiltersWithMainWiki() throws Exception
{
NotificationFilter fakeFilter1 = mock(NotificationFilter.class);

when(componentManager.getInstanceMap(NotificationFilter.class))
.thenReturn(Collections.singletonMap("1", fakeFilter1));

Collection<NotificationFilter> filters = this.filterManager.getAllFilters(testUser, false);

assertEquals(1, filters.size());
assertTrue(filters.contains(fakeFilter1));
}

@Test
void getAllFiltersForWiki() throws Exception
{
NotificationFilter fakeFilter1 = mock(NotificationFilter.class);
NotificationFilter fakeFilter2 = mock(NotificationFilter.class);

WikiReference currentWiki = new WikiReference("current");
when(wikiDescriptorManager.getCurrentWikiReference()).thenReturn(currentWiki);

WikiReference argumentWiki = new WikiReference("foo");

when(componentManager.getInstanceList(NotificationFilter.class))
.thenReturn(Arrays.asList(fakeFilter1, fakeFilter2));

Collection<NotificationFilter> filters = this.filterManager.getAllFilters(argumentWiki);

assertEquals(2, filters.size());
assertTrue(filters.contains(fakeFilter1));
assertTrue(filters.contains(fakeFilter2));
verify(this.modelContext).setCurrentEntityReference(argumentWiki);
verify(this.modelContext).setCurrentEntityReference(currentWiki);
}

@Test
void getAllFiltersWithOneDisabledFilter() throws Exception
{
SystemUserNotificationFilter disabledFilter = mock(SystemUserNotificationFilter.class);

when(componentManager.getInstanceMap(NotificationFilter.class))
.thenReturn(Collections.singletonMap("1", disabledFilter));

when(disabledFilter.getName()).thenReturn(SystemUserNotificationFilter.FILTER_NAME);
Map<String, Boolean> filterActivations = new HashMap<>();
filterActivations.put(SystemUserNotificationFilter.FILTER_NAME, false);

Collection<NotificationFilter> filters = this.filterManager.getEnabledFilters(
this.filterManager.getAllFilters(testUser, true), filterActivations).collect(Collectors.toList());

assertEquals(0, filters.size());
}

@Test
void getFiltersWithMatchingFilters() throws Exception
{
NotificationFilter fakeFilter1 = mock(NotificationFilter.class);

NotificationPreference preference = mock(NotificationPreference.class);

when(fakeFilter1.matchesPreference(preference)).thenReturn(true);

Collection<NotificationFilter> filters = this.filterManager.getFiltersRelatedToNotificationPreference(
Arrays.asList(fakeFilter1), preference).collect(Collectors.toList());

assertEquals(1, filters.size());
assertTrue(filters.contains(fakeFilter1));
}

@Test
void getFiltersWithOneBadFilter() throws Exception
@Override
protected DefaultNotificationFilterManager getFilterManager()
{
NotificationFilter fakeFilter1 = mock(NotificationFilter.class);

NotificationPreference preference = mock(NotificationPreference.class);

when(fakeFilter1.matchesPreference(preference)).thenReturn(false);

Collection<NotificationFilter> filters = this.filterManager
.getFiltersRelatedToNotificationPreference(Arrays.asList(fakeFilter1), preference)
.collect(Collectors.toList());

assertEquals(0, filters.size());
return this.filterManager;
}

@Test
void getFiltersWithSpecificFilteringPhase() throws Exception
@BeforeEach
void setUp() throws Exception
{
NotificationFilter filter1 = mock(NotificationFilter.class);
NotificationFilter filter2 = mock(NotificationFilter.class);
NotificationFilter filter3 = mock(NotificationFilter.class);
NotificationFilter filter4 = mock(NotificationFilter.class);
NotificationFilter filter5 = mock(NotificationFilter.class);
NotificationFilter filter6 = mock(NotificationFilter.class);
NotificationFilter filter7 = mock(NotificationFilter.class);

when(filter1.getName()).thenReturn("filter1");
when(filter2.getName()).thenReturn("filter2");
when(filter3.getName()).thenReturn("filter3");
when(filter4.getName()).thenReturn("filter4");
when(filter5.getName()).thenReturn("filter5");
when(filter6.getName()).thenReturn("filter6");
when(filter7.getName()).thenReturn("filter7");

Map<String, ToggleableNotificationFilterActivation> filterActivations = new HashMap<>();
filterActivations.put("filter1", new ToggleableNotificationFilterActivation("filter1", true, null, -1));
filterActivations.put("filter2", new ToggleableNotificationFilterActivation("filter2", false, null, -1));
filterActivations.put("filter3", new ToggleableNotificationFilterActivation("filter3", true, null, -1));
filterActivations.put("filter4", new ToggleableNotificationFilterActivation("filter4", false, null, -1));
filterActivations.put("filter5", new ToggleableNotificationFilterActivation("filter5", true, null, -1));
filterActivations.put("filter6", new ToggleableNotificationFilterActivation("filter6", false, null, -1));
// We don't put filter7 so it should default as being considered activated

when(this.filterPreferencesModelBridge.getToggleableFilterActivations(testUser)).thenReturn(filterActivations);
when(filter1.getFilteringPhases())
.thenReturn(NotificationFilter.SUPPORT_ONLY_PRE_FILTERING_PHASE);
when(filter2.getFilteringPhases())
.thenReturn(NotificationFilter.SUPPORT_ONLY_PRE_FILTERING_PHASE);
when(filter3.getFilteringPhases())
.thenReturn(NotificationFilter.SUPPORT_ONLY_POST_FILTERING_PHASE);
when(filter4.getFilteringPhases())
.thenReturn(NotificationFilter.SUPPORT_ONLY_POST_FILTERING_PHASE);
when(filter5.getFilteringPhases())
.thenReturn(NotificationFilter.SUPPORT_BOTH_FILTERING_PHASE);
when(filter6.getFilteringPhases())
.thenReturn(NotificationFilter.SUPPORT_BOTH_FILTERING_PHASE);
when(filter7.getFilteringPhases())
.thenReturn(NotificationFilter.SUPPORT_BOTH_FILTERING_PHASE);

// Using subwiki so we manipulate a set instead of a map
when(wikiDescriptorManager.getMainWikiId()).thenReturn("somethingElseThanwiki");
when(componentManager.getInstanceList(NotificationFilter.class))
.thenReturn(Arrays.asList(filter1, filter2, filter3, filter4, filter5, filter6, filter7));

// prefiltering enabled: we request prefiltering filters that are enabled:
// we should not return filter2/4/6 since they are not enabled,
// nor filter3 because it's only for post-filtering
when(this.configuration.isEventPrefilteringEnabled()).thenReturn(true);
Collection<NotificationFilter> allFilters = this.filterManager.getAllFilters(testUser, true,
NotificationFilter.FilteringPhase.PRE_FILTERING);
assertEquals(3, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter1, filter5, filter7)), allFilters);

// prefiltering still enabled: we request postfiltering filters that are enabled:
// we should not return filter2/4/6 since they are not enabled,
// nor filter1 because it's only for pre-filtering, nor filter5 because it's for both pre and post filtering
allFilters = this.filterManager.getAllFilters(testUser, true, NotificationFilter.FilteringPhase.POST_FILTERING);
assertEquals(1, allFilters.size());
assertEquals(Collections.singleton(filter3), allFilters);

// prefiltering still enabled: we request all filters that are enabled:
// we should not return filter2/4/6 since they are not enabled.
allFilters = this.filterManager.getAllFilters(testUser, true, null);
assertEquals(4, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter1, filter3, filter5, filter7)), allFilters);

// prefiltering still enabled: we request prefiltering filters whatever if they are enabled or not
// we should not return filter3 and 4 because they are only for post-filtering
allFilters = this.filterManager.getAllFilters(testUser, false,
NotificationFilter.FilteringPhase.PRE_FILTERING);
assertEquals(5, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter1, filter2, filter5, filter6, filter7)), allFilters);

// prefiltering still enabled: we request postfiltering filters whatever if they are enabled or not
// we should not return filter1/2 because they are only for pre-filtering,
// nor filter5/6/7 because they are for both pre and post filtering
allFilters = this.filterManager.getAllFilters(testUser, false,
NotificationFilter.FilteringPhase.POST_FILTERING);
assertEquals(2, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter3, filter4)), allFilters);

// prefiltering still enabled: we request all filters whatever if they are enabled or not:
// we return all filters
allFilters = this.filterManager.getAllFilters(testUser, false, null);
assertEquals(7, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter1, filter2, filter3, filter4, filter5, filter6, filter7)),
allFilters);

// prefiltering not enabled: we request prefiltering filters that are enabled:
// we return nothing: this does not make sense to have prefiltering filters in that case.
when(this.configuration.isEventPrefilteringEnabled()).thenReturn(false);
allFilters = this.filterManager.getAllFilters(testUser, true,
NotificationFilter.FilteringPhase.PRE_FILTERING);
assertTrue(allFilters.isEmpty());

// prefiltering still not enabled: we request postfiltering filters that are enabled:
// we should not return filter2/4/6 since they are not enabled,
// nor filter1 because it's only for pre-filtering
allFilters = this.filterManager.getAllFilters(testUser, true, NotificationFilter.FilteringPhase.POST_FILTERING);
assertEquals(3, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter3, filter5, filter7)), allFilters);

// prefiltering still not enabled: we request all filters that are enabled:
// we should not return filter2/4/6 since they are not enabled.
allFilters = this.filterManager.getAllFilters(testUser, true, null);
assertEquals(4, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter1, filter3, filter5, filter7)), allFilters);

// prefiltering still not enabled: we request prefiltering filters whatever if they are enabled or not
// we return nothing: this does not make sense to have prefiltering filters in that case.
allFilters = this.filterManager.getAllFilters(testUser, false,
NotificationFilter.FilteringPhase.PRE_FILTERING);
assertTrue(allFilters.isEmpty());

// prefiltering still not enabled: we request postfiltering filters whatever if they are enabled or not
// we should not return filter1/2 because they are only for pre-filtering,
allFilters = this.filterManager.getAllFilters(testUser, false,
NotificationFilter.FilteringPhase.POST_FILTERING);
assertEquals(5, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter3, filter4, filter5, filter6, filter7)), allFilters);

// prefiltering still not enabled: we request all filters whatever if they are enabled or not:
// we return all filters
allFilters = this.filterManager.getAllFilters(testUser, false, null);
assertEquals(7, allFilters.size());
assertEquals(new HashSet<>(Arrays.asList(filter1, filter2, filter3, filter4, filter5, filter6, filter7)),
allFilters);
}
this.testUser = new DocumentReference("wiki", "test", "user");

}
// Set a default comportment for the wikiDescriptorManager (inherited from Abstract class)
when(this.wikiDescriptorManager.getMainWikiId()).thenReturn("wiki");
when(this.wikiDescriptorManager.getCurrentWikiId()).thenReturn("currentWikiId");
when(this.wikiDescriptorManager.getAllIds()).
Loading