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 }