web/api/src/test/java/org/onosproject/rest/resources/ApplicationsResourceTest.java - onos - Gitiles

 /*
  * Copyright 2016-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.rest.resources;

 import com.eclipsesource.json.Json;
 import com.eclipsesource.json.JsonArray;
 import com.eclipsesource.json.JsonObject;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import org.hamcrest.Description;
 import org.hamcrest.TypeSafeMatcher;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.onlab.osgi.ServiceDirectory;
 import org.onlab.osgi.TestServiceDirectory;
 import org.onosproject.app.ApplicationAdminService;
 import org.onosproject.app.ApplicationService;
 import org.onosproject.app.ApplicationState;
 import org.onosproject.codec.CodecService;
 import org.onosproject.codec.impl.ApplicationCodec;
 import org.onosproject.codec.impl.CodecManager;
 import org.onosproject.codec.impl.MockCodecContext;
 import org.onosproject.core.Application;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.ApplicationRole;
 import org.onosproject.core.CoreService;
 import org.onosproject.core.DefaultApplication;
 import org.onosproject.core.DefaultApplicationId;
 import org.onosproject.core.Version;

 import javax.ws.rs.NotFoundException;
 import javax.ws.rs.client.Entity;
 import javax.ws.rs.client.WebTarget;
 import javax.ws.rs.core.MediaType;
 import java.io.InputStream;
 import java.net.URI;
 import java.util.Optional;

 import static org.easymock.EasyMock.createMock;
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.expectLastCall;
 import static org.easymock.EasyMock.isA;
 import static org.easymock.EasyMock.replay;
 import static org.easymock.EasyMock.verify;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.notNullValue;

 /**
  * Unit tests for applications REST APIs.
  */

 public class ApplicationsResourceTest extends ResourceTest {

     private static class MockCodecContextWithAppService extends MockCodecContext {
         private ApplicationAdminService appService;

         MockCodecContextWithAppService(ApplicationAdminService appService) {
             this.appService = appService;
         }

         @Override
         @SuppressWarnings("unchecked")
         public <T> T getService(Class<T> serviceClass) {
             return (T) appService;
         }
     }

     private static class MockCodecContextWithCoreService extends MockCodecContext {
         private CoreService coreService;

         MockCodecContextWithCoreService(CoreService coreService) {
             this.coreService = coreService;
         }

         @Override
         @SuppressWarnings("unchecked")
         public <T> T getService(Class<T> serviceClass) {
             return (T) coreService;
         }
     }

     private ApplicationAdminService appService;
     private CoreService coreService;
     private ApplicationId id1 = new DefaultApplicationId(1, "app1");
     private ApplicationId id2 = new DefaultApplicationId(2, "app2");
     private ApplicationId id3 = new DefaultApplicationId(3, "app3");
     private ApplicationId id4 = new DefaultApplicationId(4, "app4");

     private static final URI FURL = URI.create("mvn:org.foo-features/1.2a/xml/features");
     private static final Version VER = Version.version(1, 2, "a", null);

     private DefaultApplication.Builder baseBuilder = DefaultApplication.builder()
                 .withVersion(VER)
                 .withIcon(new byte[0])
                 .withRole(ApplicationRole.ADMIN)
                 .withPermissions(ImmutableSet.of())
                 .withFeaturesRepo(Optional.of(FURL))
                 .withFeatures(ImmutableList.of("My Feature"))
                 .withRequiredApps(ImmutableList.of());

     private Application app1 =
             DefaultApplication.builder(baseBuilder)
                 .withAppId(id1)
                 .withTitle("title1")
                 .withDescription("desc1")
                 .withOrigin("origin1")
                 .withCategory("category1")
                 .withUrl("url1")
                 .withReadme("readme1")
                 .build();
     private Application app2 =
             DefaultApplication.builder(baseBuilder)
                     .withAppId(id2)
                     .withTitle("title2")
                     .withDescription("desc2")
                     .withOrigin("origin2")
                     .withCategory("category2")
                     .withUrl("url2")
                     .withReadme("readme2")
                     .build();
     private Application app3 =
             DefaultApplication.builder(baseBuilder)
                     .withAppId(id3)
                     .withTitle("title3")
                     .withDescription("desc3")
                     .withOrigin("origin3")
                     .withCategory("category3")
                     .withUrl("url3")
                     .withReadme("readme3")
                     .build();
     private Application app4 =
             DefaultApplication.builder(baseBuilder)
                     .withAppId(id4)
                     .withTitle("title4")
                     .withDescription("desc4")
                     .withOrigin("origin4")
                     .withCategory("category4")
                     .withUrl("url4")
                     .withReadme("readme4")
                     .build();

     /**
      * Hamcrest matcher to check that an application representation in JSON matches
      * the actual device.
      */
     private static class AppJsonMatcher extends TypeSafeMatcher<JsonObject> {
         private final Application app;
         private String reason = "";

         public AppJsonMatcher(Application appValue) {
             app = appValue;
         }

         @Override
         public boolean matchesSafely(JsonObject jsonApp) {
             // check id
             short jsonId = (short) jsonApp.get("id").asInt();
             if (jsonId != app.id().id()) {
                 reason = "id " + app.id().id();
                 return false;
             }

             // check name
             String jsonName = jsonApp.get("name").asString();
             if (!jsonName.equals(app.id().name())) {
                 reason = "name " + app.id().name();
                 return false;
             }

             // check origin
             String jsonOrigin = jsonApp.get("origin").asString();
             if (!jsonOrigin.equals(app.origin())) {
                 reason = "manufacturer " + app.origin();
                 return false;
             }

             return true;
         }

         @Override
         public void describeTo(Description description) {
             description.appendText(reason);
         }
     }

     /**
      * Hamcrest matcher to check that an application id representation in JSON.
      */
     private static final class AppIdJsonMatcher extends TypeSafeMatcher<JsonObject> {
         private final ApplicationId appId;
         private String reason = "";

         private AppIdJsonMatcher(ApplicationId appId) {
             this.appId = appId;
         }

         @Override
         protected boolean matchesSafely(JsonObject jsonAppId) {
             // check id
             short jsonId = (short) jsonAppId.get("id").asInt();
             if (jsonId != appId.id()) {
                 reason = "id " + appId.id();
                 return false;
             }

             // check name
             String jsonName = jsonAppId.get("name").asString();
             if (!jsonName.equals(appId.name())) {
                 reason = "name " + appId.name();
                 return false;
             }

             return true;
         }

         @Override
         public void describeTo(Description description) {
             description.appendText(reason);
         }
     }

     /**
      * Factory to allocate an application matcher.
      *
      * @param app application object we are looking for
      * @return matcher
      */
     private static AppJsonMatcher matchesApp(Application app) {
         return new AppJsonMatcher(app);
     }

     /**
      * Factory to allocate an application Id matcher.
      *
      * @param appId application Id object we are looking for
      * @return matcher
      */
     private static AppIdJsonMatcher matchesAppId(ApplicationId appId) {
         return new AppIdJsonMatcher(appId);
     }

     /**
      * Initializes test mocks and environment.
      */
     @Before
     public void setUpMocks() {
         appService = createMock(ApplicationAdminService.class);
         coreService = createMock(CoreService.class);

         expect(appService.getId("one"))
                 .andReturn(id1)
                 .anyTimes();
         expect(appService.getId("two"))
                 .andReturn(id2)
                 .anyTimes();
         expect(appService.getId("three"))
                 .andReturn(id3)
                 .anyTimes();
         expect(appService.getId("four"))
                 .andReturn(id4)
                 .anyTimes();

         expect(appService.getApplication(id3))
                 .andReturn(app3)
                 .anyTimes();
         expect(appService.getState(isA(ApplicationId.class)))
                 .andReturn(ApplicationState.ACTIVE)
                 .anyTimes();

         // Register the services needed for the test
         CodecManager codecService = new CodecManager();
         codecService.activate();
         ServiceDirectory testDirectory =
                 new TestServiceDirectory()
                         .add(ApplicationAdminService.class, appService)
                         .add(ApplicationService.class, appService)
                         .add(CoreService.class, coreService)
                         .add(CodecService.class, codecService);

         setServiceDirectory(testDirectory);
     }

     /**
      * Tests a GET of all applications when no applications are present.
      */
     @Test
     public void getAllApplicationsEmpty() {
         expect(appService.getApplications())
                 .andReturn(ImmutableSet.of());
         replay(appService);

         WebTarget wt = target();
         String response = wt.path("applications").request().get(String.class);
         assertThat(response, is("{\"applications\":[]}"));

         verify(appService);
     }

     /**
      * Tests a GET of all applications with data.
      */
     @Test
     public void getAllApplicationsPopulated() {
         expect(appService.getApplications())
                 .andReturn(ImmutableSet.of(app1, app2, app3, app4));
         replay(appService);

         WebTarget wt = target();
         String response = wt.path("applications").request().get(String.class);
         assertThat(response, containsString("{\"applications\":["));

         JsonObject result = Json.parse(response).asObject();
         assertThat(result, notNullValue());

         assertThat(result.names(), hasSize(1));
         assertThat(result.names().get(0), is("applications"));

         JsonArray jsonApps = result.get("applications").asArray();
         assertThat(jsonApps, notNullValue());
         assertThat(jsonApps.size(), is(4));

         assertThat(jsonApps.get(0).asObject(), matchesApp(app1));
         assertThat(jsonApps.get(1).asObject(), matchesApp(app2));
         assertThat(jsonApps.get(2).asObject(), matchesApp(app3));
         assertThat(jsonApps.get(3).asObject(), matchesApp(app4));

         verify(appService);
     }

     /**
      * Tests a GET of a single application.
      */
     @Test
     public void getSingleApplication() {
         replay(appService);

         WebTarget wt = target();
         String response = wt.path("applications/three").request().get(String.class);

         JsonObject result = Json.parse(response).asObject();
         assertThat(result, notNullValue());

         assertThat(result, matchesApp(app3));

         verify(appService);
     }

     /**
      * Tests a DELETE of a single application - this should
      * attempt to uninstall it.
      */
     @Test
     public void deleteApplication() {
         appService.uninstall(id3);
         expectLastCall();

         replay(appService);

         WebTarget wt = target();
         wt.path("applications/three").request().delete();

         verify(appService);
     }

     /**
      * Tests a DELETE of a single active application - this should
      * attempt to uninstall it.
      */
     @Test
     public void deleteActiveApplication() {
         appService.deactivate(id3);
         expectLastCall();

         replay(appService);

         WebTarget wt = target();
         wt.path("applications/three/active").request().delete();

         verify(appService);
     }

     /**
      * Tests a POST operation to the "active" URL.  This should attempt to
      * activate the application.
      */
     @Test
     public void postActiveApplication() {
         appService.activate(id3);
         expectLastCall();

         replay(appService);

         WebTarget wt = target();
         wt.path("applications/three/active").request().post(null);

         verify(appService);
     }

     /**
      * Tests a POST operation.  This should attempt to
      * install the application.
      */
     @Test
     public void postApplication() {
         expect(appService.install(isA(InputStream.class)))
                 .andReturn(app4)
                 .once();

         replay(appService);

         ApplicationCodec codec = new ApplicationCodec();
         String app4Json = codec.encode(app4,
                 new MockCodecContextWithAppService(appService))
                 .asText();

         WebTarget wt = target();
         String response = wt.path("applications").request().post(
                 Entity.entity(app4Json, MediaType.APPLICATION_OCTET_STREAM), String.class);

         JsonObject result = Json.parse(response).asObject();
         assertThat(result, notNullValue());

         assertThat(result, matchesApp(app4));

         verify(appService);
     }

     /**
      * Tests a POST operation. This should attempt to register an on/off platform
      * application ID.
      */
     @Test
     public void postRegisterAppId() {
         expect(coreService.registerApplication("app1")).andReturn(id1).anyTimes();
         replay(coreService);

         WebTarget wt = target();
         wt.path("applications/app1/register").request().post(null);

         verify(coreService);
     }

     /**
      * Tests a GET of all application Ids when no applications are present.
      */
     @Test
     public void getAllApplicationIdsEmpty() {
         expect(coreService.getAppIds()).andReturn(ImmutableSet.of());
         replay(coreService);

         WebTarget wt = target();
         String response = wt.path("applications/ids").request().get(String.class);
         assertThat(response, is("{\"applicationIds\":[]}"));

         verify(coreService);
     }

     /**
      * Tests a GET of all application Ids.
      */
     @Test
     public void getAllApplicationIdsPopulated() {
         expect(coreService.getAppIds())
                 .andReturn(ImmutableSet.of(id1, id2, id3, id4));
         replay(coreService);

         WebTarget wt = target();
         String response = wt.path("applications/ids").request().get(String.class);

         assertThat(response, containsString("{\"applicationIds\":["));

         JsonObject result = Json.parse(response).asObject();
         assertThat(result, notNullValue());

         assertThat(result.names(), hasSize(1));
         assertThat(result.names().get(0), is("applicationIds"));

         JsonArray jsonApps = result.get("applicationIds").asArray();
         assertThat(jsonApps, notNullValue());
         assertThat(jsonApps.size(), is(4));

         assertThat(jsonApps.get(0).asObject(), matchesAppId(id1));
         assertThat(jsonApps.get(1).asObject(), matchesAppId(id2));
         assertThat(jsonApps.get(2).asObject(), matchesAppId(id3));
         assertThat(jsonApps.get(3).asObject(), matchesAppId(id4));

         verify(coreService);
     }

     /**
      * Tests a GET of an applicationId entry with the given numeric id.
      */
     @Test
     public void getAppIdByShortId() {
         expect(coreService.getAppId((short) 1)).andReturn(id1);
         replay(coreService);

         WebTarget wt = target();
         String response = wt.path("applications/ids/entry")
                 .queryParam("id", 1).request().get(String.class);

         JsonObject result = Json.parse(response).asObject();
         assertThat(result, notNullValue());

         assertThat(result, matchesAppId(id1));

         verify(coreService);
     }

     /**
      * Tests a GET of an applicationId entry with the given application name.
      */
     @Test
     public void getAppIdByName() {
         expect(coreService.getAppId("app2")).andReturn(id2);
         replay(coreService);

         WebTarget wt = target();
         String response = wt.path("applications/ids/entry")
                 .queryParam("name", "app2").request().get(String.class);

         JsonObject result = Json.parse(response).asObject();
         assertThat(result, notNullValue());

         assertThat(result, matchesAppId(id2));

         verify(coreService);
     }

     /**
      * Tests a GET of an applicationId without specifying any parameters.
      */
     @Test
     public void getAppWithNoParam() {
         WebTarget wt = target();

         try {
             wt.path("applications/ids/entry").request().get();
         } catch (NotFoundException ex) {
             Assert.assertThat(ex.getMessage(),
                     containsString("HTTP 404 Not Found"));
         }
     }
 }
	/*
	* Copyright 2016-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.rest.resources;

	import com.eclipsesource.json.Json;
	import com.eclipsesource.json.JsonArray;
	import com.eclipsesource.json.JsonObject;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableSet;
	import org.hamcrest.Description;
	import org.hamcrest.TypeSafeMatcher;
	import org.junit.Assert;
	import org.junit.Before;
	import org.junit.Test;
	import org.onlab.osgi.ServiceDirectory;
	import org.onlab.osgi.TestServiceDirectory;
	import org.onosproject.app.ApplicationAdminService;
	import org.onosproject.app.ApplicationService;
	import org.onosproject.app.ApplicationState;
	import org.onosproject.codec.CodecService;
	import org.onosproject.codec.impl.ApplicationCodec;
	import org.onosproject.codec.impl.CodecManager;
	import org.onosproject.codec.impl.MockCodecContext;
	import org.onosproject.core.Application;
	import org.onosproject.core.ApplicationId;
	import org.onosproject.core.ApplicationRole;
	import org.onosproject.core.CoreService;
	import org.onosproject.core.DefaultApplication;
	import org.onosproject.core.DefaultApplicationId;
	import org.onosproject.core.Version;

	import javax.ws.rs.NotFoundException;
	import javax.ws.rs.client.Entity;
	import javax.ws.rs.client.WebTarget;
	import javax.ws.rs.core.MediaType;
	import java.io.InputStream;
	import java.net.URI;
	import java.util.Optional;

	import static org.easymock.EasyMock.createMock;
	import static org.easymock.EasyMock.expect;
	import static org.easymock.EasyMock.expectLastCall;
	import static org.easymock.EasyMock.isA;
	import static org.easymock.EasyMock.replay;
	import static org.easymock.EasyMock.verify;
	import static org.hamcrest.MatcherAssert.assertThat;
	import static org.hamcrest.Matchers.containsString;
	import static org.hamcrest.Matchers.hasSize;
	import static org.hamcrest.Matchers.is;
	import static org.hamcrest.Matchers.notNullValue;

	/**
	* Unit tests for applications REST APIs.
	*/

	public class ApplicationsResourceTest extends ResourceTest {

	private static class MockCodecContextWithAppService extends MockCodecContext {
	private ApplicationAdminService appService;

	MockCodecContextWithAppService(ApplicationAdminService appService) {
	this.appService = appService;
	}

	@Override
	@SuppressWarnings("unchecked")
	public <T> T getService(Class<T> serviceClass) {
	return (T) appService;
	}
	}

	private static class MockCodecContextWithCoreService extends MockCodecContext {
	private CoreService coreService;

	MockCodecContextWithCoreService(CoreService coreService) {
	this.coreService = coreService;
	}

	@Override
	@SuppressWarnings("unchecked")
	public <T> T getService(Class<T> serviceClass) {
	return (T) coreService;
	}
	}

	private ApplicationAdminService appService;
	private CoreService coreService;
	private ApplicationId id1 = new DefaultApplicationId(1, "app1");
	private ApplicationId id2 = new DefaultApplicationId(2, "app2");
	private ApplicationId id3 = new DefaultApplicationId(3, "app3");
	private ApplicationId id4 = new DefaultApplicationId(4, "app4");

	private static final URI FURL = URI.create("mvn:org.foo-features/1.2a/xml/features");
	private static final Version VER = Version.version(1, 2, "a", null);

	private DefaultApplication.Builder baseBuilder = DefaultApplication.builder()
	.withVersion(VER)
	.withIcon(new byte[0])
	.withRole(ApplicationRole.ADMIN)
	.withPermissions(ImmutableSet.of())
	.withFeaturesRepo(Optional.of(FURL))
	.withFeatures(ImmutableList.of("My Feature"))
	.withRequiredApps(ImmutableList.of());

	private Application app1 =
	DefaultApplication.builder(baseBuilder)
	.withAppId(id1)
	.withTitle("title1")
	.withDescription("desc1")
	.withOrigin("origin1")
	.withCategory("category1")
	.withUrl("url1")
	.withReadme("readme1")
	.build();
	private Application app2 =
	DefaultApplication.builder(baseBuilder)
	.withAppId(id2)
	.withTitle("title2")
	.withDescription("desc2")
	.withOrigin("origin2")
	.withCategory("category2")
	.withUrl("url2")
	.withReadme("readme2")
	.build();
	private Application app3 =
	DefaultApplication.builder(baseBuilder)
	.withAppId(id3)
	.withTitle("title3")
	.withDescription("desc3")
	.withOrigin("origin3")
	.withCategory("category3")
	.withUrl("url3")
	.withReadme("readme3")
	.build();
	private Application app4 =
	DefaultApplication.builder(baseBuilder)
	.withAppId(id4)
	.withTitle("title4")
	.withDescription("desc4")
	.withOrigin("origin4")
	.withCategory("category4")
	.withUrl("url4")
	.withReadme("readme4")
	.build();

	/**
	* Hamcrest matcher to check that an application representation in JSON matches
	* the actual device.
	*/
	private static class AppJsonMatcher extends TypeSafeMatcher<JsonObject> {
	private final Application app;
	private String reason = "";

	public AppJsonMatcher(Application appValue) {
	app = appValue;
	}

	@Override
	public boolean matchesSafely(JsonObject jsonApp) {
	// check id
	short jsonId = (short) jsonApp.get("id").asInt();
	if (jsonId != app.id().id()) {
	reason = "id " + app.id().id();
	return false;
	}

	// check name
	String jsonName = jsonApp.get("name").asString();
	if (!jsonName.equals(app.id().name())) {
	reason = "name " + app.id().name();
	return false;
	}

	// check origin
	String jsonOrigin = jsonApp.get("origin").asString();
	if (!jsonOrigin.equals(app.origin())) {
	reason = "manufacturer " + app.origin();
	return false;
	}

	return true;
	}

	@Override
	public void describeTo(Description description) {
	description.appendText(reason);
	}
	}

	/**
	* Hamcrest matcher to check that an application id representation in JSON.
	*/
	private static final class AppIdJsonMatcher extends TypeSafeMatcher<JsonObject> {
	private final ApplicationId appId;
	private String reason = "";

	private AppIdJsonMatcher(ApplicationId appId) {
	this.appId = appId;
	}

	@Override
	protected boolean matchesSafely(JsonObject jsonAppId) {
	// check id
	short jsonId = (short) jsonAppId.get("id").asInt();
	if (jsonId != appId.id()) {
	reason = "id " + appId.id();
	return false;
	}

	// check name
	String jsonName = jsonAppId.get("name").asString();
	if (!jsonName.equals(appId.name())) {
	reason = "name " + appId.name();
	return false;
	}

	return true;
	}

	@Override
	public void describeTo(Description description) {
	description.appendText(reason);
	}
	}

	/**
	* Factory to allocate an application matcher.
	*
	* @param app application object we are looking for
	* @return matcher
	*/
	private static AppJsonMatcher matchesApp(Application app) {
	return new AppJsonMatcher(app);
	}

	/**
	* Factory to allocate an application Id matcher.
	*
	* @param appId application Id object we are looking for
	* @return matcher
	*/
	private static AppIdJsonMatcher matchesAppId(ApplicationId appId) {
	return new AppIdJsonMatcher(appId);
	}

	/**
	* Initializes test mocks and environment.
	*/
	@Before
	public void setUpMocks() {
	appService = createMock(ApplicationAdminService.class);
	coreService = createMock(CoreService.class);

	expect(appService.getId("one"))
	.andReturn(id1)
	.anyTimes();
	expect(appService.getId("two"))
	.andReturn(id2)
	.anyTimes();
	expect(appService.getId("three"))
	.andReturn(id3)
	.anyTimes();
	expect(appService.getId("four"))
	.andReturn(id4)
	.anyTimes();

	expect(appService.getApplication(id3))
	.andReturn(app3)
	.anyTimes();
	expect(appService.getState(isA(ApplicationId.class)))
	.andReturn(ApplicationState.ACTIVE)
	.anyTimes();

	// Register the services needed for the test
	CodecManager codecService = new CodecManager();
	codecService.activate();
	ServiceDirectory testDirectory =
	new TestServiceDirectory()
	.add(ApplicationAdminService.class, appService)
	.add(ApplicationService.class, appService)
	.add(CoreService.class, coreService)
	.add(CodecService.class, codecService);

	setServiceDirectory(testDirectory);
	}

	/**
	* Tests a GET of all applications when no applications are present.
	*/
	@Test
	public void getAllApplicationsEmpty() {
	expect(appService.getApplications())
	.andReturn(ImmutableSet.of());
	replay(appService);

	WebTarget wt = target();
	String response = wt.path("applications").request().get(String.class);
	assertThat(response, is("{\"applications\":[]}"));

	verify(appService);
	}

	/**
	* Tests a GET of all applications with data.
	*/
	@Test
	public void getAllApplicationsPopulated() {
	expect(appService.getApplications())
	.andReturn(ImmutableSet.of(app1, app2, app3, app4));
	replay(appService);

	WebTarget wt = target();
	String response = wt.path("applications").request().get(String.class);
	assertThat(response, containsString("{\"applications\":["));

	JsonObject result = Json.parse(response).asObject();
	assertThat(result, notNullValue());

	assertThat(result.names(), hasSize(1));
	assertThat(result.names().get(0), is("applications"));

	JsonArray jsonApps = result.get("applications").asArray();
	assertThat(jsonApps, notNullValue());
	assertThat(jsonApps.size(), is(4));

	assertThat(jsonApps.get(0).asObject(), matchesApp(app1));
	assertThat(jsonApps.get(1).asObject(), matchesApp(app2));
	assertThat(jsonApps.get(2).asObject(), matchesApp(app3));
	assertThat(jsonApps.get(3).asObject(), matchesApp(app4));

	verify(appService);
	}

	/**
	* Tests a GET of a single application.
	*/
	@Test
	public void getSingleApplication() {
	replay(appService);

	WebTarget wt = target();
	String response = wt.path("applications/three").request().get(String.class);

	JsonObject result = Json.parse(response).asObject();
	assertThat(result, notNullValue());

	assertThat(result, matchesApp(app3));

	verify(appService);
	}

	/**
	* Tests a DELETE of a single application - this should
	* attempt to uninstall it.
	*/
	@Test
	public void deleteApplication() {
	appService.uninstall(id3);
	expectLastCall();

	replay(appService);

	WebTarget wt = target();
	wt.path("applications/three").request().delete();

	verify(appService);
	}

	/**
	* Tests a DELETE of a single active application - this should
	* attempt to uninstall it.
	*/
	@Test
	public void deleteActiveApplication() {
	appService.deactivate(id3);
	expectLastCall();

	replay(appService);

	WebTarget wt = target();
	wt.path("applications/three/active").request().delete();

	verify(appService);
	}

	/**
	* Tests a POST operation to the "active" URL. This should attempt to
	* activate the application.
	*/
	@Test
	public void postActiveApplication() {
	appService.activate(id3);
	expectLastCall();

	replay(appService);

	WebTarget wt = target();
	wt.path("applications/three/active").request().post(null);

	verify(appService);
	}

	/**
	* Tests a POST operation. This should attempt to
	* install the application.
	*/
	@Test
	public void postApplication() {
	expect(appService.install(isA(InputStream.class)))
	.andReturn(app4)
	.once();

	replay(appService);

	ApplicationCodec codec = new ApplicationCodec();
	String app4Json = codec.encode(app4,
	new MockCodecContextWithAppService(appService))
	.asText();

	WebTarget wt = target();
	String response = wt.path("applications").request().post(
	Entity.entity(app4Json, MediaType.APPLICATION_OCTET_STREAM), String.class);

	JsonObject result = Json.parse(response).asObject();
	assertThat(result, notNullValue());

	assertThat(result, matchesApp(app4));

	verify(appService);
	}

	/**
	* Tests a POST operation. This should attempt to register an on/off platform
	* application ID.
	*/
	@Test
	public void postRegisterAppId() {
	expect(coreService.registerApplication("app1")).andReturn(id1).anyTimes();
	replay(coreService);

	WebTarget wt = target();
	wt.path("applications/app1/register").request().post(null);

	verify(coreService);
	}

	/**
	* Tests a GET of all application Ids when no applications are present.
	*/
	@Test
	public void getAllApplicationIdsEmpty() {
	expect(coreService.getAppIds()).andReturn(ImmutableSet.of());
	replay(coreService);

	WebTarget wt = target();
	String response = wt.path("applications/ids").request().get(String.class);
	assertThat(response, is("{\"applicationIds\":[]}"));

	verify(coreService);
	}

	/**
	* Tests a GET of all application Ids.
	*/
	@Test
	public void getAllApplicationIdsPopulated() {
	expect(coreService.getAppIds())
	.andReturn(ImmutableSet.of(id1, id2, id3, id4));
	replay(coreService);

	WebTarget wt = target();
	String response = wt.path("applications/ids").request().get(String.class);

	assertThat(response, containsString("{\"applicationIds\":["));

	JsonObject result = Json.parse(response).asObject();
	assertThat(result, notNullValue());

	assertThat(result.names(), hasSize(1));
	assertThat(result.names().get(0), is("applicationIds"));

	JsonArray jsonApps = result.get("applicationIds").asArray();
	assertThat(jsonApps, notNullValue());
	assertThat(jsonApps.size(), is(4));

	assertThat(jsonApps.get(0).asObject(), matchesAppId(id1));
	assertThat(jsonApps.get(1).asObject(), matchesAppId(id2));
	assertThat(jsonApps.get(2).asObject(), matchesAppId(id3));
	assertThat(jsonApps.get(3).asObject(), matchesAppId(id4));

	verify(coreService);
	}

	/**
	* Tests a GET of an applicationId entry with the given numeric id.
	*/
	@Test
	public void getAppIdByShortId() {
	expect(coreService.getAppId((short) 1)).andReturn(id1);
	replay(coreService);

	WebTarget wt = target();
	String response = wt.path("applications/ids/entry")
	.queryParam("id", 1).request().get(String.class);

	JsonObject result = Json.parse(response).asObject();
	assertThat(result, notNullValue());

	assertThat(result, matchesAppId(id1));

	verify(coreService);
	}

	/**
	* Tests a GET of an applicationId entry with the given application name.
	*/
	@Test
	public void getAppIdByName() {
	expect(coreService.getAppId("app2")).andReturn(id2);
	replay(coreService);

	WebTarget wt = target();
	String response = wt.path("applications/ids/entry")
	.queryParam("name", "app2").request().get(String.class);

	JsonObject result = Json.parse(response).asObject();
	assertThat(result, notNullValue());

	assertThat(result, matchesAppId(id2));

	verify(coreService);
	}

	/**
	* Tests a GET of an applicationId without specifying any parameters.
	*/
	@Test
	public void getAppWithNoParam() {
	WebTarget wt = target();

	try {
	wt.path("applications/ids/entry").request().get();
	} catch (NotFoundException ex) {
	Assert.assertThat(ex.getMessage(),
	containsString("HTTP 404 Not Found"));
	}
	}
	}