public async Task UploadImageBinaryRequest_AreEqual() { var client = new ImgurClient("123", "1234"); var requestBuilder = new ImageRequestBuilder(); var url = $"{client.EndpointUrl}image"; var image = File.ReadAllBytes("banana.gif"); var request = requestBuilder.UploadImageBinaryRequest(url, image, "TheAlbum", "TheTitle", "TheDescription"); Assert.IsNotNull(request); Assert.AreEqual("https://api.imgur.com/3/image", request.RequestUri.ToString()); Assert.AreEqual(HttpMethod.Post, request.Method); var content = (MultipartFormDataContent)request.Content; var imageContent = (ByteArrayContent)content.FirstOrDefault(x => x.Headers.ContentDisposition.Name == "image"); var album = (StringContent)content.FirstOrDefault(x => x.Headers.ContentDisposition.Name == "album"); var type = (StringContent)content.FirstOrDefault(x => x.Headers.ContentDisposition.Name == "type"); var title = (StringContent)content.FirstOrDefault(x => x.Headers.ContentDisposition.Name == "title"); var description = (StringContent)content.FirstOrDefault(x => x.Headers.ContentDisposition.Name == "description"); Assert.IsNotNull(imageContent); Assert.IsNotNull(type); Assert.IsNotNull(album); Assert.IsNotNull(title); Assert.IsNotNull(description); Assert.AreEqual(image.Length, imageContent.Headers.ContentLength); Assert.AreEqual("file", await type.ReadAsStringAsync()); Assert.AreEqual("TheAlbum", await album.ReadAsStringAsync()); Assert.AreEqual("TheTitle", await title.ReadAsStringAsync()); Assert.AreEqual("TheDescription", await description.ReadAsStringAsync()); }
private async Task <IImage> UploadVideoInternalAsync(Stream image, string album = null, string name = null, string title = null, string description = null, IProgress <int> progress = null, int?bufferSize = 4096, CancellationToken cancellationToken = default) { const string url = "upload"; using (var request = ImageRequestBuilder.UploadVideoStreamRequest(url, image, album, name, title, description, progress, bufferSize)) { var response = await SendRequestAsync <Image>(request, cancellationToken).ConfigureAwait(false); return(response); } }
public void TestIsDiskCacheDisabledIfRequested7() { ImageRequestBuilder builder = ImageRequestBuilder.NewBuilderWithSource(new Uri("data:image/png;base64")); builder.DisableDiskCache(); Assert.IsFalse(builder.IsDiskCacheEnabled); }
public void TestDownloadHandler() { _imageRequest = ImageRequestBuilder .NewBuilderWithSource(IMAGE_URL) .SetProgressiveRenderingEnabled(true) .Build(); _producerContext = new SettableProducerContext( _imageRequest, $"{ _imageRequest.SourceUri.ToString() }2", _producerListener, new object(), RequestLevel.FULL_FETCH, false, true, Priority.MEDIUM); _networkFetchProducer.ProduceResults(_consumer, _producerContext); // Wait for callback _completion.WaitOne(); Assert.IsTrue(_onNewResultImplCalls > 1); Assert.IsTrue(_intermediateResultProducerEventCalls > 1); }
private async void FetchDecodedImage() { try { Uri uri = MainPage.GenerateImageUri(); ImageRequestBuilder builder = ImageRequestBuilder.NewBuilderWithSource(uri); if (GrayscaleRadioButton.IsChecked.Value) { builder.SetPostprocessor(GrayscalePostprocessor); } else if (InvertRadioButton.IsChecked.Value) { builder.SetPostprocessor(InvertPostprocessor); } ImageRequest request = builder.Build(); WriteableBitmap bitmap = await _imagePipeline.FetchDecodedBitmapImageAsync(request); var image = new Image(); image.Width = image.Height = MainPage.VIEW_DIMENSION; image.Source = bitmap; ImageGrid.Items.Add(image); } catch (Exception) { // Invalid uri, try again FetchDecodedImage(); } }
public void TestExceptionInFetchImage() { _imageRequest = ImageRequestBuilder .NewBuilderWithSource(FAILURE_URL) .SetProgressiveRenderingEnabled(true) .Build(); _producerContext = new SettableProducerContext( _imageRequest, _imageRequest.SourceUri.ToString(), _producerListener, new object(), RequestLevel.FULL_FETCH, false, true, Priority.MEDIUM); _networkFetchProducer.ProduceResults(_consumer, _producerContext); // Wait for callback _completion.WaitOne(); Assert.IsTrue(_onProducerFinishWithFailureFuncCalls == 1); Assert.AreEqual(_internalRequestId, _imageRequest.SourceUri.ToString()); Assert.AreEqual(_internalProducerName, NetworkFetchProducer.PRODUCER_NAME); Assert.IsNotNull(_internalError); Assert.IsNull(_internalExtraMap); }
public void TestIsDiskCacheDisabledIfRequested4() { ImageRequestBuilder builder = ImageRequestBuilder.NewBuilderWithSource(new Uri("ms-appx-web:///request")); builder.DisableDiskCache(); Assert.IsFalse(builder.IsDiskCacheEnabled); }
/// <summary> /// Return the images the user has favorited in the gallery. /// </summary> /// <param name="username">The user account. Default: me</param> /// <param name="page">Set the page number so you don't have to retrieve all the data at once. Default: null.</param> /// <param name="sort">Indicates the order that a list of items are sorted. Default: Newest.</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ImgurException"></exception> /// <exception cref="MashapeException"></exception> /// <exception cref="OverflowException"></exception> /// <returns></returns> public async Task <ICollection <IGalleryAlbumImageBase> > GetAccountGalleryFavoritesAsync(string username = "******", int?page = null, GallerySortOrder?sort = GallerySortOrder.Newest) { if (string.IsNullOrEmpty(username)) { throw new ArgumentNullException(nameof(username)); } if (username.Equals("me", StringComparison.OrdinalIgnoreCase) && ApiClient.OAuth2Token == null) { throw new ArgumentNullException(nameof(ApiClient.OAuth2Token), OAuth2RequiredExceptionMessage); } var sortValue = $"{sort ?? GallerySortOrder.Newest}".ToLower(); var url = $"account/{username}/gallery_favorites/{page}/{sortValue}"; using (var request = ImageRequestBuilder.CreateRequest(HttpMethod.Get, url)) { var favorites = await SendRequestAsync <IGalleryAlbumImageBase[]>(request); return(favorites); } }
public void UploadImageBinaryRequest_WithUrlNull_ThrowsArgumentNullException() { var requestBuilder = new ImageRequestBuilder(); var image = File.ReadAllBytes("banana.gif"); requestBuilder.UploadImageBinaryRequest(null, image); }
public void Initialize() { _request = ImageRequestBuilder.NewBuilderWithSource(new Uri("http://request")).Build(); _callerContext = new object(); _error = new Exception(); _immutableMap = new Dictionary <string, string>(); ProducerListenerImpl producerListener1 = new ProducerListenerImpl( (_, __) => { ++_onProducerStartFuncCalls1; }, (_, __, ___) => { ++_onProducerEventFuncCalls1; }, (_, __, ___) => { ++_onProducerFinishWithSuccessFuncCalls1; }, (_, __, ___, ____) => { ++_onProducerFinishWithFailureFuncCalls1; }, (_, __, ___) => { ++_onProducerFinishWithCancellationFuncCalls1; }, (_) => { ++_requiresExtraMapFuncCalls1; return(false); }); ProducerListenerImpl producerListener2 = new ProducerListenerImpl( (_, __) => { ++_onProducerStartFuncCalls2; }, (_, __, ___) => { ++_onProducerEventFuncCalls2; }, (_, __, ___) => { ++_onProducerFinishWithSuccessFuncCalls2; }, (_, __, ___, ____) => { ++_onProducerFinishWithFailureFuncCalls2; }, (_, __, ___) => { ++_onProducerFinishWithCancellationFuncCalls2; }, (_) => { ++_requiresExtraMapFuncCalls2; return(false); }); ProducerListenerImpl producerListener3 = new ProducerListenerImpl( (_, __) => { ++_onProducerStartFuncCalls3; }, (_, __, ___) => { ++_onProducerEventFuncCalls3; }, (_, __, ___) => { ++_onProducerFinishWithSuccessFuncCalls3; }, (_, __, ___, ____) => { ++_onProducerFinishWithFailureFuncCalls3; }, (_, __, ___) => { ++_onProducerFinishWithCancellationFuncCalls3; }, (_) => { ++_requiresExtraMapFuncCalls3; return(false); }); _requestListener1 = new RequestListenerImpl( producerListener1, (_, __, ___, ____) => { ++_onRequestStartFuncCalls1; }, (_, __, ___) => { ++_onRequestSuccessFuncCall1; }, (_, __, ___, ____) => { ++_onRequestFailureFuncCalls1; }, (_) => { ++_onRequestCancellationFuncCalls1; }); _requestListener2 = new RequestListenerImpl( producerListener2, (_, __, ___, ____) => { ++_onRequestStartFuncCalls2; }, (_, __, ___) => { ++_onRequestSuccessFuncCall2; }, (_, __, ___, ____) => { ++_onRequestFailureFuncCalls2; }, (_) => { ++_onRequestCancellationFuncCalls2; }); _requestListener3 = new RequestListenerImpl( producerListener3, (_, __, ___, ____) => { ++_onRequestStartFuncCalls3; }, (_, __, ___) => { ++_onRequestSuccessFuncCall3; }, (_, __, ___, ____) => { ++_onRequestFailureFuncCalls3; }, (_) => { ++_onRequestCancellationFuncCalls3; }); _listenerManager = new ForwardingRequestListener(new HashSet <IRequestListener> { _requestListener1, _requestListener2, _requestListener3 }); }
public void UploadImageBinaryRequest_WithImageNull_ThrowsArgumentNullException() { var client = new ImgurClient("123", "1234"); var requestBuilder = new ImageRequestBuilder(); var url = $"{client.EndpointUrl}image"; requestBuilder.UploadImageBinaryRequest(url, null); }
public void UploadStreamBinaryRequest_WithUrlNull_ThrowsArgumentNullException() { var requestBuilder = new ImageRequestBuilder(); using (var fs = new FileStream("banana.gif", FileMode.Open)) { requestBuilder.UploadImageStreamRequest(null, fs); } }
/// <summary> /// Returns whether the image is stored in the disk cache. /// Performs disk cache check synchronously. It is not /// recommended to use this unless you know what exactly /// you are doing. Disk cache check is a costly operation, /// the call will block the caller thread until the cache /// check is completed. /// </summary> /// <param name="uri"> /// The uri for the image to be looked up. /// </param> /// <param name="cacheChoice"> /// The cacheChoice for the cache to be looked up. /// </param> /// <returns> /// true if the image was found in the disk cache, /// false otherwise. /// </returns> public bool IsInDiskCacheSync(Uri uri, CacheChoice cacheChoice) { ImageRequest imageRequest = ImageRequestBuilder .NewBuilderWithSource(uri) .SetCacheChoice(cacheChoice) .Build(); return(IsInDiskCacheSync(imageRequest)); }
public void getSize(string uriString, IPromise promise) { if (string.IsNullOrEmpty(uriString)) { promise.Reject(ErrorInvalidUri, "Cannot get the size of an image for an empty URI."); return; } var uri = new Uri(uriString); var imagePipeline = ImagePipelineFactory.Instance.GetImagePipeline(); var request = ImageRequestBuilder.NewBuilderWithSource(uri).Build(); var dataSource = imagePipeline.FetchDecodedImage(request, null); var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <CloseableImage> >( response => { if (!response.IsFinished()) { return(Task.CompletedTask); } CloseableReference <CloseableImage> reference = response.GetResult(); if (reference != null) { try { CloseableImage image = reference.Get(); promise.Resolve(new JObject { { "width", image.Width }, { "height", image.Height }, }); } catch (Exception ex) { promise.Reject(ErrorGetSizeFailure, ex.Message); } finally { CloseableReference <CloseableImage> .CloseSafely(reference); } } else { promise.Reject(ErrorGetSizeFailure, Invariant($"Invalid URI '{uri}' provided.")); } return(Task.CompletedTask); }, response => { promise.Reject(ErrorGetSizeFailure, response.GetFailureCause()); }); dataSource.Subscribe(dataSubscriber, FBCore.Concurrency.CallerThreadExecutor.Instance); }
/// <summary> /// Updates the title or description of an image. /// You can only update an image you own and is associated with your account. /// For an anonymous image, {id} must be the image's deletehash. /// </summary> /// <param name="imageId">The image id.</param> /// <param name="title">The title of the image.</param> /// <param name="description">The description of the image.</param> /// <exception cref="ArgumentNullException"> /// Thrown when a null reference is passed to a method that does not accept it as a /// valid argument. /// </exception> /// <exception cref="ImgurException">Thrown when an error is found in a response from an Imgur endpoint.</exception> /// <exception cref="MashapeException">Thrown when an error is found in a response from a Mashape endpoint.</exception> /// <returns></returns> private async Task <bool> UpdateImageInternalAsync(string imageId, string title = null, string description = null) { var url = $"image/{imageId}"; using (var request = ImageRequestBuilder.UpdateImageRequest(url, title, description)) { var updated = await SendRequestAsync <bool>(request).ConfigureAwait(false); return(updated); } }
public void UploadStreamBinaryRequest_WithImageNull_ThrowsArgumentNullException() { var client = new ImgurClient("123", "1234"); var requestBuilder = new ImageRequestBuilder(); var url = $"{client.EndpointUrl}image"; using (var fs = new FileStream("banana.gif", FileMode.Open)) { requestBuilder.UploadImageStreamRequest(url, null); } }
/// <summary> /// Upload a new image using a URL. /// </summary> /// <param name="upload">The Stream file of the image/video.</param> /// <param name="fileName">Name of the file.</param> /// <param name="fileType">The Filetype (image/video).</param> /// <param name="albumId"> /// The id of the album you want to add the image to. For anonymous albums, {albumId} should be the /// deletehash that is returned at creation. /// </param> /// <param name="name">The name of the file.</param> /// <param name="title">The title of the image.</param> /// <param name="description">The description of the image.</param> /// <exception cref="ArgumentNullException"> /// Thrown when a null reference is passed to a method that does not accept it as a /// valid argument. /// </exception> /// <exception cref="ImgurException">Thrown when an error is found in a response from an Imgur endpoint.</exception> /// <exception cref="MashapeException">Thrown when an error is found in a response from a Mashape endpoint.</exception> /// <returns></returns> private async ValueTask <IImage> UploadFileInternalAsync(Stream upload, string fileName, FileType fileType = FileType.Image, string albumId = null, string name = null, string title = null, string description = null) { const string url = nameof(upload); using (var request = ImageRequestBuilder.UploadFileRequest(url, upload, fileName, fileType, albumId, name, title, description)) { var returnImage = await SendRequestAsync <Image>(request).ConfigureAwait(false); return(returnImage); } }
public void UploadImageUrlRequest_WithUrlNull_ThrowsArgumentNullException() { var exception = Record.Exception(() => ImageRequestBuilder.UploadImageUrlRequest(null, null)); Assert.NotNull(exception); Assert.IsType <ArgumentNullException>(exception); var argNullException = (ArgumentNullException)exception; Assert.Equal("url", argNullException.ParamName); }
/// <summary> /// Upload a new image using a stream. /// </summary> /// <param name="image">A stream.</param> /// <param name="albumId"> /// The id of the album you want to add the image to. For anonymous albums, {albumId} should be the /// deletehash that is returned at creation. /// </param> /// <param name="name">The name of the file.</param> /// <param name="title">The title of the image.</param> /// <param name="description">The description of the image.</param> /// <param name="progressBytes">A provider for progress updates.</param> /// <param name="progressBufferSize">The amount of bytes that should be uploaded while performing a progress upload.</param> /// <exception cref="ArgumentNullException"> /// Thrown when a null reference is passed to a method that does not accept it as a /// valid argument. /// </exception> /// <exception cref="ImgurException">Thrown when an error is found in a response from an Imgur endpoint.</exception> /// <exception cref="MashapeException">Thrown when an error is found in a response from a Mashape endpoint.</exception> /// <returns></returns> private async Task <IImage> UploadImageStreamInternalAsync(Stream image, string albumId = null, string name = null, string title = null, string description = null, IProgress <int> progressBytes = null, int progressBufferSize = 4096) { const string url = nameof(image); using (var request = ImageRequestBuilder.UploadImageStreamRequest(url, image, albumId, name, title, description, progressBytes, progressBufferSize)) { var returnImage = await SendRequestAsync <Image>(request).ConfigureAwait(false); return(returnImage); } }
/// <summary> /// Upload a new image using a URL. /// </summary> /// <param name="image">The URL for the image.</param> /// <param name="albumId"> /// The id of the album you want to add the image to. For anonymous albums, {albumId} should be the /// deletehash that is returned at creation. /// </param> /// <param name="name">The name of the file.</param> /// <param name="title">The title of the image.</param> /// <param name="description">The description of the image.</param> /// <exception cref="ArgumentNullException"> /// Thrown when a null reference is passed to a method that does not accept it as a /// valid argument. /// </exception> /// <exception cref="ImgurException">Thrown when an error is found in a response from an Imgur endpoint.</exception> /// <exception cref="MashapeException">Thrown when an error is found in a response from a Mashape endpoint.</exception> /// <returns></returns> private async Task <IImage> UploadImageUrlInternalAsync(string image, string albumId = null, string name = null, string title = null, string description = null) { const string url = nameof(image); using (var request = ImageRequestBuilder.UploadImageUrlRequest(url, image, albumId, name, title, description)) { var returnImage = await SendRequestAsync <Image>(request).ConfigureAwait(false); return(returnImage); } }
public void UploadVideoStreamRequest_WithUrlNull_ThrowsArgumentNullException() { using var ms = new MemoryStream(new byte[9]); var exception = Record.Exception(() => ImageRequestBuilder.UploadVideoStreamRequest(null, ms)); Assert.NotNull(exception); Assert.IsType <ArgumentNullException>(exception); var argNullException = (ArgumentNullException)exception; Assert.Equal("url", argNullException.ParamName); }
public void UpdateImageRequest_WithUrlNull_ThrowsArgumentNullException() { var requestBuilder = new ImageRequestBuilder(); var exception = Record.Exception(() => ImageRequestBuilder.UpdateImageRequest(null, "1234Xyz9")); Assert.NotNull(exception); Assert.IsType <ArgumentNullException>(exception); var argNullException = (ArgumentNullException)exception; Assert.Equal(argNullException.ParamName, "url"); }
public void UploadImageUrlRequest_WithUrlNull_ThrowsArgumentNullException() { var requestBuilder = new ImageRequestBuilder(); var exception = Record.Exception(() => ImageRequestBuilder.UploadImageBinaryRequest(null, new byte[9])); Assert.NotNull(exception); Assert.IsType <ArgumentNullException>(exception); var argNullException = (ArgumentNullException)exception; Assert.Equal(argNullException.ParamName, "url"); }
public void UploadImageUrlRequest_WithImageNull_ThrowsArgumentNullException() { var apiClient = new ApiClient("123"); var mockUrl = $"{apiClient.BaseAddress}image"; var exception = Record.Exception(() => ImageRequestBuilder.UploadImageUrlRequest(mockUrl, null)); Assert.NotNull(exception); Assert.IsType <ArgumentNullException>(exception); var argNullException = (ArgumentNullException)exception; Assert.Equal("imageUrl", argNullException.ParamName); }
public async Task UpdateImageRequest_Equal() { var apiClient = new ApiClient("123"); var mockUrl = $"{apiClient.BaseAddress}image/1234Xyz9"; var request = ImageRequestBuilder.UpdateImageRequest(mockUrl, "TheTitle", "TheDescription"); Assert.NotNull(request); Assert.Equal("https://api.imgur.com/3/image/1234Xyz9", request.RequestUri.ToString()); Assert.Equal(HttpMethod.Post, request.Method); var expected = await request.Content.ReadAsStringAsync(); Assert.Equal("title=TheTitle&description=TheDescription", expected); }
public void UploadImageBinaryRequest_WithImageNull_ThrowsArgumentNullException() { var client = new ImgurClient("123", "1234"); var requestBuilder = new ImageRequestBuilder(); var mockUrl = $"{client.EndpointUrl}image"; var exception = Record.Exception(() => ImageRequestBuilder.UploadImageBinaryRequest(mockUrl, null)); Assert.NotNull(exception); Assert.IsType <ArgumentNullException>(exception); var argNullException = (ArgumentNullException)exception; Assert.Equal(argNullException.ParamName, "image"); }
public async Task TestFetchLocalJpegExif() { var imageRequest = ImageRequestBuilder .NewBuilderWithSource(LOCAL_JPEG_EXIF_URL) .SetAutoRotateEnabled(true) .Build(); var bitmap = await _imagePipeline.FetchDecodedBitmapImageAsync(imageRequest) .ConfigureAwait(false); await DispatcherHelpers.RunOnDispatcherAsync(() => { Assert.IsTrue(bitmap.PixelWidth != 0); Assert.IsTrue(bitmap.PixelHeight != 0); }); }
/// <summary> /// Returns the users favorited images. OAuth authentication required. /// </summary> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ImgurException"></exception> /// <exception cref="MashapeException"></exception> /// <exception cref="OverflowException"></exception> /// <returns></returns> public async Task <ICollection <IGalleryAlbumImageBase> > GetAccountFavoritesAsync() { if (ApiClient.OAuth2Token == null) { throw new ArgumentNullException(nameof(ApiClient.OAuth2Token), OAuth2RequiredExceptionMessage); } var url = "account/me/favorites"; using (var request = ImageRequestBuilder.CreateRequest(HttpMethod.Get, url)) { var favorites = await SendRequestAsync <IGalleryAlbumImageBase[]>(request); return(favorites); } }
/// <summary> /// Updates the title or description of an image. /// You can only update an image you own and is associated with your account. /// For an anonymous image, {id} must be the image's deletehash. /// </summary> /// <param name="imageId">The image id.</param> /// <param name="title">The title of the image.</param> /// <param name="description">The description of the image.</param> /// <exception cref="ArgumentNullException"> /// Thrown when a null reference is passed to a method that does not accept it as a /// valid argument. /// </exception> /// <exception cref="ImgurException">Thrown when an error is found in a response from an Imgur endpoint.</exception> /// <exception cref="MashapeException">Thrown when an error is found in a response from a Mashape endpoint.</exception> /// <returns></returns> public async Task <bool> UpdateImageAsync(string imageId, string title = null, string description = null) { if (string.IsNullOrWhiteSpace(imageId)) { throw new ArgumentNullException(nameof(imageId)); } var url = $"image/{imageId}"; using (var request = ImageRequestBuilder.UpdateImageRequest(url, title, description)) { var updated = await SendRequestAsync <bool>(request).ConfigureAwait(false); return(updated); } }
public async Task UpdateImageRequest_Equal() { var client = new ImgurClient("123", "1234"); var requestBuilder = new ImageRequestBuilder(); var mockUrl = $"{client.EndpointUrl}image/1234Xyz9"; var request = ImageRequestBuilder.UpdateImageRequest(mockUrl, "TheTitle", "TheDescription"); Assert.NotNull(request); Assert.Equal("https://api.imgur.com/3/image/1234Xyz9", request.RequestUri.ToString()); Assert.Equal(HttpMethod.Post, request.Method); var expected = await request.Content.ReadAsStringAsync().ConfigureAwait(false); Assert.Equal("title=TheTitle&description=TheDescription", expected); }