diff --git a/apps/pce/src/test/java/org/onosproject/pce/pceservice/DefaultPcePathTest.java b/apps/pce/src/test/java/org/onosproject/pce/pceservice/DefaultPcePathTest.java
new file mode 100644
index 0000000..2f5347d
--- /dev/null
+++ b/apps/pce/src/test/java/org/onosproject/pce/pceservice/DefaultPcePathTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * 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.pce.pceservice;
+
+import org.junit.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+import org.onosproject.incubator.net.tunnel.TunnelId;
+
+/**
+ * Unit tests for DefaultPcePath class.
+ */
+public class DefaultPcePathTest {
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        // create same two pce-path objects.
+        final String cost1 = "1";
+        final String bandwidth1 = "200";
+        final String src1 = "foo";
+        final String dst1 = "bee";
+        final String type1 = "1";
+        final String name1 = "pcc";
+
+        PcePath path1 = DefaultPcePath.builder()
+                .source(src1)
+                .destination(dst1)
+                .lspType(type1)
+                .name(name1)
+                .costConstraint(cost1)
+                .bandwidthConstraint(bandwidth1)
+                .build();
+        path1.id(TunnelId.valueOf("1"));
+
+        // create same as above object
+        PcePath samePath1 = DefaultPcePath.builder()
+                .source(src1)
+                .destination(dst1)
+                .lspType(type1)
+                .name(name1)
+                .costConstraint(cost1)
+                .bandwidthConstraint(bandwidth1)
+                .build();
+        samePath1.id(TunnelId.valueOf("1"));
+
+        // Create different pce-path object.
+        final String cost2 = "1";
+        final String bandwidth2 = "200";
+        final String src2 = "google";
+        final String dst2 = "yahoo";
+        final String type2 = "2";
+        final String name2 = "pcc2";
+
+        PcePath path2 = DefaultPcePath.builder()
+                .source(src2)
+                .destination(dst2)
+                .lspType(type2)
+                .name(name2)
+                .costConstraint(cost2)
+                .bandwidthConstraint(bandwidth2)
+                .build();
+        path2.id(TunnelId.valueOf("2"));
+        //TODO: will be uncommented below line once CostConstraint and LocalBandwidthConstraint classes are ready
+        //new EqualsTester().addEqualityGroup(path1, samePath1).addEqualityGroup(path2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultPcePath object.
+     */
+    @Test
+    public void testConstruction() {
+        final String cost = "1";
+        final String bandwidth = "600";
+        final String src = "indiatimes";
+        final String dst = "deccan";
+        final String type = "3";
+        final String name = "pcc4";
+
+        PcePath path = DefaultPcePath.builder()
+                .source(src)
+                .destination(dst)
+                .lspType(type)
+                .name(name)
+                .costConstraint(cost)
+                .bandwidthConstraint(bandwidth)
+                .build();
+
+        assertThat(src, is(path.source()));
+        assertThat(dst, is(path.destination()));
+        assertThat(LspType.WITHOUT_SIGNALLING_AND_WITHOUT_SR, is(path.lspType()));
+        assertThat(name, is(path.name()));
+        //TODO: will be uncommented below lines once CostConstraint and LocalBandwidthConstraint classes are ready
+        //assertThat(cost, is(path.costConstraint().toString()));
+        //assertThat(bandwidth, is(path.bandwidthConstraint().toString()));
+    }
+}
diff --git a/apps/pce/src/test/java/org/onosproject/pce/web/MockPceCodecContext.java b/apps/pce/src/test/java/org/onosproject/pce/web/MockPceCodecContext.java
new file mode 100644
index 0000000..1aa90aa
--- /dev/null
+++ b/apps/pce/src/test/java/org/onosproject/pce/web/MockPceCodecContext.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * 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.pce.web;
+
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.CodecService;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.codec.impl.CodecManager;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Mock codec context for use in codec unit tests.
+ */
+public class MockPceCodecContext implements CodecContext {
+
+    private final ObjectMapper mapper = new ObjectMapper();
+    private final CodecManager codecManager = new CodecManager();
+    private final PceCodecRegistrator manager = new PceCodecRegistrator();
+
+    /**
+     * Constructs a new mock codec context.
+     */
+    public MockPceCodecContext() {
+        codecManager.activate();
+        manager.codecService = codecManager;
+        manager.activate();
+    }
+
+    @Override
+    public ObjectMapper mapper() {
+        return mapper;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> T getService(Class<T> serviceClass) {
+        // TODO
+        return null;
+    }
+
+    @Override
+    public <T> JsonCodec<T> codec(Class<T> entityClass) {
+        return codecManager.getCodec(entityClass);
+    }
+
+    /**
+     * Get the codec manager.
+     *
+     * @return instance of codec manager
+     */
+    public CodecService codecManager() {
+        return codecManager;
+    }
+}
diff --git a/apps/pce/src/test/java/org/onosproject/pce/web/PcePathCodecTest.java b/apps/pce/src/test/java/org/onosproject/pce/web/PcePathCodecTest.java
new file mode 100644
index 0000000..64f1c48
--- /dev/null
+++ b/apps/pce/src/test/java/org/onosproject/pce/web/PcePathCodecTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * 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.pce.web;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.pce.pceservice.PcePath;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * PCE path codec unit tests.
+ */
+public class PcePathCodecTest {
+
+    MockPceCodecContext context;
+    JsonCodec<PcePath> pcePathCodec;
+    /**
+     * Sets up for each test. Creates a context and fetches the PCE path codec.
+     */
+    @Before
+    public void setUp() {
+        context = new MockPceCodecContext();
+        pcePathCodec = context.codec(PcePath.class);
+        assertThat(pcePathCodec, notNullValue());
+    }
+
+    /**
+     * Reads in a pce-path from the given resource and decodes it.
+     *
+     * @param resourceName resource to use to read the json for the pce-path
+     * @return decoded pce-path
+     * @throws IOException if processing the resource fails
+     */
+    private PcePath getPcePath(String resourceName) throws IOException {
+        InputStream jsonStream = PcePathCodecTest.class
+                .getResourceAsStream(resourceName);
+        ObjectMapper mapper = new ObjectMapper();
+        JsonNode json = mapper.readTree(jsonStream);
+        assertThat(json, notNullValue());
+        PcePath pcePath = pcePathCodec.decode((ObjectNode) json, context);
+        assertThat(pcePath, notNullValue());
+        return pcePath;
+    }
+
+    /**
+     * Checks that a simple pce-path is decoded properly.
+     *
+     * @throws IOException if the resource cannot be processed
+     */
+    @Test
+    public void codecPcePathTest() throws IOException {
+
+        PcePath pcePath = getPcePath("pcePath.json");
+
+        assertThat(pcePath, notNullValue());
+
+        assertThat(pcePath.source().toString(), is("11.0.0.1"));
+        assertThat(pcePath.destination(), is("11.0.0.2"));
+        assertThat(pcePath.lspType().toString(), is("SR_WITHOUT_SIGNALLING"));
+        //TODO: uncomment below lines once CostConstraint and LocalBandwidthConstraint are ready
+        //assertThat(pcePath.costConstraint().toString(), is(2));
+        //assertThat(pcePath.bandwidthConstraint().toString(), is(200.0));
+    }
+}
diff --git a/apps/pce/src/test/java/org/onosproject/pce/web/PcePathResourceTest.java b/apps/pce/src/test/java/org/onosproject/pce/web/PcePathResourceTest.java
new file mode 100644
index 0000000..181f864
--- /dev/null
+++ b/apps/pce/src/test/java/org/onosproject/pce/web/PcePathResourceTest.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * 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.pce.web;
+
+//import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.createMock;
+//import static org.easymock.EasyMock.expect;
+//import static org.easymock.EasyMock.replay;
+//import static org.hamcrest.Matchers.containsString;
+//import static org.hamcrest.Matchers.is;
+//import static org.hamcrest.Matchers.notNullValue;
+//import static org.junit.Assert.assertThat;
+//import static org.junit.Assert.fail;
+
+//import javax.ws.rs.NotFoundException;
+//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.io.InputStream;
+//import java.net.HttpURLConnection;
+//import java.util.HashSet;
+//import java.util.List;
+//import java.util.Objects;
+//import java.util.Optional;
+//import java.util.Set;
+
+//import com.eclipsesource.json.Json;
+//import com.eclipsesource.json.JsonObject;
+//import com.google.common.collect.ImmutableList;
+//import com.google.common.collect.Lists;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.osgi.ServiceDirectory;
+import org.onlab.osgi.TestServiceDirectory;
+import org.onlab.rest.BaseResource;
+import org.onosproject.codec.CodecService;
+import org.onosproject.incubator.net.tunnel.TunnelId;
+import org.onosproject.net.intent.Constraint;
+import org.onosproject.pce.pceservice.PcePath;
+import org.onosproject.pce.pceservice.LspType;
+import org.onosproject.pce.pceservice.api.PceService;
+
+/**
+ * Unit tests for pce path REST APIs.
+ */
+public class PcePathResourceTest extends PceResourceTest {
+    final PceService pceService = createMock(PceService.class);
+    final TunnelId pcePathId1 = TunnelId.valueOf("1");
+    //TODO: will be uncommented below lines once CostConstraint and LocalBandwidthConstraint classes are ready
+    final Constraint costConstraint = null; //CostConstraint.of("2");
+    final Constraint bandwidthConstraint = null; //LocalBandwidthConstraint.of("200.0");
+    final LspType lspType = LspType.WITH_SIGNALLING;
+    final MockPcePath pcePath1 = new MockPcePath(pcePathId1, "11.0.0.1", "11.0.0.2", lspType, "pcc2",
+                                                 costConstraint, bandwidthConstraint);
+
+    /**
+     * Mock class for a pce path.
+     */
+    private static class MockPcePath implements PcePath {
+        private TunnelId id;
+        private String source;
+        private String destination;
+        private LspType lspType;
+        private String name;
+        private Constraint costConstraint;
+        private Constraint bandwidthConstraint;
+
+        /**
+         * Constructor to initialize member variables.
+         *
+         * @param id pce path id
+         * @param src source device
+         * @param dst destination device
+         * @param type lsp type
+         * @param name symbolic path name
+         * @param constrnt pce constraint
+         */
+        public MockPcePath(TunnelId id, String src, String dst, LspType type, String name,
+                           Constraint costConstrnt, Constraint bandwidthConstrnt) {
+            this.id = id;
+            this.source = src;
+            this.destination = dst;
+            this.name = name;
+            this.lspType = type;
+            this.costConstraint = costConstrnt;
+            this.bandwidthConstraint = bandwidthConstrnt;
+        }
+
+        @Override
+        public TunnelId id() {
+            return id;
+        }
+
+        @Override
+        public void id(TunnelId id) {
+            this.id = id;
+        }
+
+        @Override
+        public String source() {
+            return source;
+        }
+
+        @Override
+        public void source(String src) {
+            this.source = src;
+        }
+
+        @Override
+        public String destination() {
+            return destination;
+        }
+
+        @Override
+        public void destination(String dst) {
+            this.destination = dst;
+        }
+
+        @Override
+        public LspType lspType() {
+            return lspType;
+        }
+
+        @Override
+        public String name() {
+            return name;
+        }
+
+        @Override
+        public Constraint costConstraint() {
+            return costConstraint;
+        }
+
+        @Override
+        public Constraint bandwidthConstraint() {
+            return bandwidthConstraint;
+        }
+
+        @Override
+        public PcePath copy(PcePath path) {
+            if (null != path.source()) {
+                this.source = path.source();
+            }
+            if (null != path.destination()) {
+                this.destination = path.destination();
+            }
+            if (this.lspType != path.lspType()) {
+                this.lspType = path.lspType();
+            }
+            if (null != path.name()) {
+                this.name = path.name();
+            }
+            if (null != path.costConstraint()) {
+                this.costConstraint = path.costConstraint();
+            }
+            if (null != path.bandwidthConstraint()) {
+                this.bandwidthConstraint = path.bandwidthConstraint();
+            }
+            return this;
+        }
+    }
+
+    /**
+     * Sets up the global values for all the tests.
+     */
+    @Before
+    public void setUpTest() {
+        MockPceCodecContext context = new MockPceCodecContext();
+        ServiceDirectory testDirectory = new TestServiceDirectory().add(PceService.class, pceService)
+                .add(CodecService.class, context.codecManager());
+        BaseResource.setServiceDirectory(testDirectory);
+    }
+
+    /**
+     * Cleans up.
+     */
+    @After
+    public void tearDownTest() {
+    }
+
+    /**
+     * Tests the result of the rest api GET when there are no pce paths.
+     */
+    @Test
+    public void testPcePathsEmpty() {
+        //TODO: will be uncommented below code once PceService is ready
+        //expect(pceService.queryAllPath()).andReturn(null).anyTimes();
+        //replay(pceService);
+        //final WebTarget wt = target();
+        //final String response = wt.path("path").request().get(String.class);
+        //assertThat(response, is("{\"paths\":[]}"));
+    }
+
+    /**
+     * Tests the result of a rest api GET for pce path id.
+     */
+    @Test
+    public void testGetTunnelId() {
+        //TODO: will be uncommented below code once PceService is ready
+        //final Set<PcePath> pcePaths = new HashSet<>();
+        //pcePaths.add(pcePath1);
+
+        //expect(pceService.queryPath(anyObject())).andReturn(pcePath1).anyTimes();
+        //replay(pceService);
+
+        //final WebTarget wt = target();
+        //final String response = wt.path("path/1").request().get(String.class);
+        //final JsonObject result = Json.parse(response).asObject();
+        //assertThat(result, notNullValue());
+    }
+
+    /**
+     * Tests that a fetch of a non-existent pce path object throws an exception.
+     */
+    @Test
+    public void testBadGet() {
+        //TODO: will be uncommented below code once PceService is ready
+        //expect(pceService.queryPath(anyObject()))
+        //        .andReturn(null).anyTimes();
+        //replay(pceService);
+
+        //WebTarget wt = target();
+        //try {
+        //    wt.path("path/1").request().get(String.class);
+        //    fail("Fetch of non-existent pce path did not throw an exception");
+        //} catch (NotFoundException ex) {
+        //    assertThat(ex.getMessage(),
+        //               containsString("HTTP 404 Not Found"));
+        //}
+    }
+
+    /**
+     * Tests creating a pce path with POST.
+     */
+    @Test
+    public void testPost() {
+        //TODO: will be uncommented below code once PceService is ready
+        //expect(pceService.setupPath(anyObject()))
+        //        .andReturn(true).anyTimes();
+        //replay(pceService);
+
+        //WebTarget wt = target();
+        //InputStream jsonStream = PcePathResourceTest.class.getResourceAsStream("post-PcePath.json");
+
+        //Response response = wt.path("path")
+        //        .request(MediaType.APPLICATION_JSON_TYPE)
+        //        .post(Entity.json(jsonStream));
+        //assertThat(response.getStatus(), is(HttpURLConnection.HTTP_OK));
+    }
+
+    /**
+     * Tests creating a pce path with PUT.
+     */
+    @Test
+    public void testPut() {
+        //TODO: will be uncommented below code once PceService is ready
+        //expect(pceService.updatePath(anyObject()))
+        //        .andReturn(true).anyTimes();
+        //replay(pceService);
+
+        //WebTarget wt = target();
+        //InputStream jsonStream = PcePathResourceTest.class.getResourceAsStream("post-PcePath.json");
+
+        //Response response = wt.path("path/1")
+        //        .request(MediaType.APPLICATION_JSON_TYPE)
+        //        .put(Entity.json(jsonStream));
+        //assertThat(response.getStatus(), is(HttpURLConnection.HTTP_OK));
+    }
+
+    /**
+     * Tests deleting a pce path.
+     */
+    @Test
+    public void testDelete() {
+        //TODO: will be uncommented below code once PceService is ready
+        //expect(pceService.releasePath(anyObject()))
+        //        .andReturn(true).anyTimes();
+        //replay(pceService);
+
+        //WebTarget wt = target();
+
+        //String location = "path/1";
+
+        //Response deleteResponse = wt.path(location)
+        //        .request(MediaType.APPLICATION_JSON_TYPE)
+        //        .delete();
+        //assertThat(deleteResponse.getStatus(),
+        //           is(HttpURLConnection.HTTP_OK));
+    }
+}
diff --git a/apps/pce/src/test/java/org/onosproject/pce/web/PceResourceTest.java b/apps/pce/src/test/java/org/onosproject/pce/web/PceResourceTest.java
new file mode 100644
index 0000000..d7a29f5
--- /dev/null
+++ b/apps/pce/src/test/java/org/onosproject/pce/web/PceResourceTest.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * 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.pce.web;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+
+/**
+ * Base class for pce rest api tests.  Performs common configuration operations.
+ */
+public class PceResourceTest extends JerseyTest {
+
+    /**
+     * Creates a new web-resource test.
+     */
+    public PceResourceTest() {
+        super(ResourceConfig.forApplicationClass(PceWebApplication.class));
+    }
+}