public BrowserEventDispatcher(FormatterContainer formatters, ILogFactory logFactory)
{
Ensure.NotNull(formatters, "formatters");
Ensure.NotNull(logFactory, "logFactory");
this.formatters = formatters;
this.log = logFactory.Scope("BrowserEventDispatcher");
}
public HttpCommandDispatcher(ApiClient api, FormatterContainer formatters)
{
Ensure.NotNull(api, "api");
Ensure.NotNull(formatters, "formatters");
this.api = api;
this.formatters = formatters;
}
public ApiHub(IEventHandlerCollection eventHandlers, FormatterContainer formatters, ExceptionHandlerBuilder exceptionHandlerBuilder)
{
Ensure.NotNull(eventHandlers, "eventHandlers");
Ensure.NotNull(formatters, "formatters");
this.formatters = formatters;
eventHandlers.AddAll(this);
exceptionHandlerBuilder.Filter <AggregateRootException>().Handler(this);
}
public ApiController(FormatterContainer formatters, ICommandDispatcher commandDispatcher, IQueryDispatcher queryDispatcher)
{
Ensure.NotNull(formatters, "formatters");
Ensure.NotNull(commandDispatcher, "commandDispatcher");
Ensure.NotNull(queryDispatcher, "queryDispatcher");
this.formatters = formatters;
this.commandDispatcher = commandDispatcher;
this.queryDispatcher = queryDispatcher;
}
public void Configuration_Null_Configurator_Throws_NullArgumentException()
{
// Arrange
// Act
TestDelegate test = () => FormatterContainer.Create(null);
// Assert
Assert.That(test, Throws.ArgumentNullException);
}
public HttpQueryDispatcher(ApiClient api, FormatterContainer formatters, ILogFactory logFactory, IEnumerable <IMiddleware> middlewares)
{
Ensure.NotNull(api, "api");
Ensure.NotNull(formatters, "formatters");
Ensure.NotNull(logFactory, "logFactory");
Ensure.NotNull(middlewares, "middlewares");
this.api = api;
this.formatters = formatters;
this.middlewares = middlewares;
this.log = logFactory.Scope("HttpQueryDispatcher");
}
public void Initialize()
{
ILogFilter logFilter = DefaultLogFilter.Warning;
#if DEBUG
logFilter = PrefixLogFilter.Ignored(new[] {
"Root.Json",
"Root.CompositeListFormatter",
"Root.ApiClient",
"Root.ApiAuthenticationState"
});
#endif
logFactory = new DefaultLogFactory("Root")
.AddSerializer(new ConsoleSerializer(new SingleLineLogFormatter(), logFilter));
Json json = new Json();
Domain(json);
//priceCalculator = new PriceCalculator(eventDispatcher.Handlers);
FormatterContainer formatters = new FormatterContainer(commandFormatter, eventFormatter, queryFormatter, exceptionFormatter);
eventDispatcher = new BrowserEventDispatcher(formatters, logFactory, json);
BrowserExceptionHandler exceptionHandler = new BrowserExceptionHandler(formatters, logFactory, json);
services
//.AddSingleton(priceCalculator)
.AddSingleton(json)
.AddSingleton(formatters)
.AddSingleton(logFactory)
.AddTransient <CurrencyFormatterFactory>()
.AddSingleton <MessageBuilder>()
.AddScoped <LocalExpenseOnlineRunner>()
.AddTransient <HttpCommandDispatcher>()
.AddTransient <CommandStorage>()
.AddTransient <CreateExpenseStorage>()
.AddTransient <OfflineCommandDispatcher>()
.AddSingleton <LocalCommandDispatcher>()
.AddSingleton <MenuItemService>()
.AddSingleton <ICommandHandlerCollection, LocalCommandHandlerCollection>()
.AddTransient <ICommandDispatcher, LocalCommandDispatcher>()
.AddTransient <IQueryDispatcher, HttpQueryDispatcher>()
.AddTransient(typeof(ILog <>), typeof(DefaultLog <>))
.AddSingleton(eventDispatcher)
.AddSingleton(eventDispatcher.Handlers)
.AddSingleton(eventDispatcher.Dispatcher)
.AddSingleton(exceptionHandler)
.AddSingleton(exceptionHandler.Handler)
.AddSingleton(exceptionHandler.HandlerBuilder);
void AddMiddleware <T>(IServiceCollection services, bool register = true)
where T : class, HttpQueryDispatcher.IMiddleware
public void NullableValueTypesFormatNull_ReturnEmptyString_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.NullableValueTypesFormatNull = NullFormatHandling.ReturnEmptyString;
});
// Act
string result = formatter.For <int?>().Format(null);
// Assert
Assert.That(result, Is.EqualTo(""));
}
public void NullableValueTypesFormatNull_ThrowArgumentNullException_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.NullableValueTypesFormatNull = NullFormatHandling.ThrowArgumentNullException;
});
// Act
TestDelegate test = () => formatter.For <int?>().Format(null);
// Assert
Assert.That(test, Throws.TypeOf <ArgumentNullException>());
}
public void ReferenceTypesFormatNullToNull_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.ReferenceTypesFormatNullToNull = true;
});
// Act
string result = formatter.For <TestClass>().Format(null);
// Assert
Assert.That(result, Is.Null);
}
public void FormatSpecific_String_Func_Can_Replace_Default(string input, string expected)
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.UseFunc <string>(s => s.ToUpper(), (s, f) => s.ToUpper());
});
// Act
string result = formatter.For <string>().Format("hello?");
// Assert
Assert.That(result, Is.EqualTo("HELLO?"));
}
public ApiController(FormatterContainer formatters, ICommandDispatcher commandDispatcher, IQueryDispatcher queryDispatcher, CommandMapper commandMapper, QueryMapper queryMapper, Json json)
{
Ensure.NotNull(formatters, "formatters");
Ensure.NotNull(commandDispatcher, "commandDispatcher");
Ensure.NotNull(queryDispatcher, "queryDispatcher");
Ensure.NotNull(commandMapper, "commandMapper");
Ensure.NotNull(queryMapper, "queryMapper");
Ensure.NotNull(json, "json");
this.formatters = formatters;
this.commandDispatcher = commandDispatcher;
this.queryDispatcher = queryDispatcher;
this.commandMapper = commandMapper;
this.queryMapper = queryMapper;
this.json = json;
}
public void MissingFormatSpecific_UseToString_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.MissingFormatSpecific = MissingFormatSpecificHandling.UseToString;
});
var input = new TestClassWithoutFormatSpecific("anything");
// Act
string result = formatter.For <TestClassWithoutFormatSpecific>().Format(input, null);
// Assert
Assert.That(result, Is.EqualTo("anything"));
}
public void Format_Uses_Configured_Type_Converter(string input)
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.UseTypeConverter <TestClassWithTypeConverter>();
});
TestClassWithTypeConverter obj = new TestClassWithTypeConverter(input);
// Act
string result = formatter.For <TestClassWithTypeConverter>().Format(obj);
// Assert
Assert.That(result, Is.EqualTo(input));
}
public void MissingFormatSpecific_ThrowNotSupportedException_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.MissingFormatSpecific = MissingFormatSpecificHandling.ThrowNotSupportedException;
});
var input = new TestClassWithoutFormatSpecific("anything");
// Act
TestDelegate test = () => formatter.For <TestClassWithoutFormatSpecific>().Format(input, null);
// Assert
Assert.That(test, Throws.TypeOf <NotSupportedException>());
}
public void Configuration_Rejects_FormatFunc_For_NullableValueType()
{
// Arrange
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseFunc <int?>(v => "");
});
};
// Assert
}
public void Configuration_Rejects_FormatFunc_For_Delegate()
{
// Arrange
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseFunc <Func <int> >(v => "");
});
};
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_UseTypeConverter_Throws_If_Configuration_Locked()
{
// Arrange
FormatterConfiguration outerConfig = null;
FormatterContainer.Create(config =>
{
outerConfig = config;
});
// Act
TestDelegate test = () => outerConfig.UseTypeConverter <string>();
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_Null_FormatterObject_Throws_NullArgumentException()
{
// Arrange
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseFormatterObject <int>(null);
});
};
// Assert
Assert.That(test, Throws.ArgumentNullException);
}
public void Configuration_ReferenceTypesFormatNullToNull_Throws_If_Configuration_Locked()
{
// Arrange
FormatterConfiguration outerConfig = null;
FormatterContainer.Create(config =>
{
outerConfig = config;
});
// Act
TestDelegate test = () => outerConfig.ReferenceTypesFormatNullToNull = true;
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_NullableValueTypesFormatNull_Throws_If_Configuration_Locked()
{
// Arrange
FormatterConfiguration outerConfig = null;
FormatterContainer.Create(config =>
{
outerConfig = config;
});
// Act
TestDelegate test = () => outerConfig.NullableValueTypesFormatNull = NullFormatHandling.ReturnEmptyString;
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_Rejects_Mix_Of_Default_And_TypeConverter()
{
// Arrange
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseDefault <int>();
config.UseTypeConverter <int>();
});
};
// Assert
}
public void Configuration_MissingFormatSpecific_Throws_If_Configuration_Locked()
{
// Arrange
FormatterConfiguration outerConfig = null;
FormatterContainer.Create(config =>
{
outerConfig = config;
});
// Act
TestDelegate test = () => outerConfig.MissingFormatSpecific = MissingFormatSpecificHandling.ReturnEmptyString;
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_Rejects_Mix_Of_Default_And_FormatterObject()
{
// Arrange
Mock <IFormatter <int> > formatterObjectMock = new Mock <IFormatter <int> >();
IFormatter <int> formatterObject = formatterObjectMock.Object;
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseDefault <int>();
config.UseFormatterObject(formatterObject);
});
};
// Assert
}
public void Configuration_Rejects_FormatterObject_For_Interface()
{
// Arrange
Mock <IFormatter <IFormattable> > formatterObjectMock = new Mock <IFormatter <IFormattable> >();
IFormatter <IFormattable> formatterObject = formatterObjectMock.Object;
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseFormatterObject(formatterObject);
});
};
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_Rejects_Mix_Of_TypeConverter_And_FormatterObject()
{
// Arrange
Mock <IFormatter <int> > formatterObjectMock = new Mock <IFormatter <int> >();
IFormatter <int> formatterObject = formatterObjectMock.Object;
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseTypeConverter <int>();
config.UseFormatterObject(formatterObject);
});
};
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Initialize()
{
ILogFilter logFilter = DefaultLogFilter.Debug;
#if !DEBUG
logFilter = DefaultLogFilter.Warning;
#endif
logFactory = new DefaultLogFactory("Root")
.AddSerializer(new ConsoleSerializer(new SingleLineLogFormatter(), logFilter));
Domain();
//priceCalculator = new PriceCalculator(eventDispatcher.Handlers);
FormatterContainer formatters = new FormatterContainer(commandFormatter, eventFormatter, queryFormatter, exceptionFormatter);
BrowserEventDispatcher eventDispatcher = new BrowserEventDispatcher(formatters, logFactory);
BrowserExceptionHandler exceptionHandler = new BrowserExceptionHandler(formatters, logFactory);
services
//.AddSingleton(priceCalculator)
.AddSingleton(formatters)
.AddSingleton(logFactory)
.AddSingleton <MessageBuilder>()
.AddTransient <ICommandDispatcher, HttpCommandDispatcher>()
.AddTransient <IQueryDispatcher, HttpQueryDispatcher>()
.AddTransient(typeof(ILog <>), typeof(DefaultLog <>))
.AddSingleton(eventDispatcher)
.AddSingleton(eventDispatcher.Handlers)
.AddSingleton(eventDispatcher.Dispatcher)
.AddSingleton(exceptionHandler)
.AddSingleton(exceptionHandler.Handler)
.AddSingleton(exceptionHandler.HandlerBuilder);
QueryMiddlewares(eventDispatcher.Handlers);
//CurrencyCache currencyCache = new CurrencyCache(eventDispatcher.Handlers, queryDispatcher);
//services
// .AddSingleton(currencyCache);
//currencyCache.InitializeAsync(queryDispatcher);
//priceCalculator.InitializeAsync(queryDispatcher);
}
public void Initialize()
{
ILogFilter logFilter = DefaultLogFilter.Debug;
#if !DEBUG
logFilter = DefaultLogFilter.Warning;
#endif
logFactory = new DefaultLogFactory("Root")
.AddSerializer(new ConsoleSerializer(new SingleLineLogFormatter(), logFilter));
Json json = new Json();
Domain(json);
//priceCalculator = new PriceCalculator(eventDispatcher.Handlers);
FormatterContainer formatters = new FormatterContainer(commandFormatter, eventFormatter, queryFormatter, exceptionFormatter);
eventDispatcher = new BrowserEventDispatcher(formatters, logFactory, json);
BrowserExceptionHandler exceptionHandler = new BrowserExceptionHandler(formatters, logFactory, json);
services
//.AddSingleton(priceCalculator)
.AddSingleton(json)
.AddSingleton(formatters)
.AddSingleton(logFactory)
.AddSingleton <MessageBuilder>()
.AddTransient <ICommandDispatcher, HttpCommandDispatcher>()
.AddTransient <IQueryDispatcher, HttpQueryDispatcher>()
.AddTransient(typeof(ILog <>), typeof(DefaultLog <>))
.AddSingleton(eventDispatcher)
.AddSingleton(eventDispatcher.Handlers)
.AddSingleton(eventDispatcher.Dispatcher)
.AddSingleton(exceptionHandler)
.AddSingleton(exceptionHandler.Handler)
.AddSingleton(exceptionHandler.HandlerBuilder);
void AddMiddleware <T>(IServiceCollection services)
where T : class, HttpQueryDispatcher.IMiddleware
public void Format_FormatSpecific_String_FormatterObject_Can_Replace_Default(string input, string expected)
{
// Arrange
Mock <IFormatter <string> > stringFormatterMock = new Mock <IFormatter <string> >();
stringFormatterMock.Setup(m => m.Format(It.IsAny <string>()))
.Returns(new FormatReturns <string>(s => s.ToUpper()));
stringFormatterMock.Setup(m => m.Format(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new FormatSpecificReturns <string>((s, f) => s.ToUpper()));
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.UseFormatterObject(stringFormatterMock.Object);
});
// Act
string result1 = formatter.For <string>().Format(input);
string result2 = formatter.For <string>().Format(input, null);
// Assert
Assert.That(result1, Is.EqualTo(expected));
Assert.That(result2, Is.EqualTo(expected));
}
public DefaultMiddleware(ApiClient api, FormatterContainer formatters, ILog log)
{
this.api = api;
this.formatters = formatters;
this.log = log;
}
