કતાર અને JMeter: પ્રકાશક અને સબ્સ્ક્રાઇબર સાથે શેરિંગ

હેલો, હેબ્ર! આ મારી સિક્વલ છે અગાઉનું પ્રકાશન, જેમાં હું JMeter નો ઉપયોગ કરીને કતારોમાં સંદેશા મૂકવાના વિકલ્પો વિશે વાત કરીશ.

અમે મોટી ફેડરલ કંપની માટે ડેટા બસ બનાવી રહ્યા છીએ. વિવિધ વિનંતી ફોર્મેટ, પરિવર્તન, જટિલ રૂટીંગ. પરીક્ષણ માટે, તમારે કતારમાં ઘણા બધા સંદેશા મોકલવાની જરૂર છે. મેન્યુઅલી એક પીડા છે જે દરેક શિરોપ્રેક્ટર સંભાળી શકતી નથી.

પરિચય

જોકે મારે પહેલા આ પીડા સહન કરવી પડી હતી. તે બધું RFHUtil થી શરૂ થયું. શક્તિશાળી, પરંતુ બેડોળ અને ડરામણી: સારું, તમે રસને જાણો છો.

કેટલાક કિસ્સાઓમાં અનિવાર્ય, પરંતુ સક્રિય ઉપયોગના કિસ્સામાં સતત ઘટાડો.
તેની સાથે અનુકૂળ પરીક્ષણ અશક્ય છે.

JMeter સાથે બધું સરળ બની ગયું છે. નિપુણતાના પ્રથમ તબક્કા પછી અને તેની આદત પાડ્યા પછી, ખુશ પરીક્ષણ માટે આશા ઉભરાવા લાગી.

હું સક્રિયપણે JMS પ્રકાશક અને JMS સબ્સ્ક્રાઇબર નમૂનાઓનો ઉપયોગ કરું છું. JMS પોઈન્ટ-ટુ-પોઈન્ટથી વિપરીત, આ જોડી વાપરવા માટે વધુ અનુકૂળ લાગતી હતી. ઉદાહરણ તરીકે, જેએમએસ સિલેક્ટરમાં સબસ્ક્રાઇબર સાથે તમે ચલનો ઉલ્લેખ કરી શકો છો, પરંતુ પોઈન્ટ-ટુ-પોઈન્ટ સાથે તમે કરી શકતા નથી (અથવા આ પદ્ધતિ બહુ સ્પષ્ટ નથી).

નમૂનાઓ તૈયાર કરી રહ્યા છીએ

જેએમએસ પ્રકાશક

• સેટઅપ - દરેક નમૂના. અપાચે ભલામણ કરે છે આ વિકલ્પનો ઉપયોગ કરો જો કતાર/વિષયો ચલો દ્વારા નિર્દિષ્ટ કરવામાં આવ્યા હોય.
• સમાપ્તિ (ms) = 120000. નિષ્ફળતાના કિસ્સામાં, પરીક્ષણ વિનંતીઓ 2 મિનિટ પછી કતારમાંથી અદૃશ્ય થઈ જશે.
• બિન-સતત ડિલિવરી મોડનો ઉપયોગ કરીએ? - સાચું. IBM મંજૂર કરે છેતે સતત મોડ અચાનક નિષ્ફળતાના કિસ્સામાં પ્રસારિત સંદેશાઓની વિશ્વસનીય જાળવણીની ખાતરી આપે છે. અને બિન-સતત મોડમાં ઝડપી વિનિમય. પરીક્ષણ હેતુઓ માટે, ઝડપ વધુ મહત્વપૂર્ણ છે.

દરેક પબ્લિશરમાં મેં એક jms પ્રોપર્ટી સેટ કરી છે જેનો સબ્સ્ક્રાઇબર JMS સિલેક્ટરમાં ઉપયોગ કરશે. દરેક સબમિશન માટે, યુઝર પેરામીટર ટેસ્ટ પ્લાન એલિમેન્ટમાં રેન્ડમ વેલ્યુ જનરેટ થાય છે:

આ રીતે તમે ખાતરી કરી શકો છો કે સાચો સંદેશ વાંચવામાં આવ્યો છે.

પૂર્વ-રૂપરેખાંકિત JMS પ્રકાશકનું અંતિમ "ખાલી":

JMS સબ્સ્ક્રાઇબર

• સેટઅપ - દરેક નમૂના. સારું, તમે સમજો છો.
• સમયસમાપ્તિ (ms) = 100000. જો વિનંતી 100 સેકન્ડની રાહ જોયા પછી કતારમાં ન આવે, તો કંઈક ખોટું થયું છે.
• નમૂનાઓ વચ્ચે રોકો? - સાચું.

JMS પસંદગીકાર - તદ્દન અનુકૂળ વસ્તુ. અંતિમ JMS સબ્સ્ક્રાઇબર:

પ્રસારિત સંદેશાઓમાં સિરિલિક મૂળાક્ષરો સાથે કેવી રીતે વ્યવહાર કરવો. JMeter માં, મૂળભૂત રીતે, પ્રૂફરીડિંગ પછી, તે કુટિલ રીતે પ્રદર્શિત થાય છે. આને ટાળવા અને હંમેશા અને સર્વત્ર મહાન અને શક્તિશાળીનો આનંદ માણવા માટે, તમારે આ કરવાની જરૂર છે:

1. JMeter “લૉન્ચર” માં JVM દલીલ ઉમેરો:

   -Dfile.encoding=UTF-8

2. ગ્રુવી લાઇન સાથે સબસ્ક્રાઇબરમાં JSR223 પોસ્ટપ્રોસેસર ઉમેરો:

   prev.setDataEncoding("UTF-8")

ટેક્સ્ટ મોકલો

સૌથી આળસુ વિકલ્પ. તાજા લેખિત પરીક્ષણોને ડીબગ કરવા માટે યોગ્ય. અથવા એવા કિસ્સાઓ માટે જ્યારે તમારે ઓછામાં ઓછું કંઈક નાનું મોકલવાની જરૂર હોય. વિકલ્પ પસંદ કરો સંદેશ સ્ત્રોત - Textarea અને સંદેશના મુખ્ય ભાગને ટેક્સ્ટ બ્લોકમાં મૂકો:

ફાઇલ ટ્રાન્સફર

સૌથી સામાન્ય વિકલ્પ. મોટા ભાગના દૃશ્યો માટે યોગ્ય. વિકલ્પ પસંદ કરો સંદેશ સ્ત્રોત - ફાઇલમાંથી અને ક્ષેત્રમાં સંદેશનો માર્ગ સૂચવો ફાઇલ - ફાઇલનામ:

ફાઇલને ટેક્સ્ટ ફીલ્ડમાં સ્થાનાંતરિત કરવી

સૌથી સર્વતોમુખી વિકલ્પ. મોટા ભાગના દૃશ્યો માટે યોગ્ય + JMS પોઈન્ટ-ટુ-પોઈન્ટમાં વાપરી શકાય છે જ્યાં બીજો મોકલવાનો વિકલ્પ નથી:

બાઈટ એરે પસાર કરી રહ્યા છીએ

સૌથી મુશ્કેલ વિકલ્પ. વિકૃતિ, 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