public static TConfiguration Add <TConfiguration>(this ListConfiguration <TConfiguration, VirtualType> source, params Func <VirtualTypeBuilder, VirtualType>[] typeBuilders ) => source.Add( typeBuilders.Select(builder => builder(BuildRoutine.VirtualType()) ) );
public void When_invocation_fails_and_second_interceptor_handles_the_exception__first_interceptor_does_not_know_about_the_exception() { var interceptor = new ChainInterceptor <Context>(); interceptor.Add(BuildRoutine.Interceptor <Context>().Do() .Before(ctx => ctx.Value += " - before1") .Success(ctx => ctx.Value += " - success1") .After(ctx => ctx.Value += " - after1")); interceptor.Add(BuildRoutine.Interceptor <Context>().Do() .Before(ctx => ctx.Value += " - before2") .Fail(ctx => { ctx.Value += " - fail2 (handled)"; ctx.ExceptionHandled = true; ctx.Result = "result2"; }) .After(ctx => ctx.Value += " - after2")); var testing = interceptor; invocation.Context.Value = "begin"; invocation.FailsWith(new Exception()); var actual = invocation.Intercept(testing); Assert.AreEqual("result2", actual); Assert.AreEqual("begin - before1 - before2 - fail2 (handled) - after2 - success1 - after1", invocation.Context.Value); Assert.AreEqual(1, invocation.Count); }
public void Refreshes_added_types_within_coding_style_when_a_new_type_is_added_so_that_old_IType_instances_are_not_stored() { var codingStyle = BuildRoutine.CodingStyle().FromBasic() .AddTypes(typeof(CachedBusiness)) .IdExtractor.Set(c => c.IdByProperty(m => m.Returns <string>("Id"))) .Locator.Set(c => c.Locator(l => l.Constant(null))) .ValueExtractor.Set(c => c.Value(e => e.By(obj => $"{obj}"))); var testing = new DefaultCoreContext(codingStyle, new DictionaryCache()); testing.GetDomainTypes(); var expected = testing.GetDomainType(type.of <CachedBusiness>()); codingStyle.AddTypes(typeof(LaterAddedType)); testing = new DefaultCoreContext(codingStyle, new DictionaryCache()); testing.GetDomainTypes(); var actual = testing.GetDomainType(type.of <CachedBusiness>()); Assert.AreNotSame(expected.Type, actual.Type); }
public override void SetUp() { base.SetUp(); objectRepository = new Dictionary <string, object>(); codingStyle = BuildRoutine.CodingStyle().FromBasic() .AddTypes(GetType().Assembly, t => t.IsPublic && t.Namespace != null && t.Namespace.StartsWith(RootNamespace)) .Initializers.Add(c => c.Constructors().When(t => t.IsValueType && t.Namespace?.StartsWith(RootNamespace) == true)) .Datas.Add(c => c.PublicProperties(m => !m.IsInherited()).When(t => t.Namespace?.StartsWith(RootNamespace) == true)) .Operations.Add(c => c.PublicMethods(m => !m.IsInherited()).When(t => t.Namespace?.StartsWith(RootNamespace) == true)) .IdExtractor.Set(c => c.IdByProperty(p => p.Returns <string>("Id")).When(t => t.Namespace != null && t.Namespace.StartsWith(RootNamespace))) .Locator.Set(c => c.Locator(l => l.SingleBy(id => objectRepository[id])).When(t => t.Namespace != null && t.Namespace.StartsWith(RootNamespace) && t.Properties.Any(m => m.Returns <string>("Id")))) .NextLayer() ; var cache = new DictionaryCache(); ctx = new DefaultCoreContext(codingStyle, cache); testing = new ObjectService(ctx, cache); }
public void Facade__Can_return_constant_result_no_matter_what() { IConvention <string, string> testing = BuildRoutine.Convention <string, string>().Constant("constant_result"); Assert.AreEqual("constant_result", testing.Apply("test1")); Assert.AreEqual("constant_result", testing.Apply("test2")); }
public void When_first_interceptor_fails_on_success__second_interceptor_does_not_know_about_the_exception() { var interceptor = new ChainInterceptor <Context>(); interceptor.Add(BuildRoutine.Interceptor <Context>().Do() .Before(ctx => ctx.Value += " - before1") .Success(ctx => { ctx.Value += " - success1"; throw new Exception(); }) .Fail(ctx => ctx.Value += " - fail1") .After(ctx => ctx.Value += " - after1")); interceptor.Add(BuildRoutine.Interceptor <Context>().Do() .Before(ctx => ctx.Value += " - before2") .Success(ctx => ctx.Value += " - success2") .After(ctx => ctx.Value += " - after2")); var testing = interceptor; invocation.Context.Value = "begin"; invocation.Returns("actual"); Assert.Throws <Exception>(() => invocation.Intercept(testing)); Assert.AreEqual("begin - before1 - before2 - success2 - after2 - success1 - fail1 - after1", invocation.Context.Value); Assert.AreEqual(1, invocation.Count); }
public void First_added_interceptor_wraps_the_second_one_and_invocation_happens_last() { var interceptor = new ChainInterceptor <Context>(); interceptor.Add(BuildRoutine.Interceptor <Context>().Do() .Before(ctx => ctx.Value += " - before1") .Success(ctx => ctx.Value += " - success1") .After(ctx => ctx.Value += " - after1")); interceptor.Add(BuildRoutine.Interceptor <Context>().Do() .Before(ctx => ctx.Value += " - before2") .Success(ctx => ctx.Value += " - success2") .After(ctx => ctx.Value += " - after2")); var testing = interceptor; invocation.Context.Value = "begin"; invocation.Returns("actual"); var actual = invocation.Intercept(testing); Assert.AreEqual("actual", actual); Assert.AreEqual("begin - before1 - before2 - success2 - after2 - success1 - after1", invocation.Context.Value); Assert.AreEqual(1, invocation.Count); }
public void Can_be_itself_and_object() { IType testing = BuildRoutine.VirtualType().FromBasic(); Assert.IsTrue(testing.CanBe(type.of <object>())); Assert.IsFalse(testing.CanBe(type.of <string>())); }
public void When_return_type_is_virtual__virtual_type_is_used_for_result_validation() { var vt = BuildRoutine.VirtualType().FromBasic() .Name.Set("VirtualType") .Namespace.Set("Virtual") .ToStringMethod.Set(o => o.Id) ; IMethod testing = new VirtualMethod(type.of <string>()) .Name.Set("VirtualMethod") .ReturnType.Set(vt) .Body.Set((target, _) => { if (Equals(target, "test")) { return(new VirtualObject((string)target, vt)); } return(target); }) ; var actual = testing.PerformOn("test"); Assert.AreEqual(new VirtualObject("test", vt), actual); Assert.Throws <InvalidCastException>(() => testing.PerformOn("dummy")); }
public void SetUp() { objectRepository = new Dictionary <string, object>(); ReflectionOptimizer.Enable(); var apiCtx = BuildRoutine.Context() .AsClientApplication( codingStyle = BuildRoutine.CodingStyle() .FromBasic() .AddCommonSystemTypes() .AddTypes(GetType().Assembly, t => t.Namespace?.StartsWith("Routine.Test.Performance.Domain") == true) .Use(p => p.ParseableValueTypePattern()) .Initializers.Add(c => c.PublicConstructors().When(type.of <BusinessPerformanceInput>())) .Datas.Add(c => c.Properties(m => !m.IsInherited(true, true))) .DataFetchedEagerly.Set(true) .Operations.Add(c => c.Methods(o => !o.IsInherited(true, true))) .IdExtractor.Set(c => c.IdByProperty(m => m.Returns <int>("Id"))) .Locator.Set(c => c.Locator(l => l.SingleBy(id => objectRepository[id]))) .ValueExtractor.Set(c => c.Value(e => e.By(o => $"{o}"))) ); objectService = apiCtx.ObjectService; rapp = apiCtx.Application; var _ = objectService.ApplicationModel; }
public void Facade_By_IType__List_IType_and_Func_IType() { Assert.AreEqual("success", ((IConverter)BuildRoutine.Converter().By(() => type.of <string>(), (_, _) => "success")).Convert(0, type.of <int>(), type.of <string>())); Assert.AreEqual("success", ((IConverter)BuildRoutine.Converter().By(type.of <string>(), (_, _) => "success")).Convert(0, type.of <int>(), type.of <string>())); Assert.AreEqual("success", ((IConverter)BuildRoutine.Converter().By(new List <IType> { type.of <string>() }, (_, _) => "success")).Convert(0, type.of <int>(), type.of <string>())); }
public void Does_not_cover_void__non_value_types_and_generic_types() { IConverter converter = BuildRoutine.Converter().ToNullable(); Assert.IsEmpty(converter.GetTargetTypes(type.ofvoid())); Assert.IsEmpty(converter.GetTargetTypes(type.of <string>())); Assert.IsEmpty(converter.GetTargetTypes(type.of <int?>())); }
public static IServiceContext AsServiceApplication( this ContextBuilder source, Func <ServiceConfigurationBuilder, IServiceConfiguration> serviceConfiguration, Func <CodingStyleBuilder, ICodingStyle> codingStyle ) => source.AsServiceApplication( serviceConfiguration(BuildRoutine.ServiceConfig()), codingStyle(BuildRoutine.CodingStyle()) );
public IEnumerable <IMethod> TargetByParameter <TConcrete>(string parameterName) where TConcrete : T => methods.Select(o => Build(parentType, o, (_, parameters) => parameters[0], BuildRoutine.Parameter(o).Virtual() .ParameterType.Set(type.of <TConcrete>()) .Name.Set(parameterName) ) );
public static ConventionBase <IType, IIdExtractor> IdByMethod( this ConventionBuilder <IType, IIdExtractor> source, Func <IMethod, bool> filter, Func <PropertyValueExtractor, PropertyValueExtractor> configurationDelegate ) => source.By(t => configurationDelegate(BuildRoutine.IdExtractor() .ByPropertyValue(new MethodAsProperty( t.Methods.First(filter.And(o => o.HasNoParameters() && !o.ReturnsVoid())) )) )).When(t => t.Methods.Any(filter.And(o => o.HasNoParameters() && !o.ReturnsVoid()))) as DelegateBasedConvention <IType, IIdExtractor>;
public void FullName_is_built_using_namespace_and_name() { IType testing = BuildRoutine.VirtualType().FromBasic() .Name.Set("Test") .Namespace.Set("Routine") ; Assert.AreEqual("Routine.Test", testing.FullName); }
public void Cannot_cast_to_a_real_type() { IType testing = BuildRoutine.VirtualType().FromBasic() .DefaultInstanceId.Set("Id") .Name.Set("Virtual") .Namespace.Set("Routine") ; Assert.Throws <InvalidCastException>(() => testing.Cast(testing.CreateInstance(), type.of <string>())); }
public void Creates_virtual_object() { IType testing = BuildRoutine.VirtualType().FromBasic() .DefaultInstanceId.Set("default") ; var actual = testing.CreateInstance(); Assert.IsInstanceOf <VirtualObject>(actual); Assert.AreEqual("default", ((VirtualObject)actual).Id); }
public void Methods_are_created_externally_and_added_to_type() { var mockMethod = new Mock <IMethod>(); IType testing = BuildRoutine.VirtualType().FromBasic() .Methods.Add(mockMethod.Object) ; Assert.AreEqual(1, testing.Methods.Count); Assert.AreSame(mockMethod.Object, testing.Methods[0]); }
public void Throws_CannotConvertException_when_given_type_cannot_be_converted_to_target_type() { var typeMock = new Mock <IType>(); typeMock.Setup(t => t.AssignableTypes).Returns(new List <IType>()); typeMock.Setup(t => t.Cast(It.IsAny <object>(), type.of <string>())).Throws <InvalidCastException>(); IConverter converter = BuildRoutine.Converter().ByCasting(); Assert.Throws <CannotConvertException>(() => converter.Convert(0, typeMock.Object, type.of <string>())); }
public void By_default__to_string_returns_Id_and_virtual_type_name() { IType testing = BuildRoutine.VirtualType().FromBasic() .DefaultInstanceId.Set("default") .Namespace.Set("Namespace") .Name.Set("Name") ; var actual = testing.CreateInstance(); Assert.AreEqual("default (Namespace.Name)", actual.ToString()); }
public void Casts_a_virtual_object_to_object() { IType testing = BuildRoutine.VirtualType().FromBasic() .DefaultInstanceId.Set("Id") .Name.Set("Virtual") .Namespace.Set("Routine") ; var instance = testing.CreateInstance(); Assert.AreSame(instance, testing.Cast(instance, type.of <object>())); }
public void Converts_value_types_to_their_nullable_types() { IConverter converter = BuildRoutine.Converter().ToNullable(); Assert.AreEqual(type.of <int?>(), converter.GetTargetTypes(type.of <int>())[0]); var actual = converter.Convert(3, type.of <int>(), type.of <int?>()); int?expected = 3; Assert.AreEqual(expected, actual); }
public void Namespace_is_required() { IType testing = BuildRoutine.VirtualType().FromBasic() .Namespace.Set("Routine") ; Assert.AreEqual("Routine", testing.Namespace); testing = BuildRoutine.VirtualType().FromBasic(); Assert.Throws <ConfigurationException>(() => { var dummy = testing.Namespace; }); }
public void IsInterface_is_optional__default_is_false() { IType testing = BuildRoutine.VirtualType().FromBasic() .IsInterface.Set(true) ; Assert.IsTrue(testing.IsInterface); testing = BuildRoutine.VirtualType().FromBasic(); Assert.IsFalse(testing.IsInterface); }
public void When_an_interface_has_a_default_method__it_can_be_an_operation_of_its_view_model() { var testing = BuildRoutine.CodingStyle().FromBasic(); testing.AddTypes(typeof(IAnInterface), typeof(AClass)); testing.Operations.Add(c => c.PublicMethods().When(type.of <IAnInterface>())); var operations = ((ICodingStyle)testing).GetOperations(type.of <IAnInterface>()); Assert.AreEqual(1, operations.Count); Assert.AreEqual(nameof(IAnInterface.DefaultMethodOp), operations[0].Name); }
public void When_configuring_nullable_types__type_and_module_names_come_from_the_type_that_is_nullable() { var testing = BuildRoutine.CodingStyle().FromBasic() as ICodingStyle; Assert.AreEqual("Int32?", testing.GetName(type.of <int?>())); Assert.AreEqual("System", testing.GetModule(type.of <int?>())); Assert.AreEqual("DateTime?", testing.GetName(type.of <DateTime?>())); Assert.AreEqual("System", testing.GetModule(type.of <DateTime?>())); Assert.AreEqual("Text?", testing.GetName(type.of <Text?>())); Assert.AreEqual("Routine.Test", testing.GetModule(type.of <Text?>())); }
public void Converts_object_to_target_type_using_cast_method_of_IType() { var typeMock = new Mock <IType>(); typeMock.Setup(t => t.Cast(It.IsAny <object>(), type.of <string>())).Returns("success"); typeMock.Setup(t => t.AssignableTypes).Returns(new List <IType> { type.of <string>() }); IConverter converter = BuildRoutine.Converter().ByCasting(); Assert.AreEqual("success", converter.Convert(0, typeMock.Object, type.of <string>())); }
public void Converts_object_to_target_type_using_given_delegate() { IConverter converter = BuildRoutine.Converter().By(() => new List <IType> { type.of <string>() }, (o, t) => { Assert.AreEqual(0, o); Assert.AreEqual(type.of <string>(), t); return("success"); }); Assert.AreEqual("success", converter.Convert(0, type.of <int>(), type.of <string>())); }
public void Cannot_cast_to_a_virtual_type_that_is_not_in_assignable_types() { var virtualInterface = BuildRoutine.VirtualType().FromBasic() .Name.Set("IVirtual") .Namespace.Set("Routine") .IsInterface.Set(true); IType testing = BuildRoutine.VirtualType().FromBasic() .DefaultInstanceId.Set("Id") .Name.Set("Virtual") .Namespace.Set("Routine") ; Assert.Throws <InvalidCastException>(() => testing.Cast(testing.CreateInstance(), virtualInterface)); }