[webview_flutter]Add the loadRequest method

packages/webview_flutter/webview_flutter/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.1.0
+
+* Add postUrl to use POST request and accept POST data.
+
 ## 2.0.10
 
 * Fix keyboard issues link in the README.

packages/webview_flutter/webview_flutter/android/build.gradle

@@ -37,5 +37,6 @@ android {
         implementation 'androidx.annotation:annotation:1.0.0'
         implementation 'androidx.webkit:webkit:1.0.0'
         testImplementation 'junit:junit:4.12'
+        testImplementation 'org.mockito:mockito-core:3.10.0'
     }
 }

packages/webview_flutter/webview_flutter/android/src/main/java/io/flutter/plugins/webviewflutter/FlutterWebView.java

@@ -17,6 +17,7 @@
 import android.webkit.WebView;
 import android.webkit.WebViewClient;
 import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
 import io.flutter.plugin.common.BinaryMessenger;
 import io.flutter.plugin.common.MethodCall;
 import io.flutter.plugin.common.MethodChannel;
@@ -79,6 +80,14 @@ public void onProgressChanged(WebView view, int progress) {
     }
   }
 
+  @VisibleForTesting
+  FlutterWebView(WebView webView, MethodChannel methodChannel, Handler platformThreadHandler) {
+    this.webView = webView;
+    this.methodChannel = methodChannel;
+    flutterWebViewClient = new FlutterWebViewClient(methodChannel);
+    this.platformThreadHandler = platformThreadHandler;
+  }
+
   @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
   @SuppressWarnings("unchecked")
   FlutterWebView(
@@ -193,6 +202,9 @@ public void onMethodCall(MethodCall methodCall, Result result) {
       case "loadUrl":
         loadUrl(methodCall, result);
         break;
+      case "postUrl":
+        postUrl(methodCall, result);
+        break;
       case "updateSettings":
         updateSettings(methodCall, result);
         break;
@@ -258,6 +270,14 @@ private void loadUrl(MethodCall methodCall, Result result) {
     result.success(null);
   }
 
+  public void postUrl(MethodCall methodCall, Result result) {
+    Map<String, Object> request = (Map<String, Object>) methodCall.arguments;
+    String url = (String) request.get("url");
+    byte[] postData = (byte[]) request.get("postData");
+    webView.postUrl(url, postData);
+    result.success(null);
+  }
+
   private void canGoBack(Result result) {
     result.success(webView.canGoBack());
   }

packages/webview_flutter/webview_flutter/android/src/test/java/io/flutter/plugins/webviewflutter/WebViewTest.java

@@ -5,11 +5,83 @@
 package io.flutter.plugins.webviewflutter;
 
 import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.doNothing;
 
+import android.os.Handler;
+import android.webkit.WebView;
 import android.webkit.WebViewClient;
+import io.flutter.plugin.common.MethodCall;
+import io.flutter.plugin.common.MethodChannel;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Before;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.internal.matchers.Null;
 
 public class WebViewTest {
+  private static final String POST_URL = "postUrl";
+  private static final String URL = "www.example.com";
+  byte[] postData;
+
+  @Mock WebView mockWebView;
+  @Mock MethodChannel mockChannel;
+  @Mock Handler mockHandler;
+  @Mock MethodChannel.Result mockResult;
+
+  FlutterWebView flutterWebView;
+
+  @Before
+  public void setUp() {
+    MockitoAnnotations.openMocks(this);
+    postData = new byte[5];
+  }
+
+  @Test
+  public void testPostUrl_should_call_webView_postUrl_with_correct_url() {
+    MethodCall call = buildMethodCall(POST_URL, URL, postData);
+    flutterWebView = new FlutterWebView(mockWebView, mockChannel, mockHandler);
+
+    ArgumentCaptor<String> valueCapture = ArgumentCaptor.forClass(String.class);
+
+    doNothing().when(mockWebView).postUrl(valueCapture.capture(), isA(byte[].class));
+
+    flutterWebView.postUrl(call, mockResult);
+
+    assertEquals(URL, valueCapture.getValue());
+  }
+
+  @Test
+  public void testPostUrl_should_call_webView_postUrl_with_correct_http_body() {
+    MethodCall call = buildMethodCall(POST_URL, URL, postData);
+    flutterWebView = new FlutterWebView(mockWebView, mockChannel, mockHandler);
+
+    ArgumentCaptor<byte[]> valueCapture = ArgumentCaptor.forClass(byte[].class);
+
+    doNothing().when(mockWebView).postUrl(isA(String.class), valueCapture.capture());
+
+    flutterWebView.postUrl(call, mockResult);
+
+    assertEquals(postData, valueCapture.getValue());
+  }
+
+  @Test
+  public void testPostUrl_should_call_result_success_with_null() {
+    MethodCall call = buildMethodCall(POST_URL, URL, postData);
+    flutterWebView = new FlutterWebView(mockWebView, mockChannel, mockHandler);
+
+    ArgumentCaptor<Null> valueCapture = ArgumentCaptor.forClass(Null.class);
+
+    doNothing().when(mockResult).success(valueCapture.capture());
+
+    flutterWebView.postUrl(call, mockResult);
+
+    assertEquals(null, valueCapture.getValue());
+  }
+
   @Test
   public void errorCodes() {
     assertEquals(
@@ -46,4 +118,12 @@ public void errorCodes() {
         FlutterWebViewClient.errorCodeToString(WebViewClient.ERROR_UNSUPPORTED_SCHEME),
         "unsupportedScheme");
   }
+
+  private MethodCall buildMethodCall(String method, final String url, final byte[] postData) {
+    final Map<String, Object> arguments = new HashMap<>();
+    arguments.put("url", url);
+    arguments.put("postData", postData);
+
+    return new MethodCall(method, arguments);
+  }
 }

packages/webview_flutter/webview_flutter/example/ios/RunnerTests/FLTWebViewTests.m

@@ -11,17 +11,219 @@
 
 static bool feq(CGFloat a, CGFloat b) { return fabs(b - a) < FLT_EPSILON; }
 
+@interface FLTWebViewController (Test)
+- (bool)postUrl:(NSString *)url withBody:(FlutterStandardTypedData *)postData;
+- (void)onPostUrl:(FlutterMethodCall *)call result:(FlutterResult)result;
+- (bool)postRequest:(NSDictionary<NSString *, id> *)request;
+@end
+
+@interface MockFLTWebViewControllerForOnPostUrl : FLTWebViewController
+- (instancetype)initWithPostRequest:(BOOL)postRequestResult;
+@end
+
+@implementation MockFLTWebViewControllerForOnPostUrl {
+  bool _postRequestResult;
+}
+
+- (instancetype)initWithPostRequest:(bool)postRequestResult {
+  _postRequestResult = postRequestResult;
+  return self;
+}
+
+- (bool)postRequest:(NSDictionary<NSString *, id> *)request {
+  return _postRequestResult;
+}
+
+@end
+
+@interface MockFLTWebViewControllerForPostRequest : FLTWebViewController
+- (instancetype)initWithPostUrl:(BOOL)postUrlResult;
+@end
+
+@implementation MockFLTWebViewControllerForPostRequest {
+  bool _postUrlResult;
+}
+
+- (instancetype)initWithPostUrl:(bool)postUrlResult {
+  _postUrlResult = postUrlResult;
+  return self;
+}
+
+- (bool)postUrl:(NSString *)url withBody:(FlutterStandardTypedData *)postData {
+  return _postUrlResult;
+}
+
+@end
+
+@interface MockWKWebViewForPostUrl : FLTWKWebView
+@property(nonatomic, nullable) NSMutableURLRequest *receivedResult;
+@end
+
+@implementation MockWKWebViewForPostUrl
+
+- (WKNavigation *)loadRequest:(NSMutableURLRequest *)request {
+  _receivedResult = request;
+  return nil;
+}
+
+@end
+
 @interface FLTWebViewTests : XCTestCase
 
 @property(strong, nonatomic) NSObject<FlutterBinaryMessenger> *mockBinaryMessenger;
 
+@property(readonly, nonatomic) MockWKWebViewForPostUrl *resultObject;
+
 @end
 
 @implementation FLTWebViewTests
 
 - (void)setUp {
   [super setUp];
   self.mockBinaryMessenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
+  _resultObject = [MockWKWebViewForPostUrl new];
+}
+
+- (void)testPostUrl_should_return_false_when_url_is_nil {
+  // Initialise data
+  NSString *url = nil;
+  NSString *str = [NSString stringWithFormat:@"name=%@&pass=%@", @"john", @"123"];
+  NSData *data = [str dataUsingEncoding:NSUTF8StringEncoding];
+  FlutterStandardTypedData *postData = [FlutterStandardTypedData typedDataWithBytes:data];
+
+  FLTWebViewController *controller = [[FLTWebViewController alloc] initWithWebView:_resultObject];
+
+  // Run test
+  bool result = [controller postUrl:url withBody:postData];
+
+  XCTAssertFalse(result);
+}
+
+- (void)testPostUrl_should_return_true_when_url_is_not_nil {
+  // Initialise data
+  NSString *url = @"http://example.com";
+  NSString *str = [NSString stringWithFormat:@"name=%@&pass=%@", @"john", @"123"];
+  NSData *data = [str dataUsingEncoding:NSUTF8StringEncoding];
+  FlutterStandardTypedData *postData = [FlutterStandardTypedData typedDataWithBytes:data];
+
+  FLTWebViewController *controller = [[FLTWebViewController alloc] initWithWebView:_resultObject];
+
+  // Run test
+  bool result = [controller postUrl:url withBody:postData];
+  NSString *decodedHTTPBody = [[NSString alloc] initWithData:_resultObject.receivedResult.HTTPBody
+                                                    encoding:NSUTF8StringEncoding];
+
+  XCTAssertTrue(result);
+  XCTAssertTrue([decodedHTTPBody isEqualToString:str]);
+  XCTAssertTrue([_resultObject.receivedResult.HTTPMethod isEqualToString:@"POST"]);
+  XCTAssertTrue([_resultObject.receivedResult.URL.absoluteString isEqualToString:url]);
+}
+
+- (void)testOnPostUrl_should_call_result_flutter_error_when_postRequest_return_false {
+  MockFLTWebViewControllerForOnPostUrl *mockController =
+      [[MockFLTWebViewControllerForOnPostUrl alloc] initWithPostRequest:false];
+
+  __block FlutterError *result = nil;
+
+  [mockController onPostUrl:nil
+                     result:^(id _Nullable r) {
+                       result = r;
+                     }];
+
+  XCTAssertEqualObjects(result.code, @"postUrl_failed");
+}
+
+- (void)testOnPostUrl_should_call_result_nil_when_postRequest_return_true {
+  MockFLTWebViewControllerForOnPostUrl *mockController =
+      [[MockFLTWebViewControllerForOnPostUrl alloc] initWithPostRequest:true];
+
+  __block id result = @"test";
+
+  [mockController onPostUrl:nil
+                     result:^(id _Nullable r) {
+                       result = r;
+                     }];
+
+  XCTAssertEqual(result, nil);
+}
+
+- (void)testPostRequest_should_return_false_when_request_is_nil {
+  FLTWebViewController *controller = [[FLTWebViewController alloc] initWithWebView:_resultObject];
+
+  bool result = [controller postRequest:nil];
+
+  XCTAssertFalse(result);
+}
+
+- (void)testPostRequest_should_return_false_when_postUrl_return_false {
+  NSString *url = @"http://example.com";
+  NSString *str = [NSString stringWithFormat:@"name=%@&pass=%@", @"john", @"123"];
+  NSData *data = [str dataUsingEncoding:NSUTF8StringEncoding];
+  FlutterStandardTypedData *postData = [FlutterStandardTypedData typedDataWithBytes:data];
+
+  FlutterMethodCall *call =
+      [FlutterMethodCall methodCallWithMethodName:@"postUrl"
+                                        arguments:@{@"url" : url, @"postData" : postData}];
+
+  MockFLTWebViewControllerForPostRequest *mockController =
+      [[MockFLTWebViewControllerForPostRequest alloc] initWithPostUrl:false];
+
+  bool result = [mockController postRequest:[call arguments]];
+
+  XCTAssertFalse(result);
+}
+
+- (void)testPostRequest_should_return_true_when_postUrl_return_true {
+  NSString *url = @"http://example.com";
+  NSString *str = [NSString stringWithFormat:@"name=%@&pass=%@", @"john", @"123"];
+  NSData *data = [str dataUsingEncoding:NSUTF8StringEncoding];
+  FlutterStandardTypedData *postData = [FlutterStandardTypedData typedDataWithBytes:data];
+
+  FlutterMethodCall *call =
+      [FlutterMethodCall methodCallWithMethodName:@"postUrl"
+                                        arguments:@{@"url" : url, @"postData" : postData}];
+
+  MockFLTWebViewControllerForPostRequest *mockController =
+      [[MockFLTWebViewControllerForPostRequest alloc] initWithPostUrl:true];
+
+  bool result = [mockController postRequest:[call arguments]];
+
+  XCTAssertTrue(result);
+}
+
+- (void)testPostRequest_should_return_false_when_url_is_not_NSString {
+  NSError *url = [NSError new];
+  NSString *str = [NSString stringWithFormat:@"name=%@&pass=%@", @"john", @"123"];
+  NSData *data = [str dataUsingEncoding:NSUTF8StringEncoding];
+  FlutterStandardTypedData *postData = [FlutterStandardTypedData typedDataWithBytes:data];
+
+  FlutterMethodCall *call =
+      [FlutterMethodCall methodCallWithMethodName:@"postUrl"
+                                        arguments:@{@"url" : url, @"postData" : postData}];
+
+  MockFLTWebViewControllerForPostRequest *mockController =
+      [[MockFLTWebViewControllerForPostRequest alloc] initWithPostUrl:true];
+
+  bool result = [mockController postRequest:[call arguments]];
+
+  XCTAssertFalse(result);
+}
+
+- (void)testPostRequest_should_return_false_when_postData_is_not_FlutterStandardTypedData {
+  NSString *url = @"http://example.com";
+  NSString *str = [NSString stringWithFormat:@"name=%@&pass=%@", @"john", @"123"];
+  NSData *postData = [str dataUsingEncoding:NSUTF8StringEncoding];
+
+  FlutterMethodCall *call =
+      [FlutterMethodCall methodCallWithMethodName:@"postUrl"
+                                        arguments:@{@"url" : url, @"postData" : postData}];
+
+  MockFLTWebViewControllerForPostRequest *mockController =
+      [[MockFLTWebViewControllerForPostRequest alloc] initWithPostUrl:true];
+
+  bool result = [mockController postRequest:[call arguments]];
+
+  XCTAssertFalse(result);
 }
 
 - (void)testCanInitFLTWebViewController {