View Javadoc
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   * @author timp
26   * @since 22 Jun 2007
27   *
28   */
29  public class ClassNameTempletLoaderTest extends PoemTestCase {
30  
31    /**
32     * @param name
33     */
34    public ClassNameTempletLoaderTest(String name) {
35      super(name);
36    }
37  
38    /** 
39     * {@inheritDoc}
40     * @see junit.framework.TestCase#setUp()
41     */
42    protected void setUp() throws Exception {
43      super.setUp();
44    }
45  
46    /** 
47     * {@inheritDoc}
48     * @see junit.framework.TestCase#tearDown()
49     */
50    protected void tearDown() throws Exception {
51      super.tearDown();
52    }
53  
54    /**
55     * Test method for {@link org.melati.template.ClassNameTempletLoader#getInstance()}.
56     */
57    public void testGetInstance() {
58      
59    }
60  
61    /**
62     * Test method for {@link org.melati.template.ClassNameTempletLoader#templet(org.melati.template.TemplateEngine, org.melati.template.MarkupLanguage, java.lang.String, java.lang.String)}.
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      // Wrong object type, should be an Exception
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        // Velocity just ignores the calling of a non-existant method 
97        // within an if
98      } catch (TemplateEngineException e) {
99        e = null;
100       // Pass - we should have passed in an exception as the object
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     //System.err.println(m.getWriter().toString());
122     assertTrue(m.getWriter().toString().indexOf("[Access denied to Melati guest user]") != -1);
123     
124   }
125 
126   /**
127    * Test method for {@link org.melati.template.ClassNameTempletLoader#templet(
128    * org.melati.template.TemplateEngine, org.melati.template.MarkupLanguage, java.lang.String)}.
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    * Test method for {@link org.melati.template.ClassNameTempletLoader#templet(
174    *                        org.melati.template.TemplateEngine, 
175    *                        org.melati.template.MarkupLanguage, 
176    *                        java.lang.String, 
177    *                        java.lang.Class)}.
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    * Test method for {@link org.melati.template.ClassNameTempletLoader#templet(
204    * org.melati.template.TemplateEngine, 
205    * org.melati.template.MarkupLanguage, 
206    * java.lang.Class)}.
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     // FIXME too much whitespace remaining
229     assertEquals("[1]", m.getWriter().toString().trim());
230     
231   }
232 
233   /**
234    * Test method for {@link org.melati.template.ClassNameTempletLoader#templet(org.melati.template.TemplateEngine, org.melati.template.MarkupLanguage, org.melati.poem.FieldAttributes)}.
235    */
236   public void testTempletTemplateEngineMarkupLanguageFieldAttributes() {
237     
238   }
239 
240 }