X-Git-Url: https://vcs.fsf.org/?a=blobdiff_plain;f=tests.py;h=60ddd5e7084f95f81b196bd3b78581faa8dd81cc;hb=f50cbea31f915755413c7b2b8f30def77489ed7f;hp=f81538ffb38ebc66207c35fc5d37b6fe18aaddee;hpb=f2ff648397bf0e9f6df541377daf2892ffe80738;p=diaspy.git

diff --git a/tests.py b/tests.py
index f81538f..60ddd5e 100644
--- a/tests.py
+++ b/tests.py
@@ -3,13 +3,17 @@
 import unittest
 
 #   failure to import any of the modules below indicates failed tests
+#   =================================================================
 #   modules used by diaspy
-import requests
 import re
+import requests
+import warnings
 #   actual diaspy code
 import diaspy
+from diaspy import client as dclient
 
 
+####    SETUP STUFF
 ####    test suite configuration variables: can be adjusted to your liking
 import testconf
 __pod__ = testconf.__pod__
@@ -17,43 +21,243 @@ __username__ = testconf.__username__
 __passwd__ = testconf.__passwd__
 
 
-class ConnectionTest(unittest.TestCase):
-    def testLoginWithoutUsername(self):
-        connection = diaspy.connection.Connection(pod=__pod__)
-        self.assertRaises(diaspy.connection.LoginError, connection.login, password='foo')
+# Test counter
+try:
+    test_count_file = open('TEST_COUNT', 'r')
+    test_count = int(test_count_file.read())
+    test_count_file.close()
+except (IOError, ValueError):
+    test_count = 0
+finally:
+    test_count += 1
+test_count_file = open('TEST_COUNT', 'w')
+test_count_file.write(str(test_count))
+test_count_file.close()
+print('Running test no. {0}'.format(test_count))
+
+print('Running tests on connection: "{0}:{1}@{2}"\t'.format(testconf.__username__, '*'*len(testconf.__passwd__), __pod__), end='')
+test_connection = diaspy.connection.Connection(pod=__pod__, username=__username__, password=__passwd__)
+test_connection.login()
+print('[ CONNECTED ]\n')
+
+# Setup test aspects
+print('Adding test aspects...\t', end='')
+diaspy.streams.Aspects(test_connection).add(testconf.test_aspect_name_fake)
+testconf.test_aspect_id = diaspy.streams.Aspects(test_connection).add(testconf.test_aspect_name).id
+print('OK')
+
+print([i['name'] for i in test_connection.getUserInfo()['aspects']])
 
-    def testLoginWithoutPassword(self):
-        connection = diaspy.connection.Connection(pod=__pod__)
-        self.assertRaises(diaspy.connection.LoginError, connection.login, username='user')
 
-class ClientTests(unittest.TestCase):
+post_text = '#diaspy test no. {0}'.format(test_count)
+
+
+#######################################
+####        TEST SUITE CODE        ####
+#######################################
+class ConnectionTest(unittest.TestCase):
     def testGettingUserInfo(self):
-        client = diaspy.client.Client(__pod__, __username__, __passwd__)
-        info = client.get_user_info()
+        info = test_connection.getUserInfo()
         self.assertEqual(dict, type(info))
 
-    def testGettingStream(self):
-        client = diaspy.client.Client(__pod__, __username__, __passwd__)
-        stream = client.get_stream()
-        self.assertEqual(list, type(stream))
-        if stream: self.assertEqual(diaspy.models.Post, type(stream[0]))
 
-    def testGettingNotifications(self):
-        client = diaspy.client.Client(__pod__, __username__, __passwd__)
-        notifications = client.get_notifications()
-        self.assertEqual(list, type(notifications))
-        if notifications: self.assertEqual(dict, type(notifications[0]))
+class MessagesTests(unittest.TestCase):
+    def testGettingMailbox(self):
+        mailbox = diaspy.messages.Mailbox(test_connection)
+        if mailbox: 
+            for i in range(len(mailbox)):
+                self.assertEqual(diaspy.models.Conversation, type(mailbox[i]))
 
-    def testGettingTag(self):
-        client = diaspy.client.Client(pod=__pod__, username=__username__, password=__passwd__)
-        tag = client.get_tag('foo')
-        self.assertEqual(list, type(tag))
-        if tag: self.assertEqual(diaspy.models.Post, type(tag[0]))
 
-    def testGettingMailbox(self):
-        client = diaspy.client.Client(pod=__pod__, username=__username__, password=__passwd__)
-        mailbox = client.get_mailbox()
-        self.assertEqual(list, type(mailbox))
-        self.assertEqual(diaspy.conversations.Conversation, type(mailbox[0]))
+class AspectsTests(unittest.TestCase):
+    def testAspectsGettingID(self):
+        aspects = diaspy.streams.Aspects(test_connection)
+        id = aspects.getAspectID(testconf.test_aspect_name)
+        self.assertEqual(testconf.test_aspect_id, id)
+
+    def testAspectsRemoveById(self):
+        aspects = diaspy.streams.Aspects(test_connection)
+        for i in test_connection.getUserInfo()['aspects']:
+            if i['name'] == testconf.test_aspect_name:
+                print(i['id'], end=' ')
+                aspects.remove(id=i['id'])
+                break
+        names = [i['name'] for i in test_connection.getUserInfo()['aspects']]
+        print(names)
+        self.assertNotIn(testconf.test_aspect_name, names)
+
+    def testAspectsRemoveByName(self):
+        aspects = diaspy.streams.Aspects(test_connection)
+        print(testconf.test_aspect_name_fake, end=' ')
+        aspects.remove(name=testconf.test_aspect_name_fake)
+        names = [i['name'] for i in test_connection.getUserInfo()['aspects']]
+        print(names)
+        self.assertNotIn(testconf.test_aspect_name_fake, names)
+
+
+class StreamTest(unittest.TestCase):
+    def testGetting(self):
+        stream = diaspy.streams.Generic(test_connection)
+
+    def testGettingLength(self):
+        stream = diaspy.streams.Generic(test_connection)
+        len(stream)
+
+    def testClearing(self):
+        stream = diaspy.streams.Stream(test_connection)
+        stream.clear()
+        self.assertEqual(0, len(stream))
+
+    def testPurging(self):
+        stream = diaspy.streams.Stream(test_connection)
+        post = stream.post('#diaspy test')
+        stream.update()
+        post.delete()
+        stream.purge()
+        self.assertNotIn(post.id, [p.id for p in stream])
+
+    def testPostingText(self):
+        stream = diaspy.streams.Stream(test_connection)
+        post = stream.post(post_text)
+        self.assertEqual(diaspy.models.Post, type(post))
+    
+    def testPostingImage(self):
+        stream = diaspy.streams.Stream(test_connection)
+        try:
+            stream.post(text=post_text, photo='test-image.png')
+        except (diaspy.errors.StreamError) as e:
+            warnings.warn('{0}')
+        finally:
+            pass
+
+    def testingAddingTag(self):
+        ft = diaspy.streams.FollowedTags(test_connection)
+        ft.add('test')
+
+    def testActivity(self):
+        activity = diaspy.streams.Activity(test_connection)
+
+    def testMentionsStream(self):
+        mentions = diaspy.streams.Mentions(test_connection)
+
+
+class UserTests(unittest.TestCase):
+    def testHandleSeparatorRaisingExceptions(self):
+        handles = ['user.pod.example.com',
+                   'user@podexamplecom',
+                   '@pod.example.com',
+                   'use r@pod.example.com',
+                   'user0@pod300 example.com',
+                   ]
+        for h in handles:
+            self.assertRaises(Exception, diaspy.people.sephandle, h)
+
+    def testGettingUserByHandleData(self):
+        user = diaspy.people.User(test_connection, handle=testconf.diaspora_id, fetch='data')
+        self.assertEqual(testconf.guid, user['guid'])
+        self.assertEqual(testconf.diaspora_id, user['handle'])
+        self.assertEqual(testconf.diaspora_name, user['name'])
+        self.assertEqual(type(user.stream), list)
+        self.assertEqual(user.stream, [])
+        self.assertIn('id', user.data)
+        self.assertIn('avatar', user.data)
+
+    def testGettingUserByHandlePosts(self):
+        user = diaspy.people.User(test_connection, handle=testconf.diaspora_id)
+        self.assertEqual(testconf.guid, user['guid'])
+        self.assertEqual(testconf.diaspora_id, user['handle'])
+        self.assertEqual(testconf.diaspora_name, user['name'])
+        self.assertIn('id', user.data)
+        self.assertIn('avatar', user.data)
+        self.assertEqual(type(user.stream), diaspy.streams.Outer)
+ 
+    def testGettingUserByGUID(self):
+        user = diaspy.people.User(test_connection, guid=testconf.guid)
+        self.assertEqual(testconf.diaspora_id, user['handle'])
+        self.assertEqual(testconf.diaspora_name, user['name'])
+        self.assertIn('id', user.data)
+        self.assertIn('avatar', user.data)
+        self.assertEqual(type(user.stream), diaspy.streams.Outer)
+
+
+class ContactsTest(unittest.TestCase):
+    def testGetOnlySharing(self):
+        contacts = diaspy.people.Contacts(test_connection)
+        result = contacts.get(set='only_sharing')
+        for i in result:
+            self.assertEqual(diaspy.people.User, type(i))
+
+    def testGetAll(self):
+        contacts = diaspy.people.Contacts(test_connection)
+        result = contacts.get(set='all')
+        for i in result:
+            self.assertEqual(diaspy.people.User, type(i))
+
+    def testGet(self):
+        contacts = diaspy.people.Contacts(test_connection)
+        result = contacts.get()
+        for i in result:
+            self.assertEqual(diaspy.people.User, type(i))
+
+
+class PostTests(unittest.TestCase):
+    def testStringConversion(self):
+        s = diaspy.streams.Stream(test_connection)
+
+    def testRepr(self):
+        s = diaspy.streams.Stream(test_connection)
+
+
+class NotificationsTests(unittest.TestCase):
+    def testMarkingRead(self):
+        notifications = diaspy.notifications.Notifications(test_connection)
+        notif = None
+        for n in notifications:
+            if n.unread:
+                notif = n
+                break
+        if notif is not None:
+            n.mark(unread=False)
+        else:
+            warnings.warn('test not sufficient: no unread notifications were found')
+
+
+class SettingsTests(unittest.TestCase):
+    profile = diaspy.settings.Profile(test_connection)
+    account = diaspy.settings.Account(test_connection)
+
+    def testGettingName(self):
+        self.assertEqual(testconf.user_names_tuple, self.profile.getName())
+
+    def testGettingLocation(self):
+        self.assertEqual(testconf.user_location_string, self.profile.getLocation())
+
+    def testGettingGender(self):
+        self.assertEqual(testconf.user_gender_string, self.profile.getGender())
+
+    def testGettingBirthDate(self):
+        self.assertEqual(testconf.user_date_of_birth, self.profile.getBirthDate(named_month=False))
+        self.assertEqual(testconf.user_date_of_birth_named, self.profile.getBirthDate(named_month=True))
+
+    def testGettingInfoIfProfileIsSearchable(self):
+        self.assertEqual(testconf.user_is_searchable, self.profile.isSearchable())
+
+    def testGettingInfoIfProfileIsNSFW(self):
+        self.assertEqual(testconf.user_is_nsfw, self.profile.isNSFW())
+
+    def testGettingTags(self):
+        self.assertEqual(sorted(testconf.user_tags), sorted(self.profile.getTags()))
+
+    def testGettingLanguages(self):
+        self.assertIn(('English', 'en'), self.account.getLanguages())
+
+    def testGettingEmail(self):
+        self.assertEqual(testconf.user_email, self.account.getEmail())
+
 
-if __name__ == '__main__': unittest.main()
+if __name__ == '__main__': 
+    print('Hello World!')
+    print('It\'s testing time!')
+    n = unittest.main()
+    print(n)
+    print('It was testing time!')