示例#1
0
        public void UsingInitialImpl_resolves_impl_from_resolver(IResolver resolver, ServiceImpl1 impl)
        {
            var sut = new AutofacDecoratorBuilder(resolver, typeof(IServiceInterface));

            Mock.Get(resolver)
            .Setup(x => x.Resolve <ServiceImpl1>(It.IsAny <IEnumerable <Parameter> >()))
            .Returns(impl);

            var result = sut.UsingInitialImpl <ServiceImpl1>();

            Assert.That(result?.Implementation, Is.SameAs(impl));
        }
        public void ThenWrapWith_resolves_impl_from_resolver(IResolver resolver,
                                                             ServiceImpl2 impl,
                                                             ServiceImpl1 initialImpl)
        {
            var sut = new AutofacDecoratorCustomizer(resolver, typeof(IServiceInterface), initialImpl);

            Mock.Get(resolver)
            .Setup(x => x.Resolve <ServiceImpl2>(It.IsAny <IEnumerable <Parameter> >()))
            .Returns(impl);

            var result = sut.ThenWrapWith <ServiceImpl2>();

            Assert.That(result?.Implementation, Is.SameAs(impl));
        }
示例#3
0
        public void UsingInitialImpl_passes_params_to_resolver(IResolver resolver,
                                                               ServiceImpl1 impl,
                                                               Parameter[] parameters)
        {
            var sut = new AutofacDecoratorBuilder(resolver, typeof(IServiceInterface));

            Mock.Get(resolver)
            .Setup(x => x.Resolve <ServiceImpl1>(parameters))
            .Returns(impl);

            var result = sut.UsingInitialImpl <ServiceImpl1>(parameters);

            Assert.That(result?.Implementation, Is.SameAs(impl));
        }
示例#4
0
        public void UsingInitialImplType_passes_params_to_resolver(IResolver resolver,
                                                                   ServiceImpl1 impl,
                                                                   Parameter[] parameters)
        {
            var sut = new AutofacGenericDecoratorBuilder <IServiceInterface>(resolver);

            Mock.Get(resolver)
            .Setup(x => x.Resolve(typeof(ServiceImpl1), parameters))
            .Returns(impl);

            var result = (AutofacGenericDecoratorCustomizer <IServiceInterface>)sut.UsingInitialImplType(typeof(ServiceImpl1), parameters);

            Assert.That(result?.Implementation, Is.SameAs(impl));
        }
        public void ThenWrapWith_passes_impl_to_resolver_as_parameter(IResolver resolver,
                                                                      ServiceImpl2 impl,
                                                                      Parameter[] parameters,
                                                                      ServiceImpl1 initialImpl)
        {
            var sut = new AutofacDecoratorCustomizer(resolver, typeof(IServiceInterface), initialImpl);

            Mock.Get(resolver)
            .Setup(x => x.Resolve <ServiceImpl2>(It.Is <IEnumerable <Parameter> >(p => p.OfType <TypedParameter>().Any(a => a.Type == typeof(IServiceInterface) && a.Value == initialImpl))))
            .Returns(impl);

            var result = sut.ThenWrapWith <ServiceImpl2>(parameters);

            Assert.That(result?.Implementation, Is.SameAs(impl));
        }
        public void ThenWrapWith_passes_params_to_resolver(IResolver resolver,
                                                           ServiceImpl2 impl,
                                                           Parameter[] parameters,
                                                           ServiceImpl1 initialImpl)
        {
            var sut = new AutofacDecoratorCustomizer(resolver, typeof(IServiceInterface), initialImpl);

            Mock.Get(resolver)
            .Setup(x => x.Resolve <ServiceImpl2>(It.Is <IEnumerable <Parameter> >(p => parameters.All(y => p.Contains(y)))))
            .Returns(impl);

            var result = sut.ThenWrapWith <ServiceImpl2>(parameters);

            Assert.That(result?.Implementation, Is.SameAs(impl));
        }
        public void ThenWrapWith_throws_exception_if_generic_impl_does_not_derive_from_service(IResolver resolver,
                                                                                               ServiceImpl1 initialImpl)
        {
            var sut = new AutofacDecoratorCustomizer(resolver, typeof(IServiceInterface), initialImpl);

            Assert.That(() => sut.ThenWrapWith <DifferentImpl>(), Throws.ArgumentException);
        }
示例#8
0
        public void UsingInitialImplType_resolves_impl_from_resolver(IResolver resolver, ServiceImpl1 impl)
        {
            var sut = new AutofacGenericDecoratorBuilder <IServiceInterface>(resolver);

            Mock.Get(resolver)
            .Setup(x => x.Resolve(typeof(ServiceImpl1), It.IsAny <IEnumerable <Parameter> >()))
            .Returns(impl);

            var result = (AutofacGenericDecoratorCustomizer <IServiceInterface>)sut.UsingInitialImplType(typeof(ServiceImpl1));

            Assert.That(result?.Implementation, Is.SameAs(impl));
        }
示例#9
0
        public void ThenWrapWithType_throws_exception_if_impl_type_does_not_derive_from_service(IResolver resolver,
                                                                                                ServiceImpl1 initialImpl)
        {
            var wrapped = new AutofacDecoratorCustomizer(resolver, typeof(IServiceInterface), initialImpl);
            var sut     = new AutofacGenericDecoratorCustomizer <IServiceInterface>(wrapped, initialImpl);

            Assert.That(() => sut.ThenWrapWithType(typeof(DifferentImpl)), Throws.ArgumentException);
        }
 public ResolveByClassUnification(ServiceImpl1 s1)
 {
 }