root/trunk/test/unit/dbnp/studycapturing/TemplateFieldTests.groovy @ 959

Revision 959, 6.3 KB (checked in by j.a.m.wesbeek@…, 4 years ago)

- set keyword expansion

  • Property svn:keywords set to Author Date Rev
Line 
1package dbnp.studycapturing
2
3import grails.test.*
4
5class TemplateFieldTests extends GrailsUnitTestCase {
6    def testEvent;
7    protected void setUp() {
8        super.setUp()
9
10        // Create the template itself
11        def testTemplate = new Template(
12                name: 'Template for testing relative date fields',
13                entity: dbnp.studycapturing.Event,
14                fields: [
15                    new TemplateField(
16                        name: 'testStartDate',
17                        type: TemplateFieldType.DATE
18                    ),
19                    new TemplateField(
20                        name: 'testRelTime',
21                        type: TemplateFieldType.RELTIME
22                    ),
23                    new TemplateField(
24                        name: 'testFile',
25                        type: TemplateFieldType.FILE
26                    )
27                ]
28            );
29
30                // Add static methods to Template
31                mockDomain( Template, [testTemplate] );
32                mockDomain( TemplateField, testTemplate.fields );
33
34        this.testEvent = new Event(
35                template: testTemplate,
36                startTime: 3600,
37                endTime: 7200
38        );
39
40                mockDomain( Event, [testEvent] );
41                this.testEvent.save();
42    }
43
44    protected void tearDown() {
45        super.tearDown()
46    }
47
48        void testInUse() {
49               
50                // All template fields in the testTemplate are in use (even in use on a object)
51                assert testEvent.template.fields.size() == 3;
52                testEvent.template.fields.each {
53                        if( it != null ) {
54                                assert it.inUse();
55                        }
56                }
57
58                // Create 2 template fields and use the first in a template, the second is not used
59                TemplateField t1 = new TemplateField(
60                                                                name: 'test1',
61                                                                type: TemplateFieldType.DATE,
62                                                                entity: dbnp.studycapturing.Event
63                                                        ).save();
64                TemplateField t2 = new TemplateField(
65                                                                name: 'test2',
66                                                                type: TemplateFieldType.DATE,
67                                                                entity: dbnp.studycapturing.Event
68                                                        ).save();
69
70                mockDomain( TemplateField, [t1, t2] );
71
72        def template1 = new Template(
73                name: 'Template for testing inUse',
74                entity: dbnp.studycapturing.Event,
75                fields: [
76                                        t1
77                ]
78            ).save();
79
80                assert t1.inUse();
81                assert !t2.inUse();
82
83        }
84
85    void testRelTimeFieldCreation() {
86        def RelTimeField = new TemplateField(
87                name: 'RelTime',
88                type: TemplateFieldType.RELTIME
89        );
90    }
91
92    void testRelTimeSetValue() {
93        // Check whether the field exists
94        assert this.testEvent.fieldExists( 'testRelTime' );
95
96        // See that it is not a domain field
97        assert !this.testEvent.isDomainField( 'testRelTime' );
98        println( this.testEvent.getStore( TemplateFieldType.RELTIME ) );
99       
100        this.testEvent.setFieldValue( 'testRelTime', 10 );
101        assert this.testEvent.getFieldValue( 'testRelTime' ) == 10;
102
103        this.testEvent.setFieldValue( 'testRelTime', 0 );
104        assert this.testEvent.getFieldValue( 'testRelTime' ) == 0;
105
106        this.testEvent.setFieldValue( 'testRelTime', -130 );
107        assert this.testEvent.getFieldValue( 'testRelTime' ) == -130;
108
109        // RelTime must be able to handle 100 years
110        long hundredYears = 100L * 365 * 24 * 3600;
111        this.testEvent.setFieldValue( 'testRelTime', hundredYears );
112        assert this.testEvent.getFieldValue( 'testRelTime' ) ==  hundredYears;
113    }
114
115    // Tests the parsing of a string for relative dates
116    // @see TemplateEntity.setFieldValue
117    //
118        // The relative date may be set as a string, using the following format
119        //
120        //    #w #d #h #m #s
121        //
122        // Where w = weeks, d = days, h = hours, m = minutes, s = seconds
123        //
124        // The spaces between the values are optional. Every timespan
125        // (w, d, h, m, s) must appear at most once. You can also omit
126        // timespans if needed or use a different order.
127        // Other characters are disregarded, allthough results may not
128        // always be as expected.
129        //
130        // If an incorrect format is used, which can't be parsed
131        // an IllegalFormatException is thrown.
132        //
133        // An empty span is treated as zero seconds.
134        //
135        // Examples:
136        // ---------
137        //    5d 3h 20m     // 5 days, 3 hours and 20 minutes
138        //    6h 2d         // 2 days, 6 hours
139        //    10m 200s      // 13 minutes, 20 seconds (200s == 3m + 20s)
140        //    5w4h15m       // 5 weeks, 4 hours, 15 minutes
141        //
142        //    16x14w10d     // Incorrect. 16x is disregarded, so the
143        //                  // result is 15 weeks, 3 days
144        //    13days        // Incorrect: days should be d, but this is
145        //                  // parsed as 13d, 0 seconds
146        //
147    void testRelTimeParser() {
148        def s = 1L;
149        def m = 60L * s;
150        def h = 60L * m;
151        def d = 24L * h;
152        def w = 7L * d;
153
154        this.testEvent.setFieldValue( 'testRelTime', '' );
155        assert this.testEvent.getFieldValue( 'testRelTime' ) == 0;
156
157        this.testEvent.setFieldValue( 'testRelTime', '   ' );
158        assert this.testEvent.getFieldValue( 'testRelTime' ) == 0;
159
160        this.testEvent.setFieldValue( 'testRelTime', '5d 3h 20m' );
161        assert this.testEvent.getFieldValue( 'testRelTime' ) == 5 * d + 3 * h + 20 * m;
162
163        this.testEvent.setFieldValue( 'testRelTime', '6h 2d' );
164        assert this.testEvent.getFieldValue( 'testRelTime' ) == 2 * d + 6 * h;
165
166        this.testEvent.setFieldValue( 'testRelTime', '10m 200s' );
167        assert this.testEvent.getFieldValue( 'testRelTime' ) == 10 * m  + 200 * s;
168
169        this.testEvent.setFieldValue( 'testRelTime', '5w4h15m' );
170        assert this.testEvent.getFieldValue( 'testRelTime' ) == 5 * w + 4 * h + 15 * m;
171
172        // Should parse correctly, allthough it is not completely correct
173        this.testEvent.setFieldValue( 'testRelTime', '16x14w10d' );
174        assert this.testEvent.getFieldValue( 'testRelTime' ) == 14 * w + 10 * d;
175
176        this.testEvent.setFieldValue( 'testRelTime', '13days' );
177        assert this.testEvent.getFieldValue( 'testRelTime' ) == 13 * d;
178
179        // Test whether an IllegalFormatException is thrown
180        try {
181            this.testEvent.setFieldValue( 'testRelTime', 'nonexistent relative date' );
182            fail();
183        } catch(IllegalArgumentException ex) {
184        } catch( Exception ex ) {
185            fail();
186        }
187
188    }
189}
Note: See TracBrowser for help on using the browser.