View Javadoc

1   /**
2    * Copyright (c) 2002-2015, JWebUnit team.
3    *
4    * This file is part of JWebUnit.
5    *
6    * JWebUnit is free software: you can redistribute it and/or modify
7    * it under the terms of the GNU Lesser General Public License as published by
8    * the Free Software Foundation, either version 3 of the License, or
9    * (at your option) any later version.
10   *
11   * JWebUnit is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   * GNU General Public License for more details.
15   *
16   * You should have received a copy of the GNU Lesser General Public License
17   * along with JWebUnit.  If not, see <http://www.gnu.org/licenses/>.
18   */
19  package net.sourceforge.jwebunit.tests;
20  
21  import org.junit.Test;
22  
23  import net.sourceforge.jwebunit.api.IElement;
24  
25  import static net.sourceforge.jwebunit.junit.JWebUnit.*;
26  import static org.junit.Assert.*;
27  
28  public class FormAssertionsTest extends JWebUnitAPITestCase {
29  	
30      public void setUp() throws Exception {
31          super.setUp();
32          setBaseUrl(HOST_PATH + "/FormAssertionsTest");
33      }
34  
35      @Test
36      public void testAssertButtonWithTextPresent() {
37          beginAt("/assertButtonWithText.html");
38          assertButtonPresentWithText("foo");
39          assertButtonPresentWithText("bar");
40          assertButtonNotPresentWithText("foobar");
41      }
42      
43      @Test
44      public void testAssertFormParameterPresent() throws Throwable {
45          beginAt("/testPage.html");
46          assertPassFail("assertFormElementPresent", "testInputElement", "noSuchElement");
47          assertPass("assertFormElementPresent", "checkboxselected");
48          assertPass("assertFormElementEmpty", "testInputElement2");
49          assertPass("assertFormElementPresent", "text");
50      }
51  
52      @Test
53      public void testAssertFormParameterNotPresent() throws Throwable {
54          beginAt("/testPage.html");
55          assertPassFail("assertFormElementNotPresent", "noSuchElement", "testInputElement");
56      }
57  
58      @Test
59      public void testAssertFormPresent() throws Throwable {
60          beginAt("/testPage.html");
61          assertPass("assertFormPresent", NOARGS);
62          beginAt("/noFormPage.html");
63          assertFail("assertFormPresent", NOARGS);
64          assertPass("assertFormNotPresent", NOARGS);        
65      }
66  
67      @Test
68      public void testAssertFormPresentByName() throws Throwable {
69          beginAt("/testPage.html");
70          assertPass("assertFormPresent", new String[]{"form2"});
71          assertFail("assertFormPresent", new String[]{"noform"});
72          assertPass("assertFormNotPresent", new String[]{"noform"});
73      }
74  
75      @Test
76      public void testAssertFormElementEquals() throws Throwable {
77          beginAt("/testPage.html");
78          assertPassFail("assertTextFieldEquals", new Object[]{"testInputElement", "testValue"}, new Object[]{"testInputElement", "noSuchValue"});
79          assertPass("assertSubmitButtonPresent", new Object[]{"submitButton", "buttonLabel"});
80          setWorkingForm("form5");
81          assertPass("assertTextFieldEquals", new Object[]{"textarea", "sometexthere"});
82          setWorkingForm("form3");
83          assertPass("assertRadioOptionSelected", new Object[]{"cool", "dog"});
84          setWorkingForm("form5");
85          assertPassFail("assertHiddenFieldPresent", new Object[]{"hiddenelement", "hiddenvalue"}, new Object[]{"hiddenelement", "notThisValue"});
86          setWorkingForm("form1");
87          assertFail("assertTextFieldEquals", new Object[]{"noSuchElement", "testValue"});
88          assertFail("assertHiddenFieldPresent", new Object[]{"noSuchElement", "testValue"});
89          setWorkingForm("form5");        
90          assertPassFail("assertTextFieldEquals", new Object[]{"passwordelement", "password"}, new Object[]{"passwordelement", "noSuchValue"});
91      }
92  
93      @Test
94      public void testCheckboxSelected() throws Throwable {
95          beginAt("/testPage.html");
96          assertPassFail("assertCheckboxSelected", "checkboxselected", "checkboxnotselected");
97          assertFail("assertCheckboxSelected", "nosuchbox");
98      }
99  
100     @Test
101     public void testCheckboxSelectedByName() throws Throwable {
102         beginAt("/testPage.html");
103         assertPassFail("assertCheckboxSelected", new Object[]{"checkboxnotselected", "actuallyselected"},
104                                                  new Object[]{"checkboxselected", "actuallynotselected"});
105         assertFail("assertCheckboxSelected", new Object[]{"checkboxselected", "nosuchvalue"});
106     }
107 
108     @Test
109     public void testCheckboxNotSelected() throws Throwable {
110         beginAt("/testPage.html");
111         assertPassFail("assertCheckboxNotSelected", "checkboxnotselected", "checkboxselected");
112         assertFail("assertCheckboxNotSelected", "nosuchbox");
113     }
114 
115     @Test
116     public void testCheckboxNotSelectedByName() throws Throwable {
117         beginAt("/testPage.html");
118         assertPassFail("assertCheckboxNotSelected", new Object[]{"checkboxselected", "actuallynotselected"},
119                                                  new Object[]{"checkboxnotselected", "actuallyselected"});
120         assertFail("assertCheckboxNotSelected", new Object[]{"checkboxnotselected", "nosuchvalue"});
121     }
122 
123     @Test
124     public void testAssertSubmitButtonPresent() throws Throwable {
125         beginAt("/testPage.html");
126         assertPassFail("assertSubmitButtonPresent", "submitButton", "noSuchButton");
127     }
128 
129     @Test
130     public void testAssertSubmitButtonNotPresent() throws Throwable {
131         beginAt("/testPage.html");
132         assertPassFail("assertSubmitButtonNotPresent", "noSuchButton", "submitButton");
133     }
134 
135     @Test
136     public void testAssertSubmitButtonValue() throws Throwable {
137         beginAt("/testPage.html");
138         assertPassFail("assertSubmitButtonPresent",
139                 new Object[]{"submitButton", "buttonLabel"},
140                 new Object[]{"submitButton", "noSuchLabel"});
141     }
142 
143     @Test
144     public void testAssertResetButtonPresent() throws Throwable {
145         beginAt("/testPage.html");
146         assertPassFail("assertResetButtonPresent", "resetButton", "noSuchButton");
147     }
148 
149     @Test
150     public void testAssertResetButtonNotPresent() throws Throwable {
151         beginAt("/testPage.html");
152         assertPassFail("assertResetButtonNotPresent", "noSuchButton", "resetButton");
153     }
154 
155     @Test
156     public void testAssertRadioOptionPresent() throws Throwable {
157         beginAt("/testPage.html");
158         assertPassFail("assertRadioOptionPresent",
159                 new String[]{"cool", "cat"},
160                 new String[]{"cool", "fish"});
161     }
162 
163     @Test
164     public void testAssertRadioOptionNotPresent() throws Throwable {
165         beginAt("/testPage.html");
166         assertPassFail("assertRadioOptionNotPresent",
167                 new String[]{"cool", "fish"},
168                 new String[]{"cool", "cat"});
169     }
170 
171     @Test
172     public void testAssertRadioOptionSelected() throws Throwable {
173         beginAt("/testPage.html");
174         assertPassFail("assertRadioOptionSelected",
175                 new String[]{"cool", "dog"},
176                 new String[]{"cool", "cat"});
177     }
178 
179     @Test
180     public void testAssertRadioOptionNotSelected() throws Throwable {
181         beginAt("/testPage.html");
182         assertPassFail("assertRadioOptionNotSelected", new String[]{"cool", "cat"}, new String[]{"cool", "dog"});
183     }
184     
185     @Test
186     public void testAssertSelectOptionPresent() throws Throwable {
187         beginAt("/testPage.html");
188         assertPassFail("assertSelectOptionPresent",
189                 new String[]{"selectOption", "One"},
190                 new String[]{"selectOption", "NoSuchOption"});
191     }
192     
193     @Test
194     public void testAssertSelectOptionNotPresent() throws Throwable {
195         beginAt("/testPage.html");
196         assertPassFail("assertSelectOptionNotPresent",
197                 new String[]{"selectOption", "NoSuchOption"},
198                 new String[]{"selectOption", "One"});    	
199     }
200 
201     @Test
202     public void testAssertSelectOptionValuePresent() throws Throwable {
203         beginAt("/testPage.html");
204         assertPassFail("assertSelectOptionValuePresent",
205                 new String[]{"selectOption", "1"},
206                 new String[]{"selectOption", "NoSuchOption"});
207     }
208     
209     @Test
210     public void testAssertSelectOptionValueNotPresent() throws Throwable {
211         beginAt("/testPage.html");
212         assertPassFail("assertSelectOptionValueNotPresent",
213                 new String[]{"selectOption", "NoSuchOption"},
214                 new String[]{"selectOption", "1"});       
215     }
216 
217     @Test
218     public void testAssertSelectOptionsEqual() throws Throwable {
219         beginAt("/testPage.html");
220         assertPass("assertSelectOptionsEqual", new Object[]{"select1", new String[]{"one", "two", "three", "four"}});
221         assertFail("assertSelectOptionsEqual", new Object[]{"select1", new String[]{"one", "four", "three", "two"}});
222         assertFail("assertSelectOptionsEqual", new Object[]{"select1", new String[]{"one", "two", "three", "four", "five"}});
223     }
224 
225     @Test
226     public void testAssertSelectOptionsNotEqual() throws Throwable {
227         beginAt("/testPage.html");
228         assertFail("assertSelectOptionsNotEqual", new Object[]{"select1", new String[]{"one", "two", "three", "four"}});
229         assertPass("assertSelectOptionsNotEqual", new Object[]{"select1", new String[]{"one", "four", "three", "two"}});
230         assertPass("assertSelectOptionsNotEqual", new Object[]{"select1", new String[]{"one", "two", "three", "four", "five"}});
231     }
232 
233     @Test
234     public void testAssertSelectOptionValuesEqual() throws Throwable {
235         beginAt("/testPage.html");
236         assertPass("assertSelectOptionValuesEqual", new Object[]{"select1", new String[]{"1", "2", "3", "4"}});
237         assertFail("assertSelectOptionValuesEqual", new Object[]{"select1", new String[]{"1", "4", "3", "2"}});
238         assertFail("assertSelectOptionValuesEqual", new Object[]{"select1", new String[]{"1", "2", "3", "4", "5"}});
239     }
240 
241     @Test
242     public void testAssertSelectOptionValuesNotEqual() throws Throwable {
243         beginAt("/testPage.html");
244         assertFail("assertSelectOptionValuesNotEqual", new Object[]{"select1", new String[]{"1", "2", "3", "4"}});
245         assertPass("assertSelectOptionValuesNotEqual", new Object[]{"select1", new String[]{"1", "4", "3", "2"}});
246         assertPass("assertSelectOptionValuesNotEqual", new Object[]{"select1", new String[]{"1", "2", "3", "4", "5"}});
247     }
248 
249     @Test
250     public void testAssertSelectedOptionEquals() throws Throwable {
251         beginAt("/testPage.html");
252         assertPassFail("assertSelectedOptionEquals", new String[]{"select1", "one"}, new String[]{"select1", "two"});
253     }
254 
255     @Test
256     public void testAssertSelectedOptionValueEquals() throws Throwable {
257         beginAt("/testPage.html");
258         assertPassFail("assertSelectedOptionValueEquals", new String[]{"select1", "1"}, new String[]{"select1", "2"});
259     }
260 
261     @Test
262     public void testAssertButtonPresent() throws Throwable {
263         beginAt("/testPage.html");
264         assertPassFail("assertButtonPresent", "b1", "nobutton");
265     }
266 
267     @Test
268     public void testAssertButtonNotPresent() throws Throwable {
269         beginAt("/testPage.html");
270         assertPassFail("assertButtonNotPresent", "nobutton", "b1");
271     }
272     
273     /**
274      * Test elements with complicated names.
275      */
276     @Test
277     public void testComplicatedElementNames() {
278     	beginAt("/testPage.html");
279     	
280     	// the names to search for
281     	String[] names = new String[] {
282     			"complicated[5]", "complicated'6'", "complicated['7'].8",
283     	};
284     	
285     	// test each of them
286     	for (String s : names) {
287     		assertFormElementPresent(s);
288     		assertTextFieldEquals(s, s);
289     	}
290     }
291 
292     /**
293      * Testing for issue 1996193: clickRadioOption does not work as expected 
294      */
295     @Test
296     public void testIssue1996193() {
297     	beginAt("/testPage.html");
298     	
299     	String option1 = "coreAnswers['0-1'].strAnswer"; 
300     	assertRadioOptionPresent(option1, "1"); 
301     	clickRadioOption(option1, "1");
302     	assertRadioOptionSelected(option1, "1");
303 
304     }
305     
306     /**
307      * tests for label elements
308      */
309     @Test
310     public void testLabels() {
311     	beginAt("/testPage.html");
312     	
313     	assertLabelPresent("label1");
314     	assertLabeledFieldEquals("label1", "one");
315 
316     	assertLabelPresent("label2");
317     	assertLabeledFieldEquals("label2", "two");
318 
319     	assertLabelPresent("label3");
320     	assertLabeledFieldEquals("label3", "three");
321 
322     	assertLabelPresent("label4");
323     	assertLabeledFieldEquals("label4", "2");
324 
325     	assertLabelPresent("label5");
326     	assertLabeledFieldEquals("label5", "2");
327 
328     	assertLabelPresent("label6");
329     	assertLabeledFieldEquals("label6", "ten");
330 
331     	assertLabelPresent("label7");
332     	assertLabeledFieldEquals("label7", "10");
333 
334     	assertLabelPresent("label8");
335     	assertLabeledFieldEquals("label8", "eight");
336     }
337     
338     /**
339      * Test setting elements retrieved through labels
340      */
341     @Test
342     public void testSetLabels() {
343     	beginAt("/testPage.html");
344 
345     	assertLabelPresent("label1");
346     	assertLabeledFieldEquals("label1", "one");
347     	assertTextFieldEquals("label1_field1", "one");
348     	assertEquals(getElementById("field1_id").getAttribute("value"), "one");
349     	
350     	// through setLabeledFormElementField
351     	setLabeledFormElementField("label1", "two");
352     	
353     	assertLabeledFieldEquals("label1", "two");
354     	assertTextFieldEquals("label1_field1", "two");
355     	assertEquals(getElementById("field1_id").getAttribute("value"), "two");
356     	
357     	// through normal setValue
358     	setTextField("label1_field1", "three");
359 
360     	assertLabeledFieldEquals("label1", "three");
361     	assertTextFieldEquals("label1_field1", "three");
362     	assertEquals(getElementById("field1_id").getAttribute("value"), "three");
363     	
364     	// through IElement
365     	IElement element = getElementById("field1_id");
366     	assertNotNull(element);
367     	element.setAttribute("value", "four");
368 
369     	assertLabeledFieldEquals("label1", "four");
370     	assertTextFieldEquals("label1_field1", "four");
371     	assertEquals(getElementById("field1_id").getAttribute("value"), "four");
372     	
373     }
374     
375     /**
376      * Even though the element has no value set (i.e. getAttribute("value") == null),
377      * it should still qualify as equal to an empty string.
378      */
379     @Test
380     public void testLabeledEmptyElement() {
381     	beginAt("/testPage.html");
382     	assertLabeledFieldEquals("label9", "");
383 
384     }
385 
386 }