Improve displaying of circular dependency error

inject-groovy/src/test/groovy/io/micronaut/inject/failures/ConstructorCircularDependencyFailureSpec.groovy

@@ -31,36 +31,66 @@ class ConstructorCircularDependencyFailureSpec extends Specification {
         ApplicationContext context = ApplicationContext.run()
 
         when:"A bean is obtained that has a setter with @Inject"
-        B b =  context.getBean(B)
+        MyClassB b =  context.getBean(MyClassB)
 
         then:"The implementation is injected"
         def e = thrown(CircularDependencyException)
         e.message.normalize() == '''\
-Failed to inject value for field [a] of class: io.micronaut.inject.failures.ConstructorCircularDependencyFailureSpec$B
+Failed to inject value for field [propA] of class: io.micronaut.inject.failures.ConstructorCircularDependencyFailureSpec$MyClassB
 
 Message: Circular dependency detected
-Path Taken: 
-new B() --> B.a --> new A([C c]) --> new C([B b])
-^                                              |
-|                                              |
-|                                              |
-+----------------------------------------------+'''
+Path Taken:
+new MyClassB()
+      \\---> MyClassB.propA
+            ^  \\---> new MyClassA([MyClassC propC])
+            |        \\---> new MyClassC([MyClassB propB])
+            |              |
+            +--------------+'''
 
         cleanup:
         context.close()
     }
 
-    static class C {
-        @Inject C( B b ) {}
+    void "test another constructor circular dependency failure"() {
+        given:
+        ApplicationContext context = ApplicationContext.run(["spec.name": getClass().simpleName])
+
+        when:"A bean is obtained that has a setter with @Inject"
+        context.getBean(MyClassD)
+
+        then:"The implementation is injected"
+        def e = thrown(CircularDependencyException)
+        e.message.normalize() == '''\
+Failed to inject value for field [propA] of class: io.micronaut.inject.failures.ConstructorCircularDependencyFailureSpec$MyClassB
+
+Message: Circular dependency detected
+Path Taken:
+new MyClassD(MyClassB propB)
+      \\---> new MyClassD([MyClassB propB])
+            \\---> MyClassB.propA
+                  ^  \\---> new MyClassA([MyClassC propC])
+                  |        \\---> new MyClassC([MyClassB propB])
+                  |              |
+                  +--------------+'''
+    }
+
+    static class MyClassC {
+        @Inject
+        MyClassC(MyClassB propB) {}
     }
     @Singleton
-    static class A {
-        A(C c) {}
+    static class MyClassA {
+        MyClassA(MyClassC propC) {}
+    }
+
+    @Singleton
+    static class MyClassB {
+        @Inject protected MyClassA propA
     }
 
     @Singleton
-    static class B {
-        @Inject protected A a
+    static class MyClassD {
+        MyClassD(MyClassB propB) {}
     }
 }
 

inject-groovy/src/test/groovy/io/micronaut/inject/failures/FactoryCircularDependencyFailureSpec.groovy

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2017-2019 original 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
+ *
+ * http://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 io.micronaut.inject.failures
+
+import io.micronaut.context.ApplicationContext
+import io.micronaut.context.annotation.Factory
+import io.micronaut.context.exceptions.CircularDependencyException
+import spock.lang.Specification
+
+import javax.inject.Inject
+import javax.inject.Singleton
+
+
+class FactoryCircularDependencyFailureSpec extends Specification {
+
+    void "test circular dependency with factory failure"() {
+        given:
+        ApplicationContext context = ApplicationContext.run()
+
+        when:"A bean is obtained that has a setter with @Inject"
+        context.getBean(ElectricalGrid)
+
+        then:"The implementation is injected"
+        def e = thrown(CircularDependencyException)
+        e.message.normalize() == '''\
+Failed to inject value for parameter [stations] of class: io.micronaut.inject.failures.FactoryCircularDependencyFailureSpec$ElectricalGrid
+
+Message: Circular dependency detected
+Path Taken:
+new ElectricalGrid(List<ElectricStation E> stations)
+      \\---> new ElectricalGrid([List<ElectricStation E> stations])
+            ^  \\---> ElectricStationFactory.nuclearStation([MeasuringEquipment equipment])
+            |        \\---> MeasuringEquipment.grid
+            |              |
+            +--------------+'''
+
+        cleanup:
+        context.close()
+    }
+
+    static class ElectricalGrid {
+        @Inject
+        ElectricalGrid(List<ElectricStation> stations) {}
+    }
+
+    static class ElectricStation {
+        ElectricStation() {}
+    }
+
+    @Factory
+    static class ElectricStationFactory {
+
+        @Singleton
+        ElectricStation solarStation() {
+            return new ElectricStation()
+        }
+
+        @Singleton
+        ElectricStation nuclearStation(MeasuringEquipment equipment) {
+            return new ElectricStation()
+        }
+
+    }
+
+    @Singleton
+    static class MeasuringEquipment {
+        @Inject protected ElectricalGrid grid
+    }
+}
+

inject-groovy/src/test/groovy/io/micronaut/inject/failures/FieldCircularDependencyFailureSpec.groovy

@@ -39,12 +39,13 @@ class FieldCircularDependencyFailureSpec extends Specification {
 Failed to inject value for field [a] of class: io.micronaut.inject.failures.FieldCircularDependencyFailureSpec$B
 
 Message: Circular dependency detected
-Path Taken: 
-new B() --> B.a --> new A([C c]) --> C.b
-^                                     |
-|                                     |
-|                                     |
-+-------------------------------------+'''
+Path Taken:
+new B()
+      \\---> B.a
+            ^  \\---> new A([C c])
+            |        \\---> C.b
+            |              |
+            +--------------+'''
         cleanup:
         context.close()
     }

inject-groovy/src/test/groovy/io/micronaut/inject/failures/PropertyCircularDependencyFailureSpec.groovy

@@ -34,16 +34,17 @@ class PropertyCircularDependencyFailureSpec extends Specification {
 
         then:"The implementation is injected"
         CircularDependencyException e = thrown()
-        def lines = e.message.lines().toList()
-        lines[0] == 'Failed to inject value for parameter [a] of method [setA] of class: io.micronaut.inject.failures.PropertyCircularDependencyFailureSpec$B'
-        lines[1] == ''
-        lines[2] == 'Message: Circular dependency detected'
-        lines[3] == 'Path Taken: '
-        lines[4] == 'new B() --> B.setA([A a]) --> A.setB([B b])'
-        lines[5] == '^                                        |'
-        lines[6] == '|                                        |'
-        lines[7] == '|                                        |'
-        lines[8] == '+----------------------------------------+'
+        e.message == '''\
+Failed to inject value for parameter [a] of method [setA] of class: io.micronaut.inject.failures.PropertyCircularDependencyFailureSpec$B
+
+Message: Circular dependency detected
+Path Taken:
+new B()
+      \\---> B.setA([A a])
+            ^  \\---> A.setB([B b])
+            |        |
+            +--------+'''
+
         cleanup:
         context.close()
     }

inject-java/src/test/groovy/io/micronaut/inject/failures/ctorcirculardependency/ConstructorCircularDependencyFailureSpec.groovy

@@ -16,35 +16,54 @@
 package io.micronaut.inject.failures.ctorcirculardependency
 
 import io.micronaut.context.ApplicationContext
-import io.micronaut.context.BeanContext
-import io.micronaut.context.DefaultBeanContext
-import io.micronaut.context.annotation.Property
 import io.micronaut.context.exceptions.CircularDependencyException
 import spock.lang.Specification
 
-import jakarta.inject.Singleton
-
 class ConstructorCircularDependencyFailureSpec extends Specification {
 
     void "test simple constructor circular dependency failure"() {
         given:
         ApplicationContext context = ApplicationContext.run(["spec.name": getClass().simpleName])
 
         when:"A bean is obtained that has a setter with @Inject"
-        B b =  context.getBean(B)
+        context.getBean(MyClassB)
+
+        then:"The implementation is injected"
+        def e = thrown(CircularDependencyException)
+        e.message.normalize() == '''\
+Failed to inject value for field [propA] of class: io.micronaut.inject.failures.ctorcirculardependency.MyClassB
+
+Message: Circular dependency detected
+Path Taken:
+new MyClassB()
+      \\---> MyClassB.propA
+            ^  \\---> new MyClassA([MyClassC propC])
+            |        \\---> new MyClassC([MyClassB propB])
+            |              |
+            +--------------+'''
+    }
+
+    void "test another constructor circular dependency failure"() {
+        given:
+        ApplicationContext context = ApplicationContext.run(["spec.name": getClass().simpleName])
+
+        when:"A bean is obtained that has a setter with @Inject"
+        context.getBean(MyClassD)
 
         then:"The implementation is injected"
         def e = thrown(CircularDependencyException)
         e.message.normalize() == '''\
-Failed to inject value for field [a] of class: io.micronaut.inject.failures.ctorcirculardependency.B
+Failed to inject value for field [propA] of class: io.micronaut.inject.failures.ctorcirculardependency.MyClassB
 
 Message: Circular dependency detected
-Path Taken: 
-new B() --> B.a --> new A([C c]) --> new C([B b])
-^                                              |
-|                                              |
-|                                              |
-+----------------------------------------------+'''
+Path Taken:
+new MyClassD(MyClassB propB)
+      \\---> new MyClassD([MyClassB propB])
+            \\---> MyClassB.propA
+                  ^  \\---> new MyClassA([MyClassC propC])
+                  |        \\---> new MyClassC([MyClassB propB])
+                  |              |
+                  +--------------+'''
     }
 
     void "test multiple optionals do not cause a circular dependency exception"() {

inject-java/src/test/groovy/io/micronaut/inject/failures/ctorcirculardependency/A.java → inject-java/src/test/groovy/io/micronaut/inject/failures/ctorcirculardependency/MyClassA.java

@@ -21,6 +21,6 @@
 
 @Requires(property = "spec.name", value = "ConstructorCircularDependencyFailureSpec")
 @Singleton
-public class A {
-    public A(C c) {}
+public class MyClassA {
+    public MyClassA(MyClassC propC) {}
 }

inject-java/src/test/groovy/io/micronaut/inject/failures/ctorcirculardependency/B.java → inject-java/src/test/groovy/io/micronaut/inject/failures/ctorcirculardependency/MyClassB.java

@@ -22,7 +22,7 @@
 
 @Requires(property = "spec.name", value = "ConstructorCircularDependencyFailureSpec")
 @Singleton
-public class B {
+public class MyClassB {
     @Inject
-    protected A a;
+    protected MyClassA propA;
 }

inject-java/src/test/groovy/io/micronaut/inject/failures/ctorcirculardependency/C.java → inject-java/src/test/groovy/io/micronaut/inject/failures/ctorcirculardependency/MyClassC.java

@@ -17,7 +17,7 @@
 
 import jakarta.inject.Inject;
 
-public class C {
+public class MyClassC {
     @Inject
-    public C(B b ) {}
+    public MyClassC(MyClassB propB) {}
 }

inject-java/src/test/groovy/io/micronaut/inject/failures/ctorcirculardependency/MyClassD.java

@@ -0,0 +1,14 @@
+package io.micronaut.inject.failures.ctorcirculardependency;
+
+import io.micronaut.context.annotation.Requires;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+
+@Requires(property = "spec.name", value = "ConstructorCircularDependencyFailureSpec")
+@Singleton
+public class MyClassD {
+
+    @Inject
+    public MyClassD(MyClassB propB) {}
+
+}

inject-java/src/test/groovy/io/micronaut/inject/failures/fieldcirculardependency/FieldCircularDependencyFailureSpec.groovy

@@ -36,12 +36,13 @@ class FieldCircularDependencyFailureSpec extends Specification {
 Failed to inject value for field [a] of class: io.micronaut.inject.failures.fieldcirculardependency.B
 
 Message: Circular dependency detected
-Path Taken: 
-new B() --> B.a --> new A([C c]) --> C.b
-^                                     |
-|                                     |
-|                                     |
-+-------------------------------------+'''
+Path Taken:
+new B()
+      \\---> B.a
+            ^  \\---> new A([C c])
+            |        \\---> C.b
+            |              |
+            +--------------+'''
 
         cleanup:
         context.close()