コード例 #1
0
  @Test(enabled = TESTS_ENABLED)
  @SuppressWarnings("unchecked")
  public void synchronizeRepo() throws Exception {

    // Test
    // --------------------------------------------
    boolean completed =
        pluginService.getContentProviderManager().synchronizeRepo(repoToSync.getId());
    assert completed;

    // Verify
    // --------------------------------------------

    // Make sure the proper calls were made into the provider
    assert contentProvider1.getLogSynchronizePackagesRepos().size() == 1
        : "Expected: 1, Found: " + contentProvider1.getLogSynchronizePackagesRepos().size();

    // Need to add in distro packages being syncced
    assert contentProvider1.getLogGetInputStreamLocations().size()
            == TestContentProvider.PACKAGE_COUNT_FOR_BITS
        : "Expected: "
            + TestContentProvider.PACKAGE_COUNT_FOR_BITS
            + ", Found: "
            + contentProvider1.getLogGetInputStreamLocations().size();

    // Make sure all of the packages were added
    TransactionManager tx = getTransactionManager();
    tx.begin();
    EntityManager entityManager = getEntityManager();

    Query query = entityManager.createNamedQuery(PackageVersion.QUERY_FIND_BY_REPO_ID);
    query.setParameter("repoId", repoToSync.getId());
    List<PackageVersion> repoPackages = query.getResultList();

    assert repoPackages.size() == TestContentProvider.PACKAGES.size()
        : "Expected: " + TestContentProvider.PACKAGES.size() + ", Found: " + repoPackages.size();

    // Make sure all of the distributions were added
    query = entityManager.createNamedQuery(RepoDistribution.QUERY_FIND_BY_REPO_ID);
    query.setParameter("repoId", repoToSync.getId());
    List<RepoDistribution> repoDistributions = query.getResultList();

    assert repoDistributions.size() == TestContentProvider.DISTRIBUTIONS.size()
        : "Expected: "
            + TestContentProvider.DISTRIBUTIONS.size()
            + ", Found: "
            + repoDistributions.size();

    // Make sure each distribution has the correct files associated
    int distro1FileCount =
        countDistroFiles(entityManager, TestContentProvider.DISTRIBUTION_1_LABEL);
    assert distro1FileCount == 2 : "Expected: 2, Found: " + distro1FileCount;

    int distro2FileCount =
        countDistroFiles(entityManager, TestContentProvider.DISTRIBUTION_2_LABEL);
    assert distro2FileCount == 1 : "Expected: 1, Found: " + distro1FileCount;

    tx.rollback();
  }
コード例 #2
0
  @Override
  public ListGridRecord copyValues(Repo from) {
    TreeNode record = new TreeNode();

    record.setID(String.valueOf(from.getId()));
    record.setName(from.getName());

    record.setAttribute("id", from.getId());
    record.setAttribute("name", from.getName());
    record.setAttribute("description", from.getDescription());
    record.setAttribute("syncSchedule", from.getSyncSchedule());
    record.setAttribute("syncStatus", from.getSyncStatus());

    record.setIsFolder(false); // don't attempt to load any children

    return record;
  }
コード例 #3
0
  @BeforeMethod
  public void setupBeforeMethod() throws Exception {

    // Plugin service setup
    prepareScheduler();
    pluginService = new TestContentServerPluginService(this);

    TransactionManager tx = getTransactionManager();
    try {
      tx.begin();
      EntityManager entityManager = getEntityManager();

      ContentManagerLocal contentManager = LookupUtil.getContentManager();
      ContentSourceManagerLocal contentSourceManager = LookupUtil.getContentSourceManager();
      RepoManagerLocal repoManager = LookupUtil.getRepoManagerLocal();
      ResourceTypeManagerLocal resourceTypeManager = LookupUtil.getResourceTypeManager();
      SubjectManagerLocal subjectManager = LookupUtil.getSubjectManager();
      Subject overlord = subjectManager.getOverlord();

      // protect if it aleady exists due to a failed run
      contentSourceType = contentSourceManager.getContentSourceType("testType");
      if (null == contentSourceType) {
        // Create a sample content source type that will be used in this test
        contentSourceType = new ContentSourceType("testType");
        entityManager.persist(contentSourceType);
        entityManager.flush();
      }

      // protect if it aleady exists due to a failed run
      ContentSource cs1 =
          contentSourceManager.getContentSourceByNameAndType(
              overlord, "contentSource1", "testType");
      if (null == cs1) {
        // A repo sync will query all providers for that repo, so add multiple providers
        cs1 = new ContentSource("contentSource1", contentSourceType);
        cs1.setDownloadMode(DownloadMode.DATABASE);
        cs1 = contentSourceManager.simpleCreateContentSource(overlord, cs1);
      }
      ContentSource cs2 =
          contentSourceManager.getContentSourceByNameAndType(
              overlord, "contentSource2", "testType");
      if (null == cs2) {
        cs2 = new ContentSource("contentSource2", contentSourceType);
        cs2.setDownloadMode(DownloadMode.DATABASE);
        cs2 = contentSourceManager.simpleCreateContentSource(overlord, cs2);
      }

      pluginService.associateContentProvider(cs1, contentProvider1);
      pluginService.associateContentProvider(cs2, contentProvider2);

      repoContentSources.add(cs1);
      repoContentSources.add(cs2);

      // Create the package type packages will be created against
      resourceType =
          resourceTypeManager.getResourceTypeByNameAndPlugin(
              TestContentProvider.RESOURCE_TYPE_NAME,
              TestContentProvider.RESOURCE_TYPE_PLUGIN_NAME);
      if (null == resourceType) {
        resourceType =
            new ResourceType(
                TestContentProvider.RESOURCE_TYPE_NAME,
                TestContentProvider.RESOURCE_TYPE_PLUGIN_NAME,
                ResourceCategory.PLATFORM,
                null);
        entityManager.persist(resourceType);
        entityManager.flush();
      }

      List<PackageType> packageTypes =
          contentManager.findPackageTypes(
              overlord,
              TestContentProvider.RESOURCE_TYPE_NAME,
              TestContentProvider.RESOURCE_TYPE_PLUGIN_NAME);
      if (!packageTypes.isEmpty()) {
        packageType = packageTypes.get(0);
      } else {
        packageType = new PackageType(TestContentProvider.PACKAGE_TYPE_NAME, resourceType);
        entityManager.persist(packageType);
      }

      // Create the repo to be synced
      List<Repo> repos = repoManager.getRepoByName(TestContentProvider.REPO_WITH_PACKAGES);
      if (!repos.isEmpty()) {
        repoToSync = repos.get(0);
      } else {
        Repo repo = new Repo(TestContentProvider.REPO_WITH_PACKAGES);
        repo.addContentSource(cs1);
        //        repo.addContentSource(cs2);  Disabled until we implement a second test content
        // source to return new stuff
        repoToSync = repoManager.createRepo(overlord, repo);
      }

      tx.commit();
    } catch (Throwable t) {
      tx.rollback();
      // rethrow because if we swallow the exception then tests proceed to execute when they
      // probably should not
      throw new RuntimeException(t);
    }
  }
コード例 #4
0
  @AfterMethod
  public void tearDownAfterMethod() throws Exception {
    try {

      TransactionManager tx = getTransactionManager();
      tx.begin();
      EntityManager entityManager = getEntityManager();

      Query query;

      ContentSourceManagerLocal contentSourceManagerLocal = LookupUtil.getContentSourceManager();
      RepoManagerLocal repoManager = LookupUtil.getRepoManagerLocal();
      DistributionManagerLocal distroManager = LookupUtil.getDistributionManagerLocal();
      SubjectManagerLocal subjectManager = LookupUtil.getSubjectManager();
      Subject overlord = subjectManager.getOverlord();

      // Delete all distributions
      distroManager.deleteDistributionMappingsForRepo(overlord, repoToSync.getId());

      for (String distroLabel : TestContentProvider.DISTRIBUTIONS.keySet()) {
        Distribution distro = distroManager.getDistributionByLabel(distroLabel);
        if (distro != null) {
          // Delete the files
          query = entityManager.createNamedQuery(DistributionFile.DELETE_BY_DIST_ID);
          query.setParameter("distId", distro.getId());
          query.executeUpdate();

          // Delete the actual distro
          distroManager.deleteDistributionByDistId(overlord, distro.getId());
        }
      }

      // Delete all package version <-> content source mappings
      for (ContentSource source : repoContentSources) {
        contentSourceManagerLocal.deleteContentSource(overlord, source.getId());
      }
      repoContentSources.clear();

      // Delete the repo
      repoManager.deleteRepo(overlord, repoToSync.getId());

      // Delete any packages that were created
      for (ContentProviderPackageDetails details : TestContentProvider.PACKAGES.values()) {
        String packageName = details.getContentProviderPackageDetailsKey().getName();

        query = entityManager.createNamedQuery(Package.QUERY_FIND_BY_NAME_PKG_TYPE_ID);
        query.setParameter("name", packageName);
        query.setParameter("packageTypeId", packageType.getId());

        Package p = (Package) query.getSingleResult();
        entityManager.remove(p);
      }

      // Delete the package type
      packageType = entityManager.find(PackageType.class, packageType.getId());
      entityManager.remove(packageType);

      resourceType = entityManager.find(ResourceType.class, resourceType.getId());
      entityManager.remove(resourceType);

      // Delete the content source type
      contentSourceType = entityManager.find(ContentSourceType.class, contentSourceType.getId());
      entityManager.remove(contentSourceType);

      tx.commit();

      // Cleanup providers between tests
      contentProvider1.reset();
      contentProvider2.reset();

    } finally {
      // Plugin service teardown
      unprepareServerPluginService();
      unprepareScheduler();
    }
  }