public void FindCategoryWithValidCategorySucceeds()
{
//Arrange
var replaceLocator = new ActivatingServiceLocator();
SharePointServiceLocator.ReplaceCurrentServiceLocator(replaceLocator);
replaceLocator.RegisterTypeMapping <IHierarchicalConfig, MockHierarchicalConfig>(InstantiationType.AsSingleton);
replaceLocator.RegisterTypeMapping <IConfigManager, MockConfigManager>(InstantiationType.AsSingleton);
var target = new DiagnosticsService();
var config = SharePointServiceLocator.GetCurrent().GetInstance <IConfigManager>() as MockConfigManager;
string category11Name = string.Format("{0}/{1}", MockConfigManager.Area1Name, MockConfigManager.Area1Category1Name);
string category21Name = string.Format("{0}/{1}", MockConfigManager.Area2Name, MockConfigManager.Area2Category1Name);
string category12Name = string.Format("{0}/{1}", MockConfigManager.Area1Name, MockConfigManager.Area1Category2Name);
string category22Name = string.Format("{0}/{1}", MockConfigManager.Area2Name, MockConfigManager.Area2Category2Name);
//Act
SPDiagnosticsCategory category11 = target.FindCategory(category11Name);
SPDiagnosticsCategory category12 = target.FindCategory(category12Name);
SPDiagnosticsCategory category21 = target.FindCategory(category21Name);
SPDiagnosticsCategory category22 = target.FindCategory(category22Name);
// Assert
Assert.AreEqual(MockConfigManager.Area1Category1Name, category11.Name);
Assert.AreEqual(MockConfigManager.Area1Category2Name, category12.Name);
Assert.AreEqual(MockConfigManager.Area2Category1Name, category21.Name);
Assert.AreEqual(MockConfigManager.Area2Category2Name, category22.Name);
Assert.AreEqual(MockConfigManager.Area1Name, category11.Area.Name);
Assert.AreEqual(MockConfigManager.Area1Name, category12.Area.Name);
Assert.AreEqual(MockConfigManager.Area2Name, category21.Area.Name);
Assert.AreEqual(MockConfigManager.Area2Name, category22.Area.Name);
Assert.IsTrue(config.LoadedCount == 1);
}
public void Remove(string key)
{
var logger = SharePointServiceLocator.GetCurrent().GetInstance <ILogger>();
rrLock.EnterWriteLock();
try
{
//intentionally nested, both cases getting a write lock, is safe and ensures no race.
//Force the reload of the persisted object, which minimizes chances of a failure due
// to a concurrency failure.
Reset();
WebAppSettingStore store = GetWriteSettingStore();
if (store.Settings.ContainsKey(key))
{
store.Settings.Remove(key);
store.Update();
}
}
catch (SPUpdatedConcurrencyException)
{
Reset();
throw;
}
finally
{
rrLock.ExitWriteLock();
}
}
public void Init()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IHierarchicalConfig, MockHierarchicalConfig>(InstantiationType.AsSingleton));
config = SharePointServiceLocator.Current.GetInstance <IHierarchicalConfig>() as MockHierarchicalConfig;
}
/// <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();
}
protected void areaResultsGridView_RowCommand(object sender, GridViewCommandEventArgs e)
{
AreaDisplayTypes displayType =
(AreaDisplayTypes)System.Enum.Parse(typeof(AreaDisplayTypes), AreaRadioButton.SelectedValue);
int selectedAreaId =
int.Parse(AreaResultsGridView.DataKeys[int.Parse(e.CommandArgument.ToString())].Value.ToString());
using (var partManagementRepository = SharePointServiceLocator.GetCurrent().GetInstance <IPartManagementRepository>())
{
IEnumerable <MachineDTO> machines = null;
switch (displayType)
{
case AreaDisplayTypes.Category:
machines = partManagementRepository.GetMachinesByCategory(selectedAreaId);
break;
case AreaDisplayTypes.Manufacturer:
machines = partManagementRepository.GetMachinesByManufacturer(selectedAreaId);
break;
case AreaDisplayTypes.Department:
machines = partManagementRepository.GetMachinesByDepartment(selectedAreaId);
break;
}
ShowMachines(machines);
}
}
public static void EnsureConfiguredAreasRegistered()
{
var mgr = SharePointServiceLocator.GetCurrent().GetInstance <IConfigManager>();
var areas = new DiagnosticsAreaCollection(mgr);
RegisterAreas(areas);
}
public void GetPartnerSiteCollectionUrl()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IHierarchicalConfig, MockConfigManager>()
.RegisterTypeMapping <ILogger, MockLogger>(InstantiationType.AsSingleton));
SPFarm fakeFarm = Isolate.Fake.Instance <SPFarm>();
Isolate.WhenCalled(() => SPFarm.Local).WillReturn(fakeFarm);
SPSite fakeSite = Isolate.Fake.Instance <SPSite>();
Isolate.Swap.NextInstance <SPSite>().With(fakeSite);
SPWeb fakeWeb = fakeSite.OpenWeb();
SPList fakeList = fakeWeb.Lists["Sites"];
SPListItemCollection fakeItems = fakeList.GetItems(new SPQuery());
Isolate.WhenCalled(() => fakeItems.Count).WillReturn(1);
SPListItem fakeItem = fakeItems[0];
Isolate.WhenCalled(() => fakeItem["URL"]).WillReturn("http://localhost, http://localhost");
PartnerSiteDirectory target = new PartnerSiteDirectory();
string expected = "http://localhost";
string actual;
actual = target.GetPartnerSiteCollectionUrl("TestPartnerId");
MockLogger logger = SharePointServiceLocator.Current.GetInstance <ILogger>() as MockLogger;
Assert.AreEqual(logger.loggedMessage, string.Format("PartnerSiteDirectory FindPartnerMappingForCurrentPartner CAML: <Where><Eq><FieldRef ID='{0}'/><Value Type='Text'>TestPartnerId</Value></Eq></Where>", FieldIds.PartnerFieldId));
Assert.AreEqual(expected, actual);
}
public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
{
try
{
IServiceLocator serviceLocator = SharePointServiceLocator.GetCurrent();
IServiceLocatorConfig typeMappings = serviceLocator.GetInstance <IServiceLocatorConfig>();
typeMappings.Site = SPContext.Current.Site;
typeMappings.RemoveTypeMappings <LicenseRepository>();
typeMappings.RemoveTypeMappings <PageLayoutRepository>();
typeMappings.RemoveTypeMappings <MasterPageRepository>();
}
catch (Exception ex)
{
ex.ToString();
}
try
{
SPUserCodeService userCodeService = SPUserCodeService.Local;
RemoveProxyOperation(userCodeService, ContainsKeyDataArgs.OperationAssemblyName, ContainsKeyDataArgs.OperationTypeName);
RemoveProxyOperation(userCodeService, ReadConfigArgs.OperationAssemblyName, ReadConfigArgs.OperationTypeName);
RemoveProxyOperation(userCodeService, ProxyInstalledArgs.OperationAssemblyName, ProxyInstalledArgs.OperationTypeName);
userCodeService.Update();
}
catch (Exception ex)
{
ex.ToString();
}
}
public void FeatureActivatedTest()
{
SPFeatureReceiverProperties properties = Isolate.Fake.Instance <SPFeatureReceiverProperties>(Members.ReturnRecursiveFakes);
SPFarm fakeSPFarm = Isolate.Fake.Instance <SPFarm>(Members.ReturnRecursiveFakes);
Isolate.WhenCalled(() => SPFarm.Local).WillReturn(fakeSPFarm);
Hashtable farmProperties = new Hashtable();
Isolate.WhenCalled(() => fakeSPFarm.Properties).WillReturn(farmProperties);
MockConfigManager.ReturnValue = "http://localhost";
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IConfigManager, MockConfigManager>()
.RegisterTypeMapping <ILogger, MockLogger>());
SPWeb fakeSPWeb = Isolate.Fake.Instance <SPWeb>(Members.ReturnRecursiveFakes);
Isolate.WhenCalled(() => properties.Feature.Parent).WillReturn(fakeSPWeb);
SPWorkflowAssociation fakeAssociation = Isolate.Fake.Instance <SPWorkflowAssociation>(Members.ReturnRecursiveFakes);
Isolate.WhenCalled(() => SPWorkflowAssociation.CreateListAssociation(null, "", null, null)).WillReturn(fakeAssociation);
FeatureReceiver target = new FeatureReceiver();
target.FeatureActivated(properties);
Isolate.Verify.WasCalledWithAnyArguments(() => fakeSPWeb.Lists["Sub Site Creation Requests"].Update());
}
public void GetBusinessEventTypeConfigurationNoItems()
{
MockConfigManager.ReturnValue = "http://localhost";
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator().RegisterTypeMapping <IHierarchicalConfig, MockConfigManager>());
SPSite fakeSite = Isolate.Fake.Instance <SPSite>(Members.ReturnRecursiveFakes);
Isolate.Swap.NextInstance <SPSite>().With(fakeSite);
SPWeb fakeWeb = Isolate.Fake.Instance <SPWeb>(Members.ReturnRecursiveFakes);
Isolate.WhenCalled(() => fakeSite.OpenWeb()).WillReturn(fakeWeb);
SPFarmPropertyBag spFarmPropertyBag = Isolate.Fake.Instance <SPFarmPropertyBag>();
Isolate.Swap.NextInstance <SPFarmPropertyBag>().With(spFarmPropertyBag);
SPList fakeList = fakeWeb.Lists["Business Event Type Configuration"];
SPListItemCollection fakeItems = fakeList.GetItems(new SPQuery());
Isolate.WhenCalled(() => fakeItems.Count).WillReturn(0);
BusinessEventTypeConfigurationRepository target = new BusinessEventTypeConfigurationRepository();
target.GetBusinessEventTypeConfiguration("");
}
public ManageMasterPages()
{
serviceLocator = SharePointServiceLocator.GetCurrent();
serviceMasterPages = serviceLocator.GetInstance <IMasterPageRepository>();
cmurl = SPContext.Current.Site.RootWeb.CustomMasterUrl;
murl = SPContext.Current.Site.RootWeb.MasterUrl;
}
public void TraceWithNullDefaultCategorySucceeds()
{
//Arrange
var replaceLocator = new ActivatingServiceLocator();
SharePointServiceLocator.ReplaceCurrentServiceLocator(replaceLocator);
replaceLocator.RegisterTypeMapping <IHierarchicalConfig, MockHierarchicalConfig>(InstantiationType.AsSingleton);
replaceLocator.RegisterTypeMapping <IConfigManager, MockConfigManager>(InstantiationType.AsSingleton);
var service = new DiagnosticsService();
bool traceLogWritten = false;
SPDiagnosticsCategory target = null;
MSPDiagnosticsServiceBase.AllInstances.WriteTraceUInt32SPDiagnosticsCategoryTraceSeverityStringObjectArray
= (diagnosticsServiceBase, ID, category, severity, str1, obj) =>
{
traceLogWritten = true;
target = category;
};
//Act
service.LogTrace("Message", 99, TraceSeverity.Verbose, null);
//Assert
Assert.IsTrue(traceLogWritten);
Assert.AreEqual <SPDiagnosticsCategory>(service.DefaultCategory, target);
}
public void LogEventWithEmptyStringDefaultCategorySucceeds()
{
//Arrange
var replaceLocator = new ActivatingServiceLocator();
SharePointServiceLocator.ReplaceCurrentServiceLocator(replaceLocator);
replaceLocator.RegisterTypeMapping <IHierarchicalConfig, MockHierarchicalConfig>(InstantiationType.AsSingleton);
replaceLocator.RegisterTypeMapping <IConfigManager, MockConfigManager>(InstantiationType.AsSingleton);
var service = new DiagnosticsService();
SPDiagnosticsCategory target = null;
bool eventLogWritten = false;
MSPDiagnosticsServiceBase.AllInstances.WriteEventUInt16SPDiagnosticsCategoryEventSeverityStringObjectArray
= (diagnosticsServiceBase, ID, category, severity, str1, obj) =>
{
eventLogWritten = true;
target = category;
};
//Act
service.LogEvent("Message", 99, EventSeverity.Information, string.Empty);
//Assert
Assert.IsTrue(eventLogWritten);
Assert.AreEqual <SPDiagnosticsCategory>(service.DefaultCategory, target);
}
public void ProvideAreasSucceeds()
{
//Arrange
var target = new TestableProvideAreas();
var replaceLocator = new ActivatingServiceLocator();
SharePointServiceLocator.ReplaceCurrentServiceLocator(replaceLocator);
replaceLocator.RegisterTypeMapping <IConfigManager, MockConfigManager>(InstantiationType.AsSingleton);
replaceLocator.RegisterTypeMapping <IHierarchicalConfig, MockHierarchicalConfig>(InstantiationType.AsSingleton);
//Act
IEnumerable <SPDiagnosticsArea> result = target.TestProvideAreas();
// Assert
List <SPDiagnosticsArea> list = new List <SPDiagnosticsArea>(result);
Assert.IsTrue(list.Count == 3);
Assert.AreEqual(MockConfigManager.Area1Name, list[0].Name);
Assert.AreEqual(MockConfigManager.Area2Name, list[1].Name);
Assert.AreEqual(target.DefaultCategory.Area.Name, list[2].Name);
Assert.IsTrue(list[0].Categories[MockConfigManager.Area1Category1Name] != null);
Assert.IsTrue(list[0].Categories[MockConfigManager.Area1Category2Name] != null);
Assert.IsTrue(list[1].Categories[MockConfigManager.Area2Category1Name] != null);
Assert.IsTrue(list[1].Categories[MockConfigManager.Area2Category2Name] != null);
Assert.IsTrue(list[2].Categories[target.DefaultCategory.Name] != null);
}
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 TheServiceLocatorFromCommonServiceLocatorThrowsClearErrorMessage()
{
Isolate.WhenCalled(() => SPFarm.Local).WillReturn(Isolate.Fake.Instance <SPFarm>());
ServiceLocatorConfig fakeConfig = Isolate.Fake.Instance <ServiceLocatorConfig>();
Isolate.Swap.NextInstance <ServiceLocatorConfig>().With(fakeConfig);
Isolate.WhenCalled(() => fakeConfig.GetTypeMappings()).WillReturn(null);
SharePointServiceLocator.Reset();
var sl = SharePointServiceLocator.Current;
try
{
var sl1 = ServiceLocator.Current;
Assert.Fail();
}
catch (NotSupportedException ex)
{
Assert.AreEqual(ex.Message,
"ServiceLocator.Current is not supported. Use SharePointServiceLocator.Current instead.");
}
catch (Exception)
{
Assert.Fail();
}
}
public void RedirectToBusinessEventNoTopLevelSite()
{
MockBusinessEventTypeConfiguration.ReturnValue = new BusinessEventTypeConfiguration {
TopLevelSiteRelativeUrl = "incident"
};
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IBusinessEventTypeConfigurationRepository, MockBusinessEventTypeConfiguration>()
.RegisterTypeMapping <IPartnerSiteDirectory, MockPartnerSiteDirectory>());
HttpContext fakeContext = Isolate.Fake.Instance <HttpContext>(Members.ReturnRecursiveFakes);
Isolate.WhenCalled(() => HttpContext.Current).WillReturn(fakeContext);
MockHttpResponse mockHttpResponse = new MockHttpResponse();
Isolate.Swap.CallsOn(HttpContext.Current.Response).WithCallsTo(mockHttpResponse);
SPSite fakeSite = Isolate.Fake.Instance <SPSite>(Members.ReturnRecursiveFakes);
Isolate.Swap.NextInstance <SPSite>().With(fakeSite);
SPWeb fakeWeb = fakeSite.OpenWeb("");
Isolate.WhenCalled(() => fakeWeb.Exists).WillReturn(false);
TestablePartnerRedirectController target = new TestablePartnerRedirectController();
string queryParamValue = "incident";
target.Redirect(queryParamValue);
Assert.AreEqual("/MySite/MyPage", mockHttpResponse.RedirectUrl);
}
public void Init()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <ILogger, MockLogger>(InstantiationType.AsSingleton));
logger = SharePointServiceLocator.Current.GetInstance <ILogger>() as MockLogger;
}
/// <summary>
/// Calls the remote service.
/// </summary>
/// <param name="requestUrl">The The URL of a Windows SharePoint Services "14" Web site.</param>
/// <param name="warnningList">The warnning list.</param>
public override void CallService(string requestUrl, List <Warnning> warnningList)
{
IServiceLocator serviceLocator = SharePointServiceLocator.GetCurrent();
ICWAccountFactory _cwFactory = serviceLocator.GetInstance <ICWAccountFactory>();
_cwFactory.CreateCWAccount(this, warnningList, requestUrl);
}
public void Setup()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator());
((ActivatingServiceLocator)SharePointServiceLocator.GetCurrent())
.RegisterTypeMapping <ITraceLogger, MockEventAndTraceLogger>(InstantiationType.AsSingleton)
.RegisterTypeMapping <IEventLogLogger, MockEventAndTraceLogger>(InstantiationType.AsSingleton);
}
public void GetCurrentPartnerIdReturnPartnerId()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IHierarchicalConfig, MockConfigManager>()
.RegisterTypeMapping <ILogger, MockLogger>());
SPFarm fakeFarm = Isolate.Fake.Instance <SPFarm>();
Isolate.WhenCalled(() => SPFarm.Local).WillReturn(fakeFarm);
Isolate.WhenCalled(() => ServerContext.GetContext(new SPSite(null))).WillReturn(null);
Isolate.WhenCalled(() => SPContext.Current.Site).WillReturn(null);
UserProfileManager fakeUserProfileManager = Isolate.Fake.Instance <UserProfileManager>();
Isolate.Swap.NextInstance <UserProfileManager>().With(fakeUserProfileManager);
UserProfile fakeUserProfile = Isolate.Fake.Instance <UserProfile>();
Isolate.WhenCalled(() => fakeUserProfileManager.GetUserProfile(string.Empty)).WillReturn(fakeUserProfile);
Isolate.WhenCalled(() => SPContext.Current.Web.CurrentUser.LoginName).WillReturn("User1");
Isolate.WhenCalled(() => fakeUserProfileManager.UserExists("User1")).WithExactArguments().WillReturn(true);
Isolate.WhenCalled(() => fakeUserProfile["PartnerId"].Value).WillReturn("TestPartnerId");
PartnerSiteDirectory target = new PartnerSiteDirectory();
string actualPartnerId = target.GetCurrentPartnerId();
Assert.AreEqual("TestPartnerId", actualPartnerId);
}
public void WhenLoggingFailsAClearExceptionIsThrown()
{
//Arrange
var target = new SharePointLogger();
string message = testMessageString;
((ActivatingServiceLocator)SharePointServiceLocator.GetCurrent())
.RegisterTypeMapping <IEventLogLogger, FailingEventLogger>();
//Act
try
{
target.LogToOperations(message, 99, EventSeverity.Error, TestsConstants.AreasCategories);
Assert.Fail();
}
//Assert
catch (LoggingException ex)
{
Assert.IsTrue(ex.Message.Contains(message));
Assert.IsTrue(ex.Message.Contains("EventLog"));
}
catch (Exception)
{
Assert.Fail();
}
}
protected void AreaRadioButton_SelectedIndexChanged(object sender, EventArgs e)
{
//Clear the Part Results Grid
PartResultsGridView.DataSource = null;
PartResultsGridView.DataBind();
PartResultUpdatePanel.Update();
//Clear the Machine Results Grid
MachineResultsGridView.DataSource = null;
MachineResultsGridView.DataBind();
MachineResultsUpdatePanel.Update();
AreaDisplayTypes displayType = (AreaDisplayTypes)System.Enum.Parse(typeof(AreaDisplayTypes), AreaRadioButton.SelectedValue);
// AreaResultsGridView.Columns[1].HeaderText = "All " + MakePlural(displayType);
using (var partManagementRepository = SharePointServiceLocator.GetCurrent().GetInstance <IPartManagementRepository>())
{
if (displayType == AreaDisplayTypes.Category)
{
var categories = partManagementRepository.GetCategories();
var areaDtos = categories.Select(category => new AreaDTO
{
Title = category.Title,
Id =
category.Id.HasValue
? category.Id.Value
: 0
});
ShowAreaResults(areaDtos);
}
if (displayType == AreaDisplayTypes.Department)
{
var departments = partManagementRepository.GetDepartments();
var areaDtos = departments.Select(department => new AreaDTO
{
Title = department.Title,
Id =
department.Id.HasValue
? department.Id.Value
: 0
});
ShowAreaResults(areaDtos);
}
if (displayType == AreaDisplayTypes.Manufacturer)
{
var manufacturers = partManagementRepository.GetManufacturers();
var areaDtos = manufacturers.Select(manufacturer => new AreaDTO
{
Title = manufacturer.Title,
Id =
manufacturer.Id.
HasValue
? manufacturer.Id.
Value
: 0
});
ShowAreaResults(areaDtos);
}
}
}
public void LogMessageShouldContainContextualInformation()
{
// arrange
var context = BHttpContext.SetCurrent();
MSPContext.CurrentGet = () => null;
context.Timestamp = new DateTime(2000, 1, 1);
var user = context.SetUser();
var identity = user.SetIdentity();
identity.Name = "TestUser";
var request = context.SetRequest();
request.Url = new Uri("http://localhost/mypage.aspx");
request.UserHostAddress = "1.1.1.1.1";
request.UserAgent = "MyAgent";
var eventLogger = SharePointServiceLocator.GetCurrent().GetInstance <IEventLogLogger>() as MockEventAndTraceLogger;
Exception ex = new Exception("message");
// act
var target = new SharePointLogger();
target.LogToOperations(ex);
var message = eventLogger.Messages[0].Message;
Assert.IsTrue(message.Contains(@"Request URL: 'http://localhost/mypage.aspx'"));
Assert.IsTrue(message.Contains("Request TimeStamp: '" + context.Timestamp.ToString("o", CultureInfo.CurrentCulture) + "'"));
Assert.IsTrue(message.Contains("UserName: '******'"));
Assert.IsTrue(message.Contains("Originating IP address: '1.1.1.1.1'"));
Assert.IsTrue(message.Contains("User Agent: 'MyAgent'"));
}
public UoBMySiteJob() : base()
{
IServiceLocator serviceLocator = SharePointServiceLocator.GetCurrent();
ILogger logger = serviceLocator.GetInstance <ILogger>();
logger.LogToOperations("Starting UoB Delete Old MySite DocLibs Timer Job", EventSeverity.Information);
}
/// <summary>
/// Calls the service.
/// </summary>
/// <param name="requestUrl">The request URL.</param>
/// <param name="warnningList">The warnning list.</param>
public void CallService(string requestUrl, List <Customs.Warnning> warnningList)
{
IServiceLocator serviceLocator = SharePointServiceLocator.GetCurrent();
ICWAccountFactory _cwFactory = serviceLocator.GetInstance <ICWAccountFactory>();
_cwFactory.ClearThroughCustoms(this, warnningList, requestUrl);
}
public void IfGetLoggerFailsExceptionIsHandled()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator().RegisterTypeMapping <ILogger, BadLogger>());
var originalException = new InvalidOperationException("Bad Error");
var target = new TestableBaseRobustExceptionHandler();
try
{
target.CallGetLogger(originalException);
Assert.Fail();
}
catch (ExceptionHandlingException ex)
{
Assert.AreSame(originalException, ex.InnerException);
Assert.IsInstanceOfType(ex.HandlingException, typeof(ActivationException));
Assert.IsTrue(ex.Message.Contains("Bad Error"));
}
catch (Exception)
{
Assert.Fail();
}
}
public void AddSubSiteCreationRequestTest()
{
MockConfigManager.ReturnValue = "http://localhost";
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator().RegisterTypeMapping <IHierarchicalConfig, MockConfigManager>());
Hashtable farmProperties = new Hashtable(1);
farmProperties.Add("SubSiteCreationConfigurationSite", "http://localhost");
Isolate.WhenCalled(() => SPFarm.Local.Properties).WillReturn(farmProperties);
SPSite fakeSite = Isolate.Fake.Instance <SPSite>(Members.ReturnRecursiveFakes);
Isolate.Swap.NextInstance <SPSite>().With(fakeSite);
SPWeb fakeWeb = Isolate.Fake.Instance <SPWeb>(Members.ReturnRecursiveFakes);
Isolate.WhenCalled(() => fakeSite.OpenWeb()).WillReturn(fakeWeb);
SPList fakeList = fakeWeb.Lists["Sub Site Creation Requests"];
SPListItem fakeItem = fakeList.Items.Add();
SubSiteCreationRequestsRepository target = new SubSiteCreationRequestsRepository();
SubSiteCreationRequest request = new SubSiteCreationRequest();
request.BusinessEvent = "unittest";
request.EventId = "0000";
request.SiteCollectionUrl = "testurl";
target.AddSubSiteCreationRequest(request);
Isolate.Verify.WasCalledWithAnyArguments(() => fakeItem.Update());
}
//public override void FeatureActivated(SPFeatureReceiverProperties properties)
//{
//}
//public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
//{
//}
/// <summary>
/// Occurs after a Feature is installed.
/// </summary>
/// <param name="properties">An <see cref="T:Microsoft.SharePoint.SPFeatureReceiverProperties" /> object that represents the properties of the event.</param>
public override void FeatureInstalled(SPFeatureReceiverProperties properties)
{
try
{
if (!System.Diagnostics.EventLog.SourceExists(SourceName))
{
System.Diagnostics.EventLog.CreateEventSource(new System.Diagnostics.EventSourceCreationData(SourceName, "Application"));
}
WebsiteModelExtensions.RegisterLoggerSource();
WebsiteModelExtensions.TraceEvent
(String.Format("CAS.SmartFactory.CW.WebsiteModel FeatureInstalled: {0}", properties.Definition.DisplayName), 54, TraceSeverity.High, WebsiteModelExtensions.LoggingCategories.FeatureActivation);
IServiceLocator _serviceLocator = SharePointServiceLocator.GetCurrent();
IServiceLocatorConfig _typeMappings = _serviceLocator.GetInstance <IServiceLocatorConfig>();
_typeMappings.RegisterTypeMapping <ICWAccountFactory, CWAccountData>();
WebsiteModelExtensions.TraceEvent("CAS.SmartFactory.CW.WebsiteModel TypeMapping registered", 59, TraceSeverity.High, WebsiteModelExtensions.LoggingCategories.FeatureActivation);
}
catch (Exception _ex)
{
System.Diagnostics.EventLog.WriteEvent(SourceName, new System.Diagnostics.EventInstance(63, 0)
{
EntryType = System.Diagnostics.EventLogEntryType.Error
}, _ex);
throw;
}
}
public void TestInitialize()
{
ActivatingServiceLocator locator = new ActivatingServiceLocator();
locator.RegisterTypeMapping <ILogger, MockLogger>(InstantiationType.AsSingleton);
SharePointServiceLocator.ReplaceCurrentServiceLocator(locator);
}
