Examples of org.jboss.forge.addon.projects.Project

org.jboss.forge.addon.projects.Project
Describes a set of {@link Resource} instances that represent a unit of work. @author Lincoln Baxter, III

   }


   @Test
   public void shouldReturnOneLogEntryForSingleCommit() throws Exception
   {
      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());
      String commitMsg = "First commit";


      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, "initial commit");


      FileResource<?> file = (FileResource<?>) project.getRootDirectory().getChild("test.txt");
      file.setContents("Foo bar baz contents").createNewFile();
      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, commitMsg);


      List<String> logs = gitUtils.getLogForCurrentBranch(repo);

View Full Code Here

   public void shouldReturnTwoLogEntriesForTwoCommits() throws Exception
   {
      boolean isCreated = false;
      String[] commitMsgs = { "initial commit", "First commit", "Second commit" };


      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());


      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, commitMsgs[0]);


      FileResource<?> file1 = project.getRootDirectory().getChild("test.txt").reify(FileResource.class);
      isCreated = file1.createNewFile();
      Assert.assertTrue("file 1 was not created", isCreated);
      file1.setContents("Foo bar baz contents");
      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, commitMsgs[1]);


      FileResource<?> file2 = project.getRootDirectory().getChild("testTwo.txt").reify(FileResource.class);
      isCreated = file2.createNewFile();
      Assert.assertTrue("file 2 was not created", isCreated);
      file2.setContents("Foo bar baz contents");
      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, commitMsgs[2]);

View Full Code Here

   }


   @Test
   public void shouldThrowNoHeadExceptionWhenRepoHasNoCommits() throws Exception
   {
      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());


      try
      {
         gitUtils.getLogForCurrentBranch(repo);
         Assert.fail("Expected " + NoHeadException.class);

View Full Code Here

   public void shouldStashAndApplyCommit() throws Exception
   {
      boolean isCreated = false;
      String[] commitMsgs = { "initial commit", "First commit" };


      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());


      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, commitMsgs[0]);


      FileResource<?> file1 = project.getRootDirectory().getChild("test.txt").reify(FileResource.class);
      isCreated = file1.createNewFile();
      Assert.assertTrue("file 1 was not created", isCreated);
      file1.setContents("Foo bar baz contents");


      gitUtils.addAll(repo);

View Full Code Here

      // verify number of commits (3 on master branch)


      String[] branchNames = { "master", "branch_two" };
      String[] files = { "test1.txt", "test2.txt" };


      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());


      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, "initial commit");


      repo.branchCreate().setName(branchNames[1]).call();


      FileResource<?> file0 = project.getRootDirectory().getChild(files[0]).reify(FileResource.class);
      file0.createNewFile();
      gitUtils.add(repo, files[0]);
      gitUtils.commit(repo, "file added on " + branchNames[0]);


      gitUtils.switchBranch(repo, branchNames[1]);


      FileResource<?> file1 = project.getRootDirectory().getChild(files[1]).reify(FileResource.class);
      file1.createNewFile();
      gitUtils.add(repo, files[1]);
      gitUtils.commit(repo, "file added on " + branchNames[1]);


      gitUtils.getLogForCurrentBranch(repo);


      gitUtils.switchBranch(repo, branchNames[0]);
      Ref branch2Ref = repo.getRepository().getRef(branchNames[1]);
      gitUtils.cherryPick(repo, branch2Ref);


      // assert file2 exists
      Assert.assertTrue("file from cherry picked commit should exist", project.getRootDirectory().getChild(files[1])
               .exists());


      // assert number of commits (on master). Should be 3, latest created by the merge from cherry pick
      List<String> log = gitUtils.getLogForCurrentBranch(repo);
      Assert.assertEquals("wrong number of commits", 3, log.size());

View Full Code Here

      // verify number of commits (2 on master branch)


      String[] branchNames = { "master", "branch_two" };
      String[] files = { "test1.txt", "test2.txt" };


      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());


      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, "initial commit");


      repo.branchCreate().setName(branchNames[1]).call();


      FileResource<?> file0 = project.getRootDirectory().getChild(files[0]).reify(FileResource.class);
      file0.createNewFile();
      gitUtils.add(repo, files[0]);
      gitUtils.commit(repo, "file added on " + branchNames[0]);


      gitUtils.switchBranch(repo, branchNames[1]);


      FileResource<?> file1 = project.getRootDirectory().getChild(files[1]).reify(FileResource.class);
      file1.createNewFile();
      gitUtils.add(repo, files[1]);
      gitUtils.commit(repo, "file added on " + branchNames[1]);


      gitUtils.getLogForCurrentBranch(repo);


      gitUtils.switchBranch(repo, branchNames[0]);
      Ref branch2Ref = repo.getRepository().getRef(branchNames[1]);
      gitUtils.cherryPickNoMerge(repo, branch2Ref);


      // assert file2 exists
      Assert.assertTrue("file from cherry picked commit should exist", project.getRootDirectory().getChild(files[1])
               .exists());


      // assert number of commits (on master). Should be 2 (cherry pick produced no merge)
      List<String> log = gitUtils.getLogForCurrentBranch(repo);
      Assert.assertEquals("wrong number of commits", 2, log.size());

View Full Code Here


      List<String> log = null;
      String[] branchNames = { "master" };
      String[] files = { "test1.txt", "test2.txt" };


      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());


      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, "initial commit");


      FileResource<?> file0 = project.getRootDirectory().getChild(files[0]).reify(FileResource.class);
      file0.createNewFile();
      gitUtils.add(repo, files[0]);
      gitUtils.commit(repo, "file added on " + branchNames[0]);


      log = gitUtils.getLogForCurrentBranch(repo);
      Assert.assertEquals("wrong number of commits", 2, log.size());
      Assert.assertTrue("file should exist", project.getRootDirectory().getChild(files[0]).exists());


      FileResource<?> file1 = project.getRootDirectory().getChild(files[1]).reify(FileResource.class);
      file1.createNewFile();
      gitUtils.add(repo, files[1]);
      gitUtils.commit(repo, "file added on " + branchNames[0]);


      log = gitUtils.getLogForCurrentBranch(repo);
      Assert.assertEquals("wrong number of commits", 3, log.size());
      Assert.assertTrue("file should exist", project.getRootDirectory().getChild(files[1]).exists());


      gitUtils.resetHard(repo, "HEAD^1");
      log = gitUtils.getLogForCurrentBranch(repo);
      Assert.assertEquals("wrong number of commits", 2, log.size());
      Assert.assertTrue("file should exist", project.getRootDirectory().getChild(files[0]).exists());
      Assert.assertFalse("file should not exist", project.getRootDirectory().getChild(files[1]).exists());
   }

View Full Code Here

      // git init
      // create new branch
      // verify branch exists


      String testBranchName = "testBranch";
      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());


      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, "initial commit");


      Ref testBranch = gitUtils.createBranch(repo, testBranchName);

View Full Code Here

      String[] branchNames = { "master" };
      String[] files = { "test1.txt" };
      List<String> commits = null;
      CherryPickResult cherryPickResult = null;


      Project project = projectFactory.createTempProject();
      Git repo = gitUtils.init(project.getRootDirectory());


      gitUtils.addAll(repo);
      gitUtils.commitAll(repo, "initial commit");


      FileResource<?> file0 = project.getRootDirectory().getChild(files[0]).reify(FileResource.class);
      file0.createNewFile();
      gitUtils.add(repo, files[0]);
      gitUtils.commit(repo, "file added on " + branchNames[0]);


      commits = gitUtils.getLogForCurrentBranch(repo);

View Full Code Here

   private Furnace furnace;


   @Test
   public void testComplexAddonProject() throws FileNotFoundException, FacetNotFoundException
   {
      Project project = projectFactory.createTempProject();
      project.getRoot().reify(DirectoryResource.class).deleteOnExit();


      MetadataFacet metadataFacet = project.getFacet(MetadataFacet.class);
      metadataFacet.setProjectName("testproject");
      metadataFacet.setProjectVersion("1.0.0-SNAPSHOT");
      metadataFacet.setProjectGroupName("com.acme.testproject");


      Version forgeVersion = furnace.getVersion();
      configurator.setupComplexAddonProject(project, forgeVersion, Collections.<AddonId> emptyList());
      Assert.assertTrue(project.hasFacet(AddonParentFacet.class));
      Assert.assertTrue(project.hasFacet(JavaCompilerFacet.class));
      Assert.assertFalse(project.hasFacet(JavaSourceFacet.class));
      Assert.assertFalse(project.hasFacet(CDIFacet.class));
      Assert.assertFalse(project.hasFacet(ResourcesFacet.class));
      Resource<?> projectRoot = project.getRoot();


      Assert.assertTrue("ADDON module is missing", projectRoot.getChild("addon").exists());
      Assert.assertTrue("API module is missing", projectRoot.getChild("api").exists());
      Assert.assertTrue("IMPL module is missing", projectRoot.getChild("impl").exists());
      Assert.assertTrue("SPI module is missing", projectRoot.getChild("spi").exists());
      Assert.assertTrue("TESTS module is missing", projectRoot.getChild("tests").exists());


      Project addonProject = projectFactory.findProject(projectRoot.getChild("addon"));
      Project apiProject = projectFactory.findProject(projectRoot.getChild("api"));
      Project implProject = projectFactory.findProject(projectRoot.getChild("impl"));
      Project spiProject = projectFactory.findProject(projectRoot.getChild("spi"));
      Project testsProject = projectFactory.findProject(projectRoot.getChild("tests"));


      Assert.assertTrue(project.hasFacet(ForgeBOMFacet.class));


      Assert.assertFalse(addonProject.hasFacet(ForgeBOMFacet.class));
      Assert.assertFalse(addonProject.hasFacet(JavaCompilerFacet.class));
      Assert.assertTrue(addonProject.hasFacet(JavaSourceFacet.class));
      Assert.assertTrue(addonProject.hasFacet(ResourcesFacet.class));
      Assert.assertFalse(addonProject.hasFacet(CDIFacet.class));


      Assert.assertFalse(apiProject.hasFacet(ForgeBOMFacet.class));
      Assert.assertFalse(apiProject.hasFacet(JavaCompilerFacet.class));
      Assert.assertTrue(apiProject.hasFacet(JavaSourceFacet.class));
      Assert.assertTrue(apiProject.hasFacet(ResourcesFacet.class));
      Assert.assertTrue(apiProject.hasFacet(CDIFacet_1_1.class));


      Assert.assertFalse(implProject.hasFacet(ForgeBOMFacet.class));
      Assert.assertFalse(implProject.hasFacet(JavaCompilerFacet.class));
      Assert.assertTrue(implProject.hasFacet(JavaSourceFacet.class));
      Assert.assertTrue(implProject.hasFacet(ResourcesFacet.class));
      Assert.assertTrue(implProject.hasFacet(CDIFacet_1_1.class));


      Assert.assertFalse(spiProject.hasFacet(ForgeBOMFacet.class));
      Assert.assertFalse(spiProject.hasFacet(JavaCompilerFacet.class));
      Assert.assertTrue(spiProject.hasFacet(JavaSourceFacet.class));
      Assert.assertTrue(spiProject.hasFacet(ResourcesFacet.class));
      Assert.assertTrue(spiProject.hasFacet(FurnaceAPIFacet.class));
      Assert.assertFalse(spiProject.hasFacet(CDIFacet_1_1.class));


      Assert.assertFalse(testsProject.hasFacet(ForgeBOMFacet.class));
      Assert.assertFalse(testsProject.hasFacet(JavaCompilerFacet.class));
      Assert.assertTrue(testsProject.hasFacet(JavaSourceFacet.class));
      Assert.assertTrue(testsProject.hasFacet(ResourcesFacet.class));
      Assert.assertFalse(testsProject.hasFacet(CDIFacet_1_1.class));


      Dependency addonDependency = DependencyBuilder.create(
               addonProject.getFacet(MetadataFacet.class).getOutputDependency())
               .setClassifier(FORGE_ADDON_CLASSIFIER);
      Dependency apiDependency = apiProject.getFacet(MetadataFacet.class).getOutputDependency();
      Dependency implDependency = implProject.getFacet(MetadataFacet.class).getOutputDependency();
      Dependency spiDependency = DependencyBuilder.create(
               spiProject.getFacet(MetadataFacet.class).getOutputDependency())
               .setClassifier(FORGE_ADDON_CLASSIFIER);


      /*
       * Verify parent project
       */
      Assert.assertNull(project.getFacet(MavenFacet.class).getModel().getParent());


      Assert.assertFalse(project.getRoot().getChild("src").exists());
      Assert.assertTrue(project.getFacet(DependencyFacet.class).hasDirectManagedDependency(
               DefaultFurnaceContainerAPIFacet.FURNACE_CONTAINER_API_DEPENDENCY));
      Assert.assertFalse(project.getFacet(DependencyFacet.class).hasDirectDependency(
               DependencyBuilder.create("javax.annotation:jsr250-api:1.0")));
      Assert.assertTrue(project.getFacet(DependencyFacet.class).hasDirectManagedDependency(
               DependencyBuilder.create(addonProject.getFacet(MetadataFacet.class).getOutputDependency())
                        .setClassifier(FORGE_ADDON_CLASSIFIER)));
      Assert.assertTrue(project.getFacet(DependencyFacet.class).hasDirectManagedDependency(apiDependency));
      Assert.assertTrue(project.getFacet(DependencyFacet.class).hasDirectManagedDependency(
               implProject.getFacet(MetadataFacet.class).getOutputDependency()));


      Assert.assertTrue(project.getFacet(DependencyFacet.class).hasDirectManagedDependency(spiDependency));


      /*
       * Verify impl/ sub-module
       */


      Assert.assertEquals(".." + File.separator + "pom.xml", implProject.getFacet(MavenFacet.class).getModel()
               .getParent().getRelativePath());
      Assert.assertTrue(implProject.hasFacet(DefaultFurnaceContainerAPIFacet.class));
      Assert.assertTrue(implProject.getFacet(JavaSourceFacet.class)
               .getJavaResource("com.acme.testproject.package-info.java").exists());


      Assert.assertTrue(implProject.getFacet(DependencyFacet.class).hasDirectDependency(apiDependency));
      Assert.assertFalse(implProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(apiDependency));
      Assert.assertTrue(implProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(apiDependency));
      Assert.assertEquals("provided", implProject.getFacet(DependencyFacet.class).getDirectDependency(apiDependency)
               .getScopeType());


      Assert.assertTrue(implProject.getFacet(DependencyFacet.class).hasDirectDependency(spiDependency));
      Assert.assertFalse(implProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(spiDependency));
      Assert.assertTrue(implProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(spiDependency));
      Assert.assertEquals("provided", implProject.getFacet(DependencyFacet.class).getDirectDependency(spiDependency)
               .getScopeType());


      // Assert.assertTrue(implProject.getFacet(DependencyFacet.class).getManagedDependencies().isEmpty());
      Assert.assertTrue(implProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DefaultFurnaceContainerAPIFacet.FURNACE_CONTAINER_API_DEPENDENCY));
      Assert.assertFalse(implProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(
               DefaultFurnaceContainerAPIFacet.FURNACE_CONTAINER_API_DEPENDENCY));
      Assert.assertTrue(implProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(
               DefaultFurnaceContainerAPIFacet.FURNACE_CONTAINER_API_DEPENDENCY));
      Assert.assertFalse(implProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DependencyBuilder.create("javax.annotation:jsr250-api:1.0")));
      Assert.assertTrue(implProject.hasFacet(AddonImplFacet.class));
      Assert.assertFalse(implProject.hasFacet(FurnacePluginFacet.class));


      /*
       * Verify api/ sub-module
       */
      Assert.assertEquals(".." + File.separator + "pom.xml", apiProject.getFacet(MavenFacet.class).getModel()
               .getParent().getRelativePath());
      Assert.assertTrue(apiProject.hasFacet(DefaultFurnaceContainerAPIFacet.class));
      Assert.assertTrue(apiProject.getFacet(JavaSourceFacet.class)
               .getJavaResource("com.acme.testproject.package-info.java").exists());


      Assert.assertTrue(apiProject.getFacet(DependencyFacet.class).hasDirectDependency(spiDependency));
      Assert.assertFalse(apiProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(spiDependency));
      Assert.assertTrue(apiProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(spiDependency));
      Assert.assertEquals("provided", apiProject.getFacet(DependencyFacet.class).getDirectDependency(spiDependency)
               .getScopeType());


      // Assert.assertTrue(apiProject.getFacet(DependencyFacet.class).getManagedDependencies().isEmpty());
      Assert.assertTrue(apiProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DefaultFurnaceContainerAPIFacet.FURNACE_CONTAINER_API_DEPENDENCY));
      Assert.assertFalse(apiProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(
               DefaultFurnaceContainerAPIFacet.FURNACE_CONTAINER_API_DEPENDENCY));
      Assert.assertTrue(apiProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(
               DefaultFurnaceContainerAPIFacet.FURNACE_CONTAINER_API_DEPENDENCY));
      Assert.assertFalse(apiProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DependencyBuilder.create("javax.annotation:jsr250-api:1.0")));
      Assert.assertTrue(apiProject.hasFacet(AddonAPIFacet.class));
      Assert.assertFalse(apiProject.hasFacet(FurnacePluginFacet.class));


      /*
       * Verify spi/ sub-module2.0.0.Final
       */
      Assert.assertEquals(".." + File.separator + "pom.xml", spiProject.getFacet(MavenFacet.class).getModel()
               .getParent().getRelativePath());
      Assert.assertTrue(spiProject.getFacet(JavaSourceFacet.class)
               .getJavaResource("com.acme.testproject.package-info.java").exists());


      // Assert.assertTrue(spiProject.getFacet(DependencyFacet.class).getManagedDependencies().isEmpty());
      Assert.assertTrue(spiProject.getFacet(DependencyFacet.class).hasDirectDependency(
               FurnaceAPIFacet.FURNACE_API_DEPENDENCY));
      Assert.assertFalse(spiProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(
               FurnaceAPIFacet.FURNACE_API_DEPENDENCY));
      Assert.assertTrue(spiProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(
               FurnaceAPIFacet.FURNACE_API_DEPENDENCY));
      Assert.assertFalse(spiProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DependencyBuilder.create("javax.annotation:jsr250-api:1.0")));
      Assert.assertFalse(spiProject.hasFacet(DefaultFurnaceContainerFacet.class));
      Assert.assertFalse(spiProject.hasFacet(DefaultFurnaceContainerAPIFacet.class));
      Assert.assertFalse(spiProject.hasFacet(CDIFacet_1_1.class));
      Assert.assertTrue(spiProject.hasFacet(AddonSPIFacet.class));
      Assert.assertTrue(spiProject.hasFacet(FurnacePluginFacet.class));


      /*
       * Verify addon/ sub-module
       */
      Assert.assertEquals(".." + File.separator + "pom.xml", addonProject.getFacet(MavenFacet.class).getModel()
               .getParent()
               .getRelativePath());
      Assert.assertTrue(addonProject.getFacet(JavaSourceFacet.class)
               .getJavaResource("com.acme.testproject.package-info.java").exists());


      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).hasDirectDependency(apiDependency));
      Assert.assertFalse(addonProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(apiDependency));
      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(apiDependency));
      Assert.assertNull(addonProject.getFacet(DependencyFacet.class).getDirectDependency(apiDependency)
               .getScopeType());
      Assert.assertFalse(addonProject.getFacet(DependencyFacet.class).getDirectDependency(apiDependency).isOptional());


      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).hasDirectDependency(implDependency));
      Assert.assertFalse(addonProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(implDependency));
      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(implDependency));
      Assert.assertEquals("runtime", addonProject.getFacet(DependencyFacet.class).getDirectDependency(implDependency)
               .getScopeType());
      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).getDirectDependency(implDependency).isOptional());


      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).hasDirectDependency(spiDependency));
      Assert.assertFalse(addonProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(spiDependency));
      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(spiDependency));
      Assert.assertNull(addonProject.getFacet(DependencyFacet.class).getDirectDependency(spiDependency)
               .getScopeType());
      Assert.assertEquals("compile", addonProject.getFacet(DependencyFacet.class).getEffectiveDependency(spiDependency)
               .getScopeType());
      Assert.assertFalse(addonProject.getFacet(DependencyFacet.class).getDirectDependency(spiDependency).isOptional());


      // Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).getManagedDependencies().isEmpty());
      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DefaultFurnaceContainerFacet.FURNACE_CONTAINER_DEPENDENCY));
      Assert.assertFalse(addonProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(
               DefaultFurnaceContainerFacet.FURNACE_CONTAINER_DEPENDENCY));
      Assert.assertTrue(addonProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(
               DefaultFurnaceContainerFacet.FURNACE_CONTAINER_DEPENDENCY));
      Assert.assertFalse(addonProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DependencyBuilder.create("javax.annotation:jsr250-api:1.0")));


      Assert.assertTrue(addonProject.hasFacet(FurnacePluginFacet.class));


      /*
       * Verify tests/ sub-module
       */


      Assert.assertEquals(".." + File.separator + "pom.xml", testsProject.getFacet(MavenFacet.class).getModel()
               .getParent()
               .getRelativePath());


      Assert.assertTrue(testsProject.getFacet(DependencyFacet.class).hasDirectDependency(addonDependency));
      Assert.assertFalse(testsProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(addonDependency));
      Assert.assertTrue(testsProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(addonDependency));
      Assert.assertNull(testsProject.getFacet(DependencyFacet.class).getDirectDependency(addonDependency)
               .getScopeType());
      Assert.assertNotNull("ADDON module is not present in the TESTS module",
               testsProject.getFacet(DependencyFacet.class).getEffectiveDependency(addonDependency));
      Assert.assertEquals("compile",
               testsProject.getFacet(DependencyFacet.class).getEffectiveDependency(addonDependency)
                        .getScopeType());


      Assert.assertFalse(testsProject.getFacet(DependencyFacet.class).hasDirectDependency(spiDependency));
      Assert.assertFalse(testsProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(spiDependency));
      Assert.assertTrue(testsProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(spiDependency));


      // Assert.assertTrue(testsProject.getFacet(DependencyFacet.class).getManagedDependencies().isEmpty());
      Assert.assertTrue(testsProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DefaultFurnaceContainerFacet.FURNACE_CONTAINER_DEPENDENCY));
      Assert.assertFalse(testsProject.getFacet(DependencyFacet.class).hasDirectManagedDependency(
               DefaultFurnaceContainerFacet.FURNACE_CONTAINER_DEPENDENCY));
      Assert.assertTrue(testsProject.getFacet(DependencyFacet.class).hasEffectiveManagedDependency(
               DefaultFurnaceContainerFacet.FURNACE_CONTAINER_DEPENDENCY));
      Assert.assertEquals(forgeVersion.toString(), testsProject.getFacet(DependencyFacet.class).getEffectiveDependency(
               DefaultFurnaceContainerFacet.FURNACE_CONTAINER_DEPENDENCY).getCoordinate().getVersion());
      Assert.assertFalse(testsProject.getFacet(DependencyFacet.class).hasDirectDependency(
               DependencyBuilder.create("javax.annotation:jsr250-api:1.0")));


      Assert.assertTrue(project.getRoot().getChild("README.asciidoc").exists());
      project.getRoot().delete(true);
      project.getRoot().reify(DirectoryResource.class).deleteOnExit();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.jboss.forge.addon.projects.Project

org.jboss.errai.forge.ui.features.AbstractFeatureCommand

org.jboss.forge.addon.addons.AddonProjectConfigurator

org.jboss.forge.addon.addons.FurnaceAddonSetupStep

org.jboss.forge.addon.addons.NewFurnaceTestCommand

org.jboss.forge.addon.addons.NewUICommandWizard

org.jboss.forge.addon.addons.project.AddonProjectConfigurator

org.jboss.forge.addon.addons.project.AddonProjectConfiguratorImpl

org.jboss.forge.addon.addons.project.AddonProjectConfiguratorTest

org.jboss.forge.addon.addons.ui.AddAddonDependencyCommand

org.jboss.forge.addon.addons.ui.AddAddonDependencyCommandImpl

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.