2012-06-19 13 views
8

मेरे पास एक एसिंक विधि है जो मैं उलटी गिनती का उपयोग कर एक सिंक विधि में परिवर्तित कर रहा हूं। मैं मॉकिटो के टाइमआउट फ़ंक्शन का उपयोग किये बिना यूनिट टेस्ट लिखने के लिए संघर्ष कर रहा हूं। मैं बाहर काम नहीं कर सकते कि यह सत्यापित विधि async विधि कॉल के लिए प्रतीक्षा करने के लिए:जावा एसिंक के साथ मॉकिटो-> सिंक कनवर्टर

public interface SyncExchangeService { 
    boolean placeOrder(Order order); 
} 
public interface ExchangeService { 
    void placeOrder(Order order, OrderCallback orderResponseCallback); 
} 

public interface OrderCallback { 
    public void onSuccess(); 
    public void onFailure(); 
} 



public class SyncExchangeServiceAdapter implements SyncExchangeService { 
    private ExchangeService exchangeService; 

    public SyncExchangeServiceAdapter(ExchangeService exchangeService) { 
     this.exchangeService = exchangeService; 
    } 

    @Override 
    public boolean placeOrder(Order order) { 

     final CountDownLatch countdownLatch=new CountDownLatch(1); 
     final AtomicBoolean result=new AtomicBoolean(); 
     exchangeService.placeOrder(order, new OrderCallback() { 

      @Override 
      public void onSuccess() { 
       result.set(true); 
       countdownLatch.countDown(); 
      } 

      @Override 
      public void onFailure(String rejectReason) { 
       result.set(false); 
       countdownLatch.countDown(); 
      } 
     }); 
     try { 
      countdownLatch.await(); 
     } catch (InterruptedException e) { 
      throw new RuntimeException(e); 
     } 
     return result.get(); 
    } 
} 


public class SyncExchangeServiceAdapterTest { 
    private ExchangeService mockExchange=mock(ExchangeService.class); 
    private SyncExchangeServiceAdapter adapter=new SyncExchangeServiceAdapter(mockExchange); 
    private Boolean response; 
    private ArgumentCaptor<Boolean> callback=CaptorArgumentCaptor.forClass(OrderCallback.class); 
    private CountDownLatch latch=new CountDownLatch(1); 


    @Test 
    public void testPlaceOrderWithSuccess() throws Exception { 
     final Order order=mock(Order.class); 
     Executors.newSingleThreadExecutor().submit(new Runnable() { 
      @Override 
      public void run() { 
       response=adapter.placeOrder(order); 
       latch.countDown(); 
      } 
     }); 
      verify(mockExchange,timeout(10)).placeOrder(eq(order), callbackCaptor.capture()); 
//the timeout method is not really recommended and could also fail randomly if the thread takes more than 10ms 


     callbackCaptor.getValue().onSuccess(); 
     latch.await(1000,TimeUnit.MILLISECONDS); 
      assertEquals(true,response); 
    } 


} 

उत्तर

2

में कहा जाता है है मुझे awaitility नामक छोटी पुस्तकालय का उपयोग करना पसंद है। आप इसे अपने आप को उलटी गिनती के साथ कर सकते हैं, लेकिन जैसा कि आपने देखा है कि आपको उस काम को करने के लिए माचेट के साथ अपना परीक्षण हैक करना है।

इस परीक्षण में आपको लच का इंतजार करने के बाद सत्यापित करना चाहिए।

आपके कोड में एक और समस्या private Boolean response है। चूंकि आप इसे किसी अन्य थ्रेड में बदल रहे हैं, तो आपको इसे AtomicBoolean बनाना चाहिए या कम से कम इसे volatile घोषित करना चाहिए।

+1

+1 बनाने में सहायक हो सकता है। मैंने कभी इसके बारे में नहीं सुना था, लेकिन यह काफी उपयोगी दिखता है। – jhericks

-1

मुझे यकीन है कि मैं तुम्हें सही ढंग से समझ नहीं हूँ। यदि आप परीक्षण करना चाहते हैं कि एक थ्रेड अनिश्चित काल तक इंतजार कर रहा है जब तक कि अन्य थ्रेड कुछ नहीं करता तब मैं कहूंगा कि आप इसे नहीं कर सकते हैं। क्योंकि इसका मतलब है कि आप पूछ रहे हैं कि कार्यक्रम समाप्त हो गया है या नहीं। इसके बजाय आप दो चीजें कर सकते हैं।

  1. नियमित समवर्ती परीक्षण करें (परिभाषा के अनुसार यह यादृच्छिक है और आपको निश्चित नहीं है कि कोड सही है)। आप दो धागे के साथ जटिल परीक्षण बनाते हैं जो ताले का उपयोग करता है और सेवा को अनुकरण करता है और yeld() विधि का उपयोग करता है। गंभीर वर्गों में आप परीक्षण कर सकते हैं कि कोई गलत ऑर्डर नहीं है। बेशक आप यह कई बार चलाने के लिए तो यह आप एक से अधिक 10ms
  2. ले जाएगा लगता है कि CountDownLatch सही ढंग से काम करता है, यह नकली और जाँच परीक्षणों के इन प्रकार के लिए यदि अपने कार्यों सही क्रम
+0

मुझे पूरा यकीन नहीं है कि आप क्या प्राप्त कर रहे हैं..मैं ऊपर की कक्षा का परीक्षण करने का एक निर्धारिक तरीका ढूंढ रहा हूं। यानी यह हमेशा एक ही परिणाम देगा चाहे आप इसे एक या दस लाख बार चलाते हों। फिलहाल दौड़ की स्थिति है इसलिए यह असफल हो सकता है। –

+0

कक्षा के पुनर्गठन के बिना आप CountDownLatch को नकल नहीं कर सकते क्योंकि इसे निर्भरता के रूप में पारित नहीं किया जा रहा है। –

+0

जो मेरा मुद्दा है। आप बस बहु-थ्रेडेड कोड का निर्धारण करने के लिए एक निर्धारक तरीके से परीक्षण नहीं कर सकते: 'यह सही है'। यदि आप एक थ्रेड किसी अन्य [http://en.wikipedia.org/wiki/Halting_problem] तक प्रतीक्षा करते हैं तो आप परीक्षण नहीं कर सकते। और निश्चित रूप से आप countDownLatch का नकल कर सकते हैं, पावरमॉक और व्हाइटबॉक्स – piotrek

 संबंधित मुद्दे

  • कोई संबंधित समस्या नहीं^_^