286 product type attributes enum actions by jortizsao · Pull Request #295 · commercetools/commercetools-sync-java

jortizsao · 2018-07-30T22:17:03Z

Summary

This PR adds the attribute definition update actions for plain enum values and localized enum values

Description

AttributeDefinitionUpdateActionUtils
- Add PlainEnumValue to attribute definition update action
- Change order of PlainEnumValue update action
- Remove PlainEnumValues from attribute definition update action
- Change plain enum value label update action
- Add LocalizedEnumValue to attribute definition update action
- Change order of LocalizedEnumValue update action
- Remove LocalizedEnumValues from attribute definition update action
- Change localized enum value label update action

Todo

Tests
- Unit

* Add PlainEnumValue to attribute definition update action * Change order of PlainEnumValue update action * Remove PlainEnumValues from attribute definition update action * Change plain enum value label update action * Add LocalizedEnumValue to attribute definition update action * Change order of LocalizedEnumValue update action * Remove LocalizedEnumValues from attribute definition update action * Change localized enum value label update action

# Conflicts: # src/main/java/com/commercetools/sync/producttypes/utils/AttributeDefinitionUpdateActionUtils.java # src/main/java/com/commercetools/sync/producttypes/utils/ProductTypeUpdateActionUtils.java

codecov-io · 2018-07-30T22:42:40Z

Codecov Report

Merging #295 into master will increase coverage by 0.13%.
The diff coverage is 98.1%.

@@             Coverage Diff              @@
##             master     #295      +/-   ##
============================================
+ Coverage     95.15%   95.28%   +0.13%     
- Complexity      967     1011      +44     
============================================
  Files            88       94       +6     
  Lines          2415     2546     +131     
  Branches        120      123       +3     
============================================
+ Hits           2298     2426     +128     
- Misses           99      102       +3     
  Partials         18       18

Impacted Files	Coverage Δ	Complexity Δ
...cttypes/utils/LocalizedEnumUpdateActionsUtils.java	`100% <100%> (ø)`	`3 <3> (?)`
...ync/commons/exceptions/DifferentTypeException.java	`100% <100%> (ø)`	`3 <3> (?)`
...ils/ProductTypeUpdateLocalizedEnumActionUtils.java	`100% <100%> (ø)`	`4 <4> (?)`
...s/utils/ProductTypeUpdatePlainEnumActionUtils.java	`100% <100%> (ø)`	`4 <4> (?)`
...oductTypeUpdateAttributeDefinitionActionUtils.java	`100% <100%> (ø)`	`17 <1> (ø)`	⬇️
...roducttypes/utils/PlainEnumUpdateActionsUtils.java	`100% <100%> (ø)`	`3 <3> (?)`
...es/utils/AttributeDefinitionUpdateActionUtils.java	`100% <100%> (ø)`	`20 <10> (+9)`	⬆️
...oducttypes/utils/ProductTypeUpdateActionUtils.java	`100% <100%> (ø)`	`5 <0> (ø)`	⬇️
...types/utils/ProductTypeUpdateEnumActionsUtils.java	`93.75% <93.75%> (ø)`	`18 <18> (?)`
... and 5 more

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 3e18555...14ea923. Read the comment docs.

lojzatran

I cannot finish the review now because there are some other urgent tasks. So here's what I saw so far.

lojzatran · 2018-07-31T12:11:00Z

+
+import javax.annotation.Nonnull;
+
+public class DifferentTypeException extends RuntimeException {


Can you write a short comment when is this exception used?

lojzatran · 2018-07-31T12:22:23Z

+        throws DuplicateKeyException, DifferentTypeException {

-        return Stream
+        final List<UpdateAction<ProductType>> updateActions = Stream


This should be only inside if (haveSameAttributeType(oldAttributeDefinition, newAttributeDefinitionDraft)) {.

lojzatran · 2018-07-31T12:23:29Z

            .collect(toList());
+
+        if (haveSameAttributeType(oldAttributeDefinition, newAttributeDefinitionDraft)) {
+            if (isPlainEnumAttribute(oldAttributeDefinition)) {


Other attribute types will be done later?

Only PlainEnumValues and LocalizedEnum values because you can't apply update actions on the other attribute types according to the commercetools API: https://docs.commercetools.com/http-api-projects-productTypes.html

There's also update of isSearchable etc., but I understand now.

lojzatran · 2018-07-31T12:58:05Z

+     *
+     * @return true if both attribute definitions have the same attribute type, false otherwise.
+     */
+    private static final boolean haveSameAttributeType(


No need for final as method is private.

lojzatran · 2018-07-31T13:26:23Z

-     * @param oldAttributeDefinitions                       the old list of attribute definitions.
-     * @param newAttributeDefinitionsDrafts                 the new list of attribute definitions drafts.
-     *
+     * @param oldAttributeDefinitions       the old list of attribute definitions.


Maybe you should sync the formatting rules with @heshamMassoud so you don't have these formatting changes here.

I already did it :). That's why the changes on the format in this file. At the beginning I had the default formatting rules.

lojzatran · 2018-07-31T13:36:18Z

+            final List<UpdateAction<ProductType>> updateActions =
+                buildRemoveAttributeDefinitionOrAttributeDefinitionUpdateActions(
+                    oldAttributeDefinitions,
+                    removedAttributesDefinitionsNames,


This variable got me confused. It's not used afterwards at all. Can you check?

mmm... there is in line 118 and

updateActions.addAll( buildAddAttributeDefinitionUpdateActions( newAttributeDefinitionsDrafts, oldAttributesDefinitionsNameMap ) );

it is also used in line 125, by finally returning the updateActions in line 131:

Sorry I was not clear, this attribute is not used: removedAttributesDefinitionsNames

it's used in line 112 in

final List<UpdateAction<ProductType>> updateActions = buildRemoveAttributeDefinitionOrAttributeDefinitionUpdateActions( oldAttributeDefinitions, removedAttributesDefinitionsNames, newAttributesDefinitionsDraftsNameMap );

Yes, I see, but what do you do with it in the method? You have this in the method:

removedAttributeDefinitionNames.add(oldAttributeDefinitionName);

but then you don't use it anymore. So I still don't understand why do you need it.

You are right @lojzatran :)

Removed!

lojzatran · 2018-07-31T13:37:06Z

-        return updateActions;
+            return updateActions;
+
+        } catch (final DuplicateNameException dne) {


You can use } catch (final DuplicateNameException | DuplicateKeyException | DifferentTypeException dne) {

lojzatran

I added my second part of review. Now I reviewed everything.

lojzatran · 2018-08-01T09:24:22Z

+     *         Otherwise, if the enum values are identical, an empty optional is returned.
+     */
+    @Nonnull
+    public static <T extends WithKey> Optional<UpdateAction<ProductType>> buildRemoveEnumValuesUpdateActions(


What about this:

@Nonnull public static <T extends WithKey> Optional<UpdateAction<ProductType>> buildRemoveEnumValuesUpdateActions( @Nonnull final String attributeDefinitionName, @Nonnull final List<T> oldEnumValues, @Nullable final List<T> newEnumValues) { final Map<String, T> newEnumValuesKeyMap = getEnumValuesKeyMapWithKeyValidation( attributeDefinitionName, Optional.ofNullable(newEnumValues).orElse(Collections.emptyList()) ); final List<String> keysToRemove = oldEnumValues .stream() .map(WithKey::getKey) .filter(oldEnumValueKey -> !newEnumValuesKeyMap.containsKey(oldEnumValueKey)) .collect(Collectors.toList()); if (!keysToRemove.isEmpty()) { return of(RemoveEnumValues.of(attributeDefinitionName, keysToRemove)); } else { return empty(); } }

You don't have to do if/else because you will receive newEnumValuesKeyMap empty anyway. And return of(RemoveEnumValues.of(attributeDefinitionName, keysToRemove)); is better because it can never be null.

Better use specific type RemoveEnumValues instead of Optional<UpdateAction<ProductType>>?

Better use specific type RemoveEnumValues instead of Optional<UpdateAction>?

I can treat all update action as a more generic UpdateAction type, so then all update actions applied to the product type are the same and easier to manipulate in more abstract methods used at higher levels of the product type sync

lojzatran · 2018-08-01T09:27:11Z

+     *         Otherwise, if the enum values order is identical, an empty optional is returned.
+     */
+    @Nonnull
+    public static <T extends WithKey> Optional<UpdateAction<ProductType>> buildChangeEnumValuesOrderUpdateAction(


I don't see the order comparision in this method. I see only existence check. Can you clarify?

The array of new enum values drafts are either existing enum values or new enum values that are added and didn’t exist before.

The addition of new enum values are added at the end of the array (commercetools doesn’t allow to add a new enum value in a particular position of the array).

So concatenating the sorted keys of the existing enum values with the keys of the new ones, we would have the “natural” order if there wasn’t a change on the order.

Thus, if we compare this concatenated array containing the keys of the “natural” order against the array of keys of the enum values coming as a parameter, we can know that if the order is different it means that has been a change in the order.

Note: the method buildUpdateAction compares the first two parameters and returns the function applied to both if they are different

lojzatran · 2018-08-01T09:42:55Z

+        @Nonnull final List<T> newEnumValues,
+        @Nonnull final BiFunction<String, T, UpdateAction<ProductType>> addEnumCallback) {
+
+        final Map<String, T> oldEnumValuesKeyMap = getEnumValuesKeyMap(oldEnumValues);


Why not calling getEnumValuesKeyMapWithKeyValidation() also in this case?

lojzatran · 2018-08-01T09:50:54Z

+
+        return oldEnumValues
+            .stream()
+            .map(oldEnumValue ->


A bit more consistent with the previous method calls:

return oldEnumValues .stream() .filter(oldEnumValue -> newEnumValuesKeyMap.containsKey(oldEnumValue.getKey())) .map(oldEnumValue -> matchingEnumCallback.apply(attributeDefinitionName, oldEnumValue, newEnumValuesKeyMap.get(oldEnumValue.getKey()))) .flatMap(Collection::stream) .collect(Collectors.toList());

lojzatran · 2018-08-01T09:54:33Z

+        @Nonnull final String attributeDefinitionName,
+        @Nonnull final List<T> oldEnumValues,
+        @Nonnull final List<T> newEnumValues,
+        @Nonnull final BiFunction<String, T, UpdateAction<ProductType>> addEnumCallback) {


Better use specific type AddEnumValue instead of UpdateAction<ProductType>?

It has to be the parent class because the action can be AddEnumValue or AddLocalizedEnumValue depending on the addEnumCallback will return one or the other.

Another thing is that I can treat all update action as a more generic UpdateAction<ProductType> type, so then all update actions applied to the product type are the same and easier to manipulate in more abstract methods used at higher levels of the product type sync

lojzatran · 2018-08-01T09:54:46Z

+        @Nonnull final String attributeDefinitionName,
+        @Nonnull final List<T> oldEnumValues,
+        @Nonnull final List<T> newEnumValues,
+        @Nonnull final BiFunction<String, List<T>, UpdateAction<ProductType>> changeOrderEnumCallback) {


Better use specific type ChangeEnumValueOrder instead of UpdateAction<ProductType>?

It has to be the parent class because the action can be ChangeEnumValueOrder or ChangeLocalizedEnumValueOrder depending on the changeOrderEnumCallback will return one or the other

Another thing is that I can treat all update action as a more generic UpdateAction<ProductType> type, so then all update actions applied to the product type are the same and easier to manipulate in more abstract methods used at higher levels of the product type sync

lojzatran · 2018-08-01T10:05:59Z

+import static com.commercetools.sync.producttypes.utils.ProductTypeUpdateEnumActionsUtils.buildChangeEnumValuesOrderUpdateAction;
+import static java.util.Collections.emptyList;
+
+public final class ProductTypeUpdateLocalizedEnumActionUtils {


The code is almost identical with class ProductTypeUpdatePlainEnumActionUtils. What about creating a new abstract parent class for both of them and put the common methods there?

The ProductTypeUpdateLocalizedEnumActionUtils and ProductTypeUpdatePlainEnumActionUtils classes are similar in the buildUpdateAction method and someone could argue that I could also reuse the code in the ProductTypeUpdateEnumActionsUtils class, the same as it's done with other methods.

I did it that way first but the code ended up more tight and difficult to understand since all three particular methods for adding, removing and change order of the enums have to be passed as parameters in the common method placed at ProductTypeUpdateEnumActionsUtils, making this method to have 6 parameters where some of them are BiFunction, TriFunction... (long and "complex" signature)

So I finally decided to repeat some code in ProductTypeUpdateLocalizedEnumActionUtils and ProductTypeUpdateLocalizedEnumActionUtils in order to clarify and decouple the buildUpdateAction method of both classes.

lojzatran · 2018-08-01T12:47:29Z

    }
+
+    @Test
+    public void buildActions_WithNewDifferentValues_ShouldReturnAction() {


buildActions_WithNewDifferentValues_ShouldReturnAction -> buildActions_WithNewDifferentValues_ShouldReturnActions

heshamMassoud

Looks good but please check the comments @jortizsao :)

heshamMassoud · 2018-08-09T07:15:40Z

+        @Nonnull final String attributeDefinitionName,
+        @Nonnull final List<EnumValue> oldEnumValues,
+        @Nullable final List<EnumValue> newEnumValues)
+        throws DuplicateKeyException {


The throws DuplicateKeyException here is redundant since it's a runtime exception

heshamMassoud · 2018-08-09T07:16:12Z

-            .map(Optional::get)
-            .collect(toList());
+        @Nonnull final AttributeDefinitionDraft newAttributeDefinitionDraft)
+        throws DuplicateKeyException, DifferentTypeException {


The throws DuplicateKeyException here is redundant since it's a runtime exception

heshamMassoud · 2018-08-09T07:56:30Z

+                ));
+            }
+        } else {
+            throw new DifferentTypeException(format("The attribute type of the attribute definitions are different. "


when the attributeDefinitions with the same name but of different types we shouldn't just throw an exception but rather we should remove the old attributeDefinition and create a new one with the new type.

don't you think is more safer to throw an error, and if the user actually wants to change the type, he can follow a two step process of deleting the attribute in a first run and add the new one with the new type in a second run?

Removing is always dangerous but if you think that we should't notify the user and remove the attribute right away, it is ok :)

I've changed my mind :). let's help the user and avoid unnecessary steps ;)

heshamMassoud · 2018-08-09T07:58:40Z

+     *
+     * @return true if the attribute definition is a plain enum value, false otherwise.
+     */
+    private static boolean isPlainEnumAttribute(@Nonnull final AttributeDefinition attributeDefiniton) {


attributeDefiniton -> attributeDefinition in the variable name and in the javadoc.

heshamMassoud · 2018-08-09T07:58:46Z

+     *
+     * @return true if the attribute definition is a localized enum value, false otherwise.
+     */
+    private static boolean isLocalizedEnumAttribute(@Nonnull final AttributeDefinition attributeDefiniton) {


also here: attributeDefiniton -> attributeDefinition

heshamMassoud · 2018-08-09T08:12:05Z

+            .collect(Collectors.toList());
+
+        if (!keysToRemove.isEmpty()) {
+            return ofNullable(RemoveEnumValues.of(attributeDefinitionName, keysToRemove));


RemoveEnumValues.of(attributeDefinitionName, keysToRemove) can never be null, so we should use Optional#of instead of Optional#ofNullable.

Also instead of if else, you can use conditional operator like that:

return keysToRemove.isEmpty() ? of(RemoveEnumValues.of(attributeDefinitionName, keysToRemove)) : empty();

heshamMassoud · 2018-08-09T08:13:08Z

+
+        final Map<String, T> newEnumValuesKeyMap = getEnumValuesKeyMapWithKeyValidation(
+            attributeDefinitionName,
+            Optional.ofNullable(newEnumValues).orElse(Collections.emptyList())


I see down there you already are statically importing the Optional#ofNullable, so would be good if here too for consistent style

you could also statically import Collections#emptyList() ;)

heshamMassoud · 2018-08-09T08:13:59Z

+    @Nonnull
+    public static <T extends WithKey> Map<String, T> getEnumValuesKeyMapWithKeyValidation(
+        @Nonnull final String attributeDefinitionName,
+        @Nonnull final List<T> enumValues) throws DuplicateKeyException {


The throws DuplicateKeyException here is redundant since it's a runtime exception

heshamMassoud · 2018-08-09T08:26:01Z

+        @Nonnull final EnumValue oldEnumValue,
+        @Nonnull final EnumValue newEnumValue) {
+
+        return Stream


(just a question) don't you think it looks better this way:

return Stream.of(buildChangeLabelAction(attributeDefinitionName, oldEnumValue, newEnumValue)) .filter(Optional::isPresent) .map(Optional::get) .collect(toList());

heshamMassoud · 2018-08-09T08:46:15Z

+            )
+
+        ).collect(Collectors.toList());
+    }


This method looks exactly the same as ProductTypeUpdateLocalizedEnumActionUtils#buildActions. Why don't you make a generic implementation and reuse. Like this:

@Nonnull private static <T extends WithKey> List<UpdateAction<ProductType>> buildUpdateActions( @Nonnull final String attributeDefinitionName, @Nonnull final List<T> oldEnumValues, @Nonnull final List<T> newEnumValues, @Nonnull final TriFunction<String, T, T, List<UpdateAction<ProductType>>> matchingEnumActionBuilder, @Nonnull final BiFunction<String, T, UpdateAction<ProductType>> addEnumActionBuilder, @Nonnull final BiFunction<String, List<T>, UpdateAction<ProductType>> changeOrderActionBuilder){ final List<UpdateAction<ProductType>> removeEnumValuesUpdateActions = buildRemoveEnumValuesUpdateActions( attributeDefinitionName, oldEnumValues, newEnumValues) .map(Collections::singletonList) .orElse(emptyList()); final List<UpdateAction<ProductType>> matchingEnumValuesUpdateActions = buildMatchingEnumValuesUpdateActions(attributeDefinitionName, oldEnumValues, newEnumValues, matchingEnumActionBuilder); final List<UpdateAction<ProductType>> addEnumValuesUpdateActions = buildAddEnumValuesUpdateActions( attributeDefinitionName, oldEnumValues, newEnumValues, addEnumActionBuilder); final List<UpdateAction<ProductType>> changeEnumValuesOrderUpdateActions = buildChangeEnumValuesOrderUpdateAction(attributeDefinitionName, oldEnumValues, newEnumValues, changeOrderActionBuilder) .map(Collections::singletonList) .orElse(emptyList()); return Stream.concat( Stream.concat(removeEnumValuesUpdateActions.stream(), matchingEnumValuesUpdateActions.stream()), Stream.concat(addEnumValuesUpdateActions.stream(), changeEnumValuesOrderUpdateActions.stream())) .collect(Collectors.toList()); }

and then reuse it for both by doing:
for ProductTypeUpdatePlainEnumActionUtils

buildUpdateActions(attributeDefinitionName, oldEnumValues, newEnumValues, PlainEnumUpdateActionsUtils::buildActions, AddEnumValue::of, ChangeEnumValueOrder::of);

and for ProductTypeUpdateLocalizedEnumActionUtils:

buildUpdateActions(attributeDefinitionName, oldEnumValues, newEnumValues, LocalizedEnumUpdateActionsUtils::buildActions, AddLocalizedEnumValue::of, ChangeLocalizedEnumValueOrder::of);

@heshamMassoud I tried your way first and I explained the reason of "copying" to Lam. This is my previous comment

"The ProductTypeUpdateLocalizedEnumActionUtils and ProductTypeUpdatePlainEnumActionUtils classes are similar in the buildUpdateAction method and someone could argue that I could also reuse the code in the ProductTypeUpdateEnumActionsUtils class, the same as it's done with other methods.

I did it that way first but the code ended up more tight and difficult to understand since all three particular methods for adding, removing and change order of the enums have to be passed as parameters in the common method placed at ProductTypeUpdateEnumActionsUtils, making this method to have 6 parameters where some of them are BiFunction, TriFunction... (long and "complex" signature)

So I finally decided to repeat some code in ProductTypeUpdateLocalizedEnumActionUtils and ProductTypeUpdateLocalizedEnumActionUtils in order to clarify and decouple the buildUpdateAction method of both classes."

In my opinion, that function is too tight and coupled (it's ad-hoc).

First: Passing 6 parameters looks too many parameters for a function (it is a coupling indicator)
Second: It's going to be difficult to extend or modify in the future if a particular change only applies to one of the enum values (either plain or localized).
Third: In some cases is better to "copy" and explicitly show what's going on behind scenes rather than hide and add too much "magic"

What do you think? if you find your way more understandable for future maintainers, I change it :)

I think it's ok to keep them copied also, I agree with your arguments. It was just an indicator for reuse right away and taking advantage of generics when they look the same. So we don't have to have the exact same code twice. But your arguments are also valid enough, It's fine for now, since it's only going to be reused by only these two. From experience we had some generic methods which maybe had many params but were very helpful to use by any sync process implementation and saved a lot of time (and also the dev didn't need to know about how it's working inside), this was the custom update action builder util method - it was used easily by almost every sync process implementation for example latley in the price custom type sync.

We can leave it like this for now, and see what happens in the future, if we see that we are changing always in both the same things, then we can generify the method.

jortizsao added 4 commits July 26, 2018 18:34

#286 Merge branch 'master' into 286-product-type-attributes-enum-actions

07df3ae

# Conflicts: # src/main/java/com/commercetools/sync/producttypes/utils/AttributeDefinitionUpdateActionUtils.java # src/main/java/com/commercetools/sync/producttypes/utils/ProductTypeUpdateActionUtils.java

#286 Format code according to project style

aa01263

#286 Add unit tests to AttributeDefinitionUpdateActionUtils#buildActions

c548aaa

jortizsao requested review from heshamMassoud and lojzatran July 31, 2018 07:12

jortizsao changed the title ~~286 product type attributes enum actions b~~ 286 product type attributes enum actions Jul 31, 2018

lojzatran reviewed Aug 1, 2018

View reviewed changes

jortizsao added 4 commits August 1, 2018 09:16

#286 Add documentation to DifferentTypeException

094acab

#286 Fix issue with code review

938ec1c

#286 Remove final from private methods

29ce264

#286 Catch exception in a multiple OR condition

e15f64f

lojzatran suggested changes Aug 1, 2018

View reviewed changes

jortizsao added 4 commits August 5, 2018 21:20

#286 Refactor buildRemoveEnumValuesUpdateActions

c00d98f

#286 Call duplicate key validation when adding new enum values

c990d02

#286 Refactor buildMatchingEnumValuesUpdateActions

5e901ca

#286 Fix typo in test clause

9dca967

lojzatran approved these changes Aug 6, 2018

View reviewed changes

jortizsao added 2 commits August 7, 2018 17:53

#286 Remove useless removedAttributeDefinitionNames map

93763b9

#286 Fix checkstyle

14ea923

jortizsao merged commit 5e973a5 into master Aug 7, 2018

heshamMassoud reviewed Aug 9, 2018

View reviewed changes

heshamMassoud deleted the 286-product-type-attributes-enum-actions-b branch September 6, 2018 11:59


		import javax.annotation.Nonnull;

		public class DifferentTypeException extends RuntimeException {

Conversation

jortizsao commented Jul 30, 2018

Summary

Description

Todo

Uh oh!

codecov-io commented Jul 30, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

lojzatran left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jortizsao Aug 1, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

lojzatran left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

codecov-io commented Jul 30, 2018 •

edited

Loading

jortizsao Aug 1, 2018 •

edited

Loading

jortizsao Aug 6, 2018 •

edited

Loading

jortizsao Aug 6, 2018 •

edited

Loading