public void should_add_skipped_automap_types_to_result()
{
var despatcher = Mock <IDiagnosticMessageDespatcher> .Create();
var logger = new DefaultDiagnosticLogger(despatcher);
logger.AutomappingSkippedType(typeof(object), "reason");
logger.Flush();
DiagnosticResults result = null;
despatcher.AssertWasCalled(x => x.Publish(Arg <DiagnosticResults> .Is.Anything),
c => c.Callback <DiagnosticResults>(x =>
{
result = x;
return(true);
}));
result.AutomappingSkippedTypes
.ShouldContain(new SkippedAutomappingType
{
Type = typeof(object),
Reason = "reason"
});
}
public void should_format_results()
{
var results = new DiagnosticResults(new ScannedSource[0], new Type[0], new Type[0], new SkippedAutomappingType[0], new Type[0], new AutomappingType[0]);
var formatter = A.Fake <IDiagnosticResultsFormatter>();
var listener = new StringLambdaOutputListener(x => { });
listener.SetFormatter(formatter);
listener.Receive(results);
A.CallTo(() => formatter.Format(results)).MustHaveHappened();
}
public void should_format_results()
{
var results = new DiagnosticResults(new ScannedSource[0], new Type[0], new Type[0], new SkippedAutomappingType[0], new Type[0], new AutomappingType[0]);
var formatter = Mock <IDiagnosticResultsFormatter> .Create();
var listener = new StringLambdaOutputListener(x => { });
listener.SetFormatter(formatter);
listener.Receive(results);
formatter.AssertWasCalled(x => x.Format(results));
}
public void should_publish_results_to_all_listeners()
{
var firstListener = A.Fake <IDiagnosticListener>();
var secondListener = A.Fake <IDiagnosticListener>();
var results = new DiagnosticResults(new ScannedSource[0], new Type[0], new Type[0], new SkippedAutomappingType[0], new Type[0], new AutomappingType[0]);
dispatcher.RegisterListener(firstListener);
dispatcher.RegisterListener(secondListener);
dispatcher.Publish(results);
A.CallTo(() => firstListener.Receive(results)).MustHaveHappened();
A.CallTo(() => secondListener.Receive(results)).MustHaveHappened();
}
public void should_add_conventions_to_result()
{
var dispatcher = A.Fake <IDiagnosticMessageDispatcher>();
var logger = new DefaultDiagnosticLogger(dispatcher);
DiagnosticResults result = null;
A.CallTo(() => dispatcher.Publish(A <DiagnosticResults> ._))
.Invokes(a => { result = (DiagnosticResults)a.Arguments.First(); });
logger.ConventionDiscovered(typeof(SomeConvention));
logger.Flush();
result.Conventions.ShouldContain(typeof(SomeConvention));
}
public void should_raise_formatted_results()
{
var results = new DiagnosticResults(new ScannedSource[0], new Type[0], new Type[0], new SkippedAutomappingType[0], new Type[0], new AutomappingType[0]);
var output = "formatted output";
var receivedOutput = "";
var formatter = A.Fake <IDiagnosticResultsFormatter>();
A.CallTo(() => formatter.Format(results)).Returns(output);
var listener = new StringLambdaOutputListener(x => { receivedOutput = x; });
listener.SetFormatter(formatter);
listener.Receive(results);
receivedOutput.ShouldEqual(output);
}
public void should_publish_results_to_all_listeners()
{
var firstListener = Mock <IDiagnosticListener> .Create();
var secondListener = Mock <IDiagnosticListener> .Create();
var results = new DiagnosticResults(new ScannedSource[0], new Type[0], new Type[0], new SkippedAutomappingType[0], new Type[0], new AutomappingType[0]);
dispatcher.RegisterListener(firstListener);
dispatcher.RegisterListener(secondListener);
dispatcher.Publish(results);
firstListener.AssertWasCalled(x => x.Receive(results));
secondListener.AssertWasCalled(x => x.Receive(results));
}
public void should_add_automapping_candidates()
{
var dispatcher = A.Fake <IDiagnosticMessageDispatcher>();
var logger = new DefaultDiagnosticLogger(dispatcher);
DiagnosticResults result = null;
A.CallTo(() => dispatcher.Publish(A <DiagnosticResults> ._))
.Invokes(a => { result = (DiagnosticResults)a.Arguments.First(); });
logger.AutomappingCandidateTypes(new[] { typeof(object) });
logger.Flush();
result.AutomappingCandidateTypes
.ShouldContain(typeof(object));
}
public void should_raise_formatted_results()
{
var results = new DiagnosticResults(new ScannedSource[0], new Type[0], new Type[0], new SkippedAutomappingType[0], new Type[0], new AutomappingType[0]);
var output = "formatted output";
var receivedOutput = "";
var formatter = Stub <IDiagnosticResultsFormatter> .Create(sb =>
sb.Stub(x => x.Format(results))
.Return(output));
var listener = new StringLambdaOutputListener(x => { receivedOutput = x; });
listener.SetFormatter(formatter);
listener.Receive(results);
receivedOutput.ShouldEqual(output);
}
public void should_add_automapping_type_with_begin()
{
var dispatcher = A.Fake <IDiagnosticMessageDispatcher>();
var logger = new DefaultDiagnosticLogger(dispatcher);
DiagnosticResults result = null;
A.CallTo(() => dispatcher.Publish(A <DiagnosticResults> ._))
.Invokes(a => { result = (DiagnosticResults)a.Arguments.First(); });
logger.BeginAutomappingType(typeof(object));
logger.Flush();
result.AutomappedTypes
.Select(x => x.Type)
.ShouldContain(typeof(object));
}
public void should_add_scanned_convention_sources_to_result()
{
var dispatcher = A.Fake <IDiagnosticMessageDispatcher> ();
var logger = new DefaultDiagnosticLogger(dispatcher);
DiagnosticResults result = null;
A.CallTo(() => dispatcher.Publish(A <DiagnosticResults> ._))
.Invokes(a => { result = (DiagnosticResults)a.Arguments.First(); });
logger.LoadedConventionsFromSource(new StubTypeSource());
logger.Flush();
result.ScannedSources
.Where(x => x.Phase == ScanPhase.Conventions)
.Select(x => x.Identifier)
.ShouldContain("StubTypeSource");
}
public void should_add_skipped_automap_types_to_result()
{
var dispatcher = A.Fake <IDiagnosticMessageDispatcher>();
var logger = new DefaultDiagnosticLogger(dispatcher);
DiagnosticResults result = null;
A.CallTo(() => dispatcher.Publish(A <DiagnosticResults> ._))
.Invokes(a => { result = (DiagnosticResults)a.Arguments.First(); });
logger.AutomappingSkippedType(typeof(object), "reason");
logger.Flush();
result.AutomappingSkippedTypes
.ShouldContain(new SkippedAutomappingType
{
Type = typeof(object),
Reason = "reason"
});
}
public void should_add_conventions_to_result()
{
var despatcher = Mock <IDiagnosticMessageDespatcher> .Create();
var logger = new DefaultDiagnosticLogger(despatcher);
logger.ConventionDiscovered(typeof(SomeConvention));
logger.Flush();
DiagnosticResults result = null;
despatcher.AssertWasCalled(x => x.Publish(Arg <DiagnosticResults> .Is.Anything),
c => c.Callback <DiagnosticResults>(x =>
{
result = x;
return(true);
}));
result.Conventions.ShouldContain(typeof(SomeConvention));
}
public void should_add_automapping_candidates()
{
var despatcher = Mock <IDiagnosticMessageDespatcher> .Create();
var logger = new DefaultDiagnosticLogger(despatcher);
logger.AutomappingCandidateTypes(new[] { typeof(object) });
logger.Flush();
DiagnosticResults result = null;
despatcher.AssertWasCalled(x => x.Publish(Arg <DiagnosticResults> .Is.Anything),
c => c.Callback <DiagnosticResults>(x =>
{
result = x;
return(true);
}));
result.AutomappingCandidateTypes
.ShouldContain(typeof(object));
}
public void should_add_automapping_type_with_begin()
{
var despatcher = Mock <IDiagnosticMessageDespatcher> .Create();
var logger = new DefaultDiagnosticLogger(despatcher);
logger.BeginAutomappingType(typeof(object));
logger.Flush();
DiagnosticResults result = null;
despatcher.AssertWasCalled(x => x.Publish(Arg <DiagnosticResults> .Is.Anything),
c => c.Callback <DiagnosticResults>(x =>
{
result = x;
return(true);
}));
result.AutomappedTypes
.Select(x => x.Type)
.ShouldContain(typeof(object));
}
public void should_add_scanned_fluent_mapping_sources_to_result()
{
var despatcher = Mock <IDiagnosticMessageDespatcher> .Create();
var logger = new DefaultDiagnosticLogger(despatcher);
logger.LoadedFluentMappingsFromSource(new StubTypeSource());
logger.Flush();
DiagnosticResults result = null;
despatcher.AssertWasCalled(x => x.Publish(Arg <DiagnosticResults> .Is.Anything),
c => c.Callback <DiagnosticResults>(x =>
{
result = x;
return(true);
}));
result.ScannedSources
.Where(x => x.Phase == ScanPhase.FluentMappings)
.Select(x => x.Identifier)
.ShouldContain("StubTypeSource");
}
public void Receive(DiagnosticResults results)
{
var output = this.formatter.Format(results);
this.logger.Debug(output);
}
public void Receive(DiagnosticResults results)
{
receiver(results);
}
public void should_produce_simple_format()
{
var formatter = new DefaultOutputFormatter();
var results = new DiagnosticResults(new[]
{
new ScannedSource
{
Identifier = typeof(One).Assembly.GetName().FullName,
Phase = ScanPhase.FluentMappings
},
new ScannedSource
{
Identifier = typeof(One).Assembly.GetName().FullName,
Phase = ScanPhase.Conventions
}
},
new[] { typeof(Two), typeof(One) },
new[] { typeof(Two), typeof(One) },
new[]
{
new SkippedAutomappingType
{
Type = typeof(One),
Reason = "first reason"
},
new SkippedAutomappingType
{
Type = typeof(Two),
Reason = "second reason"
},
},
new[] { typeof(Two), typeof(One) },
new[]
{
new AutomappingType
{
Type = typeof(One)
},
new AutomappingType
{
Type = typeof(Two)
},
});
var output = formatter.Format(results);
output.ShouldEqual(
"Fluent Mappings\r\n" +
"---------------\r\n\r\n" +
"Sources scanned:\r\n\r\n" +
" " + typeof(One).Assembly.GetName().FullName + "\r\n" +
"\r\n" +
"Mappings discovered:\r\n\r\n" +
" " + typeof(One).Name + " | " + typeof(One).AssemblyQualifiedName + "\r\n" +
" " + typeof(Two).Name + " | " + typeof(Two).AssemblyQualifiedName + "\r\n" +
"\r\n" +
"Conventions\r\n" +
"-----------\r\n\r\n" +
"Sources scanned:\r\n\r\n" +
" " + typeof(One).Assembly.GetName().FullName + "\r\n" +
"\r\n" +
"Conventions discovered:\r\n\r\n" +
" " + typeof(One).Name + " | " + typeof(One).AssemblyQualifiedName + "\r\n" +
" " + typeof(Two).Name + " | " + typeof(Two).AssemblyQualifiedName + "\r\n" +
"\r\n" +
"Automapping\r\n" +
"-----------\r\n\r\n" +
"Skipped types:\r\n\r\n" +
" " + typeof(One).Name + " | first reason | " + typeof(One).AssemblyQualifiedName + "\r\n" +
" " + typeof(Two).Name + " | second reason | " + typeof(Two).AssemblyQualifiedName + "\r\n" +
"\r\n" +
"Candidate types:\r\n\r\n" +
" " + typeof(One).Name + " | " + typeof(One).AssemblyQualifiedName + "\r\n" +
" " + typeof(Two).Name + " | " + typeof(Two).AssemblyQualifiedName + "\r\n" +
"\r\n" +
"Mapped types:\r\n\r\n" +
" " + typeof(One).Name + " | " + typeof(One).AssemblyQualifiedName + "\r\n" +
" " + typeof(Two).Name + " | " + typeof(Two).AssemblyQualifiedName + "\r\n"
);
}