public async Task CreateReport_WhenParamsAreValid()
{
//Arrange
var options = Utils.GetOptions(nameof(CreateReport_WhenParamsAreValid));
var title = "Report Title";
var summary = "Report Summary";
var description = "Report Description";
var author = TestModelsSeeder.SeedUser();
var industry = TestModelsSeeder.SeedIndustry();
var imgURL = "imageurl";
var tag = TestModelsSeeder.SeedTag();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Users.AddAsync(author);
await arrangeContext.Industries.AddAsync(industry);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sutReports = new ReportServices(assertContext, sutTags);
var act = await sutReports.CreateReport(title, summary, description, author.Email, imgURL, industry.Name, tag.Name);
var result = assertContext.Reports.FirstOrDefault(t => t.Title == title);
Assert.AreEqual(title, result.Title);
Assert.AreEqual(description, result.Description);
Assert.AreEqual(tag.Name, result.ReportTags.First().Tag.Name);
}
public async Task ReturnCorrectDeletedTags_When_ParamsValid()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnCorrectDeletedTags_When_ParamsValid));
var firstTag = TestModelsSeeder.SeedTag();
var secondTag = TestModelsSeeder.SeedTag2();
using (var arrangeContext = new InsightHubContext(options))
{
arrangeContext.Tags.Add(firstTag);
arrangeContext.Tags.Add(secondTag);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sut = new TagServices(assertContext);
await sut.DeleteTag(1);
await sut.DeleteTag(2);
var act = await sut.GetDeletedTags();
var result = act.ToArray();
Assert.AreEqual(2, result.Length);
Assert.AreEqual(firstTag.Name, result[0].Name);
Assert.AreEqual(secondTag.Name, result[1].Name);
}
public async Task ReturnCorrectTags_WithSortAndSearch_When_ParamValid()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnCorrectTags_WithSortAndSearch_When_ParamValid));
var firstTag = TestModelsSeeder.SeedTag();
var secondTag = TestModelsSeeder.SeedTag2();
var thirdTag = TestModelsSeeder.SeedTag3();
using (var arrangeContext = new InsightHubContext(options))
{
arrangeContext.Tags.Add(firstTag);
arrangeContext.Tags.Add(secondTag);
arrangeContext.Tags.Add(thirdTag);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sut = new TagServices(assertContext);
var act = await sut.GetTags("name_desc", "Test");
var result = act.ToArray();
Assert.AreEqual(3, result.Count());
Assert.AreEqual(thirdTag.Name, result[0].Name);
}
internal static TemplateServices CreateTestTemplateServices()
{
BuildHandler buildHandler = new BuildHandler();
TagServices tagServices = new TagServices(buildHandler);
return(new TemplateServices(buildHandler, tagServices));
}
public async Task ThrowArgumentException_When_TitleAlreadyExists()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentException_When_TitleAlreadyExists));
var summary = "Report Summary";
var description = "Report Description";
var author = TestModelsSeeder.SeedUser();
var industry = TestModelsSeeder.SeedIndustry();
var imgURL = "imageurl";
var tag = TestModelsSeeder.SeedTag();
var report = TestModelsSeeder.SeedReport();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Users.AddAsync(author);
await arrangeContext.Industries.AddAsync(industry);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Reports.AddAsync(report);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sutReports = new ReportServices(assertContext, sutTags);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sutReports.CreateReport(report.Title, summary, description, author.Email, imgURL, industry.Name, tag.Name));
}
public void TwoTagsFirstWithContentAndPropertySecondTwoProperties()
{
TagServices tagServices = new TagServices(new BuildHandler());
// 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222
// 11111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223
// 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
string searchText = "some test text <!-- a_tag_name_START tag0property0='some value' -->some content<!-- a_tag_name_END --> <!-- a_tag_name_START tag1Property0='another value' tag1Property1='yet another value' --> more content <!-- a_tag_name_END --> and some more text";
string tagName = "a_tag_name";
List <Tag> actualTags = tagServices.ExtractTags(searchText, tagName, true);
// Check result
Dictionary <string, string> expectedTag0Properties = new Dictionary <string, string>()
{
{ "tag0property0", "some value" }
};
Tag expectedTag0 = TagUtilities.CreateTestTag(tagName, searchText, 15, 37, 67, 79, 99, 102, "some content", expectedTag0Properties);
Dictionary <string, string> expectedTag1Properties = new Dictionary <string, string>()
{
{ "tag1Property0", "another value" }, { "tag1Property1", "yet another value" }
};
Tag expectedTag1 = TagUtilities.CreateTestTag(tagName, searchText, 104, 126, 193, 207, 227, 230, " more content ", expectedTag1Properties);
Assert.True(2 == actualTags.Count);
TagUtilities.AreTagsSame(expectedTag0, actualTags[0]);
TagUtilities.AreTagsSame(expectedTag1, actualTags[1]);
}
public async Task ApproveReport_When_ParamsValid()
{
//Arrange
var options = Utils.GetOptions(nameof(ApproveReport_When_ParamsValid));
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
report1.IsPending = true;
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTag = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTag);
await sut.ApproveReport(1);
Assert.IsFalse(assertContext.Reports.First(u => u.Id == 1).IsPending);
}
public async Task ToggleReport_ToFeatured_When_NotFeatured()
{
//Arrange
var options = Utils.GetOptions(nameof(ToggleReport_ToFeatured_When_NotFeatured));
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTag = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTag);
Assert.IsFalse(assertContext.Reports.First(u => u.Id == 1).IsFeatured);
await sut.ToggleFeatured(1);
Assert.IsTrue(assertContext.Reports.First(u => u.Id == 1).IsFeatured);
}
public async Task DoNot_AddToDownloadsCount_When_AlreadyDownloaded()
{
//Arrange
var options = Utils.GetOptions(nameof(DoNot_AddToDownloadsCount_When_AlreadyDownloaded));
var user = TestModelsSeeder.SeedUser();
var report = TestModelsSeeder.SeedReport();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.Reports.AddAsync(report);
arrangeContext.SaveChanges();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTags);
await sut.AddToDownloadsCount(user.Id, report.Id);
await sut.AddToDownloadsCount(user.Id, report.Id);
var count = assertContext.DownloadedReports.Count();
Assert.AreEqual(1, count);
}
public async Task GetsCorrectReport_When_ParamsValid()
{
//Arrange
var options = Utils.GetOptions(nameof(GetsCorrectReport_When_ParamsValid));
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTags);
var result = await sut.GetReport(1);
Assert.AreEqual(report1.Title, result.Title);
Assert.AreEqual(report1.Summary, result.Summary);
Assert.AreEqual(report1.Description, result.Description);
Assert.AreEqual(report1.Author.Email, result.Author.Split(" ").Last());
}
public async Task ThrowArgumentException_WhenReportNotExists()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentException_WhenReportNotExists));
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTag = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTag);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.ApproveReport(5));
}
public void TwoTagsOnePropertyTwoProperties()
{
TagServices tagServices = new TagServices(new BuildHandler());
// 111111111111111111111111111111111111111111111111111
// 111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999000000000011111111112222222222333333333344444444445
// 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
string searchText = "some test text <!-- a_tag_name tag0property0='some value' --> <!-- a_tag_name tag1Property0='another value' tag1Property1='yet another value' --> and some more text";
string tagName = "a_tag_name";
List <Tag> actualTags = tagServices.ExtractTags(searchText, tagName, false);
// Check result
Dictionary <string, string> expectedTag0Properties = new Dictionary <string, string>()
{
{ "tag0property0", "some value" }
};
Tag expectedTag0 = TagUtilities.CreateTestTag(tagName, searchText, 15, 31, 61, null, null, null, null, expectedTag0Properties);
Dictionary <string, string> expectedTag1Properties = new Dictionary <string, string>()
{
{ "tag1Property0", "another value" }, { "tag1Property1", "yet another value" }
};
Tag expectedTag1 = TagUtilities.CreateTestTag(tagName, searchText, 62, 78, 145, null, null, null, null, expectedTag1Properties);
Assert.True(2 == actualTags.Count);
TagUtilities.AreTagsSame(expectedTag0, actualTags[0]);
TagUtilities.AreTagsSame(expectedTag1, actualTags[1]);
}
public PostsController(ForumCategoryServices forumCategoryServices, PostServices postServices, CommentServices commentServices, TagServices tagServices, ThemeServices themeServices)
{
_forumCategriesManager = forumCategoryServices;
_postsManager = postServices;
_commentsManager = commentServices;
_tagsManager = tagServices;
_themesManager = themeServices;
}
public void EmptyString()
{
TagServices tagServices = new TagServices(new BuildHandler());
List <Tag> actualTags = tagServices.ExtractTags("", "a_tag_name", false);
// Check result
Assert.IsEmpty(actualTags);
}
public void NoTags()
{
TagServices tagServices = new TagServices(new BuildHandler());
List <Tag> actualTags = tagServices.ExtractTags("some test text", "a_tag_name", true);
// Check result
Assert.IsEmpty(actualTags);
}
public async Task ReturnPendingReports_WithSearch_When_ParamValid()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnPendingReports_WithSearch_When_ParamValid));
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
var tag2 = TestModelsSeeder.SeedTag2();
var tag3 = TestModelsSeeder.SeedTag3();
var report2 = TestModelsSeeder.SeedReport2();
var industry2 = TestModelsSeeder.SeedIndustry2();
var report3 = TestModelsSeeder.SeedReport3();
var industry3 = TestModelsSeeder.SeedIndustry3();
report1.IsPending = true;
report2.IsPending = true;
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Reports.AddAsync(report2);
await arrangeContext.Tags.AddAsync(tag2);
await arrangeContext.Industries.AddAsync(industry2);
await arrangeContext.Reports.AddAsync(report3);
await arrangeContext.Tags.AddAsync(tag3);
await arrangeContext.Industries.AddAsync(industry3);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTags);
var act = await sut.GetPendingReports(null, "TestReport");
var result = act.ToArray();
Assert.AreEqual(2, result.Length);
Assert.AreEqual(report1.Title, result[0].Title);
Assert.AreEqual(report1.Summary, result[0].Summary);
Assert.IsTrue(result[0].Title.Contains("TestReport"));
Assert.AreEqual(report2.Title, result[1].Title);
Assert.AreEqual(report2.Summary, result[1].Summary);
Assert.IsTrue(result[1].Title.Contains("TestReport"));
}
public async Task GetMostDownloadedReports_When_ParamsValid()
{
//Arrange
var options = Utils.GetOptions(nameof(GetMostDownloadedReports_When_ParamsValid));
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
var tag2 = TestModelsSeeder.SeedTag2();
var tag3 = TestModelsSeeder.SeedTag3();
var report2 = TestModelsSeeder.SeedReport2();
var industry2 = TestModelsSeeder.SeedIndustry2();
var report3 = TestModelsSeeder.SeedReport3();
var industry3 = TestModelsSeeder.SeedIndustry3();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Reports.AddAsync(report2);
await arrangeContext.Tags.AddAsync(tag2);
await arrangeContext.Industries.AddAsync(industry2);
await arrangeContext.Reports.AddAsync(report3);
await arrangeContext.Tags.AddAsync(tag3);
await arrangeContext.Industries.AddAsync(industry3);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTags);
var act = await sut.GetMostDownloadedReports();
var result = act.ToArray();
Assert.AreEqual(3, result.Length);
Assert.AreEqual(report2.Title, result[0].Title);
Assert.AreEqual(report2.Summary, result[0].Summary);
Assert.IsTrue(result[0].DownloadsCount > result[1].DownloadsCount);
Assert.AreEqual(report1.Title, result[1].Title);
Assert.AreEqual(report1.Summary, result[1].Summary);
Assert.IsTrue(result[1].DownloadsCount > result[2].DownloadsCount);
Assert.AreEqual(report3.Title, result[2].Title);
Assert.AreEqual(report3.Summary, result[2].Summary);
}
public ForumController(ForumCategoryServices forumCategoryServices, PostServices postServices, CommentServices commentServices, TagServices tagServices, ThemeServices themeServices, ApplicationUserManager userManager)
{
_forumCategriesManager = forumCategoryServices;
_postsManager = postServices;
_commentsManager = commentServices;
_tagsManager = tagServices;
_themesManager = themeServices;
_userManager = userManager;
}
public async Task ThrowArgumentNullException_When_NotExists()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentNullException_When_NotExists));
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sut = new TagServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.UpdateTag(5, "n"));
}
public async Task Throw_When_ParamsNotValid()
{
//Arrange
var options = Utils.GetOptions(nameof(Throw_When_ParamsNotValid));
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sut = new TagServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await sut.DeleteTag(5));
}
public async Task ReturnNotDeletedReport_WithSortAndSearchAndIndustry_When_ParamValid()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnNotDeletedReport_WithSortAndSearchAndIndustry_When_ParamValid));
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
var tag2 = TestModelsSeeder.SeedTag2();
var tag3 = TestModelsSeeder.SeedTag3();
var report2 = TestModelsSeeder.SeedReport2();
var industry2 = TestModelsSeeder.SeedIndustry2();
var report3 = TestModelsSeeder.SeedReport3();
var industry3 = TestModelsSeeder.SeedIndustry3();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Reports.AddAsync(report2);
await arrangeContext.Tags.AddAsync(tag2);
await arrangeContext.Industries.AddAsync(industry2);
await arrangeContext.Reports.AddAsync(report3);
await arrangeContext.Tags.AddAsync(tag3);
await arrangeContext.Industries.AddAsync(industry3);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTags);
var act = await sut.GetReports("title_desc", "TestReport", null, "Industry", null);
var result = act.ToList();
Assert.AreEqual(3, result.Count());
Assert.AreEqual(report3.Title, result[0].Title);
Assert.IsTrue(result[0].Industry.Contains("Industry"));
Assert.AreEqual(report2.Title, result[1].Title);
Assert.IsTrue(result[1].Industry.Contains("Industry"));
Assert.AreEqual(report1.Title, result[2].Title);
Assert.IsTrue(result[2].Industry.Contains("Industry"));
}
public async Task Throw_When_IdIsInvalid()
{
//Arrange
var options = Utils.GetOptions(nameof(Throw_When_IdIsInvalid));
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTag = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTag);
await sut.GetReport(5);
}
public void OneTagNotClosed()
{
TagServices tagServices = new TagServices(new BuildHandler());
// 11111111112222222222333333333344444444445555555555666666666677777777778888888888999
// 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012
string searchText = "some test text <!-- a_tag_name_START -->some content<!-- a_tag_name_ZEND --> and some more text";
string tagName = "a_tag_name";
BuildException buildException = Assert.Throws <BuildException>(() => { tagServices.ExtractTags(searchText, tagName, true); });
// Check result
Assert.AreEqual("Missing end tag", buildException.Message);
}
public void OneTagMissingCommentEnd()
{
TagServices tagServices = new TagServices(new BuildHandler());
// 1111111111222222222233333333334444444444555
// 01234567890123456789012345678901234567890123456789012
string searchText = "some test text <!-- a_tag_name and some more text";
string tagName = "a_tag_name";
BuildException buildException = Assert.Throws <BuildException>(() => { tagServices.ExtractTags(searchText, tagName, false); });
// Check result
Assert.AreEqual(tagName + " tag not closed", buildException.Message);
}
public void OneTagNoSpaceBetweenCommentAndTagName()
{
TagServices tagServices = new TagServices(new BuildHandler());
// 1111111111222222222233333333334444444444555
// 01234567890123456789012345678901234567890123456789012
string searchText = "some test text <!--a_tag_name--> and some more text";
string tagName = "a_tag_name";
List <Tag> actualTags = tagServices.ExtractTags(searchText, tagName, false);
// Check result
Assert.True(0 == actualTags.Count);
}
public void OneTagWithOnePropertyMissingSecondQuote()
{
TagServices tagServices = new TagServices(new BuildHandler());
// 11111111112222222222333333333344444444445555555555666666666677777777778888888888999
// 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012
string searchText = "some test text <!-- a_tag_name property0=' --> and some more text";
string tagName = "a_tag_name";
BuildException buildException = Assert.Throws <BuildException>(() => { tagServices.ExtractTags(searchText, tagName, false); });
// Check result
Assert.AreEqual("Missing second single quote", buildException.Message);
}
public async Task GetsCorrectReports_When_ParamsValid()
{
//Arrange
var options = Utils.GetOptions(nameof(GetsCorrectReports_When_ParamsValid));
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
var tag2 = TestModelsSeeder.SeedTag2();
var tag3 = TestModelsSeeder.SeedTag3();
var report2 = TestModelsSeeder.SeedReport2();
var industry2 = TestModelsSeeder.SeedIndustry2();
var report3 = TestModelsSeeder.SeedReport3();
var industry3 = TestModelsSeeder.SeedIndustry3();
report1.IsDeleted = true;
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Reports.AddAsync(report2);
await arrangeContext.Tags.AddAsync(tag2);
await arrangeContext.Industries.AddAsync(industry2);
await arrangeContext.Reports.AddAsync(report3);
await arrangeContext.Tags.AddAsync(tag3);
await arrangeContext.Industries.AddAsync(industry3);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sut = new ReportServices(assertContext, sutTags);
var result = await sut.GetReports(null, null, null, null, null);
Assert.AreEqual(2, result.Count);
}
public async Task ReturnCorrectNewTag_When_ParamValid()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnCorrectNewTag_When_ParamValid));
var tagName = "space";
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sut = new TagServices(assertContext);
var act = await sut.CreateTag(tagName);
var result = assertContext.Tags.FirstOrDefault(t => t.Name == tagName);
Assert.AreEqual(tagName, result.Name);
}
public async Task UpdateReport_WhenParamsAreValid()
{
//Arrange
var options = Utils.GetOptions(nameof(UpdateReport_WhenParamsAreValid));
var newTitle = "New Report Title";
var newSummary = "New Report Summary";
var newDescription = "New Report Description";
var newIndustry = TestModelsSeeder.SeedIndustry2();
var newImgURL = "imageurl";
var newTag = TestModelsSeeder.SeedTag2();
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Industries.AddAsync(newIndustry);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Tags.AddAsync(newTag);
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sutReports = new ReportServices(assertContext, sutTags);
var act = await sutReports.UpdateReport(1, newTitle, newSummary, newDescription, newImgURL, newIndustry.Name, newTag.Name);
var result = assertContext.Reports.FirstOrDefault(t => t.Title == newTitle);
Assert.AreEqual(newTitle, result.Title);
Assert.AreEqual(newSummary, result.Summary);
Assert.AreEqual(newDescription, result.Description);
Assert.AreEqual(newIndustry.Name, result.Industry.Name);
Assert.AreEqual(newImgURL, result.ImgUrl);
Assert.AreEqual(newTag.Name, result.ReportTags.First().Tag.Name);
}
public async Task ThrowArgumentException_WhenTitleAlreadyExists()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentException_WhenTitleAlreadyExists));
var newSummary = "New Report Summary";
var newDescription = "New Report Description";
var newIndustry = TestModelsSeeder.SeedIndustry2();
var newImgURL = "imageurl";
var newTag = TestModelsSeeder.SeedTag2();
var report1 = TestModelsSeeder.SeedReport();
var industry1 = TestModelsSeeder.SeedIndustry();
var user = TestModelsSeeder.SeedUser();
var tag = TestModelsSeeder.SeedTag();
var report2 = TestModelsSeeder.SeedReport2();
var industry2 = TestModelsSeeder.SeedIndustry3();
var tag2 = TestModelsSeeder.SeedTag3();
using (var arrangeContext = new InsightHubContext(options))
{
await arrangeContext.Users.AddAsync(user);
await arrangeContext.Industries.AddAsync(industry1);
await arrangeContext.Industries.AddAsync(industry2);
await arrangeContext.Industries.AddAsync(newIndustry);
await arrangeContext.Tags.AddAsync(tag);
await arrangeContext.Tags.AddAsync(newTag);
await arrangeContext.Tags.AddAsync(tag2);
await arrangeContext.Reports.AddAsync(report1);
await arrangeContext.Reports.AddAsync(report2);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using var assertContext = new InsightHubContext(options);
var sutTags = new TagServices(assertContext);
var sutReports = new ReportServices(assertContext, sutTags);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sutReports.UpdateReport(1, report2.Title, newSummary, newDescription, newImgURL, newIndustry.Name, newTag.Name));
}
