kdeconnect-android/tests/org/kde/kdeconnect/LanLinkTest.java

/*
 * Copyright 2015 Vineet Garg <grg.vineet@gmail.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License or (at your option) version 3 or any later version
 * accepted by the membership of KDE e.V. (or its successor approved
 * by the membership of KDE e.V.), which shall act as a proxy
 * defined in Section 14 of version 3 of the license.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

package org.kde.kdeconnect;

import android.test.AndroidTestCase;
import android.util.Log;

import org.json.JSONException;
import org.json.JSONObject;
import org.kde.kdeconnect.Backends.LanBackend.LanLink;
import org.kde.kdeconnect.Backends.LanBackend.LanLinkProvider;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;

public class LanLinkTest extends AndroidTestCase {

    LanLink badLanLink;
    LanLink goodLanLink;

    OutputStream badOutputStream;
    OutputStream goodOutputStream;

    Device.SendPackageStatusCallback callback;

    @Override
    protected void setUp() throws Exception {
        super.setUp();

        System.setProperty("dexmaker.dexcache", getContext().getCacheDir().getPath());

        LanLinkProvider linkProvider = Mockito.mock(LanLinkProvider.class);
        Mockito.when(linkProvider.getName()).thenReturn("LanLinkProvider");

        callback = Mockito.mock(Device.SendPackageStatusCallback.class);

        goodOutputStream = Mockito.mock(OutputStream.class);
        badOutputStream = Mockito.mock(OutputStream.class);
        Mockito.doThrow(new IOException("AAA")).when(badOutputStream).write(Mockito.any(byte[].class));


        Socket socketMock = Mockito.mock(Socket.class);
        Mockito.when(socketMock.getRemoteSocketAddress()).thenReturn(new InetSocketAddress(5000));
        Mockito.when(socketMock.getOutputStream()).thenReturn(goodOutputStream);

        Socket socketBadMock = Mockito.mock(Socket.class);
        Mockito.when(socketBadMock.getRemoteSocketAddress()).thenReturn(new InetSocketAddress(5000));
        Mockito.when(socketBadMock.getOutputStream()).thenReturn(badOutputStream);

        goodLanLink = new LanLink(getContext(), "testDevice", linkProvider, socketMock, LanLink.ConnectionStarted.Remotely);
        badLanLink = new LanLink(getContext(), "testDevice", linkProvider, socketBadMock, LanLink.ConnectionStarted.Remotely);
    }

    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
    }

    public void testSendPackageSuccess() throws JSONException {

        NetworkPackage testPackage = Mockito.mock(NetworkPackage.class);
        Mockito.when(testPackage.getType()).thenReturn("kdeconnect.test");
        Mockito.when(testPackage.getBoolean("isTesting")).thenReturn(true);
        Mockito.when(testPackage.getString("testName")).thenReturn("testSendPackageSuccess");
        Mockito.when(testPackage.serialize()).thenReturn("{\"id\":123,\"type\":\"kdeconnect.test\",\"body\":{\"isTesting\":true,\"testName\":\"testSendPackageSuccess\"}}");

        goodLanLink.sendPackage(testPackage, callback);

        Mockito.verify(callback).onSuccess();
    }

    public void testSendPackageFail() throws JSONException {

        NetworkPackage testPackage = Mockito.mock(NetworkPackage.class);
        Mockito.when(testPackage.getType()).thenReturn("kdeconnect.test");
        Mockito.when(testPackage.getBoolean("isTesting")).thenReturn(true);
        Mockito.when(testPackage.getString("testName")).thenReturn("testSendPackageFail");
        Mockito.when(testPackage.serialize()).thenReturn("{\"id\":123,\"type\":\"kdeconnect.test\",\"body\":{\"isTesting\":true,\"testName\":\"testSendPackageFail\"}}");

        badLanLink.sendPackage(testPackage, callback);

        Mockito.verify(callback).onFailure(Mockito.any(RuntimeException.class));

    }


    public void testSendPayload() throws Exception{

        class Downloader extends Thread {

            NetworkPackage np;
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            public void setNetworkPackage(NetworkPackage networkPackage){
                this.np = networkPackage;
            }

            public ByteArrayOutputStream getOutputStream(){
                return outputStream;
            }

            @Override
            public void run(){
                try {

                    Socket socket = null;
                    try {
                        socket = new Socket();
                        int tcpPort = np.getPayloadTransferInfo().getInt("port");
                        InetSocketAddress address = new InetSocketAddress(5000);
                        socket.connect(new InetSocketAddress(address.getAddress(), tcpPort));
                        np.setPayload(socket.getInputStream(), np.getPayloadSize());
                    } catch (Exception e) {
                        try { socket.close(); } catch(Exception ignored) { throw ignored; }
                        e.printStackTrace();
                        Log.e("KDE/LanLinkTest", "Exception connecting to remote socket");
                        throw e;
                    }

                    final InputStream input = np.getPayload();
                    final long fileLength = np.getPayloadSize();

                    byte data[] = new byte[1024];
                    long progress = 0, prevProgressPercentage = 0;
                    int count;
                    while ((count = input.read(data)) >= 0) {
                        progress += count;
                        outputStream.write(data, 0, count);
                        if (fileLength > 0) {
                            if (progress >= fileLength) break;
                            long progressPercentage = (progress * 100 / fileLength);
                            if (progressPercentage != prevProgressPercentage) {
                                prevProgressPercentage = progressPercentage;
                            }
                        }

                    }
                    outputStream.close();
                    input.close();

                } catch(Exception e) {
                    Log.e("Downloader Test", "Exception");
                    e.printStackTrace();
                }
            }
        }


        final Downloader downloader = new Downloader();

        // Using byte array for payload, try to use input stream as used in real device
        String dataString = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."+
                        " Cras vel erat et ante fringilla tristique. Sed consequat ligula at interdum "+
                        "rhoncus. Integer semper enim felis, id sodales tellus aliquet eget."+
                        " Sed fringilla ac metus eget dictum. Aliquam euismod non sem sit"+
                        " amet dapibus. Interdum et malesuada fames ac ante ipsum primis "+
                        "in faucibus. Nam et ligula placerat, varius justo eu, convallis "+
                        "lorem. Nam consequat consequat tortor et gravida. Praesent "+
                        "ultricies tortor eget ex elementum gravida. Suspendisse aliquet "+
                        "erat a orci feugiat dignissim.";

        // reallyLongString contains dataString 16 times
        String reallyLongString = dataString + dataString;
        reallyLongString = reallyLongString + reallyLongString;
        reallyLongString = reallyLongString + reallyLongString;
        reallyLongString = reallyLongString + reallyLongString;

        final byte[] data = reallyLongString.getBytes();

        final JSONObject sharePackageJson = new JSONObject("{\"id\":123,\"body\":{\"filename\":\"data.txt\"},\"payloadTransferInfo\":{},\"payloadSize\":8720,\"type\":\"kdeconnect.share\"}");

        // Mocking share package
        final NetworkPackage sharePackage = Mockito.mock(NetworkPackage.class);
        Mockito.when(sharePackage.getType()).thenReturn("kdeconnect.share");
        Mockito.when(sharePackage.hasPayload()).thenReturn(true);
        Mockito.when(sharePackage.hasPayloadTransferInfo()).thenReturn(true);
        Mockito.doAnswer(new Answer() {
            @Override
            public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
                return sharePackageJson.toString();
            }
        }).when(sharePackage).serialize();
        Mockito.when(sharePackage.getPayload()).thenReturn(new ByteArrayInputStream(data));
        Mockito.when(sharePackage.getPayloadSize()).thenReturn((long) data.length);
        Mockito.doAnswer(new Answer() {
            @Override
            public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
                return sharePackageJson.getJSONObject("payloadTransferInfo");
            }
        }).when(sharePackage).getPayloadTransferInfo();
        Mockito.doAnswer(new Answer() {
            @Override
            public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
                JSONObject object = (JSONObject)invocationOnMock.getArguments()[0];

                sharePackageJson.put("payloadTransferInfo", object);
                return null;
            }
        }).when(sharePackage).setPayloadTransferInfo(Mockito.any(JSONObject.class));

        Mockito.doAnswer(new Answer() {
            @Override
            public Object answer(InvocationOnMock invocationOnMock) throws Throwable {

                Log.e("LanLinkTest","Write to stream");
                String stringNetworkPackage = new String((byte[])invocationOnMock.getArguments()[0]);
                final NetworkPackage np = NetworkPackage.unserialize(stringNetworkPackage);

                downloader.setNetworkPackage(np);
                downloader.start();

                return stringNetworkPackage.length();
            }
        }).when(goodOutputStream).write(Mockito.any(byte[].class));

        goodLanLink.sendPackage(sharePackage, callback);

        try {
            // Wait 1 secs for downloader to finish (if some error, it will continue and assert will fail)
            downloader.join(1*1000);
        }catch (Exception e){
            e.printStackTrace();
            throw e;
        }
        assertEquals(new String(data), new String(downloader.getOutputStream().toByteArray()));

        Mockito.verify(callback).onSuccess();

    }
}