// Copyright (c) 2019-2021 Uber Technologies, Inc.

//

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to deal

// in the Software without restriction, including without limitation the rights

// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

package fx_test

import (

"bytes"

"context"

"errors"

"fmt"

"io"

"strconv"

"strings"

"testing"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

"go.uber.org/atomic"

"go.uber.org/fx"

"go.uber.org/fx/fxevent"

"go.uber.org/fx/fxtest"

)

func TestAnnotated(t *testing.T) {

t.Parallel()

type a struct {

name string

}

type in struct {

fx.In

A *a `name:"foo"`

}

newA := func() *a {

return &a{name: "foo"}

}

t.Run("Provide", func(t *testing.T) {

t.Parallel()

var in in

app := fxtest.New(t,

fx.Provide(

fx.Annotated{

Name: "foo",

Target: newA,

},

),

fx.Populate(&in),

)

defer app.RequireStart().RequireStop()

assert.NotNil(t, in.A, "expected in.A to be injected")

assert.Equal(t, "foo", in.A.name, "expected to get a type 'a' of name 'foo'")

})

}

type fromStringer struct {

name string

}

func (from *fromStringer) String() string {

return from.name

}

type asStringer struct {

name string

}

func (as *asStringer) String() string {

return as.name

}

type anotherStringer struct {

name string

}

func (a anotherStringer) String() string {

return a.name

}

func TestAnnotatedFrom(t *testing.T) {

t.Parallel()

type myStringer interface {

String() string

}

newFromStringer := func() *fromStringer {

return &fromStringer{

name: "a good stringer",

}

}

tests := []struct {

desc string

provide fx.Option

invoke interface{}

}{

{

desc: "provide a good stringer",

provide: fx.Provide(

newFromStringer,

fx.Annotate(

func(myStringer myStringer) fmt.Stringer {

return &fromStringer{

name: myStringer.String(),

}

},

fx.From(new(*fromStringer)),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "a good stringer")

},

},

{

desc: "value type implementing interface",

provide: fx.Provide(

func() anotherStringer {

return anotherStringer{

"another stringer",

}

},

fx.Annotate(

func(myStringer myStringer) fmt.Stringer {

return &fromStringer{

name: myStringer.String(),

}

},

fx.From(new(anotherStringer)),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "another stringer")

},

},

{

desc: "provide with multiple types From",

provide: fx.Provide(

newFromStringer,

func() anotherStringer {

return anotherStringer{

"another stringer",

}

},

fx.Annotate(

func(myStringer1 myStringer, myStringer2 myStringer) fmt.Stringer {

return &fromStringer{

name: myStringer1.String() + " and " + myStringer2.String(),

}

},

fx.From(new(anotherStringer), new(*fromStringer)),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "another stringer and a good stringer")

},

},

{

desc: "provide from with param annotation",

provide: fx.Provide(

fx.Annotate(

newFromStringer,

fx.ResultTags(`name:"struct1"`),

),

fx.Annotate(

func(myStringer myStringer) fmt.Stringer {

return &fromStringer{

name: myStringer.String(),

}

},

fx.From(new(*fromStringer)),

fx.ParamTags(`name:"struct1"`),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "a good stringer")

},

},

{

// same as the test above, except now we annotate

// it in a different order.

desc: "provide from with param annotation, in different order",

provide: fx.Provide(

fx.Annotate(

newFromStringer,

fx.ResultTags(`name:"struct1"`),

),

fx.Annotate(

func(myStringer myStringer) fmt.Stringer {

return &fromStringer{

name: myStringer.String(),

}

},

fx.ParamTags(`name:"struct1"`),

fx.From(new(*fromStringer)),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "a good stringer")

},

},

{

desc: "annotate fewer items than required for constructor",

provide: fx.Provide(

newFromStringer,

func() anotherStringer {

return anotherStringer{

"another stringer",

}

},

fx.Annotate(

func(myStringer1 myStringer, fromStringer2 *fromStringer) fmt.Stringer {

return &fromStringer{

name: myStringer1.String() + " and " + fromStringer2.String(),

}

},

fx.From(new(anotherStringer)),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "another stringer and a good stringer")

},

},

{

desc: "Provide with empty From type",

provide: fx.Provide(

newFromStringer,

fx.Annotate(

func(myStringer *fromStringer) fmt.Stringer {

return &fromStringer{

name: myStringer.String(),

}

},

fx.From(),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "a good stringer")

},

},

{

desc: "Provide with variadic function",

provide: fx.Provide(

newFromStringer,

fx.Annotate(

func(myStringer myStringer, x ...int) fmt.Stringer {

return &fromStringer{

name: myStringer.String(),

}

},

fx.From(new(*fromStringer)),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "a good stringer")

},

},

}

for _, tt := range tests {

tt := tt

t.Run(tt.desc, func(t *testing.T) {

t.Parallel()

app := NewForTest(t,

fx.WithLogger(func() fxevent.Logger {

return fxtest.NewTestLogger(t)

}),

tt.provide,

fx.Invoke(tt.invoke),

)

require.NoError(t, app.Err())

})

}

}

func TestAnnotatedFromFailures(t *testing.T) {

t.Parallel()

type myStringer interface {

String() string

}

newFromStringer := func() *fromStringer {

return &fromStringer{name: "stringer"}

}

tests := []struct {

desc string

provide fx.Option

invoke interface{}

errorContains string

}{

{

desc: "provide when an illegal type From",

provide: fx.Provide(

fx.Annotate(

func(writer io.Writer) fmt.Stringer {

return &fromStringer{}

},

fx.From(new(*fromStringer)),

),

),

invoke: func(stringer fmt.Stringer) {

fmt.Println(stringer.String())

},

errorContains: "*fx_test.fromStringer does not implement io.Writer",

},

{

desc: "provide with variadic function and an illegal type From",

provide: fx.Provide(

fx.Annotate(

func(writer io.Writer, x ...int) fmt.Stringer {

return &fromStringer{}

},

fx.From(new(*fromStringer)),

),

),

invoke: func(stringer fmt.Stringer) {

fmt.Println(stringer.String())

},

errorContains: "*fx_test.fromStringer does not implement io.Writer",

},

{

desc: "don't provide original type using From",

provide: fx.Provide(

fx.Annotate(

func(myStringer myStringer) fmt.Stringer {

return &fromStringer{

name: myStringer.String(),

}

},

fx.From(new(*fromStringer)),

),

),

invoke: func(stringer fmt.Stringer) {

fmt.Println(stringer.String())

},

errorContains: "missing type: *fx_test.fromStringer",

},

{

desc: "fail to provide with name annotation",

provide: fx.Provide(

fx.Annotate(

newFromStringer,

),

fx.Annotate(

func(myStringer myStringer) fmt.Stringer {

return &fromStringer{

name: myStringer.String(),

}

},

fx.From(new(*fromStringer)),

fx.ParamTags(`name:"struct1"`),

),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "a good stringer")

},

errorContains: `missing type: *fx_test.fromStringer[name="struct1"]`,

},

{

desc: "non-pointer argument to From",

provide: fx.Provide(

fx.Annotate(

newFromStringer,

fx.From("foo"),

),

),

errorContains: "argument must be a pointer",

},

{

desc: "multiple from annotations",

provide: fx.Provide(

fx.Annotate(

newFromStringer,

fx.From(new(asStringer)),

fx.From(new(asStringer)),

),

),

errorContains: "cannot apply more than one line of From",

},

{

desc: "variadic argument",

provide: fx.Provide(

fx.Annotate(

func(ss ...myStringer) {},

fx.From(new(asStringer)),

),

),

errorContains: "cannot annotate a variadic argument",

},

}

for _, tt := range tests {

tt := tt

t.Run(tt.desc, func(t *testing.T) {

t.Parallel()

app := NewForTest(t,

fx.WithLogger(func() fxevent.Logger {

return fxtest.NewTestLogger(t)

}),

tt.provide,

fx.Invoke(tt.invoke),

)

err := app.Err()

require.Error(t, err)

assert.Contains(t, err.Error(), tt.errorContains)

})

}

}

func TestAnnotatedAs(t *testing.T) {

t.Parallel()

type in struct {

fx.In

S fmt.Stringer `name:"goodStringer"`

}

type myStringer interface {

String() string

}

newAsStringer := func() *asStringer {

return &asStringer{

name: "a good stringer",

}

}

tests := []struct {

desc string

provide fx.Option

invoke interface{}

startApp bool

}{

{

desc: "provide a good stringer",

provide: fx.Provide(

fx.Annotate(newAsStringer, fx.As(new(fmt.Stringer))),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "a good stringer")

},

},

{

desc: "value type implementing interface",

provide: fx.Provide(

fx.Annotate(func() anotherStringer {

return anotherStringer{

"another stringer",

}

}, fx.As(new(fmt.Stringer))),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, s.String(), "another stringer")

},

},

{

desc: "provide with multiple types As",

provide: fx.Provide(fx.Annotate(func() (*asStringer, *bytes.Buffer) {

buf := make([]byte, 1)

b := bytes.NewBuffer(buf)

return &asStringer{name: "stringer"}, b

}, fx.As(new(fmt.Stringer), new(io.Writer)))),

invoke: func(s fmt.Stringer, w io.Writer) {

w.Write([]byte(s.String()))

},

},

{

desc: "provide as with result annotation",

provide: fx.Provide(

fx.Annotate(func() *asStringer {

return &asStringer{name: "stringer"}

},

fx.ResultTags(`name:"goodStringer"`),

fx.As(new(fmt.Stringer))),

),

invoke: func(i in) {

assert.Equal(t, "stringer", i.S.String())

},

},

{

// same as the test above, except now we annotate

// it in a different order.

desc: "provide as with result annotation, in different order",

provide: fx.Provide(

fx.Annotate(func() *asStringer {

return &asStringer{name: "stringer"}

},

fx.As(new(fmt.Stringer)),

fx.ResultTags(`name:"goodStringer"`)),

),

invoke: func(i in) {

assert.Equal(t, "stringer", i.S.String())

},

},

{

desc: "provide as with result annotation with error",

provide: fx.Provide(

fx.Annotate(func() (*asStringer, error) {

return &asStringer{name: "stringer"}, nil

},

fx.ResultTags(`name:"goodStringer"`),

fx.As(new(fmt.Stringer))),

),

invoke: func(i in) {

assert.Equal(t, "stringer", i.S.String())

},

},

{

desc: "provide as with result annotation in different order with error",

provide: fx.Provide(

fx.Annotate(func() (*asStringer, error) {

return &asStringer{name: "stringer"}, nil

},

fx.As(new(fmt.Stringer)),

fx.ResultTags(`name:"goodStringer"`)),

),

invoke: func(i in) {

assert.Equal(t, "stringer", i.S.String())

},

},

{

desc: "provide multiple constructors annotated As",

provide: fx.Provide(

fx.Annotate(func() *asStringer {

return &asStringer{name: "stringer"}

}, fx.As(new(fmt.Stringer))),

fx.Annotate(func() *bytes.Buffer {

buf := make([]byte, 1)

return bytes.NewBuffer(buf)

}, fx.As(new(io.Writer))),

),

invoke: func(s fmt.Stringer, w io.Writer) {

assert.Equal(t, "stringer", s.String())

_, err := w.Write([]byte{1})

require.NoError(t, err)

},

},

{

desc: "provide the same provider as multiple types",

provide: fx.Provide(

fx.Annotate(newAsStringer, fx.As(new(fmt.Stringer))),

fx.Annotate(newAsStringer, fx.As(new(myStringer))),

),

invoke: func(s fmt.Stringer, ms myStringer) {

assert.Equal(t, "a good stringer", s.String())

assert.Equal(t, "a good stringer", ms.String())

},

},

{

desc: "annotate fx.Supply",

provide: fx.Supply(

fx.Annotate(&asStringer{"foo"}, fx.As(new(fmt.Stringer))),

),

invoke: func(s fmt.Stringer) {

assert.Equal(t, "foo", s.String())

},

},

{

desc: "annotate as many interfaces",

provide: fx.Provide(

fx.Annotate(func() (*asStringer, error) {

return &asStringer{name: "stringer"}, nil

},

fx.As(new(fmt.Stringer)),

fx.As(new(myStringer)),

fx.ResultTags(`name:"stringer"`)),

),

invoke: fx.Annotate(

func(

S fmt.Stringer,

MS myStringer,

) {

assert.Equal(t, "stringer", S.String())

assert.Equal(t, "stringer", MS.String())

}, fx.ParamTags(`name:"stringer"`, `name:"stringer"`),

),

},

{

desc: "annotate as many interfaces with both-annotated return values",

provide: fx.Provide(

fx.Annotate(func() (*asStringer, *bytes.Buffer) {

return &asStringer{name: "stringer"},

bytes.NewBuffer(make([]byte, 1))

},

fx.As(new(fmt.Stringer), new(io.Reader)),

fx.As(new(myStringer), new(io.Writer))),

),

invoke: func(s fmt.Stringer, ms myStringer, r io.Reader, w io.Writer) {

assert.Equal(t, "stringer", s.String())

assert.Equal(t, "stringer", ms.String())

_, err := w.Write([]byte("."))

assert.NoError(t, err)

buf := make([]byte, 1)

_, err = r.Read(buf)

assert.NoError(t, err)

},

},

{

desc: "annotate as many interfaces with different numbers of annotations",

provide: fx.Provide(

fx.Annotate(func() (*asStringer, *bytes.Buffer) {

return &asStringer{name: "stringer"},

bytes.NewBuffer(make([]byte, 1))

},

// annotate both in here

fx.As(new(fmt.Stringer), new(io.Writer)),

// annotate just myStringer here

fx.As(new(myStringer))),

),

invoke: func(s fmt.Stringer, ms myStringer, w io.Writer) {

assert.Equal(t, "stringer", s.String())

assert.Equal(t, "stringer", ms.String())

_, err := w.Write([]byte("."))

assert.NoError(t, err)

},

},

{

desc: "annotate many interfaces with varying annotation count and check original type",

provide: fx.Provide(

fx.Annotate(func() (*asStringer, *bytes.Buffer) {

return &asStringer{name: "stringer"},

bytes.NewBuffer(make([]byte, 1))

},

// annotate just myStringer here

fx.As(new(myStringer)),

// annotate both in here

fx.As(new(fmt.Stringer), new(io.Writer))),

),

invoke: func(s fmt.Stringer, ms myStringer, buf *bytes.Buffer, w io.Writer) {

assert.Equal(t, "stringer", s.String())

assert.Equal(t, "stringer", ms.String())

_, err := w.Write([]byte("."))

assert.NoError(t, err)

_, err = buf.Write([]byte("."))

assert.NoError(t, err)

},

},

{

desc: "annotate fewer items than provided constructor",

provide: fx.Provide(

fx.Annotate(func() (*bytes.Buffer, *strings.Builder) {

s := "Hello"

return bytes.NewBuffer([]byte(s)), &strings.Builder{}

},

fx.As(new(io.Reader))),

),

invoke: func(r io.Reader) {

},

},

{

desc: "results annotated as are provided to hooks as annotated types",

provide: fx.Provide(

fx.Annotate(func() (*asStringer, *bytes.Buffer) {

return &asStringer{name: "stringer"},

bytes.NewBuffer([]byte{})

},

// lifecycle hook added is able to receive results as annotated

fx.OnStart(func(s fmt.Stringer, ms myStringer, buf *bytes.Buffer, w io.Writer) {

assert.Equal(t, "stringer", s.String())

assert.Equal(t, "stringer", ms.String())

_, err := w.Write([]byte("."))

assert.NoError(t, err)

_, err = buf.Write([]byte("."))

assert.NoError(t, err)

}),

fx.OnStop(func(buf *bytes.Buffer) {

assert.Equal(t, "....", buf.String(), "buffer should contain bytes written in Invoke func and OnStart hook")

}),

// annotate just myStringer here

fx.As(new(myStringer)),

// annotate both in here

fx.As(new(fmt.Stringer), new(io.Writer))),

),

invoke: func(s fmt.Stringer, ms myStringer, buf *bytes.Buffer, w io.Writer) {

assert.Equal(t, "stringer", s.String())

assert.Equal(t, "stringer", ms.String())

_, err := w.Write([]byte("."))

assert.NoError(t, err)

_, err = buf.Write([]byte("."))

assert.NoError(t, err)

},

startApp: true,

},

}

for _, tt := range tests {

tt := tt

t.Run(tt.desc, func(t *testing.T) {

t.Parallel()

app := NewForTest(t,

fx.WithLogger(func() fxevent.Logger {

return fxtest.NewTestLogger(t)

}),

tt.provide,

fx.Invoke(tt.invoke),

)

require.NoError(t, app.Err())

if tt.startApp {

ctx := context.Background()

require.NoError(t, app.Start(ctx))

require.NoError(t, app.Stop(ctx))

}

})

}

}

func TestAnnotatedAsFailures(t *testing.T) {

t.Parallel()

newAsStringer := func() *asStringer {

return &asStringer{name: "stringer"}

}

newAsStringerWithErr := func() (*asStringer, error) {

return nil, errors.New("great sadness")

}

tests := []struct {

desc string

provide fx.Option

invoke interface{}

errorContains string

}{

{

desc: "provide when an illegal type As",

provide: fx.Provide(fx.Annotate(newAsStringer, fx.As(new(io.Writer)))),

invoke: func() {},

errorContains: "asStringer does not implement io.Writer",

},

{

desc: "provide when an illegal type As with result tag",

provide: fx.Provide(fx.Annotate(newAsStringer, fx.ResultTags(`name:"stringer"`), fx.As(new(io.Writer)))),

invoke: func() {},

errorContains: "asStringer does not implement io.Writer",

},

{

desc: "error is propagated without result tag",

provide: fx.Provide(fx.Annotate(newAsStringerWithErr, fx.As(new(fmt.Stringer)))),

invoke: func(_ fmt.Stringer) {},

errorContains: "great sadness",

},

{

desc: "error is propagated with result tag",

provide: fx.Provide(fx.Annotate(newAsStringerWithErr, fx.ResultTags(`name:"stringer"`), fx.As(new(fmt.Stringer)))),

invoke: fx.Annotate(func(_ fmt.Stringer) {}, fx.ParamTags(`name:"stringer"`)),

errorContains: "great sadness",

},

{

desc: "don't provide original type using As",

provide: fx.Provide(fx.Annotate(newAsStringer, fx.As(new(fmt.Stringer)))),

invoke: func(as *asStringer) {

fmt.Println(as.String())

},

errorContains: "missing type: *fx_test.asStringer",

},

{

desc: "fail to provide with name annotation",

provide: fx.Provide(fx.Annotate(func(n string) *asStringer {

return &asStringer{name: n}

}, fx.As(new(fmt.Stringer)), fx.ParamTags(`name:"n"`))),

invoke: func(a fmt.Stringer) {

fmt.Println(a)

},

errorContains: `missing type: string[name="n"]`,

},

{

desc: "non-pointer argument to As",

provide: fx.Provide(

fx.Annotate(

newAsStringer,

fx.As("foo"),

),

),

errorContains: "argument must be a pointer to an interface: got string",

},

}

for _, tt := range tests {

tt := tt

t.Run(tt.desc, func(t *testing.T) {

t.Parallel()

app := NewForTest(t,

fx.WithLogger(func() fxevent.Logger {

return fxtest.NewTestLogger(t)

}),

tt.provide,

fx.Invoke(tt.invoke),

)

err := app.Err()

require.Error(t, err)

assert.Contains(t, err.Error(), tt.errorContains)

})

}

}

func TestAnnotatedWrongUsage(t *testing.T) {

t.Parallel()

type a struct {

name string

}

type in struct {

fx.In

A *a `name:"foo"`

}

newA := func() *a {

return &a{name: "foo"}

}

t.Run("In Constructor", func(t *testing.T) {

t.Parallel()

var in in

app := NewForTest(t,

fx.WithLogger(func() fxevent.Logger {

return fxtest.NewTestLogger(t)

}),

fx.Provide(

func() fx.Annotated {

return fx.Annotated{

Name: "foo",

Target: newA,

}

},

),

fx.Populate(&in),

)

err := app.Err()

require.Error(t, err)

// Example:

// fx.Annotated should be passed to fx.Provide directly, it should not be returned by the constructor: fx.Provide received go.uber.org/fx_test.TestAnnotatedWrongUsage.func2.1() from:

// go.uber.org/fx_test.TestAnnotatedWrongUsage.func2

// /.../fx/annotated_test.go:76

// testing.tRunner

// /.../go/1.13.3/libexec/src/testing/testing.go:909

assert.Contains(t, err.Error(), "fx.Annotated should be passed to fx.Provide directly, it should not be returned by the constructor")

assert.Contains(t, err.Error(), "fx.Provide received go.uber.org/fx_test.TestAnnotatedWrongUsage")

assert.Contains(t, err.Error(), "go.uber.org/fx_test.TestAnnotatedWrongUsage")

assert.Contains(t, err.Error(), "/annotated_test.go")

})

t.Run("Result Type", func(t *testing.T) {

t.Parallel()

app := NewForTest(t,

fx.WithLogger(func() fxevent.Logger {

return fxtest.NewTestLogger(t)

}),

fx.Provide(

fx.Annotated{

Name: "foo",

Target: func() in {

return in{A: &a{name: "foo"}}

},

},

),

)

assert.Contains(t, app.Err().Error(), "embeds a dig.In", "expected error when result types were annotated")

})

t.Run("invalid group option", func(t *testing.T) {

t.Parallel()

app := NewForTest(t,

fx.Provide(

fx.Annotate(func() string { return "sad times" },

fx.ResultTags(`group:"foo,soft"`)),

),

)

assert.Contains(t, app.Err().Error(), "cannot use soft with result value groups", "expected error when invalid group option is provided")

})

}

func TestAnnotatedString(t *testing.T) {

t.Parallel()

tests := []struct {

desc string

give fx.Annotated

want string

}{

{

desc: "empty",

give: fx.Annotated{},

want: "fx.Annotated{}",

},

{

desc: "name",

give: fx.Annotated{Name: "foo"},

want: `fx.Annotated{Name: "foo"}`,

},

{

desc: "group",

give: fx.Annotated{Group: "foo"},

want: `fx.Annotated{Group: "foo"}`,

},

{

desc: "name and group",

give: fx.Annotated{Name: "foo", Group: "bar"},

want: `fx.Annotated{Name: "foo", Group: "bar"}`,

},

{

desc: "target",

give: fx.Annotated{Target: func() {}},

want: "fx.Annotated{Target: go.uber.org/fx_test.TestAnnotatedString.func1()}",

},

{

desc: "name and target",

give: fx.Annotated{Name: "foo", Target: func() {}},

want: `fx.Annotated{Name: "foo", Target: go.uber.org/fx_test.TestAnnotatedString.func2()}`,

},

{

desc: "group and target",

give: fx.Annotated{Group: "foo", Target: func() {}},

want: `fx.Annotated{Group: "foo", Target: go.uber.org/fx_test.TestAnnotatedString.func3()}`,

},

{

desc: "name, group and target",

give: fx.Annotated{Name: "foo", Group: "bar", Target: func() {}},

want: `fx.Annotated{Name: "foo", Group: "bar", Target: go.uber.org/fx_test.TestAnnotatedString.func4()}`,

},

}

for _, tt := range tests {

tt := tt

t.Run(tt.desc, func(t *testing.T) {

t.Parallel()

assert.Equal(t, tt.want, tt.give.String())

})

}

}

func TestAnnotate(t *testing.T) {

t.Parallel()

type a struct{}

type b struct{ a *a }

type c struct{ b *b }

type sliceA struct{ sa []*a }

newA := func() *a { return &a{} }

newB := func(a *a) *b {

return &b{a}

}

newC := func(b *b) *c {

return &c{b}

}

newSliceA := func(sa ...*a) *sliceA {

return &sliceA{sa}

}

newSliceAWithB := func(b *b, sa ...*a) *sliceA {

total := append(sa, b.a)

return &sliceA{total}

}

t.Run("Provide with empty param+result tags", func(t *testing.T) {

t.Parallel()

app := fxtest.New(t,

fx.Provide(

newA,

fx.Annotate(newB, fx.ParamTags(), fx.ResultTags()),

),

fx.Invoke(newC),

)

defer app.RequireStart().RequireStop()

require.NoError(t, app.Err())

})

t.Run("Provide with optional", func(t *testing.T) {

t.Parallel()

app := fxtest.New(t,

fx.Provide(

fx.Annotate(newB, fx.ParamTags(`name:"a" optional:"true"`)),

),

fx.Invoke(newC),

)