public void ShouldConfigureGlobalOption()
{
CombinedTargetContainerConfig config = new CombinedTargetContainerConfig();
config.ConfigureOption((TestOption)"global");
var targets = new TargetContainer(config);
Assert.Equal("global", targets.GetOption <TestOption>());
}
public void ShouldConfigureServiceSpecicOption()
{
CombinedTargetContainerConfig config = new CombinedTargetContainerConfig();
config.ConfigureOption <TestOption, string>("for System.String");
var targets = new TargetContainer(config);
Assert.Equal("for System.String", targets.GetOption <TestOption, string>());
Assert.Null(targets.GetOption <TestOption>());
}
public void ShouldNotAddRegistrationsIfDisabledByOption()
{
var configs = new CombinedTargetContainerConfig
{
Configuration.InjectLists.Instance,
Configuration.Configure.Option <Options.EnableListInjection>(false)
};
var targets = new TargetContainer(configs);
Assert.Null(targets.Fetch(typeof(List <string>)));
Assert.Null(targets.Fetch(typeof(IList <string>)));
}
public void ShouldConfigureGlobalOptionByCallback()
{
CombinedTargetContainerConfig config = new CombinedTargetContainerConfig();
config.ConfigureOption(tc =>
{
Assert.NotNull(tc);
return((TestOption)"global (callback)");
});
var targets = new TargetContainer(config);
Assert.Equal("global (callback)", targets.GetOption <TestOption>());
}
public void ShouldConfigureAfterOptionSet()
{
CombinedTargetContainerConfig coll = new CombinedTargetContainerConfig
{
// add the dependant first
new ConfiguredByTestOptionConfig(t => Assert.Equal("configured!", t.GetOption <TestOption>()), true)
};
// then add the config that configures the option :)
coll.ConfigureOption <TestOption>("configured!");
var targets = new TargetContainer(coll);
// this just ensures that the configure method was actually called
Assert.IsType <Rezolver.Targets.ObjectTarget>(targets.Fetch(typeof(ConfiguredByTestOptionConfig)));
}
public void ShouldConfigureServiceSpecificOptionByCallback()
{
CombinedTargetContainerConfig config = new CombinedTargetContainerConfig();
config.ConfigureOption(typeof(string), (tc, t) =>
{
Assert.NotNull(tc);
Assert.Equal(typeof(string), t);
return((TestOption)$"for { t.FullName } (callback)");
});
var targets = new TargetContainer(config);
Assert.Equal($"for { typeof(string).FullName } (callback)", targets.GetOption <TestOption, string>());
Assert.Null(targets.GetOption <TestOption>());
}
public void ShouldNotAddRegistrationsIfDisabledByOption()
{
// note input order reversed from the preferred: tests that InjectCollections config
// expresses dependency on a configuration which configures the option
CombinedTargetContainerConfig config = new CombinedTargetContainerConfig()
{
InjectCollections.Instance,
Configure.Option <EnableCollectionInjection>(false)
};
var targets = new TargetContainer(config);
Assert.Null(targets.Fetch(typeof(Collection <string>)));
Assert.Null(targets.Fetch(typeof(ICollection <string>)));
Assert.Null(targets.Fetch(typeof(ReadOnlyCollection <string>)));
Assert.Null(targets.Fetch(typeof(IReadOnlyCollection <string>)));
}
public void ShouldAddRegistrations()
{
var configs = new CombinedTargetContainerConfig
{
Configuration.InjectLists.Instance
};
var targets = new TargetContainer(configs);
var concreteTarget = targets.Fetch(typeof(List <string>));
var interfaceTarget = targets.Fetch(typeof(IList <string>));
Assert.NotNull(concreteTarget);
Assert.False(concreteTarget.UseFallback);
Assert.NotNull(interfaceTarget);
Assert.False(interfaceTarget.UseFallback);
}
public void ShouldConfigureAfterAllOptionsSet()
{
CombinedTargetContainerConfig coll = new CombinedTargetContainerConfig
{
new ConfiguredByTestOptionConfig(t =>
{
Assert.Equal("global configured!", t.GetOption <TestOption>());
Assert.Equal("IEnumerable configured!", t.GetOption <TestOption>(typeof(IEnumerable <>)));
Assert.Equal("IEnumerable<string> configured!", t.GetOption <TestOption, IEnumerable <string> >());
Assert.Equal("IEnumerable configured!", t.GetOption <TestOption, IEnumerable <double> >());
Assert.Equal("global configured!", t.GetOption <TestOption, int>());
}, true)
};
coll.ConfigureOption <TestOption, IEnumerable <string> >("IEnumerable<string> configured!");
coll.ConfigureOption <TestOption>(typeof(IEnumerable <>), "IEnumerable configured!");
coll.ConfigureOption <TestOption>("global configured!");
var targets = new TargetContainer(coll);
Assert.IsType <Rezolver.Targets.ObjectTarget>(targets.Fetch(typeof(ConfiguredByTestOptionConfig)));
}
public void ShouldAddRegistrations()
{
CombinedTargetContainerConfig config = new CombinedTargetContainerConfig
{
InjectCollections.Instance
};
var targets = new TargetContainer(config);
var rwConcreteTarget = targets.Fetch(typeof(Collection <string>));
var rwInterfaceTarget = targets.Fetch(typeof(ICollection <string>));
var roConcreteTarget = targets.Fetch(typeof(ReadOnlyCollection <string>));
var roInterfaceTarget = targets.Fetch(typeof(IReadOnlyCollection <string>));
Assert.NotNull(rwConcreteTarget);
Assert.NotNull(rwInterfaceTarget);
Assert.NotNull(roConcreteTarget);
Assert.NotNull(roInterfaceTarget);
Assert.False(rwConcreteTarget.UseFallback);
Assert.False(rwInterfaceTarget.UseFallback);
Assert.False(roConcreteTarget.UseFallback);
Assert.False(roInterfaceTarget.UseFallback);
}
