Spring boot migrator displays only applied recipe (#321)

Co-authored-by: Andrei Shakirin <[email protected]>

Author: sanagaraj-pivotal

applications/spring-shell/src/main/java/org/springframework/sbm/shell/ApplyCommandRenderer.java

@@ -65,13 +65,13 @@ public class ApplyCommandRenderer {
     @Setter
     private int delay = 250;
 
-    public AttributedString render(Recipe recipe) {
+    public AttributedString render(String recipeName, List<Action> actions) {
         AttributedStringBuilder builder = new AttributedStringBuilder();
         builder.append("\n");
         builder.style(AttributedStyle.DEFAULT.italicDefault());
-        builder.append(recipe.getName());
+        builder.append(recipeName);
         builder.append(" successfully applied the following actions:\n")
-                .append(recipe.getActions().stream()
+                .append(actions.stream()
                         .map(a -> "  (x) " + getDescriptionWithIndent(a))
                         .collect(Collectors.joining("\n")))
                 .append("\n");

applications/spring-shell/src/main/java/org/springframework/sbm/shell/ApplyShellCommand.java

@@ -20,6 +20,7 @@
 import org.springframework.sbm.engine.commands.ApplyCommand;
 import org.springframework.sbm.engine.context.ProjectContext;
 import org.springframework.sbm.engine.context.ProjectContextHolder;
+import org.springframework.sbm.engine.recipe.Action;
 import org.springframework.sbm.engine.recipe.Recipe;
 import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
@@ -57,8 +58,8 @@ public AttributedString apply(@ShellOption(arity = 1, valueProvider = ApplyRecip
         System.out.println(header.toAnsi());
 
         ProjectContext projectContext = projectContextHolder.getProjectContext();
-        Recipe recipe = applyCommand.execute(projectContext, recipeName);
-        AttributedString applyCommandOutput = applyCommandRenderer.render(recipe);
+        List<Action> appliedActions = applyCommand.execute(projectContext, recipeName);
+        AttributedString applyCommandOutput = applyCommandRenderer.render(recipeName, appliedActions);
 
         List<Recipe> applicableRecipes = applicableRecipeListCommand.execute(projectContext);
         AttributedString applicableRecipesOutput = applicableRecipeListRenderer.render(applicableRecipes);

applications/spring-shell/src/test/java/org/springframework/sbm/shell/ApplyShellCommandTest.java

@@ -58,7 +58,6 @@ class ApplyShellCommandTest {
     @Test
     void testApply() {
         String recipeName = "recipe-1";
-        Recipe recipe = new Recipe();
         AttributedString applyOutput = new AttributedString("applyOutput");
         List<Recipe> applicableRecipes = List.of();
         AttributedString applicableRecipesOutput = new AttributedString("applicableRecipesOutput");
@@ -67,8 +66,8 @@ void testApply() {
 
         ProjectContext projectContext = mock(ProjectContext.class);
         when(projectContextHolder.getProjectContext()).thenReturn(projectContext);
-        when(applyCommand.execute(projectContext, recipeName)).thenReturn(recipe);
-        when(applyCommandRenderer.render(recipe)).thenReturn(applyOutput);
+        when(applyCommand.execute(projectContext, recipeName)).thenReturn(List.of());
+        when(applyCommandRenderer.render(recipeName, List.of())).thenReturn(applyOutput);
         when(applicableRecipeListCommand.execute(projectContext)).thenReturn(applicableRecipes);
         when(applicableRecipeListRenderer.render(applicableRecipes)).thenReturn(applicableRecipesOutput);
 

components/sbm-core/src/main/java/org/springframework/sbm/engine/commands/ApplyCommand.java

@@ -19,25 +19,18 @@
 import org.springframework.sbm.common.filter.ModifiedResourcePathStringFilter;
 import org.springframework.sbm.engine.context.ProjectContext;
 import org.springframework.sbm.engine.context.ProjectContextSerializer;
-import org.springframework.sbm.engine.context.ProjectRootPathResolver;
 import org.springframework.sbm.engine.git.GitSupport;
 import org.springframework.sbm.engine.git.ProjectSyncVerifier;
+import org.springframework.sbm.engine.recipe.Action;
 import org.springframework.sbm.engine.recipe.Recipe;
 import org.springframework.sbm.engine.recipe.RecipesBuilder;
-import org.springframework.sbm.project.parser.ProjectContextInitializer;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
 
 @Component
 public class ApplyCommand extends AbstractCommand<Recipe> {
 
-    private final ProjectContextInitializer projectContextBuilder;
-
-    private final ApplyCommandHelper applyCommandHelper;
-
-    private final ProjectRootPathResolver projectRootPathResolver;
-
     private final RecipesBuilder recipesBuilder;
 
     private final ProjectContextSerializer contextSerializer;
@@ -47,27 +40,25 @@ public class ApplyCommand extends AbstractCommand<Recipe> {
     private final GitSupport gitSupport;
 
     public ApplyCommand(
-            ProjectContextInitializer projectContextBuilder,
-            ApplyCommandHelper applyCommandHelper,
-            ProjectRootPathResolver projectRootPathResolver, RecipesBuilder recipesBuilder, ProjectContextSerializer contextSerializer, ProjectSyncVerifier projectSyncVerifier, GitSupport gitSupport) {
+            RecipesBuilder recipesBuilder,
+            ProjectContextSerializer contextSerializer,
+            ProjectSyncVerifier projectSyncVerifier,
+            GitSupport gitSupport) {
         super("apply");
-        this.projectContextBuilder = projectContextBuilder;
-        this.applyCommandHelper = applyCommandHelper;
-        this.projectRootPathResolver = projectRootPathResolver;
         this.recipesBuilder = recipesBuilder;
         this.contextSerializer = contextSerializer;
         this.projectSyncVerifier = projectSyncVerifier;
         this.gitSupport = gitSupport;
     }
 
-    public Recipe execute(ProjectContext projectContext, String recipeName) {
+    public List<Action> execute(ProjectContext projectContext, String recipeName) {
         Recipe recipe = recipesBuilder.buildRecipes().getRecipeByName(recipeName)
                 .orElseThrow(() -> new IllegalArgumentException("Recipe with name '" + recipeName + "' could not be found"));
 
         // verify that project sources are in sync with in memory representation
         projectSyncVerifier.rescanWhenProjectIsOutOfSyncAndGitAvailable(projectContext);
 
-        recipe.apply(projectContext);
+        List<Action> appliedActions = recipe.apply(projectContext);
 
         // verify that project sources didn't change while running recipe
         projectSyncVerifier.verifyProjectIsInSyncWhenGitAvailable(projectContext);
@@ -80,21 +71,12 @@ public Recipe execute(ProjectContext projectContext, String recipeName) {
 
         gitSupport.commitWhenGitAvailable(projectContext, recipeName, modifiedResources, deletedResources);
 
-        return recipe;
+        return appliedActions;
     }
 
     @Override
     @Deprecated
     public Recipe execute(String... arguments) {
-//        if (arguments == null || arguments.length < 2) {
-//            throw new IllegalArgumentException("Apply command needs project path (as first) and recipe name (as second) to be provided");
-//        } else {
-//            Path projectRoot = projectRootPathResolver.getProjectRootOrDefault(arguments[0]);
-//            // FIXME: This triggers a new scan which shouldn't be required. Retrieve current ProjectContext from...? and use it here.
-//            ProjectContext context = projectContextBuilder.initProjectContext(projectRoot, new RewriteExecutionContext());
-//            return applyCommandHelper.applyRecipe(context, arguments[1]);
-//        }
         return null;
     }
-
 }

components/sbm-core/src/main/java/org/springframework/sbm/engine/recipe/Recipe.java

@@ -22,6 +22,7 @@
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotEmpty;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -50,8 +51,8 @@ public class Recipe {
     public Recipe(
             @JsonProperty(value = "name", required = true) String name,
             @JsonProperty(value = "actions", required = true) List<Action> actions,
-            @JsonProperty(value = "condition", required = false) Condition condition,
-            @JsonProperty(value = "order", required = false) Integer order
+            @JsonProperty(value = "condition") Condition condition,
+            @JsonProperty(value = "order") Integer order
     ) {
         this.name = name;
         this.actions = actions;
@@ -91,10 +92,18 @@ public boolean isApplicable(ProjectContext context) {
         return condition.evaluate(context) && actions.stream().anyMatch(a -> a.isApplicable(context));
     }
 
-    public void apply(ProjectContext context) {
-        actions.stream()
-                .filter(a -> a.isApplicable(context))
-                .forEach(a -> a.applyWithStatusEvent(context));
+    public List<Action> apply(ProjectContext context) {
+
+        List<Action> appliedActions = new ArrayList<>();
+        for (Action action : actions) {
+
+             if (action.isApplicable(context)) {
+                 action.applyWithStatusEvent(context);
+                 appliedActions.add(action);
+             }
+        }
+
+        return appliedActions;
     }
 
     public String getDetails() {

components/sbm-core/src/main/java/org/springframework/sbm/engine/recipe/RecipeLoader.java

@@ -15,11 +15,6 @@
  */
 package org.springframework.sbm.engine.recipe;
 
-import org.springframework.sbm.project.resource.ResourceHelper;
-import lombok.RequiredArgsConstructor;
-import org.springframework.core.io.Resource;
-import org.springframework.stereotype.Component;
-
 import java.util.List;
 
 public interface RecipeLoader {

components/sbm-core/src/test/java/org/springframework/sbm/engine/commands/ApplyCommandTest.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2021 - 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.sbm.engine.commands;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.sbm.engine.context.ProjectContext;
+import org.springframework.sbm.engine.context.ProjectContextSerializer;
+import org.springframework.sbm.engine.git.GitSupport;
+import org.springframework.sbm.engine.git.ProjectSyncVerifier;
+import org.springframework.sbm.engine.recipe.Action;
+import org.springframework.sbm.engine.recipe.Recipe;
+import org.springframework.sbm.engine.recipe.Recipes;
+import org.springframework.sbm.engine.recipe.RecipesBuilder;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class ApplyCommandTest {
+    @Mock
+    private RecipesBuilder recipesBuilder;
+    @Mock
+    private ProjectContextSerializer contextSerializer;
+    @Mock
+    private ProjectSyncVerifier projectSyncVerifier;
+    @Mock
+    private GitSupport gitSupport;
+    @Mock
+    Recipes recipes;
+    @Mock
+    private Recipe recipe;
+    @Mock
+    ProjectContext projectContext;
+    @Mock
+    Action action1;
+    @Mock
+    Action action2;
+
+    @InjectMocks
+    ApplyCommand applyCommand;
+
+    @Test
+    void shouldReturnActionList() {
+        when(recipesBuilder.buildRecipes()).thenReturn(recipes);
+        when(recipes.getRecipeByName("testRecipe")).thenReturn(Optional.of(recipe));
+        when(recipe.apply(projectContext)).thenReturn(List.of(action1, action2));
+        List<Action> actions = applyCommand.execute(projectContext, "testRecipe");
+
+        assertThat(actions).hasSize(2);
+        assertThat(actions).contains(action1).contains(action2);
+    }
+}

components/sbm-core/src/test/java/org/springframework/sbm/engine/recipe/RecipeTest.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2021 - 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.sbm.engine.recipe;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.sbm.engine.context.ProjectContext;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class RecipeTest {
+    @Mock
+    Action applicableAction;
+    @Mock
+    Action notApplicableAction;
+    @Mock
+    ProjectContext projectContext;
+
+    @Test
+    void shouldReturnOnlyApplicableActions() {
+        when(applicableAction.isApplicable(any(ProjectContext.class))).thenReturn(true);
+        when(notApplicableAction.isApplicable(any(ProjectContext.class))).thenReturn(false);
+        Recipe testRecipe = new Recipe(
+                "test recipe",
+                List.of(applicableAction, notApplicableAction),
+                Condition.TRUE,
+                0);
+
+        List<Action> actionList = testRecipe.apply(projectContext);
+
+        assertThat(actionList).hasSize(1);
+        assertThat(actionList).contains(applicableAction);
+    }
+
+    @Test
+    void shouldReturnOnlyActionsWhichHaveSuccessfullyBeingApplied() {
+
+        when(applicableAction.isApplicable(any(ProjectContext.class))).thenReturn(true);
+        when(notApplicableAction.isApplicable(any(ProjectContext.class))).thenReturn(false);
+
+        final Action successAction = mock(Action.class);
+        final Action failAction = mock(Action.class);
+
+        when(successAction.isApplicable(any(ProjectContext.class))).thenReturn(true);
+        when(failAction.isApplicable(any(ProjectContext.class))).thenReturn(true);
+
+        Recipe testRecipe = new Recipe(
+                "test recipe",
+                List.of(
+                        applicableAction,
+                        notApplicableAction,
+                        successAction,
+                        failAction
+                ),
+                Condition.TRUE,
+                0);
+
+
+        doThrow(new RuntimeException("")).when(failAction).applyWithStatusEvent(any());
+
+        assertThrows(RuntimeException.class, () -> testRecipe.apply(projectContext));
+    }
+}