← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to gis/dhis-gis-geostat/mfbase/mapfish/tests/core/Protocol/test_MergeFilterDecorator.html

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
gis/dhis-gis-geostat/mfbase/mapfish/tests/core/Protocol/test_MergeFilterDecorator.html
 
1
<!DOCTYPE html>
 
2
<html debug="true">
 
3
  <head>
 
4
    <link rel="stylesheet" type="text/css" href="../../../ext/resources/css/ext-all.css" />
 
5
 
 
6
    <script type="text/javascript" src="../../../../openlayers/lib/Firebug/firebug.js"></script>
 
7
    <script type="text/javascript" src="../../../../openlayers/lib/OpenLayers.js"></script>
 
8
 
 
9
    <script type="text/javascript" src="../../../../ext/adapter/ext/ext-base.js"></script>
 
10
    <script type="text/javascript" src="../../../../ext/ext-all-debug.js"></script>
 
11
 
 
12
    <script type="text/javascript">
 
13
      // Because of a bug in Firefox 2 we need to specify the MapFish base path.
 
14
      // See https://bugzilla.mozilla.org/show_bug.cgi?id=351282
 
15
      var gMfLocation = "../../../../mapfish/";
 
16
    </script>
 
17
    <script type="text/javascript" src="../../../../mapfish/MapFish.js"></script>
 
18
 
 
19
    <script type="text/javascript"><!--
 
20
    function test_MergeFilterDecorator_initialize(t) {
 
21
        t.plan(1);
 
22
 
 
23
        // setup
 
24
       
 
25
        var decorator;
 
26
 
 
27
        decorator = new mapfish.Protocol.MergeFilterDecorator({
 
28
            protocol: new OpenLayers.Protocol()
 
29
        });
 
30
 
 
31
        // 1 test
 
32
        t.eq(decorator.searchers, [],
 
33
             "initialize correctly sets searchers property");
 
34
    }
 
35
    function test_MergeFilterDecorator_register(t) {
 
36
        t.plan(2);
 
37
 
 
38
        // setup
 
39
       
 
40
        var decorator, searcher;
 
41
 
 
42
        decorator = new mapfish.Protocol.MergeFilterDecorator({
 
43
            protocol: new OpenLayers.Protocol()
 
44
        });
 
45
 
 
46
        // 2 tests
 
47
        searcher = new mapfish.Searcher({
 
48
            protocol: decorator
 
49
        });
 
50
        decorator.register(searcher);
 
51
        t.eq(decorator.searchers.length, 1,
 
52
             "register registers one searcher");
 
53
        t.ok(decorator.searchers[0] == searcher,
 
54
             "register registers expected searcher");
 
55
    }
 
56
    function test_MergeFilterDecorator_toFilter(t) {
 
57
        t.plan(15);
 
58
 
 
59
        // setup
 
60
 
 
61
        var decorator, filter0, filter1, obj;
 
62
 
 
63
        decorator = new mapfish.Protocol.MergeFilterDecorator({
 
64
            protocol: new OpenLayers.Protocol()
 
65
        });
 
66
 
 
67
        // 1 test
 
68
        filter0 = decorator.toFilter();
 
69
        t.eq(filter0, undefined,
 
70
             "toFilter returns undefined if it is not passed args");
 
71
 
 
72
        // 5 tests
 
73
        obj = {a: "a", b: "b"};
 
74
        filter0 = decorator.toFilter(obj);
 
75
        t.eq(filter0.CLASS_NAME, "OpenLayers.Filter.Logical",
 
76
             "toFilter returns a logical filter");
 
77
        t.eq(filter0.filters.length, 1,
 
78
             "toFilter returns a logical filter with expected " +
 
79
             "number of filters");
 
80
        t.eq(filter0.filters[0].CLASS_NAME, "OpenLayers.Filter.Logical",
 
81
             "toFilter returns a logical filter whose first filter " +
 
82
             "is a logical filter");
 
83
        t.eq(filter0.filters[0].filters[0].CLASS_NAME,
 
84
             "OpenLayers.Filter.Comparison",
 
85
             "toFilter returns a logical filter whose first filter " +
 
86
             "includes a comparison filter");
 
87
        t.eq(filter0.filters[0].filters[1].CLASS_NAME,
 
88
             "OpenLayers.Filter.Comparison",
 
89
             "toFilter returns a logical filter whose first filter " +
 
90
             "includes a comparison filter");
 
91
 
 
92
        // 3 tests
 
93
        obj = new OpenLayers.Filter();
 
94
        filter0 = decorator.toFilter(obj);
 
95
        t.eq(filter0.CLASS_NAME, "OpenLayers.Filter.Logical",
 
96
             "toFilter returns a logical filter");
 
97
        t.eq(filter0.filters.length, 1,
 
98
             "toFilter returns a logical filter with expected " +
 
99
             "number of filters");
 
100
        t.ok(filter0.filters[0] == obj,
 
101
             "toFilter returns a logical filter whose first filter " +
 
102
             "is the expected one");
 
103
 
 
104
        // 3 tests
 
105
        filter0 = new OpenLayers.Filter.Logical(
 
106
            {type: OpenLayers.Filter.Logical.AND});
 
107
        obj = new OpenLayers.Filter();
 
108
        filter1 = decorator.toFilter(obj, filter0);
 
109
        t.ok(filter1 == filter0,
 
110
             "toFilter returns expected filter");
 
111
        t.eq(filter1.filters.length, 1,
 
112
             "toFilter returns a logical filter with expected " +
 
113
             "number of filters");
 
114
        t.ok(filter1.filters[0] == obj,
 
115
             "toFilter returns a logical filter whose first filter " +
 
116
             "is the expected one");
 
117
        
 
118
        // 3 tests
 
119
        filter0 = new OpenLayers.Filter();
 
120
        obj = new OpenLayers.Filter();
 
121
        filter1 = decorator.toFilter(obj, filter0);
 
122
        t.eq(filter1.CLASS_NAME, "OpenLayers.Filter.Logical",
 
123
             "toFilter returns a logical filter");
 
124
        t.eq(filter1.filters.length, 2,
 
125
             "toFilter returns a logical filter with expected " +
 
126
             "number of filters");
 
127
        t.ok(filter1.filters[0] == filter0 && filter1.filters[1] == obj,
 
128
             "toFilter returns a logical filter whose filters " +
 
129
             "are the expected ones");
 
130
    }
 
131
    function test_MergeFilterDecorator_fromObjToFilter(t) {
 
132
        t.plan(4);
 
133
 
 
134
        // setup
 
135
 
 
136
        var decorator, filter, obj;
 
137
 
 
138
        decorator = new mapfish.Protocol.MergeFilterDecorator({
 
139
            protocol: new OpenLayers.Protocol()
 
140
        });
 
141
 
 
142
        obj = {a: "a", b: "b"};
 
143
 
 
144
        // 4 tests
 
145
        filter = decorator.fromObjToFilter(obj);
 
146
        t.eq(filter.CLASS_NAME, "OpenLayers.Filter.Logical",
 
147
             "fromObjToFilter returns a logical filter");
 
148
        t.eq(filter.filters.length, 2,
 
149
             "fromObjToFilter returns a filter with expected " +
 
150
             "number of filters");
 
151
        t.eq(filter.filters[0].CLASS_NAME, "OpenLayers.Filter.Comparison",
 
152
             "fromObjToFilter returns a filter whose first filter " +
 
153
             "is a comparison filter");
 
154
        t.eq(filter.filters[1].CLASS_NAME, "OpenLayers.Filter.Comparison",
 
155
             "fromObjToFilter returns a filter whose second filter " +
 
156
             "is a comparison filter");
 
157
    }
 
158
    function test_MergeFilterDecorator_isLogicalFilter(t) {
 
159
        t.plan(4);
 
160
 
 
161
        // setup
 
162
 
 
163
        var decorator, obj, bool;
 
164
 
 
165
        decorator = new mapfish.Protocol.MergeFilterDecorator({
 
166
            protocol: new OpenLayers.Protocol()
 
167
        });
 
168
 
 
169
        // 1 test
 
170
        obj = {fake: "object"};
 
171
        bool = decorator.isLogicalFilter(obj);
 
172
        t.eq(bool, false,
 
173
             "isLogicalFilter returns expected value");
 
174
 
 
175
        // 1 test
 
176
        obj = new OpenLayers.Filter();
 
177
        bool = decorator.isLogicalFilter(obj);
 
178
        t.eq(bool, false,
 
179
             "isLogicalFilter returns expected value");
 
180
 
 
181
        // 1 test
 
182
        obj = new OpenLayers.Filter.Spatial();
 
183
        bool = decorator.isLogicalFilter(obj);
 
184
        t.eq(bool, false,
 
185
             "isLogicalFilter returns expected value");
 
186
 
 
187
        // 1 test
 
188
        obj = new OpenLayers.Filter.Logical();
 
189
        bool = decorator.isLogicalFilter(obj);
 
190
        t.eq(bool, true,
 
191
             "isLogicalFilter returns expected value");
 
192
    }
 
193
    function test_MergeFilterDecorator_isFilter(t) {
 
194
        t.plan(3);
 
195
 
 
196
        // setup
 
197
 
 
198
        var decorator, obj, bool;
 
199
 
 
200
        decorator = new mapfish.Protocol.MergeFilterDecorator({
 
201
            protocol: new OpenLayers.Protocol()
 
202
        });
 
203
 
 
204
        // 1 test
 
205
        obj = {fake: "object"};
 
206
        bool = decorator.isFilter(obj);
 
207
        t.eq(bool, false,
 
208
             "isFilter returns expected value");
 
209
 
 
210
        // 1 test
 
211
        obj = new OpenLayers.Filter();
 
212
        bool = decorator.isFilter(obj);
 
213
        t.eq(bool, true,
 
214
             "isFilter returns expected value");
 
215
 
 
216
        // 1 test
 
217
        obj = new OpenLayers.Filter.Spatial();
 
218
        bool = decorator.isFilter(obj);
 
219
        t.eq(bool, true,
 
220
             "isFilter returns expected value");
 
221
    }
 
222
--></script>
 
223
 
 
224
  </head>
 
225
  <body>
 
226
  </body>
 
227
</html>