16 refactor tests

pom.xml

@@ -11,8 +11,8 @@
     <artifactId>graph-core</artifactId>
 
     <packaging>jar</packaging>
-    <version>2.0.9</version>
-    <name>Graph Core Next Generation</name>
+    <version>2.0.10-SNAPSHOT</version>
+    <name>Graph Core</name>
 
     <description>
         The Reactome Graph Project aims to model the Reactome knowledgebase into a interconnected graph. For more
@@ -111,6 +111,12 @@
             <artifactId>jackson-databind</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.voodoodyne.jackson.jsog</groupId>
+            <artifactId>jackson-jsog</artifactId>
+            <version>1.1.2</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -119,7 +125,7 @@
         <resources>
             <resource>
                 <directory>src/main/resources</directory>
-                <filtering>false</filtering>
+                <filtering>true</filtering>
             </resource>
         </resources>
 
@@ -249,6 +255,20 @@
                 <artifactId>maven-source-plugin</artifactId>
                 <version>${maven.source.version}</version>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <version>${maven.source.version}</version>
+                <executions>
+                    <execution>
+                        <id>attach-sources</id>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 

src/main/java/org/reactome/server/graph/aop/README.md

@@ -1,18 +1,18 @@
 <img src=https://cloud.githubusercontent.com/assets/6883670/22938783/bbef4474-f2d4-11e6-92a5-07c1a6964491.png width=220 height=100 />
 
-Aspect-Oriented Programming with Spring
+Aspect Oriented Programming with Spring
 ===
 
 :warning: Changes in this package have to be taken carefully, considering it is going to reflect in the whole application
 
 ### What is Aspect-Oriented Programming - AOP?
 
-Spring AOP framework is used to modularize cross-cutting concerns in aspects. Simply, it’s just an interceptor to intercept some processes, for example, when a method is executed, Spring AOP can hijack the executing method, and add extra functionality before or after the method execution. The most used feature is logging.
+Spring AOP framework is used to modularize cross-cutting concerns in aspects. Simply, t’s just an interceptor to intercept some processes, for example, when a method is execute, Spring AOP can hijack the executing method, and add extra functionality before or after the method execution. The most used feature is logging.
 However, in Reactome, we are taking benefit of this concept in order to implement our own Lazy-Loading mechanism. This functionality is also available in ORM frameworks, such as, Hibernate and to achieve this they are implementing AOP concepts. Sorting and Logging aspect are present as well.
 
-Complete information on Spring AOP you'll find [here](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html).
+Complete information of Spring AOP you'll find [here](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html).
 
-### What are the `@PointCut` in Reactome for LazyLoading?
+### What are the `@PointCut` in Reactome for LazyLoading ?
 
 ```java
 execution(public java.util.Collection<org.reactome.server.graph.domain.model.DatabaseObject+>+ org.reactome.server.graph.domain.model.*.get*(..))
@@ -24,7 +24,7 @@ execution(public org.reactome.server.graph.domain.model.DatabaseObject+ org.reac
 ```
 Intercepting ALL the getters in our Domain Model whose return type is `DatabaseObject` or `instance of`
 
-### How does it work?
+### How does it work ?
 
 Mainly, we are loading DEPTH{2} data from the graph without any relationship previously loaded, only identifiers. Once intercepted, the code checks whether the AOP is enabled and whether the object has been loaded previously. Substantially using Java Reflection, the code is capable to identify all the information regarding the method that has been intercepted, for instance, return type (`Collection` or `DatabaseObject`) and `@Relationship` which contains important information for querying against the Graph. Up to this point, the data have been retrieve and the code invokes the setter and proceed.
 
@@ -95,19 +95,19 @@ public LazyFetchAspect lazyFetchAspect() {
 </plugin>
 ```
 
-#### What is the flag `enableAOP`?
+#### What is the flag `enableAOP` ?
 
-The AOP is enabled by default, but in certain projects like [Content Service](https://github.com/reactome/content-service.git) where we respond a serialised JSON, the `@PointCut` will be invoked everywhere, every time, endless times. Thus, given the `Content Service` requirements, it makes sense that we disable this feature. However, we kept it enabled in the [Data Content](https://github.com/reactome/data-content).
+The AOP is enabled by default, but in certain projects like [Content Service](https://github.com/reactome/content-service.git) where we respond a serialised JSON, the `@PointCut` will be invoked every where, every time, endless times. Thus, given the requirements of the `Content Service` it makes sense that we disable this feature. However, in the [Data Content](https://github.com/reactome/data-content) we kept it enabled.
 
 
 =
 
-### SortingAspect?
+### SortingAspect ?
 
 Intercepting ALL the getters in our Domain Model whose return type is `Collection<? extends DatabaseObject>` and sorting the list based on the `displayName`.
 
 =
 
-### LoggingAspect?
+### LoggingAspect ?
 
-Logging everything at the service level. The package `service` is being intercepted to measure the execution time.
+Logging everything at the service level. The package `service` is being intercepted in order to measure the execution time.

src/main/java/org/reactome/server/graph/domain/annotations/StoichiometryView.java

@@ -0,0 +1,10 @@
+package org.reactome.server.graph.domain.annotations;
+
+public class StoichiometryView {
+
+    public interface Flatten { }
+
+    public interface Nested { }
+
+    public interface NestedAggregated extends Nested { }
+}

src/main/java/org/reactome/server/graph/domain/model/AbstractModifiedResidue.java

@@ -3,11 +3,12 @@
 import org.springframework.data.neo4j.core.schema.Node;
 import org.springframework.data.neo4j.core.schema.Relationship;
 
+
 @SuppressWarnings("unused")
 @Node
 public abstract class AbstractModifiedResidue extends DatabaseObject {
 
-    @Relationship(type = "referenceSequence")
+    @Relationship(type = Relationships.REFERENCE_SEQUENCE)
     private ReferenceSequence referenceSequence;
 
     public AbstractModifiedResidue() {}

src/main/java/org/reactome/server/graph/domain/model/BlackBoxEvent.java

@@ -19,7 +19,7 @@ public String getExplanation() {
 
     }
 
-    @Relationship(type = "templateEvent")
+    @Relationship(type = Relationships.TEMPLATE_EVENT)
     private Event templateEvent;
 
     public BlackBoxEvent() {}

src/main/java/org/reactome/server/graph/domain/model/Book.java

@@ -17,7 +17,7 @@ public class Book extends Publication {
     @ReactomeProperty
     private Integer year;
 
-    @Relationship(type = "publisher")
+    @Relationship(type = Relationships.PUBLISHER)
     private Affiliation publisher;
 
     public Book() {}

src/main/java/org/reactome/server/graph/domain/model/CandidateSet.java

@@ -1,50 +1,55 @@
 package org.reactome.server.graph.domain.model;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonView;
 import org.reactome.server.graph.domain.annotations.ReactomeSchemaIgnore;
+import org.reactome.server.graph.domain.annotations.StoichiometryView;
+import org.reactome.server.graph.domain.relationship.Has;
 import org.reactome.server.graph.domain.relationship.HasCandidate;
+import org.reactome.server.graph.domain.relationship.CompositionAggregator;
 import org.springframework.data.neo4j.core.schema.Node;
 import org.springframework.data.neo4j.core.schema.Relationship;
 
 import java.util.*;
+import java.util.stream.Stream;
 
 /**
  * A set of entities that are interchangeable in function, with two subclasses, members that are hypothetical and members that have been demonstrated. Hypothetical members are identified as values of the hasCandidate slot. Members that have been demonstrated are identified in the hasMember slot. At least one hasCandidate value is required; hasMember values are optional.
  */
 @SuppressWarnings("unused")
 @Node
-public class CandidateSet extends EntitySet {
+public class CandidateSet extends EntitySet implements CompositionAggregator {
 
-    @Relationship(type = "hasCandidate")
+    @Relationship(type = Relationships.HAS_CANDIDATE)
     private SortedSet<HasCandidate> hasCandidate;
 
-    public CandidateSet() {}
+    @Override
+    public Stream<? extends Collection<? extends Has<? extends DatabaseObject>>> defineCompositionRelations() {
+        return Stream.concat(super.defineCompositionRelations(), Stream.of(hasCandidate));
+    }
+
+    public CandidateSet() {
+    }
+
+    @ReactomeSchemaIgnore
+    @JsonView(StoichiometryView.Nested.class)
+    public SortedSet<HasCandidate> getCandidates() {
+        return hasCandidate;
+    }
+
+    @JsonView(StoichiometryView.Nested.class)
+    public void setCandidates(SortedSet<HasCandidate> hasCandidate) {
+        this.hasCandidate = hasCandidate;
+    }
 
+    @JsonView(StoichiometryView.Flatten.class)
     public List<PhysicalEntity> getHasCandidate() {
-        List<PhysicalEntity> rtn = null;
-        if (hasCandidate != null) {
-            rtn = new ArrayList<>();
-            //stoichiometry does NOT need to be taken into account here
-            for (HasCandidate candidate : hasCandidate) {
-                rtn.add(candidate.getPhysicalEntity());
-            }
-        }
-        return rtn;
+        return Has.Util.expandStoichiometry(this.hasCandidate);
     }
 
+    @JsonView(StoichiometryView.Flatten.class)
     public void setHasCandidate(List<PhysicalEntity> hasCandidate) {
-        if (hasCandidate == null) return;
-        Map<Long, HasCandidate> components = new LinkedHashMap<>();
-        int order = 0;
-        for (PhysicalEntity physicalEntity : hasCandidate) {
-            //stoichiometry does NOT need to be taken into account here
-            HasCandidate aux = new HasCandidate();
-//            aux.setEntitySet(this);
-            aux.setPhysicalEntity(physicalEntity);
-            aux.setOrder(order++);
-            components.put(physicalEntity.getDbId(), aux);
-        }
-        this.hasCandidate = new TreeSet<>(components.values());
+        this.hasCandidate = Has.Util.aggregateStoichiometry(hasCandidate, HasCandidate::new);
     }
 
     @ReactomeSchemaIgnore

src/main/java/org/reactome/server/graph/domain/model/CatalystActivity.java

@@ -15,24 +15,24 @@
 @Node
 public class CatalystActivity extends DatabaseObject  {
 
-    @Relationship(type = "activeUnit")
+    @Relationship(type = Relationships.ACTIVE_UNIT)
     private Set<PhysicalEntity> activeUnit;
 
-    @Relationship(type = "activity")
+    @Relationship(type = Relationships.ACTIVITY)
     private GO_MolecularFunction activity;
 
     /**
      * catalyzedEvent is not a field of the previous RestfulApi and will be ignored until needed
      */
     @JsonIgnore
     @ReactomeTransient
-    @Relationship(type = "catalystActivity", direction = Relationship.Direction.INCOMING)
+    @Relationship(type = Relationships.CATALYST_ACTIVITY, direction = Relationship.Direction.INCOMING)
     private List<ReactionLikeEvent> catalyzedEvent;
 
-    @Relationship(type = "physicalEntity")
+    @Relationship(type =  Relationships.PHYSICAL_ENTITY)
     private PhysicalEntity physicalEntity;
 
-    @Relationship(type = "literatureReference")
+    @Relationship(type = Relationships.LITERATURE_REFERENCE)
     private List<Publication> literatureReference;
 
     public CatalystActivity() {}

src/main/java/org/reactome/server/graph/domain/model/Cell.java

@@ -1,34 +1,47 @@
 package org.reactome.server.graph.domain.model;
 
 import com.fasterxml.jackson.annotation.JsonGetter;
+import org.reactome.server.graph.domain.relationship.CompositionAggregator;
+import org.reactome.server.graph.domain.relationship.Has;
 import org.springframework.data.neo4j.core.schema.Node;
 import org.springframework.data.neo4j.core.schema.Relationship;
 
+import java.util.Collection;
 import java.util.List;
+import java.util.Objects;
+import java.util.stream.Stream;
 
 @Node
-public class Cell extends PhysicalEntity {
-    @Relationship(type = "RNAMarker")
+public class Cell extends PhysicalEntity implements CompositionAggregator {
+    @Relationship(type = Relationships.RNA_MARKER)
     private List<EntityWithAccessionedSequence> RNAMarker;
 
-    @Relationship(type = "markerReference")
+    @Relationship(type = Relationships.MARKER_REFERENCE)
     private List<MarkerReference> markerReference;
 
-    @Relationship(type = "organ")
+    @Relationship(type = Relationships.ORGAN)
     private Anatomy organ;
 
-    @Relationship(type = "proteinMarker")
+    @Relationship(type = Relationships.PROTEIN_MARKER)
     private List<EntityWithAccessionedSequence> proteinMarker;
 
-    @Relationship(type = "species")
+    @Relationship(type = Relationships.SPECIES)
     private List<Taxon> species;
 
-    @Relationship(type = "tissue")
+    @Relationship(type = Relationships.TISSUE)
     private Anatomy tissue;
 
-    @Relationship(type = "tissueLayer")
+    @Relationship(type = Relationships.TISSUE_LAYER)
     private Anatomy tissueLayer;
 
+    @Override
+    public Stream<? extends Collection<? extends Has<? extends DatabaseObject>>> defineCompositionRelations() {
+        return Stream.of(
+                Has.Util.wrapUniqueElements(RNAMarker, "rnaMarker"),
+                Has.Util.wrapUniqueElements(proteinMarker, "proteinMarker")
+        );
+    }
+
     public Cell() {
 
     }