apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 50700

releaseNotes:
- |

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>lifecycle-participant-reactor-dependency-injection</groupId>
  <artifactId>parent</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>

  <modules>
    <module>module-a</module>
    <module>module-b</module>
  </modules>

apiVersion: release-notes/v2
kind: feature
area: installation
issue:
  - 51506
releaseNotes:
- |

deploy:
  kubectl:
    hooks:
      before:
        - host:
            command: ["sh", "-c", "kubectl label namespace default istio-injection=enabled --overwrite"]
            os: [darwin, linux]
        - host:
            command: ["cmd.exe", "/C", "kubectl label namespace default istio-injection=enabled --overwrite"]
            os: [windows]
    manifests:
      - "../../../samples/bookinfo/platform/kube/bookinfo.yaml"

                        }

                        withModule('org:parent') { ComponentSelection selection ->
                            logger.warn("rejecting parent")
                            selection.reject("Rejecting parent")
                        }
                    }
                }
            }

            dependencies {
                conf "org:child:1.0"
            }

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

/**
 * <a href="https://guava.dev/EventBus">Discouraged</a> in favor of dependency injection and
 * concurrency frameworks, EventBus allows publish-subscribe-style communication.
 *
 * <p>See the Guava User Guide article on <a
 * href="https://github.com/google/guava/wiki/EventBusExplained">{@code EventBus}</a>.
 */

import (
	"testing"

	fuzz "github.com/AdaLogics/go-fuzz-headers"
)

func FuzzRunTemplate(f *testing.F) {
	f.Fuzz(func(t *testing.T, data []byte, v string) {
		ff := fuzz.NewConsumer(data)

		// create injection parameters
		IP := InjectionParameters{}
		err := ff.GenerateStruct(&IP)
		if err != nil {
			return
		}
		if IP.pod == nil {
			return
		}
		vc, err := NewValuesConfig(v)
		if err != nil {
			return

				if injectionWhConf.Service == nil {
					t.Fatalf("expected injection service %s, got nil", tc.whSVC)
				}
				if injectionWhConf.Service.Name != tc.whSVC {
					t.Fatalf("expected injection service %s, got %s", tc.whSVC, injectionWhConf.Service.Name)
				}
			}
			if tc.whURL != "" {
				if injectionWhConf.URL == nil {
					t.Fatalf("expected injection URL %s, got nil", tc.whURL)
				}

    }

    def "injects service using getter injection"() {
        given:
        services.add(String, "string")

        when:
        def result = instantiator.newInstance(HasGetterInjection)

        then:
        result.someService == 'string'
    }

    def "injects service using abstract getter injection"() {
        given:
        services.add(String, "string")

        when:

```
class MyTest {
  private final MockWebServer server;

  MyTest(MockWebServer server) {
    this.server = server;
  }

  @Test
  void test() {
    ...
  }
}
```

Constructor injection is particularly concise in Kotlin:

```
class MyTest(
  private val server: MockWebServer
) {
  @Test
  fun test() {
    ...
  }
}
```