public void ParseInvalidGroups()
{
var map = new TargetMapper();
var groupings = "group1 target1,target2; group2: target1, target3";
map.ParseAliasString(groupings);
Assert.Equal("group1", map.GetNames("group1").Single());
AreCollectionsEqual(new[] { "target1", "target3" }, map.GetNames("group2"));
}
public void ParseInvalidGroupsValidateAtomicOperation()
{
var map = new TargetMapper();
var groupings = "group1: target1,target2; group2 target1, target3";
Assert.Throws <ArgumentOutOfRangeException>(() => map.ParseAliasString(groupings, true));
Assert.Equal("group1", map.GetNames("group1").Single());
Assert.Equal("group2", map.GetNames("group2").Single());
}
public void ParseGroupings2Groups()
{
var map = new TargetMapper();
var groupings = "group1: target1,target2; group2: target1, target3";
map.ParseAliasString(groupings);
AreCollectionsEqual(new[] { "target1", "target2" }, map.GetNames("group1"));
AreCollectionsEqual(new[] { "target1", "target3" }, map.GetNames("group2"));
}
public void CaseInsensitiveAlias()
{
var map = new TargetMapper();
map.AddAlias("alias1", "target");
map.AddAlias("Alias1", "target");
Assert.Equal("target", map.GetNames("Alias1").Single());
Assert.Equal("target", map.GetNames("alias1").Single());
}
public void AliasList()
{
var map = new TargetMapper();
map.AddAlias("alias1", "Target1");
map.AddAlias("alias2", "target1");
map.AddAlias("Alias1", "target2");
AreCollectionsEqual(new[] { "alias1", "alias2" }, map.Aliases);
}
public void ParseInvalidGroupsValidate()
{
Assert.Throws(typeof(ArgumentOutOfRangeException), () =>
{
var map = new TargetMapper();
var groupings = "group1 target1,target2; group2: target1, target3";
map.ParseAliasString(groupings, true);
});
}
public void VerifySingleAliasMapping()
{
Assert.Throws(typeof(AliasMappedToMultipleNamesException), () =>
{
var map = new TargetMapper();
map.AddAlias("alias", "name1");
map.AddAlias("alias", "name2");
map.VerifySingleAlias();
});
}
public static IUnityContainer Build(ICommandLineOptions options, ProductInformation productInformation)
{
var container = new UnityContainer();
var targetMapper = new TargetMapper();
targetMapper.LoadFromConfig();
container.RegisterInstance <ICommandLineOptions>(options);
container.RegisterInstance <ITargetMapper>(targetMapper);
// For debug purposes, the FileOutputApiPortService helps as it serializes the request to json and opens it with the
// default json handler. To use this service, uncomment the the next line and comment the one after that.
//container.RegisterType<IApiPortService, FileOutputApiPortService>(new ContainerControlledLifetimeManager());
container.RegisterInstance <IApiPortService>(new ApiPortService(options.ServiceEndpoint, productInformation));
container.RegisterType <IEnumerable <IgnoreAssemblyInfo>, FileIgnoreAssemblyInfoList>(new ContainerControlledLifetimeManager());
container.RegisterType <IDependencyFinder, ReflectionMetadataDependencyFinder>(new ContainerControlledLifetimeManager());
container.RegisterType <IReportGenerator, ReportGenerator>(new ContainerControlledLifetimeManager());
container.RegisterType <ApiPortService>(new ContainerControlledLifetimeManager());
container.RegisterType <IFileSystem, WindowsFileSystem>(new ContainerControlledLifetimeManager());
container.RegisterType <IFileWriter, ReportFileWriter>(new ContainerControlledLifetimeManager());
container.RegisterType <IRequestAnalyzer, RequestAnalyzer>(new ContainerControlledLifetimeManager());
container.RegisterType <IAnalysisEngine, AnalysisEngine>(new ContainerControlledLifetimeManager());
container.RegisterType <ConsoleApiPort>(new ContainerControlledLifetimeManager());
container.RegisterType <ICollection <IReportWriter> >(new ContainerControlledLifetimeManager(), new InjectionFactory(WriterCollection));
container.RegisterType <IApiPortOptions>(new ContainerControlledLifetimeManager(), new InjectionFactory(GetOptions));
// Register the default output format name
container.RegisterInstance(DefaultOutputFormatInstanceName, "Excel");
if (Console.IsOutputRedirected)
{
container.RegisterInstance <IProgressReporter>(new TextWriterProgressReporter(Console.Out));
}
else
{
container.RegisterType <IProgressReporter, ConsoleProgressReporter>(new ContainerControlledLifetimeManager());
}
// Load any customizations via Unity
var fileMap = new ExeConfigurationFileMap
{
ExeConfigFilename = Path.Combine(GetApplicationDirectory(), "unity.config")
};
var configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
var unitySection = (UnityConfigurationSection)configuration.GetSection("unity");
return(unitySection == null ? container : container.LoadConfiguration(unitySection));
}
public void TestNullMapsToScopePositive()
{
var scopes = Enum.GetValues(typeof(Sex))
.OfType <Sex>()
.Select(val => new ScopeValue(DummyScope(val.GetType()), val.ToString())
{
Value = val,
Description = val.ToString()
}).ToList();
var propertyInfo = typeof(InpatientTarget).GetProperty("Sex");
Assert.IsNotNull(propertyInfo);
var element = new Element(DummyTarget, propertyInfo.Name);
element.Scope = new Scope(DummyTarget, "Sex", typeof(Sex));
element.Scope.Description = "Sex";
PrivateObject prv = new PrivateObject(element.Scope);
prv.SetProperty("Id", 1);
scopes.ForEach(s => element.Scope.Values.Add(s));
var fieldEntry = new FieldEntry(new DataColumn("Sex"));
fieldEntry.Bin.AddValue(null);
fieldEntry.Bin.AddValue(int.MinValue);
fieldEntry.Bin.AddValue(0);
fieldEntry.Bin.AddValue(int.MaxValue);
var expected = Sex.Male;
var notexpected = Sex.Female;
fieldEntry.Bin[null].ScopeValue = scopes.FirstOrDefault(v => object.Equals(v.Value, expected));
fieldEntry.Bin[int.MinValue].ScopeValue = scopes.FirstOrDefault(v => object.Equals(v.Value, notexpected));
fieldEntry.Bin[0].ScopeValue = scopes.FirstOrDefault(v => object.Equals(v.Value, notexpected));
fieldEntry.Bin[int.MaxValue].ScopeValue = scopes.FirstOrDefault(v => object.Equals(v.Value, notexpected));
var mappedField = new MappedFieldEntryViewModel(propertyInfo, element, fieldEntry);
var mapper = new TargetMapper <InpatientTarget>(DummyTarget, new[] { mappedField });
mapper[element] = DBNull.Value;
Assert.AreEqual(expected, mapper.Target.Sex);
//var po = new PrivateObject(mapper);
//var ElementMaps = po.GetProperty("ElementMaps") as IDictionary;
//Assert.IsTrue(ElementMaps.Count > 0);
//var errors = new List<ValidationError>();
//var engine = new InstanceValidator<Monahrq.Wing.Discharge.Inpatient.InpatientTarget>();
//var result = engine.ValidateInstance(mapper.Target);
}
private TargetMapper LoadXml(string config)
{
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms)
{
AutoFlush = true
})
{
writer.Write(config);
ms.Seek(0, SeekOrigin.Begin);
var targetMapper = new TargetMapper();
targetMapper.Load(ms);
return(targetMapper);
}
}
public void TestWarnings()
{
var wing = WingRepository.New(Guid.NewGuid().ToString());
var target = TargetRepository.New(wing, Guid.Empty, Guid.NewGuid().ToString());
var mapper = new TargetMapper <FooTarget>(target, Enumerable.Empty <MappedFieldEntryViewModel>());
var po = new PrivateObject(mapper);
var ElementMaps = po.GetProperty("ElementMaps") as IDictionary;
Assert.IsTrue(ElementMaps.Count > 0);
var errors = new List <ValidationError>();
var engine = new InstanceValidator <FooTarget>();
var result = engine.ValidateInstance(mapper.Target);
Assert.IsTrue(result.PropertyWarnings.Count > 0);
}
public void AliasEqualsTarget()
{
var map = new TargetMapper();
map.AddAlias("TestTarget2", "TestTarget1");
try
{
map.AddAlias("ProjectAlias", "TestTarget2");
}
catch (TargetMapperException e)
{
Assert.Equal(String.Format(CultureInfo.CurrentCulture, LocalizedStrings.AliasCanotBeEqualToTargetNameError, "TestTarget2"), e.Message);
return;
}
Assert.True(false, "Expected exception was not thrown");
}
public void GetTargetNamesForDistinctTargets()
{
var mapper = new TargetMapper();
mapper.AddAlias("Mobile", "Windows Phone");
mapper.AddAlias("Mobile", "Windows");
mapper.AddAlias("Mobile", "Mono");
mapper.AddAlias("Desktop", ".NET Framework Test");
var netFramework4 = new FrameworkName(".NET Framework,Version=4.0");
var windowsPhone = new FrameworkName("Windows Phone,Version=8.1");
var windows8 = new FrameworkName("Windows,Version=8.0");
var targets = new List <FrameworkName> {
netFramework4, windowsPhone, windows8
};
var targetNames = mapper.GetTargetNames(targets, includeVersion: false).ToArray();
var targetNamesWithVersions = mapper.GetTargetNames(targets, includeVersion: true).ToArray();
AreCollectionsEqual(new string[] { ".NET Framework", "Windows Phone", "Windows" }, targetNames);
AreCollectionsEqual(new string[] { netFramework4.FullName, windowsPhone.FullName, windows8.FullName }, targetNamesWithVersions);
}
public void LoadXmlFromFile()
{
var map = new TargetMapper();
Assert.False(map.LoadFromConfig("doesnotexist.xml"));
}
public void UnknownTarget()
{
var map = new TargetMapper();
Assert.Equal("Target", map.GetNames("Target").Single());
}
public void ParseGroupingsNull()
{
var map = new TargetMapper();
map.ParseAliasString(null);
}
