| // Copyright 2021 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| package inject | |
| import ( | |
| "fmt" | |
| "reflect" | |
| "strings" | |
| "testing" | |
| ) | |
| func TestRequirePtrToStruct(t *testing.T) { | |
| targets := []interface{}{ | |
| int32(4), | |
| make(map[string]rune), | |
| struct{}{}, | |
| []bool{true}, | |
| } | |
| for _, target := range targets { | |
| if _, err := Start(target); err == nil { | |
| t.Errorf("expected failure when starting: %T", target) | |
| } else if !strings.Contains(err.Error(), "must be pointer to struct") { | |
| t.Errorf("expected a different failure when starting: %s", err) | |
| } | |
| } | |
| } | |
| func TestEmptyStruct(t *testing.T) { | |
| target := &struct{}{} | |
| stopper, err := Start(target) | |
| if err != nil { | |
| t.Fatalf("when starting: %s", err) | |
| } | |
| checkStoppingOrder(t, stopper, []reflect.Type{ | |
| reflect.TypeOf((*struct{})(nil)), | |
| }) | |
| if err := stopper.Stop(); err != nil { | |
| t.Fatalf("when stopping: %s", err) | |
| } | |
| } | |
| type pointsToSelf struct { | |
| Self *pointsToSelf `inject:""` | |
| } | |
| func TestPointsToSelf(t *testing.T) { | |
| target := &pointsToSelf{} | |
| _, err := Start(target) | |
| if err == nil { | |
| t.Fatalf("expected failure when starting: %T", target) | |
| } | |
| if !strings.Contains(err.Error(), "*inject.pointsToSelf > *inject.pointsToSelf: cyclic dependency") { | |
| t.Fatalf("expected a different failure when starting: %s", err) | |
| } | |
| } | |
| type simpleChainOne struct { | |
| SkipMe string | |
| SkipMeAsWell string | |
| Two *simpleChainTwo `inject:""` | |
| } | |
| type simpleChainTwo struct { | |
| Three *simpleChainThree `inject:""` | |
| } | |
| type simpleChainThree struct { | |
| Here string | |
| We string | |
| Skip string | |
| More string | |
| Fields string | |
| } | |
| func TestSimpleChain(t *testing.T) { | |
| target := &simpleChainOne{} | |
| stopper, err := Start(target) | |
| if err != nil { | |
| t.Fatalf("when starting: %s", err) | |
| } | |
| checkStoppingOrder(t, stopper, []reflect.Type{ | |
| reflect.TypeOf((*simpleChainOne)(nil)), | |
| reflect.TypeOf((*simpleChainTwo)(nil)), | |
| reflect.TypeOf((*simpleChainThree)(nil)), | |
| }) | |
| if target.Two == nil { | |
| t.Fatalf("two is nil") | |
| } | |
| if target.Two.Three == nil { | |
| t.Fatalf("three is nil") | |
| } | |
| if err := stopper.Stop(); err != nil { | |
| t.Fatalf("when stopping: %s", err) | |
| } | |
| } | |
| type diamondTop struct { | |
| Left *diamondLeft `inject:""` | |
| Right *diamondRight `inject:""` | |
| } | |
| type diamondLeft struct { | |
| Bottom *diamondBottom `inject:""` | |
| } | |
| type diamondRight struct { | |
| Bottom *diamondBottom `inject:""` | |
| } | |
| type diamondBottom struct { | |
| } | |
| func TestDiamond(t *testing.T) { | |
| top := &diamondTop{} | |
| stopper, err := Start(top) | |
| if err != nil { | |
| t.Fatalf("when starting: %s", err) | |
| } | |
| checkStoppingOrder(t, stopper, []reflect.Type{ | |
| reflect.TypeOf((*diamondTop)(nil)), | |
| reflect.TypeOf((*diamondLeft)(nil)), | |
| reflect.TypeOf((*diamondBottom)(nil)), | |
| reflect.TypeOf((*diamondRight)(nil)), | |
| }) | |
| if top.Left == nil { | |
| t.Fatalf("top.left is nil") | |
| } | |
| if top.Right == nil { | |
| t.Fatalf("top.right is nil") | |
| } | |
| if top.Left.Bottom == nil { | |
| t.Fatalf("left.bottom is nil") | |
| } | |
| if top.Right.Bottom == nil { | |
| t.Fatalf("right.bottom is nil") | |
| } | |
| if top.Left.Bottom != top.Right.Bottom { | |
| t.Fatalf("left.bottom is not the same as right.bottom") | |
| } | |
| if err := stopper.Stop(); err != nil { | |
| t.Fatalf("when stopping: %s", err) | |
| } | |
| } | |
| type configurableStartAndStop struct { | |
| failToStart, failToStop bool | |
| startCounter, stopCounter int | |
| } | |
| var _ Starter = (*configurableStartAndStop)(nil) | |
| var _ Stopper = (*configurableStartAndStop)(nil) | |
| func (module *configurableStartAndStop) Start() error { | |
| if module.failToStart { | |
| return fmt.Errorf("failed to start") | |
| } | |
| module.startCounter++ | |
| return nil | |
| } | |
| func (module *configurableStartAndStop) Stop() error { | |
| if module.failToStop { | |
| return fmt.Errorf("failed to stop") | |
| } | |
| module.stopCounter++ | |
| return nil | |
| } | |
| func TestStartStopSucceed(t *testing.T) { | |
| target := &configurableStartAndStop{} | |
| stopper, err := Start(target) | |
| if err != nil { | |
| t.Fatalf("when starting: %s", err) | |
| } | |
| if err := stopper.Stop(); err != nil { | |
| t.Fatalf("when stopping: %s", err) | |
| } | |
| if expected := 1; target.startCounter != expected { | |
| t.Fatalf("startCounter expected %d, found %d", expected, target.startCounter) | |
| } | |
| if expected := 1; target.stopCounter != expected { | |
| t.Fatalf("stopCounter expected %d, found %d", expected, target.stopCounter) | |
| } | |
| } | |
| func TestStartFails(t *testing.T) { | |
| target := &configurableStartAndStop{failToStart: true} | |
| _, err := Start(target) | |
| if err == nil { | |
| t.Fatalf("expected failure when starting: %T", target) | |
| } | |
| if !strings.Contains(err.Error(), "failed to start") { | |
| t.Fatalf("expected a different failure when starting: %s", err) | |
| } | |
| if expected := 0; target.startCounter != expected { | |
| t.Fatalf("startCounter expected %d, found %d", expected, target.startCounter) | |
| } | |
| if expected := 0; target.stopCounter != expected { | |
| t.Fatalf("stopCounter expected %d, found %d", expected, target.stopCounter) | |
| } | |
| } | |
| func TestStopFails(t *testing.T) { | |
| target := &configurableStartAndStop{failToStop: true} | |
| stopper, err := Start(target) | |
| if err != nil { | |
| t.Fatalf("when starting: %s", err) | |
| } | |
| err = stopper.Stop() | |
| if err == nil { | |
| t.Fatalf("expected failure when stopping: %T", target) | |
| } | |
| if !strings.Contains(err.Error(), "failed to stop") { | |
| t.Fatalf("expected a different failure when stopping: %s", err) | |
| } | |
| if expected := 1; target.startCounter != expected { | |
| t.Fatalf("startCounter expected %d, found %d", expected, target.startCounter) | |
| } | |
| if expected := 0; target.stopCounter != expected { | |
| t.Fatalf("stopCounter expected %d, found %d", expected, target.stopCounter) | |
| } | |
| } | |
| type someDependency interface{ specialMethodHere() } | |
| type implOfSomeDependency struct{} | |
| var _ someDependency = (*implOfSomeDependency)(nil) | |
| func (*implOfSomeDependency) specialMethodHere() {} | |
| type lateBoundDependency struct { | |
| SomeDependency someDependency `inject:""` | |
| } | |
| func TestLateBoundDependency(t *testing.T) { | |
| target := &lateBoundDependency{} | |
| stopper, err := Start(target, ImplementedBy{ | |
| Target: reflect.TypeOf((*someDependency)(nil)).Elem(), | |
| Impl: reflect.TypeOf((*implOfSomeDependency)(nil)), | |
| }) | |
| if err != nil { | |
| t.Fatalf("when starting: %s", err) | |
| } | |
| if _, ok := target.SomeDependency.(*implOfSomeDependency); !ok { | |
| t.Fatalf("field SomeDependency has incorrect type: %T", target.SomeDependency) | |
| } | |
| if err := stopper.Stop(); err != nil { | |
| t.Fatalf("when stopping: %s", err) | |
| } | |
| } | |
| func TestLateBoundDependencyDoesNotImplement(t *testing.T) { | |
| target := &lateBoundDependency{} | |
| _, err := Start(target, ImplementedBy{ | |
| Target: reflect.TypeOf((*someDependency)(nil)).Elem(), | |
| Impl: reflect.TypeOf(implOfSomeDependency{}), | |
| }) | |
| if err == nil { | |
| t.Fatalf("expected failure when starting: %T", target) | |
| } | |
| if !strings.Contains(err.Error(), "inject.implOfSomeDependency does not implement inject.someDependency") { | |
| t.Fatalf("expected a different failure when starting: %s", err) | |
| } | |
| } | |
| func TestLateBoundDependencyNotAnInterface(t *testing.T) { | |
| target := &lateBoundDependency{} | |
| _, err := Start(target, ImplementedBy{ | |
| Target: reflect.TypeOf(map[string]struct{}{}), | |
| Impl: reflect.TypeOf((*implOfSomeDependency)(nil)), | |
| }) | |
| if err == nil { | |
| t.Fatalf("expected failure when starting: %T", target) | |
| } | |
| if !strings.Contains(err.Error(), "map[string]struct {} is not an interface") { | |
| t.Fatalf("expected a different failure when starting: %s", err) | |
| } | |
| } | |
| func checkStoppingOrder(t *testing.T, stopper Stopper, expectedOrder []reflect.Type) { | |
| t.Helper() | |
| var actualOrder []reflect.Type | |
| for _, node := range (stopper).(*graph).stoppingOrder { | |
| actualOrder = append(actualOrder, node.typ) | |
| } | |
| if !reflect.DeepEqual(actualOrder, expectedOrder) { | |
| t.Errorf( | |
| "stoppingOrder mismatch\nactual: %s\nexpected: %s", | |
| typesToNiceString(actualOrder), typesToNiceString(expectedOrder)) | |
| } | |
| } | |
| func typesToNiceString(types []reflect.Type) string { | |
| var parts []string | |
| for _, typ := range types { | |
| parts = append(parts, typ.String()) | |
| } | |
| return strings.Join(parts, ", ") | |
| } |