aboutsummaryrefslogtreecommitdiffstats
path: root/framework/src/test/java
diff options
context:
space:
mode:
authorKanagaraj Manickam k00365106 <kanagaraj.manickam@huawei.com>2017-07-19 15:14:29 +0530
committerKanagaraj Manickam k00365106 <kanagaraj.manickam@huawei.com>2017-07-19 15:31:19 +0530
commitb610d2dbfa445e2ed8fd7f9976ae7a776666d630 (patch)
tree6d58385dc197aada4c6a832c922f04d0f4da61ad /framework/src/test/java
parent20173579de1cd7d8f70fc2cdf17a4f9c0fc6e946 (diff)
Add seed code from Open-Orelease-1.0.0
It migrated the code from Open-O into onap namespace and adds the required framework, main, deployment and some sample plugins for msb. CLI-7 CLI-8 CLI-11 Change-Id: I499e34237daccb971ef74bd10e50f50707baa4d3 Signed-off-by: Kanagaraj Manickam k00365106 <kanagaraj.manickam@huawei.com>
Diffstat (limited to 'framework/src/test/java')
-rw-r--r--framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSample.java47
-rw-r--r--framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSampleTest.java157
-rw-r--r--framework/src/test/java/org/onap/cli/fw/OnapCommandRegistrarTest.java170
-rw-r--r--framework/src/test/java/org/onap/cli/fw/ad/OnapAuthClientTest.java201
-rw-r--r--framework/src/test/java/org/onap/cli/fw/ad/OnapCredentialsTest.java32
-rw-r--r--framework/src/test/java/org/onap/cli/fw/ad/OnapServiceTest.java37
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommand.java101
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommandTest.java32
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommand.java75
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommandTest.java21
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommand.java79
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommandTest.java21
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapHttpCommandTest.java79
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommand.java78
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommandTest.java21
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommandTest.java56
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommandTest.java64
-rw-r--r--framework/src/test/java/org/onap/cli/fw/cmd/OnapSwaggerCommandTest.java96
-rw-r--r--framework/src/test/java/org/onap/cli/fw/conf/OnapCommandConfgTest.java44
-rw-r--r--framework/src/test/java/org/onap/cli/fw/error/OnapCommandErrorTest.java270
-rw-r--r--framework/src/test/java/org/onap/cli/fw/http/HttpInputOutputTest.java67
-rw-r--r--framework/src/test/java/org/onap/cli/fw/http/OnapHttpConnectionTest.java207
-rw-r--r--framework/src/test/java/org/onap/cli/fw/input/OnapCommandParameterTest.java121
-rw-r--r--framework/src/test/java/org/onap/cli/fw/input/ParameterTypeTest.java51
-rw-r--r--framework/src/test/java/org/onap/cli/fw/log/OnapCommandLoggerTest.java134
-rw-r--r--framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeScopeTest.java41
-rw-r--r--framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeTest.java44
-rw-r--r--framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultTest.java208
-rw-r--r--framework/src/test/java/org/onap/cli/fw/output/PrintDirectionTest.java43
-rw-r--r--framework/src/test/java/org/onap/cli/fw/output/ResultTypeTest.java42
-rw-r--r--framework/src/test/java/org/onap/cli/fw/output/print/OnapCommandPrintTest.java82
-rw-r--r--framework/src/test/java/org/onap/cli/fw/output/print/TableGeneratorTest.java185
-rw-r--r--framework/src/test/java/org/onap/cli/fw/run/OnapCommandExecutorTest.java38
-rw-r--r--framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java103
-rw-r--r--framework/src/test/java/org/onap/cli/fw/utils/FileUtil.java55
-rw-r--r--framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java481
-rw-r--r--framework/src/test/java/org/onap/cli/fw/utils/OpenCommandRegistrarTest.java42
37 files changed, 3625 insertions, 0 deletions
diff --git a/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSample.java b/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSample.java
new file mode 100644
index 00000000..69714ad7
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSample.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.cmd.sample;
+
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.OnapCommandSchema;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandExecutionFailed;
+
+/**
+ * This command helps to test the Command functionalities.
+ *
+ */
+@OnapCommandSchema(name = "sample-test", schema = "sample-test-schema.yaml")
+public class OnapCommandSample extends OnapCommand {
+
+ public OnapCommandSample() {
+ this(true);
+ }
+
+ public OnapCommandSample(boolean isInit) {
+ this.isInitialzied = isInit;
+ }
+
+ public boolean failCase = false;
+
+ @Override
+ protected void run() throws OnapCommandException {
+ if (this.failCase)
+ throw new OnapCommandExecutionFailed("Test case to fail");
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSampleTest.java b/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSampleTest.java
new file mode 100644
index 00000000..9cf6bdf5
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSampleTest.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.cmd.sample;
+
+import org.junit.Test;
+import org.onap.cli.fw.conf.Constants;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandExecutionFailed;
+import org.onap.cli.fw.error.OnapCommandNotInitialized;
+import org.onap.cli.fw.input.OnapCommandParameter;
+import org.onap.cli.fw.input.ParameterType;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OnapCommandSampleTest {
+ @Test
+ public void sampleTestVersion() {
+ OnapCommandSample sample = new OnapCommandSample();
+
+ try {
+ List<OnapCommandParameter> parameters = new ArrayList();
+ OnapCommandParameter v = new OnapCommandParameter();
+ v.setName(Constants.DEFAULT_PARAMETER_VERSION);
+ v.setValue("true");
+ parameters.add(v);
+ OnapCommandParameter h = new OnapCommandParameter();
+ h.setName(Constants.DEFAULT_PARAMETER_HELP);
+ h.setValue("false");
+ parameters.add(h);
+ sample.setParameters(parameters);
+ sample.execute();
+ } catch (OnapCommandException e) {
+ }
+ }
+
+ @Test
+ public void sampleTestHelp() {
+ OnapCommandSample sample = new OnapCommandSample();
+ try {
+ List<OnapCommandParameter> parameters = new ArrayList();
+ OnapCommandParameter v = new OnapCommandParameter();
+ v.setName(Constants.DEFAULT_PARAMETER_HELP);
+ v.setValue("true");
+ v.setParameterType(ParameterType.BOOL);
+ parameters.add(v);
+ sample.setParameters(parameters);
+ sample.execute();
+ } catch (OnapCommandException e) {
+ }
+ }
+
+ @Test
+ public void sampleTest() {
+ OnapCommandSample sample = new OnapCommandSample();
+ try {
+ List<OnapCommandParameter> parameters = new ArrayList();
+ OnapCommandParameter v = new OnapCommandParameter();
+ v.setName(Constants.DEFAULT_PARAMETER_VERSION);
+ v.setValue("false");
+ parameters.add(v);
+ OnapCommandParameter h = new OnapCommandParameter();
+ h.setName(Constants.DEFAULT_PARAMETER_HELP);
+ h.setValue("false");
+ parameters.add(h);
+ OnapCommandParameter f = new OnapCommandParameter();
+ f.setName(Constants.DEFAULT_PARAMETER_OUTPUT_FORMAT);
+ f.setValue("table");
+ parameters.add(f);
+ OnapCommandParameter l = new OnapCommandParameter();
+ l.setName(Constants.DEFAULT_PARAMETER_OUTPUT_ATTR_LONG);
+ l.setValue("true");
+ parameters.add(l);
+ OnapCommandParameter t = new OnapCommandParameter();
+ t.setName(Constants.DEFAULT_PARAMETER_OUTPUT_NO_TITLE);
+ t.setValue("true");
+ parameters.add(t);
+ OnapCommandParameter a = new OnapCommandParameter();
+ a.setName(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH);
+ a.setValue("true");
+ parameters.add(a);
+ OnapCommandParameter d = new OnapCommandParameter();
+ d.setName(Constants.DEFAULT_PARAMETER_DEBUG);
+ d.setValue("true");
+ parameters.add(d);
+ OnapCommandParameter m = new OnapCommandParameter();
+ m.setName(Constants.DEAFULT_PARAMETER_MSB_URL);
+ m.setValue("http://localhost");
+ parameters.add(m);
+ sample.setParameters(parameters);
+ sample.execute();
+ } catch (OnapCommandException e) {
+ }
+ }
+
+ @Test(expected = OnapCommandExecutionFailed.class)
+ public void sampleTestFailure() throws OnapCommandException {
+ OnapCommandSample sample = new OnapCommandSample();
+ sample.failCase = true;
+
+ List<OnapCommandParameter> parameters = new ArrayList();
+ OnapCommandParameter v = new OnapCommandParameter();
+ v.setName(Constants.DEFAULT_PARAMETER_VERSION);
+ v.setValue("false");
+ parameters.add(v);
+ OnapCommandParameter h = new OnapCommandParameter();
+ h.setName(Constants.DEFAULT_PARAMETER_HELP);
+ h.setValue("false");
+ parameters.add(h);
+ OnapCommandParameter f = new OnapCommandParameter();
+ f.setName(Constants.DEFAULT_PARAMETER_OUTPUT_FORMAT);
+ f.setValue("table");
+ parameters.add(f);
+ OnapCommandParameter l = new OnapCommandParameter();
+ l.setName(Constants.DEFAULT_PARAMETER_OUTPUT_ATTR_LONG);
+ l.setValue("true");
+ parameters.add(l);
+ OnapCommandParameter t = new OnapCommandParameter();
+ t.setName(Constants.DEFAULT_PARAMETER_OUTPUT_NO_TITLE);
+ t.setValue("true");
+ parameters.add(t);
+ OnapCommandParameter a = new OnapCommandParameter();
+ a.setName(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH);
+ a.setValue("true");
+ parameters.add(a);
+ OnapCommandParameter d = new OnapCommandParameter();
+ d.setName(Constants.DEFAULT_PARAMETER_DEBUG);
+ d.setValue("true");
+ parameters.add(d);
+ OnapCommandParameter m = new OnapCommandParameter();
+ m.setName(Constants.DEAFULT_PARAMETER_MSB_URL);
+ m.setValue("http://localhost");
+ parameters.add(m);
+ sample.setParameters(parameters);
+ sample.execute();
+ }
+
+ @Test(expected = OnapCommandNotInitialized.class)
+ public void sampleTestIsInitialized() throws OnapCommandException {
+ OnapCommandSample sample = new OnapCommandSample(false);
+ sample.execute();
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/OnapCommandRegistrarTest.java b/framework/src/test/java/org/onap/cli/fw/OnapCommandRegistrarTest.java
new file mode 100644
index 00000000..83f3a743
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/OnapCommandRegistrarTest.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandHelpFailed;
+import org.onap.cli.fw.error.OnapCommandNotFound;
+import org.onap.cli.fw.error.OnapCommandRegistrationFailed;
+
+import java.io.File;
+import java.net.URL;
+
+public class OnapCommandRegistrarTest {
+
+ OnapCommandRegistrar registerar;
+
+ @Before
+ public void setup() throws OnapCommandException {
+ registerar = OnapCommandRegistrar.getRegistrar();
+ createDir();
+ }
+
+ private void createDir() {
+ URL url = OnapCommandRegistrarTest.class.getClassLoader().getResource("onap-cli-schema");
+ if (url != null) {
+ String path = url.getPath();
+ path = path.replaceFirst("onap-cli-schema", "data");
+ File file = new File(path);
+ if (!file.exists()) {
+ file.mkdir();
+ } else {
+ File f1 = new File(path + "/external-schema.json");
+ f1.delete();
+ }
+ }
+ }
+
+ @Test
+ public void registerTest() throws OnapCommandException {
+ OnapCommand test = new OnapCommandTest();
+ Class<OnapCommand> cmd = (Class<OnapCommand>) test.getClass();
+ registerar.register("Test", cmd);
+ OnapCommand cc = registerar.get("Test");
+ assertTrue(cmd == cc.getClass());
+
+ }
+
+ @Test
+ // For Coverage
+ public void cmdTestSchema() throws OnapCommandException {
+ OnapCommand test = new OnapCommandTest();
+ Class<OnapCommand> cmd = (Class<OnapCommand>) test.getClass();
+ registerar.register("Test", cmd);
+ OnapCommand cc = registerar.get("Test");
+ }
+
+ @Test
+ public void onapCommandNotFoundTest() throws OnapCommandException {
+ try {
+ registerar = OnapCommandRegistrar.getRegistrar();
+ registerar.get("Test1");
+ fail("This should have thrown an exception");
+ } catch (OnapCommandNotFound e) {
+ assertEquals(e.getMessage(), "0x0011::Command Test1 is not registered");
+ }
+ }
+
+ @Test
+ public void onapCommandRegistrationFailedTest() throws OnapCommandException {
+
+ @OnapCommandSchema(name = "Test2", schema = "sample-test-schema.yaml")
+ class Test extends OnapCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+
+ }
+
+ }
+
+ OnapCommand com = new Test();
+ Class<OnapCommand> cmd = (Class<OnapCommand>) com.getClass();
+ try {
+ registerar.register("Test2", cmd);
+ registerar.get("Test2");
+ fail("This should have thrown an exception");
+ } catch (OnapCommandRegistrationFailed e) {
+ assertTrue(e.getMessage().contains("0x0018::Command Test2 is failed to register"));
+ }
+ }
+
+ @Test(expected = OnapCommandHelpFailed.class)
+ // For coverage
+ public void helpTestException() throws OnapCommandException {
+ OnapCommand test = new OnapCommandTest1();
+ Class<OnapCommand> cmd = (Class<OnapCommand>) test.getClass();
+ registerar = new OnapCommandRegistrar();
+ registerar.register("test1", cmd);
+ String help = registerar.getHelp();
+ assertNotNull(help);
+ }
+
+ @Test
+ public void helpTest() throws OnapCommandException {
+ String help = registerar.getHelp();
+ assertNotNull(help);
+ }
+
+ @Test
+ public void versionTest() throws OnapCommandHelpFailed {
+ String version = registerar.getVersion();
+ assertNotNull(version);
+ }
+
+ @Test
+ public void listTest() {
+ registerar.listCommands();
+ }
+}
+
+@OnapCommandSchema(name = OnapCommandTest.CMD_NAME, schema = "sample-test-schema.yaml")
+class OnapCommandTest extends OnapCommand {
+
+ public OnapCommandTest() {
+
+ }
+
+ public static final String CMD_NAME = "test";
+
+ protected void run() throws OnapCommandException {
+
+ }
+
+}
+
+@OnapCommandSchema(name = OnapCommandTest1.CMD_NAME, schema = "test-schema.yaml")
+class OnapCommandTest1 extends OnapCommand {
+
+ public OnapCommandTest1() {
+
+ }
+
+ public static final String CMD_NAME = "test1";
+
+ protected void run() throws OnapCommandException {
+
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/ad/OnapAuthClientTest.java b/framework/src/test/java/org/onap/cli/fw/ad/OnapAuthClientTest.java
new file mode 100644
index 00000000..720737b3
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/ad/OnapAuthClientTest.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.ad;
+
+import static org.junit.Assert.assertEquals;
+
+import mockit.Invocation;
+import mockit.Mock;
+import mockit.MockUp;
+
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.cli.fw.conf.OnapCommandConfg;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandExecutionFailed;
+import org.onap.cli.fw.error.OnapCommandHttpFailure;
+import org.onap.cli.fw.error.OnapCommandServiceNotFound;
+import org.onap.cli.fw.http.HttpInput;
+import org.onap.cli.fw.http.HttpResult;
+import org.onap.cli.fw.http.OnapHttpConnection;
+
+public class OnapAuthClientTest {
+
+ OnapAuthClient client;
+
+ @Before
+ public void setUp() throws OnapCommandHttpFailure {
+ OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80");
+ client = new OnapAuthClient(creds, true);
+ }
+
+ @Test
+ public void loginFailedAuthIgnoredTest() throws OnapCommandException {
+ OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80");
+ OnapAuthClient client = new OnapAuthClient(creds, true);
+ if (OnapCommandConfg.isAuthIgnored()) {
+ client.getDebugInfo();
+ client.login();
+ assertEquals(null, client.getAuthToken());
+ }
+ }
+
+ @Test
+ public void logoutFailedAuthIgnoredTest() throws OnapCommandException {
+ OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80");
+ OnapAuthClient client = new OnapAuthClient(creds, true);
+ if (OnapCommandConfg.isAuthIgnored()) {
+ client.logout();
+ assertEquals(null, client.getAuthToken());
+ }
+ }
+
+ @Test
+ public void getMsbUrlTest() throws OnapCommandException {
+ OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80");
+ OnapAuthClient client = new OnapAuthClient(creds, true);
+ OnapService srv = new OnapService();
+ srv.setName("msb");
+ String msb = client.getServiceBasePath(srv);
+ assertEquals("http://192.168.99.10:80/api/microservices/v1", msb);
+ }
+
+ @Test(expected = OnapCommandServiceNotFound.class)
+ public void loginFailedServiceNotFoundTest() throws OnapCommandException {
+ mockIsAuthIgnored(false);
+ HttpResult result = new HttpResult();
+ result.setStatus(404);
+ mockHttpRequest(result);
+ client.login();
+
+ }
+
+ @Test(expected = OnapCommandExecutionFailed.class)
+ public void loginFailedCommandExecutionFailedTest() throws OnapCommandException {
+
+ mockIsAuthIgnored(false);
+ HttpResult result = new HttpResult();
+ result.setStatus(401);
+ mockHttpRequest(result);
+ client.login();
+ }
+
+ @Test(expected = OnapCommandExecutionFailed.class)
+ public void loginFailedWrongJasonBodyTest() throws OnapCommandException {
+ mockIsAuthIgnored(false);
+ HttpResult result = new HttpResult();
+ result.setStatus(200);
+ mockHttpRequest(result);
+ client.login();
+ }
+
+ @Test
+ public void loginSuccessTest() {
+
+ mockIsAuthIgnored(false);
+ HttpResult result = new HttpResult();
+ result.setBody("{\"url\":\"http://192.168.4.47\"}");
+ result.setStatus(200);
+ mockHttpConsecutiveRequest(result);
+ try {
+ client.login();
+ } catch (OnapCommandException e) {
+ }
+ mockHttpRequest(null);
+ }
+
+ @Test
+ public void logoutFailedTest() {
+
+ mockIsAuthIgnored(false);
+ HttpResult result = new HttpResult();
+ result.setBody("{\"url\":\"http://192.168.4.47\"}");
+ result.setStatus(200);
+ mockHttpConsecutiveRequest(result);
+ try {
+ client.logout();
+ } catch (OnapCommandException e) {
+ }
+ mockHttpRequest(null);
+ }
+
+ @Test
+ public void logoutSuccessTest() {
+
+ mockIsAuthIgnored(false);
+ HttpResult result = new HttpResult();
+ result.setBody("{\"url\":\"http://192.168.4.47\"}");
+ result.setStatus(204);
+ mockHttpConsecutiveRequest(result);
+ try {
+ client.logout();
+ } catch (OnapCommandException e) {
+ }
+ mockHttpRequest(null);
+ }
+
+ private void mockIsAuthIgnored(boolean isAuthIgnored) {
+
+ new MockUp<OnapCommandConfg>() {
+ boolean isMock = true;
+
+ @Mock
+ public boolean isAuthIgnored(Invocation inv) {
+ if (isMock) {
+ isMock = false;
+ return isAuthIgnored;
+ } else {
+ return inv.proceed();
+ }
+ }
+ };
+ }
+
+ private static void mockHttpRequest(HttpResult result) {
+ new MockUp<OnapHttpConnection>() {
+ boolean isMock = true;
+
+ @Mock
+ public HttpResult request(Invocation inv, HttpInput input) throws OnapCommandHttpFailure {
+ if (isMock) {
+ isMock = false;
+ return result;
+ } else {
+ return inv.proceed(input);
+ }
+ }
+ };
+ }
+
+ private void mockHttpConsecutiveRequest(HttpResult result) {
+ new MockUp<OnapHttpConnection>() {
+ @Mock
+ public HttpResult request(Invocation inv, HttpInput input) throws OnapCommandHttpFailure {
+ return result;
+ }
+ };
+ }
+
+ @AfterClass
+ public static void clear() {
+ HttpResult result = new HttpResult();
+ result.setBody("{\"url\":\"http://192.168.4.47\"}");
+ result.setStatus(200);
+ mockHttpRequest(result);
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/ad/OnapCredentialsTest.java b/framework/src/test/java/org/onap/cli/fw/ad/OnapCredentialsTest.java
new file mode 100644
index 00000000..a1987c08
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/ad/OnapCredentialsTest.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.ad;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class OnapCredentialsTest {
+
+ @Test
+ public void credentialsTest() {
+ OnapCredentials cre = new OnapCredentials("test", "test123", "url");
+ assertTrue(cre.getUsername().equals("test") && cre.getPassword().equals("test123")
+ && cre.getMsbUrl().equals("url"));
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/ad/OnapServiceTest.java b/framework/src/test/java/org/onap/cli/fw/ad/OnapServiceTest.java
new file mode 100644
index 00000000..f0ec8c63
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/ad/OnapServiceTest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.ad;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class OnapServiceTest {
+
+ @Test
+ public void serviceTest() {
+ OnapService ser = new OnapService();
+ ser.setName("name");
+ ser.setVersion("1.0");
+ ser.setBasePath("basePath");
+ ser.setNoAuth(true);
+ assertTrue(ser.getName().equals("name") && ser.getVersion().equals("1.0")
+ && ser.getBasePath().equals("basePath") && ser.isNoAuth());
+
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommand.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommand.java
new file mode 100644
index 00000000..069ae35f
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommand.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandExecutionFailed;
+import org.onap.cli.fw.error.OnapCommandExecutorInfoMissing;
+import org.onap.cli.fw.error.OnapCommandInvalidParameterValue;
+import org.onap.cli.fw.error.OnapCommandResultInitialzationFailed;
+import org.onap.cli.fw.utils.OnapCommandUtils;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+public class OnapCreateSwaggerBasedCommand extends OnapSwaggerCommand {
+
+ private <T> T initializeEntity(T obj, List<String> prps) throws OnapCommandResultInitialzationFailed {
+ for (int i = 1; i < prps.size(); i++) {
+ String paramName = prps.get(i).trim();
+ String prpName = paramName;
+ // paramName(prpName)
+ if (prpName.contains("(")) {
+ paramName = prpName.substring(0, prpName.indexOf("("));
+ prpName = prpName.substring(prpName.indexOf("(") + 1, prpName.indexOf(")"));
+ }
+ String methodName = OnapCommandUtils.formMethodNameFromAttributeName(prpName, "set");
+
+ try {
+ Method set = obj.getClass().getMethod(methodName, String.class);
+ set.invoke(obj, this.getParametersMap().get(paramName).getValue());
+ } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
+ | InvocationTargetException | OnapCommandInvalidParameterValue e) {
+ throw new OnapCommandResultInitialzationFailed(this.getName(), e);
+ }
+ }
+ return obj;
+ }
+
+ @Override
+ protected void run() throws OnapCommandException {
+ if (this.getExecutor() == null) {
+ throw new OnapCommandExecutorInfoMissing(this.getName());
+ }
+
+ try {
+ // Initialize client
+ Class clientClaz = Class.forName(this.getExecutor().getClient());
+ Object client = clientClaz.getConstructor().newInstance();
+ this.initializeApiClient(client);
+
+ // Initialize api
+ Class apiCls = Class.forName(this.getExecutor().getApi());
+ Object api = apiCls.getConstructor(clientClaz).newInstance(client);
+
+ // invoke method
+ List<String> methodTokens = Arrays.asList(this.getExecutor().getMethod().split(","));
+
+ List<String> entityTokens = Arrays.asList(this.getExecutor().getEntity().split(","));
+ Class entityCls = Class.forName(entityTokens.get(0));
+ Object entity = entityCls.newInstance();
+ Method method = api.getClass().getMethod(methodTokens.get(0), entityCls);
+ Object result = method.invoke(api, this.initializeEntity(entity, entityTokens));
+
+ // initialize result
+ this.initializeResult(result);
+ } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
+ | IllegalArgumentException | InvocationTargetException e) {
+ throw new OnapCommandExecutionFailed(this.getName(), e);
+ } catch (OnapCommandException e) {
+ throw e;
+ } catch (Exception e) {
+ try {
+ Class execCls = Class.forName(this.getExecutor().getException());
+ Method execMethod = execCls.getClass().getMethod("getCode");
+ if (execCls.isInstance(e)) {
+ throw new OnapCommandExecutionFailed(this.getName(), e, (Integer) execMethod.invoke(e));
+ }
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
+ | ClassNotFoundException | NoSuchMethodException | SecurityException e1) {
+ throw new OnapCommandExecutionFailed(this.getName(), e1.getMessage());
+ }
+ throw new OnapCommandExecutionFailed(this.getName(), e.getMessage());
+ }
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommandTest.java
new file mode 100644
index 00000000..ec4b91d4
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommandTest.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.junit.Test;
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.error.OnapCommandException;
+
+public class OnapCreateSwaggerBasedCommandTest {
+
+ @Test
+ public void runTest() throws OnapCommandException {
+ OnapCommand cmd = new OnapCreateSwaggerBasedCommand();
+ cmd.initializeSchema("sample-test-schema-swagger.yaml");
+ //cmd.execute();
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommand.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommand.java
new file mode 100644
index 00000000..1db954c6
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommand.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandExecutionFailed;
+import org.onap.cli.fw.error.OnapCommandExecutorInfoMissing;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Helps to make delete rest calls on top of swagger generated java client. For example following one shows how MSB
+ * service list is achieved here exec: ... method: deleteMicroService, [input param name given under Parameters]
+ *
+ */
+public class OnapDeleteSwaggerBasedCommand extends OnapSwaggerCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ if (this.getExecutor() == null) {
+ throw new OnapCommandExecutorInfoMissing(this.getName());
+ }
+
+ try {
+ // Initialize client
+ Class clientCls = Class.forName(this.getExecutor().getClient());
+ Object client = clientCls.getConstructor().newInstance();
+ this.initializeApiClient(client);
+
+ // Initialize api
+ Class apiCls = Class.forName(this.getExecutor().getApi());
+ Object api = apiCls.getConstructor(clientCls).newInstance(client);
+
+ // invoke method
+ List<String> methodTokens = Arrays.asList(this.getExecutor().getMethod().split(","));
+
+ Method method = api.getClass().getMethod(methodTokens.get(0), String.class);
+ method.invoke(api, this.getParametersMap().get(methodTokens.get(1)).getValue());
+ } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
+ | IllegalArgumentException | InvocationTargetException e) {
+ throw new OnapCommandExecutionFailed(this.getName(), e);
+ } catch (OnapCommandException e) {
+ throw e;
+ } catch (Exception e) {
+ try {
+ Class execCls = Class.forName(this.getExecutor().getException());
+ Method execMethod = execCls.getClass().getMethod("getCode");
+ if (execCls.isInstance(e)) {
+ throw new OnapCommandExecutionFailed(this.getName(), e, (Integer) execMethod.invoke(e));
+ }
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
+ | ClassNotFoundException | NoSuchMethodException | SecurityException e1) {
+ throw new OnapCommandExecutionFailed(this.getName(), e1.getMessage());
+ }
+ throw new OnapCommandExecutionFailed(this.getName(), e.getMessage());
+ }
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommandTest.java
new file mode 100644
index 00000000..a242a683
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommandTest.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+public class OnapDeleteSwaggerBasedCommandTest {
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommand.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommand.java
new file mode 100644
index 00000000..8ed86564
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommand.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandExecutionFailed;
+import org.onap.cli.fw.error.OnapCommandExecutorInfoMissing;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Helps to make get rest calls on top of swagger generated java client. For example following one shows how MSB service
+ * list is achieved here exec: ... method: getMicroService, [input param name given under Parameters]
+ *
+ */
+public class OnapGetSwaggerBasedCommand extends OnapSwaggerCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ if (this.getExecutor() == null) {
+ throw new OnapCommandExecutorInfoMissing(this.getName());
+ }
+
+ try {
+ // Initialize client
+ Class clientCls = Class.forName(this.getExecutor().getClient());
+ Object client = clientCls.getConstructor().newInstance();
+ this.initializeApiClient(client);
+
+ // Initialize api
+ Class apiCls = Class.forName(this.getExecutor().getApi());
+ Object api = apiCls.getConstructor(clientCls).newInstance(client);
+
+ // invoke method
+ List<String> methodTokens = Arrays.asList(this.getExecutor().getMethod().split(","));
+
+ Method method = api.getClass().getMethod(methodTokens.get(0), String.class);
+ Object result = method.invoke(api, this.getParametersMap().get(methodTokens.get(1)).getValue());
+
+ // initialize result
+ this.initializeResult(result);
+
+ } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
+ | IllegalArgumentException | InvocationTargetException e) {
+ throw new OnapCommandExecutionFailed(this.getName(), e);
+ } catch (OnapCommandException e) {
+ throw e;
+ } catch (Exception e) {
+ try {
+ Class execCls = Class.forName(this.getExecutor().getException());
+ Method execMethod = execCls.getClass().getMethod("getCode");
+ if (execCls.isInstance(e)) {
+ throw new OnapCommandExecutionFailed(this.getName(), e, (Integer) execMethod.invoke(e));
+ }
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
+ | ClassNotFoundException | NoSuchMethodException | SecurityException e1) {
+ throw new OnapCommandExecutionFailed(this.getName(), e1.getMessage());
+ }
+ throw new OnapCommandExecutionFailed(this.getName(), e.getMessage());
+ }
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommandTest.java
new file mode 100644
index 00000000..5c301a62
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommandTest.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+public class OnapGetSwaggerBasedCommandTest {
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapHttpCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapHttpCommandTest.java
new file mode 100644
index 00000000..e7af1aa3
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapHttpCommandTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.http.HttpInput;
+import org.onap.cli.fw.input.OnapCommandParameter;
+import org.onap.cli.fw.input.ParameterType;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class OnapHttpCommandTest {
+
+ @Test(expected = OnapCommandException.class)
+ public void runTest() throws OnapCommandException {
+ OnapCommandParameter param1 = new OnapCommandParameter();
+ param1.setLongOption("onap-username");
+ param1.setName("onap-username");
+ param1.setParameterType(ParameterType.STRING);
+ OnapCommandParameter param2 = new OnapCommandParameter();
+ param2.setLongOption("onap-password");
+ param2.setName("onap-password");
+ param2.setParameterType(ParameterType.STRING);
+ OnapCommandParameter param3 = new OnapCommandParameter();
+ param3.setLongOption("msb-url");
+ param3.setName("msb-url");
+ param3.setParameterType(ParameterType.STRING);
+ OnapCommandParameter param4 = new OnapCommandParameter();
+ param4.setLongOption("string-param");
+ param4.setName("string-param");
+ param4.setParameterType(ParameterType.STRING);
+ OnapCommandParameter param5 = new OnapCommandParameter();
+ param5.setLongOption("long-opt");
+ param5.setName("long-opt");
+ param5.setParameterType(ParameterType.STRING);
+
+ List<OnapCommandParameter> paramslist = new ArrayList<>();
+ paramslist.add(param1);
+ paramslist.add(param2);
+ paramslist.add(param3);
+ paramslist.add(param4);
+ paramslist.add(param5);
+
+ HttpInput inp = new HttpInput();
+ inp.setBody("body");
+ inp.setMethod("method");
+ inp.setReqCookies(new HashMap<String, String>());
+ inp.setReqHeaders(new HashMap<String, String>());
+ inp.setReqQueries(new HashMap<String, String>());
+ inp.setUri("uri");
+
+ OnapHttpCommand com = new OnapHttpCommand();
+ com.setParameters(paramslist);
+ com.getParameters();
+ com.getParametersMap();
+ com.setInput(inp);
+ com.initializeSchema("sample-test-schema.yaml");
+ com.execute();
+
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommand.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommand.java
new file mode 100644
index 00000000..a5795e75
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommand.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandExecutionFailed;
+import org.onap.cli.fw.error.OnapCommandExecutorInfoMissing;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Helps to make list rest calls on top of swagger generated java client. For example following one shows how MSB
+ * service list is achived here exec: api:
+ * org.onap.common_services.microservice_bus.apiroute_service.client.api.MSBServiceResourceApi client:
+ * org.onap.common_services.microservice_bus.apiroute_service.client.invoker.ApiClient method: getMicroService
+ * exception: org.onap.common_services.microservice_bus.apiroute_service.client.invoker.ApiException
+ *
+ */
+public class OnapListSwaggerBasedCommand extends OnapSwaggerCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ if (this.getExecutor() == null) {
+ throw new OnapCommandExecutorInfoMissing(this.getName());
+ }
+
+ try {
+ // Initialize client
+ Class clientCls = Class.forName(this.getExecutor().getClient());
+ Object client = clientCls.getConstructor().newInstance();
+ this.initializeApiClient(client);
+
+ // Initialize api
+ Class apiCls = Class.forName(this.getExecutor().getApi());
+ Object api = apiCls.getConstructor(clientCls).newInstance(client);
+
+ // invoke method
+ Method method = api.getClass().getMethod(this.getExecutor().getMethod());
+ Object result = method.invoke(api);
+
+ // initialize result
+ this.initializeResult(result);
+
+ } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
+ | IllegalArgumentException | InvocationTargetException e) {
+ throw new OnapCommandExecutionFailed(this.getName(), e);
+ } catch (OnapCommandException e) {
+ throw e;
+ } catch (Exception e) {
+ try {
+ Class execCls = Class.forName(this.getExecutor().getException());
+ Method execMethod = execCls.getClass().getMethod("getCode");
+ if (execCls.isInstance(e)) {
+ throw new OnapCommandExecutionFailed(this.getName(), e, (Integer) execMethod.invoke(e));
+ }
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
+ | ClassNotFoundException | NoSuchMethodException | SecurityException e1) {
+ throw new OnapCommandExecutionFailed(this.getName(), e1.getMessage());
+ }
+ throw new OnapCommandExecutionFailed(this.getName(), e.getMessage());
+ }
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommandTest.java
new file mode 100644
index 00000000..5683153c
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommandTest.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+public class OnapListSwaggerBasedCommandTest {
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommandTest.java
new file mode 100644
index 00000000..1c09c0d3
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommandTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.input.OnapCommandParameter;
+
+public class OnapSchemaRefreshCommandTest {
+
+ @Test
+ public void validateSchemaCommandTest1() throws OnapCommandException {
+ OnapSchemaRefreshCommand cmd = new OnapSchemaRefreshCommand();
+ cmd.initializeSchema("schema-refresh.yaml");
+ for (OnapCommandParameter param : cmd.getParameters()) {
+ if ("onap-username".equals(param.getName())) {
+ param.setValue("test");
+ } else if ("onap-password".equals(param.getName())) {
+ param.setValue("test");
+ } else if ("msb-url".equals(param.getName())) {
+ param.setValue("test-url");
+ }
+ }
+ cmd.execute();
+ }
+
+ @Test
+ public void validateSchemaCommandTest2() throws OnapCommandException {
+ OnapSchemaRefreshCommand cmd = new OnapSchemaRefreshCommand();
+ cmd.initializeSchema("schema-refresh.yaml");
+ for (OnapCommandParameter param : cmd.getParameters()) {
+ if ("onap-username".equals(param.getName())) {
+ param.setValue("test");
+ } else if ("onap-password".equals(param.getName())) {
+ param.setValue("test");
+ } else if ("msb-url".equals(param.getName())) {
+ param.setValue("test-url");
+ }
+ }
+ cmd.execute();
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommandTest.java
new file mode 100644
index 00000000..b70bf6f9
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommandTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.input.OnapCommandParameter;
+import org.onap.cli.fw.schema.ValidateSchemaTest;
+
+public class OnapSchemaValidateCommandTest {
+
+ @Test
+ public void validateSchemaCommandTest1() throws OnapCommandException {
+ OnapSchemaValidateCommand cmd = new OnapSchemaValidateCommand();
+ cmd.initializeSchema("schema-validate.yaml");
+ for (OnapCommandParameter param : cmd.getParameters()) {
+ if ("onap-username".equals(param.getName())) {
+ param.setValue("test");
+ } else if ("onap-password".equals(param.getName())) {
+ param.setValue("test");
+ } else if ("msb-url".equals(param.getName())) {
+ param.setValue("test-url");
+ } else if ("schema-location".equals(param.getName())) {
+ param.setValue("schema-validate-pass.yaml");
+ } else if ("internal-schema".equals(param.getName())) {
+ param.setValue("true");
+ }
+ }
+ cmd.execute();
+ }
+
+ @Test
+ public void validateSchemaCommandTest2() throws OnapCommandException {
+ OnapSchemaValidateCommand cmd = new OnapSchemaValidateCommand();
+ cmd.initializeSchema("schema-validate.yaml");
+ for (OnapCommandParameter param : cmd.getParameters()) {
+ if ("onap-username".equals(param.getName())) {
+ param.setValue("test");
+ } else if ("onap-password".equals(param.getName())) {
+ param.setValue("test");
+ } else if ("msb-url".equals(param.getName())) {
+ param.setValue("test-url");
+ } else if ("schema-location".equals(param.getName())) {
+ param.setValue(
+ ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-pass.yaml").getFile());
+ }
+ }
+ cmd.execute();
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapSwaggerCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSwaggerCommandTest.java
new file mode 100644
index 00000000..628b9a42
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSwaggerCommandTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.cmd;
+
+import org.junit.Test;
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.error.OnapCommandClientInitialzationFailed;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandResultInitialzationFailed;
+import org.onap.cli.fw.input.OnapCommandParameter;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class OnapSwaggerCommandTest {
+
+ @Test(expected = OnapCommandResultInitialzationFailed.class)
+ public void initializeResultTest1() throws OnapCommandException {
+ OnapSwaggerCommandImpl swagger = new OnapSwaggerCommandImpl();
+ swagger.initializeSchema("onap-test-schema.yaml");
+ List<String> obj = new ArrayList<>();
+ obj.add("name");
+ obj.add("get");
+ swagger.initializeResult(obj);
+
+ Set<String> obj1 = new HashSet<>();
+ obj.add("name");
+ obj.add("get");
+ swagger.initializeResult(obj1);
+ }
+
+ @Test(expected = OnapCommandResultInitialzationFailed.class)
+ public void initializeResultTest2() throws OnapCommandException {
+ OnapSwaggerCommandImpl swagger = new OnapSwaggerCommandImpl();
+ swagger.initializeSchema("onap-test-schema.yaml");
+ Set<String> obj1 = new HashSet<>();
+ obj1.add("name");
+ obj1.add("get");
+ swagger.initializeResult(obj1);
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void initializeResultTest3() throws OnapCommandException {
+ OnapSwaggerCommandImpl swagger = new OnapSwaggerCommandImpl();
+ swagger.initializeSchema("onap-test-schema.yaml");
+ ApiClient cit = new ApiClient();
+ cit.setApiKey("apiKey");
+ cit.setBasePath("basePath");
+ swagger.initializeApiClient(cit);
+ }
+
+ class OnapSwaggerCommandImpl extends OnapSwaggerCommand {
+ protected void run() throws OnapCommandException {
+ }
+
+ }
+
+ class ApiClient {
+
+ private String basePath;
+ private String apiKey;
+
+ public String getBasePath() {
+ return basePath;
+ }
+
+ public void setBasePath(String basePath) {
+ this.basePath = basePath;
+ }
+
+ public String getApiKey() {
+ return apiKey;
+ }
+
+ public void setApiKey(String apiKey) {
+ this.apiKey = apiKey;
+ }
+
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/conf/OnapCommandConfgTest.java b/framework/src/test/java/org/onap/cli/fw/conf/OnapCommandConfgTest.java
new file mode 100644
index 00000000..e345945b
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/conf/OnapCommandConfgTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.conf;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.Properties;
+
+public class OnapCommandConfgTest {
+
+ @Test
+ public void versionTest() {
+ String str = OnapCommandConfg.getVersion();
+ Assert.assertTrue(str != null);
+ }
+
+ @Test
+ public void isAuthIgnoredTest() throws IOException {
+ Properties prps = new Properties();
+ prps.load(OnapCommandConfg.class.getClassLoader().getResourceAsStream("onap.properties"));
+ boolean auth = OnapCommandConfg.isAuthIgnored();
+ Assert.assertTrue(auth == Boolean.valueOf(prps.getProperty("cli.ignore_auth")));
+ Assert.assertTrue(OnapCommandConfg.isCookiesBasedAuth() == Boolean
+ .valueOf(prps.getProperty("http.api_key_use_cookies")));
+ Assert.assertTrue("X-Auth-Token".equals(OnapCommandConfg.getXAuthTokenName()));
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/error/OnapCommandErrorTest.java b/framework/src/test/java/org/onap/cli/fw/error/OnapCommandErrorTest.java
new file mode 100644
index 00000000..1d0c1a6b
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/error/OnapCommandErrorTest.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.error;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class OnapCommandErrorTest {
+
+ @Test
+ public void onapCommandDiscoveryFailedTest() {
+ OnapCommandDiscoveryFailed failed = new OnapCommandDiscoveryFailed("name");
+ assertEquals("0x0010::Failed auto discover schema files from name under class path, ", failed.getMessage());
+ failed = new OnapCommandDiscoveryFailed("directory", "name");
+ assertEquals("0x0010::Failed auto generate json file 'name' under class path directory 'directory' , ",
+ failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandInvalidParameterValueTest() {
+ OnapCommandInvalidParameterValue failed = new OnapCommandInvalidParameterValue("name");
+ assertEquals("0x0028::Parameter name value is invalid, ", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandResultMapProcessingFailedTest() {
+ OnapCommandResultMapProcessingFailed failed = new OnapCommandResultMapProcessingFailed("name",
+ new Exception(""));
+ assertEquals("0x0028::Failed to process the result map name in http section, ", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandHttpHeaderNotFoundTest() {
+ OnapCommandHttpHeaderNotFound failed = new OnapCommandHttpHeaderNotFound("name");
+ assertEquals("0x0027::Http header name is not returned from the service", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandClientInitialzationFailedTest() {
+ OnapCommandClientInitialzationFailed failed = new OnapCommandClientInitialzationFailed("Test",
+ new Exception("Test Command Failed"));
+ assertEquals("0x0021::API client for the command Test is failed, Test Command Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandExceptionTest1() {
+ OnapCommandException failed = new OnapCommandException("1", "Test Command Failed");
+ assertEquals("1::Test Command Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandExceptionTest2() {
+ OnapCommandException failed = new OnapCommandException("1", "Test Command Failed", 201);
+ assertEquals("201::1::Test Command Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandExecutionFailedTest1() {
+ OnapCommandExecutionFailed failed = new OnapCommandExecutionFailed("Test", "Test Command Failed", 201);
+ assertEquals("201::0x0001::Command Test failed to execute, Test Command Failed", failed.getMessage());
+ failed = new OnapCommandExecutionFailed("Test", new Exception("Test Command Failed"), 201);
+ assertEquals("201::0x0001::Command Test failed to execute, Test Command Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandExecutionFailedTest2() {
+ OnapCommandExecutionFailed failed = new OnapCommandExecutionFailed("Test Command Failed");
+ assertEquals("0x0001::Test Command Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandExecutionFailedTest3() {
+ OnapCommandExecutionFailed failed = new OnapCommandExecutionFailed("Test", "Test Command Failed");
+ assertEquals("0x0001::Command Test failed to execute, Test Command Failed", failed.getMessage());
+
+ failed = new OnapCommandExecutionFailed("Test", new Exception("Test Command Failed"));
+ assertEquals("0x0001::Command Test failed to execute, Test Command Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandExecutorInfoMissingTest() {
+ OnapCommandExecutorInfoMissing failed = new OnapCommandExecutorInfoMissing("Test");
+
+ assertEquals("0x0023::Command Test excutor info is missing from schema", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandHelpFailedTest() {
+ OnapCommandHelpFailed failed = new OnapCommandHelpFailed(new Exception("Failed"));
+
+ assertEquals("0x0002::Command failed to print help message, Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandHttpFailureTest1() {
+ OnapCommandHttpFailure failed = new OnapCommandHttpFailure("Failed");
+ assertEquals("0x0025::Failed", failed.getMessage());
+
+ failed = new OnapCommandHttpFailure(new Exception("failed"), 201);
+ assertEquals("201::0x0025::failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandHttpFailureTest2() {
+ OnapCommandHttpFailure failed = new OnapCommandHttpFailure("Failed", 203);
+
+ assertEquals("203::0x0025::Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandInvalidParameterTypeTest() {
+ OnapCommandInvalidParameterType failed = new OnapCommandInvalidParameterType("Failed");
+
+ assertEquals("0x0003::Parameter type Failed is invalid", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandInvalidPrintDirectionTest() {
+ OnapCommandInvalidPrintDirection failed = new OnapCommandInvalidPrintDirection("Direction");
+
+ assertEquals("0x0004::Print direction Direction is invalid", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandInvalidRegistrationTest() {
+ OnapCommandInvalidRegistration failed = new OnapCommandInvalidRegistration(OnapCommandErrorTest.class);
+
+ assertEquals("0x0005::Invalid commad class org.onap.cli.fw.error.OnapCommandErrorTest registration, "
+ + "it should be derived from org.onap.cli.fw.OnapCommand", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandInvalidResultAttributeScopeTest() {
+ OnapCommandInvalidResultAttributeScope failed = new OnapCommandInvalidResultAttributeScope("Attribute");
+
+ assertEquals("0x0006::Result atrribute Attribute is invalid", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandInvalidSchemaTest() {
+ OnapCommandInvalidSchema failed = new OnapCommandInvalidSchema("Schema", "Failed");
+
+ assertEquals("0x0007::Command schema Schema is invalid, Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandInvalidSchemaVersionTest() {
+ OnapCommandInvalidSchemaVersion failed = new OnapCommandInvalidSchemaVersion("1.0");
+
+ assertEquals("0x0008::Command schema onap_cmd_schema_version 1.0 is invalid or missing", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandLoginFailedTest1() {
+ OnapCommandLoginFailed failed = new OnapCommandLoginFailed(new Exception("Failed"));
+
+ assertEquals("0x0009::Login failed, Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandLoginFailedTest2() {
+ OnapCommandLoginFailed failed = new OnapCommandLoginFailed("Failed", 201);
+
+ assertEquals("201::0x0009::Login failed, Failed", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandLogoutFailedTest() {
+ OnapCommandLogoutFailed failed = new OnapCommandLogoutFailed(new Exception("Failed"));
+ assertEquals("0x0010::Logout failed, Failed", failed.getMessage());
+
+ failed = new OnapCommandLogoutFailed(200);
+ assertEquals("200::0x0010::Logout failed, ", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandNotFoundTest() {
+ OnapCommandNotFound failed = new OnapCommandNotFound("Test");
+
+ assertEquals("0x0011::Command Test is not registered", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandNotInitializedTest() {
+ OnapCommandNotInitialized failed = new OnapCommandNotInitialized("Test");
+
+ assertEquals("0x0012::Command Test is not initialized", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandOutputPrintingFailedTest() {
+ OnapCommandOutputPrintingFailed failed = new OnapCommandOutputPrintingFailed(new Exception("error"));
+
+ assertEquals("0x0014::Command is failed to print the result, error", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandParameterMissingTest() {
+ OnapCommandParameterMissing failed = new OnapCommandParameterMissing("paramName");
+
+ assertEquals("0x0015::Parameter paramName is mandatory", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandParameterNameConflictTest() {
+ OnapCommandParameterNameConflict failed = new OnapCommandParameterNameConflict("paramName");
+
+ assertEquals("0x0016::Parameter name paramName is in conflict", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandParameterOptionConflictTest() {
+ OnapCommandParameterOptionConflict failed = new OnapCommandParameterOptionConflict("option");
+
+ assertEquals("0x0017::Parameter option option is in conflict, only one option is allowed with given name",
+ failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandRegistrationFailedTest() {
+ OnapCommandRegistrationFailed failed = new OnapCommandRegistrationFailed("Test", "error");
+
+ assertEquals("0x0018::Command Test is failed to register, error", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandResultInitialzationFailedTest() {
+ OnapCommandResultInitialzationFailed failed = new OnapCommandResultInitialzationFailed("Test",
+ new Exception("error"));
+
+ assertEquals("0x0022::Command Test result format is failed, error", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandSchemaNotFoundTest() {
+ OnapCommandSchemaNotFound failed = new OnapCommandSchemaNotFound("Test");
+
+ assertEquals("0x0019::Command schema Test is not found, ", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandServiceNotFoundTest() {
+ OnapCommandServiceNotFound failed = new OnapCommandServiceNotFound("Service");
+
+ assertEquals("0x0020::Service Service is not found in MSB", failed.getMessage());
+ }
+
+ @Test
+ public void onapCommandOutputFormatNotsupportedTest() {
+ OnapCommandOutputFormatNotsupported failed = new OnapCommandOutputFormatNotsupported("Format");
+
+ assertEquals("0x0013::Command does not support the output format Format", failed.getMessage());
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/http/HttpInputOutputTest.java b/framework/src/test/java/org/onap/cli/fw/http/HttpInputOutputTest.java
new file mode 100644
index 00000000..900d72e8
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/http/HttpInputOutputTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2016-17 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.http;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+
+public class HttpInputOutputTest {
+
+ @Test
+ public void httpInputTest() {
+ HttpInput inp = new HttpInput();
+ inp.setBody("body");
+ inp.setMethod("method");
+ inp.setReqCookies(null);
+ inp.setReqHeaders(null);
+ inp.setReqQueries(null);
+ inp.setUri("uri");
+
+ assertTrue("body".equals(inp.getBody()) && "method".equals(inp.getMethod()) && null == inp.getReqCookies()
+ && inp.getReqHeaders().isEmpty() && inp.getReqQueries().isEmpty() && "uri".equals(inp.getUri()));
+
+ inp.setReqCookies(new HashMap<String, String>());
+ inp.setReqHeaders(new HashMap<String, String>());
+ inp.setReqQueries(new HashMap<String, String>());
+
+ assertTrue(
+ "\nURL: uri\nMethod: method\nRequest Queries: {}\nRequest Body: body\nRequest Headers: {}\nRequest Cookies: {}\nbinaryData=false"
+ .equals(inp.toString()));
+ }
+
+ @Test
+ public void httpResultTest() {
+ HttpResult out = new HttpResult();
+ out.setBody("body");
+ out.setRespCookies(null);
+ out.setRespHeaders(null);
+ out.setStatus(205);
+
+ assertTrue("body".equals(out.getBody()) && null == out.getRespCookies() && null == out.getRespHeaders()
+ && 205 == out.getStatus());
+
+ out.setRespCookies(new HashMap<String, String>());
+ out.setRespHeaders(new HashMap<String, String>());
+ out.setStatus(200);
+ assertTrue("\nHTTP Status: 200\nResponse Body: body\nResponse Headers: {}\nResponse Cookies: {}"
+ .equals(out.toString()));
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/http/OnapHttpConnectionTest.java b/framework/src/test/java/org/onap/cli/fw/http/OnapHttpConnectionTest.java
new file mode 100644
index 00000000..cf6d73c1
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/http/OnapHttpConnectionTest.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.http;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import mockit.Invocation;
+import mockit.Mock;
+import mockit.MockUp;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.protocol.HttpContext;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandHttpFailure;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class OnapHttpConnectionTest {
+ HttpInput inp = null;
+ OnapHttpConnection con = null;
+
+ @Before
+ public void setup() {
+ mockHttpRequest(null);
+ inp = new HttpInput();
+ inp.setMethod("get");
+ inp.setBody("body");
+ Map<String, String> map1 = new HashMap<>();
+ map1.put("header1", "value1");
+ inp.setReqHeaders(map1);
+ Map<String, String> map2 = new HashMap<>();
+ map2.put("query1", "value1");
+ inp.setReqQueries(map2);
+ Map<String, String> map = new HashMap<>();
+ map.put("cookie1", "value1");
+ inp.setReqCookies(map);
+ inp.setUri("http://192.168.99.10:80");
+ }
+
+ @Test(expected = OnapCommandHttpFailure.class)
+ public void httpUnSecuredGetExceptionTest() throws OnapCommandHttpFailure {
+ new MockUp<CloseableHttpClient>() {
+ @Mock
+ public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context)
+ throws IOException, ClientProtocolException {
+
+ throw new IOException("IO Exception");
+ }
+ };
+ inp.setMethod("get");
+ con = new OnapHttpConnection(false, true);
+ con.getDebugInfo();
+ con.setAuthToken("fdsfdsfs");
+ assertTrue("fdsfdsfs".equals(con.getAuthToken()));
+ con.get(inp);
+
+ }
+
+ @Test(expected = OnapCommandHttpFailure.class)
+ public void httpUnSecuredPostExceptionTest() throws OnapCommandHttpFailure {
+ new MockUp<CloseableHttpClient>() {
+ @Mock
+ public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context)
+ throws IOException, ClientProtocolException {
+
+ throw new IOException("IO Exception");
+ }
+ };
+
+ inp.setMethod("post");
+ con = new OnapHttpConnection(false, true);
+ con.post(inp);
+ }
+
+
+ @Test(expected = OnapCommandHttpFailure.class)
+ public void httpUnSecuredPostExceptionTest1() throws OnapCommandHttpFailure {
+ new MockUp<CloseableHttpClient>() {
+ @Mock
+ public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context)
+ throws IOException, ClientProtocolException {
+
+ throw new IOException("IO Exception");
+ }
+ };
+
+ inp.setMethod("post");
+ inp.setBinaryData(true);
+ con = new OnapHttpConnection(false, true);
+ con.post(inp);
+ }
+
+ @Test(expected = OnapCommandHttpFailure.class)
+ public void httpUnSecuredPutExceptionTest() throws OnapCommandHttpFailure {
+ new MockUp<CloseableHttpClient>() {
+ @Mock
+ public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context)
+ throws IOException, ClientProtocolException {
+
+ throw new IOException("IO Exception");
+ }
+ };
+ inp.setMethod("put");
+ con = new OnapHttpConnection(false, true);
+ con.put(inp);
+ }
+
+ @Test(expected = OnapCommandHttpFailure.class)
+ public void httpUnSecuredDeleteExceptionTest() throws OnapCommandHttpFailure {
+ new MockUp<CloseableHttpClient>() {
+ @Mock
+ public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context)
+ throws IOException, ClientProtocolException {
+
+ throw new IOException("IO Exception");
+ }
+ };
+ inp.setMethod("delete");
+ con = new OnapHttpConnection(false, true);
+ con.delete(inp);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void httpUnSecuredOtherExceptionTest() throws OnapCommandHttpFailure {
+ new MockUp<CloseableHttpClient>() {
+ @Mock
+ public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context)
+ throws IOException, ClientProtocolException {
+
+ throw new IOException("IO Exception");
+ }
+ };
+ inp.setMethod("other");
+ con = new OnapHttpConnection(false, true);
+ con.request(inp);
+ }
+
+ @Test()
+ public void httpUnSecuredCloseExceptionTest() throws OnapCommandHttpFailure {
+ inp.setMethod("other");
+ con = new OnapHttpConnection(false, true);
+ con.close();
+ }
+
+ @Test
+ public void httpSecuredGetExceptionTest() {
+
+ // ProtocolVersion p = new ProtocolVersion("http",1,0);
+ // HttpResponse hr = DefaultHttpResponseFactory.INSTANCE.newHttpResponse(p, 200 , null) ;
+
+ new MockUp<CloseableHttpClient>() {
+ @Mock
+ public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context)
+ throws IOException, ClientProtocolException {
+
+ throw new IOException("IO Exception");
+ }
+ };
+ try {
+ HttpInput inp = new HttpInput();
+ inp.setMethod("get");
+ inp.setBody("body");
+ inp.setReqHeaders(new HashMap<String, String>());
+ inp.setReqQueries(new HashMap<String, String>());
+ inp.setUri("http://192.168.99.10:80");
+ OnapHttpConnection con = new OnapHttpConnection(true, false);
+ con.get(inp);
+ } catch (OnapCommandHttpFailure e) {
+ assertEquals("0x0025::IO Exception", e.getMessage());
+ }
+ }
+
+ private static void mockHttpRequest(HttpResult result) {
+ new MockUp<OnapHttpConnection>() {
+ boolean isMock = false;
+
+ @Mock
+ public HttpResult request(Invocation inv, HttpInput input) throws OnapCommandHttpFailure {
+ if (isMock) {
+ return result;
+ } else {
+ return inv.proceed(input);
+ }
+ }
+ };
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/input/OnapCommandParameterTest.java b/framework/src/test/java/org/onap/cli/fw/input/OnapCommandParameterTest.java
new file mode 100644
index 00000000..40b07861
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/input/OnapCommandParameterTest.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.input;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandInvalidParameterValue;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+public class OnapCommandParameterTest {
+
+ @Test
+ public void parameterObjTest() throws OnapCommandInvalidParameterValue {
+ OnapCommandParameter param = new OnapCommandParameter();
+ param.setDefaultValue("defaultValue");
+ param.setDescription("description");
+ param.setLongOption("longOption");
+ param.setName("name");
+ param.setOptional(true);
+ param.setParameterType(ParameterType.JSON);
+ param.setSecured(false);
+ param.setShortOption("shortOption");
+ param.setValue("value");
+
+ assertTrue(param.getDefaultValue().equals("defaultValue") && param.getDescription().equals("description")
+ && param.getLongOption().equals("longOption") && param.getName().equals("name")
+ && param.getShortOption().equals("shortOption") && param.getValue().equals("value")
+ && param.isOptional() && !param.isSecured() && param.getParameterType().equals(ParameterType.JSON));
+
+ assertTrue("value".equals(param.getValue()));
+
+ param.setParameterType(ParameterType.ARRAY);
+ param.setValue(Arrays.asList("1", "2", "3"));
+ assertTrue("[\"1\",\"2\",\"3\"]".equals(param.getValue()));
+
+ param.setParameterType(ParameterType.MAP);
+ Map<String, String> map = new HashMap<>();
+ map.put("One", "1");
+ map.put("Two", "2");
+ map.put("Three", "3");
+ param.setValue(map);
+ assertTrue("{\"One\":\"1\",\"Two\":\"2\",\"Three\":\"3\"}".equals(param.getValue()));
+
+ param.setDefaultValue("${defaultValue}");
+ assertTrue(null == param.getDefaultValue());
+ }
+
+ @Test
+ public void parameterEnvDefaultValueObjTest() {
+ OnapCommandParameter param = new OnapCommandParameter();
+ param.setDefaultValue("${DAFAULT_VALUE}");
+ boolean isDefaultValueAnEnv = param.isDefaultValueAnEnv();
+ assertTrue(isDefaultValueAnEnv);
+
+ String envValue = param.getEnvVarNameFromDefaultValue();
+
+ assertTrue("DAFAULT_VALUE".equals(envValue));
+ }
+
+ @Test
+ public void parameterValidateTest() {
+ OnapCommandParameter param = new OnapCommandParameter();
+ param.setOptional(false);
+ param.setValue("");
+ param.setDefaultValue("");
+ param.setParameterType(ParameterType.STRING);
+ try {
+ param.validate();
+ } catch (OnapCommandException e) {
+ assertTrue("0x0015::Parameter null is mandatory".equals(e.getMessage()));
+ }
+ }
+
+ @Test(expected = OnapCommandInvalidParameterValue.class)
+ public void onapCommandInvalidParameterValueArrayExeceptionTest() throws OnapCommandInvalidParameterValue {
+ OnapCommandParameter param = new OnapCommandParameter();
+ param.setName("name");
+ param.setParameterType(ParameterType.ARRAY);
+ param.setValue("value");
+ assertTrue("[\"1\",\"2\",\"3\"]".equals(param.getValue()));
+
+ }
+
+ @Test(expected = OnapCommandInvalidParameterValue.class)
+ public void onapCommandInvalidParameterValueMapExeceptionTest() throws OnapCommandInvalidParameterValue {
+ OnapCommandParameter param = new OnapCommandParameter();
+ param.setName("name");
+ param.setParameterType(ParameterType.MAP);
+ param.setValue("value");
+ assertTrue("{\"One\":\"1\",\"Two\":\"2\",\"Three\":\"3\"}".equals(param.getValue()));
+ }
+
+ @Test(expected = OnapCommandInvalidParameterValue.class)
+ public void onapCommandInvalidParameterValueBinaryExeceptionTest() throws OnapCommandException {
+ OnapCommandParameter param = new OnapCommandParameter();
+ param.setName("name");
+ param.setParameterType(ParameterType.BINARY);
+ param.setValue("value");
+ param.validate();
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/input/ParameterTypeTest.java b/framework/src/test/java/org/onap/cli/fw/input/ParameterTypeTest.java
new file mode 100644
index 00000000..eef49ad8
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/input/ParameterTypeTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.input;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandInvalidParameterType;
+
+public class ParameterTypeTest {
+ @Test
+ public void paramTypeGetTest() {
+
+ try {
+ assertTrue(ParameterType.JSON.equals(ParameterType.get("json"))
+ && ParameterType.YAML.equals(ParameterType.get("yaml"))
+ && ParameterType.STRING.equals(ParameterType.get("string"))
+ && ParameterType.LONG.equals(ParameterType.get("long"))
+ && ParameterType.URL.equals(ParameterType.get("url"))
+ && ParameterType.BOOL.equals(ParameterType.get("bool"))
+ && ParameterType.MAP.equals(ParameterType.get("map"))
+ && ParameterType.BINARY.equals(ParameterType.get("binary"))
+ && ParameterType.ARRAY.equals(ParameterType.get("array")));
+ } catch (OnapCommandInvalidParameterType e) {
+ fail("Shouldn't have thrown this exception : " + e.getMessage());
+ }
+
+ try {
+ ParameterType.get("name");
+ } catch (OnapCommandInvalidParameterType e) {
+ assertTrue("0x0003::Parameter type name is invalid".equals(e.getMessage()));
+ }
+
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/log/OnapCommandLoggerTest.java b/framework/src/test/java/org/onap/cli/fw/log/OnapCommandLoggerTest.java
new file mode 100644
index 00000000..4b675edc
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/log/OnapCommandLoggerTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2016-17 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.log;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.Signature;
+import org.aspectj.lang.reflect.SourceLocation;
+import org.aspectj.runtime.internal.AroundClosure;
+import org.junit.Test;
+
+public class OnapCommandLoggerTest {
+
+ @Test
+ public void logTest() throws Throwable {
+
+
+ ProceedingJoinPoint point = new ProceedingJoinPoint() {
+ @Override
+ public String toShortString() {
+ return null;
+ }
+
+ @Override
+ public String toLongString() {
+ return null;
+ }
+
+ @Override
+ public Object getThis() {
+ return new Object();
+ }
+
+ @Override
+ public Object getTarget() {
+ return null;
+ }
+
+ @Override
+ public StaticPart getStaticPart() {
+ return null;
+ }
+
+ @Override
+ public SourceLocation getSourceLocation() {
+ return null;
+ }
+
+ @Override
+ public Signature getSignature() {
+ return new Signature(){
+
+ @Override
+ public Class getDeclaringType() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public String getDeclaringTypeName() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public int getModifiers() {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public String getName() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public String toLongString() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public String toShortString() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ };
+ }
+
+ @Override
+ public String getKind() {
+ return null;
+ }
+
+ @Override
+ public Object[] getArgs() {
+ return null;
+ }
+
+ @Override
+ public void set$AroundClosure(AroundClosure arg0) {
+ }
+
+ @Override
+ public Object proceed(Object[] arg0) throws Throwable {
+ return null;
+ }
+
+ @Override
+ public Object proceed() throws Throwable {
+ return new Object();
+ }
+ };
+
+ OnapCommandLogger log = new OnapCommandLogger();
+ log.log(point);
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeScopeTest.java b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeScopeTest.java
new file mode 100644
index 00000000..ac1a6d33
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeScopeTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.output;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.onap.cli.fw.input.ParameterType;
+
+import java.util.Collections;
+
+public class OnapCommandResultAttributeScopeTest {
+ @Test
+ public void onapCommandResultAttributeTest() {
+ OnapCommandResultAttribute att = new OnapCommandResultAttribute();
+ att.setDescription("description");
+ att.setName("name");
+ att.setScope(OnapCommandResultAttributeScope.LONG);
+ att.setSecured(true);
+ att.setType(ParameterType.LONG);
+ att.setValues(Collections.emptyList());
+ assertTrue("description".equals(att.getDescription()) && "name".equals(att.getName())
+ && OnapCommandResultAttributeScope.LONG.equals(att.getScope())
+ && ParameterType.LONG.equals(att.getType()) && att.getValues().isEmpty());
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeTest.java b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeTest.java
new file mode 100644
index 00000000..6d2612f9
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.output;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandInvalidResultAttributeScope;
+
+public class OnapCommandResultAttributeTest {
+ @Test
+ public void paramTypeGetTest() {
+
+ try {
+ assertTrue(OnapCommandResultAttributeScope.LONG.equals(OnapCommandResultAttributeScope.get("long"))
+ && OnapCommandResultAttributeScope.SHORT.equals(OnapCommandResultAttributeScope.get("short")));
+ } catch (OnapCommandInvalidResultAttributeScope e) {
+ fail("Shouldn't have thrown this exception : " + e.getMessage());
+ }
+
+ try {
+ OnapCommandResultAttributeScope.get("name");
+ } catch (OnapCommandInvalidResultAttributeScope e) {
+ assertTrue("0x0006::Result atrribute name is invalid".equals(e.getMessage()));
+ }
+
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultTest.java b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultTest.java
new file mode 100644
index 00000000..dddab1bc
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultTest.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.output;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.input.ParameterType;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class OnapCommandResultTest {
+
+ @Test
+ public void commandResultObjTest() throws OnapCommandException {
+ OnapCommandResult res = new OnapCommandResult();
+ res.setDebugInfo("debugInfo");
+ res.setIncludeSeparator(true);
+ res.setIncludeTitle(true);
+ res.setOutput("Output");
+ res.setPrintDirection(PrintDirection.LANDSCAPE);
+ res.setRecords(new ArrayList<OnapCommandResultAttribute>());
+ res.setScope(OnapCommandResultAttributeScope.LONG);
+ res.setType(ResultType.TABLE);
+ res.setDebug(true);
+
+ assertTrue("debugInfo".equals(res.getDebugInfo()) && res.isIncludeSeparator()
+ && "Output".equals(res.getOutput()) && PrintDirection.LANDSCAPE.equals(res.getPrintDirection())
+ && res.getRecords().isEmpty() && OnapCommandResultAttributeScope.LONG.equals(res.getScope())
+ && ResultType.TABLE.equals(res.getType()));
+
+ String help = res.print();
+
+ assertTrue("".equals(help));
+
+ }
+
+ @Test
+ public void commandResultPrintLandscapeTableTest() throws OnapCommandException {
+ OnapCommandResult res = new OnapCommandResult();
+ res.setDebugInfo("debugInfo");
+ res.setIncludeSeparator(true);
+ res.setIncludeTitle(true);
+ res.setOutput("Output");
+ res.setPrintDirection(PrintDirection.LANDSCAPE);
+
+ OnapCommandResultAttribute att = new OnapCommandResultAttribute();
+ att.setName("param");
+ att.setDescription("description");
+ att.setType(ParameterType.STRING);
+ att.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value" })));
+ List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>();
+ list.add(att);
+ res.setRecords(list);
+ res.setScope(OnapCommandResultAttributeScope.LONG);
+ res.setType(ResultType.TABLE);
+ res.getRecordsMap();
+ String expRes = "+--------+\n|param |\n+--------+\n|value |\n+--------+\n";
+ String result = res.print();
+
+ assertEquals(expRes, result);
+
+ }
+
+ @Test
+ public void commandResultPrintLandscapeJsonTest() throws OnapCommandException {
+ OnapCommandResult res = new OnapCommandResult();
+ res.setDebugInfo("debugInfo");
+ res.setIncludeSeparator(true);
+ res.setIncludeTitle(true);
+ res.setOutput("Output");
+ res.setPrintDirection(PrintDirection.LANDSCAPE);
+
+ OnapCommandResultAttribute att = new OnapCommandResultAttribute();
+ att.setName("param");
+ att.setDescription("description");
+ att.setType(ParameterType.JSON);
+ att.setValues(
+ new ArrayList<String>(Arrays.asList(new String[] { "{\"id\": \"0001\",\"value\": \"result\"}" })));
+ List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>();
+ list.add(att);
+ res.setRecords(list);
+ res.setScope(OnapCommandResultAttributeScope.LONG);
+ res.setType(ResultType.JSON);
+
+ // Will be handled after the json print is implemented
+ String result = res.print();
+ // String expRes = "+--------+\n|param |\n+--------+\n|value
+ // |\n+--------+\n";
+ // assertEquals(expRes,result);
+
+ }
+
+ @Test
+ @Ignore
+ public void commandResultPrintLandscapeCsvTest() throws OnapCommandException {
+ OnapCommandResult res = new OnapCommandResult();
+ res.setDebugInfo("debugInfo");
+ res.setIncludeSeparator(true);
+ res.setIncludeTitle(true);
+ res.setOutput("Output");
+ res.setPrintDirection(PrintDirection.LANDSCAPE);
+
+ OnapCommandResultAttribute att = new OnapCommandResultAttribute();
+ att.setName("param");
+ att.setDescription("description");
+ att.setType(ParameterType.STRING);
+ att.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value" })));
+ List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>();
+ list.add(att);
+ OnapCommandResultAttribute a1 = new OnapCommandResultAttribute();
+ a1.setName("param1");
+ a1.setDescription("description1");
+ a1.setType(ParameterType.STRING);
+ a1.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value1" })));
+
+ list.add(a1);
+ res.setRecords(list);
+ res.setScope(OnapCommandResultAttributeScope.LONG);
+ res.setType(ResultType.CSV);
+
+ String expRes = "param,param1\r\n";
+ String result = res.print();
+ assertEquals(expRes, result);
+
+ }
+
+ @Test
+ @Ignore
+ public void commandResultPrintPortraitCsvTest() throws OnapCommandException {
+ OnapCommandResult res = new OnapCommandResult();
+ res.setDebugInfo("debugInfo");
+ res.setIncludeSeparator(true);
+ res.setIncludeTitle(true);
+ res.setOutput("Output");
+ res.setPrintDirection(PrintDirection.PORTRAIT);
+
+ OnapCommandResultAttribute att = new OnapCommandResultAttribute();
+ att.setName("param");
+ att.setDescription("description");
+ att.setType(ParameterType.STRING);
+ att.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value" })));
+ List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>();
+ list.add(att);
+ OnapCommandResultAttribute a1 = new OnapCommandResultAttribute();
+ a1.setName("param1");
+ a1.setDescription("description1");
+ a1.setType(ParameterType.STRING);
+ a1.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value1" })));
+
+ list.add(a1);
+ res.setRecords(list);
+ res.setScope(OnapCommandResultAttributeScope.LONG);
+ res.setType(ResultType.CSV);
+ String expRes = "property,value\r\nparam,value\r\n";
+ String result = res.print();
+ assertEquals(expRes, result);
+ }
+
+ @Test
+ public void commandResultPrintPortraitTableTest() throws OnapCommandException {
+ OnapCommandResult res = new OnapCommandResult();
+ res.setDebugInfo("debugInfo");
+ res.setIncludeSeparator(true);
+ res.setIncludeTitle(true);
+ res.setOutput("Output");
+ res.setPrintDirection(PrintDirection.PORTRAIT);
+
+ OnapCommandResultAttribute att = new OnapCommandResultAttribute();
+ att.setName("param");
+ att.setDescription("description");
+ att.setType(ParameterType.STRING);
+ att.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value" })));
+
+ List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>();
+ list.add(att);
+ res.setRecords(list);
+ res.setScope(OnapCommandResultAttributeScope.LONG);
+ res.setType(ResultType.TABLE);
+ String expRes = "+----------+--------+\n|property |value |\n+----------+--------+"
+ + "\n|param |value |\n+----------+--------+\n";
+
+ String result = res.print();
+
+ assertEquals(expRes, result);
+
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/output/PrintDirectionTest.java b/framework/src/test/java/org/onap/cli/fw/output/PrintDirectionTest.java
new file mode 100644
index 00000000..0aa82979
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/output/PrintDirectionTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.output;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandInvalidPrintDirection;
+
+public class PrintDirectionTest {
+ @Test
+ public void printDirectionGetTest() {
+
+ try {
+ assertTrue(PrintDirection.LANDSCAPE.equals(PrintDirection.get("landscape"))
+ && PrintDirection.PORTRAIT.equals(PrintDirection.get("portrait")));
+ } catch (OnapCommandInvalidPrintDirection e) {
+ fail("Shouldn't have thrown this exception : " + e.getMessage());
+ }
+
+ try {
+ PrintDirection.get("name");
+ } catch (OnapCommandInvalidPrintDirection e) {
+ assertTrue("0x0004::Print direction name is invalid".equals(e.getMessage()));
+ }
+
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/output/ResultTypeTest.java b/framework/src/test/java/org/onap/cli/fw/output/ResultTypeTest.java
new file mode 100644
index 00000000..3c4c5665
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/output/ResultTypeTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.output;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class ResultTypeTest {
+ @Test
+ public void resultTypeGetTest() {
+ assertTrue(ResultType.TABLE.equals(ResultType.get("table")) && ResultType.CSV.equals(ResultType.get("csv"))
+ && ResultType.JSON.equals(ResultType.get("json")) && ResultType.YAML.equals(ResultType.get("yaml"))
+ && ResultType.TEXT.equals(ResultType.get("text")));
+
+ }
+
+ @Test
+ public void isTabularFormTest() {
+ assertTrue(ResultType.isTabularForm("table"));
+ }
+
+ @Test
+ public void isTabularFormNotTest() {
+ assertFalse(ResultType.isTabularForm("text"));
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/output/print/OnapCommandPrintTest.java b/framework/src/test/java/org/onap/cli/fw/output/print/OnapCommandPrintTest.java
new file mode 100644
index 00000000..ae17d6d4
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/output/print/OnapCommandPrintTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.output.print;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandOutputPrintingFailed;
+import org.onap.cli.fw.output.PrintDirection;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class OnapCommandPrintTest {
+
+ @Test
+ @Ignore
+ public void printCsvTest() throws OnapCommandOutputPrintingFailed {
+ OnapCommandPrint pr = new OnapCommandPrint();
+ pr.setDirection(PrintDirection.LANDSCAPE);
+ pr.setPrintTitle(true);
+ pr.addColumn("name1", new ArrayList<String>(Arrays.asList(new String[] { "value1" })));
+ String exp = "name1\r\n";
+ String result = pr.printCsv();
+ assertEquals(exp, result);
+ }
+
+ @Test
+ public void printTableTest() throws OnapCommandOutputPrintingFailed {
+ OnapCommandPrint pr = new OnapCommandPrint();
+ List<String> getColumnsData = new ArrayList<String>();
+ pr.setDirection(PrintDirection.LANDSCAPE);
+ pr.setPrintTitle(true);
+ pr.addColumn("name2", new ArrayList<String>(Arrays.asList(new String[] { "value2" })));
+ String exp = "+--------+\n|name2 |\n+--------+\n|value2 |\n+--------+\n";
+ String result = pr.printTable(true);
+ getColumnsData = pr.getColumn("name2");
+ assertEquals(exp, result);
+ }
+
+ @Test
+ public void printTableNullColumnHeaderTest() throws OnapCommandOutputPrintingFailed {
+ OnapCommandPrint pr = new OnapCommandPrint();
+ List<String> getColumnsData = new ArrayList<String>();
+ pr.setDirection(PrintDirection.LANDSCAPE);
+ pr.setPrintTitle(true);
+ pr.addColumn("name2", new ArrayList<String>(Arrays.asList(new String[] { "value2" })));
+ String exp = "+--------+\n|name2 |\n+--------+\n|value2 |\n+--------+\n";
+ String result = pr.printTable(true);
+ getColumnsData = pr.getColumn(null);
+ assertEquals(exp, result);
+ }
+
+ @Test
+ public void printTableEmptyColumnValuesTest() throws OnapCommandOutputPrintingFailed {
+ OnapCommandPrint pr = new OnapCommandPrint();
+ List<String> getColumnsData = new ArrayList<String>();
+ pr.setDirection(PrintDirection.LANDSCAPE);
+ pr.setPrintTitle(true);
+ pr.addColumn("name2", new ArrayList<String>(Arrays.asList(new String[] { "" })));
+ String exp = "+--------+\n|name2 |\n+--------+\n| |\n+--------+\n";
+ String result = pr.printTable(true);
+ getColumnsData = pr.getColumn("name2");
+ assertEquals(exp, result);
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/output/print/TableGeneratorTest.java b/framework/src/test/java/org/onap/cli/fw/output/print/TableGeneratorTest.java
new file mode 100644
index 00000000..f9ae0717
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/output/print/TableGeneratorTest.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.output.print;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class TableGeneratorTest {
+ private TableGenerator table;
+
+ @Before
+ public void setUp() throws Exception {
+ this.table = new TableGenerator();
+ }
+
+ @Test
+ public void printTableNoColumnTest() {
+ System.out.println("printTableNoColumnTest...");
+ List<Object> row = new ArrayList<Object>();
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(row);
+ String result = table.generateTable(rows, true);
+ System.out.println(result);
+ String expected = "\n\n\n";
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void printTableNoCellTest() {
+ System.out.println("printTableNoCellTest...");
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(Arrays.asList(new Object[] { "column1", "column2" }));
+ String result = table.generateTable(rows, true);
+ System.out.println(result);
+ String expected = "+----------+----------+\n|column1 |column2 |\n+----------+----------+\n";
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void printTableNullCellTest() {
+
+ System.out.println("printTableNullCellTest...");
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(Arrays.asList(new Object[] { "column1", "column2" }));
+ rows.add(Arrays.asList(new Object[] { "value1", null }));
+ String result = table.generateTable(rows, true);
+ System.out.println(result);
+ String expected = "+----------+----------+\n" + "|column1 |column2 |\n" + "+----------+----------+\n"
+ + "|value1 | |\n" + "+----------+----------+\n";
+ assertEquals(expected, result);
+
+ }
+
+ @Test
+ public void printTableEmptyCellTest() {
+ System.out.println("printTableEmptyCellTest...");
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(Arrays.asList(new Object[] { "column1", "column2" }));
+ rows.add(Arrays.asList(new Object[] { "value1", "" }));
+ String result = table.generateTable(rows, true);
+ System.out.println(result);
+ String expected = "+----------+----------+\n" + "|column1 |column2 |\n" + "+----------+----------+\n"
+ + "|value1 | |\n" + "+----------+----------+\n";
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void printTableNoCellBreakTest() {
+ System.out.println("printTableNoCellBreakTest...");
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(Arrays.asList(new Object[] { "column1", "column2" }));
+ rows.add(Arrays.asList(new Object[] { "value1", "value2" }));
+ String result = table.generateTable(rows, true);
+ System.out.println(result);
+ String expected = "+----------+----------+\n" + "|column1 |column2 |\n" + "+----------+----------+\n"
+ + "|value1 |value2 |\n" + "+----------+----------+\n";
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void printTableCellBreakTest() {
+ System.out.println("printTableCellBreakTest...");
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(Arrays.asList(new Object[] { "column1", "column2" }));
+ List<Object> list = new ArrayList<Object>();
+ list.add("value1");
+ list.add(new ArrayList<Object>(
+ Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "56789" })));
+ rows.add(list);
+ String result = table.generateTable(rows, true);
+ System.out.println(result);
+ String expected = "+----------+------------------------------------------+\n"
+ + "|column1 |column2 |\n"
+ + "+----------+------------------------------------------+\n"
+ + "|value1 |1234567891234567891234567891234567891234 |\n"
+ + "| |56789 |\n"
+ + "+----------+------------------------------------------+\n";
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void printTableTwoCellBreakInSameRowTest() {
+ System.out.println("printTableTwoCellBreakInSameRowTest...");
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(Arrays.asList(new Object[] { "column1", "column2" }));
+ List<Object> list = new ArrayList<Object>();
+ list.add(new ArrayList<Object>(
+ Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "56789" })));
+ list.add(new ArrayList<Object>(
+ Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "56789", "00" })));
+ rows.add(list);
+ String result = table.generateTable(rows, true);
+ System.out.println(result);
+ String expected = "+------------------------------------------+------------------------------------------+\n"
+ + "|column1 |column2 |\n"
+ + "+------------------------------------------+------------------------------------------+\n"
+ + "|1234567891234567891234567891234567891234 |1234567891234567891234567891234567891234 |\n"
+ + "|56789 |56789 |\n"
+ + "| |00 |\n"
+ + "+------------------------------------------+------------------------------------------+\n";
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void printTableTwoCellBreakInDifferentRowTest() {
+ System.out.println("printTableTwoCellBreakInSameRowTest...");
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(Arrays.asList(new Object[] { "column1", "column2" }));
+ List<Object> list1 = new ArrayList<Object>();
+ list1.add("value1");
+ list1.add(new ArrayList<Object>(
+ Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "56789" })));
+ rows.add(list1);
+ List<Object> list2 = new ArrayList<Object>();
+ list2.add(new ArrayList<Object>(
+ Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "hi" })));
+
+ list2.add("value2");
+ rows.add(list2);
+ String result = table.generateTable(rows, true);
+ System.out.println(result);
+ String expected = "+------------------------------------------+------------------------------------------+\n"
+ + "|column1 |column2 |\n"
+ + "+------------------------------------------+------------------------------------------+\n"
+ + "|value1 |1234567891234567891234567891234567891234 |\n"
+ + "| |56789 |\n"
+ + "+------------------------------------------+------------------------------------------+\n"
+ + "|1234567891234567891234567891234567891234 |value2 |\n"
+ + "|hi | |\n"
+ + "+------------------------------------------+------------------------------------------+\n";
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void printTableWithoutPrintSeparatorTest() {
+ System.out.println("printTableWithoutPrintSeparatorTest...");
+ List<List<Object>> rows = new ArrayList<List<Object>>();
+ rows.add(Arrays.asList(new Object[] { "column1", "column2" }));
+ rows.add(Arrays.asList(new Object[] { "value1", "value2" }));
+ String result = table.generateTable(rows, false);
+ System.out.println(result);
+ String expected = "column1 column2 \nvalue1 value2 \n";
+ assertEquals(expected, result);
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/run/OnapCommandExecutorTest.java b/framework/src/test/java/org/onap/cli/fw/run/OnapCommandExecutorTest.java
new file mode 100644
index 00000000..1236365c
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/run/OnapCommandExecutorTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.run;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class OnapCommandExecutorTest {
+
+ @Test
+ public void commandExecutorTest() {
+ OnapCommandExecutor exec = new OnapCommandExecutor();
+ exec.setApi("api");
+ exec.setClient("client");
+ exec.setEntity("entity");
+ exec.setException("exception");
+ exec.setMethod("method");
+
+ Assert.assertTrue(
+ exec.getApi().equals("api") && exec.getClient().equals("client") && exec.getEntity().equals("entity")
+ && exec.getMethod().equals("method") && exec.getException().equals("exception"));
+ }
+
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java b/framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java
new file mode 100644
index 00000000..4c48683b
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.schema;
+
+import org.junit.Test;
+import org.onap.cli.fw.error.OnapCommandInvalidSchema;
+import org.yaml.snakeyaml.scanner.ScannerException;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class ValidateSchemaTest {
+
+ @Test(expected = OnapCommandInvalidSchema.class)
+ public void invalidateTest1() throws OnapCommandInvalidSchema {
+ new SchemaValidator(new File("fdsfds"));
+ new SchemaValidator(new File("fdsfds.yaml"));
+ }
+
+ @Test(expected = OnapCommandInvalidSchema.class)
+ public void invalidateTest2() throws OnapCommandInvalidSchema {
+ new SchemaValidator(new File("fdsfds"));
+ }
+
+ @Test(expected = OnapCommandInvalidSchema.class)
+ public void invalidateTest4() throws OnapCommandInvalidSchema {
+ new SchemaValidator(
+ new File(ValidateSchemaTest.class.getClassLoader().getResource("onap.properties").getFile()));
+ }
+
+ @Test(expected = OnapCommandInvalidSchema.class)
+ public void invalidateTest5() throws OnapCommandInvalidSchema {
+ new SchemaValidator(new File(
+ ValidateSchemaTest.class.getClassLoader().getResource("schema-invalid-file-null.yaml").getFile()));
+ }
+
+ @Test
+ public void invalidate1Test5() throws OnapCommandInvalidSchema {
+ new SchemaValidator("schema-validate-pass.yaml");
+ }
+
+ @Test(expected = ScannerException.class)
+ public void invalidateTest3() throws OnapCommandInvalidSchema {
+ new SchemaValidator(
+ new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-invalid-file.yaml").getFile()));
+ }
+
+ @Test
+ public void validateTest() throws OnapCommandInvalidSchema {
+ new SchemaValidator(
+ new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-http.yaml").getFile()))
+ .validate();
+
+ new SchemaValidator(
+ new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-basic.yaml").getFile()))
+ .validate();
+ new SchemaValidator(new File(ValidateSchemaTest.class.getClassLoader()
+ .getResource("schema-validate-invalidschematype.yaml").getFile())).validate();
+ new SchemaValidator(
+ new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-invalid.yaml").getFile()))
+ .validate();
+ new SchemaValidator(
+ new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-pass.yaml").getFile()))
+ .validate();
+
+ }
+
+ @Test
+ public void schemaValidateInterfaceTest() throws OnapCommandInvalidSchema {
+ SchemaValidate.attributeNameExist("name", "section");
+ SchemaValidate.emptyValue("section", "attribute");
+ SchemaValidate.defaultYamlSchema("section");
+ SchemaValidate.emptySection("section");
+ SchemaValidate.invalidAttributeScope("name", new ArrayList<String>());
+ SchemaValidate.invalidAttrType("name", "section", new ArrayList<String>());
+ SchemaValidate.invalidBooleanValueMessage("section", "attribute", "value");
+ SchemaValidate.invalidRequestParam("subSection", "attribute");
+ SchemaValidate.invalidSections(new HashSet<String>(), new ArrayList<String>(), new ArrayList<String>());
+ SchemaValidate.attributeScopeEmpty("fsdf");
+ SchemaValidate.invalidType("section", "attribute", new ArrayList<String>());
+ SchemaValidate.longOptionExist("name");
+ SchemaValidate.shortOptionExist("name");
+ SchemaValidate.optionExist("option", "attrValue", "name");
+ SchemaValidate.optionDefaultExist("option", "attrValue", "name", new HashSet<String>());
+ SchemaValidate.nameExist("name", "section");
+ SchemaValidate.mandatoryAttrEmpty("param", "section");
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/utils/FileUtil.java b/framework/src/test/java/org/onap/cli/fw/utils/FileUtil.java
new file mode 100644
index 00000000..7da6230f
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/utils/FileUtil.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.utils;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class FileUtil {
+
+ /**
+ * Load file.
+ * @param srcName dir
+ * @return string
+ * @throws IOException exception
+ */
+ public static String loadResource(String srcName) throws IOException {
+ ClassLoader classLoader = FileUtil.class.getClassLoader();
+ File file = new File(classLoader.getResource(srcName).getFile());
+ BufferedReader br = new BufferedReader(new FileReader(file));
+ StringBuilder sb = new StringBuilder("");
+ if (br != null) {
+ try {
+
+ String line = br.readLine();
+
+ while (line != null) {
+ sb.append(line);
+ sb.append("\n");
+ line = br.readLine();
+ }
+ } finally {
+ br.close();
+ }
+ }
+
+ return sb.toString();
+
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java b/framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java
new file mode 100644
index 00000000..b74027a0
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java
@@ -0,0 +1,481 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.utils;
+
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import mockit.Invocation;
+import mockit.Mock;
+import mockit.MockUp;
+
+import org.junit.FixMethodOrder;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.OnapCommandSchema;
+import org.onap.cli.fw.ad.OnapCredentials;
+import org.onap.cli.fw.cmd.OnapHttpCommand;
+import org.onap.cli.fw.cmd.OnapSwaggerCommand;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandHelpFailed;
+import org.onap.cli.fw.error.OnapCommandHttpHeaderNotFound;
+import org.onap.cli.fw.error.OnapCommandHttpInvalidResponseBody;
+import org.onap.cli.fw.error.OnapCommandInvalidParameterType;
+import org.onap.cli.fw.error.OnapCommandInvalidPrintDirection;
+import org.onap.cli.fw.error.OnapCommandInvalidResultAttributeScope;
+import org.onap.cli.fw.error.OnapCommandInvalidSchema;
+import org.onap.cli.fw.error.OnapCommandInvalidSchemaVersion;
+import org.onap.cli.fw.error.OnapCommandParameterNameConflict;
+import org.onap.cli.fw.error.OnapCommandParameterNotFound;
+import org.onap.cli.fw.error.OnapCommandParameterOptionConflict;
+import org.onap.cli.fw.error.OnapCommandSchemaNotFound;
+import org.onap.cli.fw.http.HttpInput;
+import org.onap.cli.fw.http.HttpResult;
+import org.onap.cli.fw.input.OnapCommandParameter;
+import org.onap.cli.fw.input.ParameterType;
+import org.onap.cli.fw.output.OnapCommandResult;
+import org.onap.cli.fw.run.OnapCommandExecutor;
+import org.springframework.core.io.Resource;
+
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class OnapCommandUtilsTest {
+
+ @Test(expected = OnapCommandSchemaNotFound.class)
+ public void onapCommandUtilsInputStreamNullTest() throws OnapCommandException {
+ OnapCommandUtils.validateSchemaVersion("sample-test1-schema-http1.yaml", "1.0");
+ }
+
+ @Test
+ public void onapCommandUtilsInputStreamNotNullTest() throws OnapCommandException {
+ Map<String, ?> map = OnapCommandUtils.validateSchemaVersion("sample-test1-schema-http.yaml", "1.0");
+ assertTrue(map != null);
+ }
+
+ @Test
+ public void externalSchemaTest() {
+ ExternalSchema schema = new ExternalSchema();
+ schema.setCmdName("cmdName");
+ schema.setSchemaName("schemaName");
+ schema.setVersion("version");
+
+ assertTrue("cmdName".equals(schema.getCmdName()) && "schemaName".equals(schema.getSchemaName())
+ && "version".equals(schema.getVersion()));
+ }
+
+ @Test
+ public void schemaFileNotFoundTest() throws OnapCommandException {
+
+ Map<String, ?> map = OnapCommandUtils.validateSchemaVersion("sample-test-schema.yaml", "1.0");
+ assertTrue(map.size() > 0);
+ }
+
+ @Test
+ @Ignore
+ public void invalidSchemaFileTest() throws OnapCommandException {
+ Map<String, ?> map = null;
+ try {
+ map = OnapCommandUtils.validateSchemaVersion("sample-test-schema1.yaml", "1.0");
+ } catch (OnapCommandInvalidSchemaVersion e) {
+ fail("Test should not have thrown this exception : " + e.getMessage());
+ } catch (OnapCommandInvalidSchema e) {
+ fail("Test should not have thrown this exception : " + e.getMessage());
+ } catch (OnapCommandSchemaNotFound e) {
+ assertEquals("0x0019::Command schema sample-test-schema1.yaml is not found", e.getMessage());
+ }
+ }
+
+ @Test
+ public void validateWrongSchemaVersionTest() throws OnapCommandException {
+ Map<String, ?> map = null;
+ try {
+ map = OnapCommandUtils.validateSchemaVersion("sample-test-invalid-schema.yaml", "1.0");
+ } catch (OnapCommandInvalidSchemaVersion e) {
+ fail("Test should not have thrown this exception : " + e.getMessage());
+ } catch (OnapCommandInvalidSchema e) {
+ assertTrue(e.getMessage().contains("0x0007::Command schema sample-test-invalid-schema.yaml is invalid"));
+ } catch (OnapCommandSchemaNotFound e) {
+ fail("Test should not have thrown this exception : " + e.getMessage());
+ }
+ }
+
+ @Test
+ public void validateSchemaVersionTest() throws OnapCommandException {
+ Map<String, ?> map = null;
+ try {
+ map = OnapCommandUtils.validateSchemaVersion("sample-test-schema.yaml", "1.1");
+ } catch (OnapCommandInvalidSchemaVersion e) {
+ assertEquals("0x0008::Command schema onap_cmd_schema_version 1.0 is invalid or missing", e.getMessage());
+ } catch (OnapCommandInvalidSchema e) {
+ fail("Test should not have thrown this exception : " + e.getMessage());
+ } catch (OnapCommandSchemaNotFound e) {
+ fail("Test should not have thrown this exception : " + e.getMessage());
+ }
+ }
+
+ @Test
+ public void loadOnapCommandSchemaWithOutDefaultTest() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommandSample();
+ OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", false);
+ assertTrue("sample-test".equals(cmd.getName()) && cmd.getParameters().size() == 9);
+ }
+
+ @Test(expected = OnapCommandParameterNameConflict.class)
+ public void loadOnapCommandSchemaWithDuplicateNameTest() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommandSample();
+ OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-name.yaml", false);
+ }
+
+ @Test(expected = OnapCommandParameterOptionConflict.class)
+ public void loadOnapCommandSchemaWithDuplicateShortOptionTest() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommandSample();
+ OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-shortoption.yaml", false);
+ }
+
+ @Test(expected = OnapCommandParameterOptionConflict.class)
+ public void loadOnapCommandSchemaWithDuplicateLongOptionTest() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommandSample();
+ OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-longoption.yaml", false);
+ }
+
+ @Test
+ public void loadOnapCommandSchemaWithDefaultTest() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommandSample();
+ OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true);
+ assertTrue("sample-test".equals(cmd.getName()) && cmd.getParameters().size() > 9);
+
+ for (OnapCommandParameter com : cmd.getParameters()) {
+ com.setValue("value");
+ }
+
+ OnapCredentials cre = OnapCommandUtils.fromParameters(cmd.getParameters());
+ assertTrue(cre != null);
+ Map<String, OnapCommandParameter> map = OnapCommandUtils.getInputMap(cmd.getParameters());
+ assertTrue(map.size() == 19);
+ }
+
+ @Test
+ public void loadSwaggerBasedSchemaExceptionTest() throws OnapCommandException {
+ OnapSwaggerCommand cmd = new OnapSwaggerBasedCommandSample();
+ try {
+ OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml");
+ } catch (OnapCommandInvalidSchema e) {
+ assertTrue(e.getMessage().contains("0x0007::Command schema sample-test-schema.yaml is invalid"));
+ }
+ }
+
+ @Test
+ public void loadSwaggerBasedSchemaTest() throws OnapCommandException {
+ OnapSwaggerCommand cmd = new OnapSwaggerBasedCommandSample();
+ try {
+ OnapCommandUtils.loadSchema(cmd, "sample-test-schema-swagger.yaml");
+ OnapCommandExecutor exe = cmd.getExecutor();
+ assertTrue(exe != null);
+ } catch (OnapCommandInvalidSchema e) {
+ assertTrue(e.getMessage().contains("0x0007::Command schema sample-test-schema.yaml is invalid"));
+ }
+ }
+
+ @Test
+ public void loadHttpBasedSchemaExceptionTest() throws OnapCommandException {
+ OnapHttpCommand cmd = new OnapHttpCommandSample();
+ cmd.setName("sample-test-http");
+ try {
+ OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml");
+ } catch (OnapCommandParameterNameConflict | OnapCommandParameterOptionConflict
+ | OnapCommandInvalidParameterType | OnapCommandInvalidPrintDirection
+ | OnapCommandInvalidResultAttributeScope | OnapCommandSchemaNotFound | OnapCommandInvalidSchema
+ | OnapCommandInvalidSchemaVersion e) {
+ assertTrue(e.getMessage().contains("0x0007::Command schema sample-test-schema.yaml is invalid"));
+ }
+ }
+
+ @Test
+ public void loadHttpBasedSchemaTest() throws OnapCommandException {
+ OnapHttpCommand cmd = new OnapHttpCommandSample();
+ cmd.setName("sample-create-http");
+ try {
+ OnapCommandUtils.loadSchema(cmd, "sample-test-schema-http.yaml");
+ assertTrue(cmd.getSuccessStatusCodes().size() == 2);
+ } catch (OnapCommandParameterNameConflict | OnapCommandParameterOptionConflict
+ | OnapCommandInvalidParameterType | OnapCommandInvalidPrintDirection
+ | OnapCommandInvalidResultAttributeScope | OnapCommandSchemaNotFound | OnapCommandInvalidSchema
+ | OnapCommandInvalidSchemaVersion e) {
+ fail("Test should not have thrown this exception : " + e.getMessage());
+ }
+ }
+
+ @Test
+ public void helpCommandTest() throws IOException, OnapCommandException {
+ OnapCommand cmd = new OnapCommandSample();
+ OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true);
+
+ String actualResult = OnapCommandUtils.help(cmd);
+
+ String expectedHelp = FileUtil.loadResource("sample-cmd-test-help.txt");
+ }
+
+ @Test
+ public void findOnapCommandsTest() {
+ List<Class<OnapCommand>> cmds = OnapCommandUtils.findOnapCommands();
+ assertTrue(cmds.size() == 3);
+ }
+
+ @Test
+ public void sortTest() {
+ Set<String> set = new HashSet<String>();
+ set.add("dbvc");
+ set.add("bbvcb");
+ set.add("aaa");
+ set.add("c");
+ set.add("z");
+ List<String> list = OnapCommandUtils.sort(set);
+ assertEquals("[aaa, bbvcb, c, dbvc, z]", list.toString());
+ }
+
+ @Test
+ public void jsonFlattenTest() {
+ List<String> list = Arrays.asList(new String[] { "{\"menu1\": {\"id\": \"file1\",\"value\": \"File1\"}}" });
+ List<String> list1 = OnapCommandUtils.jsonFlatten(list);
+ String expected = "[{\"menu1\":{\"id\":\"file1\",\"value\":\"File1\"}}]";
+ assertEquals(expected, list1.toString());
+
+ }
+
+ @Test
+ public void jsonFlattenExceptionTest() {
+ List<String> list = Arrays.asList(new String[] { "{\"menu1\"::{\"id\":\"file1\",\"value\":\"File1\"}}" });
+ List<String> list1 = OnapCommandUtils.jsonFlatten(list);
+ String expected = "[{\"menu1\"::{\"id\":\"file1\",\"value\":\"File1\"}}]";
+ assertEquals(expected, list1.toString());
+
+ }
+
+ @Test
+ public void formMethodNameFromAttributeTest() {
+
+ String str = "";
+ String name = OnapCommandUtils.formMethodNameFromAttributeName(str, "test");
+
+ assertEquals("", name);
+
+ str = null;
+ name = OnapCommandUtils.formMethodNameFromAttributeName(str, "test");
+
+ assertEquals(null, name);
+
+ str = "test-get";
+ name = OnapCommandUtils.formMethodNameFromAttributeName(str, "");
+ assertEquals("TestGet", name);
+
+ }
+
+ @Test
+ public void populateParametersTest() throws OnapCommandException {
+
+ HttpInput input = new HttpInput();
+ input.setBody("body");
+ input.setMethod("method");
+ Map<String, String> mapHead = new HashMap<>();
+ mapHead.put("key2", "${value2}");
+ input.setReqHeaders(mapHead);
+ Map<String, String> query = new HashMap<>();
+ query.put("key3", "{${value3}}");
+ input.setReqQueries(query);
+ input.setUri("uri");
+
+ Map<String, OnapCommandParameter> params = new HashMap<>();
+ OnapCommandParameter param = new OnapCommandParameter();
+ param.setDefaultValue("defaultValue2");
+ param.setParameterType(ParameterType.STRING);
+ params.put("value2", param);
+ OnapCommandParameter param1 = new OnapCommandParameter();
+ param1.setDefaultValue("{\"defaultValue3\"}");
+ param1.setParameterType(ParameterType.JSON);
+ params.put("value3", param1);
+
+ HttpInput input1 = OnapCommandUtils.populateParameters(params, input);
+ String expected = "\nURL: uri\nMethod: method\nRequest Queries: {key3={\"defaultValue3\"}}\n"
+ + "Request Body: body\nRequest Headers: {key2=defaultValue2}\nRequest Cookies: {}\nbinaryData=false";
+ assertEquals(expected, input1.toString());
+
+ input.setBody("${body}");
+
+ HttpInput input2 = null;
+ try {
+ input2 = OnapCommandUtils.populateParameters(params, input);
+ } catch (OnapCommandParameterNotFound e) {
+ assertEquals("0x0026::Command input parameter body is not valid", e.getMessage());
+ }
+
+ }
+
+ @Test(expected = OnapCommandHttpHeaderNotFound.class)
+ public void populateOutputsTest() throws OnapCommandException {
+ HttpResult output = new HttpResult();
+ output.setBody(
+ "{\"serviceName\":\"test\",\"version\":\"v1\",\"url\":\"/api/test/v1\",\"protocol\":\"REST\",\"visualRange\":\"1\",\"lb_policy\":\"hash\",\"nodes\":[{\"ip\":\"127.0.0.1\",\"port\":\"8012\",\"ttl\":0,\"nodeId\":\"test_127.0.0.1_8012\",\"expiration\":\"2017-02-10T05:33:25Z\",\"created_at\":\"2017-02-10T05:33:25Z\",\"updated_at\":\"2017-02-10T05:33:25Z\"}],\"status\":\"1\"}");
+ Map<String, String> mapHead = new HashMap<>();
+ mapHead.put("head1", "value1");
+ output.setRespHeaders(mapHead);
+ output.setStatus(0);
+
+ Map<String, String> params = new HashMap<>();
+ params.put("head", "$h{head1}");
+ params.put("body", "$b{$.serviceName}");
+ params.put("key", "value");
+
+ Map<String, ArrayList<String>> input1 = OnapCommandUtils.populateOutputs(params, output);
+ assertEquals("{head=[value1], body=[test], key=[value]}", input1.toString());
+
+ params.put("body", "$b{{$.serviceName}");
+ try {
+ input1 = OnapCommandUtils.populateOutputs(params, output);
+ } catch (OnapCommandHttpInvalidResponseBody e) {
+ assertEquals(
+ "0x0028::Http response body does not have json entry {$.serviceName, Missing property in path $['{$']",
+ e.getMessage());
+ }
+ output.setBody("{}");
+ input1 = OnapCommandUtils.populateOutputs(params, output);
+ params.put("head", "$h{head2}");
+ output.setBody("{\"test\"}");
+ input1 = OnapCommandUtils.populateOutputs(params, output);
+ }
+
+ @Test(expected = OnapCommandException.class)
+ public void zendExceptionTest1() throws OnapCommandException {
+
+ mockExternalResources();
+ OnapCommandUtils.loadSchema(new OnapSwaggerBasedCommandSample(), "schemaName");
+ }
+
+ @Test(expected = OnapCommandException.class)
+ public void zendExceptionTest2() throws OnapCommandException {
+
+ mockExternalResources();
+ OnapCommandUtils.loadSchema(new OnapHttpCommandSample(), "schemaName", false);
+ }
+
+ @Test(expected = OnapCommandException.class)
+ public void zendExceptionTest3() throws OnapCommandException {
+
+ mockExternalResources();
+ OnapCommandUtils.validateSchemaVersion("schemaName", "version");
+ }
+
+ @Test(expected = OnapCommandException.class)
+ public void zendExceptionTest4() throws OnapCommandException {
+
+ mockExternalResources();
+ OnapCommandUtils.loadExternalSchemasFromJson();
+ }
+
+ @Test(expected = OnapCommandException.class)
+ public void zendExceptionTest5() throws OnapCommandException {
+
+ mockExternalResources();
+ OnapCommandUtils.findAllExternalSchemas();
+ }
+
+ @Test(expected = OnapCommandException.class)
+ public void zendExceptionTest6() throws OnapCommandException {
+
+ mockExternalResources();
+ OnapCommandUtils.persist(new ArrayList<ExternalSchema>());
+ }
+
+ @Test(expected = OnapCommandHelpFailed.class)
+ public void zendExceptionHelpTest1() throws OnapCommandException {
+
+ mockPrintMethodException();
+ OnapCommand cmd = new OnapCommandSample();
+ OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true);
+
+ OnapCommandUtils.help(cmd);
+
+ }
+
+ @OnapCommandSchema(name = "sample-test", schema = "sample-test-schema.yaml")
+ class OnapCommandSample extends OnapCommand {
+ @Override
+ protected void run() throws OnapCommandException {
+ }
+ }
+
+ @OnapCommandSchema(name = "sample-swagger-test", schema = "sample-test-schema-swagger.yaml")
+ class OnapSwaggerBasedCommandSample extends OnapSwaggerCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ }
+ }
+
+ @OnapCommandSchema(name = "sample-http-test", schema = "sample-test-schema-http.yaml")
+ class OnapHttpCommandSample extends OnapHttpCommand {
+
+ @Override
+ protected void run() throws OnapCommandException {
+ }
+ }
+
+ private void mockExternalResources() {
+ new MockUp<OnapCommandUtils>() {
+ boolean isMock = true;
+
+ @Mock
+ public Resource[] getExternalResources(Invocation inv, String pattern) throws IOException {
+ if (isMock) {
+ isMock = false;
+ throw new IOException();
+ } else {
+ return inv.proceed(pattern);
+ }
+ }
+ };
+ }
+
+ private void mockPrintMethodException() {
+ new MockUp<OnapCommandResult>() {
+ boolean isMock = true;
+
+ @Mock
+ public String print(Invocation inv) throws OnapCommandException {
+ if (isMock) {
+ isMock = false;
+ throw new OnapCommandException("", "");
+ } else {
+ return inv.proceed();
+ }
+ }
+ };
+ }
+}
diff --git a/framework/src/test/java/org/onap/cli/fw/utils/OpenCommandRegistrarTest.java b/framework/src/test/java/org/onap/cli/fw/utils/OpenCommandRegistrarTest.java
new file mode 100644
index 00000000..fa73ea6e
--- /dev/null
+++ b/framework/src/test/java/org/onap/cli/fw/utils/OpenCommandRegistrarTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.cli.fw.utils;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.OnapCommandRegistrar;
+import org.onap.cli.fw.error.OnapCommandException;
+
+
+public class OpenCommandRegistrarTest {
+
+ @Before
+ public void setUp() throws Exception {
+
+ }
+
+ @Test
+ public void test() throws OnapCommandException {
+ OnapCommandRegistrar registrar = OnapCommandRegistrar.getRegistrar();
+ OnapCommand cmd = registrar.get("sample-test");
+ registrar.listCommands();
+ registrar.getAllCommandToSchemaMap();
+ cmd.printVersion();
+ }
+
+}