protected Type GetContractType() { return(TestableTypeBuilder.New() .WithName("IMyTestType") .WithNamespace("Test.Type") .Build()); }
public void ProvideActivationContext_Works() { var assemblyShim = this.mockRepository.Create <IAssemblyShim>(); var contract = GetContract(); var pluginAttribute = GetPluginAttributeForContract(contract); var typeName = "MyTestType"; var testableType = TestableTypeBuilder.New() .WithCustomAttributes(pluginAttribute) .WithName(typeName) .WithNamespace("Test.Type") .Build(); // NO factory method // NO activated method // NO bootstrapper // NO services assemblyShim.Setup(a => a.Types).Returns(new[] { testableType }); var sut = new DefaultPluginActivationContextProvider(); var result = sut.ProvideActivationContext(testableType, assemblyShim.Object); Assert.IsNotNull(result); Assert.IsNull(result.PluginActivatedMethod); Assert.IsNull(result.PluginFactoryMethod); Assert.AreEqual(0, result.PluginServices.Count()); Assert.AreEqual(typeName, result.PluginType.Name); }
public async Task LoadPluginAssembly_Guard_Works() { var testContext = SetupAssemblyLoadContext(); var loadContext = testContext.Sut(); var fileSystemUtility = testContext.GetMock <IFileSystemUtilities>(); var pluginAssemblyPath = "/var/home/MyPluginAssembly.dll"; var pluginDependencyContextProvider = testContext.GetMock <IPluginDependencyContextProvider>(); var pluginDependencyContext = testContext.GetMock <IPluginDependencyContext>(); var contract = TestableTypeBuilder.New() .WithName("IMyTestType") .WithNamespace("Test.Type") .Build(); var assembly = this.GetType().Assembly; var assemblyStream = File.OpenRead(assembly.Location); fileSystemUtility.Setup(f => f.EnsureFileExists(pluginAssemblyPath)).Returns(pluginAssemblyPath); fileSystemUtility.Setup(f => f.ReadFileFromDisk(pluginAssemblyPath)).ReturnsAsync(assemblyStream); var pluginLoadContext = new PluginLoadContext(pluginAssemblyPath, contract, "netcoreapp3.1"); pluginDependencyContextProvider.Setup(p => p.FromPluginLoadContext(pluginLoadContext)).ReturnsAsync(pluginDependencyContext.Object); var priseAssembly = await loadContext.LoadPluginAssembly(pluginLoadContext); await Assert.ThrowsExceptionAsync <AssemblyLoadingException>(() => loadContext.LoadPluginAssembly(pluginLoadContext)); }
public async Task Scan_Succeeds() { var startingPath = "/home/maarten"; var metadataLoadContext = this.mockRepository.Create <IMetadataLoadContext>(); var assemblyShim = this.mockRepository.Create <IAssemblyShim>(); var directoryTraverser = this.mockRepository.Create <IDirectoryTraverser>(); directoryTraverser.Setup(d => d.TraverseDirectories(startingPath)).Returns(new[] { "pathy/mcpathface" }); directoryTraverser.Setup(d => d.TraverseFiles(It.IsAny <string>(), It.IsAny <IEnumerable <string> >())).Returns(new[] { "filey.mcfile.face" }); var contract = TestableTypeBuilder.New() .WithName("IMyTestType") .WithNamespace("Test.Type") .Build(); var pluginAttributeTypedValue = new CustomAttributeTypedArgument(contract); var pluginAttribute = new TestableAttribute { _AttributeType = typeof(Prise.Plugin.PluginAttribute), _NamedArguments = new[] { new CustomAttributeNamedArgument(new TestableMemberInfo { _Name = "PluginType" }, pluginAttributeTypedValue) } }; var testableType = TestableTypeBuilder.New() .WithCustomAttributes(pluginAttribute) .WithName("MyTestType") .WithNamespace("Test.Type") .Build(); assemblyShim.Setup(a => a.Types).Returns(new[] { testableType }); metadataLoadContext.Setup(c => c.LoadFromAssemblyName(It.IsAny <string>())).Returns(assemblyShim.Object); var scanner = new DefaultAssemblyScanner( (s) => metadataLoadContext.Object, () => directoryTraverser.Object ); var types = await scanner.Scan(new AssemblyScannerOptions { StartingPath = startingPath, PluginType = contract }); var result = types.FirstOrDefault(); Assert.IsNotNull(result); Assert.AreEqual("MyTestType", result.PluginType.Name); Assert.AreEqual("Test.Type", result.PluginType.Namespace); }
public void Selecting_Plugin_Types_Works() { var assemblyShim = this.mockRepository.Create <IAssemblyShim>(); var contract = TestableTypeBuilder.New() .WithName("IMyTestType") .WithNamespace("Test.Type") .Build(); var pluginAttributeTypedValue = new CustomAttributeTypedArgument(contract); var pluginAttribute = new TestableAttribute { _AttributeType = typeof(Prise.Plugin.PluginAttribute), _NamedArguments = new[] { new CustomAttributeNamedArgument(new TestableMemberInfo { _Name = "PluginType" }, pluginAttributeTypedValue) } }; var testableType = TestableTypeBuilder.New() .WithCustomAttributes(pluginAttribute) .WithName("MyTestType") .WithNamespace("Test.Type") .Build(); var testableType2 = TestableTypeBuilder.New() .WithCustomAttributes(pluginAttribute) .WithName("MyTestType2") .WithNamespace("Test.Type") .Build(); assemblyShim.Setup(a => a.Types).Returns(new[] { testableType2, testableType, typeof(ITestPlugin) }); var selector = new DefaultPluginTypeSelector(); var pluginsTypes = selector.SelectPluginTypes(contract, assemblyShim.Object); Assert.AreEqual(2, pluginsTypes.Count()); Assert.AreEqual("MyTestType", pluginsTypes.First().Name); Assert.AreEqual("MyTestType2", pluginsTypes.ElementAt(1).Name); }
public void ProvideActivationContext_WithBootstrapper_Works() { var assemblyShim = this.mockRepository.Create <IAssemblyShim>(); var contract = GetContract(); var pluginAttribute = GetPluginAttributeForContract(contract); var serviceTypeName = "IMyService1"; var serviceType = TestableTypeBuilder.New() .WithName(serviceTypeName) .WithNamespace("Test.Type") .Build(); var proxyTypeName = "BootstrapperService"; var proxyType = TestableTypeBuilder.New() .WithName(proxyTypeName) .WithNamespace("Test.Type") .Build(); var bootstrapperServiceFieldName = "bootstrapperService"; var bootstrapperServiceField = TestableFieldBuilder.New() .WithName(bootstrapperServiceFieldName) .WithAttribute(TestableAttributeBuilder.New() .WithAttributeType(typeof(Prise.Plugin.BootstrapperServiceAttribute)) .WithNamedAgrument("ServiceType", serviceType) .WithNamedAgrument("ProxyType", proxyType) .Build()) .Build(); var typeName = "MyTestType"; var testableType = TestableTypeBuilder.New() .WithCustomAttributes(pluginAttribute) .WithName(typeName) .WithNamespace("Test.Type") .Build(); var bootstrapperAttribute = TestableAttributeBuilder.New() .WithAttributeType(typeof(Prise.Plugin.PluginBootstrapperAttribute)) .WithNamedAgrument("PluginType", testableType) .Build(); var bootstrapperName = "MyTestTypeBootstrapper"; var bootstrapperType = TestableTypeBuilder.New() .WithCustomAttributes(bootstrapperAttribute) .WithName(bootstrapperName) .WithNamespace("Test.Type") .WithFields(new[] { bootstrapperServiceField }) .Build(); assemblyShim.Setup(a => a.Types).Returns(new[] { testableType, bootstrapperType }); var sut = new DefaultPluginActivationContextProvider(); var result = sut.ProvideActivationContext(testableType, assemblyShim.Object); Assert.IsNotNull(result); Assert.IsNull(result.PluginActivatedMethod); Assert.IsNull(result.PluginFactoryMethod); Assert.AreEqual(0, result.PluginServices.Count()); Assert.AreEqual(bootstrapperServiceFieldName, result.BootstrapperServices.ElementAt(0).FieldName); Assert.AreEqual(proxyTypeName, result.BootstrapperServices.ElementAt(0).ProxyType.Name); Assert.AreEqual(serviceTypeName, result.BootstrapperServices.ElementAt(0).ServiceType.Name); Assert.AreEqual(typeName, result.PluginType.Name); Assert.AreEqual(bootstrapperName, result.PluginBootstrapperType.Name); }
public void ProvideActivationContext_WithPluginServices_Works() { var assemblyShim = this.mockRepository.Create <IAssemblyShim>(); var contract = GetContract(); var pluginAttribute = GetPluginAttributeForContract(contract); // Factory method var factoryMethodName = "This_Is_The_Factory_Method"; var factoryMethod = TestableMethodInfoBuilder.New() .WithName(factoryMethodName) .WithAttribute(TestableAttributeBuilder.New() .WithAttributeType(typeof(Prise.Plugin.PluginFactoryAttribute)).Build()) .Build(); // Activated method var activatedMethodName = "This_Is_The_Activation_Method"; var activatedMethod = TestableMethodInfoBuilder.New() .WithName(activatedMethodName) .WithAttribute(TestableAttributeBuilder.New() .WithAttributeType(typeof(Prise.Plugin.PluginActivatedAttribute)).Build()) .Build(); var serviceTypeName1 = "IMyService1"; var serviceType1 = TestableTypeBuilder.New() .WithName(serviceTypeName1) .WithNamespace("Test.Type") .Build(); var pluginService1 = "pluginService"; var serviceField1 = TestableFieldBuilder.New() .WithName(pluginService1) .WithAttribute(TestableAttributeBuilder.New() .WithAttributeType(typeof(Prise.Plugin.PluginServiceAttribute)) .WithNamedAgrument("ServiceType", serviceType1) .WithNamedAgrument("ProvidedBy", ProvidedBy.Plugin) .Build()) .Build(); var proxyTypeName = "IProxyType"; var proxyType = TestableTypeBuilder.New() .WithName(proxyTypeName) .WithNamespace("Test.Type") .Build(); var pluginService2 = "hostService"; var serviceField2 = TestableFieldBuilder.New() .WithName(pluginService2) .WithAttribute(TestableAttributeBuilder.New() .WithAttributeType(typeof(Prise.Plugin.PluginServiceAttribute)) .WithNamedAgrument("ServiceType", serviceType1) .WithNamedAgrument("ProvidedBy", ProvidedBy.Host) .WithNamedAgrument("ProxyType", proxyType) .Build()) .Build(); var typeName = "MyTestType"; var testableType = TestableTypeBuilder.New() .WithCustomAttributes(pluginAttribute) .WithName(typeName) .WithNamespace("Test.Type") .WithMethods(new[] { factoryMethod, activatedMethod }) .WithFields(new[] { serviceField1, serviceField2 }) .Build(); // NO bootstrapper assemblyShim.Setup(a => a.Types).Returns(new[] { testableType }); var sut = new DefaultPluginActivationContextProvider(); var result = sut.ProvideActivationContext(testableType, assemblyShim.Object); Assert.IsNotNull(result); Assert.IsNotNull(result.PluginActivatedMethod); Assert.AreEqual(activatedMethodName, result.PluginActivatedMethod.Name); Assert.IsNotNull(result.PluginFactoryMethod); Assert.AreEqual(factoryMethodName, result.PluginFactoryMethod.Name); Assert.AreEqual(2, result.PluginServices.Count()); Assert.AreEqual(pluginService1, result.PluginServices.ElementAt(0).FieldName); Assert.AreEqual(pluginService2, result.PluginServices.ElementAt(1).FieldName); Assert.AreEqual(ProvidedBy.Plugin, result.PluginServices.ElementAt(0).ProvidedBy); Assert.AreEqual(ProvidedBy.Host, result.PluginServices.ElementAt(1).ProvidedBy); Assert.IsNull(result.PluginServices.ElementAt(0).ProxyType); Assert.IsNotNull(result.PluginServices.ElementAt(1).ProxyType); Assert.AreEqual(proxyTypeName, result.PluginServices.ElementAt(1).ProxyType.Name); Assert.AreEqual(serviceTypeName1, result.PluginServices.ElementAt(0).ServiceType.Name); Assert.AreEqual(serviceTypeName1, result.PluginServices.ElementAt(1).ServiceType.Name); Assert.AreEqual(typeName, result.PluginType.Name); }
public async Task Compressed_NugetPackage_Must_Be_UnCompressed() { var package = "Prise.Plugin.Package.1.0.0.nupkg"; var startingPath = "/home/maarten"; var nugetUtilities = this.mockRepository.Create <INugetPackageUtilities>(); var metadataLoadContext = this.mockRepository.Create <IMetadataLoadContext>(); var assemblyShim = this.mockRepository.Create <IAssemblyShim>(); var directoryTraverser = this.mockRepository.Create <IDirectoryTraverser>(); var actualNugetUtilities = new DefaultNugetPackageUtilities(); nugetUtilities.Setup(n => n.FindAllNugetPackagesFiles(startingPath)).Returns(new[] { package }); // Call actual implementation here nugetUtilities.Setup(n => n.GetVersionFromPackageFile(It.IsAny <string>())).Returns <string>((s) => actualNugetUtilities.GetVersionFromPackageFile(s)); // Call actual implementation here nugetUtilities.Setup(n => n.GetPackageName(It.IsAny <string>())).Returns <string>((s) => actualNugetUtilities.GetPackageName(s)); nugetUtilities.Setup(n => n.HasAlreadyBeenExtracted(It.IsAny <string>())).Returns(false); nugetUtilities.Setup(n => n.UnCompressNugetPackage(It.IsAny <string>(), It.IsAny <string>())).Verifiable(); directoryTraverser.Setup(d => d.TraverseDirectories($"{startingPath}/_extracted")).Returns(new[] { "pathy/mcpathface" }); directoryTraverser.Setup(d => d.TraverseFiles(It.IsAny <string>(), It.IsAny <IEnumerable <string> >())).Returns(new[] { "filey.mcfile.face" }); var contract = TestableTypeBuilder.New() .WithName("IMyTestType") .WithNamespace("Test.Type") .Build(); var pluginAttributeTypedValue = new CustomAttributeTypedArgument(contract); var pluginAttribute = new TestableAttribute { _AttributeType = typeof(Prise.Plugin.PluginAttribute), _NamedArguments = new[] { new CustomAttributeNamedArgument(new TestableMemberInfo { _Name = "PluginType" }, pluginAttributeTypedValue) } }; var testableType = TestableTypeBuilder.New() .WithCustomAttributes(pluginAttribute) .WithName("MyTestType") .WithNamespace("Test.Type") .Build(); assemblyShim.Setup(a => a.Types).Returns(new[] { testableType }); metadataLoadContext.Setup(c => c.LoadFromAssemblyName(It.IsAny <string>())).Returns(assemblyShim.Object); var scanner = new DefaultNugetPackageAssemblyScanner( (s) => metadataLoadContext.Object, () => directoryTraverser.Object, () => nugetUtilities.Object ); var types = await scanner.Scan(new AssemblyScannerOptions { StartingPath = startingPath, PluginType = contract }); var result = types.FirstOrDefault(); Assert.IsNotNull(result); Assert.AreEqual("MyTestType", result.PluginType.Name); Assert.AreEqual("Test.Type", result.PluginType.Namespace); }