|
1 /** |
|
2 * SQL-DK |
|
3 * Copyright © 2013 František Kučera (frantovo.cz) |
|
4 * |
|
5 * This program is free software: you can redistribute it and/or modify |
|
6 * it under the terms of the GNU General Public License as published by |
|
7 * the Free Software Foundation, either version 3 of the License, or |
|
8 * (at your option) any later version. |
|
9 * |
|
10 * This program is distributed in the hope that it will be useful, |
|
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
13 * GNU General Public License for more details. |
|
14 * |
|
15 * You should have received a copy of the GNU General Public License |
|
16 * along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
17 */ |
|
18 package info.globalcode.sql.dk; |
|
19 |
|
20 import info.globalcode.sql.dk.CLIParser.Tokens; |
|
21 import static info.globalcode.sql.dk.CLIParser.TYPE_NAME_SEPARATOR; |
|
22 import info.globalcode.sql.dk.InfoLister.InfoType; |
|
23 import java.io.ByteArrayInputStream; |
|
24 import java.util.Collection; |
|
25 import static org.testng.Assert.*; |
|
26 import org.testng.annotations.BeforeMethod; |
|
27 import org.testng.annotations.Test; |
|
28 |
|
29 /** |
|
30 * |
|
31 * @author Ing. František Kučera (frantovo.cz) |
|
32 */ |
|
33 public class CLIParserTest { |
|
34 |
|
35 private static final String DATABASE_NAME_1 = "some database 1"; |
|
36 private static final String SQL_1 = "SELECT * FROM table1"; |
|
37 private static final String DATA_1 = "aaa"; |
|
38 private static final String DATA_2 = "bbb"; |
|
39 private static final String DATA_3 = "ccc"; |
|
40 private static final String NAME_1 = "param1"; |
|
41 private static final String NAME_2 = "param2"; |
|
42 private static final String NAME_3 = "param3"; |
|
43 private CLIParser parser; |
|
44 |
|
45 @BeforeMethod |
|
46 public void setUpMethod() throws Exception { |
|
47 parser = new CLIParser(); |
|
48 } |
|
49 |
|
50 private CLIOptions parseOptions(String[] args) throws CLIParserException { |
|
51 return parser.parseOptions(args, new ByteArrayInputStream("".getBytes())); |
|
52 } |
|
53 |
|
54 @Test |
|
55 public void testParseOptions_QueryNow_NoParams() throws InvalidOptionsException, CLIParserException { |
|
56 String[] args = new String[]{ |
|
57 Tokens.DB, DATABASE_NAME_1, |
|
58 Tokens.SQL, SQL_1}; |
|
59 CLIOptions options = parseOptions(args); |
|
60 options.validate(); |
|
61 |
|
62 assertEquals(options.getDatabaseName(), DATABASE_NAME_1); |
|
63 assertEquals(options.getSql(), SQL_1); |
|
64 assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW); |
|
65 assertTrue(options.getNamedParameters().isEmpty(), "Named parameters should be empty."); |
|
66 assertTrue(options.getNumberedParameters().isEmpty(), "Numbered parameters should be empty."); |
|
67 } |
|
68 |
|
69 @Test |
|
70 public void testParseOptions_QueryNow_Numbered() throws InvalidOptionsException, CLIParserException { |
|
71 String[] args = new String[]{ |
|
72 Tokens.DB, DATABASE_NAME_1, |
|
73 Tokens.SQL, SQL_1, |
|
74 Tokens.DATA, DATA_1, DATA_2, DATA_3}; |
|
75 CLIOptions options = parseOptions(args); |
|
76 options.validate(); |
|
77 |
|
78 assertEquals(options.getDatabaseName(), DATABASE_NAME_1); |
|
79 assertEquals(options.getSql(), SQL_1); |
|
80 assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW); |
|
81 assertEquals(options.getNumberedParameters().size(), 3); |
|
82 assertEquals(options.getNumberedParameters().get(0).getValue(), DATA_1); |
|
83 assertEquals(options.getNumberedParameters().get(1).getValue(), DATA_2); |
|
84 assertEquals(options.getNumberedParameters().get(2).getValue(), DATA_3); |
|
85 assertEquals(options.getNumberedParameters().get(0).getType(), Parameter.DEFAULT_TYPE); |
|
86 assertEquals(options.getNumberedParameters().get(1).getType(), Parameter.DEFAULT_TYPE); |
|
87 assertEquals(options.getNumberedParameters().get(2).getType(), Parameter.DEFAULT_TYPE); |
|
88 } |
|
89 |
|
90 @Test |
|
91 public void testParseOptions_QueryNow_Numbered_withTypes() throws InvalidOptionsException, CLIParserException { |
|
92 String[] args = new String[]{ |
|
93 Tokens.DB, DATABASE_NAME_1, |
|
94 Tokens.SQL, SQL_1, |
|
95 Tokens.TYPES, " INTEGER,VARCHAR, BOOLEAN", |
|
96 Tokens.DATA, DATA_1, DATA_2, DATA_3}; |
|
97 CLIOptions options = parseOptions(args); |
|
98 options.validate(); |
|
99 |
|
100 assertEquals(options.getDatabaseName(), DATABASE_NAME_1); |
|
101 assertEquals(options.getSql(), SQL_1); |
|
102 assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW); |
|
103 assertEquals(options.getNumberedParameters().size(), 3); |
|
104 assertEquals(options.getNumberedParameters().get(0).getValue(), DATA_1); |
|
105 assertEquals(options.getNumberedParameters().get(1).getValue(), DATA_2); |
|
106 assertEquals(options.getNumberedParameters().get(2).getValue(), DATA_3); |
|
107 assertEquals(options.getNumberedParameters().get(0).getType(), SQLType.INTEGER); |
|
108 assertEquals(options.getNumberedParameters().get(1).getType(), SQLType.VARCHAR); |
|
109 assertEquals(options.getNumberedParameters().get(2).getType(), SQLType.BOOLEAN); |
|
110 } |
|
111 |
|
112 @Test |
|
113 public void testParseOptions_QueryNow_Named() throws InvalidOptionsException, CLIParserException { |
|
114 String[] args = new String[]{ |
|
115 Tokens.DB, DATABASE_NAME_1, |
|
116 Tokens.SQL, SQL_1, |
|
117 Tokens.DATA_NAMED, NAME_1, DATA_1, NAME_2, DATA_2, NAME_3, DATA_3}; |
|
118 CLIOptions options = parseOptions(args); |
|
119 options.validate(); |
|
120 |
|
121 assertEquals(options.getDatabaseName(), DATABASE_NAME_1); |
|
122 assertEquals(options.getSql(), SQL_1); |
|
123 assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW); |
|
124 assertEquals(options.getNamedParameters().size(), 3); |
|
125 assertNamedParameter(options.getNamedParameters(), NAME_1, DATA_1, Parameter.DEFAULT_TYPE); |
|
126 assertNamedParameter(options.getNamedParameters(), NAME_2, DATA_2, Parameter.DEFAULT_TYPE); |
|
127 assertNamedParameter(options.getNamedParameters(), NAME_3, DATA_3, Parameter.DEFAULT_TYPE); |
|
128 } |
|
129 |
|
130 @Test |
|
131 public void testParseOptions_QueryNow_Named_withTypes() throws InvalidOptionsException, CLIParserException { |
|
132 String[] args = new String[]{ |
|
133 Tokens.DB, DATABASE_NAME_1, |
|
134 Tokens.SQL, SQL_1, |
|
135 Tokens.NAME_PREFIX, "$", |
|
136 Tokens.TYPES, " " + NAME_1 + TYPE_NAME_SEPARATOR + "INTEGER" + "," + NAME_3 + TYPE_NAME_SEPARATOR + "BOOLEAN", |
|
137 Tokens.DATA_NAMED, NAME_1, DATA_1, NAME_2, DATA_2, NAME_3, DATA_3}; |
|
138 CLIOptions options = parseOptions(args); |
|
139 options.validate(); |
|
140 |
|
141 assertEquals(options.getDatabaseName(), DATABASE_NAME_1); |
|
142 assertEquals(options.getSql(), SQL_1); |
|
143 assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW); |
|
144 assertEquals(options.getNamedParameters().size(), 3); |
|
145 assertNamedParameter(options.getNamedParameters(), NAME_1, DATA_1, SQLType.INTEGER); |
|
146 assertNamedParameter(options.getNamedParameters(), NAME_2, DATA_2, Parameter.DEFAULT_TYPE); |
|
147 assertNamedParameter(options.getNamedParameters(), NAME_3, DATA_3, SQLType.BOOLEAN); |
|
148 } |
|
149 |
|
150 private void assertNamedParameter(Collection<NamedParameter> params, String name, Object value, SQLType type) { |
|
151 for (NamedParameter p : params) { |
|
152 if (name.equals(p.getName())) { |
|
153 assertEquals(p.getValue(), value, "value does not match – name: " + name); |
|
154 assertEquals(p.getType(), type, "value does not match – name: " + name); |
|
155 return; |
|
156 } |
|
157 } |
|
158 fail("Named parameter not found: " + name); |
|
159 } |
|
160 |
|
161 @Test |
|
162 public void testParseOptions_PrepareBatch() throws InvalidOptionsException, CLIParserException { |
|
163 String[] args = new String[]{ |
|
164 Tokens.BATCH, |
|
165 Tokens.SQL, SQL_1}; |
|
166 CLIOptions options = parseOptions(args); |
|
167 options.validate(); |
|
168 |
|
169 assertEquals(options.getSql(), SQL_1); |
|
170 assertEquals(options.getMode(), CLIOptions.MODE.PREPARE_BATCH); |
|
171 } |
|
172 |
|
173 @Test |
|
174 public void testParseOptions_ExecuteBatch() throws InvalidOptionsException, CLIParserException { |
|
175 String[] args = new String[]{ |
|
176 Tokens.BATCH, |
|
177 Tokens.DB, DATABASE_NAME_1}; |
|
178 CLIOptions options = parseOptions(args); |
|
179 options.validate(); |
|
180 |
|
181 assertEquals(options.getDatabaseName(), DATABASE_NAME_1); |
|
182 assertEquals(options.getMode(), CLIOptions.MODE.EXECUTE_BATCH); |
|
183 } |
|
184 |
|
185 @Test |
|
186 public void testParseOptions_ShowInfo_Help() throws InvalidOptionsException, CLIParserException { |
|
187 String[] args = new String[]{Tokens.INFO_HELP}; |
|
188 CLIOptions options = parseOptions(args); |
|
189 options.validate(); |
|
190 |
|
191 assertEquals(options.getMode(), CLIOptions.MODE.JUST_SHOW_INFO); |
|
192 assertEquals(options.getShowInfo().size(), 1); |
|
193 assertTrue(options.getShowInfo().contains(InfoType.HELP)); |
|
194 } |
|
195 } |