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));
}
