Fix sending locale

3 files changed, 82 insertions, 140 deletions

diff --git a/sugar_network/toolkit/http.py b/sugar_network/toolkit/http.py
index d0fbd16..37a5388 100644
--- a/sugar_network/toolkit/http.py
+++ b/sugar_network/toolkit/http.py
@@ -58,14 +58,12 @@ class Client(object):
         elif local.certfile.value:
             verify = local.certfile.value
 
-        headers = {'Accept-Language': ','.join(ad.default_lang())}
+        headers = {'Accept-Language': ad.default_lang()}
         if self._sugar_auth:
             uid = sugar.uid()
             key_path = sugar.profile_path('owner.key')
-            headers = {
-                    'sugar_user': uid,
-                    'sugar_user_signature': _sign(key_path, uid),
-                    }
+            headers['sugar_user'] = uid
+            headers['sugar_user_signature'] = _sign(key_path, uid)
 
         self._session = Session(headers=headers, verify=verify, prefetch=False)
 
diff --git a/tests/__init__.py b/tests/__init__.py
index 18a2750..edec1e0 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -267,54 +267,6 @@ class Test(unittest.TestCase):
             volume.close()
 
 
-class Request(object):
-
-    def __init__(self, url, uid=None, privkey=None, pubkey=None):
-        self.url = url
-        self.uid = uid or UID
-        self.privkey = privkey or PRIVKEY
-
-        #self.post('/user', {'uid': self.uid, 'pubkey': pubkey or PUBKEY})
-        self.post('/user', {'pubkey': pubkey or PUBKEY})
-
-    def get(self, path, **kwargs):
-        return self._request('GET', path, **kwargs)
-
-    def put(self, path, data, **kwargs):
-        return self._request('PUT', path, data, **kwargs)
-
-    def post(self, path, data, **kwargs):
-        return self._request('POST', path, data, **kwargs)
-
-    def delete(self, path, **kwargs):
-        return self._request('DELETE', path, **kwargs)
-
-    def _request(self, method, path, data=None, headers=None, **kwargs):
-        if not headers:
-            if data:
-                headers = {'Content-Type': 'application/json'}
-                data = json.dumps(data)
-            else:
-                headers = {}
-        headers['SUGAR_USER'] = self.uid
-        headers['SUGAR_USER_SIGNATURE'] = sign(self.privkey, self.uid)
-
-        response = requests.request(method, self.url + path, data=data,
-                headers=headers, config={'keep_alive': True}, params=kwargs)
-        reply = response.content
-
-        if response.status_code != 200:
-            if reply:
-                raise RuntimeError(reply)
-            else:
-                response.raise_for_status()
-
-        if response.headers.get('Content-Type') == 'application/json':
-            return json.loads(reply)
-        else:
-            return reply
-
-
 def sign(privkey, data):
     with tempfile.NamedTemporaryFile() as tmp_privkey:
         tmp_privkey.file.write(privkey)
diff --git a/tests/units/router.py b/tests/units/router.py
index 5c3facb..0b65ac3 100755
--- a/tests/units/router.py
+++ b/tests/units/router.py
@@ -12,9 +12,10 @@ from os.path import exists
 from __init__ import tests
 
 import active_document as ad
-from sugar_network import node
+from sugar_network import node, sugar, Client
 from sugar_network.toolkit.router import Router, _Request, _parse_accept_language, Unauthorized, route
 from active_toolkit import util
+from sugar_network.resources.user import User
 from sugar_network.resources.volume import Volume
 
 
@@ -22,31 +23,31 @@ class RouterTest(tests.Test):
 
     def test_Walkthrough(self):
         self.fork(self.restful_server, [User, Document])
-        rest = tests.Request('http://localhost:8800')
+        client = Client('http://localhost:8800', sugar_auth=True)
 
-        guid_1 = rest.post('/document', {'term': 'term', 'stored': 'stored'})
+        guid_1 = client.post(['document'], {'term': 'term', 'stored': 'stored'})
 
         self.assertEqual({
             'stored': 'stored',
             'term': 'term',
             'guid': guid_1,
             'layer': ['public'],
-            'user': [rest.uid],
+            'user': [sugar.uid()],
             },
-            rest.get('/document/' + guid_1, reply='stored,term,guid,layer,user'))
+            client.get(['document', guid_1], reply='stored,term,guid,layer,user'))
 
-        guid_2 = rest.post('/document', {'term': 'term2', 'stored': 'stored2'})
+        guid_2 = client.post(['document'], {'term': 'term2', 'stored': 'stored2'})
 
         self.assertEqual({
             'stored': 'stored2',
             'term': 'term2',
             'guid': guid_2,
             'layer': ['public'],
-            'user': [rest.uid],
+            'user': [sugar.uid()],
             },
-            rest.get('/document/' + guid_2, reply='stored,term,guid,layer,user'))
+            client.get(['document', guid_2], reply='stored,term,guid,layer,user'))
 
-        reply = rest.get('/document', reply='guid,stored,term')
+        reply = client.get(['document'], reply='guid,stored,term')
         self.assertEqual(2, reply['total'])
         self.assertEqual(
                 sorted([
@@ -55,16 +56,16 @@ class RouterTest(tests.Test):
                     ]),
                 sorted(reply['result']))
 
-        rest.put('/document/' + guid_2, {'stored': 'stored3', 'term': 'term3'})
+        client.put(['document', guid_2], {'stored': 'stored3', 'term': 'term3'})
 
         self.assertEqual({
             'stored': 'stored3',
             'term': 'term3',
             'guid': guid_2,
             'layer': ['public'],
-            'user': [rest.uid],
+            'user': [sugar.uid()],
             },
-            rest.get('/document/' + guid_2, reply='stored,term,guid,layer,user'))
+            client.get(['document', guid_2], reply='stored,term,guid,layer,user'))
 
         self.assertEqual(
                 {'total': 2,
@@ -72,37 +73,37 @@ class RouterTest(tests.Test):
                         {'guid': guid_1, 'stored': 'stored', 'term': 'term'},
                         {'guid': guid_2, 'stored': 'stored3', 'term': 'term3'},
                         ])},
-                rest.get('/document', reply='guid,stored,term'))
+                client.get(['document'], reply='guid,stored,term'))
 
-        rest.delete('/document/' + guid_1)
+        client.delete(['document', guid_1])
 
         self.assertEqual(
                 {'total': 1,
                     'result': sorted([
                         {'guid': guid_2, 'stored': 'stored3', 'term': 'term3'},
                         ])},
-                rest.get('/document', reply='guid,stored,term'))
+                client.get(['document'], reply='guid,stored,term'))
 
         self.assertEqual(
                 'term3',
-                rest.get('/document/' + guid_2 + '/term'))
-        rest.put('/document/' + guid_2 + '/term', 'term4')
+                client.get(['document', guid_2, 'term']))
+        client.put(['document', guid_2, 'term'], 'term4')
         self.assertEqual(
                 'term4',
-                rest.get('/document/' + guid_2 + '/term'))
+                client.get(['document', guid_2, 'term']))
 
         payload = 'blob'
-        rest.put('/document/' + guid_2 + '/blob', payload, headers={'Content-Type': 'application/octet-stream'})
+        client.put(['document', guid_2, 'blob'], payload)
         self.assertEqual(
                 payload,
-                rest.get('/document/' + guid_2 + '/blob'))
+                client.get(['document', guid_2, 'blob']).content)
 
-        rest.delete('/document/' + guid_2)
+        client.delete(['document', guid_2])
 
         self.assertEqual(
                 {'total': 0,
                     'result': sorted([])},
-                rest.get('/document', reply='guid,stored,term'))
+                client.get(['document'], reply='guid,stored,term'))
 
     def test_StreamedResponse(self):
 
@@ -156,23 +157,18 @@ class RouterTest(tests.Test):
     def test_Register(self):
         self.fork(self.restful_server, [User, Document])
 
-        self.assertRaises(RuntimeError, tests.Request, 'http://localhost:8800',
-                uid=tests.UID, privkey=tests.PRIVKEY,
-                pubkey=tests.INVALID_PUBKEY)
+        client = Client('http://localhost:8800', sugar_auth=False)
+        self.assertRaises(RuntimeError, client.post, ['document'], {'term': 'term', 'stored': 'stored'})
+        self.assertRaises(RuntimeError, client.get, ['user', sugar.uid()])
 
-        rest = tests.Request('http://localhost:8800',
-                uid=tests.UID, privkey=tests.PRIVKEY, pubkey=tests.PUBKEY)
-        self.assertEqual(
-                {'total': 1,
-                    'result': sorted([
-                        {'guid': tests.UID},
-                        ]),
-                    },
-                rest.get('/user'))
+        client = Client('http://localhost:8800', sugar_auth=True)
+        client.post(['document'], {'term': 'term', 'stored': 'stored'})
+        self.assertEqual(sugar.uid(), client.get(['user', sugar.uid(), 'guid']))
 
     def test_Authenticate(self):
-        pid = self.fork(self.restful_server, [User])
-        rest = tests.Request('http://localhost:8800')
+        pid = self.fork(self.restful_server, [User, Document])
+        client = Client('http://localhost:8800', sugar_auth=True)
+        client.post(['document'], {'term': 'term', 'stored': 'stored'})
         self.waitpid(pid)
 
         with Volume(tests.tmpdir + '/remote', [User]) as documents:
@@ -192,24 +188,14 @@ class RouterTest(tests.Test):
             user = router.authenticate(request)
             self.assertEqual(tests.UID, user)
 
-    def test_Authorization(self):
-        self.fork(self.restful_server, [User, Document])
-
-        rest_1 = tests.Request('http://localhost:8800')
-        guid = rest_1.post('/document', {'term': '', 'stored': ''})
-
-        rest_2 = tests.Request('http://localhost:8800', tests.UID2, tests.PRIVKEY2, tests.PUBKEY2)
-        self.assertRaises(RuntimeError, rest_2.put, '/document/' + guid, {'term': 'new'})
-        self.assertRaises(RuntimeError, rest_2.delete, '/document/' + guid)
-
     def test_UrlPath(self):
         self.fork(self.restful_server, [User, Document])
-        rest = tests.Request('http://localhost:8800')
+        client = Client('http://localhost:8800', sugar_auth=True)
 
-        guid = rest.post('///document//', {'term': 'probe'})
+        guid = client.post(['///document//'], {'term': 'probe'})
         self.assertEqual(
                 'probe',
-                rest.get('///document///%s///' % guid, reply='term').get('term'))
+                client.get(['///document///', '///' + guid + '////'], reply='term').get('term'))
 
     def test_HandleRedirects(self):
         URL = 'http://sugarlabs.org'
@@ -221,13 +207,10 @@ class RouterTest(tests.Test):
                 raise ad.Redirect(URL)
 
         self.fork(self.restful_server, [User, Document2])
-        rest = tests.Request('http://localhost:8800')
-
-        guid = rest.post('/document2', {'term': 'probe'})
-        rest.put('/document2/%s/blob' % guid, 'blob')
-
-        context = urllib2.urlopen(URL).read()
-        assert context == rest.get('/document2/%s/blob' % guid)
+        client = Client('http://localhost:8800', sugar_auth=True)
+        guid = client.post(['document2'], {'term': 'probe'})
+        content = urllib2.urlopen(URL).read()
+        assert content == client.get(['document2', guid, 'blob']).content
 
     def test_Request_MultipleQueryArguments(self):
         request = _Request({
@@ -297,6 +280,45 @@ class RouterTest(tests.Test):
         self.assertEqual(['route3'], calls)
         del calls[:]
 
+    def test_GetLocalizedProps(self):
+
+        class TestDocument(Document):
+
+            @ad.active_property(slot=100, localized=True)
+            def prop(self, value):
+                return value
+
+        self.fork(self.restful_server, [User, TestDocument])
+
+        self.override(ad, 'default_lang', lambda: 'en')
+        client = Client('http://localhost:8800', sugar_auth=True)
+        guid = client.post(['testdocument'], {'prop': 'en'})
+        self.assertEqual('en', client.get(['testdocument', guid, 'prop']))
+
+        self.override(ad, 'default_lang', lambda: 'ru')
+        client = Client('http://localhost:8800', sugar_auth=True)
+        self.assertEqual('en', client.get(['testdocument', guid, 'prop']))
+        client.put(['testdocument', guid, 'prop'], 'ru')
+        self.assertEqual('ru', client.get(['testdocument', guid, 'prop']))
+
+        self.override(ad, 'default_lang', lambda: 'es')
+        client = Client('http://localhost:8800', sugar_auth=True)
+        self.assertEqual('en', client.get(['testdocument', guid, 'prop']))
+        client.put(['testdocument', guid, 'prop'], 'es')
+        self.assertEqual('es', client.get(['testdocument', guid, 'prop']))
+
+        self.override(ad, 'default_lang', lambda: 'ru')
+        client = Client('http://localhost:8800', sugar_auth=True)
+        self.assertEqual('ru', client.get(['testdocument', guid, 'prop']))
+
+        self.override(ad, 'default_lang', lambda: 'en')
+        client = Client('http://localhost:8800', sugar_auth=True)
+        self.assertEqual('en', client.get(['testdocument', guid, 'prop']))
+
+        self.override(ad, 'default_lang', lambda: 'foo')
+        client = Client('http://localhost:8800', sugar_auth=True)
+        self.assertEqual('en', client.get(['testdocument', guid, 'prop']))
+
 
 class Document(ad.Document):
 
@@ -309,7 +331,7 @@ class Document(ad.Document):
     def layer(self, value):
         return value
 
-    @ad.active_property(slot=1, prefix='A', full_text=True)
+    @ad.active_property(slot=1, prefix='A', full_text=True, default='')
     def term(self, value):
         return value
 
@@ -326,35 +348,5 @@ class Document(ad.Document):
         return value
 
 
-class User(ad.Document):
-
-    @ad.active_property(prefix='L', typecast=[], default=['public'])
-    def layer(self, value):
-        return value
-
-    @ad.active_property(ad.StoredProperty)
-    def pubkey(self, value):
-        return value
-
-    @ad.active_property(ad.StoredProperty, default='')
-    def name(self, value):
-        return value
-
-    @classmethod
-    def before_create(cls, props):
-        ssh_pubkey = props['pubkey'].split()[1]
-        props['guid'] = str(hashlib.sha1(ssh_pubkey).hexdigest())
-
-        with tempfile.NamedTemporaryFile() as tmp_pubkey:
-            tmp_pubkey.file.write(props['pubkey'])
-            tmp_pubkey.file.flush()
-
-            pubkey_pkcs8 = util.assert_call(
-                    ['ssh-keygen', '-f', tmp_pubkey.name, '-e', '-m', 'PKCS8'])
-            props['pubkey'] = pubkey_pkcs8
-
-        super(User, cls).before_create(props)
-
-
 if __name__ == '__main__':
     tests.main()