public void Test_Add_File_To_Content_Item_Without_Metadata()
{
var dataService = DataServiceFactory();
dataService.Setup(ds => ds.AddContentItem(It.IsAny <ContentItem>(), It.IsAny <int>()))
.Returns(Constants.CONTENT_AddContentItemId);
// Return empty set of metadata.
dataService.Setup(ds => ds.GetMetaData(It.IsAny <int>())).Returns(MockHelper.CreateEmptyMetaDataReader);
var content = ContentTestHelper.CreateValidContentItem();
content.Metadata.Clear();
var contentId = Util.GetContentController().AddContentItem(content);
Assert.AreEqual(contentId, Constants.CONTENT_AddContentItemId);
Assert.IsEmpty(content.Metadata);
dataService.Setup(ds => ds.GetContentItem(It.IsAny <int>()))
.Returns <int>(y => MockHelper.CreateValidContentItemReader(content));
var fileController = ComponentFactory.GetComponent <IAttachmentController>();
fileController.AddFileToContent(contentId, ContentTestHelper.CreateValidFile(0));
dataService.Verify(
ds => ds.AddMetaData(It.IsAny <ContentItem>(), FileController.FilesKey, new[] { 0 }.ToJson()));
}
public void Test_Load_Attachments_From_DataService()
{
var files = new List <IFileInfo>
{
ContentTestHelper.CreateValidFile(0),
ContentTestHelper.CreateValidFile(1),
ContentTestHelper.CreateValidFile(2)
};
var dataService = DataServiceFactory();
dataService.Setup(ds => ds.GetContentItem(It.IsAny <int>())).Returns(MockHelper.CreateValidContentItemReader);
dataService.Setup(
ds =>
ds.GetMetaData(It.IsAny <int>())).Returns(
() => MockHelper.CreateMetaDataReaderWithFiles(files, new IFileInfo[0], new IFileInfo[0]));
var contentItem = Util.GetContentController().GetContentItem(Constants.CONTENT_ValidContentItemId);
Assert.IsNotNull(contentItem);
var serialized = contentItem.Metadata[FileController.FilesKey];
Assert.IsNotEmpty(serialized);
Assert.IsNotEmpty(contentItem.Files);
Assert.AreEqual(contentItem.Files.Count, 3);
Assert.AreEqual(contentItem.Files[0].FileId, 0);
Assert.AreEqual(contentItem.Files[1].FileId, 1);
Assert.AreEqual(contentItem.Files[2].FileId, 2);
}
public void Test_Add_Attachments_With_FileController()
{
var dataService = DataServiceFactory();
dataService.Setup(
ds =>
ds.GetContentItem(It.IsAny <int>())).Returns(MockHelper.CreateValidContentItemReader);
// Use a closure to store the metadata locally in this method.
var data = new Dictionary <string, string>();
dataService.Setup(
ds =>
ds.GetMetaData(It.IsAny <int>())).Returns(
() => MockHelper.CreateMetaDataReaderFromDictionary(data));
dataService.Setup(
ds =>
ds.AddMetaData(
It.IsAny <ContentItem>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Callback <ContentItem, string, string>((ci, name, value) => data[name] = value);
var contentController = Util.GetContentController();
var contentItem = contentController.GetContentItem(Constants.CONTENT_ValidContentItemId);
Assert.IsNotNull(contentItem);
var serialized = contentItem.Metadata[FileController.FilesKey];
Assert.IsNull(serialized);
Assert.IsEmpty(contentItem.Files);
var fileManager = ComponentFactory.GetComponent <IFileManager>();
// Add some files.
var fileController = ComponentFactory.GetComponent <IAttachmentController>();
fileController.AddFileToContent(contentItem.ContentItemId, fileManager.GetFile(0));
fileController.AddFileToContent(contentItem.ContentItemId, fileManager.GetFile(1));
contentItem = contentController.GetContentItem(Constants.CONTENT_ValidContentItemId);
Assert.AreEqual(contentItem.Files.Count, 2);
Assert.AreEqual(contentItem.Files[0].FileId, 0);
Assert.AreEqual(contentItem.Files[1].FileId, 1);
dataService.Verify(
ds => ds.DeleteMetaData(It.IsAny <ContentItem>(), FileController.FilesKey, "[0]"), Times.Once());
dataService.Verify(
ds => ds.AddMetaData(It.IsAny <ContentItem>(), FileController.FilesKey, "[0]"), Times.Once());
dataService.Verify(
ds => ds.AddMetaData(It.IsAny <ContentItem>(), FileController.FilesKey, "[0,1]"), Times.Once());
}
public void Set_MetaData_To_Empty_Value_Deletes_Row()
{
var data = new Dictionary <string, string>();
var dataService = DataServiceFactoryWithLocalMetaData(ref data);
dataService.Setup(ds => ds.GetContentItem(It.IsAny <int>())).Returns(MockHelper.CreateValidContentItemReader);
var contentController = Util.GetContentController();
var fileManager = ComponentFactory.GetComponent <IFileManager>();
var contentItem = contentController.GetContentItem(Constants.CONTENT_ValidContentItemId);
Assert.IsNotNull(contentItem);
var serialized = contentItem.Metadata[FileController.FilesKey];
Assert.IsNull(serialized);
Assert.IsEmpty(contentItem.Files);
// Add some files.
var fileController = ComponentFactory.GetComponent <IAttachmentController>();
fileController.AddFileToContent(contentItem.ContentItemId, fileManager.GetFile(0));
fileController.AddFileToContent(contentItem.ContentItemId, fileManager.GetFile(1));
contentItem = contentController.GetContentItem(Constants.CONTENT_ValidContentItemId);
Assert.AreEqual(contentItem.Files.Count, 2);
Assert.AreEqual(contentItem.Files[0].FileId, 0);
Assert.AreEqual(contentItem.Files[1].FileId, 1);
Assert.IsNotEmpty(contentItem.Metadata[FileController.FilesKey]);
contentItem.Files.Clear();
contentController.UpdateContentItem(contentItem);
dataService.Verify(ds => ds.DeleteMetaData(It.IsAny <ContentItem>(), FileController.FilesKey, "[0]"), Times.Once());
dataService.Verify(ds => ds.DeleteMetaData(It.IsAny <ContentItem>(), FileController.FilesKey, "[0,1]"), Times.Once());
dataService.Verify(ds => ds.AddMetaData(It.IsAny <ContentItem>(), FileController.FilesKey, "[0]"), Times.Once());
dataService.Verify(ds => ds.AddMetaData(It.IsAny <ContentItem>(), FileController.FilesKey, "[0,1]"), Times.Once());
var emptyFiles = fileController.GetFilesByContent(contentItem.ContentItemId);
Assert.AreEqual(0, emptyFiles.Count);
}
public void Set_MetaData_To_Same_Value_Doesnt_Update_Database_Entry()
{
var metadata = new Dictionary <string, string>();
var dataService = DataServiceFactoryWithLocalMetaData(ref metadata);
var contentController = Util.GetContentController();
var contentItem = ContentTestHelper.CreateValidContentItem();
contentController.AddContentItem(contentItem);
dataService.Verify(ds => ds.AddMetaData(contentItem, FileController.TitleKey, It.IsAny <string>()), Times.Never());
dataService.Verify(ds => ds.DeleteMetaData(contentItem, FileController.TitleKey, It.IsAny <string>()), Times.Never());
contentItem.ContentTitle = "Foobar";
contentController.UpdateContentItem(contentItem);
dataService.Verify(ds => ds.AddMetaData(contentItem, FileController.TitleKey, It.IsAny <string>()), Times.Once());
dataService.Verify(ds => ds.DeleteMetaData(contentItem, FileController.TitleKey, It.IsAny <string>()), Times.Never());
contentItem.ContentTitle = "Foobar";
contentController.UpdateContentItem(contentItem);
// Should be a no-op since no real data changed
dataService.Verify(ds => ds.AddMetaData(contentItem, FileController.TitleKey, It.IsAny <string>()), Times.Once());
dataService.Verify(ds => ds.DeleteMetaData(contentItem, FileController.TitleKey, It.IsAny <string>()), Times.Never());
// Really update
contentItem.ContentTitle = "SNAFU";
contentController.UpdateContentItem(contentItem);
dataService.Verify(ds => ds.AddMetaData(contentItem, FileController.TitleKey, It.IsAny <string>()), Times.Exactly(2));
dataService.Verify(ds => ds.DeleteMetaData(contentItem, FileController.TitleKey, It.IsAny <string>()), Times.Once());
}
/// <summary>
/// Gets the terms by vocabularyId.
/// </summary>
/// <param name="voc">The voc.</param>
/// <param name="vocabularyId">The vocabulary id.</param>
/// <returns>term collection.</returns>
internal static List <Term> GetTerms(this Vocabulary voc, int vocabularyId)
{
ITermController ctl = Util.GetTermController();
return(ctl.GetTermsByVocabulary(vocabularyId).ToList());
}
/// <summary>
/// Gets the type of the scope.
/// </summary>
/// <param name="voc">The voc.</param>
/// <param name="scopeTypeId">The scope type id.</param>
/// <returns>scope type.</returns>
internal static ScopeType GetScopeType(this Vocabulary voc, int scopeTypeId)
{
IScopeTypeController ctl = Util.GetScopeTypeController();
return(ctl.GetScopeTypes().Where(s => s.ScopeTypeId == scopeTypeId).SingleOrDefault());
}
/// <summary>
/// Gets the vocabulary.
/// </summary>
/// <param name="term">The term.</param>
/// <param name="vocabularyId">The vocabulary id.</param>
/// <returns>Vocabulary.</returns>
internal static Vocabulary GetVocabulary(this Term term, int vocabularyId)
{
IVocabularyController ctl = Util.GetVocabularyController();
return((from v in ctl.GetVocabularies() where v.VocabularyId == vocabularyId select v).SingleOrDefault());
}
