diff --git a/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/FlowInfoJsonCodecTest.java b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/FlowInfoJsonCodecTest.java
new file mode 100644
index 0000000..4d3cb47
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/FlowInfoJsonCodecTest.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.onosproject.openstacktelemetry.codec.rest;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.testing.EqualsTester;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.TpPort;
+import org.onlab.packet.VlanId;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.codec.impl.CodecManager;
+import org.onosproject.core.CoreService;
+import org.onosproject.net.DeviceId;
+import org.onosproject.openstacktelemetry.api.FlowInfo;
+import org.onosproject.openstacktelemetry.api.StatsInfo;
+import org.onosproject.openstacktelemetry.api.DefaultFlowInfo;
+import org.onosproject.openstacktelemetry.api.DefaultStatsInfo;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onosproject.net.NetTestTools.APP_ID;
+import static org.onosproject.openstacktelemetry.codec.rest.FlowInfoJsonMatcher.matchesFlowInfo;
+
+/**
+ * Unit tests for FlowInfo codec.
+ */
+public class FlowInfoJsonCodecTest {
+    MockCodecContext context;
+    JsonCodec<FlowInfo> flowInfoCodec;
+    JsonCodec<StatsInfo> statsInfoCodec;
+    final CoreService mockCoreService = createMock(CoreService.class);
+    private static final String REST_APP_ID = "org.onosproject.rest";
+
+    private static final int INPUT_INTERFACE_ID = 1;
+    private static final int OUTPUT_INTERFACE_ID = 2;
+
+    private static final int VLAN_ID = 1;
+    private static final short VXLAN_ID = 10;
+    private static final int PROTOCOL = 1;
+    private static final int FLOW_TYPE = 1;
+    private static final String DEVICE_ID = "of:00000000000000a1";
+
+    private static final String SRC_IP_ADDRESS = "10.10.10.1";
+    private static final int SRC_IP_PREFIX = 24;
+    private static final String DST_IP_ADDRESS = "20.20.20.1";
+    private static final int DST_IP_PREFIX = 24;
+    private static final int SRC_PORT = 1000;
+    private static final int DST_PORT = 2000;
+    private static final String SRC_MAC_ADDRESS = "AA:BB:CC:DD:EE:FF";
+    private static final String DST_MAC_ADDRESS = "FF:EE:DD:CC:BB:AA";
+
+    private static final long LONG_VALUE = 1L;
+    private static final int INTEGER_VALUE = 1;
+    private static final short SHORT_VALUE = (short) 1;
+
+    /**
+     * Initial setup for this unit test.
+     */
+    @Before
+    public void setUp() {
+        context = new MockCodecContext();
+        flowInfoCodec = new FlowInfoJsonCodec();
+        statsInfoCodec = new StatsInfoJsonCodec();
+
+        assertThat(flowInfoCodec, notNullValue());
+        assertThat(statsInfoCodec, notNullValue());
+
+        expect(mockCoreService.registerApplication(REST_APP_ID))
+                .andReturn(APP_ID).anyTimes();
+        replay(mockCoreService);
+        context.registerService(CoreService.class, mockCoreService);
+    }
+
+    /**
+     * Tests the flow info encoding.
+     */
+    @Test
+    public void testEncode() {
+        StatsInfo statsInfo = new DefaultStatsInfo.DefaultBuilder()
+                                    .withStartupTime(LONG_VALUE)
+                                    .withFstPktArrTime(LONG_VALUE)
+                                    .withLstPktOffset(INTEGER_VALUE)
+                                    .withPrevAccBytes(LONG_VALUE)
+                                    .withPrevAccPkts(INTEGER_VALUE)
+                                    .withCurrAccBytes(LONG_VALUE)
+                                    .withCurrAccPkts(INTEGER_VALUE)
+                                    .withErrorPkts(SHORT_VALUE)
+                                    .withDropPkts(SHORT_VALUE)
+                                    .build();
+        FlowInfo flowInfo = new DefaultFlowInfo.DefaultBuilder()
+                                    .withFlowType((byte) FLOW_TYPE)
+                                    .withDeviceId(DeviceId.deviceId(DEVICE_ID))
+                                    .withInputInterfaceId(INPUT_INTERFACE_ID)
+                                    .withOutputInterfaceId(OUTPUT_INTERFACE_ID)
+                                    .withVlanId(VlanId.vlanId((short) VLAN_ID))
+                                    .withSrcIp(IpPrefix.valueOf(
+                                            IpAddress.valueOf(SRC_IP_ADDRESS), SRC_IP_PREFIX))
+                                    .withDstIp(IpPrefix.valueOf(
+                                            IpAddress.valueOf(DST_IP_ADDRESS), DST_IP_PREFIX))
+                                    .withSrcPort(TpPort.tpPort(SRC_PORT))
+                                    .withDstPort(TpPort.tpPort(DST_PORT))
+                                    .withProtocol((byte) PROTOCOL)
+                                    .withSrcMac(MacAddress.valueOf(SRC_MAC_ADDRESS))
+                                    .withDstMac(MacAddress.valueOf(DST_MAC_ADDRESS))
+                                    .withStatsInfo(statsInfo)
+                                    .build();
+
+        ObjectNode nodeJson = flowInfoCodec.encode(flowInfo, context);
+        assertThat(nodeJson, matchesFlowInfo(flowInfo));
+
+        FlowInfo flowInfoDecoded = flowInfoCodec.decode(nodeJson, context);
+        new EqualsTester().addEqualityGroup(flowInfo, flowInfoDecoded).testEquals();
+    }
+
+    /**
+     * Mock codec context for use in codec unit tests.
+     */
+    private class MockCodecContext implements CodecContext {
+        private final ObjectMapper mapper = new ObjectMapper();
+        private final CodecManager manager = new CodecManager();
+        private final Map<Class<?>, Object> services = new HashMap<>();
+
+        /**
+         * Constructs a new mock codec context.
+         */
+        public MockCodecContext() {
+            manager.activate();
+        }
+
+        @Override
+        public ObjectMapper mapper() {
+            return mapper;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public <T> JsonCodec<T> codec(Class<T> entityClass) {
+            if (entityClass == FlowInfo.class) {
+                return (JsonCodec<T>) flowInfoCodec;
+            }
+            if (entityClass == StatsInfo.class) {
+                return (JsonCodec<T>) statsInfoCodec;
+            }
+            return manager.getCodec(entityClass);
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public <T> T getService(Class<T> serviceClass) {
+            return (T) services.get(serviceClass);
+        }
+
+        // for registering mock services
+        public <T> void registerService(Class<T> serviceClass, T impl) {
+            services.put(serviceClass, impl);
+        }
+    }
+}
diff --git a/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/FlowInfoJsonMatcher.java b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/FlowInfoJsonMatcher.java
new file mode 100644
index 0000000..66ab1ba
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/FlowInfoJsonMatcher.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.onosproject.openstacktelemetry.codec.rest;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.onosproject.openstacktelemetry.api.FlowInfo;
+import org.onosproject.openstacktelemetry.api.StatsInfo;
+
+/**
+ * Hamcrest matcher for flow info.
+ */
+public final class FlowInfoJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode> {
+
+    private final FlowInfo flowInfo;
+
+    private static final String FLOW_TYPE = "flowType";
+    private static final String DEVICE_ID = "deviceId";
+    private static final String INPUT_INTERFACE_ID = "inputInterfaceId";
+    private static final String OUTPUT_INTERFACE_ID = "outputInterfaceId";
+
+    private static final String VLAN_ID = "vlanId";
+    private static final String VXLAN_ID = "vxlanId";
+    private static final String SRC_IP = "srcIp";
+    private static final String SRC_IP_PREFIX_LEN = "srcIpPrefixLength";
+    private static final String DST_IP = "dstIp";
+    private static final String DST_IP_PREFIX_LEN = "dstIpPrefixLength";
+    private static final String SRC_PORT = "srcPort";
+    private static final String DST_PORT = "dstPort";
+    private static final String PROTOCOL = "protocol";
+    private static final String SRC_MAC = "srcMac";
+    private static final String DST_MAC = "dstMac";
+    private static final String STATS_INFO = "statsInfo";
+
+    private FlowInfoJsonMatcher(FlowInfo flowInfo) {
+        this.flowInfo = flowInfo;
+    }
+
+    @Override
+    protected boolean matchesSafely(JsonNode jsonNode, Description description) {
+
+        // check flow type
+        String jsonFlowType = jsonNode.get(FLOW_TYPE).asText();
+        String flowType = String.valueOf(flowInfo.flowType());
+        if (!jsonFlowType.equals(flowType)) {
+            description.appendText("flow type was " + jsonFlowType);
+            return false;
+        }
+
+        // check device id
+        String jsonDeviceId = jsonNode.get(DEVICE_ID).asText();
+        String deviceId = flowInfo.deviceId().toString();
+        if (!jsonDeviceId.equals(deviceId)) {
+            description.appendText("device id was " + jsonDeviceId);
+            return false;
+        }
+
+        // check input interface id
+        int jsonInputInterfaceId = jsonNode.get(INPUT_INTERFACE_ID).asInt();
+        int inputInterfaceId = flowInfo.inputInterfaceId();
+        if (jsonInputInterfaceId != inputInterfaceId) {
+            description.appendText("input interface id was " + jsonInputInterfaceId);
+            return false;
+        }
+
+        // check output interface id
+        int jsonOutputInterfaceId = jsonNode.get(OUTPUT_INTERFACE_ID).asInt();
+        int outputInterfaceId = flowInfo.outputInterfaceId();
+        if (jsonOutputInterfaceId != outputInterfaceId) {
+            description.appendText("output interface id was " + jsonInputInterfaceId);
+            return false;
+        }
+
+        // check vlan id
+        try {
+            if (!(jsonNode.get(VLAN_ID).isNull())) {
+                String jsonVlanId = jsonNode.get(VLAN_ID).asText();
+                String vlanId = flowInfo.vlanId().toString();
+                if (!jsonVlanId.equals(vlanId)) {
+                    description.appendText("VLAN id was " + jsonVlanId);
+                    return false;
+                }
+            }
+        } catch (NullPointerException ex) {
+            description.appendText("VLAN id was null");
+        }
+
+        // check source IP
+        String jsonSrcIp = jsonNode.get(SRC_IP).asText();
+        String srcIp = flowInfo.srcIp().address().toString();
+        if (!jsonSrcIp.equals(srcIp)) {
+            description.appendText("Source IP was " + jsonSrcIp);
+            return false;
+        }
+
+        // check destination IP
+        String jsonDstIp = jsonNode.get(DST_IP).asText();
+        String dstIp = flowInfo.dstIp().address().toString();
+        if (!jsonDstIp.equals(dstIp)) {
+            description.appendText("Destination IP was " + jsonDstIp);
+            return false;
+        }
+
+        // check source IP prefix length
+        int jsonSrcPrefixLength = jsonNode.get(SRC_IP_PREFIX_LEN).asInt();
+        int srcPrefixLength = flowInfo.srcIp().prefixLength();
+        if (jsonSrcPrefixLength != srcPrefixLength) {
+            description.appendText("Source IP prefix length was " + jsonSrcPrefixLength);
+            return false;
+        }
+
+        // check destination IP prefix length
+        int jsonDstPrefixLength = jsonNode.get(DST_IP_PREFIX_LEN).asInt();
+        int dstPrefixLength = flowInfo.dstIp().prefixLength();
+        if (jsonDstPrefixLength != dstPrefixLength) {
+            description.appendText("Destination IP prefix length was " + jsonDstPrefixLength);
+            return false;
+        }
+
+        // check source port
+        int jsonSrcPort = jsonNode.get(SRC_PORT).asInt();
+        int srcPort = flowInfo.srcPort().toInt();
+        if (jsonSrcPort != srcPort) {
+            description.appendText("Source port was " + jsonSrcPort);
+            return false;
+        }
+
+        // check destination port
+        int jsonDstPort = jsonNode.get(DST_PORT).asInt();
+        int dstPort = flowInfo.dstPort().toInt();
+        if (jsonDstPort != dstPort) {
+            description.appendText("Destination port was " + jsonDstPort);
+            return false;
+        }
+
+        // check protocol
+        String jsonProtocol = jsonNode.get(PROTOCOL).asText();
+        String protocol = String.valueOf(flowInfo.protocol());
+        if (!jsonProtocol.equals(protocol)) {
+            description.appendText("Protocol was " + jsonProtocol);
+            return false;
+        }
+
+        // check source mac
+        String jsonSrcMac = jsonNode.get(SRC_MAC).asText();
+        String srcMac = flowInfo.srcMac().toString();
+        if (!jsonSrcMac.equals(srcMac)) {
+            description.appendText("Source MAC was " + jsonSrcMac);
+            return false;
+        }
+
+        // check destination mac
+        String jsonDstMac = jsonNode.get(DST_MAC).asText();
+        String dstMac = flowInfo.dstMac().toString();
+        if (!jsonDstMac.equals(dstMac)) {
+            description.appendText("Destination MAC was " + jsonDstMac);
+            return false;
+        }
+
+        // check stats info
+        JsonNode jsonStatsInfo = jsonNode.get(STATS_INFO);
+        if (jsonStatsInfo != null) {
+            StatsInfo statsInfo = flowInfo.statsInfo();
+            StatsInfoJsonMatcher infoMatcher =
+                    StatsInfoJsonMatcher.matchStatsInfo(statsInfo);
+            return infoMatcher.matches(jsonStatsInfo);
+        }
+
+        return true;
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        description.appendText(flowInfo.toString());
+    }
+
+    /**
+     * Factory to allocate an flow info matcher.
+     *
+     * @param flowInfo flow info object we are looking for
+     * @return matcher
+     */
+    public static FlowInfoJsonMatcher matchesFlowInfo(FlowInfo flowInfo) {
+        return new FlowInfoJsonMatcher(flowInfo);
+    }
+}
diff --git a/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/StatsInfoJsonMatcher.java b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/StatsInfoJsonMatcher.java
new file mode 100644
index 0000000..4ad86fa
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/StatsInfoJsonMatcher.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.onosproject.openstacktelemetry.codec.rest;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.onosproject.openstacktelemetry.api.StatsInfo;
+
+/**
+ * Hamcrest matcher for StatsInfoJsonCodec.
+ */
+public final class StatsInfoJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode> {
+
+    private final StatsInfo statsInfo;
+
+    private static final String STARTUP_TIME = "startupTime";
+    private static final String FST_PKT_ARR_TIME = "fstPktArrTime";
+    private static final String LST_PKT_OFFSET = "lstPktOffset";
+    private static final String PREV_ACC_BYTES = "prevAccBytes";
+    private static final String PREV_ACC_PKTS = "prevAccPkts";
+    private static final String CURR_ACC_BYTES = "currAccBytes";
+    private static final String CURR_ACC_PKTS = "currAccPkts";
+    private static final String ERROR_PKTS = "errorPkts";
+    private static final String DROP_PKTS = "dropPkts";
+
+    private StatsInfoJsonMatcher(StatsInfo statsInfo) {
+        this.statsInfo = statsInfo;
+    }
+
+    @Override
+    protected boolean matchesSafely(JsonNode jsonNode, Description description) {
+
+        // check startup time
+        long jsonStartupTime = jsonNode.get(STARTUP_TIME).asLong();
+        long startupTime = statsInfo.startupTime();
+        if (jsonStartupTime != startupTime) {
+            description.appendText("startup time was " + jsonStartupTime);
+            return false;
+        }
+
+        // check first packet arrival time
+        long jsonFstPktArrTime = jsonNode.get(FST_PKT_ARR_TIME).asLong();
+        long fstPktArrTime = statsInfo.fstPktArrTime();
+        if (jsonFstPktArrTime != fstPktArrTime) {
+            description.appendText("first packet arrival time was " + jsonFstPktArrTime);
+            return false;
+        }
+
+        // check last packet offset
+        int jsonLstPktOffset = jsonNode.get(LST_PKT_OFFSET).asInt();
+        int lstPktOffset = statsInfo.lstPktOffset();
+        if (jsonLstPktOffset != lstPktOffset) {
+            description.appendText("last packet offset was " + jsonLstPktOffset);
+            return false;
+        }
+
+        // check previous accumulated bytes
+        long jsonPrevAccBytes = jsonNode.get(PREV_ACC_BYTES).asLong();
+        long preAccBytes = statsInfo.prevAccBytes();
+        if (jsonPrevAccBytes != preAccBytes) {
+            description.appendText("previous accumulated bytes was " + jsonPrevAccBytes);
+            return false;
+        }
+
+        // check previous accumulated packets
+        int jsonPreAccPkts = jsonNode.get(PREV_ACC_PKTS).asInt();
+        int preAccPkts = statsInfo.prevAccPkts();
+        if (jsonPreAccPkts != preAccPkts) {
+            description.appendText("previous accumulated packets was " + jsonPreAccPkts);
+            return false;
+        }
+
+        // check current accumulated bytes
+        long jsonCurrAccBytes = jsonNode.get(CURR_ACC_BYTES).asLong();
+        long currAccBytes = statsInfo.currAccBytes();
+        if (jsonCurrAccBytes != currAccBytes) {
+            description.appendText("current accumulated bytes was " + jsonCurrAccBytes);
+            return false;
+        }
+
+        // check current accumulated packets
+        int jsonCurrAccPkts = jsonNode.get(CURR_ACC_PKTS).asInt();
+        int currAccPkts = statsInfo.currAccPkts();
+        if (jsonCurrAccPkts != currAccPkts) {
+            description.appendText("current accumulated packets was " + jsonCurrAccPkts);
+            return false;
+        }
+
+        // check error packets
+        short jsonErrorPkts = (short) jsonNode.get(ERROR_PKTS).asInt();
+        short errorPkts = statsInfo.errorPkts();
+        if (jsonErrorPkts != errorPkts) {
+            description.appendText("error packets was " + jsonErrorPkts);
+            return false;
+        }
+
+        // check drop packets
+        short jsonDropPkts = (short) jsonNode.get(DROP_PKTS).asInt();
+        short dropPkts = statsInfo.dropPkts();
+        if (jsonDropPkts != dropPkts) {
+            description.appendText("drop packets was " + jsonDropPkts);
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        description.appendText(statsInfo.toString());
+    }
+
+    /**
+     * Factory to allocate a stats info matcher.
+     *
+     * @param statsInfo stats info object we are looking for
+     * @return matcher
+     */
+    public static StatsInfoJsonMatcher matchStatsInfo(StatsInfo statsInfo) {
+        return new StatsInfoJsonMatcher(statsInfo);
+    }
+}
diff --git a/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfigCodecTest.java b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfigCodecTest.java
new file mode 100644
index 0000000..626aa02
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfigCodecTest.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.onosproject.openstacktelemetry.codec.rest;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Maps;
+import org.hamcrest.MatcherAssert;
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.codec.impl.CodecManager;
+import org.onosproject.core.CoreService;
+import org.onosproject.openstacktelemetry.api.DefaultTelemetryConfig;
+import org.onosproject.openstacktelemetry.api.config.TelemetryConfig;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onosproject.net.NetTestTools.APP_ID;
+import static org.onosproject.openstacktelemetry.codec.rest.TelemetryConfigJsonMatcher.matchesTelemetryConfig;
+
+/**
+ * Unit tests for TelemetryConfig codec.
+ */
+public class TelemetryConfigCodecTest {
+
+    MockCodecContext context;
+
+    JsonCodec<TelemetryConfig> telemetryConfigCodec;
+
+    final CoreService mockCoreService = createMock(CoreService.class);
+    private static final String REST_APP_ID = "org.onosproject.rest";
+
+    @Before
+    public void setUp() {
+        context = new MockCodecContext();
+        telemetryConfigCodec = new TelemetryConfigJsonCodec();
+
+        assertThat(telemetryConfigCodec, notNullValue());
+
+        expect(mockCoreService.registerApplication(REST_APP_ID))
+                .andReturn(APP_ID).anyTimes();
+        replay(mockCoreService);
+        context.registerService(CoreService.class, mockCoreService);
+    }
+
+    /**
+     * Tests the telemetry config encoding.
+     */
+    @Test
+    public void testTelemetryConfigEncode() {
+
+        String name = "grpc";
+        TelemetryConfig.ConfigType type = TelemetryConfig.ConfigType.GRPC;
+        String manufacturer = "grpc.io";
+        String swVersion = "1.0";
+        boolean enabled = true;
+
+        Map<String, String> properties = Maps.newConcurrentMap();
+        properties.put("key1", "value1");
+        properties.put("key2", "value2");
+
+        TelemetryConfig config = new DefaultTelemetryConfig(name, type,
+                ImmutableList.of(), manufacturer, swVersion, enabled, properties);
+
+        ObjectNode configJson = telemetryConfigCodec.encode(config, context);
+        assertThat(configJson, matchesTelemetryConfig(config));
+    }
+
+    /**
+     * Tests the telemetry config decoding.
+     */
+    @Test
+    public void testTelemetryConfigDecode() throws IOException {
+        TelemetryConfig config = getTelemetryConfig("TelemetryConfig.json");
+
+        assertEquals(config.name(), "grpc-config");
+        assertEquals(config.type().name(), "GRPC");
+        assertEquals(config.manufacturer(), "grpc.io");
+        assertEquals(config.swVersion(), "1.0");
+        assertTrue(config.enabled());
+
+        config.properties().forEach((k, v) -> {
+            if (k.equals("address")) {
+                assertEquals(v, "127.0.0.1");
+            }
+            if (k.equals("port")) {
+                assertEquals(v, "9092");
+            }
+        });
+    }
+
+    /**
+     * Reads in a telemetry config from the given resource and decodes it.
+     *
+     * @param resourceName resource to use to read the JSON for the rule
+     * @return decoded telemetry config
+     * @throws IOException if processing the resource fails
+     */
+    private TelemetryConfig getTelemetryConfig(String resourceName) throws IOException {
+        InputStream jsonStream = TelemetryConfigCodecTest.class.getResourceAsStream(resourceName);
+        JsonNode json = context.mapper().readTree(jsonStream);
+        MatcherAssert.assertThat(json, notNullValue());
+        TelemetryConfig config = telemetryConfigCodec.decode((ObjectNode) json, context);
+        assertThat(config, notNullValue());
+        return config;
+    }
+
+    /**
+     * Mock codec context for use in codec unit tests.
+     */
+    private class MockCodecContext implements CodecContext {
+        private final ObjectMapper mapper = new ObjectMapper();
+        private final CodecManager manager = new CodecManager();
+        private final Map<Class<?>, Object> services = new HashMap<>();
+
+        /**
+         * Constructs a new mock codec context.
+         */
+        public MockCodecContext() {
+            manager.activate();
+        }
+
+        @Override
+        public ObjectMapper mapper() {
+            return mapper;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public <T> JsonCodec<T> codec(Class<T> entityClass) {
+            if (entityClass == TelemetryConfig.class) {
+                return (JsonCodec<T>) telemetryConfigCodec;
+            }
+            return manager.getCodec(entityClass);
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public <T> T getService(Class<T> serviceClass) {
+            return (T) services.get(serviceClass);
+        }
+
+        // for registering mock services
+        public <T> void registerService(Class<T> serviceClass, T impl) {
+            services.put(serviceClass, impl);
+        }
+    }
+}
diff --git a/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfigJsonMatcher.java b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfigJsonMatcher.java
new file mode 100644
index 0000000..9bc50a2
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfigJsonMatcher.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.onosproject.openstacktelemetry.codec.rest;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.onosproject.openstacktelemetry.api.config.TelemetryConfig;
+
+/**
+ * Hamcrest matcher for TelemetryConfig.
+ */
+public final class TelemetryConfigJsonMatcher extends TypeSafeDiagnosingMatcher<JsonNode> {
+
+    private final TelemetryConfig telemetryConfig;
+
+    private static final String NAME = "name";
+    private static final String TYPE = "type";
+    private static final String MANUFACTURER = "manufacturer";
+    private static final String SW_VERSION = "swVersion";
+    private static final String ENABLED = "enabled";
+    private static final String PROPS = "props";
+    private static final String KEY = "key";
+    private static final String VALUE = "value";
+
+    private TelemetryConfigJsonMatcher(TelemetryConfig telemetryConfig) {
+        this.telemetryConfig = telemetryConfig;
+    }
+
+    @Override
+    protected boolean matchesSafely(JsonNode jsonNode, Description description) {
+
+        // check name
+        String jsonName = jsonNode.get(NAME).asText();
+        String name = telemetryConfig.name();
+        if (!jsonName.equals(name)) {
+            description.appendText("name was " + jsonName);
+            return false;
+        }
+
+        // check type
+        String jsonType = jsonNode.get(TYPE).asText();
+        String type = telemetryConfig.type().name();
+        if (!jsonType.equalsIgnoreCase(type)) {
+            description.appendText("type was " + jsonType);
+            return false;
+        }
+
+        // check manufacturer
+        String jsonManufacturer = jsonNode.get(MANUFACTURER).asText();
+        String manufacturer = telemetryConfig.manufacturer();
+        if (!jsonManufacturer.equals(manufacturer)) {
+            description.appendText("manufacturer was " + jsonManufacturer);
+            return false;
+        }
+
+        // check software version
+        String jsonSwVersion = jsonNode.get(SW_VERSION).asText();
+        String swVersion = telemetryConfig.swVersion();
+        if (!jsonSwVersion.equals(swVersion)) {
+            description.appendText("SW version was " + jsonSwVersion);
+            return false;
+        }
+
+        // check enabled
+        JsonNode jsonEnabled = jsonNode.get(ENABLED);
+        boolean enabled = telemetryConfig.enabled();
+        if (jsonEnabled == null || jsonEnabled.asBoolean() != enabled) {
+            description.appendText("Enabled was " + jsonEnabled);
+            return false;
+        }
+
+        // check properties
+        JsonNode jsonProperties = jsonNode.get(PROPS);
+        if (jsonProperties != null) {
+            if (jsonProperties.size() != telemetryConfig.properties().size()) {
+                description.appendText("properties size was " + jsonProperties.size());
+                return false;
+            }
+
+            for (String key : telemetryConfig.properties().keySet()) {
+                boolean keyFound = false;
+                boolean valueFound = false;
+                String value = telemetryConfig.properties().get(key);
+                for (int keyIndex = 0; keyIndex < jsonProperties.size(); keyIndex++) {
+                    ObjectNode jsonProperty = get(jsonProperties, keyIndex);
+                    JsonNode jsonKey = jsonProperty.get(KEY);
+                    JsonNode jsonValue = jsonProperty.get(VALUE);
+
+                    if (jsonKey != null && jsonValue != null) {
+                        if (jsonKey.asText().equals(key)) {
+                            keyFound = true;
+                        }
+
+                        if (jsonValue.asText().equals(value)) {
+                            valueFound = true;
+                        }
+
+                        if (keyFound && valueFound) {
+                            break;
+                        }
+                    }
+                }
+
+                if (!keyFound) {
+                    description.appendText("Property key not found " + key);
+                    return false;
+                }
+
+                if (!valueFound) {
+                    description.appendText("Property value not found " + value);
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        description.appendText(telemetryConfig.toString());
+    }
+
+    /**
+     * Factory to allocate an flow info matcher.
+     *
+     * @param telemetryConfig telemetry config object we are looking for
+     * @return matcher
+     */
+    public static TelemetryConfigJsonMatcher
+                    matchesTelemetryConfig(TelemetryConfig telemetryConfig) {
+        return new TelemetryConfigJsonMatcher(telemetryConfig);
+    }
+
+    private static ObjectNode get(JsonNode parent, int childIndex) {
+        JsonNode node = parent.path(childIndex);
+        return node.isObject() && !node.isNull() ? (ObjectNode) node : null;
+    }
+}
diff --git a/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/web/OpenstackTelemetryCodecRegisterTest.java b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/web/OpenstackTelemetryCodecRegisterTest.java
new file mode 100644
index 0000000..6eee616
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/web/OpenstackTelemetryCodecRegisterTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.onosproject.openstacktelemetry.web;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import org.junit.Test;
+import org.onlab.junit.TestUtils;
+import org.onosproject.codec.CodecService;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.openstacktelemetry.api.FlowInfo;
+import org.onosproject.openstacktelemetry.api.StatsFlowRule;
+import org.onosproject.openstacktelemetry.api.StatsInfo;
+import org.onosproject.openstacktelemetry.api.config.TelemetryConfig;
+import org.onosproject.openstacktelemetry.codec.rest.FlowInfoJsonCodec;
+import org.onosproject.openstacktelemetry.codec.rest.StatsFlowRuleJsonCodec;
+import org.onosproject.openstacktelemetry.codec.rest.StatsInfoJsonCodec;
+import org.onosproject.openstacktelemetry.codec.rest.TelemetryConfigJsonCodec;
+
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+/**
+ * Unit test for openstack telemetry codec register.
+ */
+public final class OpenstackTelemetryCodecRegisterTest {
+
+    private OpenstackTelemetryCodecRegister register;
+
+    /**
+     * Tests codec register activation and deactivation.
+     */
+    @Test
+    public void testActivateDeactivate() {
+        register = new OpenstackTelemetryCodecRegister();
+        CodecService codecService = new TestCodecService();
+
+        TestUtils.setField(register, "codecService", codecService);
+        register.activate();
+
+        assertEquals(StatsInfoJsonCodec.class.getName(),
+                codecService.getCodec(StatsInfo.class).getClass().getName());
+        assertEquals(FlowInfoJsonCodec.class.getName(),
+                codecService.getCodec(FlowInfo.class).getClass().getName());
+        assertEquals(StatsFlowRuleJsonCodec.class.getName(),
+                codecService.getCodec(StatsFlowRule.class).getClass().getName());
+        assertEquals(TelemetryConfigJsonCodec.class.getName(),
+                codecService.getCodec(TelemetryConfig.class).getClass().getName());
+
+        register.deactivate();
+
+        assertNull(codecService.getCodec(StatsInfo.class));
+        assertNull(codecService.getCodec(FlowInfo.class));
+        assertNull(codecService.getCodec(StatsFlowRule.class));
+        assertNull(codecService.getCodec(TelemetryConfig.class));
+    }
+
+    private static class TestCodecService implements CodecService {
+
+        private Map<String, JsonCodec> codecMap = Maps.newConcurrentMap();
+
+        @Override
+        public Set<Class<?>> getCodecs() {
+            return ImmutableSet.of();
+        }
+
+        @Override
+        public <T> JsonCodec<T> getCodec(Class<T> entityClass) {
+            return codecMap.get(entityClass.getName());
+        }
+
+        @Override
+        public <T> void registerCodec(Class<T> entityClass, JsonCodec<T> codec) {
+            codecMap.put(entityClass.getName(), codec);
+        }
+
+        @Override
+        public void unregisterCodec(Class<?> entityClass) {
+            codecMap.remove(entityClass.getName());
+        }
+    }
+}
diff --git a/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/web/OpenstackTelemetryConfigWebResourceTest.java b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/web/OpenstackTelemetryConfigWebResourceTest.java
new file mode 100644
index 0000000..ff027bc
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/java/org/onosproject/openstacktelemetry/web/OpenstackTelemetryConfigWebResourceTest.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+ *
+ * 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.onosproject.openstacktelemetry.web;
+
+import com.google.common.collect.Maps;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.osgi.ServiceDirectory;
+import org.onlab.osgi.TestServiceDirectory;
+import org.onosproject.openstacktelemetry.api.DefaultTelemetryConfig;
+import org.onosproject.openstacktelemetry.api.TelemetryConfigAdminService;
+import org.onosproject.openstacktelemetry.api.config.TelemetryConfig;
+import org.onosproject.rest.resources.ResourceTest;
+
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.util.Map;
+
+import static junit.framework.TestCase.assertEquals;
+import static org.easymock.EasyMock.anyString;
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.verify;
+import static org.onosproject.openstacktelemetry.api.config.TelemetryConfig.ConfigType.GRPC;
+
+/**
+ * Unit tests for openstack telemetry config REST API.
+ */
+public class OpenstackTelemetryConfigWebResourceTest extends ResourceTest {
+
+    private static final String NAME = "grpc";
+
+    private static final TelemetryConfig.ConfigType TYPE = GRPC;
+
+    private static final String MANUFACTURER = "grpc.io";
+
+    private static final String SW_VERSION = "1.0";
+
+    private static final Map<String, String> PROP = Maps.newConcurrentMap();
+
+    private static final String PROP_KEY_1 = "key11";
+    private static final String PROP_KEY_2 = "key12";
+    private static final String PROP_VALUE_1 = "value11";
+    private static final String PROP_VALUE_2 = "value12";
+
+    private static final boolean ENABLED = true;
+
+    private final TelemetryConfigAdminService mockConfigAdminService =
+            createMock(TelemetryConfigAdminService.class);
+    private static final String PATH = "config";
+
+    /**
+     * Constructs an openstack telemetry config resource test instance.
+     */
+    public OpenstackTelemetryConfigWebResourceTest() {
+        super(ResourceConfig.forApplicationClass(OpenstackTelemetryWebApplication.class));
+    }
+
+    private TelemetryConfig telemetryConfig;
+
+    /**
+     * Sets up the global values for all the tests.
+     */
+    @Before
+    public void setUpTest() {
+        ServiceDirectory testDirectory =
+                new TestServiceDirectory()
+                        .add(TelemetryConfigAdminService.class,
+                                mockConfigAdminService);
+        setServiceDirectory(testDirectory);
+
+        PROP.put(PROP_KEY_1, PROP_VALUE_1);
+        PROP.put(PROP_KEY_2, PROP_VALUE_2);
+
+        telemetryConfig = new DefaultTelemetryConfig(NAME, TYPE, null,
+                MANUFACTURER, SW_VERSION, ENABLED, PROP);
+    }
+
+    /**
+     * Tests the results of the REST API PUT method by modifying config address.
+     */
+    @Test
+    public void testUpdateConfigAddressWithModifyOperation() {
+        expect(mockConfigAdminService.getConfig(anyString()))
+                .andReturn(telemetryConfig).once();
+        mockConfigAdminService.updateTelemetryConfig(telemetryConfig);
+        replay(mockConfigAdminService);
+
+        final WebTarget wt = target();
+        Response response = wt.path(PATH + "/address/test1/address1")
+                .request(MediaType.APPLICATION_JSON_TYPE)
+                .put(Entity.json(""));
+        final int status = response.getStatus();
+
+        assertEquals(200, status);
+
+        verify(mockConfigAdminService);
+    }
+
+    /**
+     * Tests the results of the REST API PUT method without modifying config address.
+     */
+    @Test
+    public void testUpdateConfigAddressWithoutOperation() {
+        expect(mockConfigAdminService.getConfig(anyString())).andReturn(null).once();
+        replay(mockConfigAdminService);
+
+        final WebTarget wt = target();
+        Response response = wt.path(PATH + "/address/test1/address1")
+                .request(MediaType.APPLICATION_JSON_TYPE)
+                .put(Entity.json(""));
+        final int status = response.getStatus();
+
+        assertEquals(304, status);
+
+        verify(mockConfigAdminService);
+    }
+
+    /**
+     * Tests the results of the REST API DELETE method by removing config.
+     */
+    @Test
+    public void testDeleteConfigWithModifyOperation() {
+        expect(mockConfigAdminService.getConfig(anyString()))
+                .andReturn(telemetryConfig).once();
+        mockConfigAdminService.removeTelemetryConfig(anyString());
+        replay(mockConfigAdminService);
+
+        final WebTarget wt = target();
+        Response response = wt.path(PATH + "/test1")
+                .request(MediaType.APPLICATION_JSON_TYPE)
+                .delete();
+        final int status = response.getStatus();
+
+        assertEquals(204, status);
+
+        verify(mockConfigAdminService);
+    }
+
+    /**
+     * Tests the results of the REST API DELETE method without removing config.
+     */
+    @Test
+    public void testDeleteConfigWithoutModifyOperation() {
+        expect(mockConfigAdminService.getConfig(anyString())).andReturn(null).once();
+        replay(mockConfigAdminService);
+
+        final WebTarget wt = target();
+        Response response = wt.path(PATH + "/test1")
+                .request(MediaType.APPLICATION_JSON_TYPE)
+                .delete();
+        final int status = response.getStatus();
+
+        assertEquals(304, status);
+
+        verify(mockConfigAdminService);
+    }
+
+    /**
+     * Tests the results of REST API PUT method with enabling the config.
+     */
+    @Test
+    public void testEnableConfig() {
+        expect(mockConfigAdminService.getConfig(anyString()))
+                .andReturn(telemetryConfig).once();
+        mockConfigAdminService.updateTelemetryConfig(telemetryConfig);
+        replay(mockConfigAdminService);
+
+        final WebTarget wt = target();
+        Response response = wt.path(PATH + "/enable/test1")
+                .request(MediaType.APPLICATION_JSON_TYPE)
+                .put(Entity.json(""));
+        final int status = response.getStatus();
+
+        assertEquals(200, status);
+
+        verify(mockConfigAdminService);
+    }
+
+    /**
+     * Tests the results of REST API PUT method with disabling the config.
+     */
+    @Test
+    public void testDisableConfig() {
+        expect(mockConfigAdminService.getConfig(anyString()))
+                .andReturn(telemetryConfig).once();
+        mockConfigAdminService.updateTelemetryConfig(telemetryConfig);
+        replay(mockConfigAdminService);
+
+        final WebTarget wt = target();
+        Response response = wt.path(PATH + "/disable/test1")
+                .request(MediaType.APPLICATION_JSON_TYPE)
+                .put(Entity.json(""));
+        final int status = response.getStatus();
+
+        assertEquals(200, status);
+
+        verify(mockConfigAdminService);
+    }
+}
diff --git a/apps/openstacktelemetry/web/src/test/resources/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfig.json b/apps/openstacktelemetry/web/src/test/resources/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfig.json
new file mode 100644
index 0000000..681cad3
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/resources/org/onosproject/openstacktelemetry/codec/rest/TelemetryConfig.json
@@ -0,0 +1,17 @@
+{
+  "name": "grpc-config",
+  "type": "GRPC",
+  "manufacturer": "grpc.io",
+  "swVersion": "1.0",
+  "enabled": true,
+  "props": [
+    {
+      "key": "address",
+      "value": "127.0.0.1"
+    },
+    {
+      "key": "port",
+      "value": "9092"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/apps/openstacktelemetry/web/src/test/resources/org/onosproject/openstacktelemetry/web/openstack-telemetry-config-address.json b/apps/openstacktelemetry/web/src/test/resources/org/onosproject/openstacktelemetry/web/openstack-telemetry-config-address.json
new file mode 100644
index 0000000..a4132c5
--- /dev/null
+++ b/apps/openstacktelemetry/web/src/test/resources/org/onosproject/openstacktelemetry/web/openstack-telemetry-config-address.json
@@ -0,0 +1,5 @@
+{
+  "config": {
+    "address": "10.10.10.10"
+  }
+}
\ No newline at end of file