1
2
3
4 package org.melati.template.test;
5
6 import org.melati.Melati;
7 import org.melati.MelatiConfig;
8 import org.melati.PoemContext;
9 import org.melati.poem.AccessPoemException;
10 import org.melati.poem.Capability;
11 import org.melati.poem.Field;
12 import org.melati.poem.test.PoemTestCase;
13 import org.melati.template.ClassNameTempletLoader;
14 import org.melati.template.MarkupLanguage;
15 import org.melati.template.NotFoundException;
16 import org.melati.template.Template;
17 import org.melati.template.TemplateContext;
18 import org.melati.template.TemplateEngine;
19 import org.melati.template.TemplateEngineException;
20 import org.melati.template.webmacro.WebmacroServletTemplateEngine;
21 import org.melati.util.MelatiStringWriter;
22
23
24
25
26
27
28
29 public class ClassNameTempletLoaderTest extends PoemTestCase {
30
31
32
33
34 public ClassNameTempletLoaderTest(String name) {
35 super(name);
36 }
37
38
39
40
41
42 protected void setUp() throws Exception {
43 super.setUp();
44 }
45
46
47
48
49
50 protected void tearDown() throws Exception {
51 super.tearDown();
52 }
53
54
55
56
57 public void testGetInstance() {
58
59 }
60
61
62
63
64 public void testTempletTemplateEngineMarkupLanguageStringString() throws Exception {
65 MelatiConfig mc = new MelatiConfig();
66 TemplateEngine templateEngine = mc.getTemplateEngine();
67 Templated templated = new Templated();
68 templateEngine.init(mc);
69 Melati m = new Melati(mc, new MelatiStringWriter());
70 m.setTemplateEngine(templateEngine);
71 m.setPoemContext(new PoemContext());
72 assertNotNull(m.getTemplateEngine());
73 MarkupLanguage ml = m.getMarkupLanguage();
74 Template t = ClassNameTempletLoader.getInstance().templet(
75 templateEngine, ml, templated.getClass());
76 TemplateContext tc =
77 templateEngine.getTemplateContext();
78 m.setTemplateContext(tc);
79 tc.put("melati", m);
80 tc.put("ml", ml);
81 tc.put("object", new Integer("1"));
82 m.setTemplateContext(tc);
83 t.write(m.getWriter(), m.getTemplateContext());
84 t = ClassNameTempletLoader.getInstance().templet(
85 templateEngine, ml, "error", new Exception().getClass());
86 tc = m.getTemplateContext();
87 tc.put("melati", m);
88 tc.put("ml", ml);
89
90 tc.put("object", new Integer("1"));
91 try {
92 t.write(m.getWriter(),tc);
93 System.err.println(m.getWriter().toString());
94 if(templateEngine instanceof WebmacroServletTemplateEngine)
95 fail("Should have bombed");
96
97
98 } catch (TemplateEngineException e) {
99 e = null;
100
101 }
102
103 t = ClassNameTempletLoader.getInstance().templet(
104 templateEngine, ml, "error",new Exception().getClass());
105 tc = m.getTemplateContext();
106 tc.put("melati", m);
107 tc.put("ml", ml);
108 tc.put("object",new Exception("A message"));
109 m.setTemplateContext(tc);
110 t.write(m.getWriter(),tc);
111 assertTrue(m.getWriter().toString().indexOf("A message") != -1);
112
113 t = ClassNameTempletLoader.getInstance().templet(
114 templateEngine, ml, "error", new AccessPoemException().getClass());
115 tc = m.getTemplateContext();
116 tc.put("melati", m);
117 tc.put("ml", m.getMarkupLanguage());
118 tc.put("object", new AccessPoemException(getDb().getUserTable().guestUser(),new Capability("Cool")));
119 m.setTemplateContext(tc);
120 t.write(m.getWriter(),tc);
121
122 assertTrue(m.getWriter().toString().indexOf("[Access denied to Melati guest user]") != -1);
123
124 }
125
126
127
128
129
130 public void testTempletTemplateEngineMarkupLanguageString() throws Exception {
131 MelatiConfig mc = new MelatiConfig();
132 TemplateEngine templateEngine = mc.getTemplateEngine();
133 templateEngine.init(mc);
134 Melati m = new Melati(mc, new MelatiStringWriter());
135 m.setTemplateEngine(templateEngine);
136 m.setPoemContext(new PoemContext());
137 assertNotNull(m.getTemplateEngine());
138 MarkupLanguage ml = m.getMarkupLanguage();
139 try {
140 ClassNameTempletLoader.getInstance().templet(
141 templateEngine, ml,new Integer("1").getClass().getName());
142 fail("Should have bombed");
143 } catch (NotFoundException e) {
144 e = null;
145 }
146 Template t = ClassNameTempletLoader.getInstance().templet(
147 templateEngine, ml, new Object().getClass().getName());
148 TemplateContext tc =
149 templateEngine.getTemplateContext();
150 m.setTemplateContext(tc);
151 tc.put("melati", m);
152 tc.put("ml", ml);
153 tc.put("object", new Object());
154 t.write(m.getWriter(),tc);
155 assertTrue(m.getWriter().toString().startsWith("[java.lang.Object@"));
156
157 t = ClassNameTempletLoader.getInstance().templet(
158 templateEngine, ml,"org.melati.poem.ReferencePoemType-SelectionWindow");
159 tc = m.getTemplateContext();
160 tc.put("melati", m);
161 tc.put("ml", ml);
162 Field<?> tableField = getDb().getColumnInfoTable().
163 getColumnInfoObject(0).getField("tableinfo");
164 tc.put("object", tableField);
165 t.write(m.getWriter(),tc);
166 System.err.println(m.getWriter().toString());
167 assertTrue(m.getWriter().toString().indexOf("tableinfo_button") != -1);
168
169
170 }
171
172
173
174
175
176
177
178
179 public void testTempletTemplateEngineMarkupLanguageStringClass() throws Exception {
180 MelatiConfig mc = new MelatiConfig();
181 TemplateEngine templateEngine = mc.getTemplateEngine();
182 Templated templated = new Templated();
183 templateEngine.init(mc);
184 Melati m = new Melati(mc, new MelatiStringWriter());
185 m.setTemplateEngine(templateEngine);
186 m.setPoemContext(new PoemContext());
187 assertNotNull(m.getTemplateEngine());
188 MarkupLanguage ml = m.getMarkupLanguage();
189 Template t = ClassNameTempletLoader.getInstance().templet(
190 templateEngine, ml, templated.getClass());
191 TemplateContext tc =
192 templateEngine.getTemplateContext();
193 m.setTemplateContext(tc);
194 tc.put("melati", m);
195 tc.put("ml", ml);
196 tc.put("object", new Integer("1"));
197 m.setTemplateContext(tc);
198 t.write(m.getWriter(), m.getTemplateContext());
199 assertEquals("Hi, this is from a template.", m.getWriter().toString());
200 }
201
202
203
204
205
206
207
208 public void testTempletTemplateEngineMarkupLanguageClass() throws Exception {
209 MelatiConfig mc = new MelatiConfig();
210 TemplateEngine templateEngine = mc.getTemplateEngine();
211 templateEngine.init(mc);
212 Melati m = new Melati(mc, new MelatiStringWriter());
213 m.setTemplateEngine(templateEngine);
214 m.setPoemContext(new PoemContext());
215 assertNotNull(m.getTemplateEngine());
216 TemplateContext templateContext =
217 templateEngine.getTemplateContext();
218 m.setTemplateContext(templateContext);
219 MarkupLanguage ml = m.getMarkupLanguage();
220 Template t = ClassNameTempletLoader.getInstance().templet(
221 templateEngine, ml,
222 new Integer("1").getClass());
223 TemplateContext tc = m.getTemplateContext();
224 tc.put("melati", m);
225 tc.put("ml", ml);
226 tc.put("object", new Integer("1"));
227 t.write(m.getWriter(), tc);
228
229 assertEquals("[1]", m.getWriter().toString().trim());
230
231 }
232
233
234
235
236 public void testTempletTemplateEngineMarkupLanguageFieldAttributes() {
237
238 }
239
240 }