penkovsky_sa/cherrypick
1
0
Fork 0
mirror of https://github.com/pese-git/cherrypick.git synced 2026-01-24 13:47:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactored di library.

Browse Source
This commit is contained in:
Sergey Penkovsky
2021-04-26 09:43:57 +03:00
parent 9032abe21a
commit e726e3bf30
23 changed files with 71 additions and 1215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test/experimental/binding_test.dart → test/binding_test.dart
View File

@@ -1,4 +1,4 @@
import 'package:dart_di/experimental/binding.dart';
import 'package:dart_di/binding.dart';
import 'package:test/test.dart';
void main() {

458
test/di_container_test.dart
View File

@@ -1,458 +0,0 @@
import 'package:dart_di/di_container.dart';
import 'package:dart_di/resolvers/resolver.dart';
import 'package:test/test.dart';
import 'package:mockito/mockito.dart';
void main() {
group('Without parent', () {
test('Container bind<T> throws state error if it\'s already has resolver',
() {
final container = new DiContainer();
container.bind<int>().toResolver(_makeResolver(5));
expect(() => container.bind<int>().toResolver(_makeResolver(3)),
throwsA(isA<StateError>()));
});
test("Container resolves value after adding a dependency", () {
final expectedValue = 3;
final container = new DiContainer();
container.bind<int>().toResolver(_makeResolver(expectedValue));
expect(container.resolve<int>(), expectedValue);
});
test("Container throws state error if the value can't be resolved", () {
final container = DiContainer();
expect(() => container.resolve<int>(), throwsA(isA<StateError>()));
});
test("Container has() returns true if it has resolver", () {
final expectedValue = 5;
final container = new DiContainer();
container.bind<int>().toResolver(_makeResolver(expectedValue));
expect(container.has<int>(), true);
});
test("Container has() returns false if it hasn't resolver", () {
final container = new DiContainer();
expect(container.has<int>(), false);
});
test("Container hasInTree() returns true if it has resolver", () {
final expectedValue = 5;
final container = DiContainer();
container.bind<int>().toResolver(_makeResolver(expectedValue));
expect(container.hasInTree<int>(), true);
});
test("Container hasInTree() returns true if it hasn`t resolver", () {
final container = DiContainer();
expect(container.hasInTree<int>(), false);
});
});
group('With parent', () {
test(
"Container bind() throws state error (if it's parent already has a resolver)",
() {
final parentContainer = new DiContainer();
final container = new DiContainer(parentContainer);
parentContainer.bind<int>().toResolver(_makeResolver(5));
expect(() => container.bind<int>().toResolver(_makeResolver(3)),
throwsA(isA<StateError>()));
});
test("Container resolve() returns a value from parent container", () {
final expectedValue = 5;
final parentContainer = DiContainer();
final container = DiContainer(parentContainer);
parentContainer.bind<int>().toResolver(_makeResolver(expectedValue));
expect(container.resolve<int>(), expectedValue);
});
test("Container resolve() returns a several value from parent container",
() {
final expectedIntValue = 5;
final expectedStringValue = "Hello world";
final parentContainer = DiContainer();
final container = DiContainer(parentContainer);
parentContainer.bind<int>().toResolver(_makeResolver(expectedIntValue));
parentContainer
.bind<String>()
.toResolver(_makeResolver(expectedStringValue));
expect(container.resolve<int>(), expectedIntValue);
expect(container.resolve<String>(), expectedStringValue);
});
test("Container resolve() throws a state error if parent hasn't value too",
() {
final parentContainer = DiContainer();
final container = DiContainer(parentContainer);
expect(() => container.resolve<int>(), throwsA(isA<StateError>()));
});
test("Container has() returns false if parent has a resolver", () {
final parentContainer = DiContainer();
final container = DiContainer(parentContainer);
parentContainer.bind<int>().toResolver(_makeResolver(5));
expect(container.has<int>(), false);
});
test("Container has() returns false if parent hasn't a resolver", () {
final parentContainer = DiContainer();
final container = DiContainer(parentContainer);
expect(container.has<int>(), false);
});
test("Container hasInTree() returns true if parent has a resolver", () {
final parentContainer = DiContainer();
final container = DiContainer(parentContainer);
parentContainer.bind<int>().toResolver(_makeResolver(5));
expect(container.hasInTree<int>(), true);
});
test("Test asSingelton", () {
final expectedIntValue = 10;
final containerA = DiContainer();
final containerB = DiContainer(containerA);
containerA.bind<int>().toValue(expectedIntValue).asSingleton();
expect(containerB.resolve<int>(), expectedIntValue);
});
test("Child container can resolve parent container's value", () {
final containerA = DiContainer();
final a = AA();
containerA.bind<A>().toValue(a);
final containerB = DiContainer(containerA);
final containerC = DiContainer(containerB);
expect(containerC.resolve<A>(), a);
});
});
test("Bind to the factory resolves with value", () {
final container = DiContainer();
final a = AA();
container.bind<A>().toFactory(() => a);
expect(container.resolve<A>(), a);
});
test("Bind to the factory resolves with value", () {
final container = DiContainer();
final a = AA();
container.bind<A>().toValue(a);
container.bind<DependOnA>().toFactory1<A>((a) => DependOnA(a));
expect(container.resolve<DependOnA>().a, a);
});
test("Bind to the factory resolves with 2 value", () {
final container = DiContainer();
final a = AA();
final b = BB();
container.bind<A>().toValue(a);
container.bind<B>().toValue(b);
container.bind<DependOnAB>().toFactory2<A, B>((a, b) => DependOnAB(a, b));
expect(container.resolve<DependOnAB>().a, a);
expect(container.resolve<DependOnAB>().b, b);
});
test("Bind to the factory resolves with 3 value", () {
final container = DiContainer();
final a = AA();
final b = BB();
final c = CC();
container.bind<A>().toValue(a);
container.bind<B>().toValue(b);
container.bind<C>().toValue(c);
container
.bind<DependOnABC>()
.toFactory3<A, B, C>((a, b, c) => DependOnABC(a, b, c));
expect(container.resolve<DependOnABC>().a, a);
expect(container.resolve<DependOnABC>().b, b);
expect(container.resolve<DependOnABC>().c, c);
});
test("Bind to the factory resolves with 4 value", () {
final container = DiContainer();
final a = AA();
final b = BB();
final c = CC();
final d = DD();
container.bind<A>().toValue(a);
container.bind<B>().toValue(b);
container.bind<C>().toValue(c);
container.bind<D>().toValue(d);
container
.bind<DependOnABCD>()
.toFactory4<A, B, C, D>((a, b, c, d) => DependOnABCD(a, b, c, d));
expect(container.resolve<DependOnABCD>().a, a);
expect(container.resolve<DependOnABCD>().b, b);
expect(container.resolve<DependOnABCD>().c, c);
expect(container.resolve<DependOnABCD>().d, d);
});
test("Bind to the factory resolves with 5 value", () {
final container = DiContainer();
final a = AA();
final b = BB();
final c = CC();
final d = DD();
final e = EE();
container.bind<A>().toValue(a);
container.bind<B>().toValue(b);
container.bind<C>().toValue(c);
container.bind<D>().toValue(d);
container.bind<E>().toValue(e);
container.bind<DependOnABCDE>().toFactory5<A, B, C, D, E>(
(a, b, c, d, e) => DependOnABCDE(a, b, c, d, e));
expect(container.resolve<DependOnABCDE>().a, a);
expect(container.resolve<DependOnABCDE>().b, b);
expect(container.resolve<DependOnABCDE>().c, c);
expect(container.resolve<DependOnABCDE>().d, d);
expect(container.resolve<DependOnABCDE>().e, e);
});
test("Bind to the factory resolves with 6 value", () {
final container = DiContainer();
final a = AA();
final b = BB();
final c = CC();
final d = DD();
final e = EE();
final f = FF();
container.bind<A>().toValue(a);
container.bind<B>().toValue(b);
container.bind<C>().toValue(c);
container.bind<D>().toValue(d);
container.bind<E>().toValue(e);
container.bind<F>().toValue(f);
container.bind<DependOnABCDEF>().toFactory6<A, B, C, D, E, F>(
(a, b, c, d, e, f) => DependOnABCDEF(a, b, c, d, e, f));
expect(container.resolve<DependOnABCDEF>().a, a);
expect(container.resolve<DependOnABCDEF>().b, b);
expect(container.resolve<DependOnABCDEF>().c, c);
expect(container.resolve<DependOnABCDEF>().d, d);
expect(container.resolve<DependOnABCDEF>().e, e);
expect(container.resolve<DependOnABCDEF>().f, f);
});
test("Bind to the factory resolves with 7 value", () {
final container = DiContainer();
final a = AA();
final b = BB();
final c = CC();
final d = DD();
final e = EE();
final f = FF();
final g = GG();
container.bind<A>().toValue(a);
container.bind<B>().toValue(b);
container.bind<C>().toValue(c);
container.bind<D>().toValue(d);
container.bind<E>().toValue(e);
container.bind<F>().toValue(f);
container.bind<G>().toValue(g);
container.bind<DependOnABCDEFG>().toFactory7<A, B, C, D, E, F, G>(
(a, b, c, d, e, f, g) => DependOnABCDEFG(a, b, c, d, e, f, g));
expect(container.resolve<DependOnABCDEFG>().a, a);
expect(container.resolve<DependOnABCDEFG>().b, b);
expect(container.resolve<DependOnABCDEFG>().c, c);
expect(container.resolve<DependOnABCDEFG>().d, d);
expect(container.resolve<DependOnABCDEFG>().e, e);
expect(container.resolve<DependOnABCDEFG>().f, f);
expect(container.resolve<DependOnABCDEFG>().g, g);
});
test("Bind to the factory resolves with 8 value", () {
final container = DiContainer();
final a = AA();
final b = BB();
final c = CC();
final d = DD();
final e = EE();
final f = FF();
final g = GG();
final h = HH();
container.bind<A>().toValue(a);
container.bind<B>().toValue(b);
container.bind<C>().toValue(c);
container.bind<D>().toValue(d);
container.bind<E>().toValue(e);
container.bind<F>().toValue(f);
container.bind<G>().toValue(g);
container.bind<H>().toValue(h);
container.bind<DependOnABCDEFGH>().toFactory8<A, B, C, D, E, F, G, H>(
(a, b, c, d, e, f, g, h) => DependOnABCDEFGH(a, b, c, d, e, f, g, h));
expect(container.resolve<DependOnABCDEFGH>().a, a);
expect(container.resolve<DependOnABCDEFGH>().b, b);
expect(container.resolve<DependOnABCDEFGH>().c, c);
expect(container.resolve<DependOnABCDEFGH>().d, d);
expect(container.resolve<DependOnABCDEFGH>().e, e);
expect(container.resolve<DependOnABCDEFGH>().f, f);
expect(container.resolve<DependOnABCDEFGH>().g, g);
expect(container.resolve<DependOnABCDEFGH>().h, h);
});
}
ResolverMock<T> _makeResolver<T>(T expectedValue) {
final resolverMock = new ResolverMock<T>();
when(resolverMock.resolve()).thenReturn(expectedValue);
return resolverMock;
}
class ResolverMock<T> extends Mock implements Resolver<T> {}
abstract class A {}
class AA implements A {}
abstract class B {}
class BB implements B {}
abstract class C {}
class CC implements C {}
abstract class D {}
class DD implements D {}
abstract class E {}
class EE implements E {}
abstract class F {}
class FF implements F {}
abstract class G {}
class GG implements G {}
abstract class H {}
class HH implements H {}
class DependOnA {
final A a;
DependOnA(this.a) : assert(a != null);
}
class DependOnAB {
final A a;
final B b;
DependOnAB(this.a, this.b) : assert(a != null && b != null);
}
class DependOnABC {
final A a;
final B b;
final C c;
DependOnABC(this.a, this.b, this.c)
: assert(a != null && b != null && c != null);
}
class DependOnABCD {
final A a;
final B b;
final C c;
final D d;
DependOnABCD(this.a, this.b, this.c, this.d)
: assert(a != null && b != null && c != null && d != null);
}
class DependOnABCDE {
final A a;
final B b;
final C c;
final D d;
final E e;
DependOnABCDE(this.a, this.b, this.c, this.d, this.e)
: assert(a != null && b != null && c != null && d != null && e != null);
}
class DependOnABCDEF {
final A a;
final B b;
final C c;
final D d;
final E e;
final F f;
DependOnABCDEF(this.a, this.b, this.c, this.d, this.e, this.f)
: assert(a != null &&
b != null &&
c != null &&
d != null &&
e != null &&
f != null);
}
class DependOnABCDEFG {
final A a;
final B b;
final C c;
final D d;
final E e;
final F f;
final G g;
DependOnABCDEFG(this.a, this.b, this.c, this.d, this.e, this.f, this.g)
: assert(a != null &&
b != null &&
c != null &&
d != null &&
e != null &&
f != null &&
g != null);
}
class DependOnABCDEFGH {
final A a;
final B b;
final C c;
final D d;
final E e;
final F f;
final G g;
final H h;
DependOnABCDEFGH(
this.a, this.b, this.c, this.d, this.e, this.f, this.g, this.h)
: assert(a != null &&
b != null &&
c != null &&
d != null &&
e != null &&
f != null &&
g != null &&
h != null);
}

27
test/resolvers/factory_resolver_test.dart
View File

@@ -1,27 +0,0 @@
import 'package:dart_di/resolvers/factory_resolver.dart';
import 'package:test/test.dart';
import 'package:mockito/mockito.dart' as mockito;
void main() {
test('Factory resolver resolves with factory', () {
const expected = 3;
final factoryResolver = new FactoryResolver(() => expected);
expect(factoryResolver.resolve(), expected);
});
test('Factory creates value only after resolve() call', () {
final spy = new SpyMock();
final factoryResolver = new FactoryResolver(() => spy.onFactory());
mockito.verifyNever(spy.onFactory());
factoryResolver.resolve();
mockito.verify(spy.onFactory());
});
}
abstract class Spy {
void onFactory();
}
class SpyMock extends mockito.Mock implements Spy {}

36
test/resolvers/singelton_resolver_test.dart
View File

@@ -1,36 +0,0 @@
import 'package:dart_di/resolvers/factory_resolver.dart';
import 'package:dart_di/resolvers/singelton_resolver.dart';
import 'package:test/test.dart';
import 'package:mockito/mockito.dart' as mockito;
void main() {
test(
'Not singleton resolver resolves different values after multiple resolve() calls',
() {
const callCount = 3;
final spy = new SpyMock();
final factoryResolver = new FactoryResolver(() => spy..onFactory());
for (var i = 0; i < callCount; i++) factoryResolver.resolve();
mockito.verify(spy.onFactory()).called(callCount);
});
test('Singleton resolver resolves same value after multiple resolve() calls',
() {
const callCount = 3;
final spy = new SpyMock();
final singletonResolver =
new SingletonResolver(new FactoryResolver(() => spy..onFactory()));
for (var i = 0; i < callCount; i++) singletonResolver.resolve();
mockito.verify(spy.onFactory()).called(1);
});
}
abstract class Spy {
void onFactory();
}
class SpyMock extends mockito.Mock implements Spy {}

11
test/resolvers/value_resolver_test.dart
View File

@@ -1,11 +0,0 @@
import 'package:dart_di/resolvers/value_resolver.dart';
import 'package:test/test.dart';
void main() {
test('Value resolver resolves with selected value', () {
var a = 3;
final valResolver = new ValueResolver(a);
expect(valResolver.resolve(), a);
});
}

4
test/experimental/scope_test.dart → test/scope_test.dart
View File

@@ -1,5 +1,5 @@
import 'package:dart_di/experimental/module.dart';
import 'package:dart_di/experimental/scope.dart';
import 'package:dart_di/module.dart';
import 'package:dart_di/scope.dart';
import 'package:test/test.dart';
void main() {