//[Platform(Exclude = "Linux")]
public void RelativePathSubDependencyResolver_Resolves_RelativePaths_As_Expected_When_No_PropertiesResolver()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "relpath-castle.config", m_tempPath);
const string connString = "server=localhost;user=sa";
WindsorContainer container = new WindsorContainer(path);
container.Kernel.Resolver.AddSubResolver(new RelativePathSubDependencyResolver(container.Kernel));
// act
RelPathTestClass obj = container.Resolve <RelPathTestClass>();
// assert
Assert.IsNotNull(obj);
Assert.AreEqual(m_getFullPath(@"..\etc\config.ini"), obj.PathParam);
Assert.AreEqual(3, obj.PathArrParam.Length);
Assert.AreEqual(m_getFullPath(@"..\etc\config1.ini"), obj.PathArrParam[0]);
if (!PlatformHelper.IsUnix())
{
Assert.AreEqual(@"C:\temp.ini", obj.PathArrParam[1]);
}
Assert.AreEqual(m_getFullPath(@"..\etc\second.ini"), obj.PathArrParam[2]);
Assert.AreEqual(connString, obj.MySqlConnection.ConnectionString);
}
public void Get_Resolver_DoesNot_Throw_Exception_If_ProcessResource_Was_Called()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "castle.config", Path.GetTempPath());
PropertiesInterpreter interpreter = new PropertiesInterpreter(path);
WindsorContainer container = new WindsorContainer();
interpreter.ProcessResource(interpreter.Source, container.Kernel.ConfigurationStore, container.Kernel);
ConfigurationProcessingException actual = null;
IPropertyResolver resolver = null;
// act
try
{
resolver = interpreter.Resolver;
}
catch (ConfigurationProcessingException e)
{
actual = e;
}
// assert
Assert.IsNull(actual);
Assert.IsNotNull(resolver);
}
public void Get_Resolver_Throws_Exception_If_SubSystem_Not_Initialised()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "invalid-castle.config", Path.GetTempPath());
PropertiesSubSystem subSystem = new PropertiesSubSystem(path);
const string expectedMessagePrefix = "Error processing node castle";
string actualMessage = string.Empty;
IPropertyResolver resolver = null;
// act
try
{
resolver = subSystem.Resolver;
WindsorContainer container = new WindsorContainer();
container.Kernel.AddSubSystem(PropertiesSubSystem.SubSystemKey, subSystem);
}
catch (ConfigurationProcessingException e)
{
actualMessage = e.Message;
}
// assert
Assert.IsNull(resolver);
Assert.IsTrue(actualMessage.StartsWith(expectedMessagePrefix));
}
public void Get_Resolver_Throws_Exception_If_ProcessResource_Was_Not_Called()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "castle.config", Path.GetTempPath());
PropertiesInterpreter interpreter = new PropertiesInterpreter(path);
ConfigurationProcessingException expected =
new ConfigurationProcessingException("Properties file has not been processed yet. Have you missed calling PropertiesInterpreter.ProcessResource(IResource,IConfigurationStore,IKernel)");
ConfigurationProcessingException actual = null;
// act
try
{
IPropertyResolver resolver = interpreter.Resolver;
}
catch (ConfigurationProcessingException e)
{
actual = e;
}
// assert
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Message, actual.Message);
}
public static async Task Prepare(VsHive hive, IEnumerable <string> extensionsToInstall, bool resetSettings, IDiagnostics diagnostics)
{
await diagnostics.RunAsync("Preparing Instance", async output =>
{
var installResult = default((int InstallCount, bool HasSettingsFile, string Output));
var invokerAssembly = Assembly.GetExecutingAssembly();
using (var invoker = new TempFile(EmbeddedResourceUtil.ExtractResource(invokerAssembly, "VsixTesting.Invoker.vsix")))
{
EmbeddedResourceUtil.ApplyDateTime(invoker.Path, invokerAssembly, "VsixTesting.Invoker.vsix");
installResult = await VisualStudioUtil.InstallExtensionsAsync(
hive,
extensionsToInstall.Concat(new[] { invoker.Path }));
output.WriteLine(installResult.Output);
if (installResult.InstallCount > 0)
{
output.WriteLine("Clearing cache");
await VisualStudioUtil.ClearCacheAsync(hive);
output.WriteLine("Updating configuration");
await VisualStudioUtil.UpdateConfigurationAsync(hive);
}
}
if (!installResult.HasSettingsFile || resetSettings)
{
output.WriteLine("Resetting settings");
await VisualStudioUtil.ResetSettingsAsync(hive);
}
});
}
public void Get_Resolver_DoesNot_Throws_Exception_Once_SubSystem_Is_Initialised()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "castle.config", Path.GetTempPath());
PropertiesSubSystem subSystem = new PropertiesSubSystem(path);
WindsorContainer container = new WindsorContainer();
container.Kernel.AddSubSystem(PropertiesSubSystem.SubSystemKey, subSystem);
KernelException actual = null;
IPropertyResolver resolver = null;
// act
try
{
resolver = subSystem.Resolver;
}
catch (KernelException e)
{
actual = e;
}
// assert
Assert.IsNull(actual);
Assert.IsNotNull(resolver);
}
public static async Task <(int Result, string Output)> RunInstallerAsync(VsHive hive, IEnumerable <string> args)
{
var suffix = hive.Version >= VersionUtil.FromVsVersion(VsVersion.VS2022) ? ".x64" : string.Empty;
using (var visualStudioInstaller = new TempFile(EmbeddedResourceUtil.ExtractResource(Assembly.GetExecutingAssembly(), $"VsixTesting.Installer{suffix}.exe")))
{
var process = Process.Start(new ProcessStartInfo
{
FileName = visualStudioInstaller.Path,
Arguments = string.Join(" ", new string[]
{
"/ApplicationPath", QuotePath(hive.ApplicationPath),
"/RootSuffix", hive.RootSuffix,
}.Concat(args)),
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardError = true,
RedirectStandardOutput = true,
});
await process.WaitForExitAsync();
if (process.ExitCode < 0)
{
throw new Exception(process.StandardError.ReadToEnd());
}
return(process.ExitCode, process.StandardOutput.ReadToEnd());
}
}
public void SubSystem_From_Json_File_Initialises_Properly()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "castle.json", Path.GetTempPath());
PropertiesSubSystem subsystem = new PropertiesSubSystem(path);
WindsorContainer container = new WindsorContainer();
// act
subsystem.Init((IKernelInternal)container.Kernel);
// assert
Assert.AreEqual("mihir", subsystem.Resolver.GetValue("name"));
CollectionAssert.AreEqual(new[] { "chess", "cricket" }, subsystem.Resolver.GetValue <string[]>("hobbies"));
IDictionary <string, string> extrasStuffMixed = subsystem.Resolver.GetValue <Dictionary <string, string> >("extraStuffMixed");
Assert.AreEqual("31", extrasStuffMixed["age"]);
Assert.AreEqual("male", extrasStuffMixed["sex"]);
IDictionary <string, double> extrasStuffFloats = subsystem.Resolver.GetValue <Dictionary <string, double> >("extraStuffFloats");
Assert.AreEqual(4.0, extrasStuffFloats["precision"]);
Assert.AreEqual(2.56, extrasStuffFloats["start"]);
}
public async Task SmallCapStockSegmentTest()
{
var msabDetails = EmbeddedResourceUtil.ReadFileContent("msab_b_details.json");
httpClient.GetStringAsync(Arg.Any <string>()).Returns(msabDetails);
var stockDetails = await stockDetailParser.GetStockDetailsAsync("dummy stock id");
Assert.Equal(Segment.Small, stockDetails.GetSegment());
}
public void GetValue_Simple_Works_As_Expected()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "castle.config", Path.GetTempPath());
PropertiesSubSystem subSystem = new PropertiesSubSystem(path);
WindsorContainer container = new WindsorContainer();
container.Kernel.AddSubSystem(PropertiesSubSystem.SubSystemKey, subSystem);
IConversionManager manager = (IConversionManager)container.Kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey);
manager.Add(new PersonTypeConverter());
IPropertyResolver resolver = subSystem.Resolver;
// act
string strParam = resolver.GetValue("strParam");
double dblParam = resolver.GetValue <double>("dblParam");
string[] arrParam = resolver.GetValue <string[]>("arrParam");
IDictionary <string, string> dictParam = resolver.GetValue <IDictionary <string, string> >("dictParam");
List <double> listParam = resolver.GetValue <List <double> >("listParam");
Person[] personArr = resolver.GetValue <Person[]>("personArr");
// assert
Assert.AreEqual("this is string", strParam);
Assert.AreEqual(20.12, dblParam);
Assert.AreEqual("arr item 1", arrParam[0]);
Assert.AreEqual(strParam, arrParam[1]);
Assert.AreEqual(@"..\etc\config.ini", arrParam[2]);
Assert.IsTrue(dictParam.ContainsKey("key1"));
Assert.IsTrue(dictParam.ContainsKey("key2"));
Assert.AreEqual("value 1", dictParam["key1"]);
Assert.AreEqual("value 2", dictParam["key2"]);
Assert.AreEqual(21.2, listParam[0]);
Assert.AreEqual(3, listParam[1]);
Assert.AreEqual(dblParam, listParam[2]);
Assert.AreEqual("Mihir", personArr[0].Name);
Assert.AreEqual(30, personArr[0].PersonAge);
Assert.AreEqual("Sneha", personArr[1].Name);
Assert.AreEqual(33, personArr[1].PersonAge);
// act
Dependency[] dependencies = resolver.TryGetDependencies <TestClass>("strParam", "arrParam", "refParam", "dictParam", "listParam", "personArr");
container.Register(Component.For <TestClass>().DependsOn(dependencies));
// assert
Assert.IsNotNull(container.Resolve <TestClass>());
}
public void Ctor_Test()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "castle.config", Path.GetTempPath());
// act
PropertyResolvingWindsorContainer container = new PropertyResolvingWindsorContainer(path);
// assert
Assert.IsInstanceOf <PropertiesInterpreter>(container.Interpreter);
// get properties subsystem from kernel
PropertiesSubSystem subsystem = container.Kernel.GetSubSystem <PropertiesSubSystem>(PropertiesSubSystem.SubSystemKey);
// assert
Assert.IsNotNull(subsystem);
Assert.AreEqual("this is string", subsystem.Resolver.GetValue("strParam"));
}
public void RelativePathSubDependencyResolver_Resolves_RelativePaths_As_Expected_With_PropertiesResolver()
{
// arrange
string path = EmbeddedResourceUtil.ExportToPath("Castle.Windsor.Extensions.Test.data", "relpath-castle-with-propertiesresolver.config", m_tempPath);
const string connString = "server=localhost;user=sa";
PropertiesSubSystem subSystem = new PropertiesSubSystem(path);
WindsorContainer container = new WindsorContainer();
container.Kernel.AddSubSystem(PropertiesSubSystem.SubSystemKey, subSystem);
container.Kernel.Resolver.AddSubResolver(new RelativePathSubDependencyResolver(container.Kernel));
container.Register(Component
.For <SqlConnection>()
.DependsOn(Dependency.OnValue("connectionString", subSystem.Resolver.GetValue("dbConnectionString"))));
container.Register(Component
.For <RelPathTestClass>()
.DependsOn(
subSystem.Resolver.GetDependency <string>("pathParam"),
subSystem.Resolver.GetDependency <string[]>("pathArrParam"),
Dependency.OnComponent("mySqlConnection", typeof(SqlConnection))
));
// act
RelPathTestClass obj = container.Resolve <RelPathTestClass>();
// assert
Assert.IsNotNull(obj);
Assert.AreEqual(m_getFullPath(@"..\etc\config.ini"), obj.PathParam);
Assert.AreEqual(3, obj.PathArrParam.Length);
Assert.AreEqual(m_getFullPath(@"..\etc\config1.ini"), obj.PathArrParam[0]);
if (!PlatformHelper.IsUnix())
{
Assert.AreEqual(@"C:\temp.ini", obj.PathArrParam[1]);
}
Assert.AreEqual(m_getFullPath(@"..\etc\second.ini"), obj.PathArrParam[2]);
Assert.AreEqual(connString, obj.MySqlConnection.ConnectionString);
}
public static async Task <(int InstallCount, bool HasSettingsFile, string Output)> InstallExtensionsAsync(VsHive hive, IEnumerable <string> extensions)
{
using (var visualStudioInstaller = new TempFile(EmbeddedResourceUtil.ExtractResource(Assembly.GetExecutingAssembly(), "VsixTesting.ExtensionInstaller.exe")))
{
var process = Process.Start(new ProcessStartInfo
{
FileName = visualStudioInstaller.Path,
Arguments = string.Join(" ", new string[]
{
"--ApplicationPath", Quote(hive.ApplicationPath),
"--RootSuffix", hive.RootSuffix,
"--MajorVersion", hive.Version.Major.ToString(),
"--ExtensionPaths",
}.Concat(extensions.Select(e => Quote(e)))),
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardError = true,
RedirectStandardOutput = true,
});
await process.WaitForExitAsync();
var result = process.ExitCode;
var hasSettingsFile = true;
if (result < 0)
{
throw new Exception(process.StandardError.ReadToEnd());
}
else if (result >= 9999)
{
result -= 9999;
hasSettingsFile = false;
}
return(result, hasSettingsFile, process.StandardOutput.ReadToEnd());
}
string Quote(string str) => $"\"{str}\"";
}
public static async Task Prepare(VsHive hive, IEnumerable <string> extensionsToInstall, bool resetSettings, IDiagnostics diagnostics, bool installInvoker = true)
{
await diagnostics.RunAsync("Preparing Instance", async output =>
{
var invokerAssembly = Assembly.GetExecutingAssembly();
var resourceName = $"VsixTesting.Invoker{(hive.Version.Major >= 17 ? ".17" : string.Empty)}.vsix";
using (var invoker = new TempFile(EmbeddedResourceUtil.ExtractResource(invokerAssembly, resourceName)))
{
EmbeddedResourceUtil.ApplyDateTime(invoker.Path, invokerAssembly, resourceName);
if (installInvoker)
{
extensionsToInstall = extensionsToInstall.Concat(new[] { invoker.Path });
}
var installResult = await VisualStudioUtil.InstallExtensionsAsync(hive, extensionsToInstall);
output.WriteLine(installResult.Output);
if (installResult.InstallCount > 0)
{
output.WriteLine("Clearing cache");
await VisualStudioUtil.ClearCacheAsync(hive);
output.WriteLine("Updating configuration");
await VisualStudioUtil.UpdateConfigurationAsync(hive);
}
}
if (resetSettings)
{
output.WriteLine("Resetting settings");
await VisualStudioUtil.ResetSettingsAsync(hive);
}
});
}
public void GetEmbeddedResourceValue_InvalidResourceNameReturnsNull_Success()
{
string result = EmbeddedResourceUtil.GetEmbeddedResourceValue(InvalidEmbeddedResourceName, Assembly.GetExecutingAssembly());
Assert.IsNull(result);
}
/// <summary>
/// Gets database script from the .sql file.
/// </summary>
/// <returns>
/// Returns database script.
/// </returns>
private static string GetDatabaseScript()
{
var databaseScriptResourceName = typeof(THandler).FullName + ".sql";
return(EmbeddedResourceUtil.GetEmbeddedResourceValue(databaseScriptResourceName, typeof(THandler).Assembly));
}
public void GetEmbeddedResourceValue_ResourceNameAsNull_ThrowsException()
{
EmbeddedResourceUtil.GetEmbeddedResourceValue(null, Assembly.GetExecutingAssembly());
}
public void GetEmbeddedResourceValue_ResourceNameAsWhiteSpace_ThrowsException()
{
EmbeddedResourceUtil.GetEmbeddedResourceValue(" ", Assembly.GetExecutingAssembly());
}
public void GetEmbeddedResourceValue_AssemblyAsNull_ThrowsException()
{
EmbeddedResourceUtil.GetEmbeddedResourceValue("test", null);
}
public void GetEmbeddedResourceValue_ValidResourceNameReturnsValue_Success()
{
string result = EmbeddedResourceUtil.GetEmbeddedResourceValue(ValidEmbeddedResourceName, Assembly.GetExecutingAssembly());
Assert.AreEqual(ValueInEmbeddedResource, result);
}
