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 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 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 Init()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <ILogger, MockLogger>(InstantiationType.AsSingleton));
logger = SharePointServiceLocator.Current.GetInstance <ILogger>() as MockLogger;
}
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 Init()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IHierarchicalConfig, MockHierarchicalConfig>(InstantiationType.AsSingleton));
config = SharePointServiceLocator.Current.GetInstance <IHierarchicalConfig>() as MockHierarchicalConfig;
}
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 void TestInitialize()
{
ActivatingServiceLocator locator = new ActivatingServiceLocator();
locator.RegisterTypeMapping <ILogger, MockLogger>(InstantiationType.AsSingleton);
SharePointServiceLocator.ReplaceCurrentServiceLocator(locator);
}
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 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 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 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 void Setup()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator());
((ActivatingServiceLocator)SharePointServiceLocator.GetCurrent())
.RegisterTypeMapping <ITraceLogger, MockEventAndTraceLogger>(InstantiationType.AsSingleton)
.RegisterTypeMapping <IEventLogLogger, MockEventAndTraceLogger>(InstantiationType.AsSingleton);
}
public void Initialize()
{
var logger = new MockLogger();
var locator = new ActivatingServiceLocator();
SharePointServiceLocator.ReplaceCurrentServiceLocator(locator);
locator.RegisterTypeMapping <ILogger, MockLogger>();
}
public void CanChangeServiceLocator()
{
var mock = new MockServiceLocator();
SharePointServiceLocator.ReplaceCurrentServiceLocator(mock);
Assert.AreEqual(mock, SharePointServiceLocator.Current);
}
public void GetCurrentPartnerIdShouldOnlyRunInSharePointContext()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IHierarchicalConfig, MockConfigManager>());
PartnerSiteDirectory target = new PartnerSiteDirectory();
target.GetCurrentPartnerId();
}
public void TestInitialize()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <ITraceLogger, MockTraceLogger>(InstantiationType.AsSingleton)
.RegisterTypeMapping <IEventLogLogger, MockEventLogger>(InstantiationType.AsSingleton));
traceLogger = SharePointServiceLocator.Current.GetInstance <ITraceLogger>() as MockTraceLogger;
eventLogger = SharePointServiceLocator.Current.GetInstance <IEventLogLogger>() as MockEventLogger;
}
public void ReplaceCurrentServiceLocator_ChangeServiceLocator()
{
//Arrange
var serviceLocator = new SIServiceLocator();
//Act
SharePointServiceLocator.ReplaceCurrentServiceLocator(serviceLocator);
//Assert
Assert.AreSame(serviceLocator, SharePointServiceLocator.GetCurrent());
}
public void Execute_TracesMessage()
{
//Arrange
var args = new TracingOperationArgs();
Guid createGuid = Guid.Empty;
args.Message = TestsConstants.TestGuidName;
args.EventId = -99;
args.Category = TestsConstants.AreasCategories;
args.Severity = (int)SandboxTraceSeverity.High;
args.SiteID = TestsConstants.TestGuid;
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator());
((ActivatingServiceLocator)SharePointServiceLocator.GetCurrent())
.RegisterTypeMapping <ILogger, TestTraceLogger>(InstantiationType.AsSingleton);
var operation = new TracingOperation();
BSPFarm.SetLocal();
MSPSite site;
BSPWeb bweb = new BSPWeb();
var mweb = new MSPWeb(bweb)
{
NameGet = () => "foo.bar",
};
MSPSite.ConstructorGuid = (instance, g) =>
{
site = new MSPSite(instance)
{
Dispose = () => { },
IDGet = () => TestsConstants.TestGuid,
RootWebGet = () => mweb
};
createGuid = g;
};
//Act
object target = operation.Execute(args);
//Assert
var logger = SharePointServiceLocator.GetCurrent().GetInstance <ILogger>() as TestTraceLogger;
Assert.IsNotInstanceOfType(target, typeof(Exception));
Assert.AreEqual(TestsConstants.TestGuid, createGuid);
Assert.IsTrue(logger.Message.Contains(args.Message));
Assert.AreEqual(logger.Category, TestsConstants.AreasCategories);
Assert.AreEqual(logger.EventId, args.EventId);
Assert.AreEqual(logger.Severity, SandboxTraceSeverity.High);
}
public void PartnerSiteDirectoryConstructorTest()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IHierarchicalConfig, MockConfigManager>());
SPFarm fakeFarm = Isolate.Fake.Instance <SPFarm>();
Isolate.WhenCalled(() => SPFarm.Local).WillReturn(fakeFarm);
PartnerSiteDirectory target = new PartnerSiteDirectory();
Assert.IsNotNull(target);
}
public void GetBusinessEventTypeConfigurationNullSubSiteCreationConfigurationSiteProperty()
{
MockConfigManager.ReturnValue = string.Empty;
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator().RegisterTypeMapping <IHierarchicalConfig, MockConfigManager>());
SPFarmPropertyBag spFarmPropertyBag = Isolate.Fake.Instance <SPFarmPropertyBag>();
Isolate.Swap.NextInstance <SPFarmPropertyBag>().With(spFarmPropertyBag);
BusinessEventTypeConfigurationRepository target = new BusinessEventTypeConfigurationRepository();
target.GetBusinessEventTypeConfiguration("");
}
public void HandleListEventExceptionIsRobust()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <ILogger, MockLoggerThatThrows>());
SPItemEventProperties mockSpItemEventProperties = Isolate.Fake.Instance <SPItemEventProperties>(Members.ReturnRecursiveFakes);
Exception exception = new Exception("Unhandled Exception Occured.");
ListExceptionHandler exceptionHandler = new ListExceptionHandler();
exceptionHandler.HandleListItemEventException(exception, mockSpItemEventProperties, "New Message");
}
public void FindPromotionPagesTest()
{
//SPWeb fakeWeb = Isolate.Fake.Instance<SPWeb>(Members.ReturnRecursiveFakes);
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <IPartnerPromotionRepository, MockPartnerPromotionRepository>());
MockPartnerPromotionRepository.GetAllMyPromosRetVal = new List <PartnerPromotionEntity>();
PartnerPromotionsPresenter presenter = new PartnerPromotionsPresenter();
//presenter.TargetWeb = fakeWeb;
Assert.AreSame(MockPartnerPromotionRepository.GetAllMyPromosRetVal, presenter.FindPromotionPages());
}
public void TraceWithInvalidCategoryThrowsLoggingException()
{
//Arrange
var replaceLocator = new ActivatingServiceLocator();
const string invalidCategory = TestsConstants.TestGuidName; // should be of form area/category
SharePointServiceLocator.ReplaceCurrentServiceLocator(replaceLocator);
replaceLocator.RegisterTypeMapping <IHierarchicalConfig, MockHierarchicalConfig>(InstantiationType.AsSingleton);
replaceLocator.RegisterTypeMapping <IConfigManager, MockConfigManager>(InstantiationType.AsSingleton);
var target = new DiagnosticsService();
//Act
target.LogTrace("Message", 99, TraceSeverity.Medium, invalidCategory);
//Assert
}
public void SetServiceLocatorTest()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(SharePointServiceLocator.Current);
ServiceLocatorConfig target = new ServiceLocatorConfig();
target.RegisterTypeMapping <IFirstType, FirstTest1>();
target.RegisterTypeMapping <IFirstType, FirstTest1>("First");
target.RegisterTypeMapping <IFirstType, FirstTest2>("Second");
SharePointServiceLocator.Reset();
Assert.IsInstanceOfType(SharePointServiceLocator.Current.GetInstance <IFirstType>(), typeof(FirstTest1));
Assert.IsInstanceOfType(SharePointServiceLocator.Current.GetInstance <IFirstType>("First"), typeof(FirstTest1));
Assert.IsInstanceOfType(SharePointServiceLocator.Current.GetInstance <IFirstType>("Second"), typeof(FirstTest2));
}
public void GetBusinessEventTypeConfigurationTest()
{
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);
Guid SiteTemplateFieldId = new Guid("84267e40-7f47-4f40-b3be-4004312eb467");
Guid BusinessEventIdKeyFieldId = new Guid("3D6B9777-FDA5-4639-9316-B39D3E060573");
Guid TopLevelSiteRelativeUrlFieldId = new Guid("E87A0DE5-29D7-461e-9C83-67C2D291B54C");
SPList fakeList = fakeWeb.Lists["Business Event Type Configuration"];
SPListItemCollection fakeItems = fakeList.GetItems(new SPQuery());
Isolate.WhenCalled(() => fakeItems.Count).WillReturn(1);
var fakeItem = fakeItems[0];
Isolate.WhenCalled(() => fakeItem[SiteTemplateFieldId]).WithExactArguments().WillReturn("TESTSTP");
Isolate.WhenCalled(() => fakeItem[BusinessEventIdKeyFieldId]).WithExactArguments().WillReturn("TESTKEY");
Isolate.WhenCalled(() => fakeItem[TopLevelSiteRelativeUrlFieldId]).WithExactArguments().WillReturn("http://testurl");
SPFarmPropertyBag spFarmPropertyBag = Isolate.Fake.Instance <SPFarmPropertyBag>();
Isolate.Swap.NextInstance <SPFarmPropertyBag>().With(spFarmPropertyBag);
string businessEvent = string.Empty;
BusinessEventTypeConfiguration expected = new BusinessEventTypeConfiguration();
expected.BusinessEventIdKey = "TESTKEY";
expected.SiteTemplate = "TESTSTP";
expected.TopLevelSiteRelativeUrl = "http://testurl";
BusinessEventTypeConfigurationRepository target = new BusinessEventTypeConfigurationRepository();
BusinessEventTypeConfiguration actual;
actual = target.GetBusinessEventTypeConfiguration(businessEvent);
Assert.AreEqual(expected.BusinessEventIdKey, actual.BusinessEventIdKey);
Assert.AreEqual(expected.SiteTemplate, actual.SiteTemplate);
Assert.AreEqual(expected.TopLevelSiteRelativeUrl, actual.TopLevelSiteRelativeUrl);
}
public void ItemAddingThrowsExceptionTest()
{
SPItemEventProperties properties = Isolate.Fake.Instance <SPItemEventProperties>(Members.ReturnRecursiveFakes);
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator()
.RegisterTypeMapping <ILogger, MockLogger>()
.RegisterTypeMapping <IIncidentManagementRepository, MockIncidentManagementService>()
.RegisterTypeMapping <IPartnerSiteDirectory, MockPartnerSiteDirectory>());
IncidentTaskReceiver receiver = new IncidentTaskReceiver();
receiver.ItemAdding(properties);
Assert.IsTrue(properties.Cancel);
Assert.AreEqual("Could not write the incident task to history. Please contact support.", properties.ErrorMessage);
Assert.IsTrue(MockLogger.errorMessage.Contains("Service threw excpetion"));
}
