public void TermController_AddTermToContent_Throws_On_Null_Term()
{
// Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
ContentItem content = ContentTestHelper.CreateValidContentItem();
// Act, Arrange
Assert.Throws <ArgumentNullException>(() => termController.AddTermToContent(null, content));
}
public void ContentController_DeleteMetaData_Throws_On_Null_MetaDataName()
{
// Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
ContentController controller = new ContentController(mockDataService.Object);
ContentItem content = ContentTestHelper.CreateValidContentItem();
// Act, Arrange
Assert.Throws <ArgumentOutOfRangeException>(() => controller.AddMetaData(content, Null.NullString, Constants.CONTENT_ValidMetaDataValue));
}
public void ContentTypeController_UpdateContentType_Throws_On_Negative_ContentTypeId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var contentTypeController = new ContentTypeController(mockDataService.Object);
var contentType = ContentTestHelper.CreateValidContentType();
contentType.ContentType = Constants.CONTENTTYPE_InValidContentType;
Assert.Throws <ArgumentOutOfRangeException>(() => contentTypeController.UpdateContentType(contentType));
}
public void ScopeTypeController_DeleteScopeType_Throws_On_Negative_ScopeTypeId()
{
// Arrange
var mockDataService = new Mock <IDataService>();
var scopeTypeController = new ScopeTypeController(mockDataService.Object);
ScopeType scopeType = ContentTestHelper.CreateValidScopeType();
scopeType.ScopeTypeId = Null.NullInteger;
Assert.Throws <ArgumentOutOfRangeException>(() => scopeTypeController.DeleteScopeType(scopeType));
}
public void VocabularyController_AddVocabulary_Throws_On_Negative_ScopeTypeID()
{
// Arrange
var mockDataService = new Mock<IDataService>();
var vocabularyController = new VocabularyController(mockDataService.Object);
Vocabulary vocabulary = ContentTestHelper.CreateValidVocabulary();
vocabulary.ScopeTypeId = Null.NullInteger;
// Act, Arrange
Assert.Throws<ArgumentOutOfRangeException>(() => vocabularyController.AddVocabulary(vocabulary));
}
public void VocabularyController_AddVocabulary_Throws_On_Invalid_Name()
{
// Arrange
var mockDataService = new Mock<IDataService>();
var vocabularyController = new VocabularyController(mockDataService.Object);
Vocabulary vocabulary = ContentTestHelper.CreateValidVocabulary();
vocabulary.Name = Constants.VOCABULARY_InValidName;
// Act, Arrange
Assert.Throws<ArgumentException>(() => vocabularyController.AddVocabulary(vocabulary));
}
public void ScopeTypeController_UpdateScopeType_Throws_On_Negative_ScopeTypeId()
{
// Arrange
var mockDataService = new Mock <IDataService>();
var scopeTypeController = new ScopeTypeController(mockDataService.Object);
ScopeType scopeType = ContentTestHelper.CreateValidScopeType();
scopeType.ScopeType = Constants.SCOPETYPE_InValidScopeType;
Assert.Throws <ArgumentOutOfRangeException>(() => scopeTypeController.UpdateScopeType(scopeType));
}
public void TermController_DeleteTerm_Throws_On_Negative_TermId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
var term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId);
term.TermId = Null.NullInteger;
//Act, Arrange
Assert.Throws <ArgumentOutOfRangeException>(() => termController.DeleteTerm(term));
}
public void ContentController_DeleteContentItem_Throws_On_Negative_ContentItemId()
{
// Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
ContentController controller = new ContentController(mockDataService.Object);
ContentItem content = ContentTestHelper.CreateValidContentItem();
content.ContentItemId = Null.NullInteger;
// Act, Arrange
Assert.Throws <ArgumentOutOfRangeException>(() => controller.DeleteContentItem(content));
}
public void TermController_AddTerm_Throws_On_Invalid_Term()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
Term term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId);
term.Name = Constants.TERM_InValidName;
//Act, Arrange
Assert.Throws <ArgumentException>(() => termController.AddTerm(term));
}
public void ContentTypeController_DeleteContentType_Throws_On_Negative_ContentTypeId()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var contentTypeController = new ContentTypeController(mockDataService.Object);
ContentType contentType = ContentTestHelper.CreateValidContentType();
contentType.ContentTypeId = Null.NullInteger;
//Act, Arrange
Assert.Throws <ArgumentOutOfRangeException>(() => contentTypeController.DeleteContentType(contentType));
}
public void ContentController_AddMetaData_Throws_On_Negative_ContentItemId()
{
// Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
ContentController controller = new ContentController(mockDataService.Object);
ContentItem content = ContentTestHelper.CreateValidContentItem();
content.ContentItemId = Null.NullInteger;
// Act, Arrange
Assert.Throws <ArgumentOutOfRangeException>(() => controller.AddMetaData(content, Constants.CONTENT_ValidMetaDataName, Constants.CONTENT_ValidMetaDataValue));
}
public void VocabularyController_AddVocabulary_Clears_Vocabulary_Cache_On_Valid_Vocabulary()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var vocabularyController = new VocabularyController(mockDataService.Object);
Vocabulary vocabulary = ContentTestHelper.CreateValidVocabulary();
//Act
vocabularyController.AddVocabulary(vocabulary);
//Assert
mockCache.Verify(cache => cache.Remove(Constants.VOCABULARY_CacheKey));
}
public void ScopeTypeController_AddScopeType_Calls_DataService_On_Valid_Arguments()
{
// Arrange
var mockDataService = new Mock <IDataService>();
var scopeTypeController = new ScopeTypeController(mockDataService.Object);
var scopeType = ContentTestHelper.CreateValidScopeType();
// Act
int scopeTypeId = scopeTypeController.AddScopeType(scopeType);
// Assert
mockDataService.Verify(ds => ds.AddScopeType(scopeType));
}
public void TermController_AddTerm_Clears_Term_Cache_On_Valid_Term()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
Term term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId);
//Act
termController.AddTerm(term);
//Assert
mockCache.Verify(cache => cache.Remove(String.Format(Constants.TERM_CacheKey, Constants.VOCABULARY_ValidVocabularyId)));
}
public void TermController_AddTerm_Should_Call_DataService_AddHeirarchicalTerm_If_Term_Is_Heirarchical_Term()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
Term term = ContentTestHelper.CreateValidHeirarchicalTerm(Constants.VOCABULARY_HierarchyVocabularyId, Constants.TERM_ValidParentTermId);
// Act
int termId = termController.AddTerm(term);
// Assert
mockDataService.Verify(ds => ds.AddHeirarchicalTerm(term, UserController.Instance.GetCurrentUserInfo().UserID));
}
public void VocabularyController_AddVocabulary_Calls_DataService_On_Valid_Arguments()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var vocabularyController = new VocabularyController(mockDataService.Object);
Vocabulary vocabulary = ContentTestHelper.CreateValidVocabulary();
//Act
int vocabularyId = vocabularyController.AddVocabulary(vocabulary);
//Assert
mockDataService.Verify(ds => ds.AddVocabulary(vocabulary, It.IsAny <int>()));
}
public void TermController_RemoveTermsFromContent_Should_Call_DataService_If_Valid_Params()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
ContentItem content = ContentTestHelper.CreateValidContentItem();
// Act
termController.RemoveTermsFromContent(content);
// Assert
mockDataService.Verify(ds => ds.RemoveTermsFromContent(content));
}
public void ScopeTypeController_AddScopeType_Sets_ValidId_On_Valid_ScopeType()
{
// Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.AddScopeType(It.IsAny <ScopeType>())).Returns(Constants.SCOPETYPE_AddScopeTypeId);
var scopeTypeController = new ScopeTypeController(mockDataService.Object);
var scopeType = ContentTestHelper.CreateValidScopeType();
// Act
scopeTypeController.AddScopeType(scopeType);
// Assert
Assert.AreEqual(Constants.SCOPETYPE_AddScopeTypeId, scopeType.ScopeTypeId);
}
public void VocabularyController_DeleteVocabulary_Calls_DataService_On_Valid_Arguments()
{
// Arrange
var mockDataService = new Mock<IDataService>();
var vocabularyController = new VocabularyController(mockDataService.Object);
Vocabulary vocabulary = ContentTestHelper.CreateValidVocabulary();
vocabulary.VocabularyId = Constants.VOCABULARY_ValidVocabularyId;
// Act
vocabularyController.DeleteVocabulary(vocabulary);
// Assert
mockDataService.Verify(ds => ds.DeleteVocabulary(vocabulary));
}
public void VocabularyController_AddVocabulary_Returns_ValidId_On_Valid_Vocabulary()
{
// Arrange
var mockDataService = new Mock<IDataService>();
mockDataService.Setup(ds => ds.AddVocabulary(It.IsAny<Vocabulary>(), It.IsAny<int>())).Returns(Constants.VOCABULARY_AddVocabularyId);
var vocabularyController = new VocabularyController(mockDataService.Object);
Vocabulary vocabulary = ContentTestHelper.CreateValidVocabulary();
// Act
int vocabularyId = vocabularyController.AddVocabulary(vocabulary);
// Assert
Assert.AreEqual(Constants.VOCABULARY_AddVocabularyId, vocabularyId);
}
public void TermController_AddTermToContent_Should_Call_DataService_If_Valid_Params()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
ContentItem content = ContentTestHelper.CreateValidContentItem();
Term term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId);
// Act
termController.AddTermToContent(term, content);
// Assert
mockDataService.Verify(ds => ds.AddTermToContent(term, content));
}
public void ScopeTypeController_DeleteScopeType_Calls_DataService_On_Valid_ContentTypeId()
{
// Arrange
var mockDataService = new Mock <IDataService>();
var scopeTypeController = new ScopeTypeController(mockDataService.Object);
var scopeType = ContentTestHelper.CreateValidScopeType();
scopeType.ScopeTypeId = Constants.SCOPETYPE_ValidScopeTypeId;
// Act
scopeTypeController.DeleteScopeType(scopeType);
// Assert
mockDataService.Verify(ds => ds.DeleteScopeType(scopeType));
}
public void ContentTypeController_AddContentType_Returns_ValidId_On_Valid_ContentType()
{
//Arrange
var mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.AddContentType(It.IsAny <ContentType>())).Returns(Constants.CONTENTTYPE_AddContentTypeId);
var contentTypeController = new ContentTypeController(mockDataService.Object);
var contentType = ContentTestHelper.CreateValidContentType();
//Act
int contentTypeId = contentTypeController.AddContentType(contentType);
//Assert
Assert.AreEqual(Constants.CONTENTTYPE_AddContentTypeId, contentTypeId);
}
public void TermController_DeleteTerm_Should_Call_DataService_DeleteHeirarchicalTerm_If_Term_Is_Heirarchical_Term()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
var term = ContentTestHelper.CreateValidHeirarchicalTerm(Constants.VOCABULARY_HierarchyVocabularyId, Constants.TERM_ValidParentTermId);
term.TermId = Constants.TERM_DeleteTermId;
// Act
termController.DeleteTerm(term);
// Assert
mockDataService.Verify(ds => ds.DeleteHeirarchicalTerm(term));
}
public void ContentController_DeleteContentItem_Calls_DataService_On_Valid_ContentItemId()
{
// Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
ContentController controller = new ContentController(mockDataService.Object);
ContentItem content = ContentTestHelper.CreateValidContentItem();
content.ContentItemId = Constants.CONTENT_DeleteContentItemId;
// Act
controller.DeleteContentItem(content);
// Assert
mockDataService.Verify(ds => ds.DeleteContentItem(content.ContentItemId));
}
public void TermController_AddTerm_Sets_Valid_Id_On_Valid_Term_If_Term_Is_Heirarchical_Term()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
mockDataService.Setup(ds => ds.AddHeirarchicalTerm(It.IsAny <Term>(), It.IsAny <int>())).Returns(Constants.TERM_AddTermId);
Term term = ContentTestHelper.CreateValidHeirarchicalTerm(Constants.VOCABULARY_HierarchyVocabularyId, Constants.TERM_ValidParentTermId);
//Act
termController.AddTerm(term);
//Assert
Assert.AreEqual(Constants.TERM_AddTermId, term.TermId);
}
public void ContentController_GetContentItem_Returns_ContentItem_On_Valid_ContentItemId()
{
// Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
mockDataService.Setup(ds => ds.GetContentItem(Constants.CONTENT_ValidContentItemId)).Returns(MockHelper.CreateValidContentItemReader());
ContentController controller = new ContentController(mockDataService.Object);
// Act
ContentItem content = controller.GetContentItem(Constants.CONTENT_ValidContentItemId);
// Assert
Assert.AreEqual(Constants.CONTENT_ValidContentItemId, content.ContentItemId);
Assert.AreEqual(ContentTestHelper.GetContent(Constants.CONTENT_ValidContentItemId), content.Content);
Assert.AreEqual(ContentTestHelper.GetContentKey(Constants.CONTENT_ValidContentItemId), content.ContentKey);
}
public void TermController_AddTerm_Returns_Valid_Id_On_Valid_Term_If_Term_Is_Simple_Term()
{
//Arrange
var mockDataService = new Mock <IDataService>();
var termController = new TermController(mockDataService.Object);
mockDataService.Setup(ds => ds.AddSimpleTerm(It.IsAny <Term>(), It.IsAny <int>())).Returns(Constants.TERM_AddTermId);
Term term = ContentTestHelper.CreateValidSimpleTerm(Constants.VOCABULARY_ValidVocabularyId);
//Act
int termId = termController.AddTerm(term);
//Assert
Assert.AreEqual(Constants.TERM_AddTermId, termId);
}
public void ContentController_DeleteMetaData_Calls_DataService_On_Valid_Arguments()
{
// Arrange
Mock <IDataService> mockDataService = new Mock <IDataService>();
ContentController controller = new ContentController(mockDataService.Object);
ContentItem content = ContentTestHelper.CreateValidContentItem();
content.ContentItemId = Constants.CONTENT_ValidContentItemId;
// Act
controller.DeleteMetaData(content, Constants.CONTENT_ValidMetaDataName, Constants.CONTENT_ValidMetaDataValue);
// Assert
mockDataService.Verify(ds => ds.DeleteMetaData(content, Constants.CONTENT_ValidMetaDataName, Constants.CONTENT_ValidMetaDataValue));
}
