public async Task ShouldGetAllCourseAttachmentsAsync() { // given var randomCourseAttachments = new List <CourseAttachment>(); for (var i = 0; i <= GetRandomNumber(); i++) { CourseAttachment randomCourseAttachment = await PostCourseAttachmentAsync(); randomCourseAttachments.Add(randomCourseAttachment); } List <CourseAttachment> inputCourseAttachments = randomCourseAttachments; List <CourseAttachment> expectedCourseAttachments = inputCourseAttachments; // when List <CourseAttachment> actualCourseAttachments = await this.otripleSApiBroker.GetAllCourseAttachmentsAsync(); // then foreach (CourseAttachment expectedCourseAttachment in expectedCourseAttachments) { CourseAttachment actualCourseAttachment = actualCourseAttachments.Single(studentAttachment => studentAttachment.CourseId == expectedCourseAttachment.CourseId); actualCourseAttachment.Should().BeEquivalentTo(expectedCourseAttachment); await DeleteCourseAttachmentAsync(actualCourseAttachment); } }
public async Task ShouldThrowServiceExceptionOnAddWhenExceptionOccursAndLogItAsync() { // given CourseAttachment someCourseAttachment = CreateRandomCourseAttachment(); var exception = new Exception(); var expectedCourseAttachmentServiceException = new CourseAttachmentServiceException(exception); this.storageBrokerMock.Setup(broker => broker.InsertCourseAttachmentAsync(It.IsAny <CourseAttachment>())) .ThrowsAsync(exception); // when ValueTask <CourseAttachment> addCourseAttachmentTask = this.courseAttachmentService.AddCourseAttachmentAsync(someCourseAttachment); // then await Assert.ThrowsAsync <CourseAttachmentServiceException>(() => addCourseAttachmentTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.InsertCourseAttachmentAsync(It.IsAny <CourseAttachment>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedCourseAttachmentServiceException))), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public ValueTask <CourseAttachment> AddCourseAttachmentAsync(CourseAttachment courseAttachment) => TryCatch(async() => { ValidateCourseAttachmentOnAdd(courseAttachment); return(await storageBroker.InsertCourseAttachmentAsync(courseAttachment)); });
private static void ValidateCourseAttachmentIsNull(CourseAttachment courseAttachment) { if (courseAttachment is null) { throw new NullCourseAttachmentException(); } }
public async void ShouldThrowValidationExceptionOnAddWhenCourseAttachmentIsNullAndLogItAsync() { // given CourseAttachment invalidCourseAttachment = null; var nullCourseAttachmentException = new NullCourseAttachmentException(); var expectedCourseAttachmentValidationException = new CourseAttachmentValidationException(nullCourseAttachmentException); // when ValueTask <CourseAttachment> addCourseAttachmentTask = this.courseAttachmentService.AddCourseAttachmentAsync(invalidCourseAttachment); // then await Assert.ThrowsAsync <CourseAttachmentValidationException>(() => addCourseAttachmentTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedCourseAttachmentValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertCourseAttachmentAsync(It.IsAny <CourseAttachment>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldRetrieveCourseAttachmentById() { // given CourseAttachment randomCourseAttachment = CreateRandomCourseAttachment(); CourseAttachment storageCourseAttachment = randomCourseAttachment; CourseAttachment expectedCourseAttachment = storageCourseAttachment; this.storageBrokerMock.Setup(broker => broker.SelectCourseAttachmentByIdAsync( randomCourseAttachment.CourseId, randomCourseAttachment.AttachmentId)) .ReturnsAsync(randomCourseAttachment); // when CourseAttachment actualCourseAttachment = await this.courseAttachmentService.RetrieveCourseAttachmentByIdAsync( randomCourseAttachment.CourseId, randomCourseAttachment.AttachmentId); // then actualCourseAttachment.Should().BeEquivalentTo(expectedCourseAttachment); this.storageBrokerMock.Verify(broker => broker.SelectCourseAttachmentByIdAsync( randomCourseAttachment.CourseId, randomCourseAttachment.AttachmentId), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldAddCourseAttachmentAsync() { // given CourseAttachment randomCourseAttachment = CreateRandomCourseAttachment(); CourseAttachment inputCourseAttachment = randomCourseAttachment; CourseAttachment storageCourseAttachment = randomCourseAttachment; CourseAttachment expectedCourseAttachment = storageCourseAttachment; this.storageBrokerMock.Setup(broker => broker.InsertCourseAttachmentAsync(inputCourseAttachment)) .ReturnsAsync(storageCourseAttachment); // when CourseAttachment actualCourseAttachment = await this.courseAttachmentService.AddCourseAttachmentAsync(inputCourseAttachment); // then actualCourseAttachment.Should().BeEquivalentTo(expectedCourseAttachment); this.storageBrokerMock.Verify(broker => broker.InsertCourseAttachmentAsync(inputCourseAttachment), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenAttachmentIdIsInvalidAndLogItAsync() { // given CourseAttachment randomCourseAttachment = CreateRandomCourseAttachment(); CourseAttachment inputCourseAttachment = randomCourseAttachment; inputCourseAttachment.AttachmentId = default; var invalidCourseAttachmentInputException = new InvalidCourseAttachmentException( parameterName: nameof(CourseAttachment.AttachmentId), parameterValue: inputCourseAttachment.AttachmentId); var expectedCourseAttachmentValidationException = new CourseAttachmentValidationException(invalidCourseAttachmentInputException); // when ValueTask <CourseAttachment> addCourseAttachmentTask = this.courseAttachmentService.AddCourseAttachmentAsync(inputCourseAttachment); // then await Assert.ThrowsAsync <CourseAttachmentValidationException>(() => addCourseAttachmentTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedCourseAttachmentValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertCourseAttachmentAsync(It.IsAny <CourseAttachment>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
private static void ValidateCourseAttachmentOnAdd(CourseAttachment courseAttachment) { ValidateCourseAttachmentIsNull(courseAttachment); Validate( (Rule: IsInvalid(courseAttachment.CourseId), Parameter: nameof(CourseAttachment.CourseId)), (Rule: IsInvalid(courseAttachment.AttachmentId), Parameter: nameof(CourseAttachment.AttachmentId))); }
public int InsertCourseAttachment(CourseAttachment courseAttachment) { using (var context = new HaermsEntities()) { var obj = context.CourseAttachment.Add(courseAttachment); context.SaveChanges(); return(obj.AttachmentId); } }
public async ValueTask <CourseAttachment> DeleteCourseAttachmentAsync( CourseAttachment courseAttachment) { EntityEntry <CourseAttachment> courseAttachmentEntityEntry = this.CourseAttachments.Remove(courseAttachment); await this.SaveChangesAsync(); return(courseAttachmentEntityEntry.Entity); }
public async ValueTask <CourseAttachment> InsertCourseAttachmentAsync( CourseAttachment courseAttachment) { EntityEntry <CourseAttachment> courseAttachmentEntityEntry = await this.CourseAttachments.AddAsync(courseAttachment); await this.SaveChangesAsync(); return(courseAttachmentEntityEntry.Entity); }
private static void ValidateStorageCourseAttachment( CourseAttachment storageCourseAttachment, Guid courseId, Guid attachmentId) { if (storageCourseAttachment is null) { throw new NotFoundCourseAttachmentException(courseId, attachmentId); } }
public async ValueTask <CourseAttachment> DeleteCourseAttachmentAsync( CourseAttachment courseAttachment) { using var broker = new StorageBroker(this.configuration); EntityEntry <CourseAttachment> courseAttachmentEntityEntry = broker.CourseAttachments.Remove(entity: courseAttachment); await broker.SaveChangesAsync(); return(courseAttachmentEntityEntry.Entity); }
public ValueTask <CourseAttachment> RemoveCourseAttachmentByIdAsync( Guid courseId, Guid attachmentId) => TryCatch(async() => { ValidateCourseAttachmentIds(courseId, attachmentId); CourseAttachment maybeCourseAttachment = await this.storageBroker.SelectCourseAttachmentByIdAsync(courseId, attachmentId); ValidateStorageCourseAttachment(maybeCourseAttachment, courseId, attachmentId); return(await this.storageBroker.DeleteCourseAttachmentAsync(maybeCourseAttachment)); });
//上传课件代码 protected void UploadCourseAttachment_Command(object sender, System.Web.UI.WebControls.CommandEventArgs e) { string savePath = @"/TeacherUpload/CourseWare/";//此处savePath未加入,应该填入相应路径 string teacherJobNum = ""; if (Session["user"] is Models.Teacher t) { teacherJobNum = t.JobNumber; if (FileUploadCourseAttachment.HasFile) { //上传到服务器文件夹中 String filename; filename = FileUploadCourseAttachment.FileName; //存储路径为当前路径+老师工号 string webSavePath = Server.MapPath("~" + savePath + "/" + teacherJobNum + "/" + filename); if (!Directory.Exists(Server.MapPath("~" + savePath + "/" + teacherJobNum + "/"))) { Directory.CreateDirectory(Server.MapPath("~" + savePath + "/" + teacherJobNum + "/")); } FileUploadCourseAttachment.SaveAs(webSavePath); //插入到数据库中 var neededInsertCourseAttachment = new CourseAttachment(); neededInsertCourseAttachment.Name = filename; //通过session获得课程id string cidString = Request.QueryString["course"]; neededInsertCourseAttachment.CourseId = int.Parse(cidString); neededInsertCourseAttachment.Path = savePath + teacherJobNum + "/" + filename; neededInsertCourseAttachment.IssuedTime = DateTime.Now.ToLocalTime(); if (new CourseAttachmentServiceimpl().Create(neededInsertCourseAttachment) > 0) { Response.Redirect(Request.Url.ToString()); } else { Response.Write("<script language='javascript'>alert('上传失败,请重试!');</script>"); } } } else { Response.Write("<script language='javascript'>alert('上传失败,请重试!');</script>"); } }
public async Task ShouldThrowValidationExceptionOnRemoveWhenStorageCourseAttachmentIsNotFoundAndLogItAsync() { // given DateTimeOffset randomDateTime = GetRandomDateTime(); CourseAttachment randomCourseAttachment = CreateRandomCourseAttachment(randomDateTime); Guid someAttachmentId = randomCourseAttachment.AttachmentId; Guid someCourseId = randomCourseAttachment.CourseId; CourseAttachment nullStorageCourseAttachment = null; var notFoundCourseAttachmentException = new NotFoundCourseAttachmentException(someCourseId, someAttachmentId); var expectedCourseValidationException = new CourseAttachmentValidationException(notFoundCourseAttachmentException); this.storageBrokerMock.Setup(broker => broker.SelectCourseAttachmentByIdAsync(someCourseId, someAttachmentId)) .ReturnsAsync(nullStorageCourseAttachment); // when ValueTask <CourseAttachment> removeCourseAttachmentTask = this.courseAttachmentService.RemoveCourseAttachmentByIdAsync(someCourseId, someAttachmentId); // then await Assert.ThrowsAsync <CourseAttachmentValidationException>(() => removeCourseAttachmentTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.SelectCourseAttachmentByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedCourseValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteCourseAttachmentAsync(It.IsAny <CourseAttachment>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenReferneceExceptionAndLogItAsync() { // given CourseAttachment randomCourseAttachment = CreateRandomCourseAttachment(); CourseAttachment someCourseAttachment = randomCourseAttachment; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var foreignKeyConstraintConflictException = new ForeignKeyConstraintConflictException(exceptionMessage); var invalidCourseAttachmentReferenceException = new InvalidCourseAttachmentReferenceException(foreignKeyConstraintConflictException); var expectedCourseAttachmentValidationException = new CourseAttachmentValidationException(invalidCourseAttachmentReferenceException); this.storageBrokerMock.Setup(broker => broker.InsertCourseAttachmentAsync(someCourseAttachment)) .ThrowsAsync(foreignKeyConstraintConflictException); // when ValueTask <CourseAttachment> addCourseAttachmentTask = this.courseAttachmentService.AddCourseAttachmentAsync(someCourseAttachment); // then await Assert.ThrowsAsync <CourseAttachmentValidationException>(() => addCourseAttachmentTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.InsertCourseAttachmentAsync(It.IsAny <CourseAttachment>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedCourseAttachmentValidationException))), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenCourseAttachmentAlreadyExistsAndLogItAsync() { // given CourseAttachment randomCourseAttachment = CreateRandomCourseAttachment(); CourseAttachment alreadyExistsCourseAttachment = randomCourseAttachment; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var duplicateKeyException = new DuplicateKeyException(exceptionMessage); var alreadyExistsCourseAttachmentException = new AlreadyExistsCourseAttachmentException(duplicateKeyException); var expectedCourseAttachmentValidationException = new CourseAttachmentValidationException(alreadyExistsCourseAttachmentException); this.storageBrokerMock.Setup(broker => broker.InsertCourseAttachmentAsync(alreadyExistsCourseAttachment)) .ThrowsAsync(duplicateKeyException); // when ValueTask <CourseAttachment> addCourseAttachmentTask = this.courseAttachmentService.AddCourseAttachmentAsync(alreadyExistsCourseAttachment); // then await Assert.ThrowsAsync <CourseAttachmentValidationException>(() => addCourseAttachmentTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.InsertCourseAttachmentAsync(It.IsAny <CourseAttachment>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedCourseAttachmentValidationException))), Times.Once); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldPostCourseAttachmentAsync() { // given CourseAttachment randomCourseAttachment = await CreateRandomCourseAttachment(); CourseAttachment inputCourseAttachment = randomCourseAttachment; CourseAttachment expectedCourseAttachment = inputCourseAttachment; // when CourseAttachment actualCourseAttachment = await this.otripleSApiBroker.PostCourseAttachmentAsync(inputCourseAttachment); CourseAttachment retrievedCourseAttachment = await this.otripleSApiBroker.GetCourseAttachmentByIdsAsync( inputCourseAttachment.CourseId, inputCourseAttachment.AttachmentId); // then actualCourseAttachment.Should().BeEquivalentTo(expectedCourseAttachment); retrievedCourseAttachment.Should().BeEquivalentTo(expectedCourseAttachment); await DeleteCourseAttachmentAsync(actualCourseAttachment); }
public async Task ShouldDeleteCourseAttachmentAsync() { // given CourseAttachment randomCourseAttachment = await PostCourseAttachmentAsync(); CourseAttachment inputCourseAttachment = randomCourseAttachment; CourseAttachment expectedCourseAttachment = inputCourseAttachment; // when CourseAttachment deletedCourseAttachment = await DeleteCourseAttachmentAsync(inputCourseAttachment); ValueTask <CourseAttachment> getCourseAttachmentByIdTask = this.otripleSApiBroker.GetCourseAttachmentByIdsAsync( inputCourseAttachment.CourseId, inputCourseAttachment.AttachmentId); // then deletedCourseAttachment.Should().BeEquivalentTo(expectedCourseAttachment); await Assert.ThrowsAsync <HttpResponseNotFoundException>(() => getCourseAttachmentByIdTask.AsTask()); }
public async ValueTask <CourseAttachment> PostCourseAttachmentAsync(CourseAttachment courseAttachment) => await this.apiFactoryClient.PostContentAsync(CourseAttachmentsRelativeUrl, courseAttachment);
private void ValidateCourseAttachmentOnCreate(CourseAttachment courseAttachment) { ValidateCourseAttachmentIsNull(courseAttachment); ValidateCourseAttachmentIds(courseAttachment.CourseId, courseAttachment.AttachmentId); }