class GetLinkTestCase(TestCase):
def setUp(self):
self.url = '/'
self.session = Session()
self.schema = Schema(
self.url, raw_schema=deepcopy(SCHEMA), session=self.session)
def test_returns_link_by_rel(self):
link = self.schema.get_link('create')
self.assertEqual(link, SCHEMA['links'][0])
def test_returns_none_for_missing_link(self):
link = self.schema.get_link('missing')
self.assertIs(link, None)
class GetLinkTestCase(TestCase):
def setUp(self):
self.url = '/'
self.session = Session()
self.schema = Schema(self.url,
raw_schema=deepcopy(SCHEMA),
session=self.session)
def test_returns_link_by_rel(self):
link = self.schema.get_link('create')
self.assertEqual(link, SCHEMA['links'][0])
def test_returns_none_for_missing_link(self):
link = self.schema.get_link('missing')
self.assertIs(link, None)
def setUp(self):
raw_schema = {
'links': [
{
'rel': 'item',
'href': '/root/{id}',
},
{
'rel': 'related',
'href': '/root/{slug}/{related}',
},
{
'rel': 'create',
'href': '/root',
'method': 'post',
},
{
'rel': 'list',
'href': '/root',
}
]
}
data = {'id': '123', 'slug': 'slug'}
self.session = Session()
self.schema = Schema('/schema', raw_schema, session=self.session)
self.resource = Resource.from_data(
'http://much.url.com/',
data=data, schema=self.schema, session=self.session
)
self.request_patcher = patch.object(self.session, 'request')
self.request = self.request_patcher.start()
def setUp(self):
self.session = Session()
self.url = 'http://app.com/myschema'
self.schema = Schema(self.url,
raw_schema=deepcopy(SCHEMA),
session=self.session)
def test_add_unit(self, put, get):
resource_data = {
"name": "app1",
"units": [
{
"Ip": "10.10.10.10"
},
{
"Ip": "9.9.9.9"
},
],
}
schema = Schema("",
type="object",
properties={"units": {
"type": "array",
"items": {},
}})
resource = Resource(url="url.com", data=resource_data, schema=schema)
get.return_value = resource
data = {"units": '10'}
request = RequestFactory().post("/", data)
request.session = {"tsuru_token": "admin"}
ChangeUnit.as_view()(request, app_name="app_name")
put.assert_called_with('{0}/apps/app_name/units'.format(
settings.TSURU_HOST),
data='8',
headers={'authorization': 'admin'})
def setUp(self):
super(ParseResourceTestCase, self).setUp()
self.item_schema = {
'type':
'object',
'properties': {
'id': {
'type': 'integer'
}
},
'links': [{
"href": "http://localhost/foos/{id}/",
"method": "GET",
"rel": "item",
}]
}
self.raw_schema = {
'title': "title",
'type': "object",
'properties': {
u'objects': {
u'type': u'array',
u'items': self.item_schema,
},
u'values': {
u'type': u'array'
}
}
}
self.schema = Schema(href="url.com",
raw_schema=self.raw_schema,
session=self.session)
def test_redirect_to_the_app_detail_page(self, get):
resource_data = {
"name": "app1",
"units": [
{
"Ip": "10.10.10.10"
},
{
"Ip": "9.9.9.9"
},
],
}
schema = Schema("",
type="object",
properties={"units": {
"type": "array",
"items": {},
}})
resource = Resource(url="url.com", data=resource_data, schema=schema)
get.return_value = resource
data = {"units": '2'}
request = RequestFactory().post("/", data)
request.session = {"tsuru_token": "admin"}
response = ChangeUnit.as_view()(request, app_name="app_name")
self.assertEqual(302, response.status_code)
self.assertEqual("/apps/app_name/", response.items()[1][1])
def setUp(self):
super(FromResponseTestCase, self).setUp()
self._response = Mock()
self._response.url = 'http://example.com'
content_type = 'application/json; profile=http://example.com/schema'
self._response.headers = {'content-type': content_type}
self.schema = Schema('/', raw_schema={}, session=self.session)
def test_uses_original_ref_on_representation(self):
raw_schema = {
'properties': {
'inner': {
'$ref': '/schema'
},
}
}
session = Session()
schema = Schema('/schema', raw_schema=raw_schema, session=session)
self.assertEqual(repr(schema), repr(raw_schema))
def setUp(self):
raw_schema = {
'links': [
{
'rel': 'item',
'href': '/root/{id}',
},
{
'rel': 'related',
'href': '/root/{slug}/{related}',
},
{
'rel': 'create',
'href': '/root',
'method': 'POST',
},
{
'rel': 'list',
'href': '/root',
}
]
}
self.data = {'id': '123',
'slug': 'slug',
'items': [{"ide": 1},
{"ida": 2}]}
self.session = Session()
self.schema = Schema('/schema', raw_schema, session=self.session)
self.response = Mock()
self.response.url = 'http://example.com'
self.profile_url = 'http://example.com/schema'
content_type = 'application/json; profile=%s' % (self.profile_url)
self.response.headers = {
'content-type': content_type
}
self.resource = Resource.from_data(
'http://much.url.com/',
data=deepcopy(self.data), schema=self.schema, session=self.session
)
self.resource2 = Resource.from_data(
'http://much.url.com/',
data=deepcopy(self.data), schema=self.schema,
session=self.session, response=self.response
)
self.request_patcher = patch.object(self.session, 'request')
self.request = self.request_patcher.start()
def setUp(self, get, requests_mock):
request = RequestFactory().get("/")
request.session = {"tsuru_token": "admin"}
self.expected = {
"name": "app1",
"framework": "php",
"repository": "[email protected]:php.git",
"state": "dead",
"units": [
{"Ip": "10.10.10.10"},
{"Ip": "9.9.9.9"}
],
"teams": ["tsuruteam", "crane"]
}
schema = Schema(
"",
type="object",
properties={
"units":
{
"type": "array",
"items": {},
},
"teams":
{
"type": "array",
"items": {},
}
}
)
resource = Resource(
url="url.com",
data=self.expected,
schema=schema
)
get.return_value = resource
json_mock = mock.Mock()
json_mock.json.return_value = self.expected
requests_mock.return_value = json_mock
service_list_mock = mock.Mock()
service_list_mock.return_value = [{"service": "mongodb",
"instances": ["mymongo"]}]
service_info_mock = mock.Mock()
service_info_mock.return_value = {"Name": "mymongo",
"ServiceName": "mongodb",
"Apps": ["app1"]}
self.old_service_list = AppDetail.service_list
AppDetail.service_list = service_list_mock
self.old_service_info = AppDetail.service_info
AppDetail.service_info = service_info_mock
self.response = AppDetail.as_view()(request, app_name="app1")
self.request = request
def test_resource_with_an_array_without_schema(self):
data = {
u'units': [{
u'name': u'someunit'
}],
u'name': u'registry',
}
s = Schema(href='url',
raw_schema={
'title': 'app schema',
'type': 'object',
'required': ['name'],
'properties': {
'name': {
'type': 'string'
}
}
},
session=self.session)
response = self.resource_from_data("url", data, s)
self.assertDictEqual(data, response.data)
def parse_data(self):
if isinstance(self.data, dict):
for key, value in self.data.items():
if isinstance(value, list):
data_items = []
for item in value:
try:
prop_items = self.schema.properties[key]['items']
except KeyError:
break
if "$ref" in prop_items:
s = schema.get(prop_items['$ref'], self.auth)
else:
s = Schema(self.url, **prop_items)
data_items.append(
Resource(
self.url,
data=item,
schema=s,
))
self.data[key] = data_items
def setUp(self):
super(ResourceTestCase, self).setUp()
self.data = {
"name": "repos",
"platform": "js",
}
self.raw_schema = {
'type':
"object",
'required': ["platform"],
'title':
"some title",
'properties': {
u'name': {
u'type': u'string'
},
u'platform': {
u'type': u'string'
}
},
'links': [{
"href": "/apps/{name}/log",
"method": "GET",
"rel": "log"
}, {
"href": "/apps/{name}/env",
"method": "GET",
"rel": "env"
}]
}
self.schema = Schema(href="url.com",
raw_schema=self.raw_schema,
session=self.session)
self.url = "http://app.com/content"
self.result = self.resource_from_data(url=self.url,
data=self.data,
schema=self.schema)
def create_schema(self, href):
schema = deepcopy(SCHEMA)
return Schema(href, raw_schema=schema, session=self.session)
def schema(self, url, **kwargs):
data = self.request(url, **kwargs).json()
return Schema(url, raw_schema=data, session=self)
def item_schema(self, key):
href = '#/{0}'.format(self.SCHEMA_PREFIX)
return Schema(href, raw_schema=self.schema, session=self.session)
def setUp(self):
self.url = '/'
self.session = Session()
self.schema = Schema(
self.url, raw_schema=deepcopy(SCHEMA), session=self.session)
def create_schema(self, url, session=None):
if session is None:
session = self.session
return Schema(self.SCHEMA_URL, raw_schema={}, session=session)
def setUp(self):
self.url = '/'
self.session = Session()
self.schema = Schema(self.url,
raw_schema=deepcopy(SCHEMA),
session=self.session)
