Test cases for DeviceAgentService: updateDevice.

components/device-mgt/org.wso2.carbon.device.mgt.api/src/test/java/org/wso2/carbon/device/mgt/jaxrs/service/impl/DeviceAgentServiceTest.java

@@ -13,8 +13,12 @@ import org.testng.annotations.BeforeClass;
 import org.testng.annotations.ObjectFactory;
 import org.testng.annotations.Test;
 import org.wso2.carbon.device.mgt.common.Device;
+import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
 import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
+import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationException;
+import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationService;
+import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
 import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
 import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
 import org.wso2.carbon.device.mgt.jaxrs.service.api.DeviceAgentService;
@@ -31,12 +35,14 @@ import static org.mockito.MockitoAnnotations.initMocks;
  */
 @PowerMockIgnore("javax.ws.rs.*")
 @SuppressStaticInitializationFor({"org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils"})
-@PrepareForTest({DeviceMgtAPIUtils.class, DeviceManagementProviderService.class})
+@PrepareForTest({DeviceMgtAPIUtils.class, DeviceManagementProviderService.class,
+        DeviceAccessAuthorizationService.class})
 public class DeviceAgentServiceTest {
 
     private static final Log log = LogFactory.getLog(DeviceTypeManagementAdminService.class);
     private DeviceManagementProviderService deviceManagementProviderService;
     private DeviceAgentService deviceAgentService;
+    private DeviceAccessAuthorizationService deviceAccessAuthorizationService;
     private static final String TEST_DEVICE_TYPE = "TEST-DEVICE-TYPE";
     private static final String TEST_DEVICE_IDENTIFIER = "11222334455";
     private static final String AUTHENTICATED_USER = "admin";
@@ -54,6 +60,8 @@ public class DeviceAgentServiceTest {
         this.deviceManagementProviderService = Mockito
                 .mock(DeviceManagementProviderServiceImpl.class, Mockito.RETURNS_MOCKS);
         this.deviceAgentService = new DeviceAgentServiceImpl();
+        this.deviceAccessAuthorizationService = Mockito.mock(DeviceAccessAuthorizationServiceImpl.class,
+                Mockito.RETURNS_MOCKS);
         demoDevice = DeviceMgtAPITestHelper.generateDummyDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER);
     }
 
@@ -182,4 +190,151 @@ public class DeviceAgentServiceTest {
         Mockito.reset(this.deviceManagementProviderService);
     }
 
+    @Test(description = "Test device update scenario with device management exception.")
+    public void testUpdateDeviceDMException() throws DeviceManagementException {
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
+                .toReturn(this.deviceManagementProviderService);
+        Mockito.when(this.deviceManagementProviderService.getDevice(Mockito.any())).thenThrow(new
+                DeviceManagementException());
+        Device testDevice = DeviceMgtAPITestHelper.generateDummyDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER);
+        Response response = deviceAgentService.updateDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER, testDevice);
+
+        Assert.assertNotNull(response, "Response should not be null");
+        Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
+                "The response status should be 500");
+        Mockito.reset(this.deviceManagementProviderService);
+    }
+
+    @Test(description = "Test update device scenario when the device is null.")
+    public void testUpdateDeviceWithNoDevice() {
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
+                .toReturn(this.deviceManagementProviderService);
+        Response response = deviceAgentService.updateDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER, null);
+
+        Assert.assertNotNull(response, "Response should not be null");
+        Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode(),
+                "The response status should be 400");
+    }
+
+    @Test(description = "Test the update device scenario when there is no enrolled device.")
+    public void testUpdatingNonExistingDevice() throws DeviceManagementException {
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
+                .toReturn(this.deviceManagementProviderService);
+        Mockito.when(this.deviceManagementProviderService.getDevice(Mockito.any())).thenReturn(null);
+        Device testDevice = DeviceMgtAPITestHelper.generateDummyDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER);
+        Response response = deviceAgentService.updateDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER, testDevice);
+
+        Assert.assertNotNull(response, "Response should not be null");
+        Assert.assertEquals(response.getStatus(), Response.Status.NOT_FOUND.getStatusCode(),
+                "The response status should be 404");
+        Mockito.reset(this.deviceManagementProviderService);
+    }
+
+    @Test(description = "Test update device with device access authorization exception.")
+    public void testEnrollDeviceWithDeviceAccessAuthException() throws DeviceManagementException,
+            DeviceAccessAuthorizationException {
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
+                .toReturn(this.deviceManagementProviderService);
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class,
+                "getDeviceAccessAuthorizationService")).toReturn(this.deviceAccessAuthorizationService);
+        Device testDevice = DeviceMgtAPITestHelper.generateDummyDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER);
+
+        Mockito.when(this.deviceManagementProviderService.getDevice(Mockito.any())).thenReturn(testDevice);
+        Mockito.when(this.deviceAccessAuthorizationService.isUserAuthorized(Mockito.any(DeviceIdentifier.class)))
+                .thenThrow(new DeviceAccessAuthorizationException());
+        Response response = deviceAgentService.updateDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER, testDevice);
+        Assert.assertNotNull(response, "Response should not be null");
+        Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
+                "The response status should be 500");
+        Mockito.reset(this.deviceManagementProviderService);
+        Mockito.reset(this.deviceAccessAuthorizationService);
+    }
+
+    @Test(description = "Test update device when user does not have device access permission.")
+    public void testUpdateDeviceWithNoDeviceAccessPermission() throws DeviceManagementException,
+            DeviceAccessAuthorizationException {
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
+                .toReturn(this.deviceManagementProviderService);
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class,
+                "getDeviceAccessAuthorizationService")).toReturn(this.deviceAccessAuthorizationService);
+        Device testDevice = DeviceMgtAPITestHelper.generateDummyDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER);
+
+        Mockito.when(this.deviceManagementProviderService.getDevice(Mockito.any())).thenReturn(testDevice);
+        Mockito.when(this.deviceAccessAuthorizationService.isUserAuthorized(Mockito.any(DeviceIdentifier.class)))
+                .thenReturn(false);
+        Response response = deviceAgentService.updateDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER, testDevice);
+        Assert.assertNotNull(response, "Response should not be null");
+        Assert.assertEquals(response.getStatus(), Response.Status.UNAUTHORIZED.getStatusCode(),
+                "The response status should be 401");
+        Mockito.reset(this.deviceManagementProviderService);
+        Mockito.reset(this.deviceAccessAuthorizationService);
+    }
+
+    @Test(description = "Test update device when device modification is unsuccessful.")
+    public void testUpdateDeviceNOTModify() throws DeviceManagementException, DeviceAccessAuthorizationException {
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
+                .toReturn(this.deviceManagementProviderService);
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class,
+                "getDeviceAccessAuthorizationService")).toReturn(this.deviceAccessAuthorizationService);
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class,
+                "getAuthenticatedUser")).toReturn(AUTHENTICATED_USER);
+
+        Device testDevice = DeviceMgtAPITestHelper.generateDummyDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER);
+
+        Mockito.when(this.deviceManagementProviderService.getDevice(Mockito.any())).thenReturn(testDevice);
+        Mockito.when(this.deviceAccessAuthorizationService.isUserAuthorized(Mockito.any(DeviceIdentifier.class)))
+                .thenReturn(true);
+        Mockito.when(this.deviceManagementProviderService.modifyEnrollment(Mockito.any())).thenReturn(false);
+        Response response = deviceAgentService.updateDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER, testDevice);
+        Assert.assertNotNull(response, "Response should not be null");
+        Assert.assertEquals(response.getStatus(), Response.Status.NOT_MODIFIED.getStatusCode(),
+                "The response status should be 304");
+        Mockito.reset(this.deviceManagementProviderService);
+        Mockito.reset(this.deviceAccessAuthorizationService);
+    }
+
+    @Test(description = "Test updating device when modify enrollment throws exception")
+    public void testUpdateDeviceWithModifyEnrollmentFailure() throws DeviceManagementException, DeviceAccessAuthorizationException {
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
+                .toReturn(this.deviceManagementProviderService);
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class,
+                "getDeviceAccessAuthorizationService")).toReturn(this.deviceAccessAuthorizationService);
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class,
+                "getAuthenticatedUser")).toReturn(AUTHENTICATED_USER);
+
+        Device testDevice = DeviceMgtAPITestHelper.generateDummyDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER);
+
+        Mockito.when(this.deviceManagementProviderService.getDevice(Mockito.any())).thenReturn(testDevice);
+        Mockito.when(this.deviceAccessAuthorizationService.isUserAuthorized(Mockito.any(DeviceIdentifier.class)))
+                .thenReturn(true);
+        Mockito.when(this.deviceManagementProviderService.modifyEnrollment(Mockito.any())).thenThrow(new DeviceManagementException());
+        Response response = deviceAgentService.updateDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER, testDevice);
+        Assert.assertNotNull(response, "Response should not be null");
+        Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
+                "The response status should be 500");
+        Mockito.reset(this.deviceManagementProviderService);
+        Mockito.reset(this.deviceAccessAuthorizationService);
+    }
+    @Test(description = "Test updating device success scenario.")
+    public void testUpdateDeviceSuccess() throws DeviceManagementException, DeviceAccessAuthorizationException {
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
+                .toReturn(this.deviceManagementProviderService);
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class,
+                "getDeviceAccessAuthorizationService")).toReturn(this.deviceAccessAuthorizationService);
+        PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class,
+                "getAuthenticatedUser")).toReturn(AUTHENTICATED_USER);
+
+        Device testDevice = DeviceMgtAPITestHelper.generateDummyDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER);
+
+        Mockito.when(this.deviceManagementProviderService.getDevice(Mockito.any())).thenReturn(testDevice);
+        Mockito.when(this.deviceAccessAuthorizationService.isUserAuthorized(Mockito.any(DeviceIdentifier.class)))
+                .thenReturn(true);
+        Mockito.when(this.deviceManagementProviderService.modifyEnrollment(Mockito.any())).thenReturn((true));
+        Response response = deviceAgentService.updateDevice(TEST_DEVICE_TYPE, TEST_DEVICE_IDENTIFIER, testDevice);
+        Assert.assertNotNull(response, "Response should not be null");
+        Assert.assertEquals(response.getStatus(), Response.Status.ACCEPTED.getStatusCode(),
+                "The response status should be 202");
+        Mockito.reset(this.deviceManagementProviderService);
+        Mockito.reset(this.deviceAccessAuthorizationService);
+    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.api/src/test/java/org/wso2/carbon/device/mgt/jaxrs/service/impl/util/DeviceMgtAPITestHelper.java

@@ -19,6 +19,7 @@ package org.wso2.carbon.device.mgt.jaxrs.service.impl.util;
 
 import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
+import org.wso2.carbon.device.mgt.common.Feature;
 import org.wso2.carbon.device.mgt.common.device.details.DeviceInfo;
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
 import org.wso2.carbon.device.mgt.common.type.mgt.DeviceTypeMetaDefinition;
@@ -35,6 +36,7 @@ public class DeviceMgtAPITestHelper {
 
     private static final String DEVICE_TYPE_DESCRIPTION = "Dummy Description";
     public static final String DEVICE_TYPE = "TEST_DEVICE_TYPE";
+    public static final String DEVICE_NAME = "TEST_DEVICE";
     public static final String DEVICE_IDENTIFIER = "12345";
     public final static String OWNER = "admin";
 
@@ -87,6 +89,10 @@ public class DeviceMgtAPITestHelper {
         device.setDescription("Test Description");
         device.setDeviceIdentifier(identifier);
         device.setType(deviceType);
+        device.setDeviceInfo(generateDeviceInfo());
+        device.setName(DEVICE_NAME);
+        device.setFeatures(new ArrayList<>());
+        device.setProperties(new ArrayList<>());
         return device;
     }