SONAR-4469 Favourite issue filters still visible even if unshared

4 files changed, 155 insertions, 85 deletions

diff --git a/sonar-server/src/main/java/org/sonar/server/issue/InternalRubyIssueService.java b/sonar-server/src/main/java/org/sonar/server/issue/InternalRubyIssueService.java
index 22b0c9e8676..f52804e5da0 100644
--- a/sonar-server/src/main/java/org/sonar/server/issue/InternalRubyIssueService.java
+++ b/sonar-server/src/main/java/org/sonar/server/issue/InternalRubyIssueService.java
@@ -398,7 +398,7 @@ public class InternalRubyIssueService implements ServerComponent {
   public boolean isUserAuthorized(DefaultIssueFilter issueFilter) {
     try {
       UserSession userSession = UserSession.get();
-      String user = issueFilterService.getNotNullLogin(userSession);
+      String user = issueFilterService.getLoggedLogin(userSession);
       issueFilterService.verifyCurrentUserCanReadFilter(issueFilter, user);
       return true;
     } catch (Exception e) {
@@ -542,7 +542,7 @@ public class InternalRubyIssueService implements ServerComponent {
   }
 
   @VisibleForTesting
-  Result<DefaultIssueFilter> createIssueFilterResult(Map<String, String> params, boolean showCheckId, boolean showCheckUser) {
+  Result<DefaultIssueFilter> createIssueFilterResult(Map<String, String> params, boolean checkId, boolean checkUser) {
     Result<DefaultIssueFilter> result = Result.of();
 
     String id = params.get("id");
@@ -553,10 +553,10 @@ public class InternalRubyIssueService implements ServerComponent {
     Boolean sharedParam = RubyUtils.toBoolean(params.get("shared"));
     boolean shared = sharedParam != null ? sharedParam : false;
 
-    if (showCheckId) {
+    if (checkId) {
       checkMandatoryParameter(id, "id", result);
     }
-    if (showCheckUser) {
+    if (checkUser) {
       checkMandatoryParameter(user, "user", result);
     }
     checkMandatorySizeParameter(name, "name", 100, result);
@@ -578,7 +578,7 @@ public class InternalRubyIssueService implements ServerComponent {
   }
 
   public List<DefaultIssueFilter> findSharedFiltersForCurrentUser() {
-    return issueFilterService.findSharedFilters(UserSession.get());
+    return issueFilterService.findSharedFiltersWithoutUserFilters(UserSession.get());
   }
 
   public List<DefaultIssueFilter> findFavouriteIssueFiltersForCurrentUser() {
diff --git a/sonar-server/src/main/java/org/sonar/server/issue/IssueFilterService.java b/sonar-server/src/main/java/org/sonar/server/issue/IssueFilterService.java
index afdd7f6841e..77568fbd46a 100644
--- a/sonar-server/src/main/java/org/sonar/server/issue/IssueFilterService.java
+++ b/sonar-server/src/main/java/org/sonar/server/issue/IssueFilterService.java
@@ -50,32 +50,32 @@ import static com.google.common.collect.Lists.newArrayList;
  */
 public class IssueFilterService implements ServerComponent {
 
-  private final IssueFilterDao issueFilterDao;
-  private final IssueFilterFavouriteDao issueFilterFavouriteDao;
-  private final IssueFinder issueFinder;
+  private final IssueFilterDao filterDao;
+  private final IssueFilterFavouriteDao favouriteDao;
+  private final IssueFinder finder;
   private final AuthorizationDao authorizationDao;
-  private final IssueFilterSerializer issueFilterSerializer;
+  private final IssueFilterSerializer serializer;
 
-  public IssueFilterService(IssueFilterDao issueFilterDao, IssueFilterFavouriteDao issueFilterFavouriteDao, IssueFinder issueFinder, AuthorizationDao authorizationDao,
-                            IssueFilterSerializer issueFilterSerializer) {
-    this.issueFilterDao = issueFilterDao;
-    this.issueFilterFavouriteDao = issueFilterFavouriteDao;
-    this.issueFinder = issueFinder;
+  public IssueFilterService(IssueFilterDao filterDao, IssueFilterFavouriteDao favouriteDao, IssueFinder finder, AuthorizationDao authorizationDao,
+                            IssueFilterSerializer serializer) {
+    this.filterDao = filterDao;
+    this.favouriteDao = favouriteDao;
+    this.finder = finder;
     this.authorizationDao = authorizationDao;
-    this.issueFilterSerializer = issueFilterSerializer;
+    this.serializer = serializer;
   }
 
   public IssueFilterResult execute(IssueQuery issueQuery) {
-    return createIssueFilterResult(issueFinder.find(issueQuery), issueQuery);
+    return createIssueFilterResult(finder.find(issueQuery), issueQuery);
   }
 
   public DefaultIssueFilter find(Long id, UserSession userSession) {
-    return findIssueFilterDto(id, getNotNullLogin(userSession)).toIssueFilter();
+    return findIssueFilterDto(id, getLoggedLogin(userSession)).toIssueFilter();
   }
 
   @CheckForNull
   public DefaultIssueFilter findById(Long id) {
-    IssueFilterDto issueFilterDto = issueFilterDao.selectById(id);
+    IssueFilterDto issueFilterDto = filterDao.selectById(id);
     if (issueFilterDto != null) {
       return issueFilterDto.toIssueFilter();
     }
@@ -83,73 +83,88 @@ public class IssueFilterService implements ServerComponent {
   }
 
   public List<DefaultIssueFilter> findByUser(UserSession userSession) {
-    return toIssueFilters(issueFilterDao.selectByUser(getNotNullLogin(userSession)));
+    return toIssueFilters(selectUserIssueFilters(getLoggedLogin(userSession)));
   }
 
   public DefaultIssueFilter save(DefaultIssueFilter issueFilter, UserSession userSession) {
-    String user = getNotNullLogin(userSession);
+    String user = getLoggedLogin(userSession);
     issueFilter.setUser(user);
-    validateFilter(issueFilter, user);
+    validateFilter(issueFilter);
     return insertIssueFilter(issueFilter, user);
   }
 
   public DefaultIssueFilter update(DefaultIssueFilter issueFilter, UserSession userSession) {
-    String user = getNotNullLogin(userSession);
-    IssueFilterDto issueFilterDto = findIssueFilterDto(issueFilter.id(), user);
-    verifyCurrentUserCanModifyFilter(issueFilterDto.toIssueFilter(), user);
-    if(!issueFilterDto.getUserLogin().equals(issueFilter.user())) {
-      verifyCurrentUserCanChangeFilterOwnership(user);
+    String login = getLoggedLogin(userSession);
+    IssueFilterDto existingFilterDto = findIssueFilterDto(issueFilter.id(), login);
+    verifyCurrentUserCanModifyFilter(existingFilterDto.toIssueFilter(), login);
+    if(!existingFilterDto.getUserLogin().equals(issueFilter.user())) {
+      verifyCurrentUserCanChangeFilterOwnership(login);
     }
-    validateFilter(issueFilter, user);
-
-    issueFilterDao.update(IssueFilterDto.toIssueFilter(issueFilter));
+    validateFilter(issueFilter);
+    deleteOtherFavoriteFiltersIfFilterBecomeUnshared(existingFilterDto, issueFilter);
+    filterDao.update(IssueFilterDto.toIssueFilter(issueFilter));
     return issueFilter;
   }
 
+  private void deleteOtherFavoriteFiltersIfFilterBecomeUnshared(IssueFilterDto existingFilterDto, DefaultIssueFilter issueFilter){
+    if (existingFilterDto.isShared() && !issueFilter.shared()) {
+      for (IssueFilterFavouriteDto favouriteDto : selectFavouriteFilters(existingFilterDto.getId())) {
+        if (!favouriteDto.getUserLogin().equals(issueFilter.user())) {
+          deleteFavouriteIssueFilter(favouriteDto);
+        }
+      }
+    }
+  }
+
   public DefaultIssueFilter updateFilterQuery(Long issueFilterId, Map<String, Object> filterQuery, UserSession userSession) {
-    String user = getNotNullLogin(userSession);
-    IssueFilterDto issueFilterDto = findIssueFilterDto(issueFilterId, user);
-    verifyCurrentUserCanModifyFilter(issueFilterDto.toIssueFilter(), user);
+    String login = getLoggedLogin(userSession);
+    IssueFilterDto issueFilterDto = findIssueFilterDto(issueFilterId, login);
+    verifyCurrentUserCanModifyFilter(issueFilterDto.toIssueFilter(), login);
 
     DefaultIssueFilter issueFilter = issueFilterDto.toIssueFilter();
     issueFilter.setData(serializeFilterQuery(filterQuery));
-    issueFilterDao.update(IssueFilterDto.toIssueFilter(issueFilter));
+    filterDao.update(IssueFilterDto.toIssueFilter(issueFilter));
     return issueFilter;
   }
 
   public void delete(Long issueFilterId, UserSession userSession) {
-    String user = getNotNullLogin(userSession);
-    IssueFilterDto issueFilterDto = findIssueFilterDto(issueFilterId, user);
-    verifyCurrentUserCanModifyFilter(issueFilterDto.toIssueFilter(), user);
+    String login = getLoggedLogin(userSession);
+    IssueFilterDto issueFilterDto = findIssueFilterDto(issueFilterId, login);
+    verifyCurrentUserCanModifyFilter(issueFilterDto.toIssueFilter(), login);
 
     deleteFavouriteIssueFilters(issueFilterDto);
-    issueFilterDao.delete(issueFilterId);
+    filterDao.delete(issueFilterId);
   }
 
   public DefaultIssueFilter copy(Long issueFilterIdToCopy, DefaultIssueFilter issueFilter, UserSession userSession) {
-    String user = getNotNullLogin(userSession);
-    IssueFilterDto issueFilterDtoToCopy = findIssueFilterDto(issueFilterIdToCopy, user);
-    issueFilter.setUser(user);
+    String login = getLoggedLogin(userSession);
+    IssueFilterDto issueFilterDtoToCopy = findIssueFilterDto(issueFilterIdToCopy, login);
+    issueFilter.setUser(login);
     issueFilter.setData(issueFilterDtoToCopy.getData());
-    validateFilter(issueFilter, user);
-
-    return insertIssueFilter(issueFilter, user);
+    validateFilter(issueFilter);
+    return insertIssueFilter(issueFilter, login);
   }
 
-  public List<DefaultIssueFilter> findSharedFilters(UserSession userSession) {
-    return toIssueFilters(issueFilterDao.selectSharedWithoutUserFilters(getNotNullLogin(userSession)));
+  public List<DefaultIssueFilter> findSharedFiltersWithoutUserFilters(UserSession userSession) {
+    final String login = getLoggedLogin(userSession);
+    return toIssueFilters(newArrayList(Iterables.filter(selectSharedFilters(), new Predicate<IssueFilterDto>() {
+      @Override
+      public boolean apply(IssueFilterDto input) {
+        return !input.getUserLogin().equals(login);
+      }
+    })));
   }
 
   public List<DefaultIssueFilter> findFavoriteFilters(UserSession userSession) {
-    return toIssueFilters(issueFilterDao.selectByUserWithOnlyFavoriteFilters(getNotNullLogin(userSession)));
+    return toIssueFilters(filterDao.selectFavoriteFiltersByUser(getLoggedLogin(userSession)));
   }
 
-  public void toggleFavouriteIssueFilter(Long issueFilterId, UserSession userSession) {
-    String user = getNotNullLogin(userSession);
-    findIssueFilterDto(issueFilterId, user);
-    IssueFilterFavouriteDto issueFilterFavouriteDto = findFavouriteIssueFilter(user, issueFilterId);
+  public void toggleFavouriteIssueFilter(Long filterId, UserSession userSession) {
+    String user = getLoggedLogin(userSession);
+    findIssueFilterDto(filterId, user);
+    IssueFilterFavouriteDto issueFilterFavouriteDto = selectFavouriteFilterForUser(filterId, user);
     if (issueFilterFavouriteDto == null) {
-      addFavouriteIssueFilter(issueFilterId, user);
+      addFavouriteIssueFilter(filterId, user);
     } else {
       deleteFavouriteIssueFilter(issueFilterFavouriteDto);
     }
@@ -162,24 +177,24 @@ public class IssueFilterService implements ServerComponent {
         return IssueFilterParameters.ALL_WITHOUT_PAGINATION.contains(input.getKey());
       }
     });
-    return issueFilterSerializer.serialize(filterQueryFiltered);
+    return serializer.serialize(filterQueryFiltered);
   }
 
   public Map<String, Object> deserializeIssueFilterQuery(DefaultIssueFilter issueFilter) {
-    return issueFilterSerializer.deserialize(issueFilter.data());
+    return serializer.deserialize(issueFilter.data());
   }
 
-  private IssueFilterDto findIssueFilterDto(Long id, String user) {
-    IssueFilterDto issueFilterDto = issueFilterDao.selectById(id);
+  private IssueFilterDto findIssueFilterDto(Long id, String login) {
+    IssueFilterDto issueFilterDto = filterDao.selectById(id);
     if (issueFilterDto == null) {
       // TODO throw 404
       throw new IllegalArgumentException("Filter not found: " + id);
     }
-    verifyCurrentUserCanReadFilter(issueFilterDto.toIssueFilter(), user);
+    verifyCurrentUserCanReadFilter(issueFilterDto.toIssueFilter(), login);
     return issueFilterDto;
   }
 
-  String getNotNullLogin(UserSession userSession) {
+  String getLoggedLogin(UserSession userSession) {
     String user = userSession.login();
     if (!userSession.isLoggedIn() && user != null) {
       throw new IllegalStateException("User is not logged in");
@@ -187,8 +202,8 @@ public class IssueFilterService implements ServerComponent {
     return user;
   }
 
-  void verifyCurrentUserCanReadFilter(DefaultIssueFilter issueFilter, String user) {
-    if (!issueFilter.user().equals(user) && !issueFilter.shared()) {
+  void verifyCurrentUserCanReadFilter(DefaultIssueFilter issueFilter, String login) {
+    if (!issueFilter.user().equals(login) && !issueFilter.shared()) {
       // TODO throw unauthorized
       throw new IllegalStateException("User is not authorized to read this filter");
     }
@@ -208,37 +223,71 @@ public class IssueFilterService implements ServerComponent {
     }
   }
 
-  private void validateFilter(DefaultIssueFilter issueFilter, String user) {
-    if (issueFilterDao.selectByNameAndUser(issueFilter.name(), user, issueFilter.id()) != null) {
+  private void validateFilter(final DefaultIssueFilter issueFilter) {
+    List<IssueFilterDto> userFilters = selectUserIssueFilters(issueFilter.user());
+    IssueFilterDto userFilterSameName = findFilterWithSameName(userFilters, issueFilter.name());
+    if (userFilterSameName != null && userFilterSameName.getId() != issueFilter.id()) {
       throw new IllegalArgumentException("Name already exists");
     }
-    if (issueFilter.shared() && issueFilterDao.selectSharedWithoutUserFiltersByName(issueFilter.name(), user, issueFilter.id()) != null) {
-      throw new IllegalArgumentException("Other users already share filters with the same name");
+    if (issueFilter.shared()) {
+      List<IssueFilterDto> sharedFilters = selectSharedFilters();
+      IssueFilterDto sharedFilterWithSameName = findFilterWithSameName(sharedFilters, issueFilter.name());
+      if (sharedFilterWithSameName != null && !sharedFilterWithSameName.getUserLogin().equals(issueFilter.user())) {
+        throw new IllegalArgumentException("Other users already share filters with the same name");
+      }
     }
   }
 
-  private IssueFilterFavouriteDto findFavouriteIssueFilter(String user, Long issueFilterId) {
-    return issueFilterFavouriteDao.selectByUserAndIssueFilterId(user, issueFilterId);
+  @CheckForNull
+  private IssueFilterFavouriteDto selectFavouriteFilterForUser(Long filterId, final String user) {
+    return Iterables.find(selectFavouriteFilters(filterId), new Predicate<IssueFilterFavouriteDto>() {
+      @Override
+      public boolean apply(IssueFilterFavouriteDto input) {
+        return input.getUserLogin().equals(user);
+      }
+    }, null);
+  }
+
+  private List<IssueFilterFavouriteDto> selectFavouriteFilters(Long filterId) {
+    return favouriteDao.selectByFilterId(filterId);
+  }
+
+  private List<IssueFilterDto> selectUserIssueFilters(String user){
+    return filterDao.selectByUser(user);
+  }
+
+  private List<IssueFilterDto> selectSharedFilters(){
+    return filterDao.selectSharedFilters();
+  }
+
+  @CheckForNull
+  private IssueFilterDto findFilterWithSameName(List<IssueFilterDto> dtos, final String name){
+    return Iterables.find(dtos, new Predicate<IssueFilterDto>() {
+      @Override
+      public boolean apply(IssueFilterDto input) {
+        return input.getName().equals(name);
+      }
+    }, null);
   }
 
   private void addFavouriteIssueFilter(Long issueFilterId, String user) {
     IssueFilterFavouriteDto issueFilterFavouriteDto = new IssueFilterFavouriteDto()
       .setIssueFilterId(issueFilterId)
       .setUserLogin(user);
-    issueFilterFavouriteDao.insert(issueFilterFavouriteDto);
+    favouriteDao.insert(issueFilterFavouriteDto);
   }
 
   private void deleteFavouriteIssueFilter(IssueFilterFavouriteDto issueFilterFavouriteDto) {
-    issueFilterFavouriteDao.delete(issueFilterFavouriteDto.getId());
+    favouriteDao.delete(issueFilterFavouriteDto.getId());
   }
 
   private void deleteFavouriteIssueFilters(IssueFilterDto issueFilterDto) {
-    issueFilterFavouriteDao.deleteByIssueFilterId(issueFilterDto.getId());
+    favouriteDao.deleteByFilterId(issueFilterDto.getId());
   }
 
   private DefaultIssueFilter insertIssueFilter(DefaultIssueFilter issueFilter, String user) {
     IssueFilterDto issueFilterDto = IssueFilterDto.toIssueFilter(issueFilter);
-    issueFilterDao.insert(issueFilterDto);
+    filterDao.insert(issueFilterDto);
     addFavouriteIssueFilter(issueFilterDto.getId(), user);
     return issueFilterDto.toIssueFilter();
   }
diff --git a/sonar-server/src/test/java/org/sonar/server/issue/InternalRubyIssueServiceTest.java b/sonar-server/src/test/java/org/sonar/server/issue/InternalRubyIssueServiceTest.java
index 296a64778c7..b9fe11d8b86 100644
--- a/sonar-server/src/test/java/org/sonar/server/issue/InternalRubyIssueServiceTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/issue/InternalRubyIssueServiceTest.java
@@ -564,7 +564,7 @@ public class InternalRubyIssueServiceTest {
   @Test
   public void should_find_shared_issue_filters() {
     service.findSharedFiltersForCurrentUser();
-    verify(issueFilterService).findSharedFilters(any(UserSession.class));
+    verify(issueFilterService).findSharedFiltersWithoutUserFilters(any(UserSession.class));
   }
 
   @Test
@@ -592,7 +592,7 @@ public class InternalRubyIssueServiceTest {
   public void should_check_is_user_is_authorized_to_see_issue_filter() {
     DefaultIssueFilter issueFilter = new DefaultIssueFilter();
     service.isUserAuthorized(issueFilter);
-    verify(issueFilterService).getNotNullLogin(any(UserSession.class));
+    verify(issueFilterService).getLoggedLogin(any(UserSession.class));
     verify(issueFilterService).verifyCurrentUserCanReadFilter(eq(issueFilter), anyString());
   }
 
diff --git a/sonar-server/src/test/java/org/sonar/server/issue/IssueFilterServiceTest.java b/sonar-server/src/test/java/org/sonar/server/issue/IssueFilterServiceTest.java
index c3ed479cc3f..75cb12460ea 100644
--- a/sonar-server/src/test/java/org/sonar/server/issue/IssueFilterServiceTest.java
+++ b/sonar-server/src/test/java/org/sonar/server/issue/IssueFilterServiceTest.java
@@ -39,6 +39,7 @@ import org.sonar.core.user.AuthorizationDao;
 import org.sonar.server.user.MockUserSession;
 import org.sonar.server.user.UserSession;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -197,7 +198,7 @@ public class IssueFilterServiceTest {
 
   @Test
   public void should_not_save_if_name_already_used() {
-    when(issueFilterDao.selectByNameAndUser(eq("My Issue"), eq("john"), eq((Long) null))).thenReturn(new IssueFilterDto());
+    when(issueFilterDao.selectByUser(eq("john"))).thenReturn(newArrayList(new IssueFilterDto().setId(1L).setName("My Issue")));
     try {
       DefaultIssueFilter issueFilter = new DefaultIssueFilter().setName("My Issue");
       service.save(issueFilter, userSession);
@@ -210,10 +211,10 @@ public class IssueFilterServiceTest {
 
   @Test
   public void should_not_save_shared_filter_if_name_already_used_by_shared_filter() {
-    when(issueFilterDao.selectByNameAndUser(eq("My Issue"), eq("john"), eq((Long) null))).thenReturn(null);
-    when(issueFilterDao.selectSharedWithoutUserFiltersByName(eq("My Issue"), eq("john"), eq((Long) null))).thenReturn(new IssueFilterDto());
+    when(issueFilterDao.selectByUser(eq("john"))).thenReturn(Collections.<IssueFilterDto>emptyList());
+    when(issueFilterDao.selectSharedFilters()).thenReturn(newArrayList(new IssueFilterDto().setId(1L).setName("My Issue").setUserLogin("henry").setShared(true)));
+    DefaultIssueFilter issueFilter = new DefaultIssueFilter().setName("My Issue").setShared(true);
     try {
-      DefaultIssueFilter issueFilter = new DefaultIssueFilter().setName("My Issue").setShared(true);
       service.save(issueFilter, userSession);
       fail();
     } catch (Exception e) {
@@ -233,7 +234,22 @@ public class IssueFilterServiceTest {
   }
 
   @Test
-  public void should_update_shared_filter_if_admin() {
+  public void should_remove_other_favorite_filters_if_filter_become_unshared() {
+    when(issueFilterDao.selectById(1L)).thenReturn(new IssueFilterDto().setId(1L).setName("My Old Filter").setUserLogin("john").setShared(true));
+    IssueFilterFavouriteDto userFavouriteDto = new IssueFilterFavouriteDto().setId(10L).setUserLogin("john").setIssueFilterId(1L);
+    IssueFilterFavouriteDto otherFavouriteDto = new IssueFilterFavouriteDto().setId(11L).setUserLogin("arthur").setIssueFilterId(1L);
+    when(issueFilterFavouriteDao.selectByFilterId(1L)).thenReturn(newArrayList(userFavouriteDto, otherFavouriteDto));
+
+    DefaultIssueFilter result = service.update(new DefaultIssueFilter().setId(1L).setName("My New Filter").setUser("john").setShared(false), userSession);
+    assertThat(result.name()).isEqualTo("My New Filter");
+
+    verify(issueFilterDao).update(any(IssueFilterDto.class));
+    verify(issueFilterFavouriteDao).delete(11L);
+    verify(issueFilterFavouriteDao, never()).delete(10L);
+  }
+
+  @Test
+  public void should_update_other_shared_filter_if_admin() {
     when(authorizationDao.selectGlobalPermissions("john")).thenReturn(newArrayList(UserRole.ADMIN));
     when(issueFilterDao.selectById(1L)).thenReturn(new IssueFilterDto().setId(1L).setName("My Old Filter").setUserLogin("arthur").setShared(true));
 
@@ -274,7 +290,7 @@ public class IssueFilterServiceTest {
   @Test
   public void should_not_update_if_name_already_used() {
     when(issueFilterDao.selectById(1L)).thenReturn(new IssueFilterDto().setId(1L).setName("My Old Filter").setUserLogin("john"));
-    when(issueFilterDao.selectByNameAndUser("My Issue", "john", 1L)).thenReturn(new IssueFilterDto());
+    when(issueFilterDao.selectByUser(eq("john"))).thenReturn(newArrayList(new IssueFilterDto().setId(2L).setName("My Issue")));
 
     try {
       service.update(new DefaultIssueFilter().setId(1L).setUser("john").setName("My Issue"), userSession);
@@ -345,12 +361,12 @@ public class IssueFilterServiceTest {
   @Test
   public void should_delete_favorite_filter_on_delete() {
     when(issueFilterDao.selectById(1L)).thenReturn(new IssueFilterDto().setId(1L).setName("My Issues").setUserLogin("john"));
-    when(issueFilterFavouriteDao.selectByUserAndIssueFilterId("john", 1L)).thenReturn(new IssueFilterFavouriteDto().setId(10L).setUserLogin("john").setIssueFilterId(1L));
+    when(issueFilterFavouriteDao.selectByFilterId(1L)).thenReturn(newArrayList(new IssueFilterFavouriteDto().setId(10L).setUserLogin("john").setIssueFilterId(1L)));
 
     service.delete(1L, userSession);
 
     verify(issueFilterDao).delete(1L);
-    verify(issueFilterFavouriteDao).deleteByIssueFilterId(1L);
+    verify(issueFilterFavouriteDao).deleteByFilterId(1L);
   }
 
   @Test
@@ -450,15 +466,20 @@ public class IssueFilterServiceTest {
 
   @Test
   public void should_find_shared_issue_filter() {
-    when(issueFilterDao.selectSharedWithoutUserFilters("john")).thenReturn(newArrayList(new IssueFilterDto().setId(1L).setName("My Issue").setUserLogin("john").setShared(true)));
+    when(issueFilterDao.selectSharedFilters()).thenReturn(newArrayList(
+      new IssueFilterDto().setId(1L).setName("My Issue").setUserLogin("john").setShared(true),
+      new IssueFilterDto().setId(2L).setName("Project Issues").setUserLogin("arthur").setShared(true)
+    ));
 
-    List<DefaultIssueFilter> results = service.findSharedFilters(userSession);
+    List<DefaultIssueFilter> results = service.findSharedFiltersWithoutUserFilters(userSession);
     assertThat(results).hasSize(1);
+    DefaultIssueFilter filter = results.get(0);
+    assertThat(filter.name()).isEqualTo("Project Issues");
   }
 
   @Test
   public void should_find_favourite_issue_filter() {
-    when(issueFilterDao.selectByUserWithOnlyFavoriteFilters("john")).thenReturn(newArrayList(new IssueFilterDto().setId(1L).setName("My Issue").setUserLogin("john")));
+    when(issueFilterDao.selectFavoriteFiltersByUser("john")).thenReturn(newArrayList(new IssueFilterDto().setId(1L).setName("My Issue").setUserLogin("john")));
 
     List<DefaultIssueFilter> results = service.findFavoriteFilters(userSession);
     assertThat(results).hasSize(1);
@@ -480,7 +501,7 @@ public class IssueFilterServiceTest {
   public void should_add_favourite_issue_filter_id() {
     when(issueFilterDao.selectById(1L)).thenReturn(new IssueFilterDto().setId(1L).setName("My Issues").setUserLogin("john").setData("componentRoots=struts"));
     // The filter is not in the favorite list --> add to favorite
-    when(issueFilterFavouriteDao.selectByUserAndIssueFilterId("john", 1L)).thenReturn(null);
+    when(issueFilterFavouriteDao.selectByFilterId(1L)).thenReturn(Collections.<IssueFilterFavouriteDto>emptyList());
 
     ArgumentCaptor<IssueFilterFavouriteDto> issueFilterFavouriteDtoCaptor = ArgumentCaptor.forClass(IssueFilterFavouriteDto.class);
     service.toggleFavouriteIssueFilter(1L, userSession);
@@ -495,7 +516,7 @@ public class IssueFilterServiceTest {
   public void should_add_favourite_on_shared_filter() {
     when(issueFilterDao.selectById(1L)).thenReturn(new IssueFilterDto().setId(1L).setName("My Issues").setUserLogin("arthur").setShared(true));
     // The filter is not in the favorite list --> add to favorite
-    when(issueFilterFavouriteDao.selectByUserAndIssueFilterId("john", 1L)).thenReturn(null);
+    when(issueFilterFavouriteDao.selectByFilterId(1L)).thenReturn(Collections.<IssueFilterFavouriteDto>emptyList());
 
     ArgumentCaptor<IssueFilterFavouriteDto> issueFilterFavouriteDtoCaptor = ArgumentCaptor.forClass(IssueFilterFavouriteDto.class);
     service.toggleFavouriteIssueFilter(1L, userSession);
@@ -510,7 +531,7 @@ public class IssueFilterServiceTest {
   public void should_delete_favourite_issue_filter_id() {
     when(issueFilterDao.selectById(1L)).thenReturn(new IssueFilterDto().setId(1L).setName("My Issues").setUserLogin("john").setData("componentRoots=struts"));
     // The filter is in the favorite list --> remove favorite
-    when(issueFilterFavouriteDao.selectByUserAndIssueFilterId("john", 1L)).thenReturn(new IssueFilterFavouriteDto().setId(10L).setUserLogin("john").setIssueFilterId(1L));
+    when(issueFilterFavouriteDao.selectByFilterId(1L)).thenReturn(newArrayList(new IssueFilterFavouriteDto().setId(10L).setUserLogin("john").setIssueFilterId(1L)));
 
     service.toggleFavouriteIssueFilter(1L, userSession);
     verify(issueFilterFavouriteDao).delete(10L);