Subversion Repositories SmartDukaan

/*

 * Copyright (C) 2015 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.volley;

import com.android.volley.Request.Priority;

import com.android.volley.RequestQueue.RequestFinishedListener;

import com.android.volley.mock.MockRequest;

import com.android.volley.mock.ShadowSystemClock;

import com.android.volley.toolbox.NoCache;

import com.android.volley.utils.ImmediateResponseDelivery;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.invocation.InvocationOnMock;

import org.mockito.stubbing.Answer;

import org.robolectric.RobolectricTestRunner;

import org.robolectric.annotation.Config;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import java.util.concurrent.Semaphore;

import java.util.concurrent.TimeUnit;

import static org.junit.Assert.*;

import static org.mockito.Mockito.*;

import static org.mockito.MockitoAnnotations.initMocks;

/**

 * Integration tests for {@link RequestQueue}, that verify its behavior in conjunction with real dispatcher, queues and

 * Requests. Network is mocked out

 */

@RunWith(RobolectricTestRunner.class)

@Config(shadows = {ShadowSystemClock.class})

public class RequestQueueIntegrationTest {

    private ResponseDelivery mDelivery;

    @Mock private Network mMockNetwork;

    @Before public void setUp() throws Exception {

        mDelivery = new ImmediateResponseDelivery();

        initMocks(this);

    }

    @Test public void add_requestProcessedInCorrectOrder() throws Exception {

        // Enqueue 2 requests with different cache keys, and different priorities. The second, higher priority request

        // takes 20ms.

        // Assert that first request is only handled after the first one has been parsed and delivered.

        MockRequest lowerPriorityReq = new MockRequest();

        MockRequest higherPriorityReq = new MockRequest();

        lowerPriorityReq.setCacheKey("1");

        higherPriorityReq.setCacheKey("2");

        lowerPriorityReq.setPriority(Priority.LOW);

        higherPriorityReq.setPriority(Priority.HIGH);

        RequestFinishedListener listener = mock(RequestFinishedListener.class);

        Answer<NetworkResponse> delayAnswer = new Answer<NetworkResponse>() {

            @Override

            public NetworkResponse answer(InvocationOnMock invocationOnMock) throws Throwable {

                Thread.sleep(20);

                return mock(NetworkResponse.class);

            }

        };

        //delay only for higher request

        when(mMockNetwork.performRequest(higherPriorityReq)).thenAnswer(delayAnswer);

        when(mMockNetwork.performRequest(lowerPriorityReq)).thenReturn(mock(NetworkResponse.class));

        RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 1, mDelivery);

        queue.addRequestFinishedListener(listener);

        queue.add(lowerPriorityReq);

        queue.add(higherPriorityReq);

        queue.start();

        // you cannot do strict order verification in combination with timeouts with mockito 1.9.5 :(

        // as an alternative, first verify no requests have finished, while higherPriorityReq should be processing

        verifyNoMoreInteractions(listener);

        // verify higherPriorityReq goes through first

        verify(listener, timeout(100)).onRequestFinished(higherPriorityReq);

        // verify lowerPriorityReq goes last

        verify(listener, timeout(10)).onRequestFinished(lowerPriorityReq);

        queue.stop();

    }

    /**

     * Asserts that requests with same cache key are processed in order.

     *

     * Needs to be an integration test because relies on complex interations between various queues

     */

    @Test public void add_dedupeByCacheKey() throws Exception {

        // Enqueue 2 requests with the same cache key. The first request takes 20ms. Assert that the

        // second request is only handled after the first one has been parsed and delivered.

        Request req1 = new MockRequest();

        Request req2 = new MockRequest();

        RequestFinishedListener listener = mock(RequestFinishedListener.class);

        Answer<NetworkResponse> delayAnswer = new Answer<NetworkResponse>() {

            @Override

            public NetworkResponse answer(InvocationOnMock invocationOnMock) throws Throwable {

                Thread.sleep(20);

                return mock(NetworkResponse.class);

            }

        };

        //delay only for first

        when(mMockNetwork.performRequest(req1)).thenAnswer(delayAnswer);

        when(mMockNetwork.performRequest(req2)).thenReturn(mock(NetworkResponse.class));

        RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 3, mDelivery);

        queue.addRequestFinishedListener(listener);

        queue.add(req1);

        queue.add(req2);

        queue.start();

        // you cannot do strict order verification with mockito 1.9.5 :(

        // as an alternative, first verify no requests have finished, then verify req1 goes through

        verifyNoMoreInteractions(listener);

        verify(listener, timeout(100)).onRequestFinished(req1);

        verify(listener, timeout(10)).onRequestFinished(req2);

        queue.stop();

    }

    /**

     * Verify RequestFinishedListeners are informed when requests are canceled

     *

     * Needs to be an integration test because relies on Request -> dispatcher -> RequestQueue interaction

     */

    @Test public void add_requestFinishedListenerCanceled() throws Exception {

        RequestFinishedListener listener = mock(RequestFinishedListener.class);

        Request request = new MockRequest();

        Answer<NetworkResponse> delayAnswer = new Answer<NetworkResponse>() {

            @Override

            public NetworkResponse answer(InvocationOnMock invocationOnMock) throws Throwable {

                Thread.sleep(200);

                return mock(NetworkResponse.class);

            }

        };

        RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 1, mDelivery);

        when(mMockNetwork.performRequest(request)).thenAnswer(delayAnswer);

        queue.addRequestFinishedListener(listener);

        queue.start();

        queue.add(request);

        request.cancel();

        verify(listener, timeout(100)).onRequestFinished(request);

        queue.stop();

    }

    /**

     * Verify RequestFinishedListeners are informed when requests are successfully delivered

     *

     * Needs to be an integration test because relies on Request -> dispatcher -> RequestQueue interaction

     */

    @Test public void add_requestFinishedListenerSuccess() throws Exception {

        NetworkResponse response = mock(NetworkResponse.class);

        Request request = new MockRequest();

        RequestFinishedListener listener = mock(RequestFinishedListener.class);

        RequestFinishedListener listener2 = mock(RequestFinishedListener.class);

        RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 1, mDelivery);

        queue.addRequestFinishedListener(listener);

        queue.addRequestFinishedListener(listener2);

        queue.start();

        queue.add(request);

        verify(listener, timeout(100)).onRequestFinished(request);

        verify(listener2, timeout(100)).onRequestFinished(request);

        queue.stop();

    }

    /**

     * Verify RequestFinishedListeners are informed when request errors

     *

     * Needs to be an integration test because relies on Request -> dispatcher -> RequestQueue interaction

     */

    @Test public void add_requestFinishedListenerError() throws Exception {

        RequestFinishedListener listener = mock(RequestFinishedListener.class);

        Request request = new MockRequest();

        RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 1, mDelivery);

        when(mMockNetwork.performRequest(request)).thenThrow(new VolleyError());

        queue.addRequestFinishedListener(listener);

        queue.start();

        queue.add(request);

        verify(listener, timeout(100)).onRequestFinished(request);

        queue.stop();

    }

}