def testReset(self): db = AUSDatabase('sqlite:///:memory:') db.reset() # If we can set the dburi again, reset worked! db.setDburi('sqlite:///:memory:') db.create() insp = Inspector.from_engine(db.engine) self.assertNotEqual(insp.get_table_names(), [])
class TestReleases(unittest.TestCase, MemoryDatabaseMixin): def setUp(self): MemoryDatabaseMixin.setUp(self) self.db = AUSDatabase(self.dburi) self.db.create() self.releases = self.db.releases self.releases.t.insert().execute(name='a', product='a', version='a', data=json.dumps(dict(name=1)), data_version=1) self.releases.t.insert().execute(name='ab', product='a', version='a', data=json.dumps(dict(name=1)), data_version=1) self.releases.t.insert().execute(name='b', product='b', version='b', data=json.dumps(dict(name=2)), data_version=1) self.releases.t.insert().execute(name='c', product='c', version='c', data=json.dumps(dict(name=3)), data_version=1) def testGetReleases(self): self.assertEquals(len(self.releases.getReleases()), 4) def testGetReleasesWithLimit(self): self.assertEquals(len(self.releases.getReleases(limit=1)), 1) def testGetReleasesWithWhere(self): expected = [dict(product='b', version='b', name='b', data=dict(name=2), data_version=1)] self.assertEquals(self.releases.getReleases(name='b'), expected) def testGetReleaseBlob(self): expected = dict(name=3) self.assertEquals(self.releases.getReleaseBlob(name='c'), expected) def testGetReleaseBlobNonExistentRelease(self): self.assertRaises(KeyError, self.releases.getReleaseBlob, name='z') def testGetReleaseNames(self): releases = self.releases.getReleaseNames() expected = [ dict(name='a'), dict(name='ab'), dict(name='b'), dict(name='c')] self.assertEquals(releases, expected) releases = self.releases.getReleaseNames(product='a') expected = [ dict(name='a'), dict(name='ab')] self.assertEquals(releases, expected) releases = self.releases.getReleaseNames(version='b') expected = [ dict(name='b'), ] self.assertEquals(releases, expected) releases = self.releases.getReleaseNames(product='a', version='b') expected = [ ] self.assertEquals(releases, expected)
usage += " cleanup-dryrun: Show what would be removed if 'cleanup' is run." parser = OptionParser(usage=usage) parser.add_option("-d", "--db", dest="db", default=None, help="database to manage, in URI format") parser.add_option("--version", dest="version", default=None, type="int", help="Create/upgrade to this specific schema version rather than the latest.") options, args = parser.parse_args() if not options.db: parser.error("db is required") if len(args) < 1: parser.error("need an action to perform") action = args[0] db = AUSDatabase(options.db, mysql_traditional_mode=True) if action == 'create': db.create(options.version) elif action == 'upgrade': db.upgrade(options.version) elif action == 'downgrade': db.downgrade(options.version) elif action.startswith("cleanup"): if len(args) < 2: parser.error("need to pass maximum nightly release age") nightly_age = int(args[1]) with db.begin() as trans: if action == "cleanup": cleanup_releases(trans, nightly_age, dryrun=False) cleanup_releases_history(trans, dryrun=False) else: cleanup_releases(trans, nightly_age, dryrun=True) cleanup_releases_history(trans, dryrun=True)
usage += " cleanup-dryrun: Show what would be removed if 'cleanup' is run." parser = OptionParser(usage=usage) parser.add_option("-d", "--db", dest="db", default=None, help="database to manage, in URI format") parser.add_option("--version", dest="version", default=None, type="int", help="Create/upgrade to this specific schema version rather than the latest.") options, args = parser.parse_args() if not options.db: parser.error("db is required") if len(args) < 1: parser.error("need an action to perform") action = args[0] db = AUSDatabase(options.db, mysql_traditional_mode=True) if action == "create": db.create(options.version) elif action == "upgrade": db.upgrade(options.version) elif action == "downgrade": db.downgrade(options.version) elif action == "extract": with db.begin() as trans: if len(args) < 2: extract_active_data(trans, options.db) else: location = args[1] extract_active_data(trans, options.db, location) elif action.startswith("cleanup"): if len(args) < 2: parser.error("need to pass maximum nightly release age") nightly_age = int(args[1])
class TestPermissions(unittest.TestCase, MemoryDatabaseMixin): def setUp(self): MemoryDatabaseMixin.setUp(self) self.db = AUSDatabase(self.dburi) self.db.create() self.permissions = self.db.permissions self.permissions.t.insert().execute(permission='admin', username='******', data_version=1) self.permissions.t.insert().execute(permission='/users/:id/permissions/:permission', username='******', data_version=1) self.permissions.t.insert().execute(permission='/releases/:name', username='******', options=json.dumps(dict(product='fake')), data_version=1) self.permissions.t.insert().execute(permission='/rules', username='******', data_version=1) self.permissions.t.insert().execute(permission='/rules/:id', username='******', options=json.dumps(dict(method='POST')), data_version=1) def testGrantPermissions(self): query = self.permissions.t.select().where(self.permissions.username=='jess') self.assertEquals(len(query.execute().fetchall()), 0) self.permissions.grantPermission('bob', 'jess', '/rules/:id') self.assertEquals(query.execute().fetchall(), [('/rules/:id', 'jess', None, 1)]) def testGrantPermissionsWithOptions(self): self.permissions.grantPermission('bob', 'cathy', '/releases/:name', options=dict(product='SeaMonkey')) query = self.permissions.t.select().where(self.permissions.username=='cathy') query = query.where(self.permissions.permission=='/releases/:name') self.assertEquals(query.execute().fetchall(), [('/releases/:name', 'cathy', json.dumps(dict(product='SeaMonkey')), 1)]) def testGrantPermissionsUnknownPermission(self): self.assertRaises(ValueError, self.permissions.grantPermission, 'bob', 'bud', 'bad' ) def testGrantPermissionsUnknownOption(self): self.assertRaises(ValueError, self.permissions.grantPermission, 'bob', 'bud', '/rules/:id', dict(foo=1) ) def testRevokePermission(self): self.permissions.revokePermission(changed_by='bill', username='******', permission='/releases/:name', old_data_version=1) query = self.permissions.t.select().where(self.permissions.username=='bob') query = query.where(self.permissions.permission=='/releases/:name') self.assertEquals(len(query.execute().fetchall()), 0) def testGetAllUsers(self): self.assertEquals(self.permissions.getAllUsers(), ['bill', 'bob', 'cathy']) def testGetPermission(self): expected = { 'permission': '/releases/:name', 'username': '******', 'options': dict(product='fake'), 'data_version': 1 } self.assertEquals(self.permissions.getPermission('bob', '/releases/:name'), expected) def testGetPermissionNonExistant(self): self.assertEquals(self.permissions.getPermission('bob', '/rules'), {}) def testGetUserPermissions(self): expected = {'/users/:id/permissions/:permission': dict(options=None, data_version=1), '/releases/:name': dict(options=dict(product='fake'), data_version=1), '/rules/:id': dict(options=dict(method='POST'), data_version=1)} self.assertEquals(self.permissions.getUserPermissions('bob'), expected) def testGetOptions(self): expected = dict(product='fake') self.assertEquals(self.permissions.getOptions('bob', '/releases/:name'), expected) def testGetOptionsPermissionDoesntExist(self): self.assertRaises(ValueError, self.permissions.getOptions, 'fake', 'fake') def testGetOptionsNoOptions(self): self.assertEquals(self.permissions.getOptions('cathy', '/rules'), {}) def testHasUrlPermission(self): self.assertTrue(self.permissions.hasUrlPermission('cathy', '/rules', 'PUT', dict(product='fake'))) def testHasUrlPermissionWithOption(self): self.assertTrue(self.permissions.hasUrlPermission('bob', '/rules/:id', 'POST', dict(product='fake'))) def testHasUrlPermissionNotAllowed(self): self.assertFalse(self.permissions.hasUrlPermission('cathy', '/rules/:id', 'DELETE', dict(product='fake'))) def testHasUrlPermissionNotAllowedWithOption(self): self.assertFalse(self.permissions.hasUrlPermission('bob', '/rules/:id', 'DELETE', dict(product='fake'))) def testHasUrlPermissionWithProduct(self): self.assertTrue(self.permissions.hasUrlPermission('bob', '/releases/:name', 'DELETE', dict(product='fake')))
class TestReleasesSchema1(unittest.TestCase, MemoryDatabaseMixin): """Tests for the Releases class that depend on version 1 of the blob schema.""" def setUp(self): MemoryDatabaseMixin.setUp(self) self.db = AUSDatabase(self.dburi) self.db.create() self.releases = self.db.releases self.releases.t.insert().execute(name='a', product='a', version='a', data_version=1, data=""" { "name": "a", "platforms": { "p": { "locales": { "l": { "complete": { "filesize": 1234 } } } }, "p2": { "alias": "p" } } } """) self.releases.t.insert().execute(name='b', product='b', version='b', data_version=1, data=""" { "name": "b" } """) def testAddRelease(self): blob = ReleaseBlobV1(name=4) self.releases.addRelease(name='d', product='d', version='d', blob=blob, changed_by='bill') expected = [('d', 'd', 'd', json.dumps(dict(name=4)), 1)] self.assertEquals(self.releases.t.select().where(self.releases.name=='d').execute().fetchall(), expected) def testAddReleaseAlreadyExists(self): blob = ReleaseBlobV1(name=1) self.assertRaises(TransactionError, self.releases.addRelease, name='a', product='a', version='a', blob=blob, changed_by='bill') def testUpdateRelease(self): blob = ReleaseBlobV1(name='a') self.releases.updateRelease(name='b', product='z', version='y', blob=blob, changed_by='bill', old_data_version=1) expected = [('b', 'z', 'y', json.dumps(dict(name='a')), 2)] self.assertEquals(self.releases.t.select().where(self.releases.name=='b').execute().fetchall(), expected) def testUpdateReleaseWithBlob(self): blob = ReleaseBlobV1(name='b', schema_version=3) self.releases.updateRelease(name='b', product='z', version='y', changed_by='bill', blob=blob, old_data_version=1) expected = [('b', 'z', 'y', json.dumps(dict(name='b', schema_version=3)), 2)] self.assertEquals(self.releases.t.select().where(self.releases.name=='b').execute().fetchall(), expected) def testUpdateReleaseInvalidBlob(self): blob = ReleaseBlobV1(name=2) blob['foo'] = 'bar' self.assertRaises(ValueError, self.releases.updateRelease, changed_by='bill', name='b', blob=blob, old_data_version=1) def testAddLocaleToRelease(self): data = dict(complete=dict(hashValue='abc')) self.releases.addLocaleToRelease(name='a', platform='p', locale='c', data=data, old_data_version=1, changed_by='bill') ret = json.loads(select([self.releases.data]).where(self.releases.name=='a').execute().fetchone()[0]) expected = json.loads(""" { "name": "a", "platforms": { "p": { "locales": { "c": { "complete": { "hashValue": "abc" } }, "l": { "complete": { "filesize": 1234 } } } }, "p2": { "alias": "p" } } } """) self.assertEqual(ret, expected) def testAddLocaleToReleaseOverride(self): data = dict(complete=dict(hashValue=789)) self.releases.addLocaleToRelease(name='a', platform='p', locale='l', data=data, old_data_version=1, changed_by='bill') ret = json.loads(select([self.releases.data]).where(self.releases.name=='a').execute().fetchone()[0]) expected = json.loads(""" { "name": "a", "platforms": { "p": { "locales": { "l": { "complete": { "hashValue": 789 } } } }, "p2": { "alias": "p" } } } """) self.assertEqual(ret, expected) def testAddLocaleToReleasePlatformsDoesntExist(self): data = dict(complete=dict(filesize=432)) self.releases.addLocaleToRelease(name='b', platform='q', locale='l', data=data, old_data_version=1, changed_by='bill') ret = json.loads(select([self.releases.data]).where(self.releases.name=='b').execute().fetchone()[0]) expected = json.loads(""" { "name": "b", "platforms": { "q": { "locales": { "l": { "complete": { "filesize": 432 } } } } } } """) self.assertEqual(ret, expected) def testAddLocaleToReleaseSecondPlatform(self): data = dict(complete=dict(filesize=324)) self.releases.addLocaleToRelease(name='a', platform='q', locale='l', data=data, old_data_version=1, changed_by='bill') ret = json.loads(select([self.releases.data]).where(self.releases.name=='a').execute().fetchone()[0]) expected = json.loads(""" { "name": "a", "platforms": { "p": { "locales": { "l": { "complete": { "filesize": 1234 } } } }, "p2": { "alias": "p" }, "q": { "locales": { "l": { "complete": { "filesize": 324 } } } } } } """) self.assertEqual(ret, expected) def testAddLocaleToReleaseResolveAlias(self): data = dict(complete=dict(filesize=444)) self.releases.addLocaleToRelease(name='a', platform='p2', locale='j', data=data, old_data_version=1, changed_by='bill') ret = json.loads(select([self.releases.data]).where(self.releases.name=='a').execute().fetchone()[0]) expected = json.loads(""" { "name": "a", "platforms": { "p": { "locales": { "l": { "complete": { "filesize": 1234 } }, "j": { "complete": { "filesize": 444 } } } }, "p2": { "alias": "p" } } } """) self.assertEqual(ret, expected)
class TestRulesSpecial(unittest.TestCase, RulesTestMixin, MemoryDatabaseMixin): def setUp(self): MemoryDatabaseMixin.setUp(self) self.db = AUSDatabase(self.dburi) self.db.create() self.rules = self.db.rules self.rules.t.insert().execute(id=1, priority=100, version='4.0*', throttle=100, update_type='z', data_version=1) self.rules.t.insert().execute(id=2, priority=100, channel='release*', throttle=100, update_type='z', data_version=1) def testGetRulesMatchingQueryVersionGlobbing(self): expected = [dict(rule_id=1, priority=100, throttle=100, version='4.0*', update_type='z', data_version=1)] rules = self.rules.getRulesMatchingQuery( dict(name='', product='', version='4.0', channel='', buildTarget='', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=False ), fallbackChannel='' ) rules = self._stripNullColumns(rules) self.assertEquals(rules, expected) rules = self.rules.getRulesMatchingQuery( dict(name='', product='', version='4.0b2', channel='', buildTarget='', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=False ), fallbackChannel='' ) rules = self._stripNullColumns(rules) self.assertEquals(rules, expected) rules = self.rules.getRulesMatchingQuery( dict(name='', product='', version='4.0.1', channel='', buildTarget='', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=False ), fallbackChannel='' ) rules = self._stripNullColumns(rules) self.assertEquals(rules, expected) def testGetRulesMatchingQueryChannelGlobbing(self): expected = [dict(rule_id=2, priority=100, throttle=100, channel='release*', update_type='z', data_version=1)] rules = self.rules.getRulesMatchingQuery( dict(name='', product='', version='', channel='releasetest', buildTarget='', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=False ), fallbackChannel='releasetest' ) rules = self._stripNullColumns(rules) self.assertEquals(rules, expected) rules = self.rules.getRulesMatchingQuery( dict(name='', product='', version='', channel='releasetest-cck-blah', buildTarget='', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=False ), fallbackChannel='releasetest' ) rules = self._stripNullColumns(rules) self.assertEquals(rules, expected)
class TestRulesSimple(unittest.TestCase, RulesTestMixin, MemoryDatabaseMixin): def setUp(self): MemoryDatabaseMixin.setUp(self) self.db = AUSDatabase(self.dburi) self.db.create() self.paths = self.db.rules self.paths.t.insert().execute(id=1, priority=100, version='3.5', buildTarget='d', throttle=100, mapping='c', update_type='z', data_version=1) self.paths.t.insert().execute(id=2, priority=100, version='3.3', buildTarget='d', throttle=100, mapping='b', update_type='z', data_version=1) self.paths.t.insert().execute(id=3, priority=100, version='3.5', buildTarget='a', throttle=100, mapping='a', update_type='z', data_version=1) self.paths.t.insert().execute(id=4, priority=80, buildTarget='d', throttle=100, mapping='a', update_type='z', data_version=1) self.paths.t.insert().execute(id=5, priority=80, buildTarget='d', version='3.3', throttle=0, mapping='c', update_type='z', data_version=1) def testGetOrderedRules(self): rules = self._stripNullColumns(self.paths.getOrderedRules()) expected = [ dict(rule_id=4, priority=80, throttle=100, buildTarget='d', mapping='a', update_type='z', data_version=1), dict(rule_id=5, priority=80, throttle=0, version='3.3', buildTarget='d', mapping='c', update_type='z', data_version=1), dict(rule_id=2, priority=100, throttle=100, version='3.3', buildTarget='d', mapping='b', update_type='z', data_version=1), dict(rule_id=3, priority=100, throttle=100, version='3.5', buildTarget='a', mapping='a', update_type='z', data_version=1), dict(rule_id=1, priority=100, throttle=100, version='3.5', buildTarget='d', mapping='c', update_type='z', data_version=1), ] self.assertEquals(rules, expected) def testGetRulesMatchingQuery(self): rules = self.paths.getRulesMatchingQuery( dict(name='', product='', version='3.5', channel='', buildTarget='a', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=False ), fallbackChannel='' ) rules = self._stripNullColumns(rules) expected = [dict(rule_id=3, priority=100, throttle=100, version='3.5', buildTarget='a', mapping='a', update_type='z', data_version=1)] self.assertEquals(rules, expected) def testGetRulesMatchingQueryWithNullColumn(self): rules = self.paths.getRulesMatchingQuery( dict(name='', product='', version='3.5', channel='', buildTarget='d', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=False ), fallbackChannel='' ) rules = self._stripNullColumns(rules) expected = [ dict(rule_id=1, priority=100, throttle=100, version='3.5', buildTarget='d', mapping='c', update_type='z', data_version=1), dict(rule_id=4, priority=80, throttle=100, buildTarget='d', mapping='a', update_type='z', data_version=1), ] self.assertEquals(rules, expected) def testGetRulesMatchingQueryDontReturnThrottled(self): rules = self.paths.getRulesMatchingQuery( dict(name='', product='', version='3.3', channel='', buildTarget='d', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=False ), fallbackChannel='' ) rules = self._stripNullColumns(rules) expected = [ dict(rule_id=2, priority=100, throttle=100, version='3.3', buildTarget='d', mapping='b', update_type='z', data_version=1), dict(rule_id=4, priority=80, throttle=100, buildTarget='d', mapping='a', update_type='z', data_version=1), ] self.assertEquals(rules, expected) def testGetRulesMatchingQueryReturnThrottled(self): rules = self.paths.getRulesMatchingQuery( dict(name='', product='', version='3.3', channel='', buildTarget='d', buildID='', locale='', osVersion='', distribution='', distVersion='', headerArchitecture='', force=True ), fallbackChannel='' ) rules = self._stripNullColumns(rules) expected = [ dict(rule_id=2, priority=100, throttle=100, version='3.3', buildTarget='d', mapping='b', update_type='z', data_version=1), dict(rule_id=4, priority=80, throttle=100, buildTarget='d', mapping='a', update_type='z', data_version=1), dict(rule_id=5, priority=80, throttle=0, version='3.3', buildTarget='d', mapping='c', update_type='z', data_version=1) ] self.assertEquals(rules, expected) def testGetRuleById(self): rule = self._stripNullColumns([self.paths.getRuleById(1)]) expected = [dict(rule_id=1, priority=100, throttle=100, version='3.5', buildTarget='d', mapping='c', update_type='z', data_version=1)] self.assertEquals(rule, expected) def testAddRule(self): what = dict(throttle=11, mapping='c', update_type='z', priority=60) rule_id = self.paths.addRule(changed_by='bill', what=what) rule_id = rule_id[0] rules = self.paths.t.select().where(self.paths.rule_id==rule_id).execute().fetchall() copy_rule = dict(rules[0].items()) rule = self._stripNullColumns( [copy_rule] ) what['rule_id']=rule_id what['data_version']=1 what = [what] self.assertEquals(rule, what) def testUpdateRule(self): rules = self.paths.t.select().where(self.paths.rule_id==1).execute().fetchall() what = dict(rules[0].items()) what['mapping'] = 'd' self.paths.updateRule(changed_by='bill', rule_id=1, what=what, old_data_version=1) rules = self.paths.t.select().where(self.paths.rule_id==1).execute().fetchall() copy_rule = dict(rules[0].items()) rule = self._stripNullColumns( [copy_rule] ) expected = [dict(rule_id=1, priority=100, throttle=100, version='3.5', buildTarget='d', mapping='d', update_type='z', data_version=1)] self.assertEquals(rule, expected)
def testModelIsSameAsRepository(self): db2 = AUSDatabase('sqlite:///' + self.getTempfile()) db2.create() diff = migrate.versioning.api.compare_model_to_db(db2.engine, self.db.migrate_repo, self.db.metadata) if diff: self.fail(str(diff))