hunk.code_window:         return queryOne(List.of(nameCriteria), aclPermission);
       }
       @Override
       public Flux<Organization> findByIdsIn(Set<String> orgIds, AclPermission aclPermission) {
           Criteria orgIdsCriteria = where(fieldName(QOrganization.organization.id)).in(orgIds);
  
hunk.labels: keep keep keep keep keep replace keep
hunk.after_edit:     public Flux<Organization> findByIdsIn(Set<String> orgIds, AclPermission aclPermission, Sort sort) {
  
hunk.file_path: app/server/appsmith-server/src/main/java/com/appsmith/server/repositories/CustomOrganizationRepositoryImpl.java
hunk.type: replace
file: package com.appsmith.server.services;
  
  import com.appsmith.external.models.ActionConfiguration;
  import com.appsmith.external.models.DatasourceConfiguration;
  import com.appsmith.external.models.Policy;
  import com.appsmith.server.constants.FieldName;
  import com.appsmith.server.domains.Action;
  import com.appsmith.server.domains.Application;
  import com.appsmith.server.domains.Datasource;
  import com.appsmith.server.domains.Organization;
  import com.appsmith.server.domains.Page;
  import com.appsmith.server.domains.Plugin;
  import com.appsmith.server.domains.User;
  import com.appsmith.server.dtos.ApplicationAccessDTO;
  import com.appsmith.server.dtos.OrganizationApplicationsDTO;
  import com.appsmith.server.dtos.UserHomepageDTO;
  import com.appsmith.server.exceptions.AppsmithError;
  import com.appsmith.server.exceptions.AppsmithException;
  import com.appsmith.server.helpers.MockPluginExecutor;
  import com.appsmith.server.helpers.PluginExecutorHelper;
  import com.appsmith.server.repositories.PageRepository;
  import com.appsmith.server.solutions.ApplicationFetcher;
  import lombok.extern.slf4j.Slf4j;
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.Mockito;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.boot.test.mock.mockito.MockBean;
  import org.springframework.http.HttpMethod;
  import org.springframework.security.test.context.support.WithUserDetails;
  import org.springframework.test.annotation.DirtiesContext;
  import org.springframework.test.context.junit4.SpringRunner;
  import org.springframework.util.LinkedMultiValueMap;
  import org.springframework.util.MultiValueMap;
  import reactor.core.publisher.Flux;
  import reactor.core.publisher.Mono;
  import reactor.test.StepVerifier;
  
  import java.util.List;
  import java.util.Set;
  
  import static com.appsmith.server.acl.AclPermission.EXECUTE_ACTIONS;
  import static com.appsmith.server.acl.AclPermission.EXECUTE_DATASOURCES;
  import static com.appsmith.server.acl.AclPermission.MANAGE_ACTIONS;
  import static com.appsmith.server.acl.AclPermission.MANAGE_APPLICATIONS;
  import static com.appsmith.server.acl.AclPermission.MANAGE_DATASOURCES;
  import static com.appsmith.server.acl.AclPermission.MANAGE_PAGES;
  import static com.appsmith.server.acl.AclPermission.READ_ACTIONS;
  import static com.appsmith.server.acl.AclPermission.READ_APPLICATIONS;
  import static com.appsmith.server.acl.AclPermission.READ_DATASOURCES;
  import static com.appsmith.server.acl.AclPermission.READ_PAGES;
  import static org.assertj.core.api.Assertions.assertThat;
  
  @RunWith(SpringRunner.class)
  @SpringBootTest
  @Slf4j
  @DirtiesContext
  public class ApplicationServiceTest {
  
      @Autowired
      ApplicationService applicationService;
  
      @Autowired
      ApplicationPageService applicationPageService;
  
      @Autowired
      PageService pageService;
  
      @Autowired
      UserService userService;
  
      @Autowired
      OrganizationService organizationService;
  
      @Autowired
      PageRepository pageRepository;
  
      @Autowired
      DatasourceService datasourceService;
  
      @Autowired
      PluginService pluginService;
  
      @Autowired
      ActionService actionService;
  
      @MockBean
      PluginExecutorHelper pluginExecutorHelper;
  
      @Autowired
      ApplicationFetcher applicationFetcher;
  
      String orgId;
  
      @Before
      @WithUserDetails(value = "api_user")
      public void setup() {
          User apiUser = userService.findByEmail("api_user").block();
          orgId = apiUser.getOrganizationIds().iterator().next();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void createApplicationWithNullName() {
          Application application = new Application();
          Mono<Application> applicationMono = Mono.just(application)
                  .flatMap(app -> applicationPageService.createApplication(app, orgId));
          StepVerifier
                  .create(applicationMono)
                  .expectErrorMatches(throwable -> throwable instanceof AppsmithException &&
                          throwable.getMessage().equals(AppsmithError.INVALID_PARAMETER.getMessage(FieldName.NAME)))
                  .verify();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void createValidApplication() {
          Application testApplication = new Application();
          testApplication.setName("ApplicationServiceTest TestApp");
          Mono<Application> applicationMono = applicationPageService.createApplication(testApplication, orgId);
  
          Policy manageAppPolicy = Policy.builder().permission(MANAGE_APPLICATIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readAppPolicy = Policy.builder().permission(READ_APPLICATIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
  
          StepVerifier
                  .create(applicationMono)
                  .assertNext(application -> {
                      assertThat(application).isNotNull();
                      assertThat(application.isAppIsExample()).isFalse();
                      assertThat(application.getId()).isNotNull();
                      assertThat(application.getName().equals("ApplicationServiceTest TestApp"));
                      assertThat(application.getPolicies()).isNotEmpty();
                      assertThat(application.getPolicies()).containsAll(Set.of(manageAppPolicy, readAppPolicy));
                      assertThat(application.getOrganizationId().equals(orgId));
                  })
                  .verifyComplete();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void defaultPageCreateOnCreateApplicationTest() {
          Application testApplication = new Application();
          testApplication.setName("ApplicationServiceTest TestAppForTestingPage");
          Flux<Page> pagesFlux = applicationPageService
                  .createApplication(testApplication, orgId)
                  .flatMapMany(application -> pageService.findByApplicationId(application.getId(), READ_PAGES));
  
          Policy managePagePolicy = Policy.builder().permission(MANAGE_PAGES.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readPagePolicy = Policy.builder().permission(READ_PAGES.getValue())
                  .users(Set.of("api_user"))
                  .build();
  
          StepVerifier
                  .create(pagesFlux)
                  .assertNext(page -> {
                      assertThat(page).isNotNull();
                      assertThat(page.getName()).isEqualTo(FieldName.DEFAULT_PAGE_NAME);
                      assertThat(page.getLayouts()).isNotEmpty();
                      assertThat(page.getPolicies()).isNotEmpty();
                      assertThat(page.getPolicies().containsAll(Set.of(managePagePolicy, readPagePolicy)));
                  })
                  .verifyComplete();
      }
  
      /* Tests for Get Application Flow */
  
      @Test
      @WithUserDetails(value = "api_user")
      public void getApplicationInvalidId() {
          Mono<Application> applicationMono = applicationService.getById("random-id");
          StepVerifier.create(applicationMono)
                  .expectErrorMatches(throwable -> throwable instanceof AppsmithException &&
                          throwable.getMessage().equals(AppsmithError.NO_RESOURCE_FOUND.getMessage("resource", "random-id")))
                  .verify();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void getApplicationNullId() {
          Mono<Application> applicationMono = applicationService.getById(null);
          StepVerifier.create(applicationMono)
                  .expectErrorMatches(throwable -> throwable instanceof AppsmithException &&
                          throwable.getMessage().equals(AppsmithError.INVALID_PARAMETER.getMessage(FieldName.ID)))
                  .verify();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void validGetApplicationById() {
          Application application = new Application();
          application.setName("validGetApplicationById-Test");
          Mono<Application> createApplication = applicationPageService.createApplication(application, orgId);
          Mono<Application> getApplication = createApplication.flatMap(t -> applicationService.getById(t.getId()));
          StepVerifier.create(getApplication)
                  .assertNext(t -> {
                      assertThat(t).isNotNull();
                      assertThat(t.isAppIsExample()).isFalse();
                      assertThat(t.getId()).isNotNull();
                      assertThat(t.getName()).isEqualTo("validGetApplicationById-Test");
                  })
                  .verifyComplete();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void validGetApplicationsByName() {
          Application application = new Application();
          application.setName("validGetApplicationByName-Test");
          MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
          params.set(FieldName.NAME, application.getName());
  
          Mono<Application> createApplication = applicationPageService.createApplication(application, orgId);
  
          Flux<Application> getApplication = createApplication.flatMapMany(t -> applicationService.get(params));
          StepVerifier.create(getApplication)
                  .assertNext(t -> {
                      assertThat(t).isNotNull();
                      assertThat(t.isAppIsExample()).isFalse();
                      assertThat(t.getId()).isNotNull();
                      assertThat(t.getName()).isEqualTo("validGetApplicationByName-Test");
                  })
                  .verifyComplete();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void validGetApplications() {
          Application application = new Application();
          application.setName("validGetApplications-Test");
  
          Policy readAppPolicy = Policy.builder().permission(READ_APPLICATIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Mono<Application> createApplication = applicationPageService.createApplication(application, orgId);
          List<Application> applicationList = createApplication
                  .flatMapMany(t -> applicationService.get(new LinkedMultiValueMap<>()))
                  .collectList()
                  .block();
  
          assertThat(applicationList.size() > 0);
          applicationList
                  .stream()
                  .filter(t -> t.getName().equals("validGetApplications-Test"))
                  .forEach(t -> {
                      assertThat(t.getId()).isNotNull();
                      assertThat(t.isAppIsExample()).isFalse();
                      assertThat(t.getPolicies()).isNotEmpty();
                      assertThat(t.getPolicies()).containsAll(Set.of(readAppPolicy));
                  });
      }
  
      /* Tests for Update Application Flow */
      @Test
      @WithUserDetails(value = "api_user")
      public void validUpdateApplication() {
          Application application = new Application();
          application.setName("validUpdateApplication-Test");
  
          Mono<Application> createApplication =
                  applicationPageService
                          .createApplication(application, orgId);
          Mono<Application> updateApplication = createApplication
                  .map(t -> {
                      t.setName("NewValidUpdateApplication-Test");
                      return t;
                  })
                  .flatMap(t -> applicationService.update(t.getId(), t))
                  .flatMap(t -> applicationService.getById(t.getId()));
  
          StepVerifier.create(updateApplication)
                  .assertNext(t -> {
                      assertThat(t).isNotNull();
                      assertThat(t.getId()).isNotNull();
                      assertThat(t.getPolicies()).isNotEmpty();
                      assertThat(t.getName()).isEqualTo("NewValidUpdateApplication-Test");
                  })
                  .verifyComplete();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void reuseDeletedAppName() {
          Application firstApp = new Application();
          firstApp.setName("Ghost app");
  
          Application secondApp = new Application();
          secondApp.setName("Ghost app");
  
          Mono<Application> firstAppDeletion = applicationPageService
                  .createApplication(firstApp, orgId)
                  .flatMap(app -> applicationService.archive(app))
                  .cache();
  
          Mono<Application> secondAppCreation = firstAppDeletion.then(
                  applicationPageService.createApplication(secondApp, orgId));
  
          StepVerifier
                  .create(Mono.zip(firstAppDeletion, secondAppCreation))
                  .assertNext(tuple2 -> {
                      Application first = tuple2.getT1(), second = tuple2.getT2();
                      assertThat(first.getName()).isEqualTo("Ghost app");
                      assertThat(second.getName()).isEqualTo("Ghost app");
                      assertThat(first.isDeleted()).isTrue();
                      assertThat(second.isDeleted()).isFalse();
                  })
                  .verifyComplete();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void getAllApplicationsForHome() {
          Mono<UserHomepageDTO> allApplications = applicationFetcher.getAllApplications();
  
          StepVerifier
                  .create(allApplications)
                  .assertNext(userHomepageDTO -> {
                      assertThat(userHomepageDTO).isNotNull();
                      //In case of anonymous user, we should have errored out. Assert that the user is not anonymous.
                      assertThat(userHomepageDTO.getUser().getIsAnonymous()).isFalse();
  
                      List<OrganizationApplicationsDTO> organizationApplications = userHomepageDTO.getOrganizationApplications();
  
                      OrganizationApplicationsDTO orgAppDto = organizationApplications.get(0);
                      assertThat(orgAppDto.getOrganization().getUserPermissions().contains("read:organizations"));
  
                      Application application = orgAppDto.getApplications().get(0);
                      assertThat(application.getUserPermissions()).contains("read:applications");
                      assertThat(application.isAppIsExample()).isFalse();
                  })
                  .verifyComplete();
  
      }
  
      @Test
      @WithUserDetails(value = "usertest@usertest.com")
      public void getAllApplicationsForHomeWhenNoApplicationPresent() {
          // Create an organization for this user first.
          Organization organization = new Organization();
          organization.setName("usertest's organization");
          Mono<Organization> organizationMono = organizationService.create(organization);
  
          Mono<UserHomepageDTO> allApplications = organizationMono
                  .then(applicationFetcher.getAllApplications());
  
          StepVerifier
                  .create(allApplications)
                  .assertNext(userHomepageDTO -> {
                      assertThat(userHomepageDTO).isNotNull();
                      //In case of anonymous user, we should have errored out. Assert that the user is not anonymous.
                      assertThat(userHomepageDTO.getUser().getIsAnonymous()).isFalse();
  
                      List<OrganizationApplicationsDTO> organizationApplications = userHomepageDTO.getOrganizationApplications();
  
                      // There should be atleast one organization present in the output.
                      OrganizationApplicationsDTO orgAppDto = organizationApplications.get(0);
                      assertThat(orgAppDto.getOrganization().getUserPermissions().contains("read:organizations"));
                  })
                  .verifyComplete();
  
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void validMakeApplicationPublic() {
          Application application = new Application();
          application.setName("validMakeApplicationPublic-Test");
  
          Policy manageAppPolicy = Policy.builder().permission(MANAGE_APPLICATIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readAppPolicy = Policy.builder().permission(READ_APPLICATIONS.getValue())
                  .users(Set.of("api_user", FieldName.ANONYMOUS_USER))
                  .build();
  
          Policy managePagePolicy = Policy.builder().permission(MANAGE_PAGES.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readPagePolicy = Policy.builder().permission(READ_PAGES.getValue())
                  .users(Set.of("api_user", FieldName.ANONYMOUS_USER))
                  .build();
  
          Application createdApplication = applicationPageService.createApplication(application, orgId).block();
  
          ApplicationAccessDTO applicationAccessDTO = new ApplicationAccessDTO();
          applicationAccessDTO.setPublicAccess(true);
  
          Mono<Application> publicAppMono = applicationService
                  .changeViewAccess(createdApplication.getId(), applicationAccessDTO)
                  .cache();
  
          Mono<Page> pageMono = publicAppMono
                  .flatMap(app -> {
                      String pageId = app.getPages().get(0).getId();
                      return pageRepository.findById(pageId);
                  });
  
          StepVerifier
                  .create(Mono.zip(publicAppMono, pageMono))
                  .assertNext(tuple -> {
                      Application publicApp = tuple.getT1();
                      Page page = tuple.getT2();
  
                      assertThat(publicApp.getIsPublic()).isTrue();
                      assertThat(publicApp.getPolicies()).containsAll(Set.of(manageAppPolicy, readAppPolicy));
  
                      // Check the child page's policies
                      assertThat(page.getPolicies()).containsAll(Set.of(managePagePolicy, readPagePolicy));
                  })
                  .verifyComplete();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void validMakeApplicationPrivate() {
          Application application = new Application();
          application.setName("validMakeApplicationPrivate-Test");
  
          Policy manageAppPolicy = Policy.builder().permission(MANAGE_APPLICATIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readAppPolicy = Policy.builder().permission(READ_APPLICATIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
  
          Policy managePagePolicy = Policy.builder().permission(MANAGE_PAGES.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readPagePolicy = Policy.builder().permission(READ_PAGES.getValue())
                  .users(Set.of("api_user"))
                  .build();
  
          Mono<Application> createApplication = applicationPageService.createApplication(application, orgId);
  
          ApplicationAccessDTO applicationAccessDTO = new ApplicationAccessDTO();
          Mono<Application> privateAppMono = createApplication
                  .flatMap(application1 -> {
                      applicationAccessDTO.setPublicAccess(true);
                      return applicationService.changeViewAccess(application1.getId(), applicationAccessDTO);
                  })
                  .flatMap(application1 -> {
                      applicationAccessDTO.setPublicAccess(false);
                      return applicationService.changeViewAccess(application1.getId(), applicationAccessDTO);
                  })
                  .cache();
  
          Mono<Page> pageMono = privateAppMono
                  .flatMap(app -> {
                      String pageId = app.getPages().get(0).getId();
                      return pageRepository.findById(pageId);
                  });
  
          StepVerifier
                  .create(Mono.zip(privateAppMono, pageMono))
                  .assertNext(tuple -> {
                      Application app = tuple.getT1();
                      Page page = tuple.getT2();
  
                      assertThat(app.getIsPublic()).isFalse();
                      assertThat(app.getPolicies()).containsAll(Set.of(manageAppPolicy, readAppPolicy));
  
                      // Check the child page's policies
                      assertThat(page.getPolicies()).containsAll(Set.of(managePagePolicy, readPagePolicy));
                  })
                  .verifyComplete();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void validMakeApplicationPublicWithActions() {
          Mockito.when(pluginExecutorHelper.getPluginExecutor(Mockito.any())).thenReturn(Mono.just(new MockPluginExecutor()));
  
          Application application = new Application();
          application.setName("validMakeApplicationPublic-ExplicitDatasource-Test");
  
          Policy manageDatasourcePolicy = Policy.builder().permission(MANAGE_DATASOURCES.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readDatasourcePolicy = Policy.builder().permission(READ_DATASOURCES.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy executeDatasourcePolicy = Policy.builder().permission(EXECUTE_DATASOURCES.getValue())
                  .users(Set.of("api_user", FieldName.ANONYMOUS_USER))
                  .build();
  
          Policy manageActionPolicy = Policy.builder().permission(MANAGE_ACTIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readActionPolicy = Policy.builder().permission(READ_ACTIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy executeActionPolicy = Policy.builder().permission(EXECUTE_ACTIONS.getValue())
                  .users(Set.of("api_user", FieldName.ANONYMOUS_USER))
                  .build();
  
          Application createdApplication = applicationPageService.createApplication(application, orgId).block();
  
          String pageId = createdApplication.getPages().get(0).getId();
  
          Plugin plugin = pluginService.findByName("Installed Plugin Name").block();
          Datasource datasource = new Datasource();
          datasource.setName("Public App Test");
          datasource.setPluginId(plugin.getId());
          DatasourceConfiguration datasourceConfiguration = new DatasourceConfiguration();
          datasourceConfiguration.setUrl("http://test.com");
          datasource.setDatasourceConfiguration(datasourceConfiguration);
          datasource.setOrganizationId(orgId);
  
          Datasource savedDatasource = datasourceService.create(datasource).block();
  
          Action action = new Action();
          action.setName("Public App Test action");
          action.setPageId(pageId);
          action.setDatasource(savedDatasource);
          ActionConfiguration actionConfiguration = new ActionConfiguration();
          actionConfiguration.setHttpMethod(HttpMethod.GET);
          action.setActionConfiguration(actionConfiguration);
  
          Action savedAction = actionService.create(action).block();
  
          ApplicationAccessDTO applicationAccessDTO = new ApplicationAccessDTO();
          applicationAccessDTO.setPublicAccess(true);
  
          Mono<Application> publicAppMono = applicationService
                  .changeViewAccess(createdApplication.getId(), applicationAccessDTO)
                  .cache();
  
          Mono<Datasource> datasourceMono = publicAppMono
                  .then(datasourceService.findById(savedDatasource.getId()));
  
          Mono<Action> actionMono = publicAppMono
                  .then(actionService.findById(savedAction.getId()));
  
          StepVerifier
                  .create(Mono.zip(datasourceMono, actionMono))
                  .assertNext(tuple -> {
                      Datasource datasource1 = tuple.getT1();
                      Action action1 = tuple.getT2();
  
                      // Check that the datasource used in the app contains public execute permission
                      assertThat(datasource1.getPolicies()).containsAll(Set.of(manageDatasourcePolicy, readDatasourcePolicy, executeDatasourcePolicy));
  
                      // Check that the action used in the app contains public execute permission
                      assertThat(action1.getPolicies()).containsAll(Set.of(manageActionPolicy, readActionPolicy, executeActionPolicy));
  
                  })
                  .verifyComplete();
      }
  
      @Test
      @WithUserDetails(value = "api_user")
      public void createCloneApplication() {
          Application testApplication = new Application();
          testApplication.setName("ApplicationServiceTest Clone Source TestApp");
  
          Mono<Application> testApplicationMono = applicationPageService.createApplication(testApplication, orgId)
                  .cache();
  
          Mono<Application> applicationMono = testApplicationMono
                  .flatMap(application -> applicationPageService.cloneApplication(application.getId()))
                  .cache();
  
          Policy manageAppPolicy = Policy.builder().permission(MANAGE_APPLICATIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readAppPolicy = Policy.builder().permission(READ_APPLICATIONS.getValue())
                  .users(Set.of("api_user"))
                  .build();
  
          Mono<List<Page>> pageListMono = applicationMono
                  .flatMapMany(application -> Flux.fromIterable(application.getPages()))
                  .flatMap(applicationPage -> pageRepository.findById(applicationPage.getId()))
                  .collectList();
  
          Policy managePagePolicy = Policy.builder().permission(MANAGE_PAGES.getValue())
                  .users(Set.of("api_user"))
                  .build();
          Policy readPagePolicy = Policy.builder().permission(READ_PAGES.getValue())
                  .users(Set.of("api_user"))
                  .build();
  
          StepVerifier
                  .create(Mono.zip(applicationMono, pageListMono))
                  .assertNext(tuple -> {
                      Application application = tuple.getT1();
                      List<Page> pageList = tuple.getT2();
                      assertThat(application).isNotNull();
                      assertThat(application.isAppIsExample()).isFalse();
                      assertThat(application.getId()).isNotNull();
                      assertThat(application.getName().equals("ApplicationServiceTest Clone Source TestApp Copy"));
                      assertThat(application.getPolicies()).containsAll(Set.of(manageAppPolicy, readAppPolicy));
                      assertThat(application.getOrganizationId().equals(orgId));
  
                      assertThat(pageList).isNotEmpty();
                      for (Page page : pageList) {
                          assertThat(page.getPolicies()).containsAll(Set.of(managePagePolicy, readPagePolicy));
                          assertThat(page.getApplicationId()).isEqualTo(application.getId());
                      }
                  })
                  .verifyComplete();
  
          // verify that Pages are cloned
  
          Mono<List<Page>> testPageListMono = testApplicationMono
                  .flatMapMany(application -> Flux.fromIterable(application.getPages()))
                  .flatMap(applicationPage -> pageRepository.findById(applicationPage.getId()))
                  .collectList();
  
          Mono<List<String>> pageIdListMono = pageListMono
                  .flatMapMany(Flux::fromIterable)
                  .map(Page::getId)
                  .collectList();
  
          Mono<List<String>> testPageIdListMono = testPageListMono
                  .flatMapMany(Flux::fromIterable)
                  .map(Page::getId)
                  .collectList();
  
          StepVerifier
                  .create(Mono.zip(pageIdListMono, testPageIdListMono))
                  .assertNext(tuple -> {
                      List<String> pageIdList = tuple.getT1();
                      List<String> testPageIdList = tuple.getT2();
  
                      assertThat(pageIdList).doesNotContainAnyElementsOf(testPageIdList);
                  })
                  .verifyComplete();
  
          // verify that cloned Pages are not renamed
  
          Mono<List<String>> pageNameListMono = pageListMono
                  .flatMapMany(Flux::fromIterable)
                  .map(Page::getName)
                  .collectList();
  
          Mono<List<String>> testPageNameListMono = testPageListMono
                  .flatMapMany(Flux::fromIterable)
                  .map(Page::getName)
                  .collectList();
  
          StepVerifier
                  .create(Mono.zip(pageNameListMono, testPageNameListMono))
                  .assertNext(tuple -> {
                      List<String> pageNameList = tuple.getT1();
                      List<String> testPageNameList = tuple.getT2();
  
                      assertThat(pageNameList).containsExactlyInAnyOrderElementsOf(testPageNameList);
                  })
                  .verifyComplete();
      }
  
  }
  