def tearDown(self):
     store = new_store()
     for person in store.find(Person, name=NAME):
         store.remove(person)
     store.commit()
     DomainTest.tearDown(self)
     store.close()

    def tearDown(self):
        # Make sure to remove all committed persons from the database
        with new_store() as store:
            test_names = [u'dummy transaction test', u'dummy', u'doe', u'john']
            store.find(Person, Person.name.is_in(test_names)).remove()

        DomainTest.tearDown(self)

    def setUpClass(cls):
        DomainTest.setUpClass()
        RECREATE_SQL = """
        DROP TABLE IF EXISTS dung;
        DROP TABLE IF EXISTS dong;
        DROP TABLE IF EXISTS ding;

        CREATE TABLE ding (
            id uuid PRIMARY KEY DEFAULT uuid_generate_v1(),
            te_id bigint UNIQUE REFERENCES transaction_entry(id),
            int_field integer default 0,
            str_field text default ''
        );
        CREATE TABLE dong (
            id uuid PRIMARY KEY DEFAULT uuid_generate_v1(),
            te_id bigint UNIQUE REFERENCES transaction_entry(id),
            bool_field boolean default false,
            ding_id uuid REFERENCES ding(id) ON UPDATE CASCADE
        );
        CREATE TABLE dung (
            id uuid PRIMARY KEY DEFAULT uuid_generate_v1(),
            identifier SERIAL NOT NULL,
            te_id bigint UNIQUE REFERENCES transaction_entry(id),
            ding_id uuid REFERENCES ding(id) ON UPDATE CASCADE
        );
        """
        cls.store.execute(RECREATE_SQL)
        cls.store.commit()

 def setUp(self):
     DomainTest.setUp(self)
     self._base_category = SellableCategory(description=u"Cigarro",
                                            store=self.store)
     self._category = SellableCategory(description=u"Hollywood",
                                       category=self._base_category,
                                       suggested_markup=10,
                                       store=self.store)

 def tearDown(self):
     DomainTest.tearDown(self)
     try:
         os.unlink(self._filename)
     except OSError:
         pass
     if self._pdf_html:
         try:
             os.unlink(self._pdf_html)
         except OSError:
             pass

    def tearDown(self):
        sys.excepthook = self._old_hook
        DomainTest.tearDown(self)

        messages = test_system_notifier.reset()
        if messages:
            self.fail("Unhandled messages: %r, use @mock.patch()" % (
                messages, ))

        if self._unhandled_exceptions:
            self.fail("Unhandled exceptions: %r" % (
                self._unhandled_exceptions))

 def setUpClass(cls):
     DomainTest.setUpClass()
     RECREATE_SQL = """
     DROP TABLE IF EXISTS ding;
     CREATE TABLE ding (
         id uuid PRIMARY KEY DEFAULT uuid_generate_v1(),
         te_id bigint UNIQUE REFERENCES transaction_entry(id),
         int_field integer default 0,
         str_field text default ''
     );
     """
     cls.store.execute(RECREATE_SQL)
     cls.store.commit()

 def setUp(self):
     DomainTest.setUp(self)
     self._filename = tempfile.mktemp(prefix="stoqlib-test-boleto-",
                                      suffix=".pdf")
     self._pdf_html = None

 def setUp(self):
     DomainTest.setUp(self)
     sellable = self.create_sellable()
     self.product = Product(sellable=sellable,
                            store=self.store)

 def setUp(self):
     DomainTest.setUp(self)
     self.sparam = sysparam

 def setUp(self):
     DomainTest.setUp(self)
     self.qe = QueryExecuter(self.store)
     self.qe.set_search_spec(ClientCategory)
     self.sfilter = mock.Mock()
     self.qe.set_filter_columns(self.sfilter, ['name'])

 def setUp(self):
     DomainTest.setUp(self)
     self.branch = self.create_branch()

 def setUp(self):
     self._unhandled_exceptions = []
     self._old_hook = sys.excepthook
     sys.excepthook = self._except_hook
     test_system_notifier.reset()
     DomainTest.setUp(self)

 def setUpClass(cls):
     DomainTest.setUpClass()
     cls._ui = NFeUI()