Mercurialsql-dk / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
java/sql-dk/src/test/java/info/globalcode/sql/dk/CLIParserTest.java
author František Kučera <franta-hg@frantovo.cz>
Thu, 24 Oct 2019 21:43:08 +0200
branchv_0
changeset 250 aae5009bd0af
parent 241 f332033ed66c
permissions -rw-r--r--
fix license version: GNU GPLv3 
     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, version 3 of the License.

     8  *

     9  * This program is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

    12  * GNU General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU General Public License

    15  * along with this program. If not, see <http://www.gnu.org/licenses/>.

    16  */

    17 package info.globalcode.sql.dk;

    18 

    19 import info.globalcode.sql.dk.CLIParser.Tokens;

    20 import static info.globalcode.sql.dk.CLIParser.TYPE_NAME_SEPARATOR;

    21 import info.globalcode.sql.dk.InfoLister.InfoType;

    22 import java.io.ByteArrayInputStream;

    23 import java.util.Collection;

    24 import org.junit.jupiter.api.BeforeEach;

    25 import org.junit.jupiter.api.Test;

    26 import static org.junit.jupiter.api.Assertions.*;

    27 

    28 /**

    29  *

    30  * @author Ing. František Kučera (frantovo.cz)

    31  */

    32 public class CLIParserTest {

    33 

    34 	private static final String DATABASE_NAME_1 = "some database 1";

    35 	private static final String SQL_1 = "SELECT * FROM table1";

    36 	private static final String DATA_1 = "aaa";

    37 	private static final String DATA_2 = "bbb";

    38 	private static final String DATA_3 = "ccc";

    39 	private static final String NAME_1 = "param1";

    40 	private static final String NAME_2 = "param2";

    41 	private static final String NAME_3 = "param3";

    42 	private CLIParser parser;

    43 

    44 	@BeforeEach

    45 	public void setUpMethod() throws Exception {

    46 		parser = new CLIParser();

    47 	}

    48 

    49 	private CLIOptions parseOptions(String[] args) throws CLIParserException {

    50 		return parser.parseOptions(args, new ByteArrayInputStream("".getBytes()));

    51 	}

    52 

    53 	@Test

    54 	public void testParseOptions_QueryNow_NoParams() throws InvalidOptionsException, CLIParserException {

    55 		String[] args = new String[]{

    56 			Tokens.DB, DATABASE_NAME_1,

    57 			Tokens.SQL, SQL_1};

    58 		CLIOptions options = parseOptions(args);

    59 		options.validate();

    60 

    61 		assertEquals(options.getDatabaseName(), DATABASE_NAME_1);

    62 		assertEquals(options.getSql(), SQL_1);

    63 		assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW);

    64 		assertTrue(options.getNamedParameters().isEmpty(), "Named parameters should be empty.");

    65 		assertTrue(options.getNumberedParameters().isEmpty(), "Numbered parameters should be empty.");

    66 	}

    67 

    68 	@Test

    69 	public void testParseOptions_QueryNow_Numbered() throws InvalidOptionsException, CLIParserException {

    70 		String[] args = new String[]{

    71 			Tokens.DB, DATABASE_NAME_1,

    72 			Tokens.SQL, SQL_1,

    73 			Tokens.DATA, DATA_1, DATA_2, DATA_3};

    74 		CLIOptions options = parseOptions(args);

    75 		options.validate();

    76 

    77 		assertEquals(options.getDatabaseName(), DATABASE_NAME_1);

    78 		assertEquals(options.getSql(), SQL_1);

    79 		assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW);

    80 		assertEquals(options.getNumberedParameters().size(), 3);

    81 		assertEquals(options.getNumberedParameters().get(0).getValue(), DATA_1);

    82 		assertEquals(options.getNumberedParameters().get(1).getValue(), DATA_2);

    83 		assertEquals(options.getNumberedParameters().get(2).getValue(), DATA_3);

    84 		assertEquals(options.getNumberedParameters().get(0).getType(), Parameter.DEFAULT_TYPE);

    85 		assertEquals(options.getNumberedParameters().get(1).getType(), Parameter.DEFAULT_TYPE);

    86 		assertEquals(options.getNumberedParameters().get(2).getType(), Parameter.DEFAULT_TYPE);

    87 	}

    88 

    89 	@Test

    90 	public void testParseOptions_QueryNow_Numbered_withTypes() throws InvalidOptionsException, CLIParserException {

    91 		String[] args = new String[]{

    92 			Tokens.DB, DATABASE_NAME_1,

    93 			Tokens.SQL, SQL_1,

    94 			Tokens.TYPES, " INTEGER,VARCHAR, BOOLEAN",

    95 			Tokens.DATA, DATA_1, DATA_2, DATA_3};

    96 		CLIOptions options = parseOptions(args);

    97 		options.validate();

    98 

    99 		assertEquals(options.getDatabaseName(), DATABASE_NAME_1);

   100 		assertEquals(options.getSql(), SQL_1);

   101 		assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW);

   102 		assertEquals(options.getNumberedParameters().size(), 3);

   103 		assertEquals(options.getNumberedParameters().get(0).getValue(), DATA_1);

   104 		assertEquals(options.getNumberedParameters().get(1).getValue(), DATA_2);

   105 		assertEquals(options.getNumberedParameters().get(2).getValue(), DATA_3);

   106 		assertEquals(options.getNumberedParameters().get(0).getType(), SQLType.INTEGER);

   107 		assertEquals(options.getNumberedParameters().get(1).getType(), SQLType.VARCHAR);

   108 		assertEquals(options.getNumberedParameters().get(2).getType(), SQLType.BOOLEAN);

   109 	}

   110 

   111 	@Test

   112 	public void testParseOptions_QueryNow_Named() throws InvalidOptionsException, CLIParserException {

   113 		String[] args = new String[]{

   114 			Tokens.DB, DATABASE_NAME_1,

   115 			Tokens.SQL, SQL_1,

   116 			Tokens.DATA_NAMED, NAME_1, DATA_1, NAME_2, DATA_2, NAME_3, DATA_3};

   117 		CLIOptions options = parseOptions(args);

   118 		options.validate();

   119 

   120 		assertEquals(options.getDatabaseName(), DATABASE_NAME_1);

   121 		assertEquals(options.getSql(), SQL_1);

   122 		assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW);

   123 		assertEquals(options.getNamedParameters().size(), 3);

   124 		assertNamedParameter(options.getNamedParameters(), NAME_1, DATA_1, Parameter.DEFAULT_TYPE);

   125 		assertNamedParameter(options.getNamedParameters(), NAME_2, DATA_2, Parameter.DEFAULT_TYPE);

   126 		assertNamedParameter(options.getNamedParameters(), NAME_3, DATA_3, Parameter.DEFAULT_TYPE);

   127 	}

   128 

   129 	@Test

   130 	public void testParseOptions_QueryNow_Named_withTypes() throws InvalidOptionsException, CLIParserException {

   131 		String[] args = new String[]{

   132 			Tokens.DB, DATABASE_NAME_1,

   133 			Tokens.SQL, SQL_1,

   134 			Tokens.NAME_PREFIX, "$",

   135 			Tokens.TYPES, " " + NAME_1 + TYPE_NAME_SEPARATOR + "INTEGER" + "," + NAME_3 + TYPE_NAME_SEPARATOR + "BOOLEAN",

   136 			Tokens.DATA_NAMED, NAME_1, DATA_1, NAME_2, DATA_2, NAME_3, DATA_3};

   137 		CLIOptions options = parseOptions(args);

   138 		options.validate();

   139 

   140 		assertEquals(options.getDatabaseName(), DATABASE_NAME_1);

   141 		assertEquals(options.getSql(), SQL_1);

   142 		assertEquals(options.getMode(), CLIOptions.MODE.QUERY_NOW);

   143 		assertEquals(options.getNamedParameters().size(), 3);

   144 		assertNamedParameter(options.getNamedParameters(), NAME_1, DATA_1, SQLType.INTEGER);

   145 		assertNamedParameter(options.getNamedParameters(), NAME_2, DATA_2, Parameter.DEFAULT_TYPE);

   146 		assertNamedParameter(options.getNamedParameters(), NAME_3, DATA_3, SQLType.BOOLEAN);

   147 	}

   148 

   149 	private void assertNamedParameter(Collection<NamedParameter> params, String name, Object value, SQLType type) {

   150 		for (NamedParameter p : params) {

   151 			if (name.equals(p.getName())) {

   152 				assertEquals(p.getValue(), value, "value does not match – name: " + name);

   153 				assertEquals(p.getType(), type, "value does not match – name: " + name);

   154 				return;

   155 			}

   156 		}

   157 		fail("Named parameter not found: " + name);

   158 	}

   159 

   160 	@Test

   161 	public void testParseOptions_PrepareBatch() throws InvalidOptionsException, CLIParserException {

   162 		String[] args = new String[]{

   163 			Tokens.BATCH,

   164 			Tokens.SQL, SQL_1};

   165 		CLIOptions options = parseOptions(args);

   166 		options.validate();

   167 

   168 		assertEquals(options.getSql(), SQL_1);

   169 		assertEquals(options.getMode(), CLIOptions.MODE.PREPARE_BATCH);

   170 	}

   171 

   172 	@Test

   173 	public void testParseOptions_ExecuteBatch() throws InvalidOptionsException, CLIParserException {

   174 		String[] args = new String[]{

   175 			Tokens.BATCH,

   176 			Tokens.DB, DATABASE_NAME_1};

   177 		CLIOptions options = parseOptions(args);

   178 		options.validate();

   179 

   180 		assertEquals(options.getDatabaseName(), DATABASE_NAME_1);

   181 		assertEquals(options.getMode(), CLIOptions.MODE.EXECUTE_BATCH);

   182 	}

   183 

   184 	@Test

   185 	public void testParseOptions_ShowInfo_Help() throws InvalidOptionsException, CLIParserException {

   186 		String[] args = new String[]{Tokens.INFO_HELP};

   187 		CLIOptions options = parseOptions(args);

   188 		options.validate();

   189 

   190 		assertEquals(options.getMode(), CLIOptions.MODE.JUST_SHOW_INFO);

   191 		assertEquals(options.getShowInfo().size(), 1);

   192 		assertTrue(options.getShowInfo().contains(InfoType.HELP));

   193 	}

   194 }
sql-dk