all-IT

Das auf Groovy basierende Webframework Grails ermöglicht in der Java Welt eine schnelle Entwicklung von Webapplikationen. Die Schnelligkeit erkauft man sich aber nicht durch den Verzicht auf Tests. Im Gegenteil.

Mit dem Canoo – Webtest Plugin sind die Tests genauso schnell geschrieben, wie die Anwendung selbst (was aus meiner Sicht der einzige Weg ist dem Entwickler das Testen schmackhaft zu machen).

Für die Installation reicht ein simples:

> grails install-plugin webtest

Und mit:

1
2
3
4
5
6
7

> grails create-webtest
WebTest name not specified. Please enter:
<domain -name>
     [copy] Copying 1 file to <pfad zur Grails App>
     [copy] Copying 1 file to </pfad><pfad zur Grails App>/webtest/tests
Web Test generated at webtest/tests/<domain -name>Test.groovy
</domain></pfad></domain>

erstellt man seinen ersten Test für eine Domainklasse von Grails. Alle Tests werden standardmäßig unter /webtest/tests abgelegt. Ein generierter Test könnte so aussehen:
Continue reading »

Das auf Groovy basierende Webframework Grails ermöglicht in der Java Welt eine schnelle Entwicklung von Webapplikationen. Die Schnelligkeit erkauft man sich aber nicht durch den Verzicht auf Tests. Im Gegenteil....

geschrieben von gklinkmann \\ tags: Grails, groovy, tools, tutorial, Web

Eine der wichtigsten Resourcen, wenn man sich mit Groovy und Grails beschäftigt, ist aus meiner Sicht der Grails Podcast von und mit Sven Haiges und Glen Smith.

Der Podcast, der alle 2 Wochen in englischer Sprache erscheint, hat nun die Folge 100 erreicht.
Alles Gute von meiner Seite zu diesem Ereignis und vielen Dank für die zahlreichen Informationen und News der letzten Jahre rund um die Themen Groovy und Grails.

Macht weiter so.

Eine der wichtigsten Resourcen, wenn man sich mit Groovy und Grails beschäftigt, ist aus meiner Sicht der Grails Podcast von und mit Sven Haiges und Glen Smith. Der Podcast, der...

geschrieben von gklinkmann \\ tags: Grails, groovy, Java, podcast, Web

Aus meiner Sicht ist Groovy, die dynamische Sprache für die Java Virtual Machine, auf der großen Hype Kurve am Punkt der technischen Realität angekommen. Mit Scala und Clojure werden statt dessen gerade 2 neue Programmiersprachen durch die Gemeinde der Java Jünger getrieben.

So ist es an der Zeit einmal zu hinterfragen, was man selbst bis jetzt mit Groovy implementiert hat, ob man dabei bleibt oder doch auf den Scala Zug aufspringt.

Dierk König, der Autor von “Groovy in Action” (dem besten Fachbuch, das ich in letzter Zeit gelesen habe), hat einmal folgende 7 Anwendungsmuster für Groovy herausgearbeitet:

Super Glue, Liquid Heart, Keyhole Surgery, Smart Configuration, Unlimited Openness, House-Elf Scripts, Prototype

Oder nicht ganz so prosaisch, als:

• Bindeglied zwischen Java Komponenten (wie z.B. Spring und Hibernate in Grails)
• Auslagerung der Buisiness Logik, um sie dynamisch auf Veränderungen anpassen zu können
• Eingriffsmöglichkeit in laufende Applikationen
• Erweiterung der Konfiguration mit den Mitteln einer Programmiersprache (um endlich das plumpe XML loszuwerden)
• die leichte Veränderung von Code zur Laufzeit
• Hilfe für alle Aufgaben, die durch die Programmierung anfallen (Build automation, continuous integration, deployment, installer, service monitoring, reports, statistics, automated documentation, functional tests, HTML scraping, Web remote control, XML-RPC, WebServices)
• Tool zur schnellen Erstellung von Prototypen, mit der Möglichkeit diese später auf Java portieren zu können.

Doch zurück zum Ausgangspunkt. Was mache ich mit Groovy?

Zuerst einmal schreibe ich 95 % aller neuen Tests in Groovy. Die knackige Syntax, die perfekte Interoperabilität mit Java und die gute (aber verbesserungsfähige) Integration in Eclipse machen die Erstellung von Tests sehr viel weniger lästig. Zudem gibt es kleinere Web- und Webservices Applikationen auf Basis von Grails (dem Webframwork, das seinerseits ebenfalls auf Groovy basiert), sowie Tools, die rein in Groovy geschrieben sind.

Letztendlich kann man sagen, der Hype ist dem Alltag gewichen und Groovy passt sich perfekt in die tägliche Arbeit ein. Mit Griffon und GPars stehen 2 weitere Frameworks für Swing Applikationen und Nebenläufige Programmierung (Threads) auf Groovy Basis zur Verfügung. Und eine lebendige Community hat sich um diese dynamische Sprache gebildet. Ein Umstieg auf Scala oder Closure kommt somit für mich momentan nicht in Betracht.

Und mal ganz ehlich, wenn die Kinder fragen: “Papa was machst Du?”, klingt “ich programmiere Groovy” viel cooler als “Ich programmiere Scala”.

Links:
Groovy Usage Patterns by Dierk König

Aus meiner Sicht ist Groovy, die dynamische Sprache für die Java Virtual Machine, auf der großen Hype Kurve am Punkt der technischen Realität angekommen. Mit Scala und Clojure werden statt...

geschrieben von gklinkmann \\ tags: eclipse, Grails, groovy, Java, Open Source, Spring, Web, web2.0, XML

Groovy ist eine agile und dynamische Sprache für die Java Virtual Machine, die das Testen neben ihren vielen anderen Features extrem erleichtert. Da Groovy 100 % Byte Code kompatibel zu Java ist, lassen sich alle in dieser schönen Sprache geschriebenen Programme und Bibliotheken (und davon gibt es reichlich) nutzen. So ist es nicht verwunderlich, dass es in Groovy viele Möglichkeiten gibt, eine Webapplikation zu testen.

Ich habe mich für das Gespann Groovy und dem Testing Framework HtmlUnit entschieden, auf dem auch andere Open Source tools wie Canoo WebTest, JWebUnit, WebDriver, JSFUnit und Celerity aufsetzen. HtmlUnit unterstützt auch Javascript und hat damit wie auch HttpUnit einen Vorteil gegenüber den PHP Lösungen.

Mir gefällt die kurze und knappe Syntax von Groovy hervorragend und deswegen wird es jetzt auch Zeit sich den Beispiel Code für die Aufgabe anzuschauen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package de.koo.groovy.webtests
 
import junit.framework.TestCase
import com.gargoylesoftware.htmlunit.WebClient
import com.gargoylesoftware.htmlunit.html.*
 
public class GoogleSearchTest extends TestCase{
   def webClient
 
   void setUp() throws Exception{
      webClient = new WebClient()
   }
 
   void testSearch() throws Exception{
      def url='http://www.google.de'
 
      HtmlPage page = webClient.getPage(url)
 
      assert 'Google' == page.titleText
 
      def form = page.getFormByName('f')
      form.getInputByName('q').valueAttribute='http client examples'
      page = form.submit(form.getInputByName('btnG'))
 
      page.anchors.each { a ->
         if (a.classAttribute=='l') {
            println "<a href=\"$a.hrefAttribute\">$a.textContent</a>"   
         }
      }
 
      page.cleanUp()
   }
}

Da das Abfragen der Google Suche ein funktionaler Test ist, habe ich das Beispiel auch gleich als Groovy TestCase geschrieben. Eine der wunderbaren Eigenarten der Groovy Syntax ist, dass man bei gettern und settern jeweils das get und set weglassen kann, so dass es so aussieht als würde man direkt auf die Attribute zugreifen. Settern kann man den Wert sogar zuweisen (s. Zeile 22).
Ein zweites tolles Feature ist der Umgang mit Strings (Zeichenketten). Endlich kann man wieder (wie in PHP auch) Variablen innerhalb des Strings verwenden ohne ihn konkatenieren zu müssen (was Groovy für einen aber im Hintergrund tut).
Und drittens sind die Closures (wenn man sie mal verstanden hat – Zeile 25) ein wunderbares Sprachmittel, was der “Wirtssprache” Java noch fehlt.

Fazit:
Ein HTTP Client lässt sich mit Groovy extrem einfach und auf vieler Art und Weise realisieren. Mit der kurzen und prägnanten Syntax macht das Schreiben von funktionalen Tests für Webapplikationen mir sogar richtig Spaß. Hinzu kommen die Möglichkeit auch Webapps, die JavaScript benutzen, zu testen und die gute Einbindung in IDE’s (wie Eclipse, Idea oder NetBeans).

Es ist einfach groovy

Serie: Teil 1 – Pear Teil 2 – Zend Teil 3 – Java Teil 4 – Groovy Groovy ist eine agile und dynamische Sprache für die Java Virtual Machine, die...

geschrieben von gklinkmann \\ tags: Grails, groovy, Java, Web

Verzeichnisdienste, die LDAP (Lightweight Directory Access Protocol) unterstützen, werden immer mehr für die Authentifizierung in Applikationen eingesetzt.

Wie einfach es ist, mit der Java basierten Scriptsprache Groovy einen LDAP Server abzufragen, zeigt das Apache Directory Projekt mit seiner Bibliothek groovy-ldap.

Nach dem Download und dem Auspacken der Zip Datei, brauch man nur noch das jar Archiv in den Klassenpfad aufnehmen und dann kann es auch schon losgehen. Hier ein kleines Beispiel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

package de.koo.groovy.ldap
 
import org.apache.directory.groovyldap.LDAP
import org.apache.directory.groovyldap.SearchScope
 
public class LdapSearch{
  private LDAP conn;
 
  public LdapSearch () {
    conn =   LDAP.newInstance('ldap://ldap.uno.edu:389')
    assert (conn!=null)
    println("connected")
  }
 
  public void searchAny() {
    // alle Studenten
    try {
      conn.eachEntry (filter:'(sn=*)'
               ,base:'ou=Students,o=UNIVERSITY OF NEW ORLEANS,c=US') {student ->  
        println student.cn
      }    
    } catch (Exception e) {}
  }
 
  public void searchWithName(name) {
    def students=conn.search("(sn=${name})"
        ,'ou=Students,o=UNIVERSITY OF NEW ORLEANS,c=US'
        ,SearchScope.SUB)
    students.each {student ->        
      println student.cn
    }
  }
 
  public boolean isInLdap(dn) {
    // Existiert ein Eintrag
    return conn.exists(dn)
  }
 
  public void read(dn) {
    // Auslesen eines einzelnen Eintrags
    def student=conn.read(dn)
    println "${student.sn} (mail: ${student.mail})"
 
  }
 
  static void main(args) {
    LdapSearch ls=new LdapSearch()
    ls.searchAny()
    ls.searchWithName("Fu")
 
    def dn='cn=Erin Lee Sheehan,ou=Students,o=UNIVERSITY OF NEW ORLEANS,c=US'
    if (ls.isInLdap(dn)) ls.read(dn)
  }
}

Auf der Wiki Seite des Projekts und im Artikel von Groovy Zone befinden sich auch Beispiele zum Hinzufügen, Ändern und Löschen von LDAP Einträgen.
Eine Liste öffentlicher LDAP Server zum Testen gibt es auch.

Verzeichnisdienste, die LDAP (Lightweight Directory Access Protocol) unterstützen, werden immer mehr für die Authentifizierung in Applikationen eingesetzt. Wie einfach es ist, mit der Java basierten Scriptsprache Groovy einen LDAP Server...

geschrieben von gklinkmann \\ tags: groovy, ldap, net, Open Source