Eigene Tests schreiben: Beispiel 2

Der folgende Quellcode ist ein Beispiel für einen Test, der Namen für Warteschlangenmanager auf Einhaltung einer definierten Namenskonvention prüft. Falls Warteschlangen gefunden werden, deren Namen nicht der Konvention entsprechen, werden die Details in der Ansicht 'Testergebnis' angezeigt.


/*                                                    
 * Lizenziertes Material - Eigentum der IBM
 *  
 * 5724-H72, 5655-L82, 5724-L26, 5655R3600
 * 
 * (c) Copyright IBM Corp. 2005, 2020
 * 
 *
 */
package com.ibm.mq.explorer.tests.sample;

/**
 * Ein Beispieltest, der zur Prüfung von Warteschlangennamen auf Namenskonventionen verwendet  * wird. Warteschlangennamen werden geprüft, falls sie mit einem der festgelegten Präfixe * beginnen, die in dieser Klasse definiert wurden. Namen, die nicht mit einem der Präfixe  * beginnen, werden als Fehler ausgegeben.
 *
 * Dieses Beispiel verwendet die PCF-Klassen aus 'MS0B SupportPac'. Laden Sie dieses  * 'SupportPac' von der IBM-Website herunter und binden Sie die JAR-Datei in den  * Erstellungspfad für das Projekt ein.
 */
public class WMQQueueNames extends WMQTest {

  /** Verwaltung der Anzahl von Warteschlangen, auf deren Antwort wir warten. */
  private static int numberOfQmgrs = 0;

  /** Speicherung der akzeptierten Warteschlangen-Präfixe. */
  private static final String[] ACCEPTED_Q_PREFIXES = {"SALES_", "MARKETING_", "SHIPPING_", //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
      "INCOMING_", "OUTGOING_"}; //$NON-NLS-1$//$NON-NLS-2$

  /** Speicherung der Benutzervorgabe, ob Systemwarteschlangen eingeschlossen werden sollen. */
  boolean includeSystemObjs = false;

  /**
   * Startet den Test.
   * 
   * 
   * @param callback: Kennung für die ausführende Testengine
   * @param guimonitor: Eine Kennung für das den Test überwachende Objekt, die es dem Test       * ermöglicht, regelmäßig zu prüfen, ob der Benutzer versucht hat, den Test abzubrechen,    * sowie weitere Benutzerrückmeldung bereitzustellen
   * @param contextObjects: Kontextelement 'MQExtObjects', das an die Testengine    * weitergegeben wird
   * @param treenodeId Die für Teststarts verwendete Baumknoten-Kennung
   */
  public void runTest(WMQTestEngine callback, IProgressMonitor guimonitor,
      MQExtObject[] contextObjects, TreeNode treenodeId) {

    // Beginn der Standardimplementierung. Hierdurch wird eine Kennung
    // in der Testengine gespeichert, die für die Rückgabe von Ergebnissen    // am Ende des Tests benötigt wird.
    super.runTest(callback, guimonitor, contextObjects, treenodeId);

    // Speicherplatz zur Speicherung von Testergebnissen, die ggf. zurückgegeben werden sollen
    ArrayList testResults = new ArrayList();

    // Benutzervorgabe abfragen, ob System-Warteschlangen einzuschließen sind
    includeSystemObjs = PreferenceStoreManager.getIncludeSysObjsPreference();

    // Liste mit Warteschlangenmanagern von Explorer abrufen
    ArrayList allQmgrs = new ArrayList();

    for (int k = 0; k < contextObjects.length; k++) {
      if (contextObjects[k] instanceof MQQmgrExtObject) {
        // Objekt ist eine Warteschlange, der Liste hinzufügen
        allQmgrs.add(contextObjects[k]);
      }
    }

    // Wie viele Warteschlangen gibt es?
    numberOfQmgrs = allQmgrs.size();

    // Zahl der Warteschlangen als Anhaltspunkt für den Verarbeitungsfortschritt verwenden
    guimonitor.beginTask(getTestName(), numberOfQmgrs);

    // Für jede Warteschlange eine Abfrage übergeben
    for (int i = 0; i < numberOfQmgrs; i++) {

      // Nächsten Warteschlangenmanager abrufen
      MQQmgrExtObject nextQueueManager = (MQQmgrExtObject) allQmgrs.get(i);

      // Abfragen nur an verbundene Warteschlangenmanager übergeben
      if (nextQueueManager.isConnected()) {

        // Warteschlangenname zur Verwendung in graphischer Benutzeroberfläche abfragen
        String qmgrName = nextQueueManager.getName();

        // Kennung zu einem Java-Objekt abrufen, dass für den Warteschlangenmanager steht
        MQQueueManager qmgr = nextQueueManager.getMQQueueManager();

        try {
          // PCF-Nachrichten-Agenten abrufen für Bearbeitung von PCF-Abfrage
          PCFMessageAgent agent = new PCFMessageAgent(qmgr);

          // PCF für Abfrage der Warteschlangennamen verwenden
          PCFMessage response = submitQueueNamesQuery(qmgrName, agent);

          // Antwort auf Abfrage erhalten?
          if (response != null) {
            // Warteschlangennamen aus Antwort abrufen
            String[] qnames = (String[]) response.getParameterValue(CMQCFC.MQCACF_Q_NAMES);

            // Alle Namen prüfen
            for (int j = 0; j < qnames.length; j++) {
              boolean qnameOkay = checkQueueName(qnames[j]);

              if (!qnameOkay) {
                // Falls ein Problem mit dem Namen festgestellt wurde, eine Fehlermeldung erstellen und der zurückzugebenden Sammlung hinzufügen
                testResults.add(generateTestResult(qnames[j], qmgrName));
              }
            }
          }
        }
        catch (MQException e) {
          // Fehlerdetails erfassen
          e.printStackTrace();
        }
      }

      // Prüfen eines Warteschlangenmanagers abgeschlossen
      guimonitor.worked(1);
    }

    // Durch diesen Test erzeugte Ergebnisse zurückgeben
    WMQTestResult[] finalresults = (WMQTestResult[]) testResults
        .toArray(new WMQTestResult[testResults.size()]);
    testComplete(finalresults);
  }

  /**
   * Intern verwendet, um eine 'INQUIRE_Q_NAMES'-Abfrage mit PCF an den jeweiligen   * Warteschlangenmanager zu übergeben.
   * 
   * 
   * @param qmgrName: Name des Warteschlangenmanagers, an den die Abfrage übergeben wird
   * @param agent
   * @Rückgabe der PCF-Antwort vom Warteschlangenmanager
   */
  private PCFMessage submitQueueNamesQuery(String qmgrName, PCFMessageAgent agent) {

    // PCF-Nachricht erstellen
    PCFMessage inquireQNames = new PCFMessage(CMQCFC.MQCMD_INQUIRE_Q_NAMES);
    inquireQNames.addParameter(CMQC.MQCA_Q_NAME, "*"); //$NON-NLS-1$

    try {
      // Nachricht senden
      PCFMessage[] responseMsgs = agent.send(inquireQNames);

      // Prüfen, ob Ergebnisse erfolgreich erhalten wurden
      if (responseMsgs[0].getCompCode() == 0) {
        return responseMsgs[0];
      }
    }
    catch (IOException e) {
      // Fehlerdetails erfassen
      e.printStackTrace();

    }
    catch (MQException e) {
      // Fehlerdetails erfassen
      e.printStackTrace();
    }

    // Aus beliebigem Grund keine Antwort erhalten, daher null zurückgeben
    return null;
  }

  /**
   * Intern verwendet, um den jeweiligen Warteschlangennamen anhand der zulässigen Präfixe    * zu prüfen.
   * 
   * 
   * @param queueName: Zu prüfender Warteschlangenname
   * @'Wahr' zurückgeben bei zulässigem Warteschlangennamen, andernfalls 'Falsch'
   */
  private boolean checkQueueName(String queueName) {

    // Falls dies ein Systemobjekt ist (der Name also mit "SYSTEM" beginnt), prüfen wir
    if ((queueName.startsWith("SYSTEM.")) || (queueName.startsWith("AMQ."))) { //$NON-NLS-1$//$NON-NLS-2$
      if (!includeSystemObjs) {
        // Benutzer hat angefordert, dass Systemobjekte nicht in den Test aufgenommen         // werden. Daher geben wir 'Wahr' zurück, um zu vermeiden, dass für diese         // Warteschlange Probleme gemeldet werden
        return true;
      }
    }

    // Die PCF-Antwort wird den Warteschlangennamen löschen, daher trimmen wir ihn jetzt
    queueName = queueName.trim();

    // Warteschlangennamen anhand sämtlicher zulässiger Präfixe nacheinander prüfen und     // sofort 'Wahr' ausgeben, falls Folgendes zutrifft:
    for (int i = 0; i < ACCEPTED_Q_PREFIXES.length; i++) {
      if (queueName.startsWith(ACCEPTED_Q_PREFIXES[i]))
        return true;
    }

    // Prüfung auf alle zulässigen Präfixe abgeschlossen, ohne Übereinstimmung zu finden
    return false;
  }

  /**
   * Intern verwendet, um ein Testergebnis für den jeweiligen Warteschlangennamen zu    * erstellen.
   *
   * 
   * @param queueName: Warteschlange, die Anforderungen nicht erfüllt
   * @param qmgrName: Name des Warteschlangenmanagers, der die Warteschlange enthält
   * @Erzeugtes Testergebnis zurückgeben
   */
  private WMQTestResult generateTestResult(String queueName, String qmgrName) {
    String res = "Queue (" + queueName.trim() + ") beginnt nicht mit einem bekannten Präfix"; //$NON-NLS-1$//$NON-NLS-2$

    return new WMQTestResult(IMarker.SEVERITY_ERROR, res, qmgrName, getTestSubCategory());
  }
}