def test_fixture_module_string_5(self):
old_pkgs = getattr(settings, 'FIXTURE_PACKAGES', [])
settings.FIXTURE_PACKAGES = [
"class_fixtures.tests.some_fixture_modules",
]
try:
handlers = associate_handlers(['some_fixtures', 'moar_fixtures'])
some_module = import_module('class_fixtures.tests.fixtures.some_fixtures')
moar_module = import_module('class_fixtures.tests.some_fixture_modules.moar_fixtures')
self.assertEqual(handlers, [
('some_fixtures', 'django', None, None),
('some_fixtures', 'class_fixtures', 'submodule_name', some_module),
('moar_fixtures', 'django', None, None),
('moar_fixtures', 'class_fixtures', 'submodule_name', moar_module)
])
l = Loaddata()
l.stdout = sys.stdout
l.stderr = sys.stderr
l.handle('some_fixtures', 'moar_fixtures', verbosity=0)
self.assertEqual(Company.objects.count(), 1)
self.assertEqual(Employee.objects.count(), 2)
self.assertEqual(EmployeeHistory.objects.count(), 2)
self.assertEqual(Band.objects.count(), 1)
self.assertEqual(Musician.objects.count(), 1)
self.assertEqual(Membership.objects.count(), 1)
finally:
settings.FIXTURE_PACKAGES = old_pkgs
def test_appname_fixturemodule_string(self):
handlers = associate_handlers(['tests.some_fixtures'])
fixture_submodule = import_module('class_fixtures.tests.fixtures.some_fixtures')
self.assertEqual(handlers, [('tests.some_fixtures', 'class_fixtures', 'submodule_name', fixture_submodule)])
l = Loaddata()
l.stdout = sys.stdout
l.stderr = sys.stderr
l.handle('tests.some_fixtures', verbosity=0)
self.assertEqual(Company.objects.count(), 1)
self.assertEqual(Employee.objects.count(), 2)
self.assertEqual(EmployeeHistory.objects.count(), 2)
def test_fixture_module_string_3(self):
handlers = associate_handlers(['app_level_fixture.json'])
self.assertEqual(handlers, [('app_level_fixture.json', 'django', None, None)])
l = Loaddata()
l.stdout = sys.stdout
l.stderr = sys.stderr
l.handle('app_level_fixture.json', verbosity=0)
self.assertEqual(Band.objects.count(), 2)
self.assertEqual(MetalBand.objects.count(), 1)
self.assertEqual(Musician.objects.count(), 2)
self.assertEqual(Membership.objects.count(), 3)
self.assertEqual(Roadie.objects.count(), 1)
self.assertEqual(Company.objects.count(), 1)
self.assertEqual(Employee.objects.count(), 2)
self.assertEqual(EmployeeHistory.objects.count(), 2)
def test_fixture_module(self):
fixture_module = import_module('class_fixtures.tests.fixtures.other_fixtures')
handlers = associate_handlers([fixture_module])
self.assertEqual(handlers, [(fixture_module, 'class_fixtures', 'module', None)])
l = Loaddata()
l.stdout = sys.stdout
l.stderr = sys.stderr
l.handle(fixture_module, verbosity=0)
self.assertEqual(Band.objects.count(), 2)
self.assertEqual(MetalBand.objects.count(), 1)
self.assertEqual(Musician.objects.count(), 2)
self.assertEqual(Membership.objects.count(), 2)
self.assertEqual(Roadie.objects.count(), 3)
self.assertEqual(Company.objects.count(), 1)
self.assertEqual(Employee.objects.count(), 2)
self.assertEqual(EmployeeHistory.objects.count(), 2)
def test_appname_string(self):
handlers = associate_handlers(['tests'])
fixture_package = import_module('class_fixtures.tests.fixtures')
self.assertEqual(handlers, [('tests', 'class_fixtures', 'app_label', fixture_package)])
l = Loaddata()
l.stdout = sys.stdout
l.stderr = sys.stderr
l.handle('tests', verbosity=0)
# fixtures.some_fixtures and fixtures.other_fixtures contents combined
self.assertEqual(Band.objects.count(), 2)
self.assertEqual(MetalBand.objects.count(), 1)
self.assertEqual(Musician.objects.count(), 2)
self.assertEqual(Roadie.objects.count(), 3)
self.assertEqual(Membership.objects.count(), 2)
self.assertEqual(Company.objects.count(), 2)
self.assertEqual(Employee.objects.count(), 4)
self.assertEqual(EmployeeHistory.objects.count(), 4)
def test_fixture_module_string_4(self):
# Loads tests/testproject/project_fixtures/project_level_fixture.json
old_fixture_dirs = settings.FIXTURE_DIRS
settings.FIXTURE_DIRS = (os.path.join(os.path.dirname(os.path.abspath(__file__)), 'testproject/project_fixtures'),)
handlers = associate_handlers(['project_level_fixture'])
self.assertEqual(handlers, [('project_level_fixture', 'django', None, None)])
try:
l = Loaddata()
l.stdout = sys.stdout
l.stderr = sys.stderr
l.handle('project_level_fixture', verbosity=0)
finally:
settings.FIXTURE_DIRS = old_fixture_dirs
self.assertEqual(Band.objects.count(), 2)
self.assertEqual(MetalBand.objects.count(), 1)
self.assertEqual(Musician.objects.count(), 2)
self.assertEqual(Membership.objects.count(), 3)
self.assertEqual(Roadie.objects.count(), 1)
def handle(self, *fixture_labels, **options):
using = options.get('database', DEFAULT_DB_ALIAS)
connection = connections[using]
self.style = no_style()
show_traceback = options.get('traceback', False)
commit = options.get('commit', True)
# I'm sure there is a valid reason why Django's loaddata does this,
# so I'm just going to replicate its behaviour.
cursor = connection.cursor()
if commit:
transaction.commit_unless_managed(using=using)
transaction.enter_transaction_management(using=using)
transaction.managed(True, using=using)
total_object_count = 0
total_fixture_count = 0
do_initial_data = False
captured_outputs = []
original_verbosity = int(options.get('verbosity'))
# Mark this loaddata run as a special case for syncdb loading.
# Django's loaddata will be run first, ours second.
if fixture_labels == ('initial_data',):
# Assign a special handler type for initial data
fixture_handlers = [('initial_data', 'both_for_initial', None, None)]
else:
# Build a list of (label, handler, type, resolved_object) tuples.
fixture_handlers = associate_handlers(fixture_labels)
for label, handler, type_, obj in fixture_handlers:
if handler in ['django', 'both_for_initial']:
captured_stdout = StringIO()
# Need to assign manually; normally available to handle() via
# BaseCommand.execute(), but not when we're using it this way.
DjangoLoaddata.stdout = captured_stdout
DjangoLoaddata.stderr = self.stderr
# Capturing fixture counts from stdout requires forcing the
# verbosity option to a minimum of 1. If set higher by the
# user, respect that. Collect any extra messages for display.
if 'verbosity' in options:
options['verbosity'] = 1 if options['verbosity'] == 0 else options['verbosity']
else:
options['verbosity'] = 1
# We will either be in our own transaction handling or that of
# the script that called us, so disable transaction management
# inside Django's loaddata
options['commit'] = False
try:
if 'database' not in options:
options.update({'database': using})
DjangoLoaddata.handle(label, **options)
except Exception:
if commit:
transaction.rollback(using=using)
transaction.leave_transaction_management(using=using)
raise
django_object_count, django_fixture_count, other_msgs = process_django_output(captured_stdout.getvalue())
captured_stdout.close()
total_object_count += django_object_count
total_fixture_count += django_fixture_count
captured_outputs.extend(other_msgs)
if handler in ['class_fixtures', 'both_for_initial']:
if type_ == 'instance':
fixtures = [label]
elif type_ == 'module':
fixtures = get_fixtures_from_module(label)
elif type_ == 'submodule_name':
# obj is a reference to an individual submodule of
# the fixtures package of some app.
fixtures = get_fixtures_from_module(obj)
elif type_ == 'app_label':
# obj is a reference to the fixtures package of the
# app named in the label. Load all the fixture modules
# contained within, excluding initial_data.
fixtures = []
for importer, module_name, is_pkg in walk_packages(obj.__path__):
if module_name == 'initial_data':
continue
submodule = importer.find_module(module_name).load_module(module_name)
submod_fixtures = get_fixtures_from_module(submodule)
for submod_fixture in submod_fixtures:
# In case the user has a deeper submodule hierarchy in place
# with fixtures imported from submodule to submodule, make sure no fixture
# is included in the list twice through submodule discovery.
if submod_fixture not in fixtures:
fixtures.append(submod_fixture)
elif type_ is None and label == 'initial_data':
fixtures = gather_initial_data_fixtures()
try:
saved_set = set()
for fixture in fixtures:
saved_objects = fixture.load(using=using)
for obj in saved_objects.items():
saved_set.add(obj)
total_fixture_count += 1
total_object_count += len(saved_set)
except (SystemExit, KeyboardInterrupt):
raise
except Exception:
import traceback
if commit:
transaction.rollback(using=using)
transaction.leave_transaction_management(using=using)
if show_traceback:
traceback.print_exc()
else:
self.stderr.write(
self.style.ERROR("Problem installing class-based fixtures: %s" %
''.join(traceback.format_exception(sys.exc_type,
sys.exc_value, sys.exc_traceback))))
return
if commit:
transaction.commit(using=using)
transaction.leave_transaction_management(using=using)
# Same MySQL workaround as in Django's loaddata
if commit:
connection.close()
if total_fixture_count == 0:
if original_verbosity >= 1:
self.stdout.write("No fixtures found.\n")
else:
if original_verbosity >= 2 and captured_outputs:
# Prevent printing Django's result row along with our own
# when both handlers activate but only class-based fixtures
# are found.
if captured_outputs[-1].startswith('No fixtures found.'):
captured_outputs = captured_outputs[:-1]
self.stdout.write('\n'.join(captured_outputs) + '\n')
if original_verbosity >= 1:
# The original loaddata has another possible output format
# used when less objects were loaded than were present in the
# fixtures, but I don't care enough to implement it.
self.stdout.write("Installed %d object(s) from %d fixture(s)\n" %
(total_object_count, total_fixture_count))
def test_fixture_instance(self):
band_fixture = Fixture(Band)
handlers = associate_handlers([band_fixture])
self.assertEqual(handlers, [(band_fixture, 'class_fixtures', 'instance', None)])