inject_test.go

package di_test

import (
	"errors"
	"testing"
	"time"

	"github.com/jad21/di"
)

// type testSt struct {
// 	Msg string
// 	Num int
// }

type testSt2 struct {
	Name string
}

func (t *testSt2) String() string {
	return t.Name
}

type Itest interface {
	String() string
}

func TestInterfaceOf(t *testing.T) {
	_di := di.New()

	val := time.Now()
	_ = _di.Map(val)

	ok := "is ok"
	invoke, err := _di.Invoke(func(s Itest) string {
		if s.String() != val.String() {
			t.Errorf("expected %s, got %s", val.String(), s.String())
		}
		return ok
	})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(invoke) == 0 || invoke[0].Interface().(string) != ok {
		t.Errorf("expected result '%s', got %+v", ok, invoke)
	}

	val2 := &testSt2{Name: "val"}
	o := _di.Map(val2, di.WithInterface((*Itest)(nil)))
	if o != nil {
		t.Errorf("expected nil error mapping val2, got %v", o)
	}

	invoke, err = _di.Invoke(func(s Itest) string {
		if s.String() != "val" {
			t.Errorf("expected 'val', got %s", s.String())
		}
		return ok
	})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(invoke) == 0 || invoke[0].Interface().(string) != ok {
		t.Errorf("expected result '%s', got %+v", ok, invoke)
	}

	_, err = _di.Invoke(func(s Itest, v time.Time) string {
		if s.String() != "val" {
			t.Errorf("expected 'val', got %s", s.String())
		}
		if v.String() != val.String() {
			t.Errorf("expected %s, got %s", val.String(), v.String())
		}
		return ok
	})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	invoke, err = _di.Invoke(func(t time.Time) string {
		return ok
	})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(invoke) == 0 || invoke[0].Interface().(string) != ok {
		t.Errorf("expected result '%s', got %+v", ok, invoke)
	}
}

func TestInvoke(t *testing.T) {
	_di := di.New()

	test := &testSt{Msg: time.Now().String(), Num: 666}
	_ = _di.Map(test)

	ok := "is ok"
	invoke, err := _di.Invoke(func(s *testSt) string {
		if s != test {
			t.Errorf("expected %v, got %v", test, s)
		}
		return ok
	})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(invoke) == 0 || invoke[0].Interface().(string) != ok {
		t.Errorf("expected result '%s', got %+v", ok, invoke)
	}

	invoke, err = _di.Invoke(func(s testSt) string {
		// Comparar campos, no dirección
		if s != *test {
			t.Errorf("expected %v, got %v", *test, s)
		}
		return ok
	})
	if err == nil {
		t.Error("expected error for passing testSt by value, got nil")
	}
	t.Logf("err: %v, invoke: %+v", err, invoke)

	test2 := testSt{Msg: time.Now().String(), Num: 666}
	_ = _di.Map(test2)
	invoke, err = _di.Invoke(func(s testSt, rs *testSt) int64 {
		if s != test2 {
			t.Errorf("expected %v, got %v", test2, s)
		}
		if rs != test {
			t.Errorf("expected %v, got %v", test, rs)
		}
		return 18
	})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(invoke) == 0 || invoke[0].Interface().(int64) != 18 {
		t.Errorf("expected result 18, got %+v", invoke)
	}
}

func TestInvokeWithErrorOnly(t *testing.T) {
	_di := di.New()

	test := &testSt{Msg: time.Now().String(), Num: 666}
	_ = _di.Map(test)

	{
		err := _di.InvokeWithErrorOnly(func(s *testSt) {})
		if err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	}

	{
		err := _di.InvokeWithErrorOnly(func(s *testSt) error {
			return nil
		})
		if err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	}

	{
		err := _di.InvokeWithErrorOnly(func(s *testSt) error {
			return errors.New("test error")
		})
		if err == nil || err.Error() != "test error" {
			t.Errorf("expected 'test error', got %v", err)
		}
	}

	{
		err := _di.InvokeWithErrorOnly(func(s *testSt) error {
			panic("test panic")
		})
		if err == nil || err.Error() != "test panic" {
			t.Errorf("expected 'test panic', got %v", err)
		}
	}

	{
		err := _di.InvokeWithErrorOnly(func(s *testSt) (int, error) {
			return 0, errors.New("test error")
		})
		if err == nil || err.Error() != "test error" {
			t.Errorf("expected 'test error', got %v", err)
		}
	}
}