예제 #1
0
    def test_expansion(self):

        e = Expansion('foo', 'bar', 'baz')
        e.add_property('bar', limit=5)

        p = sorted(e.get_params().split(','))

        self.assertEqual(p, ['bar(limit:5)', 'baz', 'foo'])
예제 #2
0
    def test_expansion_limit_offset(self):
        e = Expansion()
        e.add_property('quux', limit=5, offset=10)

        p = e.get_params()

        self.assertTrue(p == 'quux(limit:5,offset:10)' or
            p == 'quux(offset:10,limit:5)')
예제 #3
0
    def test_expansion_limit_offset(self):
        e = Expansion()
        e.add_property('quux', limit=5, offset=10)

        p = e.get_params()

        self.assertTrue(p == 'quux(limit:5,offset:10)'
                        or p == 'quux(offset:10,limit:5)')
예제 #4
0
    def test_expansion(self):

        e = Expansion('foo', 'bar', 'baz')
        e.add_property('bar', limit=5)

        p = sorted(e.get_params().split(','))

        self.assertEqual(p, ['bar(limit:5)', 'baz', 'foo'])
예제 #5
0
    def test_resource_expansion(self):
        class Res(Resource):
            def get_resource_attributes(self):
                return {'related': Resource}

        ds = MagicMock()
        ds.get_resource.return_value = {
            'href': 'test/resource',
            'name': 'Test Resource',
            'related': {
                'href': 'related/resource',
                'name': 'Related Resource'
            }
        }

        r = Res(MagicMock(data_store=ds),
                href='test/resource',
                expand=Expansion('related'))

        name = r.name

        ds.get_resource.assert_called_once_with('test/resource',
                                                params={'expand': 'related'})

        self.assertEqual(name, 'Test Resource')
        self.assertEqual(r.related.name, 'Related Resource')
    def test_resource_to_json(self):
        ds = MagicMock()

        class Res(Resource, SaveMixin, DictMixin):
            writable_attrs = ('foo_val', 'bar', 'res')

        r = Res(MagicMock(data_store=ds), href='test/resource1')
        res = Res(MagicMock(data_store=ds), href='test/resource2')

        data = {'foo_val': True, 'bar': False}

        # basic resource
        r.update(data)
        r.bar = 'quux'
        data.update({'href': 'test/resource1', 'bar': 'quux'})
        self.assertEqual(data, json.loads(r.to_json()))

        # resource of resource if not extended
        res.foo_val = [1, 2, 3]
        r.res = res
        data.update({'res': {'href': 'test/resource2'}})
        self.assertEqual(data, json.loads(r.to_json()))

        # resource of resource if extended
        res.foo_val = [1, 2, 3]
        r.res = res
        r._expand = Expansion(*['res'])
        data.update({'res': {'foo_val': [1, 2, 3], 'href': 'test/resource2'}})
        self.assertEqual(data, json.loads(r.to_json()))
예제 #7
0
    def test_creation_with_expansion(self):
        ds = MagicMock()
        ds.create_resource.return_value = {
            'href': 'test/resource',
            'name': 'Test Resource',
        }

        rl = CollectionResource(
            client=MagicMock(data_store=ds,
                BASE_URL='http://www.example.com'),
            properties={
                'href': '/',
            })

        e = Expansion()
        e.add_property('bar', limit=5)

        rl.create({}, expand=e, some_param=True)

        ds.create_resource.assert_called_once_with('http://www.example.com/',
            {}, params={'someParam': True, 'expand': 'bar(limit:5)'})
예제 #8
0
    def test_creation_with_expansion(self):
        ds = MagicMock()
        ds.create_resource.return_value = {
            'href': 'test/resource',
            'name': 'Test Resource',
        }

        rl = CollectionResource(client=MagicMock(
            data_store=ds, BASE_URL='http://www.example.com'),
                                properties={
                                    'href': '/',
                                })

        e = Expansion()
        e.add_property('bar', limit=5)

        rl.create({}, expand=e, some_param=True)

        ds.create_resource.assert_called_once_with('http://www.example.com/',
                                                   {},
                                                   params={
                                                       'someParam': True,
                                                       'expand': 'bar(limit:5)'
                                                   })
    def test_collection_resource_to_json(self):
        ds = MagicMock()
        ds.get_resource.return_value = {
            'href': '/',
            'offset': 0,
            'limit': 25,
            'size': 2,
            'items': [{
                'href': 'test/resource'
            }, {
                'href': 'another/resource'
            }]
        }

        props = {
            'href': '/',
            'offset': 0,
            'limit': 25,
            'size': 2,
            'items': [{
                'href': 'test/resource'
            }, {
                'href': 'another/resource'
            }]
        }

        rl = CollectionResource(client=MagicMock(data_store=ds),
                                properties=props)

        self.assertEqual(props, json.loads(rl.to_json()))

        # collection resource as attribute
        rds = MagicMock()

        class Res(Resource, SaveMixin, DictMixin):
            writable_attrs = ('foo_val', 'bar', 'rl')

        res = Res(MagicMock(data_store=rds), href='test/resource1')
        res.rl = rl

        data = {'foo_val': True, 'bar': False}

        res.update(data)
        data.update({'href': 'test/resource1'})
        data.update({'rl': props})
        res._expand = Expansion(*['rl'])
        self.assertEqual(data, json.loads(res.to_json()))
예제 #10
0
 def test_expansion(self):
     expansion = Expansion()
     expansion.add_property('accounts', offset=0, limit=3)
     dir = self.client.directories.get(self.dir.href, expansion)
     self.assertEqual(len(dir.accounts), 5)
예제 #11
0
 def test_expansion(self):
     expansion = Expansion()
     expansion.add_property('accounts', offset=0, limit=3)
     dir = self.client.directories.get(self.dir.href, expansion)
     self.assertEqual(len(dir.accounts), 5)
예제 #12
0
    def test_tenant_expansion(self):
        e = Expansion()
        e.add_property('bar', limit=5)
        client = Client(api_key={'id': 'MyId', 'secret': 'Shush!'}, expand=e)

        self.assertIsInstance(client.tenant._expand, Expansion)
예제 #13
0
    def test_live(self):
        # test directory creation
        name = self.generate_name("my_dir")
        directory = self.client.directories.create({
            'name': name,
            'description': "This is my raindir!"
        })
        self.created_directories.append(directory)
        self.assertEqual(directory.name, name)
        self.assertTrue(directory.is_enabled())

        # test existing directory creation
        with self.assertRaises(Error):
            application = self.client.directories.create({
                "name": name})
            self.created_applications.append(application)

        # test directory group creation
        group_name = self.generate_name("my_group_1")
        group = directory.groups.create({
            "name": group_name,
            "description": "This is my support group",
            "enabled": "enabled"
        })
        self.created_groups.append(group)

        self.assertEqual(group.name, group_name)
        self.assertEqual(group.description, "This is my support group")
        self.assertTrue(group.is_enabled())

        # test directory account creation
        username = self.generate_name("william")
        account = directory.accounts.create({
            'username': username,
            'email': username + "@titan.com",
            'given_name': "William",
            'middle_name': "Thomas",
            'surname': "Riker",
            'password': "******",
            "custom_data": {
                "rank": "Captain",
                "birthDate": "2305-07-13",
                "birthPlace": "La Barre, France",
                "favoriteDrink": "Earl Grey tea"
            }
        })

        self.assertTrue(account.is_enabled())

        # test custom data
        account.custom_data['birthDate'] = 'whenever'
        self.assertEqual(account.custom_data['rank'], 'Captain')
        self.assertEqual(account.custom_data['birthDate'], 'whenever')
        account.custom_data.save()

        account = directory.accounts.get(account.href)
        self.assertEqual(account.custom_data['birthDate'], 'whenever')
        del account.custom_data['birthDate']
        with self.assertRaises(KeyError):
            account.custom_data['birthDate']
        account = directory.accounts.get(account.href)
        self.assertEqual(account.custom_data['birthDate'], "whenever")
        del account.custom_data['birthDate']
        account.custom_data.save()
        account = directory.accounts.get(account.href)
        with self.assertRaises(KeyError):
            account.custom_data['birthDate']

        # test application creation
        name = self.generate_name("my_app")
        application = self.client.applications.create({
            "name": name,
            "description": "This is my rainapp",
            "enabled": "enabled"
        })
        self.created_applications.append(application)

        # test invalid application authentication
        with self.assertRaises(Error):
            account = application.authenticate_account(username, "xaiK3auc")

        # test application creation with directory
        app_name = self.generate_name("my_app")
        dir_name = self.generate_name("my_dir")
        application2 = self.client.applications.create({
            "name": app_name,
            "description": "This is my rainapp",
            "enabled": "enabled"
        }, create_directory=dir_name)
        self.created_applications.append(application2)

        self.assertEqual(application2.name, app_name)
        self.assertEqual(application2.description, "This is my rainapp")
        self.assertTrue(application2.is_enabled())
        directory2 = self.client.directories.search({"name": dir_name})[0]
        self.created_directories.append(directory2)
        self.assertEqual(directory2.name, dir_name)
        self.assertTrue(directory2.is_enabled())

        # test account to group addition
        group_membership = group.add_account(account)
        self.created_group_memberships.append(group_membership)

        self.assertIsInstance(group_membership, GroupMembership)
        self.assertEqual(
            group_membership.account.email, username + "@titan.com")
        self.assertEqual(group_membership.group.name, group_name)

        # test account store creation
        account_store_mapping = self.client.account_store_mappings.create({
            'application': application, 'account_store': directory})
        self.created_account_stores.append(account_store_mapping)
        self.assertFalse(account_store_mapping.is_default_account_store)

        # test valid application authentication
        login_attempt = application.authenticate_account(username, "xaiK3auc")
        account = login_attempt.account
        self.assertEqual(account.email, username + "@titan.com")
        self.assertEqual(account.middle_name, "Thomas")

        # test unsuccesful account creation on application
        username2 = self.generate_name("ltcmdata")
        with self.assertRaises(Error):
            application.accounts.create({
                'username': username2,
                'email': username2 + "@enterprise.com",
                'given_name': "Lieutenant",
                'surname': "Commander",
                'password': "******"
            })

        # test default account store
        account_store_mapping.is_default_account_store = True
        account_store_mapping.save()
        account2 = application.accounts.create(
            {
                'username': username2,
                'email': username2 + "@enterprise.com",
                'given_name': "Lieutenant",
                'surname': "Commander",
                'password': "******"
            })
        self.created_accounts.append(account2)
        self.assertEqual(account2.email, username2 + "@enterprise.com")
        self.assertIsNone(account2.middle_name, None)

        # test unsuccesful group creation on application
        group2_name = self.generate_name("Android civil rights group")
        with self.assertRaises(Error):
            application.groups.create({
                'name': group2_name
            })

        # test default group store
        account_store_mapping.is_default_group_store = True
        account_store_mapping.save()
        group2 = application.groups.create({
            'name': group2_name
        })
        self.created_groups.append(group2)
        self.assertEqual(group2.name, group2_name)

        # create multiple groups to test on
        for i in range(0, 8):
            group = directory.groups.create(
                {
                    'name': "test_groupi_{0}".format(i),
                    'description': 'random_groups'
                })
            self.created_groups.append(group)

        # test pagination
        groups = directory.groups.search({"description": "random_groups"})
        self.assertEqual(len(groups), 8)
        self.assertEqual(len(groups[3:10]), 5)

        # test expansion
        expansion = Expansion('accounts', 'groups')
        expansion.add_property('groups', offset=0, limit=3)
        directory = self.client.directories.get(directory.href, expansion)
        self.assertEqual(len(directory.groups), 3)

        # test sorting
        groups = directory.groups.order("description asc")
        self.assertEqual(groups[-1].description, "This is my support group")
        groups = directory.groups.order("description desc")
        self.assertEqual(groups[0].description, "This is my support group")

        # test search
        groups = directory.groups.search({"description": "random_groups"})
        self.assertTrue(len(groups), 7)
        groups = directory.groups.search(
            {"description": "random_groups", "name": "test_groupi_1"})
        self.assertEqual(len(groups), 1)
        self.assertEqual(groups[0].name, "test_groupi_1")
예제 #14
0
    def test_live(self):
        # test directory creation
        name = self.generate_name("my_dir")
        directory = self.client.directories.create({
            'name':
            name,
            'description':
            "This is my raindir!"
        })
        self.created_directories.append(directory)
        self.assertEqual(directory.name, name)
        self.assertTrue(directory.is_enabled())

        # test existing directory creation
        with self.assertRaises(Error):
            application = self.client.directories.create({"name": name})
            self.created_applications.append(application)

        # test directory group creation
        group_name = self.generate_name("my_group_1")
        group = directory.groups.create({
            "name": group_name,
            "description": "This is my support group",
            "enabled": "enabled"
        })
        self.created_groups.append(group)

        self.assertEqual(group.name, group_name)
        self.assertEqual(group.description, "This is my support group")
        self.assertTrue(group.is_enabled())

        # test directory account creation
        username = self.generate_name("william")
        account = directory.accounts.create({
            'username': username,
            'email': username + "@titan.com",
            'given_name': "William",
            'middle_name': "Thomas",
            'surname': "Riker",
            'password': "******",
            "custom_data": {
                "rank": "Captain",
                "birthDate": "2305-07-13",
                "birthPlace": "La Barre, France",
                "favoriteDrink": "Earl Grey tea"
            }
        })

        self.assertTrue(account.is_enabled())

        # test custom data
        account.custom_data['birthDate'] = 'whenever'
        self.assertEqual(account.custom_data['rank'], 'Captain')
        self.assertEqual(account.custom_data['birthDate'], 'whenever')
        account.custom_data.save()

        account = directory.accounts.get(account.href)
        self.assertEqual(account.custom_data['birthDate'], 'whenever')
        del account.custom_data['birthDate']
        with self.assertRaises(KeyError):
            account.custom_data['birthDate']
        account = directory.accounts.get(account.href)
        self.assertEqual(account.custom_data['birthDate'], "whenever")
        del account.custom_data['birthDate']
        account.custom_data.save()
        account = directory.accounts.get(account.href)
        with self.assertRaises(KeyError):
            account.custom_data['birthDate']

        # test application creation
        name = self.generate_name("my_app")
        application = self.client.applications.create({
            "name": name,
            "description": "This is my rainapp",
            "enabled": "enabled"
        })
        self.created_applications.append(application)

        # test invalid application authentication
        with self.assertRaises(Error):
            account = application.authenticate_account(username, "xaiK3auc")

        # test application creation with directory
        app_name = self.generate_name("my_app")
        dir_name = self.generate_name("my_dir")
        application2 = self.client.applications.create(
            {
                "name": app_name,
                "description": "This is my rainapp",
                "enabled": "enabled"
            },
            create_directory=dir_name)
        self.created_applications.append(application2)

        self.assertEqual(application2.name, app_name)
        self.assertEqual(application2.description, "This is my rainapp")
        self.assertTrue(application2.is_enabled())
        directory2 = self.client.directories.search({"name": dir_name})[0]
        self.created_directories.append(directory2)
        self.assertEqual(directory2.name, dir_name)
        self.assertTrue(directory2.is_enabled())

        # test account to group addition
        group_membership = group.add_account(account)
        self.created_group_memberships.append(group_membership)

        self.assertIsInstance(group_membership, GroupMembership)
        self.assertEqual(group_membership.account.email,
                         username + "@titan.com")
        self.assertEqual(group_membership.group.name, group_name)

        # test account store creation
        account_store_mapping = self.client.account_store_mappings.create({
            'application':
            application,
            'account_store':
            directory
        })
        self.created_account_stores.append(account_store_mapping)
        self.assertFalse(account_store_mapping.is_default_account_store)

        # test valid application authentication
        login_attempt = application.authenticate_account(username, "xaiK3auc")
        account = login_attempt.account
        self.assertEqual(account.email, username + "@titan.com")
        self.assertEqual(account.middle_name, "Thomas")

        # test unsuccesful account creation on application
        username2 = self.generate_name("ltcmdata")
        with self.assertRaises(Error):
            application.accounts.create({
                'username': username2,
                'email': username2 + "@enterprise.com",
                'given_name': "Lieutenant",
                'surname': "Commander",
                'password': "******"
            })

        # test default account store
        account_store_mapping.is_default_account_store = True
        account_store_mapping.save()
        account2 = application.accounts.create({
            'username': username2,
            'email': username2 + "@enterprise.com",
            'given_name': "Lieutenant",
            'surname': "Commander",
            'password': "******"
        })
        self.created_accounts.append(account2)
        self.assertEqual(account2.email, username2 + "@enterprise.com")
        self.assertIsNone(account2.middle_name, None)

        # test unsuccesful group creation on application
        group2_name = self.generate_name("Android civil rights group")
        with self.assertRaises(Error):
            application.groups.create({'name': group2_name})

        # test default group store
        account_store_mapping.is_default_group_store = True
        account_store_mapping.save()
        group2 = application.groups.create({'name': group2_name})
        self.created_groups.append(group2)
        self.assertEqual(group2.name, group2_name)

        # create multiple groups to test on
        for i in range(0, 8):
            group = directory.groups.create({
                'name': "test_groupi_{0}".format(i),
                'description': 'random_groups'
            })
            self.created_groups.append(group)

        # test pagination
        groups = directory.groups.search({"description": "random_groups"})
        self.assertEqual(len(groups), 8)
        self.assertEqual(len(groups[3:10]), 5)

        # test expansion
        expansion = Expansion('accounts', 'groups')
        expansion.add_property('groups', offset=0, limit=3)
        directory = self.client.directories.get(directory.href, expansion)
        self.assertEqual(len(directory.groups), 3)

        # test sorting
        groups = directory.groups.order("description asc")
        self.assertEqual(groups[-1].description, "This is my support group")
        groups = directory.groups.order("description desc")
        self.assertEqual(groups[0].description, "This is my support group")

        # test search
        groups = directory.groups.search({"description": "random_groups"})
        self.assertTrue(len(groups), 7)
        groups = directory.groups.search({
            "description": "random_groups",
            "name": "test_groupi_1"
        })
        self.assertEqual(len(groups), 1)
        self.assertEqual(groups[0].name, "test_groupi_1")
예제 #15
0
    def test_tenant_expansion(self):
        e = Expansion()
        e.add_property('bar', limit=5)
        client = Client(api_key={'id': 'MyId', 'secret': 'Shush!'}, expand=e)

        self.assertIsInstance(client.tenant._expand, Expansion)