def test_generateEmail_with_null_fields(self):
     """GenerateEmail works when many fields are NULL."""
     person = self.factory.makePerson(name='person')
     cake = self.factory.makeSourcePackageRecipe(
         name=u'recipe', owner=person)
     pantry_owner = self.factory.makePerson(name='archiveowner')
     pantry = self.factory.makeArchive(name='ppa', owner=pantry_owner)
     secret = self.factory.makeDistroSeries(name=u'distroseries')
     build = self.factory.makeSourcePackageRecipeBuild(
         recipe=cake, distroseries=secret, archive=pantry,
         status=BuildStatus.SUPERSEDED)
     Store.of(build).flush()
     ctrl = self.makeStatusEmail(build)
     self.assertEqual(
         u'[recipe build #%d] of ~person recipe in distroseries: '
         'Build for superseded Source' % (build.id), ctrl.subject)
     body, footer = ctrl.body.split('\n-- \n')
     self.assertEqual(superseded_body, body)
     build_url = canonical_url(build)
     self.assertEqual(
         '%s\nYou are the requester of the build.\n' % build_url, footer)
     self.assertEqual(
         config.canonical.noreply_from_address, ctrl.from_addr)
     self.assertEqual(
         'Requester', ctrl.headers['X-Launchpad-Message-Rationale'])
     self.assertEqual(
         'recipe-build-status',
         ctrl.headers['X-Launchpad-Notification-Type'])
     self.assertEqual(
         'SUPERSEDED', ctrl.headers['X-Launchpad-Build-State'])

def bequeathe_flags(source_message, target_message, incumbents=None):
    """Destroy `source_message`, leaving flags to `target_message`.

    If `source_message` holds the is_current_ubuntu flag, and there are no
    `incumbents` that hold the same flag, then `target_message` inherits
    it.  Similar for the is_current_upstream flag.
    """
    sacrifice_flags(source_message, incumbents)

    if (source_message.is_current_ubuntu and
        not target_message.is_current_ubuntu):
        # Transfer is_current_ubuntu flag.
        source_message.is_current_ubuntu = False
        target_message.is_current_ubuntu = True
        Store.of(source_message).add_flush_order(
            source_message, target_message)

    if (source_message.is_current_upstream and
        not target_message.is_current_upstream):
        # Transfer is_current_upstream flag.
        source_message.is_current_upstream = False
        target_message.is_current_upstream = True
        Store.of(source_message).add_flush_order(
            source_message, target_message)

    source_message.destroySelf()

    def test_check_unmodifiable_strings(self):
        # This test case asserts that data migration updates unmodifiable l10n strings
        self._initStartDB(34)

        notification_l10n = NotificationL10NFactory(self.store)

        t0 = notification_l10n.get_val("export_template", "it")

        notification_l10n.set_val("export_template", "it", "")

        t1 = notification_l10n.get_val("export_template", "it")

        self.assertEqual(t1, "")

        self.store.commit()

        # place a dummy version in the current db
        store = Store(create_database(GLSettings.db_uri))
        prv = config.PrivateFactory(store)
        self.dummy_ver = "2.XX.XX"
        prv.set_val("version", self.dummy_ver)
        self.assertEqual(prv.get_val("version"), self.dummy_ver)
        store.commit()
        store.close()

        migration.perform_data_update(self.db_file)

        store = Store(create_database(GLSettings.db_uri))
        notification_l10n = NotificationL10NFactory(store)
        t2 = notification_l10n.get_val("export_template", "it")
        self.assertEqual(t2, t0)
        store.commit()
        store.close()

        shutil.rmtree(GLSettings.db_path)

 def delete(self):
     """Deletes the exercise, providing it has no associated worksheets."""
     if (self.worksheet_exercises.count() > 0):
         raise IntegrityError()
     for suite in self.test_suites:
         suite.delete()
     Store.of(self).remove(self)

    def setUp(self):
        helpers.init_glsettings_for_unit_tests()

        GLSettings.db_path = os.path.join(GLSettings.ramdisk_path, 'db_test')
        os.mkdir(GLSettings.db_path)
        db_name = 'glbackend-%d.db' % DATABASE_VERSION
        db_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'db', 'populated', db_name)
        shutil.copyfile(db_path, os.path.join(GLSettings.db_path, db_name))

        self.db_file = os.path.join(GLSettings.db_path, db_name)
        GLSettings.db_uri = GLSettings.make_db_uri(self.db_file)

        # place a dummy version in the current db
        store = Store(create_database(GLSettings.db_uri))
        prv = config.PrivateFactory(store)
        self.dummy_ver = '2.XX.XX'
        prv.set_val('version', self.dummy_ver)
        self.assertEqual(prv.get_val('version'), self.dummy_ver)
        store.commit()
        store.close()

        # backup various mocks that we will use
        self._bck_f = config.is_cfg_valid
        GLConfig['private']['xx_smtp_password'] = GLConfig['private'].pop('smtp_password')
        self.dp = u'yes_you_really_should_change_me'

 def initialize(self, debug=None):
     """See `IDatabase`."""
     # Calculate the engine url.
     url = expand(config.database.url, config.paths)
     log.debug('Database url: %s', url)
     # XXX By design of SQLite, database file creation does not honor
     # umask.  See their ticket #1193:
     # http://www.sqlite.org/cvstrac/tktview?tn=1193,31
     #
     # This sucks for us because the mailman.db file /must/ be group
     # writable, however even though we guarantee our umask is 002 here, it
     # still gets created without the necessary g+w permission, due to
     # SQLite's policy.  This should only affect SQLite engines because its
     # the only one that creates a little file on the local file system.
     # This kludges around their bug by "touch"ing the database file before
     # SQLite has any chance to create it, thus honoring the umask and
     # ensuring the right permissions.  We only try to do this for SQLite
     # engines, and yes, we could have chmod'd the file after the fact, but
     # half dozen and all...
     self.url = url
     self._prepare(url)
     database = create_database(url)
     store = Store(database, GenerationalCache())
     database.DEBUG = (as_boolean(config.database.debug)
                       if debug is None else debug)
     self.store = store
     store.commit()

class NCBITaxonomySelector(object):


    def __init__(self):
        self.__init_database()


    def __init_database(self):    
        """
        creates the sqlite database instance and checks if the database exists in biodb.
        """
        database= create_database("sqlite:%s" % biodb_sql_db_path)
        print "Created storm database from %s." % biodb_sql_db_path
        self.store= Store(database)
        

    def getTaxaByDivisionID(self, div_id):
        return self.store.find(BioDB, \
                (NCBITaxonomyDivision.taxonID == BioDB.id) & \
                (NCBITaxonomyDivision.divisionID == div_id))



    def getDivisionIDByTaxonID(self, tax_id):
        return self.store.find(NCBITaxonomyDivision, NCBITaxonomyDivision.taxonID == tax_id).one().divisionID

    def getDivisionNameByID(self, div_id):
        return self.store.find(NCBIDivision, NCBIDivision.id == div_id).one().name

    def take(self, count):
        """Take some amount of parts from this pile and return the object
        representing this amount. Everything gets copied over."""

        assert count > 0
        assert count <= self.count

        if count == self.count:
            return self

        take = Part()
        take.count = count
        self.count -= count

        take.source = self.source
        take.date = self.date
        take.price = self.price
        take.vat = self.vat
        take.part_type = self.part_type
        take.assignment = self.assignment
        take.history = self.history
        take.soldered = self.soldered
        take.usable = self.usable
        Store.of(self).add(take)

        return take

    def test_version_change_success(self):
        migration.perform_data_update(self.db_file)

        store = Store(create_database(GLSettings.db_uri))
        prv = config.PrivateFactory(store)
        self.assertEqual(prv.get_val('version'), __version__)
        store.close()

 def test_getByBuildFarmJobs(self):
     sprbs = [self.makeSourcePackageRecipeBuild() for i in range(10)]
     Store.of(sprbs[0]).flush()
     self.assertContentEqual(
         sprbs,
         SourcePackageRecipeBuild.getByBuildFarmJobs(
             [sprb.build_farm_job for sprb in sprbs]))

    def _checkValidDatabase(self, storage):
        '''Checks the Store to make sure it has a valid database'''

        store = Store(storage)
        for table in SCHEMA.iterkeys():
            result = store.execute('SELECT * FROM `%s`' % table.lower())
            self.assertEqual(result.get_all(), [])
        return True

    def __init__(self, table_history, old_db_file, new_db_file, start_ver):
        self.table_history = table_history
        self.old_db_file = old_db_file
        self.new_db_file = new_db_file
        self.start_ver = start_ver

        self.std_fancy = " ł "
        self.debug_info = "   [%d => %d] " % (start_ver, start_ver + 1)

        for k, v in table_history.iteritems():
            # +1 because count start from 0,
            # -8 because the relase befor the 8th are not supported anymore
            length = DATABASE_VERSION + 1 - 8
            if len(v) != length:
                msg = 'Expecting a table with {} statuses ({})'.format(length, k)
                raise TypeError(msg)

        log.msg('{} Opening old DB: {}'.format(self.debug_info, old_db_file))
        old_database = create_database('sqlite:' + self.old_db_file)
        self.store_old = Store(old_database)

        GLSetting.db_file = new_db_file

        new_database = create_database('sqlite:' + new_db_file)
        self.store_new = Store(new_database)

        if self.start_ver + 1 == DATABASE_VERSION:
            log.msg('{} Acquire SQL schema {}'.format(self.debug_info, GLSetting.db_schema_file))

            if not os.access(GLSetting.db_schema_file, os.R_OK):
                log.msg('Unable to access', GLSetting.db_schema_file)
                raise IOError('Unable to access db schema file')

            with open(GLSetting.db_schema_file) as f:
                create_queries = ''.join(f).split(';')
                for create_query in create_queries:
                    try:
                        self.store_new.execute(create_query + ';')
                    except OperationalError:
                        log.msg('OperationalError in "{}"'.format(create_query))
            self.store_new.commit()
            return
            # return here and manage the migrant versions here:

        for k, v in self.table_history.iteritems():

            create_query = self.get_right_sql_version(k, self.start_ver + 1)
            if not create_query:
                # table not present in the version
                continue

            try:
                self.store_new.execute(create_query + ';')
            except OperationalError as excep:
                log.msg('{} OperationalError in [{}]'.format(self.debug_info, create_query))
                raise excep

        self.store_new.commit()

    def test_ver_change_exception(self):
        # Explicity throw an exception in managed_ver_update via is_cfg_valid
        config.is_cfg_valid = apply_gen(throw_excep)

        self.assertRaises(IOError, migration.perform_data_update, self.db_file)

        store = Store(create_database(GLSettings.db_uri))
        prv = config.PrivateFactory(store)
        self.assertEqual(prv.get_val('version'), self.dummy_ver)
        store.close()

 def test_binary_builds(self):
     """The binary_builds property should be populated automatically."""
     spb = self.factory.makeSourcePackageRecipeBuild()
     multiverse = self.factory.makeComponent(name='multiverse')
     spr = self.factory.makeSourcePackageRelease(
         source_package_recipe_build=spb, component=multiverse)
     self.assertEqual([], list(spb.binary_builds))
     binary = self.factory.makeBinaryPackageBuild(spr)
     self.factory.makeBinaryPackageBuild()
     Store.of(binary).flush()
     self.assertEqual([binary], list(spb.binary_builds))

    def test_version_change_not_ok(self):
        # Set is_config_valid to false  during managed ver update
        config.is_cfg_valid = apply_gen(mod_bool)

        self.assertRaises(Exception, migration.perform_data_update, self.db_file)

        # Ensure the rollback has succeeded
        store = Store(create_database(GLSettings.db_uri))
        prv = config.PrivateFactory(store)
        self.assertEqual(prv.get_val('version'), self.dummy_ver)
        store.close()

 def test_builder_history(self):
     build = self.makeRecipeBuild()
     Store.of(build).flush()
     build_url = canonical_url(build)
     build.updateStatus(
         BuildStatus.FULLYBUILT, builder=self.factory.makeBuilder())
     browser = self.getViewBrowser(build.builder, '+history')
     self.assertTextMatchesExpressionIgnoreWhitespace(
          'Build history.*~chef/chocolate/cake recipe build',
          extract_text(find_main_content(browser.contents)))
     self.assertEqual(build_url,
             browser.getLink('~chef/chocolate/cake recipe build').url)

    def test_update_existing_record(self):
        '''Existing records should be updated.'''
        handler = self.handler()
        _video = handler(self.filename)
        videos = Store.of(_video).find(models.VideoFile,
            models.VideoFile.filename == self.filename)
        self.assertEqual(videos.count(), 1)

        _video = handler(self.filename)
        videos = Store.of(_video).find(models.VideoFile,
            models.VideoFile.filename == self.filename)
        self.assertEqual(videos.count(), 1)

    def setUp(self):
        super(PatchTest, self).setUp()

        self.patchdir = self.makeDir()
        self.pkgdir = os.path.join(self.patchdir, "mypackage")
        os.makedirs(self.pkgdir)

        f = open(os.path.join(self.pkgdir, "__init__.py"), "w")
        f.write("shared_data = []")
        f.close()

        # Order of creation here is important to try to screw up the
        # patch ordering, as os.listdir returns in order of mtime (or
        # something).
        for pname, data in [("patch_380.py", patch_test_1),
                            ("patch_42.py", patch_test_0)]:
            self.add_module(pname, data)

        sys.path.append(self.patchdir)

        self.filename = self.makeFile()
        self.uri = "sqlite:///%s" % self.filename
        self.store = Store(create_database(self.uri))

        self.store.execute("CREATE TABLE patch "
                           "(version INTEGER NOT NULL PRIMARY KEY)")

        self.assertFalse(self.store.get(Patch, (42)))
        self.assertFalse(self.store.get(Patch, (380)))

        import mypackage
        self.mypackage = mypackage

        # Create another connection just to keep track of the state of the
        # whole transaction manager.  See the assertion functions below.
        self.another_store = Store(create_database("sqlite:"))
        self.another_store.execute("CREATE TABLE test (id INT)")
        self.another_store.commit()
        self.prepare_for_transaction_check()

        class Committer(object):

            def commit(committer):
                self.store.commit()
                self.another_store.commit()

            def rollback(committer):
                self.store.rollback()
                self.another_store.rollback()

        self.committer = Committer()
        self.patch_applier = PatchApplier(self.store, self.mypackage,
                                          self.committer)

 def clone_worksheets(self, source):
     """Clone all worksheets from the specified source to this offering."""
     import ivle.worksheet.utils
     for worksheet in source.worksheets:
         newws = Worksheet()
         newws.seq_no = worksheet.seq_no
         newws.identifier = worksheet.identifier
         newws.name = worksheet.name
         newws.assessable = worksheet.assessable
         newws.published = worksheet.published
         newws.data = worksheet.data
         newws.format = worksheet.format
         newws.offering = self
         Store.of(self).add(newws)
         ivle.worksheet.utils.update_exerciselist(newws)

    def new(cls, distribution, sourcepackagename,
            is_upstream_link_allowed=False):
        """Create a new DSP with the given parameters.

        Caches the `(distro_id, spn_id) --> dsp_id` mapping.
        """
        dsp = DistributionSourcePackageInDatabase()
        dsp.distribution = distribution
        dsp.sourcepackagename = sourcepackagename
        dsp.is_upstream_link_allowed = is_upstream_link_allowed
        Store.of(distribution).add(dsp)
        Store.of(distribution).flush()
        dsp_cache_key = distribution.id, sourcepackagename.id
        cls._cache[dsp_cache_key] = dsp.id
        return dsp