def test_startDatabase(self):
     """Starts a TE and SM for a new database on a single host"""
     domain = None
     database = None
     try:
         domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD)
         
         num_dbs_before = domain.getDatabaseCount()
         peer = domain.getEntryPeer()
         
         sm = peer.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10)
         self.assertIsNotNone(sm)
         self.assertIs(sm.getPeer(), peer)
         self.assertIsNotNone(sm.getAddress())
         self.assertIsNotNone(sm.getPort())
         self.assertIsNotNone(sm.getPid())
         self.assertIsNotNone(sm.getHostname())
         self.assertIsNotNone(sm.getVersion())
         self.assertEqual(domain.getDatabaseCount(), num_dbs_before + 1)
         self.assertIn(sm, peer.getLocalProcesses())
         self.assertFalse(sm.isTransactional())
         
         database = domain.getDatabase(TEST_DB_NAME)
         self.assertIsNotNone(database)
         self.assertIn(database, domain.getDatabases())
         self.assertIs(database.getDomain(), domain)
         self.assertEqual(database.getName(), TEST_DB_NAME)
         self.assertEqual(database.getProcessCount(), 1)
         self.assertIn(sm, database.getProcesses())
         
         te = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10)
         self.assertIsNotNone(te)
         self.assertIs(te.getPeer(), peer)
         self.assertIsNotNone(te.getAddress())
         self.assertIsNotNone(te.getPort())
         self.assertIsNotNone(te.getPid())
         self.assertIsNotNone(te.getHostname())
         self.assertIsNotNone(te.getVersion())
         self.assertEqual(domain.getDatabaseCount(), num_dbs_before + 1)
         self.assertIn(te, peer.getLocalProcesses())
         self.assertTrue(te.isTransactional())
         
         self.assertEqual(database.getProcessCount(), 2)
         self.assertIn(te, database.getProcesses())
         self.assertEqual(sm.getVersion(), te.getVersion())
         self.assertIs(sm.getDatabase(), database)
         self.assertIs(te.getDatabase(), database)
         
         
     finally:
         self._cleanup(domain)
 def test_shutdownDomain(self):
     domain = None
     database = None
     try:
         domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD)
                     
         num_dbs_before = domain.getDatabaseCount()
         peer = domain.getEntryPeer()
         sm = peer.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10)
         te = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10)
         database = domain.getDatabase(TEST_DB_NAME)
         self.assertIsNotNone(database)
         domain.shutdown()
         time.sleep(1)
         database = domain.getDatabase(TEST_DB_NAME)
         self.assertIsNone(database)
         
     finally:
         self._cleanup(domain)
 def test_addProcess(self):
     domain = None
     database = None
     try:
         domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD)
         
         num_dbs_before = domain.getDatabaseCount()
         peer = domain.getEntryPeer()
         sm = peer.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10)
         te = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10)
         database = domain.getDatabase(TEST_DB_NAME)
         self.assertEqual(database.getProcessCount(), 2)
         
         new_te = peer.startTransactionEngine(TEST_DB_NAME, waitSeconds=10)
         self.assertTrue(new_te.waitForStatus('RUNNING', 10))
         self.assertEqual(database.getProcessCount(), 3)
         
     finally:
         self._cleanup(domain)