Add some unit test and CommandSdFileWrite old firmware support.

app/build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'com.android.application'
 
 android {
     compileSdkVersion 27
-    buildToolsVersion '27.0.3'
+    buildToolsVersion '28.0.3'
     defaultConfig {
         minSdkVersion 21
         targetSdkVersion 27

aurorasdk/build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'com.android.library'
 
 android {
     compileSdkVersion 27
-    buildToolsVersion '27.0.3'
+    buildToolsVersion '28.0.3'
 
     defaultConfig {
         minSdkVersion 21
@@ -41,4 +41,6 @@ dependencies {
     implementation 'com.github.markrileybot.heatshrink:heatshrink-java:0.1.1'
     api 'no.nordicsemi.android:ble:1.2.0'
     testImplementation 'junit:junit:4.12'
+    testImplementation 'org.powermock:powermock-module-junit4:1.7.4'
+    testImplementation 'org.powermock:powermock-api-mockito2:1.7.4'
 }

aurorasdk/publish.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'maven-publish'
 apply plugin: 'com.jfrog.bintray'
 
-version '1.0.2'
+version '1.0.5'
 group 'com.iwinks'
 
 publishing {

aurorasdk/src/main/java/com/aurorasdk/Command.java

@@ -81,7 +81,8 @@ public void setError(int errorCode, String errorMessage) {
 
         this.errorCode = errorCode;
 
-        if (!errorMessage.isEmpty()){
+        if (errorMessage != null
+            && !errorMessage.isEmpty()){
 
             this.errorMessage = errorMessage;
 

aurorasdk/src/main/java/com/aurorasdk/CommandProcessor.java

@@ -22,7 +22,7 @@ public enum CommandState {
     private Queue<Command> commandQueue = new ConcurrentLinkedQueue<>();
     private Command currentCommand;
 
-    private final CommandResponseParser commandResponseParser = new CommandResponseParser();
+    private CommandResponseParser commandResponseParser = new CommandResponseParser();
 
     public interface CommandExecutor {
         void executeCommand(Command command);
@@ -50,6 +50,12 @@ public interface CommandInputWriter {
         reset();
     }
 
+    CommandProcessor(CommandExecutor commandExecutor, CommandInputWriter commandInputWriter, CommandResponseParser parser){
+
+        this(commandExecutor, commandInputWriter);
+        this.commandResponseParser = parser;
+    }
+
     void queueCommand(Command command){
 
         commandQueue.add(command);

aurorasdk/src/main/java/com/aurorasdk/CommandSdFileWrite.java

@@ -20,6 +20,7 @@ public class CommandSdFileWrite extends Command {
     private long crc;
     private boolean renameIfExisting;
     private ByteArrayOutputStream compressedInput;
+    private long osVersion = 30000;
 
     public CommandSdFileWrite(String destination, String input, boolean renameIfExisting) {
 
@@ -51,6 +52,11 @@ public CommandSdFileWrite(String destination, String input){
         this(destination, input, false);
     }
 
+    public CommandSdFileWrite(String destination, String input, boolean renameIfExisting, long osVersion){
+        this(destination, input, renameIfExisting);
+        this.osVersion = osVersion;
+    }
+
     @Override
     protected boolean shouldRetry() {
 
@@ -65,7 +71,7 @@ protected void retry() {
         setInput();
     }
 
-    private void setInput(){
+    protected void setInput(){
 
         try {
             setInput(compressedInput.toByteArray());
@@ -81,6 +87,11 @@ private void setInput(){
     @Override
     public String getCommandString() {
 
-        return "sd-file-write " + destination + " / " + (renameIfExisting ? "1" : "0") + " 1 1500 1 " + crc;
+        String commandString = "sd-file-write " + destination + " / " + (renameIfExisting ? "1" : "0") + " 1 1500 1 ";
+        if(osVersion < 30000) {
+            return commandString;
+        } else {
+            return commandString + crc;
+        }
     }
 }

aurorasdk/src/test/java/com/aurorasdk/AuroraBleScannerTest.java

@@ -0,0 +1,106 @@
+package com.aurorasdk;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.le.BluetoothLeScanner;
+import android.bluetooth.le.ScanFilter;
+import android.bluetooth.le.ScanSettings;
+import android.content.Context;
+import android.support.v4.content.ContextCompat;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({android.os.Process.class, ContextCompat.class, android.os.ParcelUuid.class, AuroraBleScanner.class})
+public class AuroraBleScannerTest {
+
+    private Context context = null;
+
+    private BluetoothManager blManager = null;
+
+    private AuroraBleScanner.ScanListener listener = null;
+
+    @Before
+    public void setTest() {
+        context = PowerMockito.mock(Context.class);
+        blManager = PowerMockito.mock(BluetoothManager.class);
+        PowerMockito.when(context.getSystemService(Context.BLUETOOTH_SERVICE)).thenReturn(blManager);
+        listener = PowerMockito.mock(AuroraBleScanner.ScanListener.class);
+        PowerMockito.mockStatic(android.os.Process.class);
+    }
+
+    @Test
+    public void startScan_NoHasPermissionsDueToAdapterNull() {
+
+        AuroraBleScanner scanner = new AuroraBleScanner(context, listener);
+        scanner.startScan();
+        scanner.stopScan();
+        scanner.getResults();
+    }
+
+    @Test
+    public void startScan_NoHasPermissionsDueToAdapterIsNotEnabled() {
+
+        BluetoothAdapter adapter = PowerMockito.mock(BluetoothAdapter.class);
+        PowerMockito.when(adapter.isEnabled()).thenReturn(false);
+        PowerMockito.when(blManager.getAdapter()).thenReturn(adapter);
+
+        AuroraBleScanner scanner = new AuroraBleScanner(context, listener);
+        scanner.startScan();
+    }
+
+    @Test
+    public void startScan_NoHasPermissionsDueToHasNotLocationPermissions() throws Exception {
+
+        BluetoothAdapter adapter = PowerMockito.mock(BluetoothAdapter.class);
+
+        PowerMockito.when(adapter.isEnabled()).thenReturn(true);
+        PowerMockito.when(blManager.getAdapter()).thenReturn(adapter);
+
+        AuroraBleScanner scanner = new AuroraBleScanner(context, listener);
+
+        PowerMockito.mockStatic(ContextCompat.class);
+        PowerMockito.when(ContextCompat.checkSelfPermission(Mockito.any(), Mockito.any())).thenReturn(12);
+        scanner.startScan();
+    }
+
+    @Test
+    public void startScan_isCorrectWork() throws Exception {
+        BluetoothAdapter adapter = PowerMockito.mock(BluetoothAdapter.class);
+        BluetoothLeScanner mockScanner = PowerMockito.mock(BluetoothLeScanner.class);
+        PowerMockito.when(adapter.getBluetoothLeScanner()).thenReturn(mockScanner);
+        PowerMockito.mockStatic(android.os.ParcelUuid.class);
+        PowerMockito.when(android.os.ParcelUuid.fromString(Mockito.any())).thenReturn(null);
+        PowerMockito.when(adapter.isEnabled()).thenReturn(true);
+        PowerMockito.when(blManager.getAdapter()).thenReturn(adapter);
+        CreateScanFilterMock();
+        CreateScanSettingMock();
+        AuroraBleScanner scanner = new AuroraBleScanner(context, listener);
+
+        scanner.startScan();
+        scanner.stopScan();
+    }
+
+    private void CreateScanSettingMock() throws Exception {
+        ScanSettings.Builder mockBuilder = PowerMockito.mock(ScanSettings.Builder.class);
+        ScanSettings mockScanSettings = PowerMockito.mock(ScanSettings.class);
+        PowerMockito.when(mockBuilder.build()).thenReturn(mockScanSettings);
+        PowerMockito.when(mockBuilder.setScanMode(Mockito.anyInt())).thenReturn(mockBuilder);
+        PowerMockito.whenNew(ScanSettings.Builder.class).withNoArguments().thenReturn(mockBuilder);
+    }
+
+    private void CreateScanFilterMock() throws Exception {
+        ScanFilter.Builder mockBuilder = PowerMockito.mock(ScanFilter.Builder.class);
+        ScanFilter mockScanFilter = PowerMockito.mock(ScanFilter.class);
+        PowerMockito.when(mockBuilder.build()).thenReturn(mockScanFilter);
+        PowerMockito.when(mockBuilder.setServiceUuid(Mockito.any())).thenReturn(mockBuilder);
+        PowerMockito.whenNew(ScanFilter.Builder.class).withNoArguments().thenReturn(mockBuilder);
+    }
+
+}

aurorasdk/src/test/java/com/aurorasdk/CommandProcessorTest.java

@@ -0,0 +1,122 @@
+package com.aurorasdk;
+import android.os.Looper;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.OngoingStubbing;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.io.IOException;
+
+import static org.mockito.ArgumentMatchers.any;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({android.util.Log.class})
+public class CommandProcessorTest {
+
+    CommandProcessor.CommandExecutor executor = PowerMockito.mock(CommandProcessor.CommandExecutor.class);
+    CommandProcessor.CommandInputWriter writer = PowerMockito.mock(CommandProcessor.CommandInputWriter.class);
+    CommandProcessor processor = new CommandProcessor(executor, writer);
+
+    @Before
+    public void setTest(){
+        processor.reset();
+    }
+
+    @Test
+    public void queueCommand_isCorrectWork() {
+
+        processor.queueCommand(new CommandTimeSync());
+    }
+
+    @Test
+    public void setIdleCommandState() {
+        processor.queueCommand(new CommandTimeSync());
+        processor.setCommandState(CommandProcessor.CommandState.IDlE, 10);
+    }
+
+    @Test
+    public void setIdleCommandStateWhenPendingCommandExist() {
+        processor.queueCommand(new CommandTimeSync());
+        processor.setCommandState(CommandProcessor.CommandState.RESPONSE_TABLE_READY);
+
+        processor.setCommandState(CommandProcessor.CommandState.IDlE);
+    }
+
+    @Test
+    public void setInputRequestedCommand() {
+
+        PowerMockito.mockStatic(android.util.Log.class);
+
+        processor.queueCommand(new CommandSdFileWrite("testPath", "testValue"));
+        processor.setCommandState(CommandProcessor.CommandState.INPUT_REQUESTED, 10);
+    }
+
+    @Test
+    public void processCommandResponseLine_SucceedParsing() {
+
+        processor.queueCommand(new CommandTimeSync());
+
+        processor.setCommandState(CommandProcessor.CommandState.RESPONSE_OBJECT_READY);
+        processor.setCommandState(CommandProcessor.CommandState.IDlE);
+
+        processor.processCommandResponseLine("test:value1");
+    }
+
+    @Test
+    public void processCommandResponseLine_FailedParsingLine() {
+
+        processor.queueCommand(new CommandTimeSync());
+        processor.setCommandState(CommandProcessor.CommandState.RESPONSE_OBJECT_READY);
+
+        processor.processCommandResponseLine("test");
+    }
+
+    @Test
+    public void processCommandResponseLine_FailedParsingTable() {
+
+        processor.queueCommand(new CommandTimeSync());
+        processor.setCommandState(CommandProcessor.CommandState.RESPONSE_TABLE_READY);
+
+        processor.processCommandResponseLine("Col1|Col2");
+        processor.setCommandState(CommandProcessor.CommandState.RESPONSE_TABLE_READY);
+        processor.processCommandResponseLine("Test");
+    }
+
+    @Test
+    public void processCommandResponse_NotResponseReadyState() {
+        processor.queueCommand(new CommandTimeSync());
+        processor.setCommandState(CommandProcessor.CommandState.EXECUTE);
+        processor.processCommandResponseLine("Col1|Col2");
+    }
+
+    @Test
+    public void processCommandOutput_isCorrectWork() {
+        processor.queueCommand(new CommandTimeSync());
+        processor.processCommandOutput("data".getBytes());
+    }
+
+    @Test
+    public void processCommandOutput_IOException() throws IOException {
+
+        CommandResponseParser parser = PowerMockito.mock(CommandResponseParser.class);
+        PowerMockito.doThrow(new IOException()).when(parser).parseOutput(Mockito.any());
+
+        CommandProcessor localProc = new CommandProcessor(
+                PowerMockito.mock(CommandProcessor.CommandExecutor.class),
+                PowerMockito.mock(CommandProcessor.CommandInputWriter.class),
+                parser);
+        localProc.queueCommand((new CommandTimeSync()));
+        localProc.processCommandOutput(null);
+    }
+
+
+
+
+}

aurorasdk/src/test/java/com/aurorasdk/CommandProfileLoadTest.java

@@ -0,0 +1,11 @@
+package com.aurorasdk;
+import org.junit.Test;
+import static org.junit.Assert.*;
+public class CommandProfileLoadTest {
+    @Test
+    public void getCommandString_isCorrect() {
+        CommandProfileLoad profileLoad = new CommandProfileLoad("test");
+
+        assertEquals("prof-load test", profileLoad.getCommandString());
+    }
+}

aurorasdk/src/test/java/com/aurorasdk/CommandProfileUnloadTest.java

@@ -0,0 +1,31 @@
+package com.aurorasdk;
+import android.os.Looper;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.OngoingStubbing;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.logging.Handler;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({Logger.class, android.os.Looper.class, android.os.Handler.class})
+public class CommandProfileUnloadTest {
+
+    @Test(expected = RuntimeException.class)
+    public void CommnadProfileUnload_isCorrectWork() {
+        CommandProfileUnload command = new CommandProfileUnload();
+
+        PowerMockito.mockStatic(android.os.Looper.class);
+
+        android.os.Handler mockHandler = PowerMockito.mock(android.os.Handler.class);
+        PowerMockito.spy(mockHandler.postDelayed(Mockito.any(), Mockito.anyLong()));
+        command.completeCommand();
+    }
+}