public void should_request_items_with_correct_options()
{
// Arrange
var configData = new IntegrationConfigData("server", "list", "templateID")
{
ItemLimit = 100500,
Folder = "SomeFolder",
View = "SomeView"
};
var context = Substitute.For <SpContext>();
var list = Substitute.For <BaseList>(new EntityValues(), context, new Uri("http://empty"));
var myItemCollection = new MyItemCollection(context, list, new ItemsRetrievingOptions());
list.GetItems(Arg.Any <ItemsRetrievingOptions>()).Returns(myItemCollection);
this.sharepointListProvider.GetList(string.Empty, string.Empty, null).ReturnsForAnyArgs(list);
var args = new SynchronizeTreeArgs
{
Context = this.CreateSynchContext(configData)
};
// Act
this.processor.Process(args);
// Assert
list.Received().GetItems(Arg.Is <ItemsRetrievingOptions>(x => x.ItemLimit == configData.ItemLimit && x.Folder == configData.Folder && x.ViewName == configData.View));
}
private SynchronizeTreeArgs CreateArgsWithDefaultEntries(Actions actions = null, bool stubsTableProvider = true)
{
var args = new SynchronizeTreeArgs();
if (actions != null)
{
args.ActionList = this.CreateActions(actions);
}
var context = this.CreateSynchContext(new IntegrationConfigData("server", "list", "templateID"));
args.Context = context;
var saveEntries = new List <IDTableEntry> {
new IDTableEntry(PrefixSave, ID.NewID.ToString(), ID.NewID, context.ParentID, "ChangedGUID")
};
var deleteEntries = new List <IDTableEntry> {
new IDTableEntry(PrefixDelete, ID.NewID.ToString(), ID.NewID, context.ParentID, "DeletedGUID")
};
args.CustomData["IDTableEntries"] = new Dictionary <string, List <IDTableEntry> >
{
{ PrefixSave, saveEntries },
{ PrefixDelete, deleteEntries }
};
if (stubsTableProvider)
{
this.tableProvider.GetKeys(PrefixSave, Arg.Any <ID>()).Returns(saveEntries.ToArray());
this.tableProvider.GetKeys(PrefixDelete, Arg.Any <ID>()).Returns(deleteEntries.ToArray());
}
return(args);
}
public void Init(SynchronizeTreeArgs args)
{
args.CustomData[IdTableEntries] = new Dictionary <string, List <IDTableEntry> >
{
{ PrefixSave, this.GetEntries(PrefixSave, args.Context.ParentID) },
{ PrefixDelete, this.GetEntries(PrefixDelete, args.Context.ParentID) }
};
}
public void should_throw_if_config_item_is_not_specified()
{
// Arrange
var processor = new GetSitecoreItemList();
var args = new SynchronizeTreeArgs();
// Act
Action action = () => processor.Process(args);
// Assert
action.ShouldThrow <InvalidOperationException>().WithMessage("Value can't be null: args.Context");
}
public static void SynchronizeTree(ProcessIntegrationItemsOptions processIntegrationItemsOptions, SynchContext synchContext)
{
Assert.ArgumentNotNull(processIntegrationItemsOptions, "processIntegrationItemsOptions");
Assert.ArgumentNotNull(synchContext, "synchContext");
var pipelineArgs = new SynchronizeTreeArgs
{
Context = synchContext,
Options = processIntegrationItemsOptions
};
SynchronizeTree(pipelineArgs);
}
private static void SynchronizeTree(SynchronizeTreeArgs pipelineArgs)
{
try
{
PipelineRunner.AssertRun(PipelineNames.SynchronizeTree, pipelineArgs);
}
catch (Exception exception)
{
LogMessage(
exception,
"Sharepoint Provider can't process tree.{1}{0}",
LogMessageFormatter.FormatIntegrationConfigItemID02(pipelineArgs.Context),
Environment.NewLine);
}
}
public void should_return_right_delete_integration_item_action()
{
// Arrange
var syncActionFactory = new SyncActionFactory();
var args = new SynchronizeTreeArgs();
var integrationItem = TestHelper.CreateSitecoreItemsList(new TestHelper.Items {
"1"
}).First();
// Act
var action = syncActionFactory.GetDeleteIntegrationItemAction(args, integrationItem);
// Assert
action.Should().Match <DeleteIntegrationItemAction>(x => x.Item == integrationItem);
}
public void should_return_right_create_sharepoint_item_action()
{
// Arrange
var syncActionFactory = new SyncActionFactory();
var args = new SynchronizeTreeArgs();
var integrationItem = TestHelper.CreateSitecoreItemsList(new TestHelper.Items {
{ "1", string.Empty }
}).First();
// Act
var action = syncActionFactory.GetCreateSharepointItemAction(args, integrationItem);
// Assert
action.Should().Match <CreateSharepointItemAction>(x => x.Item == integrationItem);
}
public void should_should_not_fill_args_with_not_integration_items_only()
{
// Arrange
var processor = new GetSitecoreItemList();
var args = new SynchronizeTreeArgs {
Context = CreateSyncContext()
};
// Act
processor.Process(args);
// Assert
args.IntegrationItems.Should().NotBeNull();
args.IntegrationItems.Select(x => x.Name).Should().NotContain("notIntegrationItem");
}
public void should_abort_pipeline_if_parent_is_disabled(bool rootParent, bool directParent, bool pipelineAborted)
{
// Arrange
var configurationItem = this.PrepareDbWithThreeLevelTree(rootParent, directParent, true);
var args = new SynchronizeTreeArgs {
Context = new SynchContext(configurationItem)
};
var processor = new IsActiveTree();
// Act
processor.Process(args);
// Assert
args.Aborted.Should().Be(pipelineAborted);
}
public void should_abort_pipeline_if_config_item_is_disabled(bool isEnabled)
{
// Arrange
var configurationItem = new ItemMock().AsConfigurationItem(null, string.Empty, isEnabled);
var args = new SynchronizeTreeArgs {
Context = new SynchContext(configurationItem)
};
var processor = new IsActiveTree();
// Act
processor.Process(args);
// Assert
args.Aborted.Should().Be(!isEnabled);
}
public void Refresh(SynchronizeTreeArgs args)
{
Assert.ArgumentNotNull(args, "args");
Assert.IsNotNull(args.ActionList, "Value can't be null: args.ActionList");
var dictionary = (Dictionary <string, List <IDTableEntry> >)args.CustomData[IdTableEntries];
var tableEntries = dictionary.SelectMany(x => x.Value).Where(x => x.ParentID == args.Context.ParentID).ToList();
foreach (var entry in tableEntries)
{
var action = args.ActionList.Find(x => x.SharepotinGUID == entry.CustomData);
if (action == null || action.IsSuccessful)
{
IDTable.RemoveKey(entry.Prefix, entry.Key);
}
}
}
public void Init_should_init_delete_dictionary()
{
var synchronizeTreeArgs = new SynchronizeTreeArgs();
synchronizeTreeArgs.Context = this.CreateSynchContext(new IntegrationConfigData("server", "list", "templateID"));
var idTableEntries = new[] { new IDTableEntry(PrefixDelete, "key", ID.NewID, synchronizeTreeArgs.Context.ParentID, "customData") };
this.tableProvider.GetKeys(PrefixDelete).Returns(idTableEntries);
// Act
this.provider.Init(synchronizeTreeArgs);
// Assert
var dictionary = (Dictionary <string, List <IDTableEntry> >)synchronizeTreeArgs.CustomData["IDTableEntries"];
dictionary[PrefixDelete].Should().Contain(idTableEntries);
}
public void should_not_queue_event_if_IsEven_is_true()
{
// Arrange
var eventManager = Substitute.For <SitecoreEventManager>();
var processor = new IsIntegrationInstance(eventManager, this.azureEnvironment);
var args = new SynchronizeTreeArgs
{
Context = this.synchContext,
Options = ProcessIntegrationItemsOptions.DefaultOptions
};
args.Options.IsEvent = true;
// Act
processor.Process(args);
// Assert
eventManager.DidNotReceiveWithAnyArgs().QueueEvent(Arg.Any <ProcessTreeRemoteEvent>());
}
public void should_queue_event_if_IsEven_is_false()
{
// Arrange
var eventManager = Substitute.For <SitecoreEventManager>();
var processor = new IsIntegrationInstance(eventManager, this.azureEnvironment);
var args = new SynchronizeTreeArgs
{
Context = this.synchContext,
Options = ProcessIntegrationItemsOptions.DefaultOptions
};
args.Options.IsEvent = false;
// Act
processor.Process(args);
// Assert
eventManager.Received().QueueEvent(Arg.Is <ProcessTreeRemoteEvent>(x => x.DatabaseName == args.Context.Database.Name && x.Id == args.Context.ParentID && x.EventName == "spif:processTree"));
}
private SynchronizeTreeArgs CreateArgs(
TestHelper.Items sitecoreItems,
TestHelper.Items sharepointItems,
bool isBidirectional = true)
{
var configData = new IntegrationConfigData("server", "list", "templateID")
{
BidirectionalLink = isBidirectional
};
var args = new SynchronizeTreeArgs
{
IntegrationItems = TestHelper.CreateSitecoreItemsList(sitecoreItems),
SharepointItemList = TestHelper.CreateSharepointItemsList(sharepointItems),
Context = new SynchContext(new ItemMock().AsConfigurationItem(configData))
};
return(args);
}
public void should_update_exired_interval()
{
// Arrange
var processor = new UpdateExpirationInterval();
var args = new SynchronizeTreeArgs
{
Context = this.synchContext
};
var configData = IntegrationCache.GetIntegrationConfigData(this.itemId);
configData.ExpirationDate = DateTime.Now.AddDays(-1);
configData.IsExpired.Should().BeTrue();
// Act
processor.Process(args);
// Assert
IntegrationCache.GetIntegrationConfigData(this.itemId).IsExpired.Should().BeFalse();
}
public void should_abort_pipeline_if_not_integration_instance_in_azure()
{
// Arrange
var processor = new IsIntegrationInstance(Substitute.For <SitecoreEventManager>(), this.azureEnvironment);
var args = new SynchronizeTreeArgs
{
Context = this.synchContext,
Options = ProcessIntegrationItemsOptions.DefaultOptions
};
this.azureEnvironment.IsAzure.Returns(true);
this.azureEnvironment.IsIntegrationInstance.Returns(false);
// Act
using (new SettingsSwitcher("Sharepoint.IntegrationInstance", Settings.InstanceName))
{
processor.Process(args);
}
// Assert
args.Aborted.Should().BeTrue();
}
public void should_return_all_list_items()
{
// Arrange
var dataContext = Substitute.For <SpContext>();
var list = Substitute.For <BaseList>(new EntityValues(), dataContext, new Uri("http://empty"));
var itemCollection = new MyItemCollection(dataContext, list, new ItemsRetrievingOptions());
var listItems = new List <BaseItem>
{
new BaseItem(new EntityProperties(), list, dataContext),
new BaseItem(new EntityProperties(), list, dataContext),
new BaseItem(new EntityProperties(), list, dataContext)
};
itemCollection.Items = listItems;
// We have to make these methods as virtual in the BaseList class:
list.GetItems(Arg.Any <ItemsRetrievingOptions>()).Returns(itemCollection);
var configData = new IntegrationConfigData("server", "list", "templateID");
var args = new SynchronizeTreeArgs
{
Context = this.CreateSynchContext(configData)
};
var context = Substitute.For <SpContext>();
this.sharepointContextProvider.CreateDataContext(configData).Returns(context);
this.sharepointListProvider.GetList(configData.Web, configData.List, context).Returns(list);
// Act
this.processor.Process(args);
// Assert
args.SharepointItemList.Should().BeEquivalentTo(listItems);
}
public override SyncActionBase GetUpdateIntegrationItemAction(SynchronizeTreeArgs args, IntegrationItem item, BaseItem sharepointItem)
{
return(new ComparableUpdateIntegrationItemAction(item, sharepointItem, args.Context, args.Options));
}
public abstract SyncActionBase GetCreateIntegrationItemAction(SynchronizeTreeArgs args, BaseItem sharepointItem);
public abstract bool IsItemDeleted(SynchronizeTreeArgs args, string sharepointGUID);
public abstract SyncActionBase GetUpdateSharepointItemAction(SynchronizeTreeArgs args, BaseItem sharepointItem, IntegrationItem item);
public abstract SyncActionBase GetDeleteIntegrationItemAction(SynchronizeTreeArgs args, IntegrationItem item);
public override SyncActionBase GetDeleteSharepointItemAction(SynchronizeTreeArgs args, BaseItem sharepointItem)
{
return(new DeleteSharepointItemAction(sharepointItem, args.Context));
}
public override SyncActionBase GetCreateSharepointItemAction(SynchronizeTreeArgs args, IntegrationItem item)
{
return(new CreateSharepointItemAction(item, args.Context));
}
public override SyncActionBase GetCreateIntegrationItemAction(SynchronizeTreeArgs args, BaseItem sharepointItem)
{
return(new CreateIntegrationItemAction(sharepointItem, args.Context, args.Options));
}
public abstract SyncActionBase GetDeleteSharepointItemAction(SynchronizeTreeArgs args, BaseItem sharepointItem);
public override SyncActionBase GetUpdateSharepointItemAction(SynchronizeTreeArgs args, BaseItem sharepointItem, IntegrationItem item)
{
return(new UpdateSharepointItemAction(sharepointItem, item, args.Context));
}
public override SyncActionBase GetDeleteIntegrationItemAction(SynchronizeTreeArgs args, IntegrationItem item)
{
return(new DeleteIntegrationItemAction(item, args.Context));
}
