def mock_api():
    # Mock get the license list.
    with open(path.join(ROOT, 'licenses.json')) as f:
        mock_response_body = f.read()
    responses.add(responses.GET, 'https://api.github.com/licenses',
                  body=mock_response_body)

    # Mock get each license template.
    for license in os.listdir(path.join(ROOT, 'licenses')):
        with open(path.join(ROOT, 'licenses/{0}'.format(license))) as f:
            mock_response_body = f.read()
        responses.add(responses.GET,
                      'https://api.github.com/licenses/{0}'.format(
                          path.splitext(license)[0]),
                      body=mock_response_body, content_type='application/json')

    # Mock get the invalid license.
    with open(path.join(ROOT, 'not_found.json')) as f:
        mock_not_found_body = f.read()
    responses.add(responses.GET, 'https://api.github.com/licenses/invalid',
                  body=mock_not_found_body, content_type='application/json')

    responses.start()
    yield responses
    responses.stop()

 def wrapper(*args, **kwargs):
     responses.start()
     responses.add(**response_dict)
     result = f(response_data=json.loads(response_dict["body"]), *args, **kwargs)
     responses.stop()
     responses.reset()
     return result

def mock_api():
    """A mock for the PyPI JSON API."""
    with open(os.path.join(HERE, 'response.json'), 'r') as fp:
        webargs_response = fp.read()
    # A valid package with a proper response
    responses.add(
        responses.GET,
        'https://pypi.python.org/pypi/webargs/json',
        body=webargs_response,
        content_type='application/json'
    )
    # A valid package with no releases
    with open(os.path.join(HERE, 'response_noreleases.json'), 'r') as fp:
        foo_response = fp.read()

    responses.add(
        responses.GET,
        'https://pypi.python.org/pypi/foo/json',
        body=foo_response,
        content_type='application/json'
    )

    # An invalid package name
    responses.add(
        responses.GET,
        'https://pypi.python.org/pypi/nope/json',
        status=404
    )
    responses.start()

    yield responses

    responses.stop()

def mock_api():

    with open(path.join(ROOT, 'signin.html'), encoding='utf-8') as f:
        mock_signin_body = f.read()
    responses.add(responses.POST, 'https://www.v2ex.com/signin',
                  body=mock_signin_body)
    responses.add(responses.GET, 'https://www.v2ex.com/signin',
                  body=mock_signin_body)

    with open(path.join(ROOT, 'once.html'), encoding='utf-8') as f:
        mock_once_body = f.read()
    responses.add(responses.GET,
                  'https://www.v2ex.com/mission/daily/redeem?once=51947',
                  body=mock_once_body)

    with open(path.join(ROOT, 'balance.html'), encoding='utf-8') as f:
        mock_balance_body = f.read()
    responses.add(responses.GET, 'https://www.v2ex.com/balance',
                  body=mock_balance_body)

    with open(path.join(ROOT, 'mission.html'), encoding='utf-8') as f:
        mock_mission_body = f.read()
    responses.add(responses.GET, 'https://www.v2ex.com/mission/daily',
                  body=mock_mission_body)

    responses.start()
    yield responses
    responses.stop()

 def testTearDown(self):
     try:
         responses.stop()
     except RuntimeError:
         pass
     finally:
         responses.reset()

 def wrapper(*args, **kwargs):
     responses.start()
     for response in resps:
         responses.add(**response)
     result = f(responses=responses, *args, **kwargs)
     responses.stop()
     responses.reset()
     return result

 def tearDown(self):
     super(AkismetClientTests, self).tearDown()
     responses.stop()
     responses.reset()
     Flag.objects.update_or_create(
         name=SPAM_CHECKS_FLAG,
         defaults={'everyone': None},
     )

def mock_api():
    for package_name in ['requests', 'flask', 'pip']:
        mock_package_response(package_name)
    for package_name in ['this_package_name_has_not_been_used',
                         'you_will_never_use_this_package_name',
                         'I_suck_and_my_tests_are_order_dependent']:
        mock_package_response(package_name, status_code=404)

    responses.start()
    yield responses
    responses.stop()

 def fixture():
     responses.add(
         responses.POST,
         url,
         status=status,
         body=json.dumps(data or {}),
         content_type='application/json',
     )
     responses.start()
     yield responses
     responses.stop()
     responses.reset()

            def callback(req):
                # clean up after last callback
                add_downloaded_files(state['downloaded'], spec, state['previous_url'])
                if state['requests'] == state['total_requests']:
                    raise MaxDownloadsReached()
                # make a real requests call somehow
                responses.stop()
                # when testing this testing function
                # (testTestutil.RepoTester.test_download_setfile) we
                # still want to disable responses, but we don't want
                # to make an actual HTTP call. Detect if we are
                # running that test by examining the stack, and if so,
                # mock the requests.get call in a different way.
                frames = [f for f in inspect.stack() if f[3] == "test_download_setfile"]
                if frames:
                    frame = frames[0][0]
                    resp = frame.f_locals['self']._myget(req.url)
                else:
                    resp = requests.get(req.url)
                responses.start()
                # create a filename. use .html as suffix unless we
                # should use something else
                contenttype = resp.headers["Content-type"]
                stem = os.path.splitext(specfile)[0]
                suffix = {'application/pdf': 'pdf',
                          'application/json': 'json',
                          'text/plain': 'txt'}.get(contenttype, "html")
                outfile = "%s-%s.%s" % (stem, state['requests'], suffix)
                with open(outfile, "wb") as fp:
                    fp.write(resp.content)

                if not frames and os.environ.get("TRAVIS") != "true":
                    if suffix == "html":
                        print(
                            "requested %s, saved as %s. Edit if needed, then press enter" %
                            (req.url, outfile))
                        x = input()
                    else:
                        print("requested %s, saved %s" % (req.url, outfile))

                with open(outfile, "rb") as fp:
                    content = fp.read()
                spec[req.url] = {'file': os.path.basename(outfile)}
                if resp.encoding != 'utf-8':
                    spec[req.url]['encoding'] = resp.encoding

                state['requests'] += 1
                state['previous_url'] = req.url
                return (resp.status_code, resp.headers, content)

def start_responses_mocking(request):
    """Enable ``responses`` this enforcing us to explicitly mark tests
    that require internet usage.
    """
    marker = request.node.get_closest_marker('allow_external_http_requests')

    if not marker:
        responses.start()

    yield

    try:
        if not marker:
            responses.stop()
            responses.reset()
    except RuntimeError:
        # responses patcher was already uninstalled
        pass

def mock_request():
    with open(path.join(path.dirname(path.realpath(__file__)),
                        'fake_response.json')) as f:
        fake_response = json.load(f)

    responses.add(
        responses.GET,
        url=("https://www.bing.com/HPImageArchive.aspx?format"
             "=js&idx=0&n=1&nc=1409879295618&pid=hp"),
        json=fake_response,
        status=200,
        match_querystring=True
    )
    responses.add(
        responses.GET,
        url=("https://www.bing.com/az/hprichbg/rb/HudsonBayPolars_"
             "ZH-CN10500767857_1920x1080.jpg"),
        status=200,
        body='Hello, world'
    )

    responses.start()
    yield responses
    responses.stop()

 def done():
     responses.stop()
     responses.reset()

 def done():
     resp_module.stop()
     resp_module.reset()

 def teardown_limetypes():
     responses.stop()
     responses.reset()

 def teardown_limeobjects():
     responses.stop()
     responses.reset()

 def tearDown(self):
     responses.stop()
     responses.reset()

 def tearDown(self):
     responses.stop()
     responses.reset()
     super(MockRequestsMixin, self).tearDown()

 def callback(http_request):
     responses.stop()
     response = testypie.get_response(http_request.url, http_request.headers)
     responses.start()
     return response['code'], response['headers'], response['body']

 def teardown():
     responses.stop()
     responses.reset()