Skip to content

Commit

Permalink
Add tests to increase cov to 59%
Browse files Browse the repository at this point in the history
  • Loading branch information
@ekigamba
ekigamba committed Jun 13, 2019
1 parent cb72d0e commit fcd8aa4
Show file tree
Hide file tree
Showing 8 changed files with 343 additions and 21 deletions.
2 changes: 1 addition & 1 deletion p2p-sync/build.gradle
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@ apply plugin: 'com.github.kt3k.coveralls'


jacoco {
toolVersion = "0.8.0"
toolVersion = "0.8.2"
}

android {
Expand Down
3 changes: 2 additions & 1 deletion p2p-sync/src/main/java/org/smartregister/p2p/presenter/P2PSenderPresenter.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down
2 changes: 1 addition & 1 deletion p2p-sync/src/main/java/org/smartregister/p2p/sync/handler/SyncSenderHandler.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand Down
70 changes: 70 additions & 0 deletions p2p-sync/src/test/java/org/smartregister/p2p/activity/P2pModeSelectActivityTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand All @@ -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;
Expand All @@ -41,6 +48,9 @@
public class P2pModeSelectActivityTest {

private P2pModeSelectActivity activity;

private P2pModeSelectContract.SenderPresenter senderPresenter;
private P2pModeSelectContract.ReceiverPresenter receiverPresenter;

@Rule
public MockitoRule mockitoRule = MockitoJUnit.rule();
Expand All @@ -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
Expand Down Expand Up @@ -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);
}*/
}
147 changes: 145 additions & 2 deletions p2p-sync/src/test/java/org/smartregister/p2p/presenter/P2PSenderPresenterTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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<String, Long>())
.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";
Expand Down Expand Up @@ -927,8 +964,6 @@ public void errorOccurredSyncShouldCallResetStateAndShowSyncCompleteFragmentWith
.when(syncSenderHandler)
.getTransferProgress();



ReflectionHelpers.setField(p2PSenderPresenter, "syncSenderHandler", syncSenderHandler);

p2PSenderPresenter.errorOccurredSync(new Exception("some error"));
Expand Down Expand Up @@ -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));
}
}
39 changes: 39 additions & 0 deletions p2p-sync/src/test/java/org/smartregister/p2p/shadows/ShadowPayload.java
View file
Original file line number Diff line number Diff line change
@@ -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 - [email protected] 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;
}

}
30 changes: 30 additions & 0 deletions p2p-sync/src/test/java/org/smartregister/p2p/sync/handler/SyncReceiverHandlerTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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<Long, SyncPackageManifest> 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";
Expand Down
Loading

0 comments on commit fcd8aa4

Please sign in to comment.