public void MergeRequirementsWithConfigDisabledAndLiveUserActions()
{
Guid id = new Guid("{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}");
TestBase.CopyPluginToTestDir("ServiceA.dll");
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
RequirementLayer layer = new RequirementLayer("MyLayer");
layer.PluginRequirements.AddOrSet(id, RunningRequirement.MustExistTryStart);
RequirementLayer layer2 = new RequirementLayer("MyLayer2");
layer2.PluginRequirements.AddOrSet(id, RunningRequirement.Optional);
// the requirements needs a MustExistTryStart, we set the status of the plugin to Disabled
_ctx.ConfigManager.UserConfiguration.PluginsStatus.SetStatus(id, ConfigPluginStatus.Disabled);
// and we set the LiveUserAction to started
_ctx.ConfigManager.UserConfiguration.LiveUserConfiguration.SetAction(id, ConfigUserAction.Started);
PluginRunner.Add(layer);
PluginRunner.Add(layer2);
Assert.That(PluginRunner.RunnerRequirements.FinalRequirement(id) == SolvedConfigStatus.Disabled);
}
public void LiveUserConfigOptional()
{
Guid id_plugin1 = new Guid("{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}");
Guid id_plugin2 = new Guid("{E64F17D5-DCAB-4A07-8CEE-901A87D8295E}");
TestBase.CopyPluginToTestDir("ServiceA.dll");
TestBase.CopyPluginToTestDir("ServiceB.dll");
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
RequirementLayer layer = new RequirementLayer("MyLayer");
PluginRunner.Add(layer);
Assert.That(!PluginRunner.IsDirty, "Not dirty because the layer is empty");
layer.PluginRequirements.AddOrSet(id_plugin1, RunningRequirement.Optional);
Assert.That(!PluginRunner.IsDirty, "Still not dirty because plugin's are optional ... so we have nothing to change.");
ConfigManager.UserConfiguration.LiveUserConfiguration.SetAction(id_plugin2, ConfigUserAction.None);
Assert.That(!PluginRunner.IsDirty);
Assert.IsTrue(PluginRunner.Remove(layer));
Assert.That(PluginRunner.RunnerRequirements.Count, Is.EqualTo(0));
Assert.That(!PluginRunner.IsDirty, "Not dirty because of the live user");
}
public void RequirementLayerOptionals()
{
Guid id_plugin1 = new Guid("{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}");
Guid id_plugin2 = new Guid("{E64F17D5-DCAB-4A07-8CEE-901A87D8295E}");
TestBase.CopyPluginToTestDir("ServiceA.dll");
TestBase.CopyPluginToTestDir("ServiceB.dll");
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
RequirementLayer layer = new RequirementLayer("MyLayer");
PluginRunner.Add(layer);
Assert.That(!PluginRunner.IsDirty, "Not dirty because the layer is empty");
layer.PluginRequirements.AddOrSet(id_plugin1, RunningRequirement.Optional);
layer.PluginRequirements.AddOrSet(id_plugin2, RunningRequirement.Optional);
Assert.That(!PluginRunner.IsDirty, "Not dirty because plugin's are optional ... so we have nothing to change.");
Assert.IsTrue(PluginRunner.Remove(layer));
Assert.That(PluginRunner.RunnerRequirements.Count, Is.EqualTo(0));
Assert.That(!PluginRunner.IsDirty, "Not dirty because the PluginRunner doesn't contains any requirement");
}
public void RequirementLayersEvents()
{
RequirementLayer layer = new RequirementLayer("Layer");
PluginRequirementCollectionEvents(layer.PluginRequirements as PluginRequirementCollection);
ServiceRequirementCollectionEvents(layer.ServiceRequirements as ServiceRequirementCollection);
}
public void RediscoverImplementationOfAService()
{
Guid serviceC = new Guid("{C24EE3EA-F078-4974-A346-B34208221B35}");
Guid serviceC2 = new Guid("{1EC4980D-17F0-4DDC-86C6-631CDB69A6AD}");
TestBase.CopyPluginToTestDir("ServiceC.Model.dll"); // Service
TestBase.CopyPluginToTestDir("ServiceC.dll"); // Implementation
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
RequirementLayer layer = new RequirementLayer("RunnerTest");
layer.ServiceRequirements.AddOrSet("CK.Tests.Plugin.IServiceC, ServiceC.Model", RunningRequirement.MustExistAndRun);
PluginRunner.RunnerRequirements.Add(layer);
Assert.That(PluginRunner.Apply());
Assert.That(PluginRunner.IsPluginRunning(PluginRunner.Discoverer.FindPlugin(serviceC)));
TestBase.CopyPluginToTestDir("ServiceC.Bis.dll"); // Second Implementation
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
Assert.That(PluginRunner.IsDirty, Is.False);
PluginRunner.ConfigManager.UserConfiguration.PluginsStatus.SetStatus(serviceC, ConfigPluginStatus.Disabled);
Assert.That(PluginRunner.IsDirty);
Assert.That(PluginRunner.Apply());
Assert.That(PluginRunner.IsPluginRunning(PluginRunner.Discoverer.FindPlugin(serviceC2)));
}
public void ApplicationExitDisableRunner()
{
Guid simplePluginId = new Guid("{EEAEC976-2AFC-4A68-BFAD-68E169677D52}");
TestContextHost host = new TestContextHost("TestContexts");
IContext c = host.CreateContext();
TestBase.CopyPluginToTestDir("SimplePlugin.dll");
c.PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
var pluginId = c.PluginRunner.Discoverer.FindPlugin(simplePluginId);
Assert.That(pluginId, Is.Not.Null);
Assert.That(c.PluginRunner.PluginHost.IsPluginRunning(pluginId), Is.False);
Assert.That(c.PluginRunner.PluginHost.IsPluginRunning(pluginId.PluginId), Is.False);
var req = new RequirementLayer("Start SimplePlugin");
req.PluginRequirements.AddOrSet(simplePluginId, RunningRequirement.MustExistAndRun);
c.PluginRunner.Add(req);
c.PluginRunner.Apply();
Assert.That(c.PluginRunner.PluginHost.IsPluginRunning(pluginId), Is.True, "SimplePlugin is running.");
Assert.That(c.PluginRunner.PluginHost.IsPluginRunning(pluginId.PluginId), Is.True, "SimplePlugin is running.");
int eventPhasis = 0;
c.PluginRunner.PluginHost.StatusChanged += (o, e) =>
{
Assert.That(eventPhasis >= 0 && eventPhasis < 3);
Assert.That(e.PluginProxy.PluginKey.PluginId, Is.EqualTo(simplePluginId));
if (eventPhasis == 0)
{
Assert.That(e.Previous, Is.EqualTo(RunningStatus.Started));
Assert.That(e.PluginProxy.Status, Is.EqualTo(RunningStatus.Stopping));
eventPhasis = 1;
}
else if (eventPhasis == 1)
{
Assert.That(e.Previous, Is.EqualTo(RunningStatus.Stopping));
Assert.That(e.PluginProxy.Status, Is.EqualTo(RunningStatus.Stopped));
eventPhasis = 2;
}
else if (eventPhasis == 2)
{
Assert.That(e.Previous, Is.EqualTo(RunningStatus.Stopped));
Assert.That(e.PluginProxy.Status, Is.EqualTo(RunningStatus.Disabled));
eventPhasis = 3;
}
};
Assert.That(c.RaiseExitApplication(true));
Assert.That(c.PluginRunner.PluginHost.IsPluginRunning(pluginId), Is.False, "SimplePlugin is no more running.");
Assert.That(c.PluginRunner.PluginHost.IsPluginRunning(pluginId.PluginId), Is.False, "SimplePlugin is no more running.");
}
public void RequirementLayerService_AddFilled()
{
TestBase.CopyPluginToTestDir("ServiceA.dll");
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
RequirementLayer layer = new RequirementLayer("MyLayer");
layer.ServiceRequirements.AddOrSet("CK.Tests.Plugin.IServiceA, ServiceA, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", RunningRequirement.MustExistAndRun);
PluginRunner.Add(layer);
Assert.That(PluginRunner.IsDirty, "Should be dirty");
}
public void RequirementLayerUnknownService()
{
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
RequirementLayer layer = new RequirementLayer("MyLayer");
PluginRunner.Add(layer);
Assert.That(!PluginRunner.IsDirty, "Not dirty because the layer is empty");
layer.ServiceRequirements.AddOrSet("UnknownAQN!", RunningRequirement.Optional);
Assert.That(!PluginRunner.IsDirty, "Should not be dirty because the service is unknown and the requirement is optional");
}
public void SimpleWithoutDiscoverer()
{
Guid id = Guid.NewGuid();
RequirementLayer layer = new RequirementLayer("MyLayer");
PluginRunner.Add(layer);
Assert.That(!PluginRunner.IsDirty, "Not dirty because the layer is empty");
layer.PluginRequirements.AddOrSet(id, RunningRequirement.MustExistAndRun);
Assert.That(!PluginRunner.IsDirty, "Not dirty since the plugin is not found in the discoverer: it is Disabled.");
PluginRunner.Remove(layer);
Assert.That(!PluginRunner.IsDirty, "Not dirty because the PluginRunner doesn't contains any requirement");
}
internal RequirementLayerSnapshot(RequirementLayer l)
{
LayerName = l.LayerName;
var plugins = l.PluginRequirements.Select((r, idx) => new PluginRequirementIdentifier()
{
PluginId = r.PluginId, Requirement = r.Requirement
}).ToArray();
PluginRequirements = new ReadOnlyCollectionOnICollection <PluginRequirementIdentifier>(plugins);
var services = l.ServiceRequirements.Select((r, idx) => new ServiceRequirementIdentifier()
{
AssemblyQualifiedName = r.AssemblyQualifiedName, Requirement = r.Requirement
}).ToArray();
ServiceRequirements = new ReadOnlyCollectionOnICollection <ServiceRequirementIdentifier>(services);
}
public void MergeOnlyRequirements()
{
Guid id = new Guid( "{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}" );
TestBase.CopyPluginToTestDir( "ServiceA.dll" );
PluginRunner.Discoverer.Discover( TestBase.TestFolderDir, true );
RequirementLayer layer = new RequirementLayer( "MyLayer" );
layer.PluginRequirements.AddOrSet( id, RunningRequirement.MustExistAndRun );
RequirementLayer layer2 = new RequirementLayer( "MyLayer2" );
layer2.PluginRequirements.AddOrSet( id, RunningRequirement.Optional );
RequirementLayer layer3 = new RequirementLayer( "MyLayer3" );
layer3.PluginRequirements.AddOrSet( id, RunningRequirement.OptionalTryStart );
PluginRunner.Add( layer );
PluginRunner.Add( layer2 );
PluginRunner.Add( layer3 );
Assert.That( PluginRunner.RunnerRequirements.FinalRequirement( id ) == SolvedConfigStatus.MustExistAndRun );
}
public void SimpleRequirementLayer()
{
Guid id = new Guid("{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}");
TestBase.CopyPluginToTestDir("ServiceA.dll");
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
RequirementLayer layer = new RequirementLayer("MyLayer");
PluginRunner.Add(layer);
Assert.That(!PluginRunner.IsDirty, "Not dirty because the layer is empty");
layer.PluginRequirements.AddOrSet(id, RunningRequirement.MustExistAndRun);
Assert.That(PluginRunner.IsDirty, "Dirty because the plugin has been found in the discoverer.");
Assert.IsTrue(PluginRunner.Remove(layer));
Assert.That(PluginRunner.RunnerRequirements.Count, Is.EqualTo(0));
Assert.That(!PluginRunner.IsDirty, "Not dirty because the PluginRunner doesn't contains any requirement");
}
private Context(bool proxified)
{
_serviceContainer = new ContextServiceContainer(this);
_dic = SharedDictionary.Create(_serviceContainer);
_configManager = ConfigurationManager.Create(_dic);
_reqLayer = new RequirementLayer("Context");
_pluginRunner = new PluginRunner(_serviceContainer, _configManager.ConfigManager);
_serviceContainer.Add(RequirementLayerSerializer.Instance);
_serviceContainer.Add(SimpleTypeFinder.Default);
if (proxified)
{
_proxifiedContext = (IContext)_pluginRunner.ServiceHost.InjectExternalService(typeof(IContext), this);
}
else
{
_proxifiedContext = this;
_serviceContainer.Add <IContext>(this);
}
_pluginRunner.Initialize(_proxifiedContext);
}
public void MergeOnlyRequirements()
{
Guid id = new Guid("{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}");
TestBase.CopyPluginToTestDir("ServiceA.dll");
PluginRunner.Discoverer.Discover(TestBase.TestFolderDir, true);
RequirementLayer layer = new RequirementLayer("MyLayer");
layer.PluginRequirements.AddOrSet(id, RunningRequirement.MustExistAndRun);
RequirementLayer layer2 = new RequirementLayer("MyLayer2");
layer2.PluginRequirements.AddOrSet(id, RunningRequirement.Optional);
RequirementLayer layer3 = new RequirementLayer("MyLayer3");
layer3.PluginRequirements.AddOrSet(id, RunningRequirement.OptionalTryStart);
PluginRunner.Add(layer);
PluginRunner.Add(layer2);
PluginRunner.Add(layer3);
Assert.That(PluginRunner.RunnerRequirements.FinalRequirement(id) == SolvedConfigStatus.MustExistAndRun);
}
public void RediscoverImplementationOfAService()
{
Guid serviceC = new Guid( "{C24EE3EA-F078-4974-A346-B34208221B35}" );
Guid serviceC2 = new Guid( "{1EC4980D-17F0-4DDC-86C6-631CDB69A6AD}" );
TestBase.CopyPluginToTestDir( "ServiceC.Model.dll" ); // Service
TestBase.CopyPluginToTestDir( "ServiceC.dll" ); // Implementation
PluginRunner.Discoverer.Discover( TestBase.TestFolderDir, true );
RequirementLayer layer = new RequirementLayer( "RunnerTest" );
layer.ServiceRequirements.AddOrSet( "CK.Tests.Plugin.IServiceC, ServiceC.Model", RunningRequirement.MustExistAndRun );
PluginRunner.RunnerRequirements.Add( layer );
Assert.That( PluginRunner.Apply() );
Assert.That( PluginRunner.IsPluginRunning( PluginRunner.Discoverer.FindPlugin( serviceC ) ) );
TestBase.CopyPluginToTestDir( "ServiceC.Bis.dll" ); // Second Implementation
PluginRunner.Discoverer.Discover( TestBase.TestFolderDir, true );
Assert.That( PluginRunner.IsDirty, Is.False );
PluginRunner.ConfigManager.UserConfiguration.PluginsStatus.SetStatus( serviceC, ConfigPluginStatus.Disabled );
Assert.That( PluginRunner.IsDirty );
Assert.That( PluginRunner.Apply() );
Assert.That( PluginRunner.IsPluginRunning( PluginRunner.Discoverer.FindPlugin( serviceC2 ) ) );
}
public void MergeRequirementsWithConfig()
{
Guid id = new Guid( "{12A9FCC0-ECDC-4049-8DBF-8961E49A9EDE}" );
TestBase.CopyPluginToTestDir( "ServiceA.dll" );
PluginRunner.Discoverer.Discover( TestBase.TestFolderDir, true );
RequirementLayer layer = new RequirementLayer( "MyLayer" );
layer.PluginRequirements.AddOrSet( id, RunningRequirement.MustExistTryStart );
RequirementLayer layer2 = new RequirementLayer( "MyLayer2" );
layer2.PluginRequirements.AddOrSet( id, RunningRequirement.Optional );
// the requirements needs a MustExistTryStart, we set the status of the plugin to AutomaticStart
_ctx.ConfigManager.UserConfiguration.PluginsStatus.SetStatus( id, ConfigPluginStatus.AutomaticStart );
PluginRunner.Add( layer );
PluginRunner.Add( layer2 );
Assert.That( PluginRunner.RunnerRequirements.FinalRequirement( id ) == SolvedConfigStatus.MustExistAndRun );
}
bool ISimplePluginRunner.Add(RequirementLayer r, bool allowDuplicate)
{
return(_requirements.Add(r, allowDuplicate));
}
bool ISimplePluginRunner.Remove(RequirementLayer r, bool removeAll)
{
return(_requirements.Remove(r, removeAll));
}
