Wie teste ich eine Methode mit nem AsyncTask und Netzwerkverkehr?

 @Override
    public void refresh(final StartListItemTyp... itemTyps) {
        if (!onCreateWasCalled) {
            throw new IllegalStateException("onCreate() was not called");
        }
        if (itemTyps.length == 0) {
            throw new IllegalArgumentException("Es wurde keine Section übergeben.");
        }
        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... params) {
                AnnetLog.v(TAG, "refresh()");
                for (StartListItemTyp item : itemTyps) {
                    sendStartRefreshing(item);
                }
                try {
                    final List<StartEntry> newStartEntries = downloadHelper.downloadStartList();
                    final StartEntryComparator comparator = new StartEntryComparator();

                    for (StartEntry entry : newStartEntries) {
                        boolean contained = false;
                        for (StartListItemTyp itemTyp : itemTyps) {
                            if (itemTyp == entry.getTyp()) {
                                contained = true;
                                break;
                            }
                        }
                        if (contained) {
                            final StartEntry oldStartEntry = storageHelper.getStartListEntry(entry);
                            if (comparator.compare(oldStartEntry, entry) > 0) {
                                switch (entry.getTyp()) {
                                    case XXX:
                                        downloadNewsSection(entry);
                                    default:
                                        sendUpdated(entry.getTyp());
                                }
                            } else {
                                AnnetLog.v(TAG, "nothing to do with " + entry.getTyp());
                                sendUpdated(entry.getTyp());
                            }
                        }
                    }
                } catch (BException e) {
                    //FIXME Fehler weiterreichen
                }
                return null;
            }
        }.execute();
    }

        AnnetLog.v(TAG, "sendUpdated() " + itemTyp.name());
        currentRefreshing.remove(itemTyp);
        final Intent intent = new Intent(UPDATE_SUCCESS_EVENT);
        intent.putExtra("section", itemTyp.name());
        LocalBroadcastManager.getInstance(mContext).sendBroadcast(intent);

@RunWith(MockitoJUnitRunner.class)
@SmallTest
public class RefreshHelperTest {

    @Mock
    private StorageHelper storageHelper;

    @Mock
    private DownloadHelper downloadHelper;

    @Mock
    private Context context;

    @InjectMocks
    private RefreshHelperImpl helper;

    @Before
    public void setUp() throws Exception {
        helper.onCreate(context, storageHelper);
    }

    @Test(expected = IllegalStateException.class)
    public void testDoInitLoadNotCalledOnCreate() {
        final RefreshHelper refreshHelper = new RefreshHelperImpl();
        refreshHelper.doInitLoad();
    }

    @Test(expected = IllegalStateException.class)
    public void testRefreshNotCalledOnCreate() {
        final RefreshHelper refreshHelper = new RefreshHelperImpl();
        refreshHelper.refresh();
    }

    @Test(expected = IllegalStateException.class)
    public void testIsRefreshingNotCalledOnCreate() {
        final RefreshHelper refreshHelper = new RefreshHelperImpl();
        refreshHelper.isRefreshing(null);
    }

    @Test
    public void testDoCreate() {
        final RefreshHelperImpl refreshHelper = new RefreshHelperImpl();
        refreshHelper.onCreate(context, storageHelper);
    }

    @Test
    public void testIsRefreshingNotRefresh() {
        boolean isRefreshing = helper.isRefreshing(StartListItemTyp.aktuelles_table);
        assertFalse(isRefreshing);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testRefreshEmptyArguments() {
        helper.refresh();
    }

    @Test(expected = IllegalStateException.class)
    public void initLoadNotCalledOnCreate() {
        final RefreshHelperImpl refreshHelper = new RefreshHelperImpl();
        refreshHelper.doInitLoad();
    }

    @Test
    public void initLoad() {
        helper.doInitLoad();
    }
}

public class RefreshHelperImpl implements RefreshHelper {
    private static final String TAG = StringUtils.substring(RefreshHelperImpl.class.getSimpleName(), 0, 22);

    public static final String UPDATE_ERROR_EVENT = "update-error-event";
    public static final String UPDATE_SUCCESS_EVENT = "update-success-event";
    public static final String UPDATE_START = "update-start-event";

    private Context mContext;
    private StorageHelper mStorageHelper;
    private DownloadHelper mDownloadHelper;
    private boolean mOnCreateWasCalled;
    private Queue<StartListItemType> mQueue;
    private DownloadQueueAsyncTask mDownloadTask;

    private final DownloadQueueAsyncTask.Callback mDownloadCallback = new DownloadQueueAsyncTask.Callback() {
        @Override
        public void updated() {
            sendUpdated();
        }

        @Override
        public void error(int resId) {
            sendError(resId);
        }

        @Override
        public void fatalError(int resId) {
            while(!mQueue.isEmpty()) {
                sendError(resId);
            }
        }
    };

    public RefreshHelperImpl() {
        mOnCreateWasCalled = false;
    }

    public void onCreate(final Context context, final StorageHelper storageHelper) {
        if (context == null) {
            throw new IllegalArgumentException("context can't be null");
        }
        if (storageHelper == null) {
            throw new IllegalArgumentException("storageHelper can't be null");
        }
        this.mContext = context;
        this.mStorageHelper = storageHelper;
        this.mDownloadHelper = new DownloadHelperImpl();
        this.mDownloadHelper.onCreate(context);
        mQueue = new ConcurrentLinkedQueue<>();
        mDownloadTask = new DownloadQueueAsyncTask(mDownloadCallback, mQueue, mStorageHelper, mDownloadHelper, mContext);
        this.mOnCreateWasCalled = true;
    }

    @Override
    public void doInitLoad() {
        Log.v(TAG, "doInitLoad()");
        refresh(StartListItemType.values());
    }

    @Override
    public void refresh(final StartListItemType... itemTyps) {
        Log.v(TAG, "refresh()");
        if (!mOnCreateWasCalled) {
            throw new IllegalStateException("onCreate() was not called");
        }

        if (itemTyps.length == 0) {
            throw new IllegalArgumentException("Es wurde keine Section übergeben.");
        }

        if(!mStorageHelper.existCssFile()){
            mQueue.offer(StartListItemType.Android_Smartphone_css);
        }

        for (StartListItemType type : itemTyps) {
            mQueue.offer(type);
        }
        if (!mDownloadTask.isRunning()) {
            mDownloadTask.start();
        }
    }

    @Override
    public boolean isRefreshing(final StartListItemType itemType) {
        if (!mOnCreateWasCalled) {
            throw new IllegalStateException("onCreate was not called");
        }
        final boolean isRefreshing = mQueue.contains(itemType);
        return isRefreshing;
    }

    private void sendUpdated() {
        StartListItemType type = mQueue.poll();
        Log.v(TAG, "sendUpdated() " + type.name());
        final Intent intent = new Intent(UPDATE_SUCCESS_EVENT);
        intent.putExtra("section", type.name());
        LocalBroadcastManager.getInstance(mContext).sendBroadcast(intent);
    }

    private void sendError(final int resId) {
        StartListItemType type = mQueue.poll();
        Log.v(TAG, "sendError() " + type.name());
        final Intent intent = new Intent(UPDATE_ERROR_EVENT);
        intent.putExtra("section", type.name());
        intent.putExtra("errorResId", resId);
        LocalBroadcastManager.getInstance(mContext).sendBroadcast(intent);
    }

    private void sendStartRefreshing(final StartListItemType itemTyp) {
        Log.v(TAG, "sendStartRefreshing() " + itemTyp);
        final Intent intent = new Intent(UPDATE_START);
        intent.putExtra("section", itemTyp.name());
        LocalBroadcastManager.getInstance(mContext).sendBroadcast(intent);
    }
}