DBUnit प्रत्येक विधि के बाद डेटाबेस को साफ और सम्मिलित नहीं करता है, इसलिए परीक्षण स्वतंत्र नहीं हैं

Question

मेरे पास डीएओ कक्षा के लिए एक परीक्षण है, मैं डेटाबेस बनाने और पॉप्युलेट करने के लिए डीबीयूनीट का उपयोग करता हूं (इन-मेमोरी डर्बी का उपयोग करके)। दाओ अद्यतन विधि का परीक्षण करते समय मुझे समस्याएं आ रही हैं क्योंकि यह डेटा संशोधित करती है और फिर अन्य परीक्षण विफल हो जाता है। जैसा कि हम सभी जानते हैं कि एक परीक्षण किसी अन्य से स्वतंत्र होना चाहिए, और मुझे पता है कि डीबीयूनीट में प्रत्येक परीक्षण के बाद डेटाबेस को साफ और पुन: उत्पन्न करने के लिए कुछ सुविधाएं हैं। लेकिन यह काम नहीं करता है!

कोड इस (TestNG) है:

@Test(enabled=false) // Deja la BBDD en estado erroneo!!! 
public void busco_y_actualizo() throws Exception { 
    PacoUser resultado = userdao.getById(1L); 
    resultado.setName("OTRO"); 
    userdao.update(resultado); 
   PacoUser resultado2 = userdao.getById(1L); 
   AssertJUnit.assertNotNull(resultado2); 
    AssertJUnit.assertEquals("OTRO", resultado2.getName());    
} 

Answer 1

सुनिश्चित करें कि डेटाबेस हर एक परीक्षण का मामला पहले रीसेट है:

@BeforeMethod 
public void prepareData() throws Exception { 
    cleanAndPopulate("users"); 
} 

public void cleanAndPopulate (String nameXML) throws Exception { 
    IDatabaseConnection conn; 
    conn = new DatabaseConnection (sessionForTesting.connection());   
    InputStream is = DBconnection.class.getClassLoader() 
    .getResourceAsStream(nameXML + ".xml");  
    dataset = new FlatXmlDataSet(is); 
    System.out.println("*** Preparando base de datos de test"); 
    DatabaseOperation.CLEAN_INSERT.execute(conn, dataset); 
} 

यह परीक्षण (जमानत प्रभाव से बचने के विकलांग) है परीक्षा स्वतंत्रता सुनिश्चित करने के लिए। @BeforeMethod केवल सभी परीक्षण मामलों को चलाने से पहले ही बुलाया जाता है, इसलिए cleanAndPopulate डालने के लिए यहां पर्याप्त नहीं है।

Answer 2

@After 
public void after() throws SQLException { 
    Session session = hibernateSessionFactory.openSession(); 
    try { 
     Work work = new Work() { 

      @Override 
      public void execute(Connection connection) throws SQLException { 
       IDatabaseConnection dbConn = null; 
       try { 
        dbConn = getConnection(connection); 
       } catch (DatabaseUnitException e) { 
        logger.error("Exception in before", e); 
        Assert.fail(e.getMessage()); 
       } 

       try { 
        List<String> resultList = (List<String>) hibernateTemplate 
          .execute(new HibernateCallback() { 
           String sql = "SELECT st.TABLE_NAME FROM INFORMATION_SCHEMA.SYSTEM_TABLES st where st. TABLE_TYPE='TABLE'"; 

           public List<String> doInHibernate(
             Session session) 
             throws HibernateException, 
             SQLException { 
            Query query = session 
              .createSQLQuery(sql); 
            List<String> list = query.list(); 
            return list; 
           } 
          }); 

        QueryDataSet partialDataSet = new QueryDataSet(dbConn); 
        for (String tableName : resultList) { 
         partialDataSet.addTable(tableName); 
        } 

        DatabaseOperation.DELETE_ALL.execute(dbConn, 
          partialDataSet); 

       } catch (Exception e) { 
        logger.error("Exception in after", e); 
        Assert.fail(e.getMessage()); 
       } finally { 
        dbConn.close(); 
       } 

      } 

     }; 
     session.doWork(work); 

    } catch (Exception e) { 
     logger.error("Exception in after", e); 
     Assert.fail(e.getMessage()); 
    } finally { 
     session.close(); 
    } 
} 

protected DatabaseConnection getConnection(Connection connection) 
     throws DatabaseUnitException, SQLException { 
    return new DatabaseConnection(connection, SCHEMA); 
} 

Answer 3

ऐसा इसलिए है क्योंकि परीक्षण के बाद CLEAN_INSERT परीक्षण से पहले "साफ" करता है।

उदाहरण के लिए, यदि दो परीक्षण, test1 और test2 हैं। test1 और test2 क्रमशः test1.xml और test2.xml से तालिकाओं को पॉप्युलेट करें।

test1.xml test2.xml

तरह

<dataset> 
    <table1 ... /> 
    <table2 ... /> 
</dataset> 

<dataset> 
    <table1 ... /> 
</dataset> 

जब परीक्षण के आदेश test1 test2 और उसके बाद है की तरह है, CLEAN_INSERT निम्न कार्रवाई करेंगे:

1. तालिका 2
2. से सभी को हटाएं टैब से सभी को हटाएं table1 में test1.xml से LE1
3. डालने डेटा table2 में test1.xml से
4. डालने डेटा
5. निष्पादित test1
6. test2.xml से
7. डालने डेटा table1 में
8. निष्पादित table1 से हटा दें test2

तो जब test2 निष्पादित किया जाता है, तालिका 1 में test2.xml से डेटा होता है, जो हम उम्मीद करते हैं। लेकिन table2 में अभी भी test1 के लिए डेटा है, जो कुछ मुद्दों का कारण बन सकता है।

एक वर्कअराउंड सभी एक्सएमएल फाइलों में प्रत्येक तालिका के लिए एक खाली पंक्ति है। यह सुनिश्चित करेगा कि सम्मिलित करने से पहले सभी तालिकाओं को साफ किया जाएगा।

ऊपर उदाहरण के लिए,

test1.xml तरह

<dataset> 
    <table1 ... /> 
    <table2 ... /> 
    <table1 /> 
    <table2 /> 
</dataset> 

test2 हो जाएगा।xml

<dataset> 
    <table1 ... /> 
    <table1 /> 
    <table2 /> 
</dataset>