From fcd8aa4c044741f041c6bed725d79cb439d7034d Mon Sep 17 00:00:00 2001 From: Ephraim Kigamba Date: Thu, 13 Jun 2019 18:47:52 +0300 Subject: [PATCH] Add tests to increase cov to 59% --- p2p-sync/build.gradle | 2 +- .../p2p/presenter/P2PSenderPresenter.java | 3 +- .../p2p/sync/handler/SyncSenderHandler.java | 2 +- .../activity/P2pModeSelectActivityTest.java | 70 +++++++++ .../p2p/presenter/P2PSenderPresenterTest.java | 147 +++++++++++++++++- .../p2p/shadows/ShadowPayload.java | 39 +++++ .../sync/handler/SyncReceiverHandlerTest.java | 30 ++++ .../sync/handler/SyncSenderHandlerTest.java | 71 +++++++-- 8 files changed, 343 insertions(+), 21 deletions(-) create mode 100644 p2p-sync/src/test/java/org/smartregister/p2p/shadows/ShadowPayload.java diff --git a/p2p-sync/build.gradle b/p2p-sync/build.gradle index cd6ab0a..da7dc8c 100644 --- a/p2p-sync/build.gradle +++ b/p2p-sync/build.gradle @@ -4,7 +4,7 @@ apply plugin: 'com.github.kt3k.coveralls' jacoco { - toolVersion = "0.8.0" + toolVersion = "0.8.2" } android { diff --git a/p2p-sync/src/main/java/org/smartregister/p2p/presenter/P2PSenderPresenter.java b/p2p-sync/src/main/java/org/smartregister/p2p/presenter/P2PSenderPresenter.java index 5a76067..3dc9cf0 100644 --- a/p2p-sync/src/main/java/org/smartregister/p2p/presenter/P2PSenderPresenter.java +++ b/p2p-sync/src/main/java/org/smartregister/p2p/presenter/P2PSenderPresenter.java @@ -140,7 +140,8 @@ public void onCancelClicked(DialogInterface dialogInterface) { startConnectionTimeout(new OnConnectionTimeout() { @Override public void connectionTimeout(long duration, @Nullable Exception e) { - if (e == null) { if (interactor.isDiscovering()) { + if (e == null) { + if (interactor.isDiscovering()) { interactor.stopDiscovering(); view.removeDiscoveringProgressDialog(); view.enableSendReceiveButtons(true); diff --git a/p2p-sync/src/main/java/org/smartregister/p2p/sync/handler/SyncSenderHandler.java b/p2p-sync/src/main/java/org/smartregister/p2p/sync/handler/SyncSenderHandler.java index 496f7e8..ba3a34f 100644 --- a/p2p-sync/src/main/java/org/smartregister/p2p/sync/handler/SyncSenderHandler.java +++ b/p2p-sync/src/main/java/org/smartregister/p2p/sync/handler/SyncSenderHandler.java @@ -75,7 +75,7 @@ public SyncSenderHandler(@NonNull P2pModeSelectContract.SenderPresenter presente private void generateRecordsToSend() { for (DataType dataType : dataSyncOrder) { - remainingLastRecordIds.put(dataType.getName(), 0l); + remainingLastRecordIds.put(dataType.getName(), 0L); } if (receivedHistory != null && receivedHistory.size() > 0) { diff --git a/p2p-sync/src/test/java/org/smartregister/p2p/activity/P2pModeSelectActivityTest.java b/p2p-sync/src/test/java/org/smartregister/p2p/activity/P2pModeSelectActivityTest.java index 38a01b4..0400dd6 100644 --- a/p2p-sync/src/test/java/org/smartregister/p2p/activity/P2pModeSelectActivityTest.java +++ b/p2p-sync/src/test/java/org/smartregister/p2p/activity/P2pModeSelectActivityTest.java @@ -2,6 +2,7 @@ import android.Manifest; import android.support.annotation.NonNull; +import android.support.v4.app.DialogFragment; import org.junit.Before; import org.junit.Rule; @@ -19,11 +20,17 @@ import org.smartregister.p2p.P2PLibrary; import org.smartregister.p2p.TestApplication; import org.smartregister.p2p.authorizer.P2PAuthorizationService; +import org.smartregister.p2p.contract.P2pModeSelectContract; +import org.smartregister.p2p.dialog.ConnectingDialog; +import org.smartregister.p2p.dialog.SkipQRScanDialog; +import org.smartregister.p2p.dialog.StartDiscoveringModeProgressDialog; +import org.smartregister.p2p.dialog.StartReceiveModeProgressDialog; import org.smartregister.p2p.handler.OnActivityRequestPermissionHandler; import org.smartregister.p2p.model.DataType; import org.smartregister.p2p.model.dao.ReceiverTransferDao; import org.smartregister.p2p.model.dao.SenderTransferDao; import org.smartregister.p2p.shadows.ShadowAppDatabase; +import org.smartregister.p2p.util.Constants; import java.util.ArrayList; import java.util.List; @@ -41,6 +48,9 @@ public class P2pModeSelectActivityTest { private P2pModeSelectActivity activity; + + private P2pModeSelectContract.SenderPresenter senderPresenter; + private P2pModeSelectContract.ReceiverPresenter receiverPresenter; @Rule public MockitoRule mockitoRule = MockitoJUnit.rule(); @@ -57,8 +67,16 @@ public void setUp() throws Exception { activity = Robolectric.buildActivity(P2pModeSelectActivity.class) .create() .start() + .postCreate(null) .resume() .get(); + + senderPresenter = Mockito.spy((P2pModeSelectContract.SenderPresenter) + ReflectionHelpers.getField(activity, "senderBasePresenter")); + ReflectionHelpers.setField(activity, "senderBasePresenter", senderPresenter); + receiverPresenter = Mockito.spy((P2pModeSelectContract.ReceiverPresenter) + ReflectionHelpers.getField(activity, "receiverBasePresenter")); + ReflectionHelpers.setField(activity, "receiverBasePresenter", receiverPresenter); } @Test @@ -230,4 +248,56 @@ public void getUnAuthorizedPermissionsShouldReturnStoragePermissionsExclusiveWhe assertFalse(hasStoragePermissions); } + + @Test + public void onStopShouldCallPresenterOnStopMethods() { + activity.onStop(); + + Mockito.verify(senderPresenter, Mockito.times(1)) + .onStop(); + Mockito.verify(receiverPresenter, Mockito.times(1)) + .onStop(); + } + + /* @Test + public void showSkipQRScanDialog() { + activity.showSkipQRScanDialog("peer device status" + , "SAMSUNG" + , Mockito.mock(SkipQRScanDialog.SkipDialogCallback.class)); + + DialogFragment dialogFragment = (DialogFragment) activity.getSupportFragmentManager() + .findFragmentByTag(Constants.Dialog.SKIP_QR_SCAN); + + assertTrue(dialogFragment instanceof SkipQRScanDialog); + } + + @Test + public void showConnectingDialog() { + activity.showConnectingDialog(Mockito.mock(P2pModeSelectContract.View.DialogCancelCallback.class)); + + DialogFragment dialogFragment = (DialogFragment) activity.getSupportFragmentManager() + .findFragmentByTag(Constants.Dialog.CONNECTING); + + assertTrue(dialogFragment instanceof ConnectingDialog); + } + + @Test + public void showDiscoveringProgressDialog() { + activity.showDiscoveringProgressDialog(Mockito.mock(P2pModeSelectContract.View.DialogCancelCallback.class)); + + DialogFragment dialogFragment = (DialogFragment) activity.getSupportFragmentManager() + .findFragmentByTag(Constants.Dialog.START_SEND_MODE_PROGRESS); + + assertTrue(dialogFragment instanceof StartDiscoveringModeProgressDialog); + } + + @Test + public void showAdvertisingProgressDialog() { + activity.showAdvertisingProgressDialog(Mockito.mock(P2pModeSelectContract.View.DialogCancelCallback.class)); + + DialogFragment dialogFragment = (DialogFragment) activity.getSupportFragmentManager() + .findFragmentByTag(Constants.Dialog.START_RECEIVE_MODE_PROGRESS); + + assertTrue(dialogFragment instanceof StartReceiveModeProgressDialog); + }*/ } \ No newline at end of file diff --git a/p2p-sync/src/test/java/org/smartregister/p2p/presenter/P2PSenderPresenterTest.java b/p2p-sync/src/test/java/org/smartregister/p2p/presenter/P2PSenderPresenterTest.java index 4c39366..743a25f 100644 --- a/p2p-sync/src/test/java/org/smartregister/p2p/presenter/P2PSenderPresenterTest.java +++ b/p2p-sync/src/test/java/org/smartregister/p2p/presenter/P2PSenderPresenterTest.java @@ -33,9 +33,11 @@ import org.smartregister.p2p.authorizer.P2PAuthorizationService; import org.smartregister.p2p.callback.OnResultCallback; import org.smartregister.p2p.contract.P2pModeSelectContract; +import org.smartregister.p2p.dialog.SkipQRScanDialog; import org.smartregister.p2p.fragment.ErrorFragment; import org.smartregister.p2p.fragment.QRCodeScanningFragment; import org.smartregister.p2p.fragment.SyncCompleteTransferFragment; +import org.smartregister.p2p.fragment.SyncProgressFragment; import org.smartregister.p2p.handler.OnActivityRequestPermissionHandler; import org.smartregister.p2p.model.DataType; import org.smartregister.p2p.model.P2pReceivedHistory; @@ -560,6 +562,41 @@ public void onConnectionBrokenShouldResetStateAndShowSyncCompleteFragmentWithFai assertNull(ReflectionHelpers.getField(p2PSenderPresenter, "currentReceiver")); } + @Test + public void onConnectionBrokenShouldCallDisconnectFromEndpointAndShowErrorFragmentWhenConnectionLevelIsNotSentReceivedHistory() { + String endpointId = "id"; + String deviceName = "samsung SMT734"; + DiscoveredEndpointInfo discoveredEndpointInfo = Mockito.mock(DiscoveredEndpointInfo.class); + + Mockito.doReturn(deviceName) + .when(discoveredEndpointInfo) + .getEndpointName(); + + DiscoveredDevice discoveredDevice = new DiscoveredDevice(endpointId, discoveredEndpointInfo); + + ReflectionHelpers.setField(p2PSenderPresenter, "currentReceiver", discoveredDevice); + assertNotNull(ReflectionHelpers.getField(p2PSenderPresenter, "currentReceiver")); + + // Add the syncSenderHandler + SyncSenderHandler syncSenderHandler = Mockito.mock(SyncSenderHandler.class); + Mockito.doReturn(new HashMap()) + .when(syncSenderHandler) + .getTransferProgress(); + ReflectionHelpers.setField(p2PSenderPresenter, "syncSenderHandler", syncSenderHandler); + ReflectionHelpers.setField(p2PSenderPresenter, "connectionLevel", ConnectionLevel.AUTHORIZED); + + p2PSenderPresenter.onConnectionBroken(endpointId); + + Mockito.verify(view, Mockito.times(1)) + .showErrorFragment(Mockito.anyString() + , Mockito.anyString() + , Mockito.any(ErrorFragment.OnOkClickCallback.class)); + Mockito.verify(interactor, Mockito.times(1)) + .disconnectFromEndpoint(Mockito.eq(endpointId)); + + assertNull(ReflectionHelpers.getField(p2PSenderPresenter, "currentReceiver")); + } + @Test public void onDisconnectedShouldResetStateAndStartDiscoveringMode() { String endpointId = "id"; @@ -927,8 +964,6 @@ public void errorOccurredSyncShouldCallResetStateAndShowSyncCompleteFragmentWith .when(syncSenderHandler) .getTransferProgress(); - - ReflectionHelpers.setField(p2PSenderPresenter, "syncSenderHandler", syncSenderHandler); p2PSenderPresenter.errorOccurredSync(new Exception("some error")); @@ -1042,4 +1077,112 @@ public void onPayloadReceivedShouldCallProcessPayloadWhenConnectionLevelIsReceip Mockito.verify(p2PSenderPresenter, Mockito.times(1)) .processPayload(ArgumentMatchers.eq(endpointId), ArgumentMatchers.eq(payload)); } + + @Test + public void onPayloadReceivedShouldCallStartTransferWhenConnectionLevelIsAuthorizedAndConnectionCommandIsStartTransfer() { + ReflectionHelpers.setField(p2PSenderPresenter, "connectionLevel", ConnectionLevel.AUTHORIZED); + String endpointId = "endpointid"; + Payload payload = Mockito.mock(Payload.class); + + Mockito.doReturn(Payload.Type.BYTES) + .when(payload) + .getType(); + Mockito.doReturn(Constants.Connection.START_TRANSFER.getBytes()) + .when(payload) + .asBytes(); + + p2PSenderPresenter.onPayloadReceived(endpointId, payload); + + Mockito.verify(p2PSenderPresenter, Mockito.times(1)) + .startTransfer(); + Mockito.verify(view, Mockito.times(1)) + .showSyncProgressFragment(Mockito.anyString(), Mockito.any(SyncProgressFragment.SyncProgressDialogCallback.class)); + } + + @Test + public void onPayloadReceivedShouldShowSkipQRScanDialogWhenConnectionLevelIsConnectBeforeAuthenticateAndConnectionCommandIsSkipQRCodeScan() { + ReflectionHelpers.setField(p2PSenderPresenter, "connectionLevel", ConnectionLevel.CONNECT_BEFORE_AUTHENTICATE); + String endpointId = "endpointid"; + String deviceName = "john travolter"; + DiscoveredDevice discoveredDevice = Mockito.mock(DiscoveredDevice.class); + p2PSenderPresenter.setCurrentDevice(discoveredDevice); + + Mockito.doReturn(endpointId) + .when(discoveredDevice) + .getEndpointId(); + + Mockito.doReturn(deviceName) + .when(discoveredDevice) + .getEndpointName(); + Payload payload = Mockito.mock(Payload.class); + + Mockito.doReturn(Payload.Type.BYTES) + .when(payload) + .getType(); + Mockito.doReturn(Constants.Connection.SKIP_QR_CODE_SCAN.getBytes()) + .when(payload) + .asBytes(); + + p2PSenderPresenter.onPayloadReceived(endpointId, payload); + + Mockito.verify(view, Mockito.times(1)) + .showSkipQRScanDialog(Mockito.eq(Constants.PeerStatus.SENDER) + , Mockito.eq(deviceName) + , Mockito.any(SkipQRScanDialog.SkipDialogCallback.class)); + Mockito.verify(view, Mockito.times(1)) + .removeQRCodeScanningFragment(); + } + + @Test + public void onPayloadReceivedShouldCallOnAuthenticationSuccessfulWhenConnectionLevelIsConnectBeforeAuthenticateAndConnectionCommandIsConnectionAccept() { + ReflectionHelpers.setField(p2PSenderPresenter, "connectionLevel", ConnectionLevel.CONNECT_BEFORE_AUTHENTICATE); + String endpointId = "endpointid"; + Payload payload = Mockito.mock(Payload.class); + + Mockito.doReturn(Payload.Type.BYTES) + .when(payload) + .getType(); + Mockito.doReturn(Constants.Connection.CONNECTION_ACCEPT.getBytes()) + .when(payload) + .asBytes(); + + p2PSenderPresenter.onPayloadReceived(endpointId, payload); + + Mockito.verify(view, Mockito.times(1)) + .removeConnectingDialog(); + Mockito.verify(p2PSenderPresenter, Mockito.times(1)) + .onAuthenticationSuccessful(); + } + + + @Test + public void startDiscoveringShouldCallStopDiscoveringWhenConnectionTimeoutIsCalled() { + + Mockito.doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Mockito.doReturn(true) + .when(interactor) + .isDiscovering(); + + P2pModeSelectContract.BasePresenter.OnConnectionTimeout onConnectionTimeout = invocation.getArgument(0); + onConnectionTimeout.connectionTimeout(Constants.CONNECTION_TIMEOUT_SECONDS, null); + + return null; + } + }) + .when(p2PSenderPresenter) + .startConnectionTimeout(Mockito.any(P2pModeSelectContract.BasePresenter.OnConnectionTimeout.class)); + + p2PSenderPresenter.startDiscoveringMode(); + + Mockito.verify(interactor, Mockito.times(1)) + .stopDiscovering(); + Mockito.verify(p2PSenderPresenter, Mockito.times(1)) + .keepScreenOn(Mockito.eq(false)); + Mockito.verify(view, Mockito.times(1)) + .showErrorFragment(Mockito.eq(view.getString(R.string.no_nearby_devices_found)) + , Mockito.anyString() + , Mockito.any(ErrorFragment.OnOkClickCallback.class)); + } } \ No newline at end of file diff --git a/p2p-sync/src/test/java/org/smartregister/p2p/shadows/ShadowPayload.java b/p2p-sync/src/test/java/org/smartregister/p2p/shadows/ShadowPayload.java new file mode 100644 index 0000000..bedfecc --- /dev/null +++ b/p2p-sync/src/test/java/org/smartregister/p2p/shadows/ShadowPayload.java @@ -0,0 +1,39 @@ +package org.smartregister.p2p.shadows; + +import android.os.ParcelFileDescriptor; +import android.support.annotation.NonNull; + +import com.google.android.gms.nearby.connection.Payload; + +import org.mockito.Mockito; +import org.robolectric.annotation.Implementation; +import org.robolectric.annotation.Implements; + +import java.io.FileNotFoundException; + +/** + * Created by Ephraim Kigamba - ekigamba@ona.io on 2019-06-13 + */ + +@Implements(Payload.class) +public class ShadowPayload { + + private static Payload toReturn = Mockito.mock(Payload.class); + + public static void setPayloadToReturn(@NonNull Payload payloadToReturn) { + toReturn = payloadToReturn; + } + + @Implementation + @NonNull + public static Payload fromFile(@NonNull java.io.File var0) throws FileNotFoundException { + return toReturn; + } + + @Implementation + @NonNull + public static Payload fromStream(@NonNull ParcelFileDescriptor var0) { + return toReturn; + } + +} diff --git a/p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncReceiverHandlerTest.java b/p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncReceiverHandlerTest.java index 17cb1ef..318df9a 100644 --- a/p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncReceiverHandlerTest.java +++ b/p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncReceiverHandlerTest.java @@ -344,6 +344,36 @@ public void onPayloadTransferUpdateShouldCallFinishProcessDataWhenTransferStatus .finishProcessingData(Mockito.eq(endpointId), Mockito.eq(payloadId)); } + @Test + public void onPayloadTransferUpdateShouldCallUpdateProgressFragmentWhenTransferStatusUpdateIsInProgress() { + String endpointId = "endpoint-id"; + long payloadId = 923l; + int total = 20; + int sent = 5; + int expectedProgress = (5 *100)/20; + PayloadTransferUpdate update = Mockito.mock(PayloadTransferUpdate.class); + + Mockito.doReturn(PayloadTransferUpdate.Status.IN_PROGRESS) + .when(update) + .getStatus(); + Mockito.doReturn((long) sent) + .when(update) + .getBytesTransferred(); + Mockito.doReturn(payloadId) + .when(update) + .getPayloadId(); + + SyncPackageManifest syncPackageManifest = new SyncPackageManifest(payloadId, ".json", event, 45); + syncPackageManifest.setPayloadSize(total); + HashMap awaitingPackageManifests = ReflectionHelpers.getField(syncReceiverHandler, "awaitingPayloadManifests"); + awaitingPackageManifests.put(payloadId, syncPackageManifest); + + syncReceiverHandler.onPayloadTransferUpdate(endpointId, update); + + Mockito.verify(view, Mockito.times(1)) + .updateProgressFragment(Mockito.eq(expectedProgress)); + } + @Test public void finishProcessingDataShouldCallFinishProcessingNonMediaDataWhenDataTypeIsNonMedia() { String endpointId = "endpoint-id"; diff --git a/p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncSenderHandlerTest.java b/p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncSenderHandlerTest.java index db8c96a..e70c0df 100644 --- a/p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncSenderHandlerTest.java +++ b/p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncSenderHandlerTest.java @@ -2,7 +2,9 @@ import com.google.android.gms.nearby.connection.Payload; import com.google.android.gms.nearby.connection.PayloadTransferUpdate; +import com.google.gson.JsonArray; +import org.json.JSONArray; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -25,11 +27,15 @@ import org.smartregister.p2p.model.dao.ReceiverTransferDao; import org.smartregister.p2p.model.dao.SenderTransferDao; import org.smartregister.p2p.shadows.ShadowAppDatabase; +import org.smartregister.p2p.shadows.ShadowPayload; import org.smartregister.p2p.shadows.ShadowSyncSenderHandler; import org.smartregister.p2p.shadows.ShadowTasker; +import org.smartregister.p2p.sync.data.JsonData; +import org.smartregister.p2p.sync.data.MultiMediaData; import org.smartregister.p2p.sync.data.SyncPackageManifest; import org.smartregister.p2p.util.Constants; +import java.io.File; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; @@ -48,7 +54,7 @@ */ @RunWith(RobolectricTestRunner.class) -@Config(shadows = {ShadowAppDatabase.class, ShadowTasker.class, ShadowSyncSenderHandler.class}) +@Config(shadows = {ShadowAppDatabase.class, ShadowTasker.class, ShadowSyncSenderHandler.class, ShadowPayload.class}) public class SyncSenderHandlerTest { @Rule @@ -389,29 +395,62 @@ public void onPayloadTransferUpdateShouldReportFatalErrorToPresenterWhenPayloadS .errorOccurredSync(Mockito.any(Exception.class)); } - //@Test - // This test has been ignored for now - /*public void sendNextPayloadShouldCallPresenterSendPayloadWhenThereIsAwaitingPayload() throws InterruptedException { - syncSenderHandler.sendNextPayload(); + @Test + public void sendMultimediaDataManifestShouldCallPresenterSendManifest() { + DataType dataType = new DataType("pic", DataType.Type.MEDIA, 5); + + File mockFile = Mockito.mock(File.class); + MultiMediaData multiMediaData = new MultiMediaData(mockFile, 8923); + HashMap details = new HashMap<>(); + details.put("fileRecordId", "928"); - Robolectric.flushBackgroundThreadScheduler(); + multiMediaData.setMediaDetails(details); - Mockito.verify(senderPresenter, Mockito.times(0)) - .sendPayload(Mockito.any(Payload.class)); + HashMap remainingLastRecords = ReflectionHelpers.getField(syncSenderHandler, "remainingLastRecordIds"); + remainingLastRecords.put("pic", 0L); Payload payload = Mockito.mock(Payload.class); - ReflectionHelpers.setField(syncSenderHandler, "awaitingPayload", payload); + Mockito.doReturn(898L) + .when(payload) + .getId(); - syncSenderHandler.sendNextPayload(); + ShadowPayload.setPayloadToReturn(payload); - //Robolectric.flushBackgroundThreadScheduler(); - ShadowApplication.runBackgroundTasks(); - assertFalse(Robolectric.getBackgroundThreadScheduler().areAnyRunnable()); - Thread.sleep(100); + Mockito.doReturn(multiMediaData) + .when(senderTransferDao) + .getMultiMediaData(Mockito.eq(dataType), Mockito.anyLong()); + Mockito.doReturn(true) + .when(mockFile) + .exists(); + Mockito.doReturn("sample.jpg") + .when(mockFile) + .getName(); + syncSenderHandler.sendMultimediaDataManifest(dataType); Mockito.verify(senderPresenter, Mockito.times(1)) - .sendPayload(ArgumentMatchers.eq(payload)); - }*/ + .sendManifest(Mockito.any(SyncPackageManifest.class)); + } + + @Test + public void sendJsonDataManifestShouldCallPresenterSendManifest() { + DataType dataType = new DataType("Person", DataType.Type.NON_MEDIA, 5); + JsonData multiMediaData = new JsonData(new JSONArray(), 8923); + + Payload payload = Mockito.mock(Payload.class); + Mockito.doReturn(898L) + .when(payload) + .getId(); + + ShadowPayload.setPayloadToReturn(payload); + + Mockito.doReturn(multiMediaData) + .when(senderTransferDao) + .getJsonData(Mockito.eq(dataType), Mockito.anyLong(), Mockito.anyInt()); + + syncSenderHandler.sendJsonDataManifest(dataType); + Mockito.verify(senderPresenter, Mockito.times(1)) + .sendManifest(Mockito.any(SyncPackageManifest.class)); + } private P2pReceivedHistory createReceivedHistory(String entityType, long lastRecordId, String sendingDeviceId) { P2pReceivedHistory history = new P2pReceivedHistory();