public void TryGetConfigurationById_WhenFileContainsInformation_ReturnsExpectedConfiguration()
{
//arrange
var expectedConfiguration = new Configuration {
ConfigurationId = "Layer1", ConfigurationValue = 1
};
var configurationList = new List <Configuration>
{
expectedConfiguration,
new Configuration {
ConfigurationId = "Layer2", ConfigurationValue = "2"
}
};
var configurationLayer = new ConfigurationLayer(configurationList);
//act
var foundConfiguration =
configurationLayer.TryGetConfigurationById(expectedConfiguration.ConfigurationId,
out var configuration);
//assert
foundConfiguration.Should().BeTrue();
configuration.Should().BeEquivalentTo(expectedConfiguration);
}
public void Testout()
{
ConfigurationLayer cl = new ConfigurationLayer();
ConfigurationItem item1 = new ConfigurationItem();
cl.Items.AddConfigurationItem("plugin1", ConfigurationStatus.Running);
Assert.That(item1.Status == ConfigurationStatus.Running);
Assert.That(item1.ServiceOrPluginName == "plugin1");
ConfigurationItem item2 = new ConfigurationItem();
cl.Items.AddConfigurationItem("service1", ConfigurationStatus.Running);
Assert.That(item1.Status == ConfigurationStatus.Running);
Assert.That(item1.ServiceOrPluginName == "service1");
ConfigurationManager cm = new ConfigurationManager();
cm.AddLayer(cl);
Objectgraph Og = new ObjectGraph(cm);
Og.Resolve();
Og.Release();
}
/// <summary>
/// Loads the configuration layer.
/// </summary>
/// <returns>The configuration layer.</returns>
private ConfigurationLayer LoadConfigurationLayer()
{
var configurationLayer = new ConfigurationLayer();
configurationLayer.MachineFilePath = MachineConfigFilePath;
configurationLayer.SharedFilePath = SharedConfigFilePath;
configurationLayer.UserFilePath = UserConfigFilePath;
if (File.Exists(configurationLayer.MachineFilePath))
{
configurationLayer.MachineConfig = ConfigurationXmlSerializer.Deserialize(File.OpenRead(configurationLayer.MachineFilePath));
}
if (File.Exists(configurationLayer.SharedFilePath))
{
configurationLayer.SharedConfig = ConfigurationXmlSerializer.Deserialize(File.OpenRead(configurationLayer.SharedFilePath));
}
if (File.Exists(configurationLayer.UserFilePath))
{
configurationLayer.UserConfig = ConfigurationXmlSerializer.Deserialize(File.OpenRead(configurationLayer.UserFilePath));
}
configurationLayer.ComputedConfig = ProductivityShell.Configuration.Configuration.ComputeConfig(configurationLayer.MachineConfig, configurationLayer.SharedConfig, configurationLayer.UserConfig);
return(configurationLayer);
}
internal ConfigurationItem( ConfigurationLayer configurationLayer, string serviceOrPluginFullName, ConfigurationStatus initialStatus, StartDependencyImpact initialImpact, string initialStatusReason = "")
{
Debug.Assert( !String.IsNullOrEmpty( serviceOrPluginFullName ) );
Debug.Assert( configurationLayer != null );
Debug.Assert( initialStatusReason != null );
_owner = configurationLayer;
_serviceOrPluginFullName = serviceOrPluginFullName;
_status = initialStatus;
_impact = initialImpact;
_statusReason = initialStatusReason;
}
public MainWindow()
{
string responsavel = ConfigurationLayer.GetConfig("Responsavel");
if (string.IsNullOrEmpty(responsavel) || responsavel == "Dev")
{
new Login().ShowDialog();
}
InitializeComponent();
SetupTimerSalvamentoAutomático();
SetupTimerPorSegundo();
ComboBoxProjetos.ItemsSource = Timesheet.Projetos;
}
public void ConfigurationLayerWithManagerTests()
{
ConfigurationManager manager = new ConfigurationManager();
ConfigurationLayer layer = new ConfigurationLayer("system");
ConfigurationResult result = manager.Layers.Add(layer);
Assert.That(result == true);
Assert.That(layer.ConfigurationManager, Is.EqualTo(manager));
Assert.That(layer.LayerName, Is.EqualTo("system"));
Assert.DoesNotThrow(() => layer.LayerName = "");
Assert.That(layer.LayerName, Is.EqualTo(""));
result = layer.Items.Add("schmurtz1", ConfigurationStatus.Optional);
Assert.That(result == true);
ConfigurationManager manager2 = new ConfigurationManager();
result = manager2.Layers.Add(layer);
Assert.That(result == false);
result = manager.Layers.Remove(layer);
Assert.That(result == true);
Assert.That(layer.ConfigurationManager, Is.EqualTo(null));
result = manager.Layers.Add(layer);
Assert.That(result == true);
manager.ConfigurationChanging += (s, e) => e.Cancel("schmurtz!");
result = layer.Items.Add("schmurtz1", ConfigurationStatus.Runnable);
Assert.That(result == false);
Assert.That(result.IsSuccessful, Is.False);
Assert.That(result.FailureCauses[0], Is.EqualTo("schmurtz!"));
Assert.That(layer.Items["schmurtz1"].Status, Is.EqualTo(ConfigurationStatus.Optional));
result = layer.Items.Add("schmurtz2", ConfigurationStatus.Optional);
Assert.That(result == false);
Assert.That(result.IsSuccessful, Is.False);
Assert.That(result.FailureCauses[0], Is.EqualTo("schmurtz!"));
Assert.That(layer.Items["schmurtz"], Is.EqualTo(null));
result = manager.Layers.Remove(layer);
Assert.That(result == false);
Assert.That(layer.ConfigurationManager, Is.EqualTo(manager));
}
public void ConfigurationLayerWithManagerTests()
{
ConfigurationManager manager = new ConfigurationManager();
ConfigurationLayer layer = new ConfigurationLayer( "system" );
ConfigurationResult result = manager.Layers.Add( layer );
Assert.That( result == true );
Assert.That( layer.ConfigurationManager, Is.EqualTo( manager ) );
Assert.That( layer.LayerName, Is.EqualTo( "system" ) );
Assert.DoesNotThrow( () => layer.LayerName = "" );
Assert.That( layer.LayerName, Is.EqualTo( "" ) );
result = layer.Items.Add( "schmurtz1", ConfigurationStatus.Optional );
Assert.That( result == true );
ConfigurationManager manager2 = new ConfigurationManager();
result = manager2.Layers.Add( layer );
Assert.That( result == false );
result = manager.Layers.Remove( layer );
Assert.That( result == true );
Assert.That( layer.ConfigurationManager, Is.EqualTo( null ) );
result = manager.Layers.Add( layer );
Assert.That( result == true );
manager.ConfigurationChanging += ( s, e ) => e.Cancel( "schmurtz!" );
result = layer.Items.Add( "schmurtz1", ConfigurationStatus.Runnable );
Assert.That( result == false );
Assert.That( result.IsSuccessful, Is.False );
Assert.That( result.FailureCauses[0], Is.EqualTo( "schmurtz!" ) );
Assert.That( layer.Items["schmurtz1"].Status, Is.EqualTo( ConfigurationStatus.Optional ) );
result = layer.Items.Add( "schmurtz2", ConfigurationStatus.Optional );
Assert.That( result == false );
Assert.That( result.IsSuccessful, Is.False );
Assert.That( result.FailureCauses[0], Is.EqualTo( "schmurtz!" ) );
Assert.That( layer.Items["schmurtz"], Is.EqualTo( null ) );
result = manager.Layers.Remove( layer );
Assert.That( result == false );
Assert.That( layer.ConfigurationManager, Is.EqualTo( manager ) );
}
public static void BaixarAtualização(string proxAtualização)
{
var request = (FtpWebRequest)WebRequest.Create($@"ftp://{ConfigurationLayer.GetConfig("FtpServer")}/{proxAtualização}");
request.Credentials = new NetworkCredential(ConfigurationLayer.GetConfig("FtpUser"), ConfigurationLayer.GetConfig("FtpPass"));
request.Method = WebRequestMethods.Ftp.DownloadFile;
try {
using (var response = (FtpWebResponse)request.GetResponse()) {
using (var stream = response.GetResponseStream()) {
using (var file = new FileStream($@"C:\Users\{Environment.UserName}\Downloads\{proxAtualização}", FileMode.Create)) {
stream.CopyTo(file);
}
}
}
} catch (WebException e) {
throw new Exception(e.Message);
}
}
public static bool TemNovaAtualização(string proxAtualização)
{
var request = (FtpWebRequest)WebRequest.Create($@"ftp://{ConfigurationLayer.GetConfig("FtpServer")}/{proxAtualização}");
request.Credentials = new NetworkCredential(ConfigurationLayer.GetConfig("FtpUser"), ConfigurationLayer.GetConfig("FtpPass"));
request.Method = WebRequestMethods.Ftp.GetFileSize;
FtpWebResponse response = null;
try {
response = (FtpWebResponse)request.GetResponse();
return(true);
}
catch (WebException e) {
response = (FtpWebResponse)e.Response;
if (response.StatusCode == FtpStatusCode.ActionNotTakenFileUnavailable)
{
return(false);
}
}
finally { response.Close(); }
return(false);
}
/// <summary>
/// Saves the configuration layer.
/// </summary>
/// <param name="configurationLayer">The configuration layer.</param>
/// <param name="override">if set to <c>true</c> [@override].</param>
public void SaveConfigurationLayer(ConfigurationLayer configurationLayer, bool @override)
{
if (configurationLayer == null)
{
throw new ArgumentNullException(nameof(configurationLayer));
}
var configMap = new[]
{
new { FilePath = MachineConfigFilePath, Configuration = configurationLayer.MachineConfig },
new { FilePath = SharedConfigFilePath, Configuration = configurationLayer.SharedConfig },
new { FilePath = UserConfigFilePath, Configuration = configurationLayer.UserConfig }
};
foreach (var config in configMap)
{
if (string.IsNullOrWhiteSpace(config.FilePath) || config.Configuration == null)
{
continue;
}
if (!@override && File.Exists(config.FilePath))
{
continue;
}
var directoryName = Path.GetDirectoryName(config.FilePath);
if (string.IsNullOrWhiteSpace(directoryName))
{
continue;
}
Directory.CreateDirectory(directoryName);
using (var fileStream = File.OpenWrite(config.FilePath))
{
ConfigurationXmlSerializer.Serialize(fileStream, config.Configuration);
}
}
}
public void TryGetConfigurationById_WhenFileDoesNotContainInformation_ReturnsNull()
{
//arrange
var configurationList = new List <Configuration>
{
new Configuration {
ConfigurationId = "Layer1", ConfigurationValue = 1
},
new Configuration {
ConfigurationId = "Layer2", ConfigurationValue = "2"
}
};
var configurationLayer = new ConfigurationLayer(configurationList);
//act
var foundConfiguration =
configurationLayer.TryGetConfigurationById("NonExistingId", out var configuration);
//assert
foundConfiguration.Should().BeFalse();
configuration.Should().BeNull();
}
public void ManagerCreationTests()
{
ConfigurationManager cm = new ConfigurationManager();
int managerChangingCount = 0;
int managerChangedCount = 0;
Assert.That(cm.FinalConfigurationLayer == null, "Initial FinalConfiguration is null.");
cm.Changing += delegate(object sender, ConfigurationManagerChangingEventArgs e)
{
Assert.That(e.Cancel == false, "Configuration manager does not cancel by default.");
Assert.That(e.FinalConfiguration != null, "Proposed FinalConfiguration exists.");
managerChangingCount++;
};
cm.Changed += delegate(object sender, ConfigurationManagerChangedEventArgs e)
{
Assert.That(e.FinalConfiguration != null, "FinalConfiguration exists.");
managerChangedCount++;
};
bool result;
ConfigurationLayer layer = new ConfigurationLayer("BaseConfig");
layer.Items.Add("Yodii.ManagerService", ConfigurationStatus.Runnable);
layer.Items.Add(Guid.NewGuid().ToString(), ConfigurationStatus.Disable);
result = cm.Layers.Add(layer); // Fires Changing => Changed once.
Assert.That(result, Is.True);
Assert.That(managerChangingCount == 1);
Assert.That(managerChangedCount == 1);
Assert.That(cm.FinalConfigurationLayer != null, "Non-cancelled FinalConfiguration exists.");
}
public void LayerCreationTest()
{
ConfigurationLayer layer = new ConfigurationLayer("TestConfig");
Assert.That(layer.Items.Count == 0);
Assert.That(layer.ConfigurationName == "TestConfig");
string pluginIdentifier;
bool result;
// Add a random plugin GUID
pluginIdentifier = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginIdentifier, ConfigurationStatus.Disable);
Assert.That(result, Is.True);
Assert.That(layer.Items.Count == 1);
Assert.That(layer.Items[pluginIdentifier], Is.InstanceOf <ConfigurationItem>());
// Add another random plugin GUID
pluginIdentifier = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginIdentifier, ConfigurationStatus.Runnable);
Assert.That(result, Is.True);
Assert.That(layer.Items.Count == 2);
Assert.That(layer.Items[pluginIdentifier], Is.InstanceOf <ConfigurationItem>());
// Remove last plugin GUID
result = layer.Items.Remove(pluginIdentifier);
Assert.That(result, Is.True);
Assert.That(layer.Items.Count == 1);
// Add some service
pluginIdentifier = "Yodii.ManagerService";
result = layer.Items.Add(pluginIdentifier, ConfigurationStatus.Runnable);
Assert.That(result, Is.True);
Assert.That(layer.Items.Count == 2);
Assert.That(layer.Items[pluginIdentifier], Is.InstanceOf <ConfigurationItem>());
}
internal IYodiiEngineResult OnConfigurationLayerRemoving( ConfigurationLayer layer )
{
Dictionary<string, FinalConfigurationItem> final = new Dictionary<string, FinalConfigurationItem>();
ConfigurationFailureResult internalResult = FillFromConfiguration( null, final, c => c.Layer != layer );
Debug.Assert( internalResult.Success, "Removing a configuration layer can not lead to an impossibility." );
return OnConfigurationChanging( final, finalConf => new ConfigurationChangingEventArgs( finalConf, FinalConfigurationChange.LayerRemoved, layer ) );
}
public void ConfigurationLayerWithoutManagerTests()
{
int countCollectionChangedEvent = 0;
int countPropertyChangedEvent = 0;
ConfigurationLayer layer = new ConfigurationLayer();
layer.Items.CollectionChanged += ( s, e ) => countCollectionChangedEvent++;
//initialization tests
Assert.That( layer.Items.Count, Is.EqualTo( 0 ) );
Assert.Throws<IndexOutOfRangeException>( () => { ConfigurationItem lambdaItem = layer.Items[42]; } );
Assert.That( layer.Items["schmurtz"], Is.Null );
Assert.That( layer.Items.Contains( "schmurtz" ), Is.False );
//actions without items
ConfigurationResult result = layer.Items.Remove( "schmurtz" );
Assert.That( result == false ); //use a implicit cast
Assert.That( result.IsSuccessful, Is.False );
Assert.That( result.FailureCauses.Count, Is.EqualTo( 1 ) );
Assert.That( result.FailureCauses.Contains("Item not found"), Is.True );
Assert.That( countCollectionChangedEvent, Is.EqualTo( 0 ) );
//exception in add fonction
Assert.Throws<ArgumentException>( () => layer.Items.Add( null, ConfigurationStatus.Optional ) );
Assert.Throws<ArgumentException>( () => layer.Items.Add( "", ConfigurationStatus.Optional ) );
//add function tests
result = layer.Items.Add( "schmurtz", ConfigurationStatus.Optional );
Assert.That( result == true );
Assert.That( result.IsSuccessful, Is.True );
Assert.That( result.FailureCauses, Is.Not.Null );
Assert.That( result.FailureCauses.Count, Is.EqualTo( 0 ) );
Assert.That( countCollectionChangedEvent, Is.EqualTo( 1 ) );
Assert.That( layer.Items.Count, Is.EqualTo( 1 ) );
Assert.That( layer.Items["schmurtz"], Is.Not.Null );
Assert.DoesNotThrow( () => { ConfigurationItem lambdaItem = layer.Items[0]; } );
Assert.That( layer.Items["schmurtz"].Layer, Is.EqualTo( layer ) );
Assert.That( layer.Items["schmurtz"].Layer.Items["schmurtz"], Is.Not.Null );
Assert.That( layer.Items["schmurtz"].ServiceOrPluginId, Is.EqualTo( "schmurtz" ) );
Assert.That( layer.Items["schmurtz"].Status, Is.EqualTo( ConfigurationStatus.Optional ) );
Assert.That( layer.Items["schmurtz"].StatusReason, Is.EqualTo( "" ) );
//basic tests with item reference
ConfigurationItem item = layer.Items["schmurtz"];
item.PropertyChanged += ( s, e ) => countPropertyChangedEvent++;
item.StatusReason = null;
Assert.That( item.StatusReason, Is.EqualTo( "" ) );
Assert.That( countPropertyChangedEvent, Is.EqualTo( 1 ) );
Assert.DoesNotThrow( () => item.StatusReason = "schmurtz" );
Assert.That( countPropertyChangedEvent, Is.EqualTo( 2 ) );
Assert.DoesNotThrow( () => item.StatusReason = "" );
Assert.That( countPropertyChangedEvent, Is.EqualTo( 3 ) );
//setstatus tests
Assert.That( item.SetStatus( ConfigurationStatus.Disable ).IsSuccessful, Is.True );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Disable ) );
Assert.That( item.SetStatus( ConfigurationStatus.Optional ).IsSuccessful, Is.True );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Optional ) );
Assert.That( item.SetStatus( ConfigurationStatus.Runnable ).IsSuccessful, Is.True );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Runnable ) );
Assert.That( item.SetStatus( ConfigurationStatus.Running ).IsSuccessful, Is.True );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Running ) );
Assert.That( countPropertyChangedEvent, Is.EqualTo( 7 ) );
Assert.DoesNotThrow( () => item.SetStatus( ConfigurationStatus.Optional, null ) );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Optional ) );
Assert.That( item.StatusReason, Is.EqualTo( "" ) );
Assert.That( countPropertyChangedEvent, Is.EqualTo( 9 ) );
//add function tests when the item already exist
result = layer.Items.Add( "schmurtz", ConfigurationStatus.Disable );
Assert.That( result == true );
Assert.That( layer.Items.Count, Is.EqualTo( 1 ) );
Assert.That( layer.Items["schmurtz"].Status, Is.EqualTo( ConfigurationStatus.Disable ) );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Disable ) );
result = layer.Items.Add( "schmurtz", ConfigurationStatus.Optional );
Assert.That( result == true );
Assert.That( layer.Items.Count, Is.EqualTo( 1 ) );
Assert.That( layer.Items["schmurtz"].Status, Is.EqualTo( ConfigurationStatus.Optional ) );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Optional ) );
result = layer.Items.Add( "schmurtz", ConfigurationStatus.Runnable );
Assert.That( result == true );
Assert.That( layer.Items.Count, Is.EqualTo( 1 ) );
Assert.That( layer.Items["schmurtz"].Status, Is.EqualTo( ConfigurationStatus.Runnable ) );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Runnable ) );
result = layer.Items.Add( "schmurtz", ConfigurationStatus.Running );
Assert.That( result == true );
Assert.That( layer.Items.Count, Is.EqualTo( 1 ) );
Assert.That( layer.Items["schmurtz"].Status, Is.EqualTo( ConfigurationStatus.Running ) );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Running ) );
Assert.That( countPropertyChangedEvent, Is.EqualTo( 13 ) );
//OnRemoved tests
layer.Items.Remove( "schmurtz" );
Assert.That( result == true );
Assert.That( result.IsSuccessful, Is.True);
Assert.That( result.FailureCauses, Is.Not.Null );
Assert.That( result.FailureCauses.Count, Is.EqualTo( 0 ) );
Assert.That( countCollectionChangedEvent, Is.EqualTo( 2 ) );
Assert.That( layer.Items["schmurtz"], Is.Null );
Assert.Throws < IndexOutOfRangeException>( () => { ConfigurationItem lambdaItem = layer.Items[0]; } );
//tests with item reference when item is removed
Assert.That( item.Layer, Is.EqualTo( null ) );
Assert.That( item.ServiceOrPluginId, Is.EqualTo( "schmurtz" ) );
Assert.That( item.Status, Is.EqualTo( ConfigurationStatus.Optional ) );
Assert.That( item.StatusReason, Is.EqualTo( null ) );
Assert.Throws<InvalidOperationException>( () => item.StatusReason = "schmurtz" );
Assert.Throws<InvalidOperationException>( () => item.SetStatus( ConfigurationStatus.Runnable ) );
//tests with multiple add
result = layer.Items.Add( "schmurtz2", ConfigurationStatus.Optional, "schmurtz?" );
Assert.That( result == true );
result = layer.Items.Add( "schmurtz1", ConfigurationStatus.Disable, "schmurtz?" );
Assert.That( result == true );
Assert.That( layer.Items.Count, Is.EqualTo( 2 ) );
//sort tests
ConfigurationItem schmurtz1 = layer.Items["schmurtz1"];
ConfigurationItem schmurtz2 = layer.Items["schmurtz2"];
Assert.That( schmurtz1, Is.EqualTo( layer.Items[0] ) );
Assert.That( schmurtz2, Is.EqualTo( layer.Items[1] ) );
Assert.That( schmurtz1.StatusReason, Is.EqualTo( "schmurtz?" ) );
Assert.That( schmurtz2.StatusReason, Is.EqualTo( "schmurtz?" ) );
result = layer.Items.Add( "schmurtz0", ConfigurationStatus.Running );
ConfigurationItem schmurtz0 = layer.Items["schmurtz0"];
Assert.That( schmurtz0, Is.EqualTo( layer.Items[0] ) );
Assert.That( schmurtz1, Is.EqualTo( layer.Items[1] ) );
Assert.That( schmurtz2, Is.EqualTo( layer.Items[2] ) );
}
public void ConfigurationLayerWithoutManagerTests()
{
int countCollectionChangedEvent = 0;
int countPropertyChangedEvent = 0;
ConfigurationLayer layer = new ConfigurationLayer();
layer.Items.CollectionChanged += (s, e) => countCollectionChangedEvent++;
//initialization tests
Assert.That(layer.Items.Count, Is.EqualTo(0));
Assert.Throws <IndexOutOfRangeException>(() => { ConfigurationItem lambdaItem = layer.Items[42]; });
Assert.That(layer.Items["schmurtz"], Is.Null);
Assert.That(layer.Items.Contains("schmurtz"), Is.False);
//actions without items
ConfigurationResult result = layer.Items.Remove("schmurtz");
Assert.That(result == false); //use a implicit cast
Assert.That(result.IsSuccessful, Is.False);
Assert.That(result.FailureCauses.Count, Is.EqualTo(1));
Assert.That(result.FailureCauses.Contains("Item not found"), Is.True);
Assert.That(countCollectionChangedEvent, Is.EqualTo(0));
//exception in add fonction
Assert.Throws <ArgumentException>(() => layer.Items.Add(null, ConfigurationStatus.Optional));
Assert.Throws <ArgumentException>(() => layer.Items.Add("", ConfigurationStatus.Optional));
//add function tests
result = layer.Items.Add("schmurtz", ConfigurationStatus.Optional);
Assert.That(result == true);
Assert.That(result.IsSuccessful, Is.True);
Assert.That(result.FailureCauses, Is.Not.Null);
Assert.That(result.FailureCauses.Count, Is.EqualTo(0));
Assert.That(countCollectionChangedEvent, Is.EqualTo(1));
Assert.That(layer.Items.Count, Is.EqualTo(1));
Assert.That(layer.Items["schmurtz"], Is.Not.Null);
Assert.DoesNotThrow(() => { ConfigurationItem lambdaItem = layer.Items[0]; });
Assert.That(layer.Items["schmurtz"].Layer, Is.EqualTo(layer));
Assert.That(layer.Items["schmurtz"].Layer.Items["schmurtz"], Is.Not.Null);
Assert.That(layer.Items["schmurtz"].ServiceOrPluginId, Is.EqualTo("schmurtz"));
Assert.That(layer.Items["schmurtz"].Status, Is.EqualTo(ConfigurationStatus.Optional));
Assert.That(layer.Items["schmurtz"].StatusReason, Is.EqualTo(""));
//basic tests with item reference
ConfigurationItem item = layer.Items["schmurtz"];
item.PropertyChanged += (s, e) => countPropertyChangedEvent++;
item.StatusReason = null;
Assert.That(item.StatusReason, Is.EqualTo(""));
Assert.That(countPropertyChangedEvent, Is.EqualTo(1));
Assert.DoesNotThrow(() => item.StatusReason = "schmurtz");
Assert.That(countPropertyChangedEvent, Is.EqualTo(2));
Assert.DoesNotThrow(() => item.StatusReason = "");
Assert.That(countPropertyChangedEvent, Is.EqualTo(3));
//setstatus tests
Assert.That(item.SetStatus(ConfigurationStatus.Disable).IsSuccessful, Is.True);
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Disable));
Assert.That(item.SetStatus(ConfigurationStatus.Optional).IsSuccessful, Is.True);
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Optional));
Assert.That(item.SetStatus(ConfigurationStatus.Runnable).IsSuccessful, Is.True);
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Runnable));
Assert.That(item.SetStatus(ConfigurationStatus.Running).IsSuccessful, Is.True);
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Running));
Assert.That(countPropertyChangedEvent, Is.EqualTo(7));
Assert.DoesNotThrow(() => item.SetStatus(ConfigurationStatus.Optional, null));
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Optional));
Assert.That(item.StatusReason, Is.EqualTo(""));
Assert.That(countPropertyChangedEvent, Is.EqualTo(9));
//add function tests when the item already exist
result = layer.Items.Add("schmurtz", ConfigurationStatus.Disable);
Assert.That(result == true);
Assert.That(layer.Items.Count, Is.EqualTo(1));
Assert.That(layer.Items["schmurtz"].Status, Is.EqualTo(ConfigurationStatus.Disable));
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Disable));
result = layer.Items.Add("schmurtz", ConfigurationStatus.Optional);
Assert.That(result == true);
Assert.That(layer.Items.Count, Is.EqualTo(1));
Assert.That(layer.Items["schmurtz"].Status, Is.EqualTo(ConfigurationStatus.Optional));
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Optional));
result = layer.Items.Add("schmurtz", ConfigurationStatus.Runnable);
Assert.That(result == true);
Assert.That(layer.Items.Count, Is.EqualTo(1));
Assert.That(layer.Items["schmurtz"].Status, Is.EqualTo(ConfigurationStatus.Runnable));
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Runnable));
result = layer.Items.Add("schmurtz", ConfigurationStatus.Running);
Assert.That(result == true);
Assert.That(layer.Items.Count, Is.EqualTo(1));
Assert.That(layer.Items["schmurtz"].Status, Is.EqualTo(ConfigurationStatus.Running));
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Running));
Assert.That(countPropertyChangedEvent, Is.EqualTo(13));
//OnRemoved tests
layer.Items.Remove("schmurtz");
Assert.That(result == true);
Assert.That(result.IsSuccessful, Is.True);
Assert.That(result.FailureCauses, Is.Not.Null);
Assert.That(result.FailureCauses.Count, Is.EqualTo(0));
Assert.That(countCollectionChangedEvent, Is.EqualTo(2));
Assert.That(layer.Items["schmurtz"], Is.Null);
Assert.Throws <IndexOutOfRangeException>(() => { ConfigurationItem lambdaItem = layer.Items[0]; });
//tests with item reference when item is removed
Assert.That(item.Layer, Is.EqualTo(null));
Assert.That(item.ServiceOrPluginId, Is.EqualTo("schmurtz"));
Assert.That(item.Status, Is.EqualTo(ConfigurationStatus.Optional));
Assert.That(item.StatusReason, Is.EqualTo(null));
Assert.Throws <InvalidOperationException>(() => item.StatusReason = "schmurtz");
Assert.Throws <InvalidOperationException>(() => item.SetStatus(ConfigurationStatus.Runnable));
//tests with multiple add
result = layer.Items.Add("schmurtz2", ConfigurationStatus.Optional, "schmurtz?");
Assert.That(result == true);
result = layer.Items.Add("schmurtz1", ConfigurationStatus.Disable, "schmurtz?");
Assert.That(result == true);
Assert.That(layer.Items.Count, Is.EqualTo(2));
//sort tests
ConfigurationItem schmurtz1 = layer.Items["schmurtz1"];
ConfigurationItem schmurtz2 = layer.Items["schmurtz2"];
Assert.That(schmurtz1, Is.EqualTo(layer.Items[0]));
Assert.That(schmurtz2, Is.EqualTo(layer.Items[1]));
Assert.That(schmurtz1.StatusReason, Is.EqualTo("schmurtz?"));
Assert.That(schmurtz2.StatusReason, Is.EqualTo("schmurtz?"));
result = layer.Items.Add("schmurtz0", ConfigurationStatus.Running);
ConfigurationItem schmurtz0 = layer.Items["schmurtz0"];
Assert.That(schmurtz0, Is.EqualTo(layer.Items[0]));
Assert.That(schmurtz1, Is.EqualTo(layer.Items[1]));
Assert.That(schmurtz2, Is.EqualTo(layer.Items[2]));
}
private void ValidarResponsavel()
{
ConfigurationLayer.SetConfig("Responsavel", NomeTextBox.Text);
Close();
}
public void LayerAddPrecedenceTest()
{
ConfigurationLayer layer = new ConfigurationLayer("TestConfig");
bool result;
// Precedence test for Disabled
string pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginId, ConfigurationStatus.Disable);
Assert.That(result, Is.True);
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Disable);
result = layer.Items.Add(pluginId, ConfigurationStatus.Disable);
Assert.That(result, Is.True, "Adding the same plugin twice, in the same state, is a valid operation.");
Assert.That(layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Optional);
Assert.That(result, Is.False, "Layer override precedence: changing Disabled status is not valid.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Runnable);
Assert.That(result, Is.False, "Layer override precedence: changing Disabled status is not valid.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Running);
Assert.That(result, Is.False, "Layer override precedence: changing Disabled status is not valid.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Disable);
Assert.That(result, Is.True);
result = layer.Items.Remove(pluginId);
Assert.That(result, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent.");
// Precedence test for Running
pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginId, ConfigurationStatus.Running);
Assert.That(result, Is.True);
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Running);
result = layer.Items.Add(pluginId, ConfigurationStatus.Running);
Assert.That(result, Is.True, "Adding the same plugin twice, in the same state, is a valid operation.");
Assert.That(layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Optional);
Assert.That(result, Is.False, "Layer override precedence: changing Running status is not valid.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Runnable);
Assert.That(result, Is.False, "Layer override precedence: changing Running status is not valid.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Disable);
Assert.That(result, Is.False, "Layer override precedence: changing Running status is not valid.");
result = layer.Items.Remove(pluginId);
Assert.That(result, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent.");
// Precedence test for Optional -> Runnable -> Running
pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add(pluginId, ConfigurationStatus.Optional);
Assert.That(result, Is.True);
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Optional);
result = layer.Items.Add(pluginId, ConfigurationStatus.Optional);
Assert.That(result, Is.True, "Adding the same plugin twice, in the same state, is a valid operation.");
Assert.That(layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count.");
result = layer.Items.Add(pluginId, ConfigurationStatus.Runnable);
Assert.That(result, Is.False, "Layer override precedence: Optional -> Runnable is a valid operation.");
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Runnable);
result = layer.Items.Add(pluginId, ConfigurationStatus.Running);
Assert.That(result, Is.False, "Layer override precedence: Runnable -> Running is a valid operation.");
Assert.That(layer.Items[pluginId].Status == ConfigurationStatus.Running);
Assert.That(layer.Items.Count == 1, "Adding the same plugin over and over does not actually increment the count.");
result = layer.Items.Remove(pluginId);
Assert.That(result, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent.");
}
public void ManagerCreationTests()
{
ConfigurationManager cm = new ConfigurationManager();
int managerChangingCount = 0;
int managerChangedCount = 0;
Assert.That( cm.FinalConfigurationLayer == null, "Initial FinalConfiguration is null." );
cm.Changing += delegate( object sender, ConfigurationManagerChangingEventArgs e )
{
Assert.That( e.Cancel == false, "Configuration manager does not cancel by default." );
Assert.That( e.FinalConfiguration != null, "Proposed FinalConfiguration exists." );
managerChangingCount++;
};
cm.Changed += delegate( object sender, ConfigurationManagerChangedEventArgs e )
{
Assert.That( e.FinalConfiguration != null, "FinalConfiguration exists." );
managerChangedCount++;
};
bool result;
ConfigurationLayer layer = new ConfigurationLayer( "BaseConfig" );
layer.Items.Add( "Yodii.ManagerService", ConfigurationStatus.Runnable );
layer.Items.Add( Guid.NewGuid().ToString(), ConfigurationStatus.Disable );
result = cm.Layers.Add( layer ); // Fires Changing => Changed once.
Assert.That( result, Is.True );
Assert.That( managerChangingCount == 1 );
Assert.That( managerChangedCount == 1 );
Assert.That( cm.FinalConfigurationLayer != null, "Non-cancelled FinalConfiguration exists." );
}
public IConfigurationLayer Create( string layerName = null )
{
var layer = new ConfigurationLayer( _parent, layerName );
_layers.Add( layer );
return layer;
}
public void Testout()
{
ConfigurationLayer cl = new ConfigurationLayer();
ConfigurationItem item1 = new ConfigurationItem();
cl.Items.AddConfigurationItem("plugin1", ConfigurationStatus.Running);
Assert.That( item1.Status == ConfigurationStatus.Running );
Assert.That( item1.ServiceOrPluginName == "plugin1" );
ConfigurationItem item2 = new ConfigurationItem();
cl.Items.AddConfigurationItem( "service1", ConfigurationStatus.Running );
Assert.That( item1.Status == ConfigurationStatus.Running );
Assert.That( item1.ServiceOrPluginName == "service1" );
ConfigurationManager cm = new ConfigurationManager();
cm.AddLayer( cl );
Objectgraph Og = new ObjectGraph( cm );
Og.Resolve();
Og.Release();
}
public void LayerCreationTest()
{
ConfigurationLayer layer = new ConfigurationLayer( "TestConfig" );
Assert.That( layer.Items.Count == 0 );
Assert.That( layer.ConfigurationName == "TestConfig" );
string pluginIdentifier;
bool result;
// Add a random plugin GUID
pluginIdentifier = Guid.NewGuid().ToString();
result = layer.Items.Add( pluginIdentifier, ConfigurationStatus.Disable );
Assert.That( result, Is.True );
Assert.That( layer.Items.Count == 1 );
Assert.That( layer.Items[pluginIdentifier], Is.InstanceOf<ConfigurationItem>() );
// Add another random plugin GUID
pluginIdentifier = Guid.NewGuid().ToString();
result = layer.Items.Add( pluginIdentifier, ConfigurationStatus.Runnable );
Assert.That( result, Is.True );
Assert.That( layer.Items.Count == 2 );
Assert.That( layer.Items[pluginIdentifier], Is.InstanceOf<ConfigurationItem>() );
// Remove last plugin GUID
result = layer.Items.Remove( pluginIdentifier );
Assert.That( result, Is.True );
Assert.That( layer.Items.Count == 1 );
// Add some service
pluginIdentifier = "Yodii.ManagerService";
result = layer.Items.Add( pluginIdentifier, ConfigurationStatus.Runnable );
Assert.That( result, Is.True );
Assert.That( layer.Items.Count == 2 );
Assert.That( layer.Items[pluginIdentifier], Is.InstanceOf<ConfigurationItem>() );
}
public void LayerAddPrecedenceTest()
{
ConfigurationLayer layer = new ConfigurationLayer( "TestConfig" );
bool result;
// Precedence test for Disabled
string pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add( pluginId, ConfigurationStatus.Disable );
Assert.That( result, Is.True );
Assert.That( layer.Items[pluginId].Status == ConfigurationStatus.Disable );
result = layer.Items.Add( pluginId, ConfigurationStatus.Disable );
Assert.That( result, Is.True, "Adding the same plugin twice, in the same state, is a valid operation." );
Assert.That( layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count." );
result = layer.Items.Add( pluginId, ConfigurationStatus.Optional );
Assert.That( result, Is.False, "Layer override precedence: changing Disabled status is not valid." );
result = layer.Items.Add( pluginId, ConfigurationStatus.Runnable );
Assert.That( result, Is.False, "Layer override precedence: changing Disabled status is not valid." );
result = layer.Items.Add( pluginId, ConfigurationStatus.Running );
Assert.That( result, Is.False, "Layer override precedence: changing Disabled status is not valid." );
result = layer.Items.Add( pluginId, ConfigurationStatus.Disable );
Assert.That( result, Is.True );
result = layer.Items.Remove( pluginId );
Assert.That( result, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent." );
// Precedence test for Running
pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add( pluginId, ConfigurationStatus.Running );
Assert.That( result, Is.True );
Assert.That( layer.Items[pluginId].Status == ConfigurationStatus.Running );
result = layer.Items.Add( pluginId, ConfigurationStatus.Running );
Assert.That( result, Is.True, "Adding the same plugin twice, in the same state, is a valid operation." );
Assert.That( layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count." );
result = layer.Items.Add( pluginId, ConfigurationStatus.Optional );
Assert.That( result, Is.False, "Layer override precedence: changing Running status is not valid." );
result = layer.Items.Add( pluginId, ConfigurationStatus.Runnable );
Assert.That( result, Is.False, "Layer override precedence: changing Running status is not valid." );
result = layer.Items.Add( pluginId, ConfigurationStatus.Disable );
Assert.That( result, Is.False, "Layer override precedence: changing Running status is not valid." );
result = layer.Items.Remove( pluginId );
Assert.That( result, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent." );
// Precedence test for Optional -> Runnable -> Running
pluginId = Guid.NewGuid().ToString();
result = layer.Items.Add( pluginId, ConfigurationStatus.Optional );
Assert.That( result, Is.True );
Assert.That( layer.Items[pluginId].Status == ConfigurationStatus.Optional );
result = layer.Items.Add( pluginId, ConfigurationStatus.Optional );
Assert.That( result, Is.True, "Adding the same plugin twice, in the same state, is a valid operation." );
Assert.That( layer.Items.Count == 1, "Adding the same plugin twice, in the same state, does not actually add it and increment the count." );
result = layer.Items.Add( pluginId, ConfigurationStatus.Runnable );
Assert.That( result, Is.False, "Layer override precedence: Optional -> Runnable is a valid operation." );
Assert.That( layer.Items[pluginId].Status == ConfigurationStatus.Runnable );
result = layer.Items.Add( pluginId, ConfigurationStatus.Running );
Assert.That( result, Is.False, "Layer override precedence: Runnable -> Running is a valid operation." );
Assert.That( layer.Items[pluginId].Status == ConfigurationStatus.Running );
Assert.That( layer.Items.Count == 1, "Adding the same plugin over and over does not actually increment the count." );
result = layer.Items.Remove( pluginId );
Assert.That( result, Is.True, "Plugin can always be removed if it exists and layer isn't bound to a parent." );
}
