Dynamiske mock services i SoapUI

Groovy Scriptet

Groovy-scriptet skrives direkte i en editor i SoapUI, som kommer frem, når man har valgt SCRIPT som dispatch-method:

Her er ses den Groovy-kode der er nødvendig for at parse requestet og udtrække parameterværdier, slå op i databasen og opbygge en Soap-Envelope:

   import groovy.sql.Sql
   import groovy.xml.MarkupBuilder
 
   //utility klasse for diverse SoapUI/Groovy-stuff
   def groovyUtils = new com.eviware.soapui.support.GroovyUtils( context )
 
   def holder  //XmlHolder, som kan bruges til at parse requestet
   //sæt stub-data 
   (bruges, hvis der ikke er noget request, fordi scriptet køres via 
   Run-knappen i SoapUI)
   def entity = "Customer"
   def attribute = "Country"
 
   //hvis scriptet er invokeret af et SoapRequest
   if (mockRequest.requestContent != null) {
         //XmlHolder giver os mulighed for at lave XPath-forespørgsler 
         på SoapRequestet
         holder = groovyUtils.getXmlHolder( mockRequest.requestContent )
         //registrer namespace
         holder.namespaces["tex"] = 
         "http://example.lundogbendsen.dk/textrepository"
         //læs parametre fra requestet
         entity = holder["//tex:Entity"]
         attribute = holder["//tex:Attribute"]
   }
 
   log.info "GetTextRepository(Entity=${entity}, Attribute=${attribute})"
 
   //lav en JDBC-forbindelse til Excel. TextRepository er navnet på 
   ODBC-forbindelsen
   def sql = Sql.newInstance("jdbc:odbc:TextRepository", 
   "sun.jdbc.odbc.JdbcOdbcDriver")
 
   def found=false; //found er true, hvis der findes et TextRepository som 
   matcher Entity og Attribute
   int textRepositoryId
   //Undersøg om der er matchende repository og hvis ja, så hent dets id
   sql.eachRow("SELECT id FROM [TextRepository$] where Entity=${entity} 
   and Attribute=${attribute}", { row ->
         found =  true
         textRepositoryId = row[0]
   })
 
   writer = new StringWriter()
   def xml = new groovy.xml.MarkupBuilder(writer)
 
   if (found) {  //opbyg Soap-Envelope med det fundne TextRepository
         xml.'soapenv:Envelope'('xmlns:soapenv': 
         'http://schemas.xmlsoap.org/soap/envelope/') {
                'soapenv:Body'{
                      'tex:GetTextRepositoryResponse'('xmlns:tex':
                      'http://example.lundogbendsen.dk/textrepository') {
                            'tex:TextRepository'{
                                   'tex:Id'(textRepositoryId)
                                   sql.eachRow("SELECT * FROM 
                                   [TextRepository$] 
                                   where Entity=${entity} and 
                                   Attribute=${attribute}", { row ->
                                  'tex:Text' {
                                         'tex:TextId'(row.textid)
                                         'tex:Value'(row.value)
                                         'tex:IsActive'(row.isactive)
                                         }
                                   })
                            }
                      }
                }
         }    
   } else { //hvis der ikke er noget match, så opbyg en SoapFault
       xml.'soapenv:Envelope'('xmlns:soapenv': *
       'http://schemas.xmlsoap.org/soap/envelope/') {
           'soapenv:Body'{
                 'soapenv:Fault'{
                     faultcode("soapenv:Client")
                     faultstring("TextRepository ${entity}/
                     ${attribute} not found!")
                     detail {
                       'tex:NoSuchTextRepository'('xmlns:tex':
                       'http://example.lundogbendsen.dk/textrepository'){                                                
                          'tex:RepositoryId'("${entity}/${attribute}")
                          'tex:Message'("TextRepository not found!")
                                 }
                           }                     
                    }
              }          
         }
    }
 
   //opret en attribut i RequestContext, som kan læses fra Response-filen
   requestContext?.response = writer.toString()
   return "DefaultResponse"

Kernen i programmet er Groovys MarkupBuilder. Groovy har en række builders, som alle er implementationer af Builder-designmønstret fra Gamma et al. MarkupBuilder er beregnet til at opbygge en struktur i et markupsprog, fx XHTML eller – som her – XML. MarkupBuilder anvender en af Groovys dynamiske features, nemlig det der hedder ’pretended method calls’, hvor et objekt tillader at man kalder vilkårlige metoder på det uden at metoderne er defineret i forvejen. Princippet er at metodekald bliver til elementer, parametre til attributter og closures bliver til elementets børn. Her er et forsøg på en pædagogisk forklaring af princippet:

På denne vis opbygger vi en Soap-Envelope med en XML-struktur for et TextRepository eller med en SoapFault.

Response-dokumentet

Response-dokumentet er ekstremt simpelt, da det blot indeholder en expression, som refererer den response-attribut, der indeholder den opbyggede Soap-Envelope.

Test

Vi har nu alle elementerne på plads i løsningen og kan starte vores Mock Service. For at teste den bruger vi den velkendte klient-del af SoapUI:

Og kaldes operationen med en ukendt kombination af Entity/Attribute fås en Soap-Fault som forventet:

Konklusion

Efter jeg lærte at lave dynamiske mock services i SoapUI er det blevet min foretrukne teknik, når en service skal simuleres. Jeg har tidligere benyttet JAX-WS til formålet og publiceret enten via en Web Container eller direkte med Endpoint.publish-metoden. Det er klart hurtigere at benytte SoapUI og jeg vil gerne fremhæve følgende lækre features ved SoapUI:

• Lav turn-around-tid: Når du laver ændringer i Scriptet eller Mock-Servicen i øvrigt, skal du hverken gemme eller redeploye for at ændringerne træder i kraft. I og med at Groovy-scriptet fortolkes pr. request, slår ændringer igennem med det samme. Prisen er dog at man ofte glemmer at gemme projektet – og så er ens fine Mock-Service væk når maskinen eller SoapUI crasher.
• Kompakt kode, som er let at tilpasse: Groovy-kode fylder generelt mindre end tilsvarende Java-kode. Desuden er Groovys MarkupBuilder reelt et DSL for konstruktion af markup-baserede dokumenter. Groovy-koden ligner ganske enkelt den dokumentstruktur, som koden skal producere. I praksis betyder det, at man kan opbygge Groovy-koden ved at indsætte det XML-response, som skal produceres og dernæst lave en næsten triviel transformation til Groovy-syntaksen. Bemærk fx ligheden mellem XML-strukturen og den Groovy-kode der opbygger den:

Groovy:

xml.'soapenv:Envelope'('xmlns:soapenv': 
 'http://schemas.xmlsoap.org/soap/envelope/') {
      'soapenv:Body'{
         'soapenv:Fault'{
           faultcode("soapenv:Client")
          faultstring("TextRepository ${entity}/${attribute} not found!")
             detail {
             'tex:NoSuchTextRepository'('xmlns:tex':
              'http://example.lundogbendsen.dk/textrepository') {
                  'tex:RepositoryId'("${entity}/${attribute}")
                  'tex:Message'("TextRepository not found!")
                                  }
                               }    
                            }
                      }       
                   }

XML:

<soapenv:Envelope xmlns:
 soapenv="http://schemas.xmlsoap.org/soap/envelope/">
   <soapenv:Body>
      <soapenv:Fault>
        <faultcode>soapenv:Client</faultcode>
        <faultstring>TextRepository Person/Ukendt not found!</faultstring>
        <detail>
            <tex:NoSuchTextRepository xmlns_tex=
             "http://example.lundogbendsen.dk/textrepository">
               <tex:RepositoryId>Person/Ukendt</tex:RepositoryId>
               <tex:Message>TextRepository not found!</tex:Message>
            </tex:NoSuchTextRepository>
         </detail>
      </soapenv:Fault>
   </soapenv:Body>
</soapenv:Envelope>

På den negative side, skal nævnes SoapUIs Groovy-editor, som ikke giver anden hjælp end syntaks-highlight af koden. Skal man skrive større programmer, er det anbefalelsesværdigt at skrive koden i fx Eclipse med Groovy-plugins og til sidst kopiere den over i SoapUI.

Jeg håber, at jeg har vakt din interesse for at lave dynamiske Mock-Services i SoapUI med denne artikel. Hvis du vil læse mere om emnerne, så er følgende links relevante:

• Læs om Mock-konceptet, anvendelser, fordele, ulemper
• SoapUIs tutorial om statiske mock-services
• Groovy generelt
• Closures
• Builders
• Sql / databaseadgang
• JDBC-ODBC broen