/// <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();
}
public bool AddDiagnosticArea(DiagnosticsArea area)
{
bool retVal = false;
var existingArea = configuredAreas[area.Name];
if (existingArea == null)
{
configuredAreas.Add(area);
}
else
{
foreach (DiagnosticsCategory c in area.DiagnosticsCategories)
{
var existingCategory = existingArea.DiagnosticsCategories[c.Name];
if (existingCategory == null)
{
existingArea.DiagnosticsCategories.Add(c);
retVal = true;
}
}
}
return(retVal);
}
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]);
}
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 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]);
}
/// <summary>
/// Configures the area.
/// </summary>
/// <param name="areaName">Name of the area.</param>
/// <param name="categories">The categories.</param>
public static void ConfigureArea(string areaName, string[] categories)
{
var diagnosticsArea = new DiagnosticsArea(areaName);
foreach (string category in categories)
{
diagnosticsArea.DiagnosticsCategories.Add(new DiagnosticsCategory(category));
}
AddArea(diagnosticsArea);
}
public void CreateNameAndValuesConstructorWithNullNameThrowsArgumentNullException()
{
//Arrange
var diagnosticsCategories = new DiagnosticsCategoryCollection();
//Act
var area = new DiagnosticsArea(null, diagnosticsCategories);
// Assert caught by exception
}
public void CreateNameConstructorWithNullNameThrowsArgumentNullException()
{
//Arrange
//Act
var area = new DiagnosticsArea(null);
// Assert caught by exception
}
public void SetAreaNameToNullThrowsArgumentNullException()
{
//Arrange
var area = new DiagnosticsArea("test name");
//Act
area.Name = null;
// Assert (capture by ExpectedException)
}
public void CreateNameConstructorSucceeds()
{
//Arrange
const string areaName = TestsConstants.TestGuidName;
//Act
var area = new DiagnosticsArea(areaName);
// Assert
Assert.AreEqual <string>(areaName, area.Name);
Assert.AreEqual <int>(0, area.DiagnosticsCategories.Count);
}
public void CreateDefaultConstructorSucceeds()
{
//Arrange
//Act
var area = new DiagnosticsArea();
// Assert
Assert.AreEqual <string>(null, area.Name);
Assert.AreEqual <int>(0, area.DiagnosticsCategories.Count);
}
public void CreateNameAndValuesConstructorWithNullAreasSucceeds()
{
//Arrange
//Act
var area = new DiagnosticsArea("name", null);
// Assert
Assert.AreEqual <string>("name", area.Name);
Assert.AreEqual <int>(0, area.DiagnosticsCategories.Count);
}
public void SetAreaNameSucceeds()
{
//Arrange
var expected = TestsConstants.TestGuidName;
var area = new DiagnosticsArea();
//Act
area.Name = expected;
// Assert
Assert.AreEqual(expected, area.Name);
}
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);
}
/// <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 GetAreaNameSucceeds()
{
//Arrange
var expected = TestsConstants.TestGuidName;
var area = new DiagnosticsArea(expected);
//Act
string result = area.Name;
// Assert
Assert.AreEqual(expected, result);
}
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);
}
private List <DiagnosticsArea> BuildDiagnosticAreas()
{
List <DiagnosticsArea> retVal = new List <DiagnosticsArea>();
DiagnosticsArea treasuryEcmArea = new DiagnosticsArea("Treasury.ECM.DOI");
foreach (DiagnosticsCategories category in Enum.GetValues(typeof(DiagnosticsCategories)))
{
treasuryEcmArea.DiagnosticsCategories.Add(new DiagnosticsCategory(Enum.GetName(typeof(DiagnosticsCategories), category), EventSeverity.Error, TraceSeverity.Unexpected));
}
retVal.Add(treasuryEcmArea);
return(retVal);
}
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 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 TranslateToSPDiagnosticsAreaSucceeds()
{
//Arrange
var testCategory = "{0FE74678-8734-4355-AC62-45D8D211C3E6}";
var testArea = "{DBAB3052-B89B-4D26-BB67-EF489C44CA57}";
var area = new DiagnosticsArea(testArea);
var category = new DiagnosticsCategory(testCategory);
area.DiagnosticsCategories.Add(category);
//Act
var spArea = area.ToSPDiagnosticsArea();
//Assert
Assert.AreEqual <string>(spArea.Name, testArea);
Assert.AreEqual <string>(spArea.LocalizedName, testArea);
}
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 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 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 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_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");
}
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_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);
}
