def test_invalid_message_missing_username(self):
"""
Given a message with missing username
When the message is processed
Then an exception is raised
And the push message is not queued
"""
from maxbunny.consumers.conversations import __consumer__
from maxbunny.tests.mockers.conversations import MISSING_USERNAME_MESSAGE as message
self.set_server({}, None)
httpretty.enable()
http_mock_info()
runner = MockRunner('conversations', 'maxbunny.ini', 'instances2.ini')
consumer = __consumer__(runner)
self.assertRaisesWithMessage(
BunnyMessageCancel,
'Missing username in message',
consumer.process,
message
)
httpretty.disable()
httpretty.reset()
sleep(0.1) # Leave a minimum time to message to reach rabbitmq
messages = self.server.get_all('push')
self.assertEqual(len(messages), 0)
def tearDown(self):
self.w3afcore.quit()
self.kb.cleanup()
if self.MOCK_RESPONSES:
httpretty.disable()
httpretty.reset()
def test_timeout(version):
httpretty.reset()
httpretty.enable()
timeout_in_sec = 1
client = make_client(version)
#
# configure to raise the error before the timeout
#
client.timeout = timeout_in_sec / 2.0
def timeout_request_callback(request, uri, headers):
sleep(timeout_in_sec)
return (200, headers, "All good!")
uri = get_fix(version).DISCOVERY_URI_HTTP
httpretty.register_uri(
httpretty.POST,
uri,
body=timeout_request_callback,
content_type='application/json'
)
with pytest.raises(requests.exceptions.Timeout):
client.discover_services(uri=uri)
httpretty.disable()
httpretty.reset()
def tearDown(self):
httpretty.disable()
httpretty.reset()
tinify.app_identifier = None
tinify.key = None
tinify.compression_count
def test_set_headers(version):
httpretty.reset()
httpretty.enable()
uri = get_fix(version).DISCOVERY_URI_HTTP
response = get_fix(version).DISCOVERY_RESPONSE
register_uri(uri, response, version)
client = make_client(
version,
headers={CUSTOM_HEADER_NAME: CUSTOM_HEADER_VALUE})
services = client.discover_services(uri=uri)
assert len(services) == 4
message = get_sent_message(version)
assert type(message) == (tm11 if version == 11 else tm10).DiscoveryRequest
last_request = httpretty.last_request()
assert CUSTOM_HEADER_NAME in last_request.headers
assert last_request.headers[CUSTOM_HEADER_NAME] == CUSTOM_HEADER_VALUE
httpretty.disable()
httpretty.reset()
def test_expired(self):
httpretty.disable()
req = webob.Request.blank('/')
token = self.token_dict['signed_token_scoped_expired']
req.headers['X-Auth-Token'] = token
self.middleware(req.environ, self.start_fake_response)
self.assertEqual(self.response_status, 401)
def test_known_pull_request_task(app, owner, repository, session):
"""Task pull_request /pulls/1 that already exists."""
httpretty.reset()
cs1 = CommitStatus(repository,
"1",
"https://github.com/pulls/1",
{"message": [], "files": {}})
cs2 = CommitStatus(repository,
"2",
"https://github.com/pulls/2",
{"message": [], "files": {}})
session.add(cs1)
session.add(cs2)
session.commit()
bs = BranchStatus(cs2,
"test:my-branch",
"https://github.com/pulls/1",
{"commits": [cs1, cs2], "files": {}})
session.add(bs)
session.commit()
assert_that(bs.is_pending(), equal_to(False))
httpretty.enable()
pull_request(bs.id,
"https://api.github.com/pulls/1",
"http://kwalitee.invenio-software.org/status/2",
{"ACCESS_TOKEN": "deadbeef"})
httpretty.disable()
latest_requests = httpretty.HTTPretty.latest_requests
assert_that(len(latest_requests), equal_to(0),
"No requests are expected")
def test_bad_verification_code(self):
# Test redirect
resp = self.client.get(
url_for("oauthclient.login", remote_app='github')
)
self.assertStatus(resp, 302)
assert resp.location.startswith(
"https://github.com/login/oauth/authorize"
)
httpretty.enable()
fixtures.register_github_api()
# Test restart of auth flow when getting a bad_verification_code
resp = self.client.get(
url_for(
"oauthclient.authorized",
remote_app='github',
code='bad_verification_code'
)
)
assert resp.status_code == 302
assert resp.location.endswith(
url_for('oauthclient.login', remote_app='github')
)
httpretty.disable()
httpretty.reset()
def test_bad_verification_code(app, db):
with app.test_request_context():
# Test redirect
client = app.test_client()
resp = client.get(
url_for('invenio_oauthclient.login', remote_app='github')
)
assert resp.status_code == 302
assert resp.location.startswith(
'https://github.com/login/oauth/authorize'
)
state = get_state(resp.location)
httpretty.enable()
fixtures.register_github_api()
# Test restart of auth flow when getting a bad_verification_code
resp = client.get(
url_for(
'invenio_oauthclient.authorized',
remote_app='github',
code='bad_verification_code',
state=state,
)
)
assert resp.status_code == 302
# assert resp.location.endswith(
# url_for('invenio_oauthclient.login', remote_app='github')
# )
httpretty.disable()
httpretty.reset()
def test_httpretty_bypasses_when_disabled(context):
"httpretty should bypass all requests by disabling it"
httpretty.register_uri(
httpretty.GET, "http://localhost:9999/go-for-bubbles/",
body="glub glub")
httpretty.disable()
fd = urllib2.urlopen('http://localhost:9999/go-for-bubbles/')
got1 = fd.read()
fd.close()
expect(got1).to.equal(
b'. o O 0 O o . o O 0 O o . o O 0 O o . o O 0 O o . o O 0 O o .')
fd = urllib2.urlopen('http://localhost:9999/come-again/')
got2 = fd.read()
fd.close()
expect(got2).to.equal(b'<- HELLO WORLD ->')
httpretty.enable()
fd = urllib2.urlopen('http://localhost:9999/go-for-bubbles/')
got3 = fd.read()
fd.close()
expect(got3).to.equal(b'glub glub')
core.POTENTIAL_HTTP_PORTS.remove(9999)
def test_missing_domain_missing_default(self):
"""
Given a message with no domain specified
And there is no default domain specified
When the message is processed
Then an exception is raised
And the push message is not queued
"""
from maxbunny.consumers.conversations import __consumer__
from maxbunny.tests.mockers.conversations import MISSING_DOMAIN_MESSAGE as message
self.set_server({}, None)
httpretty.enable()
http_mock_info()
runner = MockRunner('conversations', 'maxbunny.ini', 'instances.ini')
consumer = __consumer__(runner)
self.assertRaisesWithMessage(
BunnyMessageCancel,
'Missing domain, and default could not be loaded',
consumer.process,
message
)
httpretty.disable()
httpretty.reset()
sleep(0.1) # Leave a minimum time to message to reach rabbitmq
messages = self.server.get_all('push')
self.assertEqual(len(messages), 0)
def test_message_with_domain(self):
"""
Given a message with a domain specified
And that domain exists in the list of known domains
When the message is processed
Then the message is posted
And the push message is queued
"""
from maxbunny.consumers.conversations import __consumer__
from maxbunny.tests.mockers.conversations import CONVERSATION_MESSAGE as message
message_id = '00000000001'
self.set_server(message, message_id)
httpretty.enable()
http_mock_info()
http_mock_post_user_message(uri='tests.local', message_id=message_id)
runner = MockRunner('conversations', 'maxbunny.ini', 'instances2.ini')
consumer = __consumer__(runner)
consumer.process(message)
httpretty.disable()
httpretty.reset()
sleep(0.1) # Leave a minimum time to message to reach rabbitmq
messages = self.server.get_all('push')
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0][0]['a'], 'k')
self.assertEqual(messages[0][0]['o'], 'm')
self.assertEqual(messages[0][0]['s'], 'b')
self.assertEqual(messages[0][0]['d']['id'], '00000000001')
def tearDown(self):
os.remove("line_file.json")
os.remove("array_file.json")
os.remove("object_file.json")
os.remove("block_file.json")
httpretty.disable()
httpretty.reset()
def test_invalid_message_unknown_domain(self):
"""
Given a message with a domain specified
And that domain doesn't match any of the known domains
When the message is processed
Then an exception is raised
And the push message is not queued
"""
from maxbunny.consumers.conversations import __consumer__
from maxbunny.tests.mockers.conversations import UNKNOWN_DOMAIN_MESSAGE as message
self.set_server({}, None)
httpretty.enable()
http_mock_info()
runner = MockRunner('conversations', 'maxbunny.ini', 'instances2.ini')
consumer = __consumer__(runner)
self.assertRaisesWithMessage(
BunnyMessageCancel,
'Unknown domain "unknown"',
consumer.process,
message
)
httpretty.disable()
httpretty.reset()
sleep(0.1) # Leave a minimum time to message to reach rabbitmq
messages = self.server.get_all('push')
self.assertEqual(len(messages), 0)
def test_for_name_similarity_required_parameters(api, json_response):
httpretty.enable()
httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info",
body=json_response, status=200, content_type="application/json")
httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-similarity",
body=json_response, status=200, content_type="application/json")
matched_name_data1 = "Michael Jackson"
matched_name_data2 = "迈克尔·杰克逊"
params = NameSimilarityParameters()
with pytest.raises(RosetteException) as e_rosette:
result = api.name_similarity(params)
assert e_rosette.value.status == 'missingParameter'
assert e_rosette.value.message == 'Required Name Similarity parameter not supplied'
params["name1"] = {
"text": matched_name_data1,
"language": "eng",
"entityType": "PERSON"}
with pytest.raises(RosetteException) as e_rosette:
result = api.name_similarity(params)
assert e_rosette.value.status == 'missingParameter'
assert e_rosette.value.message == 'Required Name Similarity parameter not supplied'
params["name2"] = {"text": matched_name_data2, "entityType": "PERSON"}
result = api.name_similarity(params)
assert result["name"] == "Rosette API"
httpretty.disable()
httpretty.reset()
def test_for_name_translation_required_parameters(api, json_response):
httpretty.enable()
httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info",
body=json_response, status=200, content_type="application/json")
httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-translation",
body=json_response, status=200, content_type="application/json")
params = NameTranslationParameters()
params["entityType"] = "PERSON"
params["targetScript"] = "Latn"
with pytest.raises(RosetteException) as e_rosette:
result = api.name_translation(params)
assert e_rosette.value.status == 'missingParameter'
assert e_rosette.value.message == 'Required Name Translation parameter not supplied'
params["name"] = "some data to translate"
with pytest.raises(RosetteException) as e_rosette:
result = api.name_translation(params)
assert e_rosette.value.status == 'missingParameter'
assert e_rosette.value.message == 'Required Name Translation parameter not supplied'
params["targetLanguage"] = "eng"
result = api.name_translation(params)
assert result["name"] == "Rosette API"
httpretty.disable()
httpretty.reset()
def test_is_referenced(self):
uri = 'http://id.erfgoed.net/foobar/2'
url = 'http://localhost:6543'
from pyramid_urireferencer.renderers import registry_adapter
reg_response_success_ref1 = registry_adapter(RegistryResponse(uri, True, False, 0, []), {})
referencer = TestReferencer(url)
self.assertIsNone(referencer.references(uri, 'test'))
response = referencer.is_referenced(uri)
self.assertIsInstance(response, RegistryResponse)
self.assertEqual(response.success, False)
httpretty.enable() # enable HTTPretty so that it will monkey patch the socket module
httpretty.register_uri(
httpretty.GET,
'{0}/references?{1}'.format(url, urlencode({'uri': uri})),
body=json.dumps(reg_response_success_ref1),
content_type="application/json"
)
response = referencer.is_referenced(uri)
self.assertIsInstance(response, RegistryResponse)
self.assertTrue(response.success)
httpretty.disable() # disable afterwards, so that you will have no problems in code that uses that socket module
httpretty.reset()
def httpretty():
"""Prepares the httpretty module for the HTTP tests in this suite"""
import httpretty
httpretty.enable()
yield httpretty
httpretty.disable()
def test_retrieve_missing_chunks(self):
httpretty.enable() # enable HTTPretty so that it will monkey patch the socket module
try:
existing_chunks = {'goog-malware-shavar': {'add': '160929-173975', 'sub': '151695-152051,152053-153220,153222-154217,154219-154240,154242-154260,154262-154638,154640-155042,155044-155415,155417-155505,155507-155706,155708-155768,155770-155781,155783-157480,157482-157623,157625-157836,157838-159256,159258-160279,160281-160909,160911-165040'}, 'googpub-phish-shavar': {'add': '325243-336324', 'sub': '20232-20239,20241-20251,20253-20254,20257-20258,20262-20264,20266,20268-20269,20272-20273,20275,20277-20278,20280,20282-20284,20286-20291,20293-20297,20300,20302-20309,20311,20314-20320,20322-20324,20326,20328-20330,20332-20333,20335-20336,20339-20341,20343-20344,20347,20349-20352,20354-20356,20358-20359,20361-20364,20366,20368-20375,20377-20378,20380-20381,20383-20384,20386-20396,20399-20404,20407-20411,20413-20416,20418-20429,20431-20438,20442-20459,20462-20479,20481-20490,20492-20494,20496-20500,20502-20506,20509,20511-20521,20523-20531,20533-20583,20585-20591,20593-20613,20615-20647,20649-20900,20902-20947,20949-20991,20993-21052,21054,21056-21176'}}
url = "https://safebrowsing.google.com/safebrowsing/downloads"
body = b'n:1704\ni:goog-malware-shavar\nu:safebrowsing-cache.google.com/safebrowsing/rd/ChNnb29nLW1hbHdhcmUtc2hhdmFyOAFAAkoMCAEQsYkKGLGJCiABSgwIABCYzwoYmM8KIAE\ni:googpub-phish-shavar\nu:safebrowsing-cache.google.com/safebrowsing/rd/ChRnb29ncHViLXBoaXNoLXNoYXZhcjgBQAJKDAgAEMXDFBjFwxQgAQ\n'
httpretty.register_uri(httpretty.POST, url, body=body, status=200)
mockchunks = [{"url": "https://safebrowsing-cache.google.com/safebrowsing/rd/ChNnb29nLW1hbHdhcmUtc2hhdmFyOAFAAkoMCAEQsYkKGLGJCiABSgwIABCYzwoYmM8KIAE", "body": b'\x00\x00\x004\x08\xb1\x89\n\x10\x01"\x18\xcc\xbdS\xfa:\xb7\x1d\xa3\xd1R&\xde\xca\x1a\x92\xfb\x84Wy\x7fI5\xba\xe0*\x12\x97\xcd\n\xec\x8f\n\xf5\x9a\n\xe3\xf8\t\xc8\xfe\t\xb9\xb6\n\x00\x00\x00\x0e\x08\x98\xcf\n"\x08\xca\x8eoj$\x19ro'},
{"url": "https://safebrowsing-cache.google.com/safebrowsing/rd/ChRnb29ncHViLXBoaXNoLXNoYXZhcjgBQAJKDAgAEMXDFBjFwxQgAQ", "body": b'\x00\x00\x00Z\x08\xc5\xc3\x14"T\xa3p\xda\x91l\xa9\xa5\xa89SOl\x12,\x0bXB0\xed\x1f\x114b2\xf2\x8b\x9a\xeb\xf4\xb6\xc1f\xe6\x80!\x81\xdd\xc4\xb5O\xfa\xfdKS\x03<\x97\xfb\x83\xb6\r\xfa\xfe\x15$\xa0\xa7C\xd4W\xd8\x029\xad\x03\xf9r\x0c/d\xb8jz\xc6\xaf4qQ\xccQ/1\xb3\xc3'}
]
for mockchunk in mockchunks:
log.debug("adding url {url} and body {body}".format(url=mockchunk['url'][:10], body=mockchunk['body'][:10]))
httpretty.register_uri(httpretty.POST, mockchunk['url'], body=mockchunk['body'], status=200)
httpretty.register_uri(httpretty.GET, mockchunk['url'], body=mockchunk['body'], status=200)
response = self.client.retrieve_missing_chunks(existing_chunks)
log.debug("RESPONSE: {res}".format(res=response))
log.debug("chunks: {res}".format(res=response.chunks))
chunks = []
for chunk in response.chunks:
log.debug("--- CHUNK --- {chunktype} {chunk}".format(chunktype=chunk.chunk_type, chunk=chunk.chunk_number))
chunks.append({"number": chunk.chunk_number, "type": chunk.chunk_type})
assert_in({'type': 'add', 'number': 336325}, chunks)
assert_in({'type': 'sub', 'number': 165041}, chunks)
assert_in({'type': 'add', 'number': 173976}, chunks)
log.info("got chunks: {chunks}".format(chunks=chunks))
log.debug("response: {res}".format(res=response))
except Exception:
raise
finally:
httpretty.disable()
httpretty.reset()
def test_metric(self, baseapi):
httpretty.enable()
stub_request('http://localhost:8080/v3/metrics/mbean/test')
baseapi.metric('test')
assert httpretty.last_request().path == '/v3/metrics/mbean/test'
httpretty.disable()
httpretty.reset()
def test_create_badge(app):
"""Test create_badge method."""
badge_url = "%sDOI-10.1234%%2Ffoo.bar-blue.svg?style=flat" % \
app.config["GITHUB_SHIELDSIO_BASE_URL"]
httpretty.enable()
httpretty.register_uri(
httpretty.GET,
badge_url,
body=SVG,
content_type="image/svg+xml",
)
output = os.path.join(app.instance_path, "test.svg")
create_badge(
"DOI",
"10.1234/foo.bar",
"blue",
output,
style="flat",
)
assert os.path.exists(output)
httpretty.disable()
def test_with_path(self, baseapi):
httpretty.enable()
stub_request('http://localhost:8080/v3/nodes/node1')
baseapi._query('nodes', path='node1')
assert httpretty.last_request().path == '/v3/nodes/node1'
httpretty.disable()
httpretty.reset()
def test_environments(self, baseapi):
httpretty.enable()
stub_request('http://localhost:8080/pdb/query/v4/environments')
baseapi.environments()
assert httpretty.last_request().path == '/pdb/query/v4/environments'
httpretty.disable()
httpretty.reset()
def test_session(self):
"""
Ensures that the session has the expected connectivity
"""
httpretty.enable()
httpretty.register_uri(
httpretty.GET,
'http://consul.internal:8501/v1/status/leader',
body="localhost:8300",
)
app = self.create_app()
consul = Consul(
app,
consul_host='consul.internal',
consul_port='8501',
test_connection=True
)
self.assertIsNotNone(consul)
httpretty.disable()
httpretty.reset()
app = self.create_app()
self.assertRaises(
ConsulConnectionError,
lambda: Consul(
app,
consul_host='consul.internal',
consul_port='8501',
test_connection=True
),
)
def mock_icon_urls():
httpretty.enable()
httpretty.HTTPretty.allow_net_connect = False
# smallest valid png, from https://github.com/mathiasbynens/small/blob/master/png-transparent.png
httpretty.register_uri(
httpretty.GET,
PROPER_ICON_URL,
body=b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\nIDATx\x9cc\x00\x01\x00\x00\x05\x00\x01\r\n-\xb4\x00\x00\x00\x00IEND\xaeB`\x82',
content_type='image/png'
)
httpretty.register_uri(
httpretty.GET,
IMPROPER_ICON_URL,
body=b'\n\n\n\n\n\n<!DOCTYPE html>\n<html lang="en">\n <head>\n',
content_type='text/html'
)
httpretty.register_uri(
httpretty.GET,
INVALID_URL
)
httpretty.register_uri(
httpretty.GET,
TIMEOUT_URL,
body=exceptionCallback
)
yield
httpretty.disable()
def test_fact_names(self, baseapi):
httpretty.enable()
stub_request('http://localhost:8080/pdb/query/v4/fact-names')
baseapi.fact_names()
assert httpretty.last_request().path == '/pdb/query/v4/fact-names'
httpretty.disable()
httpretty.reset()
def moves_auth():
httpretty.enable()
def _method(method):
return {"GET": httpretty.GET, "POST": httpretty.POST}[method]
strategy = DjangoStrategy(MovesOAuth2, DjangoStorage)
start_url = strategy.start().url
target_url = handle_state(MovesOAuth2, start_url, strategy.build_absolute_uri("/complete/{0}/?code=foobar"))
httpretty.register_uri(httpretty.GET, start_url, status=301, location=target_url)
httpretty.register_uri(httpretty.GET, target_url, status=200, body="foobar")
httpretty.register_uri(
_method(MovesOAuth2.ACCESS_TOKEN_METHOD),
uri=MovesOAuth2.ACCESS_TOKEN_URL,
status=200,
body=json.dumps({"access_token": "foobar", "token_type": "bearer"}),
content_type="text/json",
)
user_data_url = "https://api.moves-app.com.com/oauth2/v1/user/profile"
if user_data_url:
httpretty.register_uri(
httpretty.GET, user_data_url, body=json.dumps({"userId": "1010101010011"}), content_type="application/json"
)
yield
httpretty.disable()
httpretty.reset()
def tearDown(self):
""" Tear down test.
"""
httpretty.disable()
httpretty.reset()
if os.path.exists('output_test'):
shutil.rmtree('output_test')
def test_query_api_timeout_connection_error(monkeypatch, request, app, timeout):
"""Test if API is unresponsive.
Asserting line number of: response = requests.get(url, headers=headers, timeout=timeout)
:param monkeypatch: pytest fixture.
:param request: pytest fixture.
:param app: conftest fixture.
:param bool timeout: Test timeout instead of connection error.
"""
# Listen on a random port.
httpretty.disable()
server = socket.socket()
server.bind(('127.0.0.1', 0))
server.listen(1)
api_url = 'https://%s/{type}/{id}' % '{}:{}'.format(*server.getsockname())
if timeout:
request.addfinalizer(lambda: server.close())
else:
server.close() # Opened just to get unused port number.
monkeypatch.setattr('sphinxcontrib.imgur.imgur_api.API_URL', api_url)
# Test.
with pytest.raises(APIError):
query_api(app, 'client_id', 'imgur_id', False)
# Verify log.
if timeout:
assert app.messages[-1][1].startswith('timed out waiting for reply from http')
else:
assert app.messages[-1][1].startswith('unable to connect to http')
assert re.search(r'sphinxcontrib[/\\]imgur[/\\]imgur_api\.pyc?:51', app.messages[-1][2])
def callback(http_request, uri, headers):
httpretty.disable()
response = testypie.get_response(uri, http_request.headers)
headers.update({key.lower(): value for key, value in
response['headers'].iteritems()})
httpretty.enable()
return response['code'], headers, response['body'].encode('utf-8')
def patch_get():
httpretty.enable()
yield partial(httpretty.register_uri, httpretty.GET)
httpretty.disable()
httpretty.reset()
def tearDown(self):
httpretty.disable()
super(TestImageCache, self).tearDown()
def tearDown(self):
httpretty.disable()
self.processor.cleanup()
def tearDown(self):
httpretty.disable()
httpretty.reset()
def tearDown(self):
super().tearDown()
URLLibInstrumentor().uninstrument()
httpretty.disable()
def test_upsert_dataset_nama_10_fcs(self):
# nosetests -s -v dlstats.tests.fetchers.test_eurostat:FetcherTestCase.test_upsert_dataset_nama_10_fcs
httpretty.enable()
dataset_code = "nama_10_fcs"
self.DATASETS[dataset_code]["DSD"].update(
LOCAL_DATASETS_UPDATE[dataset_code])
self._load_files_datatree(TOC_FP)
self._load_files(dataset_code)
self.assertProvider()
self.assertDataset(dataset_code)
self.assertSeries(dataset_code)
'''Reload upsert_dataset for normal fail'''
with self.assertRaises(RejectUpdatedDataset) as err:
self.fetcher.upsert_dataset(dataset_code)
self.assertEqual(err.exception.comments,
"update-date[2015-10-26 00:00:00]")
'''Verify last_update in category for this dataset'''
category = Categories.search_category_for_dataset(
self.fetcher.provider_name, dataset_code, self.db)
self.assertIsNotNone(category)
last_update = None
for d in category["datasets"]:
if d["dataset_code"] == dataset_code:
last_update = d["last_update"]
self.assertIsNotNone(last_update)
self.assertEqual(str(last_update), "2015-10-26 00:00:00")
last_update = None
httpretty.reset()
httpretty.disable()
httpretty.enable()
self._load_files(dataset_code)
'''Change last_update in catalog.xml for force update dataset'''
with open(TOC_FP, 'rb') as fp:
toc = fp.read()
self.assertFalse(b'27.10.2015' in toc)
toc = toc.replace(b'26.10.2015', b'27.10.2015')
self.assertTrue(b'27.10.2015' in toc)
self._load_files_datatree(toc=toc)
self.fetcher.provider.metadata["creation_date"] = datetime.datetime(
1900, 1, 1)
results = self.fetcher.upsert_data_tree(force_update=True)
self.assertIsNotNone(results)
self.fetcher.get_selected_datasets(force=True)
query = {
'provider_name': self.fetcher.provider_name,
"dataset_code": dataset_code
}
_id = self.db[constants.COL_SERIES].find_one()["_id"]
deleted = self.db[constants.COL_SERIES].delete_one({"_id": _id})
self.assertEqual(deleted.deleted_count, 1)
dataset_settings = self.fetcher.selected_datasets[dataset_code]
self.assertEqual(dataset_settings["last_update"],
datetime.datetime(2015, 10, 27, 0, 0))
result = self.fetcher.upsert_dataset(dataset_code)
self.assertIsNotNone(result) #_id du dataset
dataset = self.db[constants.COL_DATASETS].find_one(query)
self.assertIsNotNone(dataset)
self.assertEqual(dataset["last_update"],
datetime.datetime(2015, 10, 27, 0, 0))
#self.assertEqual(dataset["download_last"],
# datetime.datetime(2015, 10, 27, 0, 0))
httpretty.disable()
def tearDown(self):
super(UserTests, self).tearDown()
httpretty.disable()
httpretty.reset()
def tearDown(self):
self.w3afcore.quit()
self.kb.cleanup()
if self.MOCK_RESPONSES:
httpretty.disable()
def i_should_see_a_200_status_code_from_the_search_page(step):
httpretty.disable()
httpretty.reset()
assert_equal(world.response_status_code, world.expected)
def httpretty_enabled():
httpretty.HTTPretty.allow_net_connect = False
httpretty.enable()
yield
httpretty.disable()
def i_should_see_the_fake_content_i_created_in_the_response(step):
httpretty.disable()
httpretty.reset()
assert_in('Hop on Pop', world.response_content)
def tearDown(self):
super(ProgramsApiClientTests, self).tearDown()
httpretty.disable()
httpretty.reset()
