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); }