ඔබ පුද්ගලික ක්‍රම පරීක්ෂා කරන්නේ කෙසේද?

මම ජාවා ව්‍යාපෘතියක වැඩ කරනවා. මම ඒකක පරීක්ෂාවට අලුත් ය. ජාවා පන්තිවල පුද්ගලික ක්‍රම පරීක්ෂා කිරීමට හොඳම ක්‍රමය කුමක්ද?

ඔබ සාමාන්‍යයෙන් unit ජුවම පුද්ගලික ක්‍රම පරීක්ෂා නොකරයි. ඒවා පුද්ගලික බැවින් ඒවා ක්‍රියාත්මක කිරීමේ විස්තරයක් සලකා බලන්න. කිසිවෙකු ඔවුන්ගෙන් එක් අයෙකු අමතා එය විශේෂිත ආකාරයකින් ක්‍රියාත්මක වනු ඇතැයි අපේක්ෂා නොකරයි.

ඒ වෙනුවට ඔබ ඔබේ පොදු අතුරු මුහුණත පරීක්ෂා කළ යුතුය. ඔබේ පුද්ගලික ක්‍රම ලෙස හඳුන්වන ක්‍රම ඔබ අපේක්ෂා කළ පරිදි ක්‍රියාත්මක වන්නේ නම්, ඔබේ පුද්ගලික ක්‍රම නිවැරදිව ක්‍රියාත්මක වන බව ඔබ දීර් extension වශයෙන් උපකල්පනය කරයි.

පොදුවේ, මම එය වළක්වා ගන්නෙමි. ඔබේ පුද්ගලික ක්‍රමය එතරම් සංකීර්ණ නම් එයට වෙනම ඒකක පරීක්ෂණයක් අවශ්‍ය නම්, බොහෝ විට එයින් අදහස් කරන්නේ එය තමන්ගේම පන්තියට සුදුසු බවයි. මෙය නැවත භාවිතා කළ හැකි ආකාරයකින් ලිවීමට ඔබව දිරිමත් කළ හැකිය. ඉන්පසු ඔබ නව පංතිය පරීක්ෂා කර ඔබගේ පැරණි පන්තියේ පොදු අතුරු මුහුණත අමතන්න.

අනෙක් අතට, සමහර විට ක්‍රියාත්මක කිරීමේ තොරතුරු වෙනම පංතිවලට සාධක කිරීම සංකීර්ණ අතුරුමුහුණත් සහිත පන්ති, පැරණි හා නව පංතිය අතර දත්ත විශාල ප්‍රමාණයක් හෝ OOP දෘෂ්ටි කෝණයෙන් හොඳ පෙනුමක් ඇති මෝස්තරයකට මඟ පාදයි. ගැටළු සහිත වසමෙන් එන ප්‍රතිභාවන්ට ගැලපෙන්න (උදා: පුද්ගලික ක්‍රම අත්හදා බැලීම වළක්වා ගැනීම සඳහා මිල ආකෘතියක් කොටස් දෙකකට බෙදීම එතරම්ම බුද්ධිමත් නොවන අතර කේතය නඩත්තු කිරීමේදී / දීර් ing කිරීමේදී පසුකාලීනව ගැටළු වලට තුඩු දිය හැකිය). සෑම විටම එකට වෙනස් වන "ද්විත්ව පන්ති" පැවැත්වීමට ඔබට අවශ්‍ය නැත.

සංක්ෂිප්තකරණය සහ පරීක්ෂණ හැකියාව අතර තේරීමකට මුහුණ දෙන විට, මම දෙවැන්න සඳහා යමි. නිවැරදිව ක්‍රියා නොකරන හොඳ OOP සැලසුමකට වඩා නිවැරදි කේතය (එනම් නිවැරදි ප්‍රතිදානය නිපදවීම) වඩා වැදගත් වන්නේ එය ප්‍රමාණවත් ලෙස පරීක්‍ෂා නොකළ බැවිනි. ජාවා හි, ඔබට සරලවම "පෙරනිමි" ප්‍රවේශය ලබා දී ඒකක පරීක්ෂණය එකම පැකේජයකට දැමිය හැකිය. ඒකක පරීක්ෂණ යනු ඔබ සංවර්ධනය කරන පැකේජයේ කොටසක් වන අතර, පරීක්ෂණ සහ පරීක්‍ෂා කරන කේතය අතර පරායත්තතාවයක් තිබීම හරි. එයින් අදහස් වන්නේ ඔබ ක්‍රියාත්මක කිරීම වෙනස් කරන විට, ඔබේ පරීක්ෂණ වෙනස් කිරීමට ඔබට අවශ්‍ය විය හැකි නමුත් එය හරි - ක්‍රියාත්මක කිරීමේ සෑම වෙනස් කිරීමකටම කේතය නැවත පරීක්ෂා කිරීම අවශ්‍ය වන අතර, ඒ සඳහා පරීක්ෂණ වෙනස් කළ යුතු නම්, ඔබ එසේ කරයි එය.

පොදුවේ ගත් කල, පන්තියක් අතුරු මුහුණත් එකකට වඩා ලබා දෙයි. පරිශීලකයින් සඳහා අතුරු මුහුණතක් සහ නඩත්තු කරන්නන් සඳහා අතුරු මුහුණතක් ඇත. කේතය ප්‍රමාණවත් ලෙස පරීක්‍ෂා කර ඇති බව සහතික කිරීම සඳහා දෙවැන්නාට තවත් නිරාවරණය කළ හැකිය. එය පුද්ගලික ක්‍රමයක් මත ඒකක පරීක්ෂණයක් විය යුතු නැත - එය, උදාහරණයක් ලෙස, ලොග් වීම විය හැකිය. ලොග් වීම ද "සංසරණය බිඳ දමයි", නමුත් අපි තවමත් එය කරන්නේ එය එතරම් ප්‍රයෝජනවත් බැවිනි.

පෞද්ගලික ක්‍රම පරීක්ෂා කිරීම ඒවායේ සංකීර්ණත්වය මත රඳා පවතී. සමහර එක් පේළියේ පෞද්ගලික ක්‍රම මගින් පරීක්ෂණ සඳහා අමතර වෑයමක් අවශ්‍ය නොවනු ඇත (මෙය පොදු ක්‍රම ගැන ද පැවසිය හැකිය), නමුත් සමහර පුද්ගලික ක්‍රම පොදු ක්‍රම මෙන් සංකීර්ණ විය හැකි අතර පොදු අතුරු මුහුණත හරහා පරීක්ෂා කිරීම දුෂ්කර ය.

මගේ ප්‍රියතම තාක්‍ෂණය වන්නේ පුද්ගලික ක්‍රම පැකේජය පුද්ගලීකරණය කිරීමයි, එමඟින් එකම පැකේජයක ඒකක පරීක්ෂණයකට ප්‍රවේශ වීමට ඉඩ ලබා දෙන නමුත් එය අනෙක් සියලුම කේත වලින් සංයුක්ත වේ. සංකීර්ණ තර්කනයේ සියලුම කොටස් ආවරණය කිරීම සඳහා පොදු ක්‍රම පරීක්ෂණයක් මත විශ්වාසය තැබීම වෙනුවට පුද්ගලික ක්‍රමවේදය තර්කනය කෙලින්ම පරීක්ෂා කිරීමේ වාසිය මෙය ලබා දෙයි.

මෙය ගූගල් ගුවා පුස්තකාලයේ isVisibleForTesting ව්‍යාඛ්‍යාව සමඟ යුගලනය කර ඇත්නම්, ඔබ මෙම පැකේජය පෞද්ගලික ක්‍රමය පරීක්ෂා කිරීම සඳහා පමණක් පෙනෙන ලෙස සලකුණු කර ඇති අතර එය වෙනත් පංති විසින් කැඳවිය යුතු නොවේ.

මෙම ක්‍රමයේ විරුද්ධවාදීන් තර්ක කරන්නේ මෙය එකම පැකේජයක් තුළ කේත කිරීම සඳහා සංවෘත කිරීම සහ පුද්ගලික ක්‍රම විවෘත කරන බවයි. මෙය සංක්ෂිප්ත කිරීම බිඳ දමා පුද්ගලික කේත වෙනත් පංතිවලට විවෘත කරන බව මම එකඟ වන අතර, දැඩි තර්කනයට වඩා සංකීර්ණ තර්කනය පරීක්ෂා කිරීම වැදගත් වන අතර, පරීක්ෂා කිරීම සඳහා පමණක් දෘශ්‍යමාන ලෙස පැහැදිලිව සලකුණු කර ඇති පැකේජ පෞද්ගලික ක්‍රම භාවිතා නොකිරීම සංවර්ධකයින්ගේ වගකීම විය යුතුය. කේත පදනම භාවිතා කිරීම සහ වෙනස් කිරීම.

පරීක්ෂා කිරීමට පෙර පුද්ගලික ක්‍රමය:

private int add(int a, int b){
    return a + b;
}

ඇසුරුම් පුද්ගලික ක්‍රමය පරීක්ෂා කිරීමට සූදානම්:

@VisibleForTesting
int add(int a, int b){
    return a + b;
}

සටහන: එකම පැකේජයක පරීක්ෂණ තැබීම ඒවා එකම භෞතික ෆෝල්ඩරයකට දැමීමට සමාන නොවේ. ඔබේ ප්‍රධාන කේතය සහ පරීක්ෂණ කේතය වෙනම භෞතික ෆෝල්ඩර ව්‍යුහයකට වෙන් කිරීම සාමාන්‍යයෙන් හොඳ පුරුද්දකි. නමුත් එකම පැකේජයේ ඇති ආකාරයට පන්ති අර්ථ දක්වා ඇති තාක් කල් මෙම තාක්ෂණය ක්‍රියාත්මක වේ.

ඔබට බාහිර API භාවිතා කිරීමට නොහැකි නම් හෝ අවශ්‍ය නොවන්නේ නම්, පරාවර්තනය භාවිතයෙන් පුද්ගලික ක්‍රම වෙත ප්‍රවේශ වීමට ඔබට පිරිසිදු සම්මත JDK API භාවිතා කළ හැකිය. මෙන්න උදාහරණයක්

MyObject obj = new MyObject();
Method privateMethod = MyObject.class.getDeclaredMethod("getFoo", null);
privateMethod.setAccessible(true);
String returnValue = (String) privateMethod.invoke(obj, null);
System.out.println("returnValue = " + returnValue);

ජාවා නිබන්ධනය http://docs.oracle.com/javase/tutorial/reflect/ හෝ ජාවා API http://docs.oracle.com/javase/7/docs/api/java/lang/reflect/package-summary පරීක්ෂා කරන්න . වැඩි විස්තර සඳහා html .

අකිජ් ඔහුගේ පිළිතුරෙහි සඳහන් කර ඇති පරිදි, පරාවර්තනය භාවිතා කරන සරල විසඳුමක් පුද්ගලික ක්‍රමයක් පරීක්ෂා කිරීම සඳහා හොඳ අවස්ථා තිබේ.

ඒකක පරීක්ෂණ නඩුව යනු කේත ඒකකය පරීක්ෂා කිරීමයි. එයින් අදහස් කරන්නේ අතුරු මුහුණත පරීක්ෂා කිරීම නොවේ, මන්ද ඔබ අතුරු මුහුණත පරීක්ෂා කරන්නේ නම්, එයින් අදහස් වන්නේ ඔබ කේත ඒකකය පරීක්ෂා කරන බවයි. එය කළු පෙට්ටි පරීක්ෂණයක් බවට පත්වේ. එසේම, අතුරුමුහුණත් මට්ටමේ ඇති ගැටළු තීරණය කිරීමට වඩා කුඩාම ඒකක මට්ටමින් ගැටළු සොයා ගැනීම වඩා හොඳය. එබැවින්, ඔවුන්ගේ විෂය පථය නොසලකා ඒකක පරීක්ෂණ නඩුව පරීක්ෂා කළ යුතුය. පහත දැක්වෙන්නේ පුද්ගලික ක්‍රම පරීක්ෂා කිරීමේ ක්‍රමයකි.

ඔබ ජාවා භාවිතා කරන්නේ නම්, ඔබට පරීක්ෂණයට භාජනය වන පන්තියේ ඕනෑම පෞද්ගලික ක්‍රමයක් ඇමතීමට Deencapsulation.invoke සපයන jmockit භාවිතා කළ හැකිය. එය අවසානයේ එය ඇමතීමට පරාවර්තනය භාවිතා කරන නමුත් එය වටා ලස්සන එතුම සපයයි. ( https://code.google.com/p/jmockit/ )

පළමුවෙන්ම, අනෙක් කතුවරුන් යෝජනා කළ පරිදි: ඔබට පුද්ගලික ක්‍රමයක් පරීක්ෂා කිරීමට අවශ්‍ය නම් දෙවරක් සිතන්න. එසේ නම්, ...

.NET හි ඔබට එය "අභ්‍යන්තර" ක්‍රමයට පරිවර්තනය කළ හැකි අතර ඔබේ ඒකක පරීක්ෂණ ව්‍යාපෘතියට " අභ්‍යන්තර දෘශ්‍ය " පැකේජය සාදන්න .

ජාවා හි දී ඔබට පරීක්‍ෂා කළ යුතු පන්තියේදීම පරීක්ෂණ ලිවිය හැකි අතර ඔබේ පරීක්ෂණ ක්‍රමවලට පෞද්ගලික ක්‍රම ද ඇමතිය හැකිය. මට ඇත්තටම විශාල ජාවා අත්දැකීමක් නැත, එබැවින් එය හොඳම පුහුණුව නොවේ.

ස්තූතියි.

මම සාමාන්‍යයෙන් එවැනි ක්‍රම ආරක්ෂා කරමි. ඔබගේ පංතිය පවතින්නේ යැයි කියමු:

src/main/java/you/Class.java

ඔබට පරීක්ෂණ පන්තියක් නිර්මාණය කළ හැක්කේ:

src/test/java/you/TestClass.java

දැන් ඔබට ආරක්ෂිත ක්‍රම වෙත ප්‍රවේශය ඇති අතර ඒවා ඒකක පරීක්‍ෂා කළ හැකිය (JUnit හෝ TestNG ඇත්ත වශයෙන්ම වැදගත් නොවේ), නමුත් ඔබ මෙම ක්‍රම ඔබට අවශ්‍ය නැති ඇමතුම්කරුවන්ගෙන් තබා ගනී.

මෙය මේවන් විලාසිතාවේ ප්‍රභව ගසක් අපේක්ෂා කරන බව සලකන්න.

ජාවා සමඟ මම අදහස් කළේ ඔබට පුද්ගලික ක්‍රමයක් පරීක්ෂා කිරීමට අවශ්‍ය නම්, ඔබට භාවිතා කළ හැකිය fest assertසහ / හෝ fest reflect. එය පරාවර්තනය භාවිතා කරයි.

මේවන් සමඟ පුස්තකාලය ආයාත කරන්න (ලබා දී ඇති අනුවාදයන් මා සිතන අන්තිම අවස්ථාව නොවේ) හෝ ඔබේ පන්ති මාර්ගයට කෙලින්ම ආනයනය කරන්න:

<dependency>
     <groupId>org.easytesting</groupId>
     <artifactId>fest-assert</artifactId>
     <version>1.4</version>
    </dependency>

    <dependency>
     <groupId>org.easytesting</groupId>
     <artifactId>fest-reflect</artifactId>
    <version>1.2</version>
</dependency>

නිදසුනක් ලෙස, ඔබට 'MyClass' නමින් පංතියක් තිබේ නම්, 'myPrivateMethod' නමින් පුද්ගලික ක්‍රමයක් ඇත, එය String එකක් පරාමිතියක් ලෙස ගෙන එහි වටිනාකම 'මෙය සිසිල් පරීක්ෂණයකි!' ලෙස යාවත්කාලීන කරයි, ඔබට පහත දැක්වෙන ජුනිට් පරීක්ෂණය කළ හැකිය:

import static org.fest.reflect.core.Reflection.method;
...

MyClass objectToTest;

@Before
public void setUp(){
   objectToTest = new MyClass();
}

@Test
public void testPrivateMethod(){
   // GIVEN
   String myOriginalString = "toto";
   // WHEN
   method("myPrivateMethod").withParameterTypes(String.class).in(objectToTest).invoke(myOriginalString);
   // THEN
   Assert.assertEquals("this is cool testing !", myOriginalString);
}

මෙම පුස්තකාලය මඟින් ඕනෑම බෝංචි ගුණාංගයක් (ඒවා පුද්ගලික වුවත්, සැකසුම් කිසිවක් ලියා නැත) විහිළුවක් මගින් ප්‍රතිස්ථාපනය කිරීමට ඔබට හැකි වන අතර, මෙය මොකිටෝ හෝ වෙනත් ව්‍යාජ රාමුවක් සමඟ භාවිතා කිරීම ඇත්තෙන්ම සිසිල් ය. මේ මොහොතේ ඔබ දැනගත යුතු එකම දෙය (මෙය ඊළඟ සංස්කරණ වලදී වඩා හොඳ වේ දැයි නොදනී) ඔබට හැසිරවීමට අවශ්‍ය ඉලක්ක ක්ෂේත්‍රයේ / ක්‍රමයේ නම සහ එහි අත්සනයි.

මම සාමාන්‍යයෙන් C # හි කරන්නේ මගේ ක්‍රම ආරක්ෂා කර ගැනීම මිස පුද්ගලික නොවේ. එය තරමක් අඩු පුද්ගලික ප්‍රවේශ විකරණකාරකයක් වන නමුත් එය පරීක්ෂණයට ලක්වන පන්තියෙන් උරුම නොවන සියලුම පන්ති වලින් ක්‍රමය සඟවයි.

public class classUnderTest
{
   //this would normally be private
   protected void methodToTest()
   {
     //some code here
   }
}

ClassUnderTest වෙතින් කෙලින්ම උරුම නොවන ඕනෑම පන්තියකට methodToTest පවා පවතින බව නොදැනේ. මගේ පරීක්ෂණ කේතය තුළ, මට මෙම ක්‍රමයට ප්‍රවේශය ලබා දෙන විශේෂ පරීක්ෂණ පන්තියක් නිර්මාණය කළ හැකිය ...

class TestingClass : classUnderTest
{
   public void methodToTest()
   {
     //this returns the method i would like to test
     return base.methodToTest();
   }
}

මෙම පන්තිය පවතින්නේ මගේ පරීක්ෂණ ව්‍යාපෘතියේ පමණි. එහි එකම අරමුණ මෙම තනි ක්‍රමයට ප්‍රවේශය සැපයීමයි. වෙනත් බොහෝ පංති නොමැති ස්ථාන වලට ප්‍රවේශ වීමට එය මට ඉඩ දෙයි.

ඔබ පරීක්ෂා කරන පන්තියේ අභ්‍යන්තර පන්තියක ඔබේ ඒකක පරීක්ෂණ තැබුවහොත් ඔබට පුද්ගලික ක්‍රම පහසුවෙන් පරීක්ෂා කළ හැකිය. TestNG භාවිතා කරමින් ඔබේ ඒකක පරීක්ෂණ est ටෙස්ට් සමඟ විවරණය කර ඇති පොදු ස්ථිතික අභ්‍යන්තර පන්ති විය යුතුය,

@Test
public static class UserEditorTest {
    public void test_private_method() {
       assertEquals(new UserEditor().somePrivateMethod(), "success");
    }
}

එය අභ්‍යන්තර පංතියක් බැවින් පුද්ගලික ක්‍රමය හැඳින්විය හැකිය.

මගේ පරීක්ෂණ maven වෙතින් ධාවනය වන අතර එය ස්වයංක්‍රීයව මෙම පරීක්ෂණ අවස්ථා සොයා ගනී. ඔබට එක් පන්තියක් පරීක්ෂා කිරීමට අවශ්‍ය නම් ඔබට කළ හැකිය

$ mvn test -Dtest=*UserEditorTest

මුලාශ්‍රය: http://www.ninthavenue.com.au/how-to-unit-test-private-methods