public virtual async Task UploadValidQualityIntoQualities_Returns_ValidList()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var httpClient  = lifeTimeScope.Resolve <HttpClient>();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.Qualities = new List <string>();

                var values = Enum.GetNames(typeof(Qualities));
                foreach (var value in values)
                {
                    uploadModel.Qualities.Add(value);
                }

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative),
                                                     uploadModel.ToMultipartFormDataContent());

                var uploadResult = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(uploadResult.Qualities);
                for (var id = 0; id < values.Length; id++)
                {
                    Assert.AreEqual(values[id], uploadResult.Qualities[id].ToString("G"));
                }
            }
        }
        public virtual async Task UploadValidQualityToNonNullableQuality_Returns_ModelWithValidQuality()
        {
            using (var lifeTimeScope = _testServer.Services.CreateScope())
            {
                var httpClient  = _testServer.CreateClient();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.NonNullableQuality = nameof(Qualities.Best);

                var httpResponseMessage = await httpClient.PostAsync(new Uri("api/upload", UriKind.Relative),
                                                                     uploadModel.ToMultipartFormDataContent());

                var uploadResult = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.AreEqual(Qualities.Best, uploadResult.NonNullableQuality);
            }
        }
        public virtual async Task NoUploadQualitiesIntoQualities_Returns_Null()
        {
            using (var lifeTimeScope = _testServer.Services.CreateScope())
            {
                var httpClient  = _testServer.CreateClient();
                var uploadModel = new RawUploadRequestViewModel();

                var content             = uploadModel.ToMultipartFormDataContent();
                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), content);

                var uploadResult = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.IsNull(uploadResult.Qualities);
            }
        }
        public virtual async Task UploadValidIntQualityToNonNullableQuality_Returns_ModelWithValidQuality()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var httpClient  = lifeTimeScope.Resolve <HttpClient>();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.NonNullableQuality = $"{(int) Qualities.Best}";

                var httpResponseMessage = await httpClient.PostAsync(new Uri("api/upload", UriKind.Relative),
                                                                     uploadModel.ToMultipartFormDataContent());

                var uploadResult = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.AreEqual(Qualities.Best, uploadResult.NonNullableQuality);
            }
        }
        public virtual async Task UploadOutOfRangeQualityToNullableQuality_Returns_ModelWithNullQuality()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var httpClient  = lifeTimeScope.Resolve <HttpClient>();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.NullableQuality = "10000";

                var httpResponseMessage = await httpClient.PostAsync(new Uri("api/upload", UriKind.Relative),
                                                                     uploadModel.ToMultipartFormDataContent());

                var uploadResult = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.IsNull(uploadResult.NullableQuality);
            }
        }
        public virtual async Task NoUploadQualitiesIntoQualities_Returns_Null()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var httpClient  = lifeTimeScope.Resolve <HttpClient>();
                var uploadModel = new RawUploadRequestViewModel();

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative),
                                                     uploadModel.ToMultipartFormDataContent());

                var uploadResult = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.IsNull(uploadResult.Qualities);
            }
        }
        public virtual async Task UploadOutOfRangeQualityToProfileNullableQuality_Returns_ModelWithNullProfileQuality()
        {
            using (var lifeTimeScope = _testServer.Services.CreateScope())
            {
                var httpClient  = _testServer.CreateClient();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.Profile = new RawProfileViewModel();
                uploadModel.Profile.NullableQuality = "10000";

                var httpResponseMessage = await httpClient.PostAsync(new Uri("api/upload", UriKind.Relative),
                                                                     uploadModel.ToMultipartFormDataContent());

                var uploadResult = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.IsNull(uploadResult.NullableQuality);
            }
        }
예제 #8
0
        public virtual async Task UploadValidProfileNonNullableGuidString_Returns_ModelWithValidProfileGuid()
        {
            using (var lifeTimeScope = _testServer.Services.CreateScope())
            {
                var httpClient  = _testServer.CreateClient();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.Profile = new RawProfileViewModel();
                uploadModel.Profile.NonNullableId = Guid.NewGuid().ToString("D");

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative),
                                                     uploadModel.ToMultipartFormDataContent());

                var httpResponse = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(httpResponse);
                Assert.AreEqual(uploadModel.Profile.NonNullableId,
                                httpResponse.Profile.NonNullableId.ToString("D"));
            }
        }
예제 #9
0
        public async Task UploadValidAttachment_Returns_AttachmentInfoWhoseInfoSameAsUploadedOne()
        {
            using (var lifeTimeScope = _testServer.Services.CreateScope())
            {
                var attachmentService = lifeTimeScope.ServiceProvider.GetService <IAttachmentService>();

                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.Attachment = await attachmentService.LoadSampleAttachmentAsync();

                var httpClient           = _testServer.CreateClient();
                var multipartFormContent = uploadModel.ToMultipartFormDataContent();
                var httpResponseMessage  = await httpClient
                                           .PostAsync(new Uri("api/upload", UriKind.Relative), multipartFormContent);

                var uploadResult = await httpResponseMessage
                                   .Content.ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(uploadResult);
                Assert.AreEqual(uploadModel.Attachment.FileName, uploadResult.Attachment.FileName);
                Assert.AreEqual(uploadModel.Attachment.ContentLength, uploadResult.Attachment.ContentLength);
                Assert.AreEqual(uploadModel.Attachment.ContentType, uploadResult.Attachment.ContentType);
            }
        }
예제 #10
0
        public virtual async Task UploadValidAttachments_Returns_AttachmentsInfoWhoseInfoSameAsUploadedOnes()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var attachmentService = lifeTimeScope.Resolve <IAttachmentService>();
                var sampleAttachment  = await attachmentService.LoadSampleAttachmentAsync();

                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.Attachments = new List <HttpFile>();
                uploadModel.Attachments.Add(new HttpFile(sampleAttachment));

                var httpClient          = lifeTimeScope.Resolve <HttpClient>();
                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

                var uploadResult = await httpResponseMessage
                                   .Content.ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(uploadResult);
                Assert.NotNull(uploadResult.Attachments);

                for (var id = 0; id < uploadModel.Attachments.Count; id++)
                {
                    Assert.AreEqual(uploadModel.Attachments[id].FileName, uploadResult.Attachments[id].FileName);
                    Assert.AreEqual(uploadModel.Attachments[id].ContentLength, uploadResult.Attachments[id].ContentLength);
                    Assert.AreEqual(uploadModel.Attachments[id].ContentType, uploadResult.Attachments[id].ContentType);
                }
            }
        }
예제 #11
0
        public virtual async Task IncludeIdsInProfileIds_Returns_ModelWithUploadedProfileIds()
        {
            using (var lifeTimeScope = _testServer.Services.CreateScope())
            {
                var httpClient  = _testServer.CreateClient();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.Profile     = new RawProfileViewModel();
                uploadModel.Profile.Ids = new List <string>
                {
                    Guid.NewGuid().ToString("D"),
                    Guid.NewGuid().ToString("D"),
                    Guid.NewGuid().ToString("D"),
                    Guid.NewGuid().ToString("D")
                };

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

                var httpResponse = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(httpResponse);

                for (var id = 0; id < uploadModel.Profile.Ids.Count; id++)
                {
                    Assert.AreEqual(uploadModel.Profile.Ids[id], httpResponse.Profile.Ids[id].ToString("D"));
                }
            }
        }
예제 #12
0
        public virtual async Task UploadValidProfileAttachments_Returns_AttachmentsInfoWhoseInfoSameAsUploadedOnes()
        {
            var attachmentService = _testServer.Services.GetService <IAttachmentService>();

            var uploadModel = new RawUploadRequestViewModel();

            uploadModel.Profile        = new RawProfileViewModel();
            uploadModel.Profile.Photos = new List <HttpFileBase>();
            uploadModel.Profile.Photos.Add(await attachmentService.LoadSampleAttachmentAsync());
            uploadModel.Profile.Photos.Add(await attachmentService.LoadSampleAttachmentAsync());

            var httpClient          = _testServer.CreateClient();
            var httpResponseMessage = await httpClient
                                      .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

            var uploadResult = await httpResponseMessage
                               .Content.ReadAsAsync <UploadResponseViewModel>();

            Assert.NotNull(uploadResult);
            Assert.NotNull(uploadResult.Profile);
            Assert.NotNull(uploadResult.Profile.Photos);

            for (var id = 0; id < uploadModel.Profile.Photos.Count; id++)
            {
                Assert.AreEqual(uploadModel.Profile.Photos[id].FileName, uploadResult.Profile.Photos[id].FileName);
                Assert.AreEqual(uploadModel.Profile.Photos[id].ContentLength,
                                uploadResult.Profile.Photos[id].ContentLength);
                Assert.AreEqual(uploadModel.Profile.Photos[id].ContentType,
                                uploadResult.Profile.Photos[id].ContentType);
            }
        }
예제 #13
0
        public virtual async Task UploadValidNestedAttachment_Returns_AttachmentInfoWhoseInfoSameAsUploadedOne()
        {
            var attachmentService = _testServer.Services.GetService <IAttachmentService>();
            var attachment        = await attachmentService.LoadSampleAttachmentAsync();

            var uploadModel = new RawUploadRequestViewModel();

            uploadModel.Profile       = new RawProfileViewModel();
            uploadModel.Profile.Photo = attachment;

            var httpClient          = _testServer.CreateClient();
            var httpResponseMessage = await httpClient
                                      .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

            var uploadResult = await httpResponseMessage
                               .Content.ReadAsAsync <UploadResponseViewModel>();

            Assert.NotNull(uploadResult);
            Assert.AreEqual(uploadModel.Profile.Photo.FileName, uploadResult.Profile.Photo.FileName);
            Assert.AreEqual(uploadModel.Profile.Photo.ContentLength, uploadResult.Profile.Photo.ContentLength);
            Assert.AreEqual(uploadModel.Profile.Photo.ContentType, uploadResult.Profile.Photo.ContentType);
        }
        public virtual async Task UploadEmptyGuidString_Returns_ModelWithEmptyGuid()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var httpClient  = lifeTimeScope.Resolve <HttpClient>();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.Id = "";

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

                var httpResponse = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(httpResponse);
                Assert.AreEqual(Guid.Empty.ToString("D"), httpResponse.Id.ToString("D"));
            }
        }
        public virtual async Task NotIncludeIdsInIds_Returns_ModelWithNullIds()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var httpClient  = lifeTimeScope.Resolve <HttpClient>();
                var uploadModel = new RawUploadRequestViewModel();

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

                var httpResponse = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(httpResponse);
                Assert.Null(httpResponse.Ids);
            }
        }
        public virtual async Task UploadEmptyAttachmentIdIntoNullableGuidField_Returns_ModelWithNullAttachmentId()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var httpClient  = lifeTimeScope.Resolve <HttpClient>();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.AttachmentId = "";

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

                var httpResponse = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(httpResponse);
                Assert.Null(httpResponse.AttachmentId);
            }
        }
예제 #17
0
        public virtual async Task NotIncludeAttachmentIdIntoNullableGuidField_Returns_ModelWithValidGuid()
        {
            using (var lifeTimeScope = _testServer.Services.CreateScope())
            {
                var httpClient  = _testServer.CreateClient();
                var uploadModel = new RawUploadRequestViewModel();

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

                var httpResponse = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(httpResponse);
                Assert.Null(httpResponse.AttachmentId);
            }
        }
예제 #18
0
        public virtual async Task LeaveIdFieldBlank_Returns_ModelWithEmptyGuid()
        {
            using (var lifeTimeScope = _testServer.Services.CreateScope())
            {
                var httpClient  = _testServer.CreateClient();
                var uploadModel = new RawUploadRequestViewModel();

                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

                var httpResponse = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(httpResponse);
                Assert.AreEqual(Guid.Empty.ToString("D"), httpResponse.Id.ToString("D"));
            }
        }
예제 #19
0
        public virtual async Task UploadValidGuidIdIntoNullableGuidField_Returns_ModelWithValidGuid()
        {
            using (var lifeTimeScope = _container.BeginLifetimeScope())
            {
                var httpClient  = lifeTimeScope.Resolve <HttpClient>();
                var uploadModel = new RawUploadRequestViewModel();
                uploadModel.Profile            = new RawProfileViewModel();
                uploadModel.Profile.NullableId = Guid.NewGuid().ToString("D");
                var httpResponseMessage = await httpClient
                                          .PostAsync(new Uri("api/upload", UriKind.Relative), uploadModel.ToMultipartFormDataContent());

                var httpResponse = await httpResponseMessage.Content
                                   .ReadAsAsync <UploadResponseViewModel>();

                Assert.NotNull(httpResponse?.Profile?.NullableId);
                Assert.AreEqual(uploadModel.Profile.NullableId,
                                httpResponse.Profile.NullableId.Value.ToString("D"));
            }
        }