diff --git a/bootstrap/vagrant-onap/Vagrantfile b/bootstrap/vagrant-onap/Vagrantfile
index 4b32fef..21766fe 100644
--- a/bootstrap/vagrant-onap/Vagrantfile
+++ b/bootstrap/vagrant-onap/Vagrantfile
@@ -25,6 +25,7 @@
   'nexus_url_snapshot'  => 'https://nexus.onap.org/content/repositories/snapshots',
   'gitlab_branch'       => 'master',
   'build_image'         => 'True',
+  'pull_docker_image'   => 'True',
   'odl_version'         => '0.5.3-Boron-SR3',
   'compile_repo'        => 'False',
   'enable_oparent'      => 'True'
diff --git a/bootstrap/vagrant-onap/lib/appc b/bootstrap/vagrant-onap/lib/appc
index 8ad7356..a0959c6 100755
--- a/bootstrap/vagrant-onap/lib/appc
+++ b/bootstrap/vagrant-onap/lib/appc
@@ -3,44 +3,41 @@
 set -o xtrace
 
 source /var/onap/sdnc
-source /var/onap/asserts
+source /var/onap/functions
+
+appc_src_folder=$git_src_folder/appc
 
 # clone_all_appc_repos() - Function that clones APPC source repo.
 function clone_all_appc_repos {
-    local src_folder=/opt/appc
-
-    clone_repo appc $src_folder
-    clone_repo appc/deployment $src_folder/deployment
+    clone_repo appc $appc_src_folder
+    clone_repo appc/deployment $appc_src_folder/deployment
 }
 
 # compile_all_appc_repos() - Function that compiles APPC source repo.
 function compile_all_appc_repos {
-    local src_folder=/opt/appc
-
-    compile_src $src_folder
-    compile_src $src_folder/deployment
+    compile_src $appc_src_folder
+    compile_src $appc_src_folder/deployment
 }
 
-# install_appc() - Function that clones and installs the APPC services from source code
-function install_appc {
-    install_package unzip
-    local src_folder=/opt/appc
+# _build_appc_images() - Function that creates APPC images from source code.
+function _build_appc_images {
+    get_sdnc_images
+    build_docker_image $appc_src_folder/deployment/installation/appc docker
+}
 
-    clone_all_appc_repos
-    if [[ "$compile_repo" == "True" ]]; then
-        compile_all_appc_repos
-    fi
-
+# get_appc_images() - Function that gets or build APPC docker images
+function get_appc_images {
     if [[ "$build_image" == "True" ]]; then
-        clone_repo sdnc/oam /opt/sdnc/oam
-        build_sdnc_images /opt/sdnc/oam
-        build_docker_image $src_folder/deployment/installation/appc docker
-        asserts_image openecomp/appc-image
+        _build_appc_images
     else
         pull_openecomp_image appc-image openecomp/appc-image:latest
         pull_openecomp_image dgbuilder-sdnc-image openecomp/dgbuilder-sdnc-image:latest
     fi
-    pushd $src_folder/deployment
+}
+
+# install_appc() - Function that clones and installs the APPC services from source code
+function install_appc {
+    pushd $appc_src_folder/deployment/docker-compose
     install_docker_compose
     /opt/docker/docker-compose up -d
     popd
@@ -48,5 +45,11 @@
 
 # init_appc() - Function that initialize APPC services
 function init_appc {
+    clone_all_appc_repos
+    if [[ "$compile_repo" == "True" ]]; then
+        compile_all_appc_repos
+    fi
+
+    get_appc_images
     install_appc
 }
diff --git a/bootstrap/vagrant-onap/lib/asdc b/bootstrap/vagrant-onap/lib/asdc
index 0c09b0b..bbd3d3b 100755
--- a/bootstrap/vagrant-onap/lib/asdc
+++ b/bootstrap/vagrant-onap/lib/asdc
@@ -32,8 +32,7 @@
     mkdir -p /data/logs/BE
     mkdir -p /data/logs/FE
     chmod 777 /data
-    chmod 777 /data/logs/BE
-    chmod 777 /data/logs/FE
+    chmod 777 /data/logs
 }
 
 # setup_docker_aliases() - Function that setups the aliases required by sdc scripts
@@ -95,8 +94,11 @@
     sed -i "s/\"ueb_url_list\":.*/\"ueb_url_list\": \""$MR_IP_ADDR","$MR_IP_ADDR"\",/g" /data/environments/$ENV_NAME.json
     sed -i "s/\"fqdn\":.*/\"fqdn\": [\""$MR_IP_ADDR"\", \""$MR_IP_ADDR"\"]/g" /data/environments/$ENV_NAME.json
 
-    docker_openecomp_login
-    bash /data/scripts/docker_run.sh -e $ENV_NAME -r $RELEASE -p $NEXUS_DOCKER_PORT
+    install_docker
+    if [[ "$pull_docker_image" == "True" ]]; then
+        docker_openecomp_login
+        bash /data/scripts/docker_run.sh -e $ENV_NAME -r $RELEASE -p $NEXUS_DOCKER_PORT
+    fi
 }
 
 # init_asdc() - Function that initialize SDC services
diff --git a/bootstrap/vagrant-onap/lib/sdnc b/bootstrap/vagrant-onap/lib/sdnc
index 3326321..9a3f9b0 100755
--- a/bootstrap/vagrant-onap/lib/sdnc
+++ b/bootstrap/vagrant-onap/lib/sdnc
@@ -4,13 +4,13 @@
 
 source /var/onap/functions
 
-src_folder=$git_src_folder/openecomp/sdnc
+sdnc_src_folder=$git_src_folder/openecomp/sdnc
 sdnc_repos=("core" "adaptors" "northbound" "plugins" "oam")
 
 # clone_all_sdnc_repos() - Function that clones SDNC source repo.
 function clone_all_sdnc_repos {
     for dirc in ${sdnc_repos[@]}; do
-        clone_repo sdnc/$dirc $src_folder/$dirc
+        clone_repo sdnc/$dirc $sdnc_src_folder/$dirc
     done
 }
 
@@ -18,21 +18,21 @@
 function compile_all_sdnc_repos {
     for dirc in ${sdnc_repos[@]}; do
         if [[ "$dirc" == "core" ]]; then
-            compile_src $src_folder/core/rootpom
+            compile_src $sdnc_src_folder/core/rootpom
         fi
-        compile_src $src_folder/$dirc
+        compile_src $sdnc_src_folder/$dirc
     done
 }
 
-# build_sdnc_images() - Builds SDNC images from source code
-function build_sdnc_images {
-    local folder=${1:-$src_folder/oam}
+# _build_sdnc_images() - Builds SDNC images from source code
+function _build_sdnc_images {
+    local folder=$sdnc_src_folder/oam
 
     install_package unzip
-    clone_repo sdnc/oam $src_folder/oam
+    clone_repo sdnc/oam $folder
     # The OAM code depends on all the SDNC repos which should be downloaded and compiled first
-    if [[ "$compile_repo" == "False" ]]; then
-        compile_src $src_folder/oam/
+    if [[ "$compile_repo" != "True" ]]; then
+        compile_src $folder
     fi
     for dirc in ubuntu sdnc admportal dgbuilder; do
         build_docker_image $folder/installation/$dirc
@@ -42,7 +42,7 @@
 # get_sdnc_images() - Build or retrieve necessary images
 function get_sdnc_images {
     if [[ "$build_image" == "True" ]]; then
-        build_sdnc_images
+        _build_sdnc_images
     else
         pull_openecomp_image sdnc-image openecomp/sdnc-image:latest
         pull_openecomp_image admportal-sdnc-image openecomp/admportal-sdnc-image:latest
@@ -53,8 +53,8 @@
 
 # install_sdnc() -  Download and install SDNC services from source code
 function install_sdnc {
-    clone_repo sdnc/oam $src_folder/oam
-    pushd $src_folder/oam/installation/src/main/yaml
+    clone_repo sdnc/oam $sdnc_src_folder/oam
+    pushd $sdnc_src_folder/oam/installation/src/main/yaml
     install_docker_compose
     /opt/docker/docker-compose up -d
     popd
diff --git a/bootstrap/vagrant-onap/tests/test_appc b/bootstrap/vagrant-onap/tests/test_appc
new file mode 100644
index 0000000..0d46ef4
--- /dev/null
+++ b/bootstrap/vagrant-onap/tests/test_appc
@@ -0,0 +1,97 @@
+#!/bin/bash
+
+source /var/onap_tests/_test_base
+source /var/onap/appc
+
+covered_functions=(
+"clone_all_appc_repos" "compile_all_appc_repos" "get_appc_images" "install_appc"
+)
+
+# test_clone_all_appc_repos() - Verify that the APPC source code is cloned
+function test_clone_all_appc_repos {
+    clone_all_appc_repos
+
+    asserts_file_exist $appc_src_folder/pom.xml
+    asserts_file_exist $appc_src_folder/deployment/pom.xml
+}
+
+# test_compile_all_appc_repos() - Verify that the APPC source code is compiled properly
+function test_compile_all_appc_repos {
+    clone_all_appc_repos
+    compile_all_appc_repos
+
+    for adapter in appc-ansible-adapter appc-chef-adapter appc-dmaap-adapter appc-iaas-adapter appc-netconf-adapter appc-rest-adapter appc-rest-healthcheck-adapter; do
+        asserts_file_exist $appc_src_folder/appc-adapters/$adapter/$adapter-bundle/target/$adapter-bundle-1.1.0-SNAPSHOT.jar
+        asserts_file_exist $appc_src_folder/appc-adapters/$adapter/$adapter-features/target/$adapter-features-1.1.0-SNAPSHOT.jar
+        if [[ "$adapter" == "appc-netconf-adapter" ]]; then
+            asserts_file_exist $appc_src_folder/appc-adapters/$adapter/appc-netconf-installer/target/$adapter-1.1.0-SNAPSHOT.zip
+        else
+            asserts_file_exist $appc_src_folder/appc-adapters/$adapter/$adapter-installer/target/$adapter-1.1.0-SNAPSHOT.zip
+        fi
+    done
+    asserts_file_exist $appc_src_folder/appc-adapters/appc-dmaap-adapter/appc-message-adapter-api/target/appc-message-adapter-api-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-adapters/appc-dmaap-adapter/appc-message-adapter-factory/target/appc-message-adapter-factory-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-adapters/appc-ssh-adapter/appc-ssh-adapter-api/target/appc-ssh-adapter-api-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-adapters/appc-ssh-adapter/appc-ssh-adapter-features/target/appc-ssh-adapter-features-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-adapters/appc-ssh-adapter/appc-ssh-adapter-sshd/target/appc-ssh-adapter-sshd-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-adapters/appc-ssh-adapter/appc-ssh-adapter-tests/target/appc-ssh-adapter-tests-1.1.0-SNAPSHOT.jar
+
+    for component in appc-asdc-listener appc-event-listener appc-oam appc-provider; do
+        asserts_file_exist $appc_src_folder/$component/$component-bundle/target/$component-bundle-1.1.0-SNAPSHOT.jar
+        asserts_file_exist $appc_src_folder/$component/$component-features/target/$component-features-1.1.0-SNAPSHOT.jar
+        asserts_file_exist $appc_src_folder/$component/$component-installer/target/$component-1.1.0-SNAPSHOT.zip
+    done
+    for component in appc-oam appc-provider; do
+        asserts_file_exist $appc_src_folder/$component/$component-model/target/$component-model-1.1.0-SNAPSHOT.jar
+    done
+
+    asserts_file_exist $appc_src_folder/appc-asdc-listener/appc-yang-generator/target/appc-yang-generator-1.1.0-SNAPSHOT.jar
+
+    asserts_file_exist $appc_src_folder/appc-common/target/appc-common-1.1.0-SNAPSHOT.jar
+
+    asserts_file_exist $appc_src_folder/appc-dg/appc-dg-shared/appc-dg-dependency-model/target/appc-dg-dependency-model-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-dg/appc-dg-shared/appc-dg-domain-model-lib/target/appc-dg-domain-model-lib-1.1.0-SNAPSHOT.jar
+
+    asserts_file_exist $appc_src_folder/appc-dispatcher/appc-command-executor/appc-command-executor-api/target/appc-command-executor-api-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-dispatcher/appc-dispatcher-common/appc-data-access-lib/target/appc-data-access-lib-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-dispatcher/appc-dispatcher-common/domain-model-lib/target/domain-model-lib-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-dispatcher/appc-dispatcher-common/execution-queue-management-lib/target/execution-queue-management-lib-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-dispatcher/appc-license-manager/appc-license-manager-api/target/appc-license-manager-api-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-dispatcher/appc-request-handler/appc-request-handler-api/target/appc-request-handler-api-1.1.0-SNAPSHOT.jar
+
+
+    asserts_file_exist $appc_src_folder/appc-lifecycle-management/appc-lifecycle-management-api/target/appc-lifecycle-management-api-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-lifecycle-management/appc-lifecycle-management-core/target/appc-lifecycle-management-core-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-lifecycle-management/appc-lifecycle-management-features/target/appc-lifecycle-management-features-1.1.0-SNAPSHOT.jar
+    asserts_file_exist $appc_src_folder/appc-lifecycle-management/appc-lifecycle-management-installer/target/appc-lifecycle-management-1.1.0-SNAPSHOT.zip
+    asserts_file_exist $appc_src_folder/appc-lifecycle-management/state-machine-lib/target/state-machine-lib-1.1.0-SNAPSHOT.jar
+
+    asserts_file_exist $appc_src_folder/appc-metric/appc-metric-bundle/target/appc-metric-bundle-1.1.0-SNAPSHOT.jar
+
+    asserts_file_exist $appc_src_folder/deployment/platform-logic/installer/target/platform-logic-installer-1.1.0-SNAPSHOT.zip
+}
+
+# test_get_appc_images() - Verify that APPC Docker images can be retrieved
+function test_get_appc_images {
+    clone_all_appc_repo
+    get_appc_images
+
+    asserts_image openecomp/appc-image
+}
+
+# test_install_appc() - Verify that the APPC Docker images are up and running
+function test_install_appc {
+    clone_all_appc_repos
+    get_appc_images
+    install_appc
+
+    asserts_image_running openecomp/dgbuilder-sdnc-image
+    asserts_image_running openecomp/appc-image
+    asserts_image_running mysql/mysql-server:5.6
+}
+
+if [ "$1" != '*' ]; then
+    unset covered_functions
+    covered_functions=$1
+fi
+main "${covered_functions[@]}"
diff --git a/bootstrap/vagrant-onap/tests/test_sdnc b/bootstrap/vagrant-onap/tests/test_sdnc
index 93110a3..a60145f 100644
--- a/bootstrap/vagrant-onap/tests/test_sdnc
+++ b/bootstrap/vagrant-onap/tests/test_sdnc
@@ -11,11 +11,11 @@
 function test_clone_all_sdnc_repos {
     clone_all_sdnc_repos
 
-    asserts_file_exist $src_folder/core/pom.xml
-    asserts_file_exist $src_folder/adaptors/pom.xml
-    asserts_file_exist $src_folder/northbound/pom.xml
-    asserts_file_exist $src_folder/plugins/pom.xml
-    asserts_file_exist $src_folder/oam/pom.xml
+    asserts_file_exist $sdnc_src_folder/core/pom.xml
+    asserts_file_exist $sdnc_src_folder/adaptors/pom.xml
+    asserts_file_exist $sdnc_src_folder/northbound/pom.xml
+    asserts_file_exist $sdnc_src_folder/plugins/pom.xml
+    asserts_file_exist $sdnc_src_folder/oam/pom.xml
 }
 
 # test_compile_all_sdnc_repos() - Verify the correct compilation of SDNC projects
@@ -24,34 +24,34 @@
     compile_all_sdnc_repos
 
     for adaptor in aai-service mdsal-resource resource-assignment sql-resource; do
-        asserts_file_exist $src_folder/adaptors/$adaptor/features/target/$adaptor-features-1.1.2-SNAPSHOT.jar
-        asserts_file_exist $src_folder/adaptors/$adaptor/installer/target/sdnc-$adaptor-1.1.2-SNAPSHOT-installer.zip
-        asserts_file_exist $src_folder/adaptors/$adaptor/provider/target/$adaptor-provider-1.1.2-SNAPSHOT.jar
+        asserts_file_exist $sdnc_src_folder/adaptors/$adaptor/features/target/$adaptor-features-1.1.2-SNAPSHOT.jar
+        asserts_file_exist $sdnc_src_folder/adaptors/$adaptor/installer/target/sdnc-$adaptor-1.1.2-SNAPSHOT-installer.zip
+        asserts_file_exist $sdnc_src_folder/adaptors/$adaptor/provider/target/$adaptor-provider-1.1.2-SNAPSHOT.jar
     done
 
-    asserts_file_exist $src_folder/core/dblib/provider/target/dblib-provider-1.1.2-SNAPSHOT.jar
-    asserts_file_exist $src_folder/core/rootpom/target/rootpom-1.1.0-site_en.xml
-    asserts_file_exist $src_folder/core/target/sdnc-core-1.1.2-SNAPSHOT-site.xml
+    asserts_file_exist $sdnc_src_folder/core/dblib/provider/target/dblib-provider-1.1.2-SNAPSHOT.jar
+    asserts_file_exist $sdnc_src_folder/core/rootpom/target/rootpom-1.1.0-site_en.xml
+    asserts_file_exist $sdnc_src_folder/core/target/sdnc-core-1.1.2-SNAPSHOT-site.xml
 
     for component in asdcApi dataChange vnfapi vnftools; do
-        asserts_file_exist $src_folder/northbound/$component/features/target/$component-features-1.1.2-SNAPSHOT.jar
-        asserts_file_exist $src_folder/northbound/$component/installer/target/sdnc-$component-1.1.2-SNAPSHOT-installer.zip
+        asserts_file_exist $sdnc_src_folder/northbound/$component/features/target/$component-features-1.1.2-SNAPSHOT.jar
+        asserts_file_exist $sdnc_src_folder/northbound/$component/installer/target/sdnc-$component-1.1.2-SNAPSHOT-installer.zip
         if [[ "$component" != "vnftools" ]]; then
-            asserts_file_exist $src_folder/northbound/$component/model/target/$component-model-1.1.2-SNAPSHOT.jar
+            asserts_file_exist $sdnc_src_folder/northbound/$component/model/target/$component-model-1.1.2-SNAPSHOT.jar
         fi
-        asserts_file_exist $src_folder/northbound/$component/provider/target/$component-provider-1.1.2-SNAPSHOT.jar
+        asserts_file_exist $sdnc_src_folder/northbound/$component/provider/target/$component-provider-1.1.2-SNAPSHOT.jar
     done
-    asserts_file_exist $src_folder/northbound/dmaap-listener/target/dmaap-listener-1.1.2-SNAPSHOT.jar
-    asserts_file_exist $src_folder/northbound/ueb-listener/target/ueb-listener-1.1.2-SNAPSHOT.jar
+    asserts_file_exist $sdnc_src_folder/northbound/dmaap-listener/target/dmaap-listener-1.1.2-SNAPSHOT.jar
+    asserts_file_exist $sdnc_src_folder/northbound/ueb-listener/target/ueb-listener-1.1.2-SNAPSHOT.jar
 
-    asserts_file_exist $src_folder/oam/admportal/target/admportal.1.1.2-SNAPSHOT.zip
-    asserts_file_exist $src_folder/oam/dgbuilder/target/dgbuilder.1.1.2-SNAPSHOT.zip
-    asserts_file_exist $src_folder/oam/platform-logic/installer/target/platform-logic-installer-1.1.2-SNAPSHOT.zip
+    asserts_file_exist $sdnc_src_folder/oam/admportal/target/admportal.1.1.2-SNAPSHOT.zip
+    asserts_file_exist $sdnc_src_folder/oam/dgbuilder/target/dgbuilder.1.1.2-SNAPSHOT.zip
+    asserts_file_exist $sdnc_src_folder/oam/platform-logic/installer/target/platform-logic-installer-1.1.2-SNAPSHOT.zip
 
     for plugin in properties-node restapi-call-node; do
-        asserts_file_exist $src_folder/plugins/$plugin/features/target/$plugin-features-1.1.2-SNAPSHOT.jar
-        asserts_file_exist $src_folder/plugins/$plugin/installer/target/sdnc-$plugin-1.1.2-SNAPSHOT-installer.zip
-        asserts_file_exist $src_folder/plugins/$plugin/provider/target/$plugin-provider-1.1.2-SNAPSHOT.jar
+        asserts_file_exist $sdnc_src_folder/plugins/$plugin/features/target/$plugin-features-1.1.2-SNAPSHOT.jar
+        asserts_file_exist $sdnc_src_folder/plugins/$plugin/installer/target/sdnc-$plugin-1.1.2-SNAPSHOT-installer.zip
+        asserts_file_exist $sdnc_src_folder/plugins/$plugin/provider/target/$plugin-provider-1.1.2-SNAPSHOT.jar
     done
 }
 
diff --git a/documentation/api-dependencies/onapapidependencies.dot b/documentation/api-dependencies/onapapidependencies.dot
index 68c9341..99efa94 100644
--- a/documentation/api-dependencies/onapapidependencies.dot
+++ b/documentation/api-dependencies/onapapidependencies.dot
@@ -53,69 +53,62 @@
 so				[shape=box,label="Service Orchestrator"]
 vfc         	[shape=box,label="VF-C"]
 vid  			[shape=box,label="VID"]
-vnfsdk			[shape=box,label="VNF SDK"]
 usecaseui		[shape=box,label="Use Case UI"]
 
 
-aai -> aaf;
-aai -> dmaap;
+aai -> dmaap;			//https://wiki.onap.org/pages/viewpage.action?pageId=8227565#A&AIM1ReleasePlanning-APIIncomingDependencies
 aai -> msb;
-aaf -> aai;
-appc -> aai;
+appc -> aai;			//https://wiki.onap.org/pages/viewpage.action?pageId=6593279#APPCM1ReleasePlanning(AmsterdamRelease)-APIIncomingDependencies
 appc -> multicloud;
 appc -> sdc;
-ccsdk -> aai;
+ccsdk -> aai;			//https://wiki.onap.org/display/DW/Release+Planning+Template+%3A+CCSDK+Amsterdam+Release#ReleasePlanningTemplate:CCSDKAmsterdamRelease-APIIncomingDependencies
 ccsdk -> sdc;
-clamp -> dcaegen2;
+clamp -> dcaegen2;		//https://wiki.onap.org/display/DW/CLAMP+Release+Planning+M1#CLAMPReleasePlanningM1-APIIncomingDependencies
 clamp -> policy;
 clamp -> sdc;
-cli -> aaf;
+cli -> aaf;				//https://wiki.onap.org/display/DW/CLI+Release+Planning#CLIReleasePlanning-APIIncomingDependencies
 cli -> aai;
 cli -> msb;
-dcaegen2 -> dmaap;
+dcaegen2 -> dmaap;		//https://wiki.onap.org/display/DW/DCAE+R1+Release+Planning#DCAER1ReleasePlanning-APIIncomingDependencies
 dcaegen2 -> multicloud;
 dcaegen2 -> policy;
-dcaegen2 -> sdc;
-dmaap -> aai;
-extapi -> so;
-holmes -> aai;
+dcaegen2 -> sdc;			
+extapi -> so;			//https://wiki.onap.org/pages/viewpage.action?pageId=8227006#ExternalAPIFrameworkM1ReleasePlanning(AmsterdamRelease)-APIIncomingDependencies		
+extapi -> sdc;
+holmes -> aai;			//https://wiki.onap.org/pages/viewpage.action?pageId=6593583#HolmesReleasePlanningforAmsterdam-APIIncomingDependencies		
 holmes -> dcaegen2;
 holmes -> dmaap;
-holmes -> policy;
-multicloud -> aai;
+holmes -> msb;
+multicloud -> aai;		//https://wiki.onap.org/pages/viewpage.action?pageId=8225753#MultiVIM/CloudRelease1Planning-APIIncomingDependencies
 multicloud -> dcaegen2;
-oom -> msb;
-policy -> aai;
+oom -> msb;				//https://wiki.onap.org/display/DW/OOM+M1+Release+Planning+Template#OOMM1ReleasePlanningTemplate-APIIncomingDependencies
+policy -> aai;			//https://wiki.onap.org/display/DW/Policy+Framework+R1+-+M1+Release+Planning+Template#PolicyFrameworkR1-M1ReleasePlanningTemplate-APIIncomingDependencies
 policy -> appc;
 policy -> dcaegen2;
 policy -> vfc;
-portal -> aaf;
-sdc -> aai;
-sdc -> modeling;
-sdnc -> aai;
-sdnc -> multivim;
+policy -> so;
+portal -> aaf;			//https://wiki.onap.org/pages/viewpage.action?pageId=8227559#PortalPlatformM1ReleasePlanning(AmsterdamRelease)-APIIncomingDependencies
+sdnc -> aai;			//https://wiki.onap.org/display/DW/Release+Planning+Template+%3A+SDNC+Amsterdam+Release#ReleasePlanningTemplate:SDNCAmsterdamRelease-APIIncomingDependencies
 sdnc -> sdc;
-so -> aai;
+so -> aai;				//https://wiki.onap.org/display/DW/Service+Orchestrator+Release+Planning#ServiceOrchestratorReleasePlanning-APIIncomingDependencies
 so -> appc;
 so -> multicloud;
 so -> sdc;
 so -> sdnc;
 so -> vfc;
-usecaseui -> dcaegen2;
+usecaseui -> dcaegen2;	//https://wiki.onap.org/display/DW/Usecase+UI+Release+Planning#UsecaseUIReleasePlanning-APIIncomingDependencies
 usecaseui -> msb;
 usecaseui -> portal;
 usecaseui -> so;
 usecaseui -> vfc;
-vid -> aai;
-vid -> aaf;
+vid -> aai;				//https://wiki.onap.org/display/DW/VID+R1+Amsterdam+Release+Planning#VIDR1AmsterdamReleasePlanning-APIIncomingDependencies
+vid -> portal;
 vid -> sdc;
 vid -> so;
-vfc -> aai;
+vfc -> aai;				//https://wiki.onap.org/display/DW/VF-C+Release+Planning#VF-CReleasePlanning-APIIncomingDependencies
 vfc -> dcaegen2;
 vfc -> modeling;
 vfc -> multicloud;
 vfc -> msb;
 vfc -> sdc;
-vnfsdk -> msb;
-vnfsdk -> sdc;
 }
diff --git a/test/csit/plans/appc/healthcheck/setup.sh b/test/csit/plans/appc/healthcheck/setup.sh
new file mode 100755
index 0000000..0a68ade
--- /dev/null
+++ b/test/csit/plans/appc/healthcheck/setup.sh
@@ -0,0 +1,67 @@
+#!/bin/bash
+#
+# Copyright 2016-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.
+#
+# Modifications copyright (c) 2017 AT&T Intellectual Property
+#
+# Place the scripts in run order:
+source ${WORKSPACE}/test/csit/scripts/appc/script1.sh
+export MTU=$(/sbin/ifconfig | grep MTU | sed 's/.*MTU://' | sed 's/ .*//' | sort -n | head -1)
+
+
+# Clone APPC repo to get docker-compose for APPC
+mkdir -p $WORKSPACE/archives/appc
+cd $WORKSPACE/archives
+git clone -b master --single-branch http://gerrit.onap.org/r/appc/deployment.git appc
+cd $WORKSPACE/archives/appc
+git pull
+cd $WORKSPACE/archives/appc/docker-compose
+
+sed -i "s/DMAAP_TOPIC_ENV=.*/DMAAP_TOPIC_ENV="AUTO"/g" docker-compose.yml
+docker login -u docker -p docker nexus3.onap.org:10001
+
+docker pull nexus3.onap.org:10001/openecomp/appc-image:1.1-STAGING-latest
+docker tag nexus3.onap.org:10001/openecomp/appc-image:1.1-STAGING-latest openecomp/appc-image:latest
+
+docker pull nexus3.onap.org:10001/openecomp/dgbuilder-sdnc-image:1.1-STAGING-latest
+docker tag nexus3.onap.org:10001/openecomp/dgbuilder-sdnc-image:1.1-STAGING-latest openecomp/dgbuilder-sdnc-image:latest
+
+# start APPC containers with docker compose and configuration from docker-compose.yml
+/opt/docker/docker-compose up -d
+
+# WAIT 5 minutes maximum and test every 5 seconds if APPC is up using HealthCheck API
+TIME_OUT=1000
+INTERVAL=40
+TIME=0
+while [ "$TIME" -lt "$TIME_OUT" ]; do
+  response=$(curl --write-out '%{http_code}' --silent --output /dev/null -H "Authorization: Basic YWRtaW46S3A4Yko0U1hzek0wV1hsaGFrM2VIbGNzZTJnQXc4NHZhb0dHbUp2VXkyVQ==" -X POST -H "X-FromAppId: csit-appc" -H "X-TransactionId: csit-appc" -H "Accept: application/json" -H "Content-Type: application/json" http://localhost:8282/restconf/operations/SLI-API:healthcheck ); echo $response
+
+  if [ "$response" == "200" ]; then
+    echo APPC started in $TIME seconds
+    break;
+  fi
+
+  echo Sleep: $INTERVAL seconds before testing if APPC is up. Total wait time up now is: $TIME seconds. Timeout is: $TIME_OUT seconds
+  sleep $INTERVAL
+  TIME=$(($TIME+$INTERVAL))
+done
+
+if [ "$TIME" -ge "$TIME_OUT" ]; then
+   echo TIME OUT: Docker containers not started in $TIME_OUT seconds... Could cause problems for testing activities...
+fi
+
+# Pass any variables required by Robot test suites in ROBOT_VARIABLES
+#ROBOT_VARIABLES="-v TEST:${TEST}"
+
diff --git a/test/csit/plans/appc/healthcheck/teardown.sh b/test/csit/plans/appc/healthcheck/teardown.sh
new file mode 100755
index 0000000..357ead8
--- /dev/null
+++ b/test/csit/plans/appc/healthcheck/teardown.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+#
+# Copyright 2016-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.
+#
+# Modifications copyright (c) 2017 AT&T Intellectual Property
+#
+
+kill-instance.sh appc_controller_container
+kill-instance.sh sdnc_dgbuilder_container
+kill-instance.sh sdnc_db_container
+
+# $WORKSPACE/archives/appc deleted with archives folder when tests starts so we keep it at the end for debugging
diff --git a/test/csit/plans/appc/healthcheck/testplan.txt b/test/csit/plans/appc/healthcheck/testplan.txt
new file mode 100644
index 0000000..2a8c1ea
--- /dev/null
+++ b/test/csit/plans/appc/healthcheck/testplan.txt
@@ -0,0 +1,4 @@
+# Test suites are relative paths under [integration.git]/test/csit/tests/.
+# Place the suites in run order.
+appc/healthcheck
+
diff --git a/test/csit/scripts/appc/script1.sh b/test/csit/scripts/appc/script1.sh
new file mode 100755
index 0000000..1c3d92e
--- /dev/null
+++ b/test/csit/scripts/appc/script1.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+#
+# Copyright 2016-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.
+#
+# Modifications copyright (c) 2017 AT&T Intellectual Property
+#
+
+echo "This is ${WORKSPACE}/test/csit/scripts/appc/script1.sh"
diff --git a/test/csit/tests/appc/healthcheck/__init__.robot b/test/csit/tests/appc/healthcheck/__init__.robot
new file mode 100644
index 0000000..3b8528d
--- /dev/null
+++ b/test/csit/tests/appc/healthcheck/__init__.robot
@@ -0,0 +1,2 @@
+*** Settings ***
+Documentation    APPC - healthcheck
diff --git a/test/csit/tests/appc/healthcheck/test1.robot b/test/csit/tests/appc/healthcheck/test1.robot
new file mode 100644
index 0000000..e43c807
--- /dev/null
+++ b/test/csit/tests/appc/healthcheck/test1.robot
@@ -0,0 +1,15 @@
+*** Settings ***
+Library     Collections
+Library     RequestsLibrary
+Library     OperatingSystem
+Library     json
+Library     HttpLibrary.HTTP
+Library     Selenium2Library
+Library     XvfbRobot
+
+
+*** Test Cases ***
+Get Requests health check ok
+    CreateSession   appc  http://localhost:8282
+    ${resp}=    Get Request    appc   /restconf/operations/SLI-API:healthcheck
+    Should Be Equal As Strings  ${resp.status_code}     200
