පෝලිම් සහ JMeter: ප්‍රකාශක සහ ග්‍රාහකයා සමඟ බෙදාගැනීම

හෙලෝ, හබ්ර්! මෙය මගේ අනුගාමිකයෙකි පෙර ප්රකාශනය, මම JMeter භාවිතයෙන් පෝලිම්වල පණිවිඩ තැබීමේ විකල්ප ගැන කතා කරමි.

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

හැඳින්වීම

මුලදී මට මේ වේදනාව දරා ගැනීමට සිදු වුවද. ඒ සියල්ල RFHUtil සමඟ ආරම්භ විය. බලවත්, නමුත් අපහසු සහ බියජනක: හොඳයි, ඔබ රුස් දන්නවා.

සමහර අවස්ථාවලදී අත්‍යවශ්‍ය වේ, නමුත් සක්‍රීය භාවිතයේදී ක්‍රමයෙන් අඩු වේ.
එය සමඟ පහසු පරීක්ෂණයක් කළ නොහැක.

JMeter සමඟ සෑම දෙයක්ම පහසු වී ඇත. ප්‍රගුණ කර පුරුදු වීමේ පළමු අදියරෙන් පසු ප්‍රීතිමත් පරීක්‍ෂණයක් සඳහා බලාපොරොත්තුව උදාවන්නට විය.

මම JMS ප්‍රකාශක සහ JMS ග්‍රාහක සාම්පල සක්‍රියව භාවිත කරමි. JMS Point-to-Point මෙන් නොව, මෙම යුගලය භාවිතා කිරීමට වඩාත් පහසු විය. උදාහරණයක් ලෙස, JMS Selector හි ග්‍රාහකයා සමඟ ඔබට විචල්‍යයක් නියම කළ හැකිය, නමුත් Point-to-Point සමඟ ඔබට කළ නොහැක (නැතහොත් මෙම ක්‍රමය ඉතා පැහැදිලි නොවේ).

සාම්පල සකස් කිරීම

JMS ප්‍රකාශක

• සැකසුම - එක් එක් නියැදිය. Apache නිර්දේශ කරයි පෝලිම්/මාතෘකා විචල්‍ය හරහා නියම කර ඇත්නම් මෙම විකල්පය භාවිතා කරන්න.
• කල් ඉකුත්වීම (ms) = 120000. අසාර්ථක වූ විට, පරීක්ෂණ ඉල්ලීම් විනාඩි 2 කට පසු පෝලිමෙන් අතුරුදහන් වනු ඇත.
• නොනැසී පවතින බෙදාහැරීමේ මාදිලිය භාවිතා කරන්නද? - සැබෑ. IBM අනුමත කරයිස්ථීර මාදිලිය හදිසි අසමත් වීමකදී සම්ප්‍රේෂණය කරන ලද පණිවිඩ විශ්වාසදායක ලෙස සංරක්ෂණය කිරීම සහතික කරයි. සහ නොනවතින මාදිලියේ වේගවත් හුවමාරුව. පරීක්ෂණ අරමුණු සඳහා, වේගය වඩා වැදගත් වේ.

සෑම ප්‍රකාශකයෙකු තුළම මම ග්‍රාහකයා JMS තේරීම්කාරකයේ භාවිතා කරන jms දේපලක් සකසමි. සෑම ඉදිරිපත් කිරීමක් සඳහාම, පරිශීලක පරාමිති පරීක්ෂණ සැලසුම් මූලද්‍රව්‍යය තුළ අහඹු අගයක් ජනනය වේ:

මේ ආකාරයෙන් නිවැරදි පණිවිඩය කියවා ඇති බවට ඔබට සහතික විය හැකිය.

පෙර-වින්‍යාසගත JMS ප්‍රකාශකයෙකුගේ අවසාන "හිස්":

JMS ග්‍රාහකයා

• සැකසුම - එක් එක් නියැදිය. හොඳයි, ඔබට තේරෙනවා.
• කල් ඉකුත්වීම (ms) = 100000. තත්පර 100ක් බලා සිටීමෙන් පසු ඉල්ලීම පෝලිමේ නොපැමිණියේ නම්, යමක් වැරදී ඇත.
• සාම්පල අතර නවත්වන්නද? - සැබෑ.

JMS තේරීම් - තරමක් පහසු දෙයක්. අවසාන JMS ග්‍රාහකයා:

සම්ප්‍රේෂණය කරන ලද පණිවිඩවල සිරිලික් හෝඩිය සමඟ කටයුතු කරන්නේ කෙසේද. JMeter හි, පෙරනිමියෙන්, සෝදුපත් කියවීමෙන් පසු, එය වංක ලෙස පෙන්වයි. මෙය වළක්වා ගැනීමට සහ සෑම විටම සහ සෑම තැනකම ශ්‍රේෂ්ඨ හා බලවත් දේ භුක්ති විඳීමට, ඔබ කළ යුත්තේ:

1. JMeter "launcher" වෙත JVM තර්කයක් එක් කරන්න:

   -Dfile.encoding=UTF-8

2. GSR223 PostProcessor Groy line සමඟ ග්‍රාහකයාට එක් කරන්න:

   prev.setDataEncoding("UTF-8")

පෙළ යවන්න

කම්මැලි විකල්පය. අලුතින් ලියන ලද පරීක්ෂණ නිදොස් කිරීම සඳහා සුදුසු වේ. නැතහොත් ඔබට අවම වශයෙන් කුඩා දෙයක් යැවීමට අවශ්‍ය වූ අවස්ථා සඳහා. විකල්පය තෝරන්න පණිවිඩ මූලාශ්රය - Textarea සහ පණිවිඩයේ අන්තර්ගතය පෙළ කොටසක තබන්න:

ගොනු හුවමාරුව

වඩාත් පොදු විකල්පය. බොහෝ අවස්ථා සඳහා සුදුසු වේ. විකල්පය තෝරන්න පණිවිඩ මූලාශ්‍රය - ගොනුවෙන් සහ ක්ෂේත්රයේ පණිවිඩය සඳහා මාර්ගය සඳහන් කරන්න ගොනුව - ගොනු නාමය:

පෙළ ක්ෂේත්‍රයකට ගොනුවක් මාරු කිරීම

වඩාත්ම බහුකාර්ය විකල්පය. බොහෝ අවස්ථා සඳහා සුදුසු වේ + දෙවන යැවීමේ විකල්පයක් නොමැති JMS Point-to-Point හි භාවිතා කළ හැක:

බයිට් අරාවක් පසුකරමින්

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

ඉතින් මට බාගත කිරීමට සිදු විය මූලාශ්ර සහ වෙනස් කරන්න කේතය JMS ග්‍රාහකයා.

ක්‍රමය තුළ ප්‍රතිස්ථාපනය කර ඇත extractContent(..) රේඛාව:

buffer.append(bytesMessage.getBodyLength() + " bytes received in BytesMessage");

මත:

byte[] bytes = new byte[(int) bytesMessage.getBodyLength()];
bytesMessage.readBytes(bytes);
try {
	buffer.append(new String(bytes, "UTF-8"));
} catch (UnsupportedEncodingException e) {
	throw new RuntimeException(e);
}

සහ JMeter නැවත ගොඩනඟා ඇත.

ඉතිරිව ඇත්තේ JSR223 නියැදි කිහිපයක් එකතු කිරීම පමණි. පළමුවැන්න සසම්භාවී බයිට් අඩංගු DAT ගොනුවක් සෑදීමට ප්‍රකාශක/ග්‍රාහක යුගලයට පෙරය.

import org.apache.commons.lang3.RandomUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

vars.put("PATH_TO_BYTES", "C:temprandomBytes.dat");
File RESULT_FILE = new File(vars.get("PATH_TO_BYTES"));
byte[] arr = RandomUtils.nextBytes((int)(Math.random()*10000));
        try {
            FileOutputStream fos = new FileOutputStream(RESULT_FILE);
            fos.write(arr);
            fos.close();
        } catch (IOException e) {
            System.out.println("file not found");
        }

දෙවැන්න - ස්ක්‍රිප්ට් අවසානයේ, ගොනුව මකා දමයි:

import java.io.File;

File RESULT_FILE = new File(vars.get("PATH_TO_BYTES"));
RESULT_FILE.delete();

ප්‍රකාශකයේ ඇති ගොනුවට මාර්ගය එක් කිරීමට අමතක නොකරන්න:

සහ ග්‍රාහකයා සඳහා JSR223 ප්‍රකාශයේ චෙක්පතක් - ප්‍රභව බයිට් ලබන්නාගේ පෝලිමේ එන ඒවා සමඟ සසඳන්න:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;

Path path = Paths.get(vars.get("PATH_TO_BYTES"), new String[0]);
byte[] originalArray = Files.readAllBytes(path);
byte[] changedArray = ctx.getPreviousResult().getResponseData();
System.out.println(changedArray.length);

if (Arrays.equals(originalArray, changedArray))
	{
     	SampleResult.setResponseMessage("OK");

	} else {
	   SampleResult.setSuccessful(false);
     	   SampleResult.setResponseMessage("Comparison failed");
	   SampleResult.setResponseData("Bytes have changed","UTF-8");
     	   IsSuccess=false;
	}

නිගමනය

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

ඔබේ කාලය ඉතිරි කරන්න. සහ ඔබේ අවධානයට ස්තූතියි.

මූලාශ්රය: www.habr.com