def test_patch_saved_query_none_fields(mocked_url, mocked_rw_apikey, mocked_account_resource_id,
capsys):
test_saved_query_id = str(uuid.uuid4())
mocked_url.return_value = '', MOCK_API_URL
mocked_rw_apikey.return_value = str(uuid.uuid4())
mocked_account_resource_id.return_value = str(uuid.uuid4())
httpretty.register_uri(httpretty.PATCH, MOCK_API_URL, status=200,
content_type='application/json',
body=json.dumps({"saved_query": SAVED_QUERY_RESPONSE}))
api.update_saved_query(test_saved_query_id, name=None,
statement="new_statement")
out, err = capsys.readouterr()
assert "Saved query with id %s updated" % test_saved_query_id in out
body = json.loads(httpretty.last_request().body)['saved_query']
assert "name" not in body
assert "statement" in body['leql']
python类last_request()的实例源码
def test_disable_api_key(mocked_url, mocked_owner_apikey, mocked_owner_apikey_id,
mocked_account_resource_id, capsys):
api_key_id = str(uuid.uuid4())
mocked_url.return_value = '', MOCK_API_URL
mocked_owner_apikey.return_value = str(uuid.uuid4())
mocked_owner_apikey_id.return_value = str(uuid.uuid4())
mocked_account_resource_id.return_value = str(uuid.uuid4())
httpretty.register_uri(httpretty.PATCH, MOCK_API_URL,
status=200,
content_type='application/json',
body=json.dumps({}))
api.update(api_key_id, False)
out, err = capsys.readouterr()
assert {'apikey': {'active': False}} == json.loads(httpretty.last_request().body)
assert not err
assert 'Disabled api key with id: %s' % api_key_id in out
def test_enable_api_key(mocked_url, mocked_owner_apikey, mocked_owner_apikey_id,
mocked_account_resource_id, capsys):
api_key_id = str(uuid.uuid4())
mocked_url.return_value = '', MOCK_API_URL
mocked_owner_apikey.return_value = str(uuid.uuid4())
mocked_owner_apikey_id.return_value = str(uuid.uuid4())
mocked_account_resource_id.return_value = str(uuid.uuid4())
httpretty.register_uri(httpretty.PATCH, MOCK_API_URL,
status=200,
content_type='application/json',
body=json.dumps({}))
api.update(api_key_id, True)
out, err = capsys.readouterr()
assert {'apikey': {'active': True}} == json.loads(httpretty.last_request().body)
assert not err
assert 'Enabled api key with id: %s' % api_key_id in out
def testCanDeleteOwnedDomain(self):
httpretty.enable()
httpretty.register_uri(httpretty.DELETE, settings.NSLORD_PDNS_API + '/zones/' + self.ownedDomains[1].name + '.')
httpretty.register_uri(httpretty.DELETE, settings.NSMASTER_PDNS_API + '/zones/' + self.ownedDomains[1].name+ '.')
url = reverse('domain-detail', args=(self.ownedDomains[1].pk,))
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(httpretty.last_request().method, 'DELETE')
self.assertEqual(httpretty.last_request().headers['Host'], 'nsmaster:8081')
httpretty.reset()
httpretty.register_uri(httpretty.DELETE, settings.NSLORD_PDNS_API + '/zones/' + self.ownedDomains[1].name + '.')
httpretty.register_uri(httpretty.DELETE, settings.NSMASTER_PDNS_API + '/zones/' + self.ownedDomains[1].name+ '.')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertTrue(isinstance(httpretty.last_request(), httpretty.core.HTTPrettyRequestEmpty))
def testCanDeleteOwnedDynDomain(self):
httpretty.enable()
httpretty.register_uri(httpretty.DELETE, settings.NSLORD_PDNS_API + '/zones/' + self.ownedDomains[1].name + '.')
httpretty.register_uri(httpretty.DELETE, settings.NSMASTER_PDNS_API + '/zones/' + self.ownedDomains[1].name + '.')
url = reverse('domain-detail', args=(self.ownedDomains[1].pk,))
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# FIXME In this testing scenario, the parent domain dedyn.io does not
# have the proper NS and DS records set up, so we cannot test their
# deletion.
httpretty.reset()
httpretty.register_uri(httpretty.DELETE, settings.NSLORD_PDNS_API + '/zones/' + self.ownedDomains[1].name + '.')
httpretty.register_uri(httpretty.DELETE, settings.NSMASTER_PDNS_API + '/zones/' + self.ownedDomains[1].name+ '.')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertTrue(isinstance(httpretty.last_request(), httpretty.core.HTTPrettyRequestEmpty))
def test_providing_res_with_url_calls_datapusher_correctly(self):
config['datapusher.url'] = 'http://datapusher.ckan.org'
httpretty.HTTPretty.register_uri(
httpretty.HTTPretty.POST,
'http://datapusher.ckan.org/job',
content_type='application/json',
body=json.dumps({'job_id': 'foo', 'job_key': 'bar'}))
package = model.Package.get('annakarenina')
tests.call_action_api(
self.app,
'datastore_create',
apikey=self.sysadmin_user.apikey,
resource=dict(package_id=package.id, url='demo.ckan.org')
)
assert len(package.resources) == 4, len(package.resources)
resource = package.resources[3]
data = json.loads(httpretty.last_request().body)
assert data['metadata']['resource_id'] == resource.id, data
assert not data['metadata'].get('ignore_hash'), data
assert data['result_url'].endswith('/action/datapusher_hook'), data
assert data['result_url'].startswith('http://'), data
def test_returns_latest_rates(self):
expected_response = {'base': 'EUR', 'date': '2016-04-29',
'rates': {'GBP': 0.78025}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio()
response = client.latest()
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
self.assertEqual(request.path, self.path)
self.assertEqual(request.querystring, {})
self.assertEqual(request.body, b'')
def test_returns_latest_rates_for_base_passed_in_constructor(self):
base = 'USD'
expected_response = {'base': base, 'date': '2016-05-13',
'rates': {'GBP': 0.69403}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(base=base)
response = client.latest()
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
params = urlencode({'base': base})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'base': [base]})
self.assertEqual(request.body, b'')
def test_returns_latest_rates_for_base_passed_in_method(self):
base = 'USD'
expected_response = {'base': base, 'date': '2016-05-13',
'rates': {'GBP': 0.69403}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio()
response = client.latest(base=base)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
params = urlencode({'base': base})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'base': [base]})
self.assertEqual(request.body, b'')
def test_returns_latest_rates_for_base_passed_in_method_if_both(self):
base = 'USD'
another_base = 'EUR'
expected_response = {'base': base, 'date': '2016-05-13',
'rates': {'GBP': 0.69403}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(base=another_base)
response = client.latest(base=base)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
params = urlencode({'base': base})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'base': [base]})
self.assertEqual(request.body, b'')
def test_returns_latest_rates_for_symbols_passed_in_constructor(self):
symbols = ['USD', 'GBP']
expected_response = {
"base": "EUR",
"date": "2016-05-19",
"rates": {"GBP": 0.76585, "USD": 1.1197}
}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(symbols=symbols)
response = client.latest()
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
symbols_str = ','.join(symbols)
params = urlencode({'symbols': symbols_str})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'symbols': [symbols_str]})
self.assertEqual(request.body, b'')
def test_returns_latest_rates_for_symbols_passed_in_method_if_both(self):
symbols = ['USD', 'GBP']
other_symbols = ['JPY', 'EUR']
expected_response = {
"base": "EUR",
"date": "2016-05-19",
"rates": {"GBP": 0.76585, "USD": 1.1197}
}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(symbols=other_symbols)
response = client.latest(symbols=symbols)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
symbols_str = ','.join(symbols)
params = urlencode({'symbols': symbols_str})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'symbols': [symbols_str]})
self.assertEqual(request.body, b'')
def test_returns_latest_rates_for_secure_passed_in_constructor(self):
expected_response = {'base': 'EUR', 'date': '2016-04-29',
'rates': {'GBP': 0.78025}}
httpretty.register_uri(httpretty.GET,
self.secure_url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(secure=True)
response = client.latest()
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
self.assertEqual(request.path, self.path)
self.assertEqual(request.querystring, {})
self.assertEqual(request.body, b'')
def test_returns_latest_rates_for_secure_passed_in_method(self):
expected_response = {'base': 'EUR', 'date': '2016-04-29',
'rates': {'GBP': 0.78025}}
httpretty.register_uri(httpretty.GET,
self.secure_url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio()
response = client.latest(secure=True)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
self.assertEqual(request.path, self.path)
self.assertEqual(request.querystring, {})
self.assertEqual(request.body, b'')
def test_returns_latest_rates_for_secure_passed_in_method_if_both(self):
expected_response = {'base': 'EUR', 'date': '2016-04-29',
'rates': {'GBP': 0.78025}}
httpretty.register_uri(httpretty.GET,
self.secure_url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(secure=False)
response = client.latest(secure=True)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
self.assertEqual(request.path, self.path)
self.assertEqual(request.querystring, {})
self.assertEqual(request.body, b'')
def test_returns_historical_rates_for_base_passed_in_method(self):
base = 'USD'
expected_response = {'base': base, 'date': '2016-05-13',
'rates': {'GBP': 0.69403}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio()
response = client.historical_rates(date=self.date, base=base)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
params = urlencode({'base': base})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'base': [base]})
self.assertEqual(request.body, b'')
def test_returns_historical_rates_for_base_passed_if_both(self):
base = 'USD'
another_base = 'EUR'
expected_response = {'base': base, 'date': '2016-05-13',
'rates': {'GBP': 0.69403}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(base=another_base)
response = client.historical_rates(date=self.date, base=base)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
params = urlencode({'base': base})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'base': [base]})
self.assertEqual(request.body, b'')
def test_returns_historical_rates_for_symbols_passed_in_constructor(self):
symbols = ['USD', 'GBP']
expected_response = {"base": "EUR",
"date": "2000-01-03",
"rates": {"GBP": 0.6246, "USD": 1.009}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(symbols=symbols)
response = client.historical_rates(date=self.date)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
symbols_str = ','.join(symbols)
params = urlencode({'symbols': symbols_str})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'symbols': [symbols_str]})
self.assertEqual(request.body, b'')
def test_returns_historical_rates_for_symbols_passed_in_method(self):
symbols = ['USD', 'GBP']
expected_response = {"base": "EUR",
"date": "2000-01-03",
"rates": {"GBP": 0.6246, "USD": 1.009}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio()
response = client.historical_rates(date=self.date, symbols=symbols)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
symbols_str = ','.join(symbols)
params = urlencode({'symbols': symbols_str})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'symbols': [symbols_str]})
self.assertEqual(request.body, b'')
def test_returns_historical_rates_for_symbols_passed_if_both(self):
symbols = ['USD', 'GBP']
other_symbols = ['JPY', 'EUR']
expected_response = {"base": "EUR",
"date": "2000-01-03",
"rates": {"GBP": 0.6246, "USD": 1.009}}
httpretty.register_uri(httpretty.GET,
self.url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(symbols=other_symbols)
response = client.historical_rates(date=self.date, symbols=symbols)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
symbols_str = ','.join(symbols)
params = urlencode({'symbols': symbols_str})
expected_path = '{url}?{params}'.format(url=self.path, params=params)
self.assertEqual(request.path, expected_path)
self.assertEqual(request.querystring, {'symbols': [symbols_str]})
self.assertEqual(request.body, b'')
def test_returns_historical_rates_for_secure_passed_in_method(self):
expected_response = {'base': 'EUR',
'date': '2000-01-03',
'rates': {'GBP': 0.6246}}
httpretty.register_uri(httpretty.GET,
self.secure_url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio()
response = client.historical_rates(date=self.date, secure=True)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
self.assertEqual(request.path, self.path)
self.assertEqual(request.querystring, {})
self.assertEqual(request.body, b'')
def test_returns_historical_rates_for_base_passed_if_both(self):
expected_response = {'base': 'EUR',
'date': '2000-01-03',
'rates': {'GBP': 0.6246}}
httpretty.register_uri(httpretty.GET,
self.secure_url,
body=json.dumps(expected_response),
content_type='application/json')
client = Fixerio(secure=False)
response = client.historical_rates(date=self.date, secure=True)
self.assertDictEqual(response, expected_response)
request = httpretty.last_request()
self.assertEqual(request.method, 'GET')
self.assertEqual(request.path, self.path)
self.assertEqual(request.querystring, {})
self.assertEqual(request.body, b'')
def test_get_doc_with_no_doc_name(self):
httpretty.register_uri(
httpretty.GET,
"http://example.com/api/resource/SomeDoc/",
body='{"data": { "f1": "v1","f2": "v2"}}',
content_type="application/json"
)
res = self.frappe.get_doc(
"SomeDoc",
filters=[["Note", "title", "LIKE", "S%"]],
fields=["name", "foo"])
self.assertEquals(res, {'f1': 'v1', 'f2': 'v2'})
request = httpretty.last_request()
url = urlparse.urlparse(request.path)
query_dict = urlparse.parse_qs(url.query)
self.assertEquals(query_dict['fields'],
[u'["name", "foo"]'])
self.assertEquals(query_dict['filters'],
[u'[["Note", "title", "LIKE", "S%"]]'])
def setup_http_server():
remote_identities = read_file(REMOTE_IDENTITIES_FILE)
http_requests = []
def request_callback(method, uri, headers):
last_request = httpretty.last_request()
if uri.startswith(REMOTE_IDENTITIES_FILE_URL):
body = remote_identities
http_requests.append(last_request)
return (200, headers, body)
httpretty.register_uri(httpretty.GET,
REMOTE_IDENTITIES_FILE_URL,
responses=[
httpretty.Response(body=request_callback)
])
return http_requests
def setup_http_server():
eclipse_projects = read_file(ECLIPSE_PROJECTS_FILE)
http_requests = []
def request_callback(method, uri, headers):
last_request = httpretty.last_request()
if uri.startswith(ECLIPSE_PROJECTS_URL):
body = eclipse_projects
http_requests.append(last_request)
return (200, headers, body)
httpretty.register_uri(httpretty.GET,
ECLIPSE_PROJECTS_URL,
responses=[
httpretty.Response(body=request_callback)
])
return http_requests
def it_should_post_the_correct_body(self):
expect(httpretty.last_request()).to(have_json([
{
"eventId": "foo",
"eventType": "settings",
"data":
{
"$userStreamAcl": {
"$r": ["bob"],
"$w": [],
"$d": [],
"$mr": [],
"$mw": []
},
"$systemStreamAcl": {
"$r": ["$admins"],
"$w": ["$admins"],
"$d": ["$admins"],
"$mr":[ "$admins"],
"$mw": ["$admins"]
}
}
}]))
def it_should_post_the_correct_body(self):
expect(httpretty.last_request()).to(have_json([
{
"eventId": "foo",
"eventType": "settings",
"data":
{
"$userStreamAcl": {
"$r": ["$all"],
"$w": ["$all"],
"$d": ["$all"],
"$mr": ["$all"],
"$mw": ["$all"]
},
"$systemStreamAcl": {
"$r": ["fred"],
"$w": ["fred"],
"$d": [],
"$mr":[],
"$mw": []
}
}
}]))
def it_should_post_the_correct_body(self):
expect(httpretty.last_request()).to(have_json([
{
"eventId": "foo",
"eventType": "settings",
"data":
{
"$userStreamAcl": {
"$r": ["$all", "giddy", "kevin"],
"$w": ["ouro"],
"$d": ["ouro"],
"$mr": ["ouro"],
"$mw": ["ouro"]
},
"$systemStreamAcl": {
"$r": ["$admins", "ouro"],
"$w": ["$admins"],
"$d": ["$admins"],
"$mr":["$admins"],
"$mw": ["$admins"]
}
}
}]))
def it_should_post_the_correct_body(self):
expect(httpretty.last_request()).to(have_json([
{
"eventId": "foo",
"eventType": "settings",
"data":
{
"$userStreamAcl": {
"$r": ["$all"],
"$w": [],
"$d": ["ouro"],
"$mr": ["ouro"],
"$mw": ["ouro"]
},
"$systemStreamAcl": {
"$r": ["$admins", "ouro"],
"$w": ["$admins"],
"$d": ["$admins"],
"$mr":["$admins"],
"$mw": ["$admins"]
}
}
}]))
def it_should_post_the_correct_body(self):
expect(httpretty.last_request()).to(have_json([
{
"eventId": "foo",
"eventType": "settings",
"data":
{
"$userStreamAcl": {
"$r": ["$all"],
"$w": ["ouro"],
"$d": ["ouro"],
"$mr": ["ouro"],
"$mw": ["ouro"]
},
"$systemStreamAcl": {
"$r": ["$admins", "ouro"],
"$w": ["$admins", "giddy", "kevin"],
"$d": ["$admins"],
"$mr":["$admins"],
"$mw": ["$admins"]
}
}
}]))
