public void RegisterAreas_SkipRegisterIfEventSourceDoesExist()
{
//Arrange
var areas = new DiagnosticsAreaCollection();
DiagnosticsArea area = new DiagnosticsArea("test");
areas.Add(area);
MEventLog.SourceExistsString = (s) => true;
string sourceName = null;
string logName = null;
int registerCnt = 0;
MEventLog.CreateEventSourceStringString = (s, l) =>
{
sourceName = s;
logName = l;
registerCnt++;
};
// Act
DiagnosticsAreaEventSource.RegisterAreas(areas);
// Assert
Assert.IsTrue(registerCnt == 0);
Assert.IsNull(sourceName);
Assert.IsNull(logName);
}
public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
{
var configManager = SharePointServiceLocator.GetCurrent().GetInstance<IConfigManager>();
var configuredAreas = new DiagnosticsAreaCollection(configManager);
foreach (var area in Areas)
{
var areaToRemove = configuredAreas[area.Name];
if (areaToRemove != null)
{
foreach (var c in area.DiagnosticsCategories)
{
var existingCat = areaToRemove.DiagnosticsCategories[c.Name];
if (existingCat != null)
{
areaToRemove.DiagnosticsCategories.Remove(existingCat);
}
}
if (areaToRemove.DiagnosticsCategories.Count == 0)
{
configuredAreas.Remove(areaToRemove);
}
}
}
configuredAreas.SaveConfiguration();
}
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
var configManager = SharePointServiceLocator.GetCurrent().GetInstance<IConfigManager>();
var configuredAreas = new DiagnosticsAreaCollection(configManager);
foreach (var newArea in Areas)
{
var existingArea = configuredAreas[newArea.Name];
if (existingArea == null)
{
configuredAreas.Add(newArea);
}
else
{
foreach (var category in newArea.DiagnosticsCategories)
{
var existingCategory = existingArea.DiagnosticsCategories[category.Name];
if (existingCategory == null)
{
existingArea.DiagnosticsCategories.Add(category);
}
}
}
}
configuredAreas.SaveConfiguration();
DiagnosticsAreaEventSource.EnsureConfiguredAreasRegistered();
}
public void RegisterAreas_EventSourceDoesntExist()
{
//Arrange
var areas = new DiagnosticsAreaCollection();
DiagnosticsArea area = new DiagnosticsArea("test");
areas.Add(area);
MEventLog.SourceExistsString = (s) => false;
string[] sourceNames = new string[2];
int sourceCnt = 0;
string [] logNames = new string [2];
MEventLog.CreateEventSourceStringString = (s, l) =>
{
if (sourceCnt < 2)
{
sourceNames[sourceCnt] = s;
logNames[sourceCnt] = l;
}
sourceCnt++;
};
// Act
DiagnosticsAreaEventSource.RegisterAreas(areas);
// Assert
Assert.IsTrue(sourceCnt == 2);
Assert.AreEqual <string>(area.Name, sourceNames[0]);
Assert.AreEqual <string>(Constants.EventLogName, logNames[0]);
Assert.AreEqual <string>(DiagnosticsArea.DefaultSPDiagnosticsArea.Name, sourceNames[1]);
Assert.AreEqual <string>(Constants.EventLogName, logNames[1]);
}
private static DiagnosticsAreaCollection GetCurrentAreas()
{
IServiceLocator serviceLocator = SharePointServiceLocator.GetCurrent();
IConfigManager config = serviceLocator.GetInstance<IConfigManager>();
DiagnosticsAreaCollection areaCollection = new DiagnosticsAreaCollection(config);
return areaCollection;
}
public void EnsureConfiguredAreasRegistered_RegistersConfiguredAreas()
{
//Arrange
var areas = new DiagnosticsAreaCollection();
var newLocator = new ActivatingServiceLocator();
SharePointServiceLocator.ReplaceCurrentServiceLocator(newLocator);
newLocator.RegisterTypeMapping <IConfigManager, MockConfigManager>();
var sourceNames = new List <string>();
var logNames = new List <string>();
DiagnosticsArea area = new DiagnosticsArea("test");
areas.Add(area);
MEventLog.SourceExistsString = (s) => false;
MEventLog.CreateEventSourceStringString = (s, l) =>
{
sourceNames.Add(s);
logNames.Add(l);
};
// Act
DiagnosticsAreaEventSource.EnsureConfiguredAreasRegistered();
// Assert
Assert.AreEqual(3, sourceNames.Count);
Assert.AreEqual(MockConfigManager.Area1Name, sourceNames[0]);
Assert.AreEqual(MockConfigManager.Area2Name, sourceNames[1]);
Assert.AreEqual <string>(Constants.EventLogName, logNames[0]);
Assert.AreEqual <string>(Constants.EventLogName, logNames[1]);
Assert.AreEqual(DiagnosticsArea.DefaultSPDiagnosticsArea.Name, sourceNames[2]);
Assert.AreEqual <string>(Constants.EventLogName, logNames[2]);
}
public void Save_AreasConfigurationWithStubs()
{
//Arrange
int saveCount = 0;
var propBag = new BIPropertyBag();
var config = new SIConfigManager
{
ContainsKeyInPropertyBagStringIPropertyBag = (key, bag) =>
{
return(false);
},
SetInPropertyBagStringObjectIPropertyBag = (key, o, bag) =>
{
if (key == Constants.AreasConfigKey)
{
saveCount++;
}
},
GetPropertyBagConfigLevel = (level) => propBag,
};
DiagnosticsAreaCollection areas = new DiagnosticsAreaCollection(config);
//Act
areas.SaveConfiguration();
//Assert
Assert.IsTrue(saveCount == 1);
}
/// <summary>
/// Registers the logger source.
/// </summary>
/// <param name="LoggingArea">The logging area.</param>
/// <param name="categories">The area categories.</param>
public static void RegisterLoggerSource(string LoggingArea, string[] categories)
{
DiagnosticsArea _newArea = new DiagnosticsArea(LoggingArea);
foreach (string _cn in categories)
{
_newArea.DiagnosticsCategories.Add(new DiagnosticsCategory(_cn, EventSeverity.Verbose, TraceSeverity.Verbose));
}
IConfigManager configMgr = SharePointServiceLocator.GetCurrent().GetInstance <IConfigManager>();
DiagnosticsAreaCollection _configuredAreas = new DiagnosticsAreaCollection(configMgr);
var existingArea = _configuredAreas[_newArea.Name];
if (existingArea == null)
{
_configuredAreas.Add(_newArea);
}
else
{
foreach (DiagnosticsCategory _dc in _newArea.DiagnosticsCategories)
{
DiagnosticsCategory existingCategory = existingArea.DiagnosticsCategories[_dc.Name];
if (existingCategory == null)
{
existingArea.DiagnosticsCategories.Add(_dc);
}
}
}
_configuredAreas.SaveConfiguration();
}
private static bool ExistArea(DiagnosticsAreaCollection collection, string areaName)
{
foreach (DiagnosticsArea item in collection)
{
if (item.Name.Trim().ToUpper() == areaName.Trim().ToUpper())
return true;
}
return false;
}
public void Indexer_WithMissingKey_ReturnsNull()
{
//Arrange
//Act
var target = new DiagnosticsAreaCollection();
//Assert
Assert.IsNull(target["{E6C24B3D-8A81-4E0A-AAC9-85E5A5B9C09A}"]);
}
public void Remove_NullAreaDoesntThrowException()
{
//Arrange
MockConfigManager config = new MockConfigManager();
DiagnosticsAreaCollection areas = new DiagnosticsAreaCollection(config);
//Act
areas.Remove(null);
// Assert - no action required, it should be a no-op
}
/// <summary>
/// Unregisters the logger source.
/// </summary>
/// <param name="loggingArea">The logging area.</param>
public static void UnregisterLoggerSource(string loggingArea)
{
IConfigManager _configMgr = SharePointServiceLocator.GetCurrent().GetInstance <IConfigManager>();
DiagnosticsAreaCollection _configuredAreas = new DiagnosticsAreaCollection(_configMgr);
DiagnosticsArea areaToRemove = _configuredAreas[loggingArea];
if (areaToRemove != null)
{
_configuredAreas.Remove(areaToRemove);
}
_configuredAreas.SaveConfiguration();
}
public void Save_AreasConfiguration()
{
//Arrange
MockConfigManager config = new MockConfigManager();
DiagnosticsAreaCollection areas = new DiagnosticsAreaCollection(config);
//Act
areas.SaveConfiguration();
//Assert
Assert.IsTrue(config.SaveCount == 1);
}
public void Add_WithDefaultConstructor()
{
//Arrange
var target = new DiagnosticsAreaCollection();
var expected = new DiagnosticsArea(TestsConstants.TestGuidName);
//Act
target.Add(expected);
//Assert
Assert.AreEqual <DiagnosticsArea>(target[0], expected);
}
public void Save_AreasConfiguration_WithBehavedTypes()
{
//Arrange
var config = new MockLoggingConfigMgr();
DiagnosticsAreaCollection areas = new DiagnosticsAreaCollection(config);
//Act
areas.SaveConfiguration();
//Assert
Assert.IsTrue(config.SaveCount == 1);
}
public void Add_AreaWithConfigMgrConstructorWithConfigData()
{
//Arrange
var configMgr = new MockConfigManager();
var target = new DiagnosticsAreaCollection(configMgr);
var expected = new DiagnosticsArea(TestsConstants.TestGuidName);
//Act
target.Add(expected);
//Assert
Assert.AreEqual <DiagnosticsArea>(target[TestsConstants.TestGuidName], expected);
}
public MockConfigManager()
{
this.Areas = new DiagnosticsAreaCollection();
DiagnosticsArea area1 = new DiagnosticsArea(Area1Name);
DiagnosticsArea area2 = new DiagnosticsArea(Area2Name);
area1.DiagnosticsCategories.Add(new DiagnosticsCategory(Area1Category1Name, EventSeverity.ErrorCritical, TraceSeverity.Medium));
area1.DiagnosticsCategories.Add(new DiagnosticsCategory(Area1Category2Name, EventSeverity.ErrorCritical, TraceSeverity.Medium));
area2.DiagnosticsCategories.Add(new DiagnosticsCategory(Area2Category1Name, EventSeverity.ErrorCritical, TraceSeverity.Medium));
area2.DiagnosticsCategories.Add(new DiagnosticsCategory(Area2Category2Name, EventSeverity.ErrorCritical, TraceSeverity.Medium));
this.Areas.Add(area1);
this.Areas.Add(area2);
}
public void CTOR_WithNoConfigurationSet()
{
//Arrange
var config = new MockConfigManager();
config.Clear();
//Act
var target = new DiagnosticsAreaCollection(config);
//Assert
Assert.IsTrue(target.Count == 0);
}
public void CTOR_WithConfigurationMgr_WithoutLogginConfigurationSucceeds()
{
//Arrange
var configMgr = new SIConfigManager();
var propBag = new BIPropertyBag();
configMgr.ContainsKeyInPropertyBagStringIPropertyBag = (key, bag) => false;
configMgr.GetPropertyBagConfigLevel = (configLevel) => propBag;
//Act
var target = new DiagnosticsAreaCollection(configMgr);
//Assert
Assert.IsTrue(target.Count == 0);
}
public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
SPWebApplication app = properties.Feature.Parent as SPWebApplication;
IConfigManager configMgr = SharePointServiceLocator.GetCurrent().GetInstance<IConfigManager>();
DiagnosticsAreaCollection configuredAreas = new DiagnosticsAreaCollection(configMgr);
try
{
foreach (DiagnosticsArea newArea in MyAreas)
{
var existingArea = configuredAreas[newArea.Name];
if (existingArea == null)
{
configuredAreas.Add(newArea);
}
else
{
throw new SPException("Diagnostic area already exists");
}
}
configuredAreas.SaveConfiguration();
DiagnosticsAreaEventSource.EnsureConfiguredAreasRegistered();
}
catch (Exception) {} // TODO - uninstall diagnostic areas
// Get the ServiceLocatorConfig service from the service locator.
IServiceLocator serviceLocator = SharePointServiceLocator.GetCurrent();
IServiceLocatorConfig serviceLocatorConfig =
serviceLocator.GetInstance<IServiceLocatorConfig>();
try
{
var testInstance = new LoupeLog();
testInstance.LogInfo("Registered type mapping for Loupe");
serviceLocatorConfig.RegisterTypeMapping<ILogging, LoupeLog>();
}
catch (FileNotFoundException)
{
var testInstance = new NaverticaLog();
testInstance.LogInfo("Registered type mapping for NaverticaLog");
serviceLocatorConfig.RegisterTypeMapping<ILogging, NaverticaLog>();
}
SharePointServiceLocator.Reset();
}
public void Indexer_FindByStringIndexer()
{
//Arrange
const string AreaName = "{E6C24B3D-8A81-4E0A-AAC9-85E5A5B9C09A}";
var target = new DiagnosticsAreaCollection();
var expected = new DiagnosticsArea(AreaName);
target.Add(expected);
//Act
DiagnosticsArea foundArea = target[AreaName];
//Assert
Assert.IsNotNull(foundArea);
Assert.AreEqual <DiagnosticsArea>(expected, foundArea);
}
public void CTOR_WithConfiguration()
{
//Arrange
var expected = new MockConfigManager();
//Act
var target = new DiagnosticsAreaCollection(expected);
//Assert
Assert.IsTrue(target.Count == expected.Areas.Count);
for (int i = 0; i < target.Count; i++)
{
Assert.AreEqual <DiagnosticsArea>(target[i], expected.Areas[i]);
}
}
public static void RegisterAreas(DiagnosticsAreaCollection areas)
{
Validation.ArgumentNotNull(areas, "areas");
foreach (DiagnosticsArea area in areas)
{
if (!EventLog.SourceExists(area.Name))
{
EventLog.CreateEventSource(area.Name, Constants.EventLogName);
}
}
if (!EventLog.SourceExists(DiagnosticsArea.DefaultSPDiagnosticsArea.Name))
{
EventLog.CreateEventSource(DiagnosticsArea.DefaultSPDiagnosticsArea.Name, Constants.EventLogName);
}
}
public void Add_WithConfigMgrConstructorWithoutConfigData()
{
//Arrange
var configMgr = new SIConfigManager();
var propBag = new BIPropertyBag();
configMgr.ContainsKeyInPropertyBagStringIPropertyBag = (key, bag) => false;
configMgr.GetPropertyBagConfigLevel = (level) => propBag;
var target = new DiagnosticsAreaCollection(configMgr);
var expected = new DiagnosticsArea(TestsConstants.TestGuidName);
//Act
target.Add(expected);
//Assert
Assert.AreEqual <DiagnosticsArea>(target[0], expected);
}
public void CTOR_WithNullConfigurationManager_ThrowsArgumentNullException()
{
//Arrange
bool expectedExceptionThrown = false;
//Act
try
{
var target = new DiagnosticsAreaCollection(null);
}
catch (ArgumentNullException)
{
expectedExceptionThrown = true;
}
//Assert
Assert.IsTrue(expectedExceptionThrown);
}
public void SaveConfiguration_WithDefaultConstructor_ThrowsInvalidOperationException()
{
//Arrange
DiagnosticsAreaCollection areas = new DiagnosticsAreaCollection();
bool expectedExceptionThrown = false;
//Act
try
{
areas.SaveConfiguration();
}
catch (InvalidOperationException)
{
expectedExceptionThrown = true;
}
Assert.IsTrue(expectedExceptionThrown);
}
public void Update_ByStringIndexer()
{
//Arrange
var config = new MockConfigManager();
var target = new DiagnosticsAreaCollection(config);
var expected = new DiagnosticsArea(MockConfigManager.Area1Name);
var category = new DiagnosticsCategory(Guid.NewGuid().ToString());
expected.DiagnosticsCategories.Add(category);
//Act
target[MockConfigManager.Area1Name] = expected;
//Assert
Assert.AreEqual <DiagnosticsArea>(target[MockConfigManager.Area1Name], expected);
Assert.IsTrue(target[MockConfigManager.Area1Name].DiagnosticsCategories.Count == 1);
Assert.AreEqual(target[MockConfigManager.Area1Name].DiagnosticsCategories[0], category);
}
public void Indexer_WithNullName_ThrowsArgumentNullException()
{
//Arrange
var target = new DiagnosticsAreaCollection();
bool expectedExceptionThrown = false;
//Act
try
{
DiagnosticsArea area = target[null];
}
catch (ArgumentNullException)
{
expectedExceptionThrown = true;
}
//Assert
Assert.IsTrue(expectedExceptionThrown, "Indexer with null index did not throw an exception");
}
public void Add_AreaWithNullName_ThrowsArgumentNullException()
{
//Arrange
var target = new DiagnosticsAreaCollection();
var area = new DiagnosticsArea();
bool expectedExceptionThrown = false;
//Act
try
{
target.Add(area);
}
catch (ArgumentNullException)
{
expectedExceptionThrown = true;
}
Assert.IsTrue(expectedExceptionThrown, "Adding area with a null area name did not throw exception");
}
public void Add_WithDefaultArea_ThrowsInvalidOperationException()
{
//Arrange
bool expectedExceptionThrown = false;
var target = new DiagnosticsAreaCollection();
var area = new DiagnosticsArea(Constants.DefaultAreaName);
//Act
try
{
target.Add(area);
}
catch (InvalidOperationException)
{
expectedExceptionThrown = true;
}
Assert.IsTrue(expectedExceptionThrown, "adding default area to areas collection failed");
}
public void Add_NullArea_ThrowsArgumentNullException()
{
//Arrange
var target = new DiagnosticsAreaCollection();
bool expectedExceptionThrown = false;
//Act
try
{
target.Add(null);
}
catch (ArgumentNullException)
{
expectedExceptionThrown = true;
}
//Assert
Assert.IsTrue(expectedExceptionThrown, "add with null area did not throw exception");
}
public void Update_ByStringIndexerWithNullValue_ThrowsArgumentNotNullException()
{
//Arrange
var config = new MockConfigManager();
var target = new DiagnosticsAreaCollection(config);
bool expectedExceptionThrown = false;
//Act
try
{
target[MockConfigManager.Area1Name] = null;
}
catch (ArgumentNullException)
{
expectedExceptionThrown = true;
}
//Assert
Assert.IsTrue(expectedExceptionThrown);
}
public void Remove_AreaRemoveDefault()
{
//Arrange
MockConfigManager config = new MockConfigManager();
DiagnosticsAreaCollection areas = new DiagnosticsAreaCollection(config);
DiagnosticsArea area = new DiagnosticsArea(MockConfigManager.Area2Name);
DiagnosticsCategory category = new DiagnosticsCategory(MockConfigManager.Area2Category1Name);
area.DiagnosticsCategories.Add(category);
int areasCount = areas.Count;
DiagnosticsArea originalArea = areas[MockConfigManager.Area2Name];
//Act
bool isRemoved = areas.Remove(originalArea);
//Assert
Assert.IsTrue(isRemoved);
Assert.IsNull(areas[MockConfigManager.Area2Name]);
}
public void Update_ByStringIndexerWithNullKey_ThrowsArgumentNullException()
{
//Arrange
var config = new MockConfigManager();
var target = new DiagnosticsAreaCollection(config);
var area = new DiagnosticsArea(TestsConstants.TestGuidName);
bool expectedExceptionThrown = false;
//Act
try
{
target[null] = area;
}
catch (ArgumentNullException)
{
expectedExceptionThrown = true;
}
//Assert
Assert.IsTrue(expectedExceptionThrown);
}
public void Update_ByStringIndexerWithNullAreaName_ThrowsArgumentNullException()
{
//Arrange
var config = new MockConfigManager();
var target = new DiagnosticsAreaCollection(config);
var area = new DiagnosticsArea();
bool expectedExceptionThrown = false;
//Act
try
{
target[MockConfigManager.Area1Name] = area;
}
catch (ArgumentNullException)
{
expectedExceptionThrown = true;
}
//Assert
Assert.IsTrue(expectedExceptionThrown, "did not throw exception with null area name");
}
public void Update_ByStringIndexerWithDuplicateArea_ThrowsInvalidOperationException()
{
//Arrange
var config = new MockConfigManager();
var target = new DiagnosticsAreaCollection(config);
var area = new DiagnosticsArea(MockConfigManager.Area2Name);
bool expectedExceptionThrown = false;
//Act
try
{
target[MockConfigManager.Area1Name] = area;
}
catch (InvalidOperationException)
{
expectedExceptionThrown = true;
}
//Assert
Assert.IsTrue(expectedExceptionThrown, "exception not thrown with duplicate area added");
}
private static bool HasArea(DiagnosticsAreaCollection collection, string areaName)
{
return collection.Any(x => string.Equals(x.Name.Trim(), areaName.Trim(), StringComparison.OrdinalIgnoreCase));
}
protected override IEnumerable<SPDiagnosticsArea> ProvideAreas()
{
IConfigManager config = SharePointServiceLocator.GetCurrent().GetInstance<IConfigManager>();
IEnumerable<DiagnosticsArea> diagnosticsAreas = new DiagnosticsAreaCollection(config);
List<SPDiagnosticsArea> spAreas = new List<SPDiagnosticsArea>();
foreach (DiagnosticsArea area in diagnosticsAreas)
{
List<SPDiagnosticsCategory> spCategories = new List<SPDiagnosticsCategory>();
foreach (DiagnosticsCategory category in area.DiagnosticsCategories)
{
spCategories.Add(category.ToSPDiagnosticsCategory());
}
SPDiagnosticsArea spArea = new SPDiagnosticsArea(area.Name, spCategories);
spAreas.Add(spArea);
}
spAreas.Add(DiagnosticsArea.DefaultSPDiagnosticsArea);
return spAreas;
}
public static void EnsureConfiguredAreasRegistered()
{
var mgr = SharePointServiceLocator.GetCurrent().GetInstance<IConfigManager>();
var areas = new DiagnosticsAreaCollection(mgr);
RegisterAreas(areas);
}
