added createSet in Exercise

src/main/java/de/avalax/fitbuddy/application/edit/workout/ManageWorkout.java

@@ -164,19 +164,38 @@ public void changeName(String name) {
         setUnsavedChanges(false);
     }
 
-    public void replaceSets(Exercise exercise, List<Set> setToAdd) {
-        for (int i = 0; i < exercise.countOfSets(); i++) {
+    public void changeSetAmount(Exercise exercise, int newSetAmount) {
+        if (newSetAmount == exercise.countOfSets()) {
+            return;
+        }
+        if (newSetAmount < exercise.countOfSets()) {
+            for (int i=0;i< exercise.countOfSets()-newSetAmount;i++) {
+                try {
+                    Set set = exercise.setAtPosition(i);
+                    exercise.removeSet(set);
+                    setRepository.delete(set.getSetId());
+                } catch (SetNotAvailableException e) {
+                    Log.d("Can't delete set", e.getMessage(), e);
+                }
+            }
+        } else {
+            int indexOfCurrentSet = exercise.indexOfCurrentSet();
+            double weight;
+            int maxReps;
             try {
-                Set set = exercise.setAtPosition(i);
-                setRepository.delete(set.getSetId());
-                exercise.removeSet(set);
+                Set set = exercise.setAtPosition(indexOfCurrentSet);
+                weight = set.getWeight();
+                maxReps = set.getMaxReps();
             } catch (SetNotAvailableException e) {
-                Log.d("Can't delete set", e.getMessage(), e);
+                weight = 0;
+                maxReps = 0;
+            }
+            for (int i=0;i< newSetAmount-exercise.countOfSets();i++) {
+                Set set = exercise.createSet();
+                set.setMaxReps(maxReps);
+                set.setWeight(weight);
+                setRepository.save(exercise.getExerciseId(), set);
             }
-        }
-        for (Set set : setToAdd) {
-            setRepository.save(exercise.getExerciseId(), set);
-            exercise.addSet(set);
         }
         setUnsavedChanges(false);
     }

src/main/java/de/avalax/fitbuddy/domain/model/exercise/BasicExercise.java

@@ -1,6 +1,7 @@
 package de.avalax.fitbuddy.domain.model.exercise;
 
 import android.util.Log;
+import de.avalax.fitbuddy.domain.model.set.BasicSet;
 import de.avalax.fitbuddy.domain.model.set.Set;
 import de.avalax.fitbuddy.domain.model.set.SetNotAvailableException;
 
@@ -100,8 +101,10 @@ public void setName(String name) {
     }
 
     @Override
-    public void addSet(Set set) {
+    public Set createSet() {
+        Set set = new BasicSet();
         sets.add(set);
+        return set;
     }
 
     @Override

src/main/java/de/avalax/fitbuddy/domain/model/exercise/Exercise.java

@@ -24,8 +24,7 @@ public interface Exercise extends Serializable {
 
     void setName(String name);
 
-    @Deprecated
-    void addSet(Set set);
+    Set createSet();
 
     void removeSet(Set set);
 }

src/main/java/de/avalax/fitbuddy/port/adapter/service/JsonInWorkoutAdapter.java

@@ -2,7 +2,6 @@
 
 import com.google.gson.Gson;
 import de.avalax.fitbuddy.domain.model.exercise.Exercise;
-import de.avalax.fitbuddy.domain.model.set.BasicSet;
 import de.avalax.fitbuddy.domain.model.set.Set;
 import de.avalax.fitbuddy.domain.model.workout.BasicWorkout;
 import de.avalax.fitbuddy.domain.model.workout.Workout;
@@ -32,10 +31,9 @@ public Workout createFromJson(String contents) throws WorkoutParseException {
                 for (ArrayList jsonSet : jsonSets) {
                     double weight = (double) jsonSet.get(1);
                     int maxReps = (int) ((double) jsonSet.get(0));
-                    Set set = new BasicSet();
+                    Set set = exercise.createSet();
                     set.setWeight(weight);
                     set.setMaxReps(maxReps);
-                    exercise.addSet(set);
                 }
             }
 

src/main/java/de/avalax/fitbuddy/presentation/edit/exercise/EditExerciseActivity.java

@@ -9,7 +9,6 @@
 import butterknife.ButterKnife;
 import de.avalax.fitbuddy.application.edit.workout.ManageWorkout;
 import de.avalax.fitbuddy.domain.model.exercise.Exercise;
-import de.avalax.fitbuddy.domain.model.set.BasicSet;
 import de.avalax.fitbuddy.domain.model.set.Set;
 import de.avalax.fitbuddy.domain.model.set.SetNotAvailableException;
 import de.avalax.fitbuddy.presentation.FitbuddyApplication;
@@ -20,8 +19,6 @@
 import de.avalax.fitbuddy.presentation.dialog.EditWeightDialogFragment;
 
 import javax.inject.Inject;
-import java.util.ArrayList;
-import java.util.List;
 
 public class EditExerciseActivity extends FragmentActivity implements EditWeightDialogFragment.DialogListener, EditSetsDialogFragment.DialogListener, EditRepsDialogFragment.DialogListener, EditNameDialogFragment.DialogListener {
 
@@ -103,15 +100,7 @@ public void onDialogPositiveClick(EditSetsDialogFragment editSetsDialogFragment)
         } catch (SetNotAvailableException e) {
             Log.d("can't get first set", e.getMessage(), e);
         }
-        //TODO: update sets, instead of replacing them
-        List<Set> sets = new ArrayList<>();
-        for (int i = 0; i < newSetAmount; i++) {
-            Set set = new BasicSet();
-            set.setWeight(weight);
-            set.setMaxReps(maxReps);
-            sets.add(set);
-        }
-        manageWorkout.replaceSets(exercise, sets);
+        manageWorkout.changeSetAmount(exercise, newSetAmount);
         editExerciseDialogFragment.init();
     }
 

src/test/java/de/avalax/fitbuddy/application/edit/workout/ManageWorkoutTest.java

@@ -14,7 +14,6 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.InOrder;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
@@ -255,25 +254,47 @@ public void undoDeleteWorkoutAfterDeleteAnExercise_shouldReinsertTheWorkout() th
             }
 
             @Test
-            public void replaceSets_shouldDeleteOldSetsAndSaveNewSets() throws Exception {
+            public void changeSetAmountWithoutSets_shouldAddOneSet() throws Exception {
                 ExerciseId exerciseId = new ExerciseId("21");
                 Exercise exercise = new BasicExercise();
                 exercise.setExerciseId(exerciseId);
-                SetId setIdToDelete = new SetId("42");
-                Set setToDelete = mock(Set.class);
-                when(setToDelete.getSetId()).thenReturn(setIdToDelete);
-                exercise.addSet(setToDelete);
-                List<Set> setsToAdd = new ArrayList<>();
-                Set setToAdd = mock(Set.class);
-                setsToAdd.add(setToAdd);
-
-                manageWorkout.replaceSets(exercise, setsToAdd);
-
-                InOrder inOrder = inOrder(setRepository);
-                inOrder.verify(setRepository).delete(setIdToDelete);
-                inOrder.verify(setRepository).save(exerciseId, setToAdd);
-                assertThat(exercise.countOfSets(), equalTo(1));
-                assertThat(exercise.setAtPosition(0), equalTo(setToAdd));
+
+                manageWorkout.changeSetAmount(exercise, 1);
+
+                verify(setRepository).save(exerciseId, exercise.setAtPosition(0));
+            }
+
+            @Test
+            public void changeSetAmountToOne_shouldRemoveOneSet() throws Exception {
+                ExerciseId exerciseId = new ExerciseId("21");
+                Exercise exercise = new BasicExercise();
+                exercise.setExerciseId(exerciseId);
+                Set set1 = exercise.createSet();
+                set1.setSetId(new SetId("42"));
+                Set set2 = exercise.createSet();
+
+                manageWorkout.changeSetAmount(exercise, 1);
+
+                assertThat(exercise.setAtPosition(0), equalTo(set2));
+                verify(setRepository).delete(set1.getSetId());
+            }
+
+            @Test
+            public void changeSetAmountWithOneSet_shouldAddASecondEqualSet() throws Exception {
+                ExerciseId exerciseId = new ExerciseId("21");
+                Exercise exercise = new BasicExercise();
+                exercise.setExerciseId(exerciseId);
+                Set set = exercise.createSet();
+                set.setMaxReps(12);
+                set.setWeight(42.0);
+
+                manageWorkout.changeSetAmount(exercise, 2);
+
+                Set newSet = exercise.setAtPosition(1);
+
+                assertThat(newSet.getMaxReps(), equalTo(12));
+                assertThat(newSet.getWeight(), equalTo(42.0));
+                verify(setRepository).save(exerciseId, newSet);
             }
         }
     }

src/test/java/de/avalax/fitbuddy/domain/model/exercise/BasicExerciseTest.java

@@ -12,8 +12,6 @@
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.IsEqual.equalTo;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
 @RunWith(HierarchicalContextRunner.class)
 public class BasicExerciseTest {
@@ -122,28 +120,23 @@ public void countOfSets_shouldReturnZeroOnConstruction() throws Exception {
 
         @Test
         public void addSet_shouldAddSetToExercise() throws Exception {
-            Set set = mock(Set.class);
-
-            exercise.addSet(set);
+            Set set = exercise.createSet();
 
             assertThat(exercise.setAtPosition(0), equalTo(set));
         }
 
         @Test
         public void removeSet_shouldRemoveSetFromExercise() throws Exception {
-            Set set = mock(Set.class);
+            Set set = exercise.createSet();
 
-            exercise.addSet(set);
             exercise.removeSet(set);
             assertThat(exercise.countOfSets(), equalTo(0));
         }
 
         @Test
         public void setAtPosition_shouldReturnSecondSet() throws Exception {
-            Set set = mock(Set.class);
-
-            exercise.addSet(mock(Set.class));
-            exercise.addSet(set);
+            exercise.createSet();
+            Set set = exercise.createSet();
 
             Set setAtPosition = exercise.setAtPosition(1);
 
@@ -157,7 +150,7 @@ public void setCurrentSetWithoutSets_shouldDoNothing() throws Exception {
 
         @Test
         public void setSetNumber_shouldSetSetNumberToZero() throws Exception {
-            exercise.addSet(mock(Set.class));
+            exercise.createSet();
 
             exercise.setCurrentSet(-1);
 
@@ -166,8 +159,7 @@ public void setSetNumber_shouldSetSetNumberToZero() throws Exception {
 
         @Test
         public void setCurrentSet_ShouldSetToLastSetWhenSizeExceeded() throws Exception {
-            Set set = mock(Set.class);
-            exercise.addSet(set);
+            exercise.createSet();
 
             exercise.setCurrentSet(exercise.countOfSets() + 1);
 
@@ -187,63 +179,58 @@ public void withoutSets_shouldHaveZeroProgress() throws Exception {
 
             @Test
             public void oneSetWithoutReps_shouldHaveZeroProgress() throws Exception {
-                Set set = mock(Set.class);
-                when(set.getMaxReps()).thenReturn(100);
-                when(set.getReps()).thenReturn(0);
-                exercise.addSet(set);
+                Set set = exercise.createSet();
+                set.setMaxReps(100);
+                set.setReps(0);
+
                 assertThat(exercise.getProgress(), equalTo(0.0));
             }
 
             @Test
             public void oneSetWithMaxReps_shouldHaveFullProgress() throws Exception {
-                Set set = mock(Set.class);
-                when(set.getMaxReps()).thenReturn(100);
-                when(set.getReps()).thenReturn(100);
-                exercise.addSet(set);
+                Set set = exercise.createSet();
+                set.setMaxReps(100);
+                set.setReps(100);
                 assertThat(exercise.getProgress(), equalTo(1.0));
             }
 
             @Test
             public void oneSetWithHalfReps_shouldHaveHalfProgress() throws Exception {
-                Set set = mock(Set.class);
-                when(set.getMaxReps()).thenReturn(100);
-                when(set.getReps()).thenReturn(50);
-                exercise.addSet(set);
+                Set set = exercise.createSet();
+                set.setMaxReps(100);
+                set.setReps(50);
                 assertThat(exercise.getProgress(), equalTo(0.5));
             }
 
             @Test
             public void twoSetsWithoutReps_shouldHaveHalfProgress() throws Exception {
-                exercise.addSet(mock(Set.class));
-                Set set = mock(Set.class);
-                when(set.getMaxReps()).thenReturn(100);
-                when(set.getReps()).thenReturn(0);
-                exercise.addSet(set);
+                exercise.createSet();
+                Set set = exercise.createSet();
+                set.setMaxReps(100);
+                set.setReps(0);
                 exercise.setCurrentSet(1);
                 assertThat(exercise.getProgress(), equalTo(0.5));
             }
 
             @Test
             public void twoSetsWithMaxReps_shouldHaveFallProgress() throws Exception {
-                exercise.addSet(mock(Set.class));
-                Set set = mock(Set.class);
-                when(set.getMaxReps()).thenReturn(100);
-                when(set.getReps()).thenReturn(100);
-                exercise.addSet(set);
+                exercise.createSet();
+                Set set = exercise.createSet();
+                set.setMaxReps(100);
+                set.setReps(100);
                 exercise.setCurrentSet(1);
                 assertThat(exercise.getProgress(), equalTo(1.0));
             }
 
             @Test
             public void twoSetsWithHalfReps_shouldHave75Progress() throws Exception {
-                exercise.addSet(mock(Set.class));
-                Set set = mock(Set.class);
-                when(set.getMaxReps()).thenReturn(100);
-                when(set.getReps()).thenReturn(50);
-                exercise.addSet(set);
+                exercise.createSet();
+                Set set = exercise.createSet();
+                set.setMaxReps(100);
+                set.setReps(50);
                 exercise.setCurrentSet(1);
                 assertThat(exercise.getProgress(), equalTo(0.75));
             }
         }
     }
-}
+}

src/test/java/de/avalax/fitbuddy/domain/model/workout/BasicWorkoutTest.java

@@ -4,7 +4,6 @@
 import de.avalax.fitbuddy.domain.model.exercise.BasicExercise;
 import de.avalax.fitbuddy.domain.model.exercise.Exercise;
 import de.avalax.fitbuddy.domain.model.exercise.ExerciseId;
-import de.avalax.fitbuddy.domain.model.set.BasicSet;
 import de.avalax.fitbuddy.domain.model.set.Set;
 import de.bechte.junit.runners.context.HierarchicalContextRunner;
 import org.junit.Before;
@@ -234,10 +233,9 @@ public void getProgress_shouldReturnZeroProgress() throws Exception {
             public void getProgress_shouldReturnFullProgress() throws Exception {
                 workout.createExercise();
                 Exercise exercise = workout.createExercise();
-                Set set = new BasicSet();
+                Set set = exercise.createSet();
                 set.setMaxReps(1);
                 set.setReps(1);
-                exercise.addSet(set);
 
                 assertThat(workout.getProgress(1), equalTo(1.0));
             }
@@ -246,10 +244,9 @@ public void getProgress_shouldReturnFullProgress() throws Exception {
             public void getProgress_shouldReturn1point5() throws Exception {
                 workout.createExercise();
                 Exercise exercise = workout.createExercise();
-                Set set = new BasicSet();
+                Set set = exercise.createSet();
                 set.setMaxReps(2);
                 set.setReps(1);
-                exercise.addSet(set);
 
                 assertThat(workout.getProgress(1), equalTo(0.75));
             }