टेस्ट MultipartFormData प्ले 2.0 FakeRequest

Question

में मैं जो इनपुट के रूप में बहुखण्डीय प्रपत्र डेटा लेता है एक प्ले 2 नियंत्रक के लिए एक समारोह परीक्षण बनाने के लिए कोशिश कर रहा हूँ। मल्टीपार्ट फॉर्म POST का समर्थन करने के लिए वर्तमान में FakeRequest में कोई विधि नहीं है। इस नियंत्रक का परीक्षण करने के अन्य तरीके क्या हैं?

Map<String, Object> map = new HashMap<String, Object>(); 
map.put("param1", "test-1"); 
map.put("param2", "test-2"); 
map.put("file", file) 
Result result = routeAndCall(fakeRequest(POST, "/register").withFormUrlEncodedBody(map));// NO SUCH METHOD 

संपादित करें: इस तरीके को मैं बहुखण्डीय परीक्षण करने के लिए किया था।

HttpClient httpclient = new DefaultHttpClient(); 
    HttpPost httppost = new HttpPost("http://localhost:3333/blobupload"); 

    FileBody imageFile = new FileBody(new File("test/resources/test-1.jpg")); 
    StringBody guid1 = null; 
    StringBody guid2 = null; 
    try { 
     guid1 = new StringBody("GUID-1"); 

    } catch (UnsupportedEncodingException e1) { 
     e1.printStackTrace(); 
    } 

    MultipartEntity reqEntity = new MultipartEntity(); 
    reqEntity.addPart("key1", imageFile); 
    reqEntity.addPart("key2", guid1); 

    httppost.setEntity(reqEntity); 

    HttpResponse response; 
    try { 
     response = httpclient.execute(httppost); 
     HttpEntity resEntity = response.getEntity(); 

     assertThat(response.getStatusLine().getStatusCode()).isEqualTo(200); 
    } catch (ClientProtocolException e) { 
     e.printStackTrace(); 
} catch (IOException e) { 
     e.printStackTrace(); 
} 

Answer 1

आप withFormUrlEncodedBody

@Test 
public void testMyAction() { 
    running(fakeApplication(), new Runnable() { 
     public void run() {     
      Map<String,String> data = new HashMap<String, Object>(); 
      data.put("param1", "test-1"); 
      data.put("param2", "test-2"); 
      data.put("file", file); 

      Result result = callAction(
       controllers.whatever.action(), 
       fakeRequest().withFormUrlEncodedBody(data) 
      ) 
      ... 
     } 
    } 
} 

उपयोग करने के लिए callAction का उपयोग करना चाहिए मैं प्ले फ्रेमवर्क 2 के लिए केवल स्काला एपीआई का उपयोग लेकिन मुझे लगता है आप withFormUrlEncodedBody का उपयोग कर बहुखण्डीय प्रपत्र परीक्षण कर सकते हैं नहीं है।

आप स्काला में इस तरह से कर सकते हैं: मुझे लगता है कि आप जावा के लिए यह अनुवाद कर सकते हैं

import play.api.libs.Files._ 
import play.api.mvc.MultipartFormData._ 

class MyTestSpec extends Specification { 

    "mytest should bla bla bla" in { 
     running(FakeApplication(aditionalConfiguration = inMemoryDatabase())) { 
      val data = new MultipartFormData(Map(
       ("param1" -> Seq("test-1")), 
       ("param2" -> Seq("test-2")) 
      ), List(
       FilePart("payload", "message", Some("Content-Type: multipart/form-data"), play.api.libs.Files.TemporaryFile(new java.io.File("/tmp/pepe.txt"))) 
    ), List(), List()) 

      val Some(result) = routeAndCall(FakeRequest(POST, "/route/action", FakeHeaders(), data)) 
      ... 
     } 
    } 
} 

, मैं कैसे जावा खेद में यह कोड करने के लिए पता नहीं है।

पीडी: माफ करना, मैं अभी भी सीख रहा हूँ मेरी अंग्रेजी के लिए

Answer 2

यह करने के लिए सबसे आसान तरीका है इस प्रकार है स्काला उपयोग करने के लिए है:

val formData = Map(
    "param-1" -> Seq("value-1"), 
    "param-2" -> Seq("value-2") 
) 
val result = routeAndCall(FakeRequest(POST, "/register").copy(body=formData)) 

यह मानते हुए है अपने नियंत्रक विधि फार्म की है:

def register = Action(parse.tolerantFormUrlEncoded) { ... } 

तुम सच में जावा का उपयोग करना चाहिए, तो आप नाम वाले पैरामीटर के लिए पहुँच नहीं है, इसलिए 'प्रतिलिपि' विधि से ऊपर पूर्ण रूप से कहा जा करने के लिए होगा। इसके अलावा, स्केला play.api.test.FakeRequest वस्तु आयात करने के लिए सावधान रहना होगा के रूप में जावा FakeRequest प्रॉक्सी एक प्रति विधि नहीं है।

Answer 3

यहाँ एक अनुरोध के लिए बहुखण्डीय/फार्म-डेटा सामग्री बनाने के लिए जावा में callAction() के साथ एक समाधान है। यह कम से कम Play 2.2.3 में काम करता है। मेरी सामग्री-प्रकार एप्लिकेशन/ज़िप था। आप इसे बदलना चाहेंगे।

@Test 
public void callImport() throws Exception { 
    File file = new File("test/yourfile.zip"); 
    FilePart<TemporaryFile> part = new MultipartFormData.FilePart<>(
      "file", "test/yourfile.zip", 
      Scala.Option("application/zip"), new TemporaryFile(file)); 
    List<FilePart<TemporaryFile>> fileParts = new ArrayList<>(); 
    fileParts.add(part); 
    scala.collection.immutable.List<FilePart<TemporaryFile>> files = scala.collection.JavaConversions 
      .asScalaBuffer(fileParts).toList(); 
    MultipartFormData<TemporaryFile> formData = new MultipartFormData<TemporaryFile>(
      null, files, null, null); 
    AnyContent anyContent = new AnyContentAsMultipartFormData(formData); 

    Result result = callAction(
      controllers.routes.ref.ImportExport.import(), 
      fakeRequest().withAnyContent(anyContent, 
        "multipart/form-data", "POST")); 

    // Your Tests 
    assertThat(status(result)).isEqualTo(OK); 
} 

Answer 4

Map<String, Object> data = new HashMap<String, Object>(); 
map.put("param1", "test-1"); 
map.put("param2", "test-2"); 

    final Http.RequestBuilder request = Helpers.fakeRequest() 
       .method(POST) 
       .bodyForm(formData) 
       .uri("/register"); 

     final Result result = route(app, request);