1 import sys, time |
1 import sys, time |
|
2 from django.conf import settings |
2 from django.core import management |
3 from django.core import management |
3 |
4 from django.db.backends.creation import BaseDatabaseCreation |
4 # This dictionary maps Field objects to their associated Oracle column |
|
5 # types, as strings. Column-type strings can contain format strings; they'll |
|
6 # be interpolated against the values of Field.__dict__ before being output. |
|
7 # If a column type is set to None, it won't be included in the output. |
|
8 DATA_TYPES = { |
|
9 'AutoField': 'NUMBER(11)', |
|
10 'BooleanField': 'NUMBER(1) CHECK (%(column)s IN (0,1))', |
|
11 'CharField': 'NVARCHAR2(%(max_length)s)', |
|
12 'CommaSeparatedIntegerField': 'VARCHAR2(%(max_length)s)', |
|
13 'DateField': 'DATE', |
|
14 'DateTimeField': 'TIMESTAMP', |
|
15 'DecimalField': 'NUMBER(%(max_digits)s, %(decimal_places)s)', |
|
16 'FileField': 'NVARCHAR2(%(max_length)s)', |
|
17 'FilePathField': 'NVARCHAR2(%(max_length)s)', |
|
18 'FloatField': 'DOUBLE PRECISION', |
|
19 'ImageField': 'NVARCHAR2(%(max_length)s)', |
|
20 'IntegerField': 'NUMBER(11)', |
|
21 'IPAddressField': 'VARCHAR2(15)', |
|
22 'NullBooleanField': 'NUMBER(1) CHECK ((%(column)s IN (0,1)) OR (%(column)s IS NULL))', |
|
23 'OneToOneField': 'NUMBER(11)', |
|
24 'PhoneNumberField': 'VARCHAR2(20)', |
|
25 'PositiveIntegerField': 'NUMBER(11) CHECK (%(column)s >= 0)', |
|
26 'PositiveSmallIntegerField': 'NUMBER(11) CHECK (%(column)s >= 0)', |
|
27 'SlugField': 'NVARCHAR2(50)', |
|
28 'SmallIntegerField': 'NUMBER(11)', |
|
29 'TextField': 'NCLOB', |
|
30 'TimeField': 'TIMESTAMP', |
|
31 'URLField': 'VARCHAR2(%(max_length)s)', |
|
32 'USStateField': 'CHAR(2)', |
|
33 } |
|
34 |
5 |
35 TEST_DATABASE_PREFIX = 'test_' |
6 TEST_DATABASE_PREFIX = 'test_' |
36 PASSWORD = 'Im_a_lumberjack' |
7 PASSWORD = 'Im_a_lumberjack' |
37 REMEMBER = {} |
8 |
38 |
9 class DatabaseCreation(BaseDatabaseCreation): |
39 def create_test_db(settings, connection, verbosity=1, autoclobber=False): |
10 # This dictionary maps Field objects to their associated Oracle column |
40 TEST_DATABASE_NAME = _test_database_name(settings) |
11 # types, as strings. Column-type strings can contain format strings; they'll |
41 TEST_DATABASE_USER = _test_database_user(settings) |
12 # be interpolated against the values of Field.__dict__ before being output. |
42 TEST_DATABASE_PASSWD = _test_database_passwd(settings) |
13 # If a column type is set to None, it won't be included in the output. |
43 TEST_DATABASE_TBLSPACE = _test_database_tblspace(settings) |
14 # |
44 TEST_DATABASE_TBLSPACE_TMP = _test_database_tblspace_tmp(settings) |
15 # Any format strings starting with "qn_" are quoted before being used in the |
45 |
16 # output (the "qn_" prefix is stripped before the lookup is performed. |
46 parameters = { |
17 |
47 'dbname': TEST_DATABASE_NAME, |
18 data_types = { |
48 'user': TEST_DATABASE_USER, |
19 'AutoField': 'NUMBER(11)', |
49 'password': TEST_DATABASE_PASSWD, |
20 'BooleanField': 'NUMBER(1) CHECK (%(qn_column)s IN (0,1))', |
50 'tblspace': TEST_DATABASE_TBLSPACE, |
21 'CharField': 'NVARCHAR2(%(max_length)s)', |
51 'tblspace_temp': TEST_DATABASE_TBLSPACE_TMP, |
22 'CommaSeparatedIntegerField': 'VARCHAR2(%(max_length)s)', |
52 } |
23 'DateField': 'DATE', |
53 |
24 'DateTimeField': 'TIMESTAMP', |
54 REMEMBER['user'] = settings.DATABASE_USER |
25 'DecimalField': 'NUMBER(%(max_digits)s, %(decimal_places)s)', |
55 REMEMBER['passwd'] = settings.DATABASE_PASSWORD |
26 'FileField': 'NVARCHAR2(%(max_length)s)', |
56 |
27 'FilePathField': 'NVARCHAR2(%(max_length)s)', |
57 cursor = connection.cursor() |
28 'FloatField': 'DOUBLE PRECISION', |
58 if _test_database_create(settings): |
29 'IntegerField': 'NUMBER(11)', |
59 if verbosity >= 1: |
30 'IPAddressField': 'VARCHAR2(15)', |
60 print 'Creating test database...' |
31 'NullBooleanField': 'NUMBER(1) CHECK ((%(qn_column)s IN (0,1)) OR (%(qn_column)s IS NULL))', |
61 try: |
32 'OneToOneField': 'NUMBER(11)', |
62 _create_test_db(cursor, parameters, verbosity) |
33 'PositiveIntegerField': 'NUMBER(11) CHECK (%(qn_column)s >= 0)', |
63 except Exception, e: |
34 'PositiveSmallIntegerField': 'NUMBER(11) CHECK (%(qn_column)s >= 0)', |
64 sys.stderr.write("Got an error creating the test database: %s\n" % e) |
35 'SlugField': 'NVARCHAR2(50)', |
65 if not autoclobber: |
36 'SmallIntegerField': 'NUMBER(11)', |
66 confirm = raw_input("It appears the test database, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_DATABASE_NAME) |
37 'TextField': 'NCLOB', |
67 if autoclobber or confirm == 'yes': |
38 'TimeField': 'TIMESTAMP', |
68 try: |
39 'URLField': 'VARCHAR2(%(max_length)s)', |
69 if verbosity >= 1: |
40 } |
70 print "Destroying old test database..." |
41 |
71 _destroy_test_db(cursor, parameters, verbosity) |
42 remember = {} |
72 if verbosity >= 1: |
43 |
73 print "Creating test database..." |
44 def _create_test_db(self, verbosity=1, autoclobber=False): |
74 _create_test_db(cursor, parameters, verbosity) |
45 TEST_DATABASE_NAME = self._test_database_name(settings) |
75 except Exception, e: |
46 TEST_DATABASE_USER = self._test_database_user(settings) |
76 sys.stderr.write("Got an error recreating the test database: %s\n" % e) |
47 TEST_DATABASE_PASSWD = self._test_database_passwd(settings) |
77 sys.exit(2) |
48 TEST_DATABASE_TBLSPACE = self._test_database_tblspace(settings) |
|
49 TEST_DATABASE_TBLSPACE_TMP = self._test_database_tblspace_tmp(settings) |
|
50 |
|
51 parameters = { |
|
52 'dbname': TEST_DATABASE_NAME, |
|
53 'user': TEST_DATABASE_USER, |
|
54 'password': TEST_DATABASE_PASSWD, |
|
55 'tblspace': TEST_DATABASE_TBLSPACE, |
|
56 'tblspace_temp': TEST_DATABASE_TBLSPACE_TMP, |
|
57 } |
|
58 |
|
59 self.remember['user'] = settings.DATABASE_USER |
|
60 self.remember['passwd'] = settings.DATABASE_PASSWORD |
|
61 |
|
62 cursor = self.connection.cursor() |
|
63 if self._test_database_create(settings): |
|
64 if verbosity >= 1: |
|
65 print 'Creating test database...' |
|
66 try: |
|
67 self._execute_test_db_creation(cursor, parameters, verbosity) |
|
68 except Exception, e: |
|
69 sys.stderr.write("Got an error creating the test database: %s\n" % e) |
|
70 if not autoclobber: |
|
71 confirm = raw_input("It appears the test database, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_DATABASE_NAME) |
|
72 if autoclobber or confirm == 'yes': |
|
73 try: |
|
74 if verbosity >= 1: |
|
75 print "Destroying old test database..." |
|
76 self._execute_test_db_destruction(cursor, parameters, verbosity) |
|
77 if verbosity >= 1: |
|
78 print "Creating test database..." |
|
79 self._execute_test_db_creation(cursor, parameters, verbosity) |
|
80 except Exception, e: |
|
81 sys.stderr.write("Got an error recreating the test database: %s\n" % e) |
|
82 sys.exit(2) |
|
83 else: |
|
84 print "Tests cancelled." |
|
85 sys.exit(1) |
|
86 |
|
87 if self._test_user_create(settings): |
|
88 if verbosity >= 1: |
|
89 print "Creating test user..." |
|
90 try: |
|
91 self._create_test_user(cursor, parameters, verbosity) |
|
92 except Exception, e: |
|
93 sys.stderr.write("Got an error creating the test user: %s\n" % e) |
|
94 if not autoclobber: |
|
95 confirm = raw_input("It appears the test user, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_DATABASE_USER) |
|
96 if autoclobber or confirm == 'yes': |
|
97 try: |
|
98 if verbosity >= 1: |
|
99 print "Destroying old test user..." |
|
100 self._destroy_test_user(cursor, parameters, verbosity) |
|
101 if verbosity >= 1: |
|
102 print "Creating test user..." |
|
103 self._create_test_user(cursor, parameters, verbosity) |
|
104 except Exception, e: |
|
105 sys.stderr.write("Got an error recreating the test user: %s\n" % e) |
|
106 sys.exit(2) |
|
107 else: |
|
108 print "Tests cancelled." |
|
109 sys.exit(1) |
|
110 |
|
111 settings.DATABASE_USER = TEST_DATABASE_USER |
|
112 settings.DATABASE_PASSWORD = TEST_DATABASE_PASSWD |
|
113 |
|
114 return settings.DATABASE_NAME |
|
115 |
|
116 def _destroy_test_db(self, test_database_name, verbosity=1): |
|
117 """ |
|
118 Destroy a test database, prompting the user for confirmation if the |
|
119 database already exists. Returns the name of the test database created. |
|
120 """ |
|
121 TEST_DATABASE_NAME = self._test_database_name(settings) |
|
122 TEST_DATABASE_USER = self._test_database_user(settings) |
|
123 TEST_DATABASE_PASSWD = self._test_database_passwd(settings) |
|
124 TEST_DATABASE_TBLSPACE = self._test_database_tblspace(settings) |
|
125 TEST_DATABASE_TBLSPACE_TMP = self._test_database_tblspace_tmp(settings) |
|
126 |
|
127 settings.DATABASE_USER = self.remember['user'] |
|
128 settings.DATABASE_PASSWORD = self.remember['passwd'] |
|
129 |
|
130 parameters = { |
|
131 'dbname': TEST_DATABASE_NAME, |
|
132 'user': TEST_DATABASE_USER, |
|
133 'password': TEST_DATABASE_PASSWD, |
|
134 'tblspace': TEST_DATABASE_TBLSPACE, |
|
135 'tblspace_temp': TEST_DATABASE_TBLSPACE_TMP, |
|
136 } |
|
137 |
|
138 self.remember['user'] = settings.DATABASE_USER |
|
139 self.remember['passwd'] = settings.DATABASE_PASSWORD |
|
140 |
|
141 cursor = self.connection.cursor() |
|
142 time.sleep(1) # To avoid "database is being accessed by other users" errors. |
|
143 if self._test_user_create(settings): |
|
144 if verbosity >= 1: |
|
145 print 'Destroying test user...' |
|
146 self._destroy_test_user(cursor, parameters, verbosity) |
|
147 if self._test_database_create(settings): |
|
148 if verbosity >= 1: |
|
149 print 'Destroying test database tables...' |
|
150 self._execute_test_db_destruction(cursor, parameters, verbosity) |
|
151 self.connection.close() |
|
152 |
|
153 def _execute_test_db_creation(self, cursor, parameters, verbosity): |
|
154 if verbosity >= 2: |
|
155 print "_create_test_db(): dbname = %s" % parameters['dbname'] |
|
156 statements = [ |
|
157 """CREATE TABLESPACE %(tblspace)s |
|
158 DATAFILE '%(tblspace)s.dbf' SIZE 20M |
|
159 REUSE AUTOEXTEND ON NEXT 10M MAXSIZE 100M |
|
160 """, |
|
161 """CREATE TEMPORARY TABLESPACE %(tblspace_temp)s |
|
162 TEMPFILE '%(tblspace_temp)s.dbf' SIZE 20M |
|
163 REUSE AUTOEXTEND ON NEXT 10M MAXSIZE 100M |
|
164 """, |
|
165 ] |
|
166 self._execute_statements(cursor, statements, parameters, verbosity) |
|
167 |
|
168 def _create_test_user(self, cursor, parameters, verbosity): |
|
169 if verbosity >= 2: |
|
170 print "_create_test_user(): username = %s" % parameters['user'] |
|
171 statements = [ |
|
172 """CREATE USER %(user)s |
|
173 IDENTIFIED BY %(password)s |
|
174 DEFAULT TABLESPACE %(tblspace)s |
|
175 TEMPORARY TABLESPACE %(tblspace_temp)s |
|
176 """, |
|
177 """GRANT CONNECT, RESOURCE TO %(user)s""", |
|
178 ] |
|
179 self._execute_statements(cursor, statements, parameters, verbosity) |
|
180 |
|
181 def _execute_test_db_destruction(self, cursor, parameters, verbosity): |
|
182 if verbosity >= 2: |
|
183 print "_execute_test_db_destruction(): dbname=%s" % parameters['dbname'] |
|
184 statements = [ |
|
185 'DROP TABLESPACE %(tblspace)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS', |
|
186 'DROP TABLESPACE %(tblspace_temp)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS', |
|
187 ] |
|
188 self._execute_statements(cursor, statements, parameters, verbosity) |
|
189 |
|
190 def _destroy_test_user(self, cursor, parameters, verbosity): |
|
191 if verbosity >= 2: |
|
192 print "_destroy_test_user(): user=%s" % parameters['user'] |
|
193 print "Be patient. This can take some time..." |
|
194 statements = [ |
|
195 'DROP USER %(user)s CASCADE', |
|
196 ] |
|
197 self._execute_statements(cursor, statements, parameters, verbosity) |
|
198 |
|
199 def _execute_statements(self, cursor, statements, parameters, verbosity): |
|
200 for template in statements: |
|
201 stmt = template % parameters |
|
202 if verbosity >= 2: |
|
203 print stmt |
|
204 try: |
|
205 cursor.execute(stmt) |
|
206 except Exception, err: |
|
207 sys.stderr.write("Failed (%s)\n" % (err)) |
|
208 raise |
|
209 |
|
210 def _test_database_name(self, settings): |
|
211 name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME |
|
212 try: |
|
213 if settings.TEST_DATABASE_NAME: |
|
214 name = settings.TEST_DATABASE_NAME |
|
215 except AttributeError: |
|
216 pass |
|
217 except: |
|
218 raise |
|
219 return name |
|
220 |
|
221 def _test_database_create(self, settings): |
|
222 name = True |
|
223 try: |
|
224 if settings.TEST_DATABASE_CREATE: |
|
225 name = True |
78 else: |
226 else: |
79 print "Tests cancelled." |
227 name = False |
80 sys.exit(1) |
228 except AttributeError: |
81 |
229 pass |
82 if _test_user_create(settings): |
230 except: |
83 if verbosity >= 1: |
231 raise |
84 print "Creating test user..." |
232 return name |
85 try: |
233 |
86 _create_test_user(cursor, parameters, verbosity) |
234 def _test_user_create(self, settings): |
87 except Exception, e: |
235 name = True |
88 sys.stderr.write("Got an error creating the test user: %s\n" % e) |
236 try: |
89 if not autoclobber: |
237 if settings.TEST_USER_CREATE: |
90 confirm = raw_input("It appears the test user, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_DATABASE_USER) |
238 name = True |
91 if autoclobber or confirm == 'yes': |
|
92 try: |
|
93 if verbosity >= 1: |
|
94 print "Destroying old test user..." |
|
95 _destroy_test_user(cursor, parameters, verbosity) |
|
96 if verbosity >= 1: |
|
97 print "Creating test user..." |
|
98 _create_test_user(cursor, parameters, verbosity) |
|
99 except Exception, e: |
|
100 sys.stderr.write("Got an error recreating the test user: %s\n" % e) |
|
101 sys.exit(2) |
|
102 else: |
239 else: |
103 print "Tests cancelled." |
240 name = False |
104 sys.exit(1) |
241 except AttributeError: |
105 |
242 pass |
106 connection.close() |
243 except: |
107 settings.DATABASE_USER = TEST_DATABASE_USER |
244 raise |
108 settings.DATABASE_PASSWORD = TEST_DATABASE_PASSWD |
245 return name |
109 |
246 |
110 management.call_command('syncdb', verbosity=verbosity, interactive=False) |
247 def _test_database_user(self, ettings): |
111 |
248 name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME |
112 # Get a cursor (even though we don't need one yet). This has |
249 try: |
113 # the side effect of initializing the test database. |
250 if settings.TEST_DATABASE_USER: |
114 cursor = connection.cursor() |
251 name = settings.TEST_DATABASE_USER |
115 |
252 except AttributeError: |
116 def destroy_test_db(settings, connection, old_database_name, verbosity=1): |
253 pass |
117 connection.close() |
254 except: |
118 |
255 raise |
119 TEST_DATABASE_NAME = _test_database_name(settings) |
256 return name |
120 TEST_DATABASE_USER = _test_database_user(settings) |
257 |
121 TEST_DATABASE_PASSWD = _test_database_passwd(settings) |
258 def _test_database_passwd(self, settings): |
122 TEST_DATABASE_TBLSPACE = _test_database_tblspace(settings) |
259 name = PASSWORD |
123 TEST_DATABASE_TBLSPACE_TMP = _test_database_tblspace_tmp(settings) |
260 try: |
124 |
261 if settings.TEST_DATABASE_PASSWD: |
125 settings.DATABASE_NAME = old_database_name |
262 name = settings.TEST_DATABASE_PASSWD |
126 settings.DATABASE_USER = REMEMBER['user'] |
263 except AttributeError: |
127 settings.DATABASE_PASSWORD = REMEMBER['passwd'] |
264 pass |
128 |
265 except: |
129 parameters = { |
266 raise |
130 'dbname': TEST_DATABASE_NAME, |
267 return name |
131 'user': TEST_DATABASE_USER, |
268 |
132 'password': TEST_DATABASE_PASSWD, |
269 def _test_database_tblspace(self, settings): |
133 'tblspace': TEST_DATABASE_TBLSPACE, |
270 name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME |
134 'tblspace_temp': TEST_DATABASE_TBLSPACE_TMP, |
271 try: |
135 } |
272 if settings.TEST_DATABASE_TBLSPACE: |
136 |
273 name = settings.TEST_DATABASE_TBLSPACE |
137 REMEMBER['user'] = settings.DATABASE_USER |
274 except AttributeError: |
138 REMEMBER['passwd'] = settings.DATABASE_PASSWORD |
275 pass |
139 |
276 except: |
140 cursor = connection.cursor() |
277 raise |
141 time.sleep(1) # To avoid "database is being accessed by other users" errors. |
278 return name |
142 if _test_user_create(settings): |
279 |
143 if verbosity >= 1: |
280 def _test_database_tblspace_tmp(self, settings): |
144 print 'Destroying test user...' |
281 name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME + '_temp' |
145 _destroy_test_user(cursor, parameters, verbosity) |
282 try: |
146 if _test_database_create(settings): |
283 if settings.TEST_DATABASE_TBLSPACE_TMP: |
147 if verbosity >= 1: |
284 name = settings.TEST_DATABASE_TBLSPACE_TMP |
148 print 'Destroying test database...' |
285 except AttributeError: |
149 _destroy_test_db(cursor, parameters, verbosity) |
286 pass |
150 connection.close() |
287 except: |
151 |
288 raise |
152 def _create_test_db(cursor, parameters, verbosity): |
289 return name |
153 if verbosity >= 2: |
|
154 print "_create_test_db(): dbname = %s" % parameters['dbname'] |
|
155 statements = [ |
|
156 """CREATE TABLESPACE %(tblspace)s |
|
157 DATAFILE '%(tblspace)s.dbf' SIZE 20M |
|
158 REUSE AUTOEXTEND ON NEXT 10M MAXSIZE 100M |
|
159 """, |
|
160 """CREATE TEMPORARY TABLESPACE %(tblspace_temp)s |
|
161 TEMPFILE '%(tblspace_temp)s.dbf' SIZE 20M |
|
162 REUSE AUTOEXTEND ON NEXT 10M MAXSIZE 100M |
|
163 """, |
|
164 ] |
|
165 _execute_statements(cursor, statements, parameters, verbosity) |
|
166 |
|
167 def _create_test_user(cursor, parameters, verbosity): |
|
168 if verbosity >= 2: |
|
169 print "_create_test_user(): username = %s" % parameters['user'] |
|
170 statements = [ |
|
171 """CREATE USER %(user)s |
|
172 IDENTIFIED BY %(password)s |
|
173 DEFAULT TABLESPACE %(tblspace)s |
|
174 TEMPORARY TABLESPACE %(tblspace_temp)s |
|
175 """, |
|
176 """GRANT CONNECT, RESOURCE TO %(user)s""", |
|
177 ] |
|
178 _execute_statements(cursor, statements, parameters, verbosity) |
|
179 |
|
180 def _destroy_test_db(cursor, parameters, verbosity): |
|
181 if verbosity >= 2: |
|
182 print "_destroy_test_db(): dbname=%s" % parameters['dbname'] |
|
183 statements = [ |
|
184 'DROP TABLESPACE %(tblspace)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS', |
|
185 'DROP TABLESPACE %(tblspace_temp)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS', |
|
186 ] |
|
187 _execute_statements(cursor, statements, parameters, verbosity) |
|
188 |
|
189 def _destroy_test_user(cursor, parameters, verbosity): |
|
190 if verbosity >= 2: |
|
191 print "_destroy_test_user(): user=%s" % parameters['user'] |
|
192 print "Be patient. This can take some time..." |
|
193 statements = [ |
|
194 'DROP USER %(user)s CASCADE', |
|
195 ] |
|
196 _execute_statements(cursor, statements, parameters, verbosity) |
|
197 |
|
198 def _execute_statements(cursor, statements, parameters, verbosity): |
|
199 for template in statements: |
|
200 stmt = template % parameters |
|
201 if verbosity >= 2: |
|
202 print stmt |
|
203 try: |
|
204 cursor.execute(stmt) |
|
205 except Exception, err: |
|
206 sys.stderr.write("Failed (%s)\n" % (err)) |
|
207 raise |
|
208 |
|
209 def _test_database_name(settings): |
|
210 name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME |
|
211 try: |
|
212 if settings.TEST_DATABASE_NAME: |
|
213 name = settings.TEST_DATABASE_NAME |
|
214 except AttributeError: |
|
215 pass |
|
216 except: |
|
217 raise |
|
218 return name |
|
219 |
|
220 def _test_database_create(settings): |
|
221 name = True |
|
222 try: |
|
223 if settings.TEST_DATABASE_CREATE: |
|
224 name = True |
|
225 else: |
|
226 name = False |
|
227 except AttributeError: |
|
228 pass |
|
229 except: |
|
230 raise |
|
231 return name |
|
232 |
|
233 def _test_user_create(settings): |
|
234 name = True |
|
235 try: |
|
236 if settings.TEST_USER_CREATE: |
|
237 name = True |
|
238 else: |
|
239 name = False |
|
240 except AttributeError: |
|
241 pass |
|
242 except: |
|
243 raise |
|
244 return name |
|
245 |
|
246 def _test_database_user(settings): |
|
247 name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME |
|
248 try: |
|
249 if settings.TEST_DATABASE_USER: |
|
250 name = settings.TEST_DATABASE_USER |
|
251 except AttributeError: |
|
252 pass |
|
253 except: |
|
254 raise |
|
255 return name |
|
256 |
|
257 def _test_database_passwd(settings): |
|
258 name = PASSWORD |
|
259 try: |
|
260 if settings.TEST_DATABASE_PASSWD: |
|
261 name = settings.TEST_DATABASE_PASSWD |
|
262 except AttributeError: |
|
263 pass |
|
264 except: |
|
265 raise |
|
266 return name |
|
267 |
|
268 def _test_database_tblspace(settings): |
|
269 name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME |
|
270 try: |
|
271 if settings.TEST_DATABASE_TBLSPACE: |
|
272 name = settings.TEST_DATABASE_TBLSPACE |
|
273 except AttributeError: |
|
274 pass |
|
275 except: |
|
276 raise |
|
277 return name |
|
278 |
|
279 def _test_database_tblspace_tmp(settings): |
|
280 name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME + '_temp' |
|
281 try: |
|
282 if settings.TEST_DATABASE_TBLSPACE_TMP: |
|
283 name = settings.TEST_DATABASE_TBLSPACE_TMP |
|
284 except AttributeError: |
|
285 pass |
|
286 except: |
|
287 raise |
|
288 return name |
|