test/persistence/org/codehaus/groovy/grails/orm/hibernate/PersistentMethodTests.java

   1 package org.codehaus.groovy.grails.orm.hibernate;
   2
   3
   4 import groovy.lang.*;
   5 import org.codehaus.groovy.grails.commons.DefaultGrailsApplication;
   6 import org.codehaus.groovy.grails.commons.DomainClassArtefactHandler;
   7 import org.codehaus.groovy.grails.commons.GrailsApplication;
   8 import org.codehaus.groovy.grails.commons.GrailsDomainClass;
   9 import org.codehaus.groovy.grails.commons.spring.GrailsRuntimeConfigurator;
  10 import org.codehaus.groovy.grails.orm.hibernate.metaclass.FindByPersistentMethod;
  11 import org.codehaus.groovy.grails.support.MockApplicationContext;
  12 import org.codehaus.groovy.grails.plugins.PluginMetaManager;
  13 import org.codehaus.groovy.grails.plugins.DefaultPluginMetaManager;
  14 import org.codehaus.groovy.runtime.InvokerInvocationException;
  15 import org.hibernate.SessionFactory;
  16 import org.springframework.context.ApplicationContext;
  17 import org.springframework.context.support.StaticMessageSource;
  18 import org.springframework.mock.web.MockServletContext;
  19 import org.springframework.orm.hibernate3.SessionHolder;
  20 import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
  21 import org.springframework.transaction.support.TransactionSynchronizationManager;
  22 import org.springframework.validation.Errors;
  23 import org.springframework.core.io.Resource;
  24
  25 import java.util.*;
  26
  27 public class PersistentMethodTests extends AbstractDependencyInjectionSpringContextTests {
  28
  29     protected GrailsApplication grailsApplication = null;
  30     private GroovyClassLoader cl = new GroovyClassLoader();
  31     private SessionFactory sessionFactory;
  32     private org.hibernate.classic.Session hibSession;
  33
  34
  35     /**
  36      * @param grailsApplication The grailsApplication to set.
  37      */
  38     public void setGrailsApplication(GrailsApplication grailsApplication) {
  39         this.grailsApplication = grailsApplication;
  40     }
  41
  42
  43     protected void onTearDown() throws Exception
  44     {
  45         grailsApplication = null;
  46         cl = null;
  47         sessionFactory = null;
  48         hibSession = null;
  49         super.onTearDown();
  50     }
  51
  52     protected void onSetUp() throws Exception {
  53         cl.parseClass("dataSource {\n" +
  54                 "\t\t\tdbCreate = \"create-drop\" // one of 'create', 'create-drop','update'\n" +
  55                 "\t\t\turl = \"jdbc:hsqldb:mem:devDB\" \n" +
  56                 "\tpooled = false\n" +
  57                 "\tdriverClassName = \"org.hsqldb.jdbcDriver\"\n" +
  58                 "\tusername = \"sa\"\n" +
  59                 "\tpassword = \"\"\n" +
  60                 "}", "DataSource");
  61         Class groovyClass = cl.parseClass("public class PersistentMethodTests {\n" +
  62             "\t Long id \n" +
  63             "\t Long version \n" +
  64             "\t\n" +
  65             "\t String firstName \n" +
  66             "\t String lastName \n" +
  67             "\t Integer age\n" +
  68             "\t boolean active = true\n" +
  69             "\t\n" +
  70             "\tstatic constraints = {\n" +
  71             "\t\tfirstName(size:4..15)\n" +
  72             "\t\tlastName(nullable:false)\n" +
  73             "\t\tage(nullable:true)\n" +
  74             "\t}\n" +
  75             "}");
  76
  77         Class descendentClass = cl.parseClass(
  78             "public class PersistentMethodTestsDescendent extends PersistentMethodTests {\n" +
  79             "   String gender\n" +
  80             "   static constraints = {\n" +
  81             "       gender(blank:false)\n" +
  82             "   }\n" +
  83             "}"
  84         );
  85
  86         ExpandoMetaClass.enableGlobally();
  87
  88         grailsApplication = new DefaultGrailsApplication(new Class[]{groovyClass, descendentClass},cl);
  89
  90
  91         MockApplicationContext parent = new MockApplicationContext();
  92         parent.registerMockBean(GrailsApplication.APPLICATION_ID, grailsApplication);
  93         parent.registerMockBean("messageSource", new StaticMessageSource());
  94         parent.registerMockBean(PluginMetaManager.BEAN_ID, new DefaultPluginMetaManager(new Resource[0]));
  95         GrailsRuntimeConfigurator configurator = new GrailsRuntimeConfigurator(grailsApplication,parent);
  96         ApplicationContext appCtx = configurator.configure( new MockServletContext( ));
  97         this.sessionFactory = (SessionFactory)appCtx.getBean("sessionFactory");
  98
  99
 100
 101         if(!TransactionSynchronizationManager.hasResource(this.sessionFactory)) {
 102             this.hibSession = this.sessionFactory.openSession();
 103             TransactionSynchronizationManager.bindResource(this.sessionFactory, new SessionHolder(hibSession));
 104         }
 105
 106         super.onSetUp();
 107     }
 108
 109     protected String[] getConfigLocations() {
 110         return new String[] { "org/codehaus/groovy/grails/orm/hibernate/grails-persistent-method-tests.xml" };
 111     }
 112
 113     public void testMethodSignatures() {
 114
 115         FindByPersistentMethod findBy = new FindByPersistentMethod( grailsApplication,null,new GroovyClassLoader());
 116         assertTrue(findBy.isMethodMatch("findByFirstName"));
 117         assertTrue(findBy.isMethodMatch("findByFirstNameAndLastName"));
 118         assertFalse(findBy.isMethodMatch("rubbish"));
 119     }
 120
 121
 122     public void testSavePersistentMethod() {
 123         // init spring config
 124
 125
 126         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 127             "PersistentMethodTests");
 128
 129         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 130         obj.setProperty( "id", new Long(1) );
 131         obj.setProperty( "firstName", "fred" );
 132         obj.setProperty( "lastName", "flintstone" );
 133
 134         obj.invokeMethod("save", null);
 135
 136         // test ident method to retrieve value of id
 137         Object id = obj.invokeMethod("ident", null);
 138         assertNotNull(id);
 139         assertTrue(id instanceof Long);
 140     }
 141
 142     public void testValidatePersistentMethod() {
 143         // init spring config
 144
 145
 146         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 147             "PersistentMethodTests");
 148
 149         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 150         obj.setProperty( "id", new Long(1) );
 151         obj.setProperty( "firstName", "fr" );
 152         obj.setProperty( "lastName", "flintstone" );
 153
 154         obj.invokeMethod("validate", null);
 155
 156         Errors errors = (Errors)obj.getProperty("errors");
 157         assertNotNull(errors);
 158         assertTrue(errors.hasErrors());
 159     }
 160
 161     public void testValidateMethodWithFieldList() {
 162         // init spring config
 163
 164
 165         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 166             "PersistentMethodTests");
 167
 168         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 169         obj.setProperty( "id", new Long(1) );
 170         obj.setProperty( "firstName", "fr" );
 171         obj.setProperty( "lastName", "flintstone" );
 172
 173         Object result = obj.invokeMethod("validate", Arrays.asList(new Object[]{"age"}));
 174         assertEquals(Boolean.TRUE, result);
 175
 176         result = obj.invokeMethod("validate", Arrays.asList(new Object[]{"firstName"}));
 177         assertEquals(Boolean.FALSE, result);
 178     }
 179
 180     public void testValidatePersistentMethodOnDerivedClass() {
 181         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 182             "PersistentMethodTestsDescendent");
 183
 184         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 185         obj.setProperty( "id", new Long(1) );
 186         obj.setProperty( "gender", "female" );
 187
 188         obj.invokeMethod("validate", null);
 189
 190         Errors errors = (Errors)obj.getProperty("errors");
 191         assertNotNull(errors);
 192         assertTrue(errors.hasErrors());
 193
 194         // Check that nullable constraints on superclass are throwing errors
 195         obj = (GroovyObject)domainClass.newInstance();
 196         obj.setProperty( "id", new Long(1) );
 197         obj.setProperty( "gender", "female" );
 198         obj.setProperty( "firstName", "Marc" );
 199
 200         obj.invokeMethod("validate", null);
 201
 202         errors = (Errors)obj.getProperty("errors");
 203
 204         System.out.println("errors = " + errors);
 205
 206         assertNotNull(errors);
 207         assertTrue(errors.hasErrors());
 208         assertEquals(1, errors.getFieldErrorCount("lastName"));
 209     }
 210
 211     public void testFindPersistentMethods() {
 212         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 213             "PersistentMethodTests");
 214
 215         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 216         obj.setProperty( "id", new Long(1) );
 217         obj.setProperty( "firstName", "fred" );
 218         obj.setProperty( "lastName", "flintstone" );
 219         obj.setProperty( "age", new Integer(45));
 220
 221         obj.invokeMethod("save", null);
 222
 223         // test query without a method
 224         try {
 225             obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] {} );
 226             fail("Should have thrown an exception");
 227         }
 228         catch(Exception e) {
 229             //expected
 230         }
 231
 232         // test invalid query
 233         try {
 234             obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] {"from AnotherClass"} );
 235             fail("Should have thrown grails query exception");
 236         }
 237         catch(GroovyRuntimeException gqe) {
 238             //expected
 239         }
 240
 241         // test find with HQL query
 242         List params = new ArrayList();
 243         params.add("fre%");
 244         Object returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests where firstName like ?", params });
 245         assertNotNull(returnValue);
 246
 247         // test find with HQL query
 248         params.clear();
 249         params.add("bre%");
 250         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests where firstName like ?", params });
 251         assertNull(returnValue);
 252
 253         // test find with HQL query and array of params
 254         Object[] paramsArray = new Object[] {"fre%"};
 255         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests where firstName like ?", paramsArray });
 256         assertNotNull(returnValue);
 257
 258         // test with a GString argument
 259         Binding b = new Binding();
 260         b.setVariable("test","fre%");
 261         b.setVariable("test1", "flint%");
 262         GString gs = (GString)new GroovyShell(b).evaluate("\"$test\"");
 263         GString gs1 = (GString)new GroovyShell(b).evaluate("\"$test1\"");
 264         params.clear();
 265
 266         params.add(gs);
 267         params.add(gs1);
 268         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests where firstName like ? and lastName like ?", params });
 269         assertNotNull(returnValue);
 270
 271         // test named params with GString parameters
 272         Map namedArgs = new HashMap();
 273         namedArgs.put("name", gs);
 274         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests where firstName like :name", namedArgs });
 275         assertNotNull(returnValue);
 276
 277         // test with a GString query
 278         b.setVariable("className","PersistentMethodTests");
 279         gs = (GString)new GroovyShell(b).evaluate("\"from ${className} where firstName like ? and lastName like ?\"");
 280
 281         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { gs, params });
 282         assertNotNull(returnValue);
 283
 284         // test find with query and named params
 285         namedArgs.clear();
 286         namedArgs.put( "name", "fred" );
 287         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests as p where p.firstName = :name", namedArgs });
 288         assertNotNull(returnValue);
 289
 290         // test find with query and named list params
 291         namedArgs.clear();
 292         List namesList = new ArrayList();
 293         namesList.add("fred");
 294         namesList.add("anothername");
 295         namedArgs.put( "namesList", namesList );
 296         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs });
 297         assertNotNull(returnValue);
 298
 299         // test find with query and named array params
 300         namedArgs.clear();
 301         namedArgs.put( "namesList", new Object[] {"fred","anothername"} );
 302         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs });
 303         assertNotNull(returnValue);
 304
 305         // test query with wrong named parameter
 306         try {
 307                 namedArgs.clear();
 308                 namedArgs.put(new Long(1), "fred");
 309             obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { "from PersistentMethodTests as p where p.firstName = :name", namedArgs});
 310             // new Long(1) is not valid name for named param, so exception should be thrown
 311             fail("Should have thrown grails query exception");
 312         }
 313         catch(GroovyRuntimeException gqe) {
 314             //expected
 315         }
 316
 317         // test find by example
 318         GroovyObject example = (GroovyObject)domainClass.newInstance();
 319         example.setProperty( "firstName", "fred" );
 320         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { example });
 321         assertNotNull(returnValue);
 322
 323         // test find by wrong example
 324         example = (GroovyObject)domainClass.newInstance();
 325         example.setProperty( "firstName", "someone" );
 326         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { example });
 327         assertNull(returnValue);
 328
 329         // test query with wrong argument type
 330         try {
 331             obj.getMetaClass().invokeStaticMethod(obj, "find", new Object[] { new Date()});
 332             fail("Should have thrown an exception");
 333         }
 334         catch(Exception e) {
 335             //expected
 336         }
 337     }
 338
 339     public void testFindByPersistentMethods() {
 340         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 341             "PersistentMethodTests");
 342
 343         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 344         obj.setProperty( "id", new Long(1) );
 345         obj.setProperty( "firstName", "fred" );
 346         obj.setProperty( "lastName", "flintstone" );
 347         obj.setProperty( "age", new Integer(45));
 348
 349         obj.invokeMethod("save", null);
 350
 351         GroovyObject obj2 = (GroovyObject)domainClass.newInstance();
 352         obj2.setProperty( "id", new Long(2) );
 353         obj2.setProperty( "firstName", "wilma" );
 354         obj2.setProperty( "lastName", "flintstone" );
 355         obj2.setProperty( "age", new Integer(42));
 356         obj2.invokeMethod("save", null);
 357
 358         GroovyObject obj3 = (GroovyObject)domainClass.newInstance();
 359         obj3.setProperty( "id", new Long(3) );
 360         obj3.setProperty( "firstName", "dino" );
 361         obj3.setProperty( "lastName", "dinosaur" );
 362         obj3.setProperty( "age", new Integer(12));
 363         obj3.invokeMethod("save", null);
 364
 365         Object returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAllByFirstName", new Object[] { "fred", new Integer(10) });
 366         assertNotNull(returnValue);
 367         assertTrue(returnValue instanceof List);
 368
 369         List returnList = (List)returnValue;
 370         assertEquals(1, returnList.size());
 371
 372         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAllByFirstNameAndLastName", new Object[] { "fred", "flintstone" });
 373         assertNotNull(returnValue);
 374         assertTrue(returnValue instanceof List);
 375
 376         returnList = (List)returnValue;
 377         assertEquals(1, returnList.size());
 378
 379         /*returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findByFirstNameOrLastName", new Object[] { "fred", "flintstone" });
 380           assertNotNull(returnValue);
 381           assertTrue(returnValue instanceof List);
 382
 383           returnList = (List)returnValue;
 384           assertEquals(2, returnList.size());*/
 385
 386         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByFirstNameNotEqual", new Object[] { "fred" });
 387         assertEquals(2, returnList.size());
 388         obj = (GroovyObject)returnList.get(0);
 389         obj2 = (GroovyObject)returnList.get(1);
 390         assertFalse("fred".equals( obj.getProperty("firstName")));
 391         assertFalse("fred".equals( obj2.getProperty("firstName")));
 392
 393         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByAgeLessThan", new Object[] { new Integer(20) });
 394         assertEquals(1, returnList.size());
 395         obj = (GroovyObject)returnList.get(0);
 396         assertEquals("dino", obj.getProperty("firstName"));
 397
 398         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByAgeLessThanEquals", new Object[] { new Integer(12) });
 399         assertEquals(1, returnList.size());
 400
 401         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByAgeGreaterThan", new Object[] { new Integer(20) });
 402         assertEquals(2, returnList.size());
 403
 404         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByAgeGreaterThanEquals", new Object[] { new Integer(42) });
 405         assertEquals(2, returnList.size());
 406
 407         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByAgeGreaterThanAndLastName", new Object[] { new Integer(20), "flintstone" });
 408         assertEquals(2, returnList.size());
 409
 410         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByLastNameLike", new Object[] { "flint%" });
 411         assertEquals(2, returnList.size());
 412
 413         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByLastNameIlike", new Object[] { "FLINT%" });
 414         assertEquals(2, returnList.size());
 415
 416         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByAgeBetween", new Object[] { new Integer(10), new Integer(43) });
 417         assertEquals(2, returnList.size());
 418
 419         // test primitives
 420         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllByActive", new Object[] { Boolean.TRUE });
 421         assertEquals(3, returnList.size());
 422
 423         Map queryMap = new HashMap();
 424         queryMap.put("firstName", "wilma");
 425         queryMap.put("lastName", "flintstone");
 426         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findWhere", new Object[] { queryMap });
 427         assertNotNull(returnValue);
 428
 429         queryMap = new HashMap();
 430         queryMap.put("lastName", "flintstone");
 431         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllWhere", new Object[] { queryMap });
 432         assertEquals(2, returnList.size());
 433
 434         // now lets test several automatic type conversions
 435         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllById", new Object[] { "1" });
 436         assertEquals(1, returnList.size());
 437
 438         returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllById", new Object[] { new Integer("1") });
 439         assertEquals(1, returnList.size());
 440
 441         // and case when automatic conversion cannot be applied
 442          try {
 443             returnList = (List)obj.getMetaClass().invokeStaticMethod(obj, "findAllById", new Object[] { "1.1" });
 444         } catch(MissingMethodException iae) {
 445                 // great!
 446          }
 447                 catch(InvokerInvocationException iie) {
 448                         // great!
 449                 }
 450
 451
 452         // and the wrong number of arguments!
 453         try {
 454             obj.getMetaClass().invokeStaticMethod(obj, "findAllByAgeBetween", new Object[] { new Integer(10) });
 455             fail("Should have thrown an exception for invalid argument count");
 456         }
 457         catch(MissingMethodException mme) {
 458             //great!
 459         }
 460         catch(InvokerInvocationException iie) {
 461             // great!
 462         }
 463
 464     }
 465
 466     public void testGetPersistentMethod() {
 467         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 468             "PersistentMethodTests");
 469
 470         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 471         obj.setProperty( "id", new Long(1) );
 472         obj.setProperty( "firstName", "fred" );
 473         obj.setProperty( "lastName", "flintstone" );
 474
 475         obj.invokeMethod("save", null);
 476
 477         GroovyObject obj2 = (GroovyObject)domainClass.newInstance();
 478         obj2.setProperty( "id", new Long(2) );
 479         obj2.setProperty( "firstName", "wilma" );
 480         obj2.setProperty( "lastName", "flintstone" );
 481
 482         obj2.invokeMethod("save", null);
 483
 484         // get wilma by id
 485         Object returnValue = obj.getMetaClass().invokeStaticMethod(obj, "get", new Object[] { new Long(2) });
 486         assertNotNull(returnValue);
 487         assertEquals(returnValue.getClass(),domainClass.getClazz());
 488     }
 489
 490     public void testGetAllPersistentMethod() {
 491         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 492                 "PersistentMethodTests");
 493
 494         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 495         obj.setProperty( "id", new Long(1) );
 496         obj.setProperty( "firstName", "fred" );
 497         obj.setProperty( "lastName", "flintstone" );
 498
 499         obj.invokeMethod("save", null);
 500
 501         GroovyObject obj2 = (GroovyObject)domainClass.newInstance();
 502         obj2.setProperty( "id", new Long(2) );
 503         obj2.setProperty( "firstName", "wilma" );
 504         obj2.setProperty( "lastName", "flintstone" );
 505
 506         obj2.invokeMethod("save", null);
 507
 508         GroovyObject obj3 = (GroovyObject)domainClass.newInstance();
 509         obj3.setProperty( "id", new Long(3) );
 510         obj3.setProperty( "firstName", "john" );
 511         obj3.setProperty( "lastName", "smith" );
 512
 513         obj3.invokeMethod("save", null);
 514
 515         // get wilma and fred by ids passed as method arguments
 516         List args = new ArrayList();
 517         args.add(new Long(2));
 518         args.add(new Long(1));
 519
 520         Object returnValue = obj.getMetaClass().invokeStaticMethod(obj, "getAll", new Object[] { args });
 521         assertNotNull(returnValue);
 522         assertEquals(ArrayList.class,returnValue.getClass());
 523         List returnList = (List)returnValue;
 524         assertEquals(2, returnList.size());
 525         GroovyObject result = (GroovyObject)returnList.get(0);
 526         GroovyObject result1 = (GroovyObject)returnList.get(1);
 527         assertEquals(new Long(2), result.getProperty("id"));
 528         assertEquals(new Long(1), result1.getProperty("id"));
 529
 530         // get john and fred by ids passed in list
 531         List param = new ArrayList();
 532         param.add( new Long(3) );
 533         param.add( new Long(1) );
 534         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "getAll", new Object[] { param });
 535         assertNotNull(returnValue);
 536         assertEquals(ArrayList.class,returnValue.getClass());
 537         returnList = (List)returnValue;
 538         assertEquals(2, returnList.size());
 539         result = (GroovyObject)returnList.get(0);
 540         result1 = (GroovyObject)returnList.get(1);
 541         assertEquals(new Long(3), result.getProperty("id"));
 542         assertEquals(new Long(1), result1.getProperty("id"));
 543
 544         // when called without arguments should return a list of all objects
 545         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "getAll", new Object[] {});
 546         assertNotNull(returnValue);
 547         assertEquals(ArrayList.class,returnValue.getClass());
 548         returnList = (List)returnValue;
 549         assertEquals(3, returnList.size());
 550
 551         args = new ArrayList();
 552         args.add(new Long(5));
 553         args.add(new Long(2));
 554         args.add(new Long(7));
 555         args.add(new Long(1));
 556         // if there are no object with specified id - should return null on corresponding places
 557         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "getAll", new Object[] {args});
 558         assertNotNull(returnValue);
 559         assertEquals(ArrayList.class,returnValue.getClass());
 560         returnList = (List)returnValue;
 561         assertEquals(4, returnList.size());
 562         assertNull(returnList.get(0));
 563         assertNull(returnList.get(2));
 564     }
 565
 566     public void testDiscardMethod() {
 567         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 568             "PersistentMethodTests");
 569
 570         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 571         obj.setProperty( "id", new Long(1) );
 572         obj.setProperty( "firstName", "fred" );
 573         obj.setProperty( "lastName", "flintstone" );
 574
 575         obj.invokeMethod("save", null);
 576
 577         assertTrue(hibSession.contains(obj));
 578         obj.invokeMethod("discard", null);
 579         assertFalse(hibSession.contains(obj));
 580
 581     }
 582     public void testFindAllPersistentMethod() {
 583         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 584             "PersistentMethodTests");
 585
 586         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 587         obj.setProperty( "id", new Long(1) );
 588         obj.setProperty( "firstName", "fred" );
 589         obj.setProperty( "lastName", "flintstone" );
 590
 591         obj.invokeMethod("save", null);
 592
 593         GroovyObject obj2 = (GroovyObject)domainClass.newInstance();
 594         obj2.setProperty( "id", new Long(2) );
 595         obj2.setProperty( "firstName", "wilma" );
 596         obj2.setProperty( "lastName", "flintstone" );
 597
 598         obj2.invokeMethod("save", null);
 599
 600         // test invalid query
 601         try {
 602             obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] {"from AnotherClass"} );
 603             fail("Should have thrown grails query exception");
 604         }
 605         catch(GroovyRuntimeException gqe) {
 606             //expected
 607         }
 608
 609         // test find with a query
 610         Object returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests" });
 611         assertNotNull(returnValue);
 612         assertEquals(ArrayList.class,returnValue.getClass());
 613         List listResult = (List)returnValue;
 614         assertEquals(2, listResult.size());
 615
 616         // test without a query (should return all instances)
 617         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] {} );
 618         assertNotNull(returnValue);
 619         assertEquals(ArrayList.class, returnValue.getClass());
 620         listResult = (List)returnValue;
 621         assertEquals(2, listResult.size());
 622
 623
 624         // test find with query and args
 625         List args = new ArrayList();
 626         args.add( "wilma" );
 627         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName = ?", args });
 628         assertNotNull(returnValue);
 629         assertEquals(ArrayList.class,returnValue.getClass());
 630         listResult = (List)returnValue;
 631         assertEquals(1, listResult.size());
 632
 633         // test find with query and array argument
 634         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName = ?", new Object[] {"wilma"} });
 635         assertNotNull(returnValue);
 636         assertEquals(ArrayList.class,returnValue.getClass());
 637         listResult = (List)returnValue;
 638         assertEquals(1, listResult.size());
 639
 640         // test find with query and named params
 641         Map namedArgs = new HashMap();
 642         namedArgs.put( "name", "wilma" );
 643         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName = :name", namedArgs });
 644         assertNotNull(returnValue);
 645         assertEquals(ArrayList.class,returnValue.getClass());
 646         listResult = (List)returnValue;
 647         assertEquals(1, listResult.size());
 648
 649         // test with a GString argument
 650         Binding b = new Binding();
 651         b.setVariable("test","fre%");
 652         b.setVariable("test1", "flint%");
 653         GString gs = (GString)new GroovyShell(b).evaluate("\"$test\"");
 654         GString gs1 = (GString)new GroovyShell(b).evaluate("\"$test1\"");
 655         args.clear();
 656         args.add(gs);
 657         args.add(gs1);
 658         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests where firstName like ? and lastName like ?", args });
 659         assertNotNull(returnValue);
 660         assertTrue(returnValue instanceof List);
 661         listResult = (List)returnValue;
 662         assertEquals(1, listResult.size());
 663
 664         // GStrings in named params
 665         namedArgs.clear();
 666         namedArgs.put("firstName", gs);
 667         namedArgs.put("lastName", gs1);
 668         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests where firstName like :firstName and lastName like :lastName", namedArgs });
 669         assertNotNull(returnValue);
 670         assertTrue(returnValue instanceof List);
 671         listResult = (List)returnValue;
 672         assertEquals(1, listResult.size());
 673
 674         // test with a GString query
 675         b.setVariable("className","PersistentMethodTests");
 676         gs = (GString)new GroovyShell(b).evaluate("\"from ${className} where firstName like ? and lastName like ?\"");
 677         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { gs, args });
 678         assertNotNull(returnValue);
 679
 680
 681         // test find with query and named list params
 682         namedArgs.clear();
 683         List namesList = new ArrayList();
 684         namesList.add("wilma");
 685         namesList.add("fred");
 686         namedArgs.put( "namesList", namesList );
 687         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs });
 688         assertNotNull(returnValue);
 689         assertEquals(ArrayList.class,returnValue.getClass());
 690         listResult = (List)returnValue;
 691         assertEquals(2, listResult.size());
 692
 693         // test find with query and named array params
 694         namedArgs.clear();
 695         namedArgs.put( "namesList", new Object[] {"wilma","fred"} );
 696         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs });
 697         assertNotNull(returnValue);
 698         assertEquals(ArrayList.class,returnValue.getClass());
 699         listResult = (List)returnValue;
 700         assertEquals(2, listResult.size());
 701
 702         // test find with max result
 703         namedArgs.clear();
 704         namedArgs.put( "namesList", new Object[] {"wilma","fred"} );
 705         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs, new Integer(1) });
 706         assertNotNull(returnValue);
 707         assertEquals(ArrayList.class,returnValue.getClass());
 708         listResult = (List)returnValue;
 709         assertEquals(1, listResult.size());
 710
 711         // test find with max result without params
 712         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p", new Integer(1) });
 713         assertNotNull(returnValue);
 714         assertEquals(ArrayList.class,returnValue.getClass());
 715         listResult = (List)returnValue;
 716         assertEquals(1, listResult.size());
 717
 718         // test with max result in Map
 719         Map resultsMap = new HashMap();
 720         resultsMap.put("max", new Integer(1));
 721         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs, resultsMap });
 722         assertNotNull(returnValue);
 723         assertEquals(ArrayList.class,returnValue.getClass());
 724         listResult = (List)returnValue;
 725         assertEquals(1, listResult.size());
 726         // test with 'max' param in named parameter map - for backward compatibility
 727         namedArgs.put("max", new Integer(1));
 728         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs });
 729         assertNotNull(returnValue);
 730         assertEquals(ArrayList.class,returnValue.getClass());
 731         listResult = (List)returnValue;
 732         assertEquals(1, listResult.size());
 733
 734         // test find with offset
 735         namedArgs.clear();
 736         namedArgs.put( "namesList", new Object[] {"wilma","fred"} );
 737         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs, new Integer(2), new Integer(1) });
 738         assertNotNull(returnValue);
 739         assertEquals(ArrayList.class,returnValue.getClass());
 740         listResult = (List)returnValue;
 741         // max results = 2 and offset = 1 => 1 of 2 result expected
 742         assertEquals(1, listResult.size());
 743
 744         // test find with offset without params
 745         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p", new Integer(2), new Integer(1) });
 746         assertNotNull(returnValue);
 747         assertEquals(ArrayList.class,returnValue.getClass());
 748         listResult = (List)returnValue;
 749         // max results = 2 and offset = 1 => 1 of 2 result expected
 750         assertEquals(1, listResult.size());
 751
 752         // test with offset in Map
 753         resultsMap = new HashMap();
 754         resultsMap.put("offset", new Integer(1));
 755         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs, resultsMap });
 756         assertNotNull(returnValue);
 757         assertEquals(ArrayList.class,returnValue.getClass());
 758         listResult = (List)returnValue;
 759         // max results not specified and offset = 1 => 1 of 2 result expected
 760         assertEquals(1, listResult.size());
 761
 762         // test with 'offset' param in named parameter map - for backward compatibility
 763         namedArgs.put("offset", new Integer(1));
 764         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName in (:namesList)", namedArgs });
 765         assertNotNull(returnValue);
 766         assertEquals(ArrayList.class,returnValue.getClass());
 767         listResult = (List)returnValue;
 768         assertEquals(1, listResult.size());
 769
 770         // test query with wrong named parameter
 771         try {
 772                 namedArgs.clear();
 773                 namedArgs.put(new Long(1), "wilma");
 774             obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { "from PersistentMethodTests as p where p.firstName = :name", namedArgs});
 775             // new Long(1) is not valid name for named param, so exception should be thrown
 776             fail("Should have thrown grails query exception");
 777         }
 778         catch(GroovyRuntimeException gqe) {
 779             //expected
 780         }
 781
 782         // test find by example
 783         GroovyObject example = (GroovyObject)domainClass.newInstance();
 784         example.setProperty( "firstName", "fred" );
 785         returnValue = obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { example });
 786         assertNotNull(returnValue);
 787         assertEquals(ArrayList.class,returnValue.getClass());
 788         listResult = (List)returnValue;
 789         assertEquals(1, listResult.size());
 790
 791         // test query with wrong argument type
 792         try {
 793             obj.getMetaClass().invokeStaticMethod(obj, "findAll", new Object[] { new Date()});
 794             fail("Should have thrown an exception");
 795         }
 796         catch(Exception e) {
 797             //expected
 798         }
 799     }
 800
 801     public void testListPersistentMethods() {
 802         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 803             "PersistentMethodTests");
 804
 805         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 806         obj.setProperty( "id", new Long(1) );
 807         obj.setProperty( "firstName", "fred" );
 808         obj.setProperty( "lastName", "flintstone" );
 809
 810         obj.invokeMethod("save", null);
 811
 812         GroovyObject obj2 = (GroovyObject)domainClass.newInstance();
 813         obj2.setProperty( "id", new Long(2) );
 814         obj2.setProperty( "firstName", "wilma" );
 815         obj2.setProperty( "lastName", "flintstone" );
 816
 817         obj2.invokeMethod("save", null);
 818
 819         GroovyObject obj3 = (GroovyObject)domainClass.newInstance();
 820         obj3.setProperty( "id", new Long(3) );
 821         obj3.setProperty( "firstName", "dino" );
 822         obj3.setProperty( "lastName", "dinosaur" );
 823
 824         obj3.invokeMethod("save", null);
 825
 826         // test plain list
 827         Object returnValue = obj.getMetaClass().invokeStaticMethod(obj,"list", null);
 828         assertNotNull(returnValue);
 829         assertTrue(returnValue instanceof List);
 830
 831         List returnList = (List)returnValue;
 832         assertEquals(3, returnList.size());
 833         // test list with max value
 834         Map argsMap = new HashMap();
 835         argsMap.put("max",new Integer(1));
 836         returnValue = obj.getMetaClass().invokeStaticMethod(obj,"list", new Object[]{ argsMap });
 837         assertNotNull(returnValue);
 838         assertTrue(returnValue instanceof List);
 839
 840         returnList = (List)returnValue;
 841         assertEquals(1, returnList.size());
 842
 843         // test list with order by desc
 844         argsMap = new HashMap();
 845         argsMap.put("order", "desc");
 846         argsMap.put("sort", "firstName");
 847
 848         returnValue = obj.getMetaClass().invokeStaticMethod(obj,
 849         "listOrderByFirstName", new Object[] { argsMap });
 850         assertNotNull(returnValue);
 851         assertTrue(returnValue instanceof List);
 852
 853         returnList = (List) returnValue;
 854         obj = (GroovyObject) returnList.get(0);
 855         obj2 = (GroovyObject) returnList.get(1);
 856
 857         assertEquals("wilma", obj.getProperty("firstName"));
 858         assertEquals("fred", obj2.getProperty("firstName"));
 859
 860
 861     }
 862
 863
 864     public void testExecuteQueryMethod() {
 865         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 866         "PersistentMethodTests");
 867
 868         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 869         obj.setProperty( "id", new Long(1) );
 870         obj.setProperty( "firstName", "fred" );
 871         obj.setProperty( "lastName", "flintstone" );
 872         obj.invokeMethod("save", null);
 873
 874         obj = (GroovyObject)domainClass.newInstance();
 875         obj.setProperty( "id", new Long(2) );
 876         obj.setProperty( "firstName", "wilma" );
 877         obj.setProperty( "lastName", "flintstone" );
 878         obj.invokeMethod("save", null);
 879
 880         MetaClass domain = obj.getMetaClass();
 881
 882         // test query without a method
 883         try {
 884             domain.invokeStaticMethod(obj, "executeQuery", new Object[] {} );
 885             fail("Should have thrown an exception");
 886         }
 887         catch(Exception e) {
 888             //expected
 889         }
 890
 891         // test query with too many params
 892         try {
 893             domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "query", "param", new HashMap(), "4" } );
 894             fail("Should have thrown an exception");
 895         }
 896         catch(Exception e) {
 897             //expected
 898         }
 899
 900         // test query with wrong third param type (must be Map)
 901         try {
 902             domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "query", "param", "wrong third param" } );
 903             fail("Should have thrown an exception");
 904         }
 905         catch(Exception e) {
 906             //expected
 907         }
 908
 909         // test find with a query
 910         Object returnValue = domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p" });
 911         assertNotNull( returnValue );
 912         assertEquals( ArrayList.class, returnValue.getClass() );
 913         List listResult = (List)returnValue;
 914         assertEquals(2, listResult.size());
 915
 916         // test find with a query and paginate params
 917         Map paginateParams = new HashMap();
 918         paginateParams.put( "max", new Integer(1) );
 919         listResult = (List)obj.getMetaClass().invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p order by p.firstName", paginateParams });
 920         assertEquals(1, listResult.size());
 921         assertEquals("fred", ((GroovyObject)listResult.get(0)).getProperty("firstName"));
 922         paginateParams.put( "offset", new Integer(1) );
 923         listResult = (List)obj.getMetaClass().invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p order by p.firstName", paginateParams });
 924         assertEquals(1, listResult.size());
 925         assertEquals("wilma", ((GroovyObject)listResult.get(0)).getProperty("firstName"));
 926
 927         // test find with query and args
 928         List args = new ArrayList();
 929         args.add( "wilma" );
 930         listResult = (List) domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p where p.firstName = ?", args });
 931         assertEquals(1, listResult.size());
 932
 933         // test find with query and arg
 934         listResult = (List)domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p where p.firstName = ?", "wilma" });
 935         assertEquals(1, listResult.size());
 936
 937         // test find with query and named params
 938         Map namedArgs = new HashMap();
 939         namedArgs.put( "name", "wilma" );
 940         listResult = (List)domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p where p.firstName = :name", namedArgs });
 941         assertEquals(1, listResult.size());
 942
 943         // test find with query and named list params
 944         namedArgs.clear();
 945         List namesList = new ArrayList();
 946         namesList.add("wilma");
 947         namesList.add("fred");
 948         namedArgs.put( "namesList", namesList );
 949         listResult = (List)domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p where p.firstName in (:namesList) order by p.firstName", namedArgs });
 950         assertEquals(2, listResult.size());
 951         // test find with a query and named list params and paginate params
 952         paginateParams.clear();
 953         paginateParams.put( "max", new Integer(1) );
 954         listResult = (List)domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p where p.firstName in (:namesList) order by p.firstName", namedArgs, paginateParams });
 955         assertEquals(1, listResult.size());
 956         assertEquals("fred", ((GroovyObject)listResult.get(0)).getProperty("firstName"));
 957         paginateParams.put( "offset", new Integer(1) );
 958         listResult = (List)domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p where p.firstName in (:namesList) order by p.firstName", namedArgs, paginateParams });
 959         assertEquals(1, listResult.size());
 960         assertEquals("wilma", ((GroovyObject)listResult.get(0)).getProperty("firstName"));
 961
 962         // test query with wrong named parameter
 963         try {
 964                 namedArgs.clear();
 965                 namedArgs.put(new Long(1), "wilma");
 966             domain.invokeStaticMethod(obj, "executeQuery", new Object[] { "select distinct p from PersistentMethodTests as p where p.firstName = :name", namedArgs});
 967             // new Long(1) is not valid name for named param, so exception should be thrown
 968             fail("Should have thrown grails query exception");
 969         }
 970         catch(GroovyRuntimeException gqe) {
 971             //expected
 972         }
 973     }
 974
 975     public void testDMLOperation() throws Exception {
 976         GrailsDomainClass domainClass = (GrailsDomainClass) this.grailsApplication.getArtefact(DomainClassArtefactHandler.TYPE,
 977             "PersistentMethodTests");
 978
 979         GroovyObject obj = (GroovyObject)domainClass.newInstance();
 980         obj.setProperty( "id", new Long(1) );
 981         obj.setProperty( "firstName", "fred" );
 982         obj.setProperty( "lastName", "flintstone" );
 983
 984         obj.invokeMethod("save", null);
 985
 986         GroovyObject obj2 = (GroovyObject)domainClass.newInstance();
 987         obj2.setProperty( "id", new Long(2) );
 988         obj2.setProperty( "firstName", "wilma" );
 989         obj2.setProperty( "lastName", "flintstone" );
 990
 991         obj2.invokeMethod("save", null);
 992
 993         GroovyObject obj3 = (GroovyObject)domainClass.newInstance();
 994         obj3.setProperty( "id", new Long(3) );
 995         obj3.setProperty( "firstName", "dino" );
 996         obj3.setProperty( "lastName", "dinosaur" );
 997
 998         obj3.invokeMethod("save", null);
 999
1000         Object returnValue = obj.getMetaClass().invokeStaticMethod(obj,"list", null);
1001         assertNotNull(returnValue);
1002         assertTrue(returnValue instanceof List);
1003
1004         List returnList = (List)returnValue;
1005         assertEquals(3, returnList.size());
1006
1007         obj.getMetaClass().invokeStaticMethod(obj,"executeUpdate", new Object[]{"delete PersistentMethodTests"});
1008
1009         returnValue = obj.getMetaClass().invokeStaticMethod(obj,"list", null);
1010         assertNotNull(returnValue);
1011         assertTrue(returnValue instanceof List);
1012
1013         returnList = (List)returnValue;
1014         assertEquals(0, returnList.size());
1015
1016
1017
1018     }
1019
1020 }