def forwards(self):
# Model 'Event'
db.create_table('events_event', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('title', models.CharField(max_length=255)),
('description', models.TextField()),
('start', models.DateField()),
('end', models.DateField()),
('location', models.CharField(max_length=255)),
('allowed_attendies', models.IntegerField(null=True, blank=True)),
('last_edited', models.DateField(auto_now = True)),
))
# Mock Models
Event = db.mock_model(model_name='Event', db_table='events_event', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[])
Contact = db.mock_model(model_name='Contact', db_table='contacts_contact', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[])
# M2M field 'Event.registrants'
db.create_table('events_event_registrants', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('event', models.ForeignKey(Event, null=False)),
('contact', models.ForeignKey(Contact, null=False))
))
db.send_create_signal('events', ['Event'])
def forwards(self):
# Mock Models
MIB = db.mock_model(model_name='MIB',
db_table='fm_mib',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
MIB = db.mock_model(model_name='MIB',
db_table='fm_mib',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Model 'MIBDependency'
db.create_table(
'fm_mibdependency',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('mib', models.ForeignKey(MIB, verbose_name=MIB)),
('requires_mib',
models.ForeignKey(MIB,
verbose_name="Requires MIB",
related_name="requiredbymib_set"))))
db.create_index('fm_mibdependency', ['mib_id', 'requires_mib_id'],
unique=True,
db_tablespace='')
db.send_create_signal('fm', ['MIBDependency'])
def forwards(self):
# Model 'Client'
db.create_table('project_client', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField(max_length=128, verbose_name=_('name'))),
))
# Mock Models
Team = db.mock_model(model_name='Team', db_table='teams_team', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
Client = db.mock_model(model_name='Client', db_table='project_client', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Model 'Project'
db.create_table('project_project', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField(max_length=128, verbose_name=_('name'))),
('team', models.ForeignKey(Team, null=True, blank = True, verbose_name=_('team'))),
('client', models.ForeignKey(Client, null=True, blank=True, verbose_name=_('client'))),
('deadline', models.DateField(null=True, blank=True, verbose_name=_('deadline'))),
))
# Mock Models
Project = db.mock_model(model_name='Project', db_table='project_project', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# M2M field 'Project.members'
db.create_table('project_project_members', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('project', models.ForeignKey(Project, null=False)),
('user', models.ForeignKey(User, null=False))
))
db.send_create_signal('project', ['Client','Project'])
def test_change_foreign_key_target(self):
# Tables for FK to target
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
db.create_table("test_fk_changed_target", [
('eggs', models.IntegerField(primary_key=True)),
])
Egg = db.mock_model(model_name='Egg', db_table='test_fk_changed_target', db_tablespace='', pk_field_name='eggs', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Table with a foreign key to the wrong table
db.create_table("test_fk_changing", [
('egg', models.ForeignKey(User, null=True)),
])
db.execute_deferred_sql()
# Change foreign key pointing
db.alter_column("test_fk_changing", "egg_id", models.ForeignKey(Egg, null=True))
db.execute_deferred_sql()
# Test that it is pointing at the right table now
try:
non_user_id = db.execute("SELECT MAX(id) FROM auth_user")[0][0] + 1
except (TypeError, IndexError):
# Got a "None" or no records, treat as 0
non_user_id = 17
db.execute("INSERT INTO test_fk_changed_target (eggs) VALUES (%s)", [non_user_id])
db.execute("INSERT INTO test_fk_changing (egg_id) VALUES (%s)", [non_user_id])
db.commit_transaction()
db.start_transaction() # The test framework expects tests to end in transaction
def backwards(self):
# Mock Models
DNSZoneProfile = db.mock_model(model_name='DNSZoneProfile',
db_table='dns_dnszoneprofile',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
DNSServer = db.mock_model(model_name='DNSServer',
db_table='dns_dnsserver',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# M2M field 'DNSZoneProfile.slaves'
db.create_table(
'dns_dnszoneprofile_ns_servers',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('dnszoneprofile', models.ForeignKey(DNSZoneProfile, null=False)),
('dnsserver', models.ForeignKey(DNSServer, null=False))))
db.execute(
"INSERT INTO dns_dnszoneprofile_ns_servers(dnszoneprofile_id,dnsserver_id) SELECT dnszoneprofile_id,dnsserver_id FROM dns_dnszoneprofile_masters UNION SELECT dnszoneprofile_id,dnsserver_id FROM dns_dnszoneprofile_slaves"
)
db.delete_table('dns_dnszoneprofile_masters')
db.delete_table('dns_dnszoneprofile_slaves')
def forwards(self):
# Model 'DNSServer'
db.create_table(
'dns_dnsserver',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField("Name", max_length=64, unique=True)),
('description',
models.CharField(
"Description", max_length=128, blank=True, null=True)),
('location',
models.CharField(
"Location", max_length=128, blank=True, null=True))))
# M2M field 'DNSZoneProfile.ns_servers'
DNSZoneProfile = db.mock_model(model_name='DNSZoneProfile',
db_table='dns_dnszoneprofile',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
DNSServer = db.mock_model(model_name='DNSServer',
db_table='dns_dnsserver',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
db.create_table(
'dns_dnszoneprofile_ns_servers',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('dnszoneprofile', models.ForeignKey(DNSZoneProfile, null=False)),
('dnsserver', models.ForeignKey(DNSServer, null=False))))
db.send_create_signal('dns', ['DNSServer'])
def forwards(self):
# Mock Models
KBEntry = db.mock_model(model_name="KBEntry",
db_table="kb_kbentry",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
User = db.mock_model(model_name="User",
db_table="auth_user",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
# Model "KBEntryPreviewLog"
db.create_table(
"kb_kbentrypreviewlog",
(("id",
models.AutoField(
verbose_name="ID", primary_key=True, auto_created=True)),
("kb_entry", models.ForeignKey(KBEntry, verbose_name="KB Entry")),
("timestamp", models.DateTimeField("Timestamp",
auto_now_add=True)),
("user", models.ForeignKey(User, verbose_name=User))))
db.send_create_signal("kb", ["KBEntryPreviewLog"])
def forwards(self):
# Model 'RPSL'
db.create_table('cm_rpsl', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('repo_path', models.CharField("Repo Path",max_length=128,unique=True)),
('push_every', models.PositiveIntegerField("Push Every (secs)",default=86400,blank=True,null=True)),
('next_push', models.DateTimeField("Next Push",blank=True,null=True)),
('last_push', models.DateTimeField("Last Push",blank=True,null=True)),
('pull_every', models.PositiveIntegerField("Pull Every (secs)",default=86400,blank=True,null=True)),
('next_pull', models.DateTimeField("Next Pull",blank=True,null=True)),
('last_pull', models.DateTimeField("Last Pull",blank=True,null=True))
))
# Mock Models
RPSL = db.mock_model(model_name='RPSL', db_table='cm_rpsl', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
ObjectCategory = db.mock_model(model_name='ObjectCategory', db_table='cm_objectcategory', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# M2M field 'RPSL.categories'
db.create_table('cm_rpsl_categories', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('rpsl', models.ForeignKey(RPSL, null=False)),
('objectcategory', models.ForeignKey(ObjectCategory, null=False))
))
db.send_create_signal('cm', ['RPSL'])
def forwards(self):
VCDomain = db.mock_model(model_name='VCDomain',
db_table='vc_vcdomain',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
ManagedObjectSelector = db.mock_model(
model_name='ManagedObjectSelector',
db_table='sa_managedobjectselector',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Adding model 'VCDomainProvisioningConfig'
db.create_table('vc_vcdomainprovisioningconfig', (
('id', models.AutoField(primary_key=True)),
('vc_domain', models.ForeignKey(VCDomain,
verbose_name="VC Domain")),
('selector',
models.ForeignKey(ManagedObjectSelector,
verbose_name="Managed Object Selector")),
('key', models.CharField("Key", max_length=64)),
('value', models.CharField("Value", max_length=256)),
))
db.send_create_signal('vc', ['VCDomainProvisioningConfig'])
# Creating unique_together for [vc_domain, selector, key] on VCDomainProvisioningConfig.
db.create_unique('vc_vcdomainprovisioningconfig',
['vc_domain_id', 'selector_id', 'key'])
db.add_column(
"vc_vcdomain", "enable_provisioning",
models.BooleanField("Enable Provisioning", default=False))
def forwards(self):
# Mock Models
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'Email'
db.create_table('emails_email', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('subject', models.CharField(max_length=255)),
('attachment', models.FileField(upload_to="attachments/%Y/%m/%d", blank=True)),
('message', models.TextField(blank=True)),
('status', models.CharField(choices=(('draft', 'draft'),('template','template'),('sent','sent mail')), max_length=9)),
('user', models.ForeignKey(User, related_name="whocaresthiswillneverbereferenced")),
('last_edited', models.DateField(auto_now = True)),
))
# Mock Models
Email = db.mock_model(model_name='Email', db_table='emails_email', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
Contact = db.mock_model(model_name='Contact', db_table='contacts_contact', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# M2M field 'Email.recipients'
db.create_table('emails_email_recipients', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('email', models.ForeignKey(Email, null=False)),
('contact', models.ForeignKey(Contact, null=False))
))
db.send_create_signal('emails', ['Email'])
def forwards(self):
# Adding model 'TimeSeries'
db.create_table('pm_timeseries', (
('id', models.AutoField(primary_key=True)),
('name', models.CharField("Name", unique=True, max_length=128)),
('is_enabled', models.BooleanField("Is Enabled?", default=True)),
))
db.send_create_signal('pm', ['TimeSeries'])
TimeSeries = db.mock_model(model_name='TimeSeries', db_table='pm_timeseries', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Adding model 'TimeSeriesData'
db.create_table('pm_timeseriesdata', (
('id', models.AutoField(primary_key=True)),
('time_series', models.ForeignKey(TimeSeries, verbose_name="Time Series")),
('timestamp', models.IntegerField("Timestamp")),
('value', models.FloatField("Value", null=True, blank=True)),
))
db.create_index('pm_timeseriesdata', ['timestamp'], unique=False, db_tablespace='')
db.send_create_signal('pm', ['TimeSeriesData'])
#
db.create_table('pm_chart', (
('id', models.AutoField(primary_key=True)),
('name', models.CharField("Name", unique=True, max_length=128)),
))
db.send_create_signal('pm', ['Chart'])
Chart = db.mock_model(model_name='Chart', db_table='pm_chart', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
#
db.create_table('pm_chart_time_series', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('chart', models.ForeignKey(Chart, null=False)),
('timeseries', models.ForeignKey(TimeSeries, null=False))
))
#
db.execute(SP_CREATE)
def forwards(self):
# Model 'Platform'
db.create_table('downloads_platform', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField(_('name'), max_length=255)),
('slug', models.SlugField(_('slug'), max_length=255, unique=True)),
))
# Model 'Release'
db.create_table('downloads_release', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('version', models.CharField(_('version'), max_length=64, help_text=_("The version string used in the URL and on the download page. Please don't use spaces here."))),
('description', models.TextField(_('description'), blank=True)),
('changelog', models.TextField(_('changelog'), blank=True, help_text=_("The changelog displayed at http://fritzing.org/downloads/history-changes/. HTML is allowed."))),
('known_issues', models.TextField(_('known issues'), blank=True, help_text=_("The known issues displayed at http://fritzing.org/downloads/known-issues/. HTML is allowed."))),
('release_date', models.DateTimeField(_('date released'), default=datetime.now)),
('active', models.BooleanField(_('active'), default=True)),
))
# Mock Models
Release = db.mock_model(model_name='Release', db_table='downloads_release', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
Platform = db.mock_model(model_name='Platform', db_table='downloads_platform', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Model 'Download'
db.create_table('downloads_download', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('release', models.ForeignKey(Release, verbose_name=_('release'))),
('platform', models.ForeignKey(Platform, verbose_name=_('platform'))),
('filename', models.FileField(_('file'), upload_to='downloads', blank=True, null=True)),
('mime_type', models.CharField(_('mime type'), max_length=255, blank=True, null=True)),
('counter', models.IntegerField(_('counter'), default=0)),
))
db.send_create_signal('downloads', ['Platform','Release','Download'])
def forwards(self):
AFI_CHOICES = [
("4", "IPv4"),
("6", "IPv6")
]
VRF = db.mock_model(
model_name="VRF", db_table="ip_vrf", db_tablespace="",
pk_field_name="id", pk_field_type=models.AutoField
)
TerminationGroup = db.mock_model(
model_name="TerminationGroup", db_table="sa_terminationgroup", db_tablespace="",
pk_field_name="id", pk_field_type=models.AutoField
)
# Adding model "IPv4AddressRange"
db.create_table("ip_ippool", (
("id", models.AutoField(primary_key=True)),
("termination_group", models.ForeignKey(TerminationGroup, verbose_name="Termination Group")),
("vrf", models.ForeignKey(VRF, verbose_name="VRF")),
("afi", models.CharField("Address Family", max_length=1, choices=AFI_CHOICES)),
("type", models.CharField("Type", max_length=1, choices=[
("D", "Dynamic"),
("S", "Static")
])),
("from_address", models.IPAddressField("From Address")),
("to_address", models.IPAddressField("To Address"))
))
db.send_create_signal("ip", ["IPPool"])
def forwards(self):
# Adding model 'GroupAccess'
Group=db.mock_model(model_name="Group",db_table="auth_group")
ManagedObjectSelector=db.mock_model(model_name="ManagedObjectSelector",db_table="sa_managedobjectselector")
db.create_table('sa_groupaccess', (
('id', models.AutoField(primary_key=True)),
('group', models.ForeignKey(Group,verbose_name="Group")),
('selector', models.ForeignKey(ManagedObjectSelector,verbose_name="Object Selector")),
))
db.send_create_signal('sa', ['GroupAccess'])
def forwards(self):
# Mock Models
Language = db.mock_model(model_name='Language', db_table='main_language', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'RefBook'
db.create_table('main_refbook', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField("Name",max_length=128,unique=True)),
('language', models.ForeignKey(Language,verbose_name=Language)),
('description', models.TextField("Description",blank=True,null=True)),
('is_enabled', models.BooleanField("Is Enabled",default=False)),
('is_builtin', models.BooleanField("Is Builtin",default=False)),
('downloader', models.CharField("Downloader",max_length=64,blank=True,null=True)),
("download_url", models.CharField("Download URL",max_length=256,null=True,blank=True)),
('last_updated', models.DateTimeField("Last Updated",blank=True,null=True)),
('next_update', models.DateTimeField("Next Update",blank=True,null=True)),
('refresh_interval', models.IntegerField("Refresh Interval (days)",default=0))
))
# Mock Models
RefBook = db.mock_model(model_name='RefBook', db_table='main_refbook', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'RefBookField'
db.create_table('main_refbookfield', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('ref_book', models.ForeignKey(RefBook,verbose_name="Ref Book")),
('name', models.CharField("Name",max_length="64")),
('order', models.IntegerField("Order")),
('is_required', models.BooleanField("Is Required",default=True)),
('description', models.TextField("Description",blank=True,null=True)),
('search_method', models.CharField("Search Method",max_length=64,blank=True,null=True)),
))
db.create_index('main_refbookfield', ['ref_book_id','order'], unique=True, db_tablespace='')
db.create_index('main_refbookfield', ['ref_book_id','name'], unique=True, db_tablespace='')
# Mock Models
RefBook = db.mock_model(model_name='RefBook', db_table='main_refbook', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
RefBookField = db.mock_model(model_name='RefBookField', db_table='main_refbookfield', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'RefBookData'
db.create_table('main_refbookdata', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('ref_book', models.ForeignKey(RefBook,verbose_name="Ref Book")),
('record_id', models.IntegerField("ID")),
('field', models.ForeignKey(RefBookField,verbose_name="Field")),
('value', models.TextField("Value",null=True,blank=True))
))
db.create_index('main_refbookdata', ['ref_book_id','record_id','field_id'], unique=True, db_tablespace='')
db.send_create_signal('main', ['RefBook','RefBookField','RefBookData'])
def forwards(self):
# Mock Models
Event = db.mock_model(model_name='Event',
db_table='fm_event',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Model 'EventRepeat'
db.create_table(
'fm_eventrepeat',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('event', models.ForeignKey(Event, verbose_name="Event")),
('timestamp', models.DateTimeField("Timestamp"))))
# Mock Models
EventClass = db.mock_model(model_name='EventClass',
db_table='fm_eventclass',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Model 'EventClassVar'
db.create_table(
'fm_eventclassvar',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('event_class',
models.ForeignKey(EventClass, verbose_name="Event Class")),
('name', models.CharField("Name", max_length=64)),
('required', models.BooleanField("Required", default=True)),
('repeat_suppression',
models.BooleanField("Repeat Suppression", default=False))))
db.create_index('fm_eventclassvar', ['event_class_id', 'name'],
unique=True,
db_tablespace='')
db.send_create_signal('fm', ['EventRepeat', 'EventClassVar'])
db.add_column('fm_eventclass', 'repeat_suppression',
models.BooleanField("Repeat Suppression", default=False))
db.add_column(
'fm_eventclass', 'repeat_suppression_interval',
models.IntegerField("Repeat Suppression interval (secs)",
default=3600))
# Migrate variables
for id, vars in db.execute("SELECT id,variables FROM fm_eventclass"):
if vars:
for v in [v.strip() for v in vars.split(",")]:
db.execute(
"INSERT INTO fm_eventclassvar(event_class_id,name,required,repeat_suppression) VALUES(%s,%s,true,false)",
[id, v])
db.delete_column('fm_eventclass', 'variables')
def test_add_unique_fk(self):
"""
Test adding a ForeignKey with unique=True or a OneToOneField
"""
db.create_table("test_add_unique_fk", [
('spam', models.BooleanField(default=False))
])
db.add_column("test_add_unique_fk", "mock1", models.ForeignKey(db.mock_model('Mock', 'mock'), null=True, unique=True))
db.add_column("test_add_unique_fk", "mock2", models.OneToOneField(db.mock_model('Mock', 'mock'), null=True))
db.delete_table("test_add_unique_fk")
def test_add_unique_fk(self):
"""
Test adding a ForeignKey with unique=True or a OneToOneField
"""
db.create_table("test_add_unique_fk", [
('spam', models.BooleanField(default=False))
])
db.add_column("test_add_unique_fk", "mock1", models.ForeignKey(db.mock_model('Mock', 'mock'), null=True, unique=True))
db.add_column("test_add_unique_fk", "mock2", models.OneToOneField(db.mock_model('Mock', 'mock'), null=True))
db.delete_table("test_add_unique_fk")
def test_add_unique_fk(self):
"""
Test adding a ForeignKey with unique=True or a OneToOneField
"""
db.create_table("test_add_unique_fk", [("spam", models.BooleanField(default=False))])
db.start_transaction()
db.add_column(
"test_add_unique_fk", "mock1", models.ForeignKey(db.mock_model("Mock", "mock"), null=True, unique=True)
)
db.add_column("test_add_unique_fk", "mock2", models.OneToOneField(db.mock_model("Mock", "mock"), null=True))
db.rollback_transaction()
db.delete_table("test_add_unique_fk")
def forwards(self):
TimePattern = db.mock_model(model_name='TimePattern',
db_table='main_timepattern',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
Language = db.mock_model(model_name='Language',
db_table='main_language',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
User = db.mock_model(model_name='User',
db_table='auth_user',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Adding model 'UserProfile'
db.create_table('main_userprofile', (
('id', models.AutoField(primary_key=True)),
('preferred_language',
models.ForeignKey(Language,
null=True,
verbose_name="Preferred Language",
blank=True)),
('user', models.ForeignKey(User, unique=True)),
))
db.send_create_signal('main', ['UserProfile'])
UserProfile = db.mock_model(model_name='UserProfile',
db_table='main_userprofile',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Adding model 'UserProfileContact'
db.create_table('main_userprofilecontact', (
('user_profile',
models.ForeignKey(UserProfile, verbose_name="User Profile")),
('notification_method', models.CharField("Method", max_length=16)),
('params', models.CharField("Params", max_length=256)),
('time_pattern',
models.ForeignKey(TimePattern, verbose_name="Time Pattern")),
('id', models.AutoField(primary_key=True)),
))
db.send_create_signal('main', ['UserProfileContact'])
# Creating unique_together for [user_profile, time_pattern, notification_method, params] on UserProfileContact.
db.create_index('main_userprofilecontact', [
'user_profile_id', 'time_pattern_id', 'notification_method',
'params'
],
unique=True)
def forwards(self):
# Mock Models
Language = db.mock_model(model_name='Language',
db_table='main_language',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Model 'KBEntryTemplate'
db.create_table(
'kb_kbentrytemplate',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField("Name", max_length=128, unique=True)),
('subject', models.CharField("Subject", max_length=256)),
('body', models.TextField("Body")),
('language',
models.ForeignKey(Language,
verbose_name=Language,
limit_choices_to={"is_active": True})),
('markup_language',
models.CharField("Markup Language",
max_length="16",
choices=parser_registry.choices))))
# Mock Models
KBEntryTemplate = db.mock_model(model_name='KBEntryTemplate',
db_table='kb_kbentrytemplate',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
KBCategory = db.mock_model(model_name='KBCategory',
db_table='kb_kbcategory',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# M2M field 'KBEntryTemplate.categories'
db.create_table(
'kb_kbentrytemplate_categories',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('kbentrytemplate', models.ForeignKey(KBEntryTemplate,
null=False)),
('kbcategory', models.ForeignKey(KBCategory, null=False))))
db.send_create_signal('kb', ['KBEntryTemplate'])
def forwards(self):
# Mock Models
ContentType = db.mock_model(
model_name="ContentType",
db_table="django_content_type",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField,
pk_field_args=[],
)
# Model 'AttachedFile'
db.create_table(
"attachments_attachedfile",
(
("id", models.AutoField(verbose_name="ID", primary_key=True, auto_created=True)),
("name", models.CharField(max_length=255)),
("file", models.FileField(upload_to="attachments/files/%Y/%m")),
("content_type", models.ForeignKey(ContentType)),
("object_id", models.PositiveIntegerField()),
),
)
# Mock Models
ContentType = db.mock_model(
model_name="ContentType",
db_table="django_content_type",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField,
pk_field_args=[],
)
# Model 'AttachedImage'
db.create_table(
"attachments_attachedimage",
(
("id", models.AutoField(verbose_name="ID", primary_key=True, auto_created=True)),
("name", models.CharField(max_length=255)),
("link_to", models.URLField(blank=True)),
("display", models.PositiveIntegerField(default=1)),
("image", models.ImageField(upload_to="attachments/images/%Y/%m")),
("content_type", models.ForeignKey(ContentType)),
("object_id", models.PositiveIntegerField()),
),
)
db.send_create_signal("attachments", ["AttachedFile", "AttachedImage"])
def forwards(self):
Prefix = db.mock_model(model_name="Prefix",
db_table="ip_prefix", db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
Address = db.mock_model(model_name="Address",
db_table="ip_address", db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
db.add_column("ip_prefix", "ipv6_transition",
models.OneToOneField(Prefix, null=True, blank=True))
db.add_column("ip_address", "ipv6_transition",
models.OneToOneField(Address, null=True, blank=True))
def forwards(self):
# Model 'DNSZoneProfile'
db.create_table('dns_dnszoneprofile', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField("Name",max_length=32,unique=True)),
('zone_transfer_acl', models.CharField("named zone transfer ACL",max_length=64)),
('zone_ns_list', models.CharField("NS list",max_length=64)),
('zone_soa', models.CharField("SOA",max_length=64)),
('zone_contact', models.CharField("Contact",max_length=64)),
('zone_refresh', models.IntegerField("Refresh",default=3600)),
('zone_retry', models.IntegerField("Retry",default=900)),
('zone_expire', models.IntegerField("Expire",default=86400)),
('zone_ttl', models.IntegerField("TTL",default=3600))
))
# Mock Models
DNSZoneProfile = db.mock_model(model_name='DNSZoneProfile', db_table='dns_dnszoneprofile', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'DNSZone'
db.create_table('dns_dnszone', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField("Domain",max_length=64,unique=True)),
('description', models.CharField("Description",null=True,blank=True,max_length=64)),
('is_auto_generated', models.BooleanField("Auto generated?")),
('serial', models.CharField("Serial",max_length=10,default="0000000000")),
('profile', models.ForeignKey(DNSZoneProfile,verbose_name="Profile"))
))
# Model 'DNSZoneRecordType'
db.create_table('dns_dnszonerecordtype', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('type', models.CharField("Type",max_length=16,unique=True)),
))
# Mock Models
DNSZone = db.mock_model(model_name='DNSZone', db_table='dns_dnszone', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
DNSZoneRecordType = db.mock_model(model_name='DNSZoneRecordType', db_table='dns_dnszonerecordtype', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'DNSZoneRecord'
db.create_table('dns_dnszonerecord', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('zone', models.ForeignKey(DNSZone,verbose_name="Zone")),
('left', models.CharField("Left",max_length=32,blank=True,null=True)),
('type', models.ForeignKey(DNSZoneRecordType,verbose_name="Type")),
('right', models.CharField("Right",max_length=64))
))
db.send_create_signal('dns', ['DNSZoneProfile','DNSZone','DNSZoneRecordType','DNSZoneRecord'])
def forwards(self):
# Model 'TimePattern'
db.create_table(
'main_timepattern',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField("Name", max_length=64, unique=True)),
('description',
models.TextField("Description", null=True, blank=True))))
# Mock Models
TimePattern = db.mock_model(model_name='TimePattern',
db_table='main_timepattern',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Model 'TimePatternTerm'
db.create_table(
'main_timepatternterm',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('time_pattern',
models.ForeignKey(TimePattern, verbose_name="Time Pattern")),
('term', models.CharField("Term", max_length=256))))
db.create_index('main_timepatternterm', ['time_pattern_id', 'term'],
unique=True,
db_tablespace='')
db.send_create_signal('main', ['TimePattern', 'TimePatternTerm'])
def test_add_columns(self):
"""
Test adding columns
"""
db.create_table("test_addc", [
('spam', models.BooleanField(default=False)),
('eggs', models.IntegerField()),
])
# Add a column
db.add_column("test_addc", "add1", models.IntegerField(default=3))
User = db.mock_model(model_name='User',
db_table='auth_user',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField,
pk_field_args=[],
pk_field_kwargs={})
# insert some data so we can test the default value of the added fkey
db.execute(
"INSERT INTO test_addc (spam, eggs, add1) VALUES (%s, 1, 2)",
[False])
db.add_column("test_addc", "user", models.ForeignKey(User, null=True))
db.execute_deferred_sql()
# try selecting from the user_id column to make sure it was actually created
val = db.execute("SELECT user_id FROM test_addc")[0][0]
self.assertEquals(val, None)
db.delete_column("test_addc", "add1")
# make sure adding an indexed field works
db.add_column(
"test_addc", "add2",
models.CharField(max_length=15, db_index=True, default='pi'))
db.execute_deferred_sql()
db.delete_table("test_addc")
def forwards(self):
# Model 'CommunityType'
db.create_table(
'peer_communitytype',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('name',
models.CharField("Description", max_length=32, unique=True))))
# Mock Models
CommunityType = db.mock_model(model_name='CommunityType',
db_table='peer_communitytype',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Model 'Community'
db.create_table(
'peer_community',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('community',
models.CharField("Community", max_length=20, unique=True)),
('type', models.ForeignKey(CommunityType, verbose_name="Type")),
('description', models.CharField("Description", max_length=64))))
db.send_create_signal('peer', ['CommunityType', 'Community'])
def forwards(self):
# Mock Models
AuthProfile = db.mock_model(model_name="AuthProfile",
db_table="sa_authprofile",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
#
db.create_table(
"sa_authprofilesuggestsnmp",
(("id",
models.AutoField(
verbose_name="ID", primary_key=True, auto_created=True)),
("auth_profile", models.ForeignKey(AuthProfile)),
("snmp_ro",
models.CharField(
"RO Community", blank=True, null=True, max_length=64)),
("snmp_rw",
models.CharField(
"RW Community", blank=True, null=True, max_length=64))))
db.create_table(
"sa_authprofilesuggestcli",
(("id",
models.AutoField(
verbose_name="ID", primary_key=True, auto_created=True)),
("auth_profile", models.ForeignKey(AuthProfile)),
("user",
models.CharField("User", max_length=32, blank=True, null=True)),
("password",
models.CharField(
"Password", max_length=32, blank=True, null=True)),
("super_password",
models.CharField(
"Super Password", max_length=32, blank=True, null=True))))
def test_alter(self):
"""
Test altering columns/tables
"""
db.create_table("test4", [
('spam', models.BooleanField(default=False)),
('eggs', models.IntegerField()),
])
db.start_transaction()
# Add a column
db.add_column("test4",
"add1",
models.IntegerField(default=3),
keep_default=False)
# Add a FK with keep_default=False (#69)
User = db.mock_model(model_name='User',
db_table='auth_user',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField,
pk_field_args=[],
pk_field_kwargs={})
db.add_column("test4",
"user",
models.ForeignKey(User, null=True),
keep_default=False)
db.delete_column("test4", "add1")
db.rollback_transaction()
db.delete_table("test4")
def forwards(self):
# Create .state
ResourceState = db.mock_model(model_name="ResourceState",
db_table="main_resourcestate",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
db.add_column(
"ip_vrf", "state",
models.ForeignKey(ResourceState,
verbose_name="State",
null=True,
blank=True))
db.add_column(
"ip_prefix", "state",
models.ForeignKey(ResourceState,
verbose_name="State",
null=True,
blank=True))
db.add_column(
"ip_address", "state",
models.ForeignKey(ResourceState,
verbose_name="State",
null=True,
blank=True))
def forwards(self):
PrefixTable = db.mock_model(model_name="PrefixTable",
db_table="main_prefixtable",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
db.add_column(
"sa_activator", "prefix_table",
models.ForeignKey(PrefixTable,
verbose_name=_("Prefix Table"),
null=True,
blank=True))
# Migrate data
for id, name, ip, to_ip in db.execute(
"SELECT id, name, ip, to_ip FROM sa_activator"):
pt_name = "Activator::%s" % name
db.execute(
"""
INSERT INTO main_prefixtable(name)
VALUES(%s)
""", [pt_name])
pt_id, = db.execute(
"SELECT id FROM main_prefixtable WHERE name = %s",
[pt_name])[0]
for p in IPv4.range_to_prefixes(ip, to_ip):
db.execute(
"""
INSERT INTO main_prefixtableprefix(table_id, afi, prefix)
VALUES(%s, '4', %s)
""", [pt_id, p.prefix])
db.execute(
"UPDATE sa_activator SET prefix_table_id=%s WHERE id=%s",
[pt_id, id])
def test_add_columns(self):
"""
Test adding columns
"""
db.create_table("test_addc", [
('spam', models.BooleanField(default=False)),
('eggs', models.IntegerField()),
])
# Add a column
db.add_column("test_addc",
"add1",
models.IntegerField(default=3),
keep_default=False)
# Add a FK with keep_default=False (#69)
User = db.mock_model(model_name='User',
db_table='auth_user',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField,
pk_field_args=[],
pk_field_kwargs={})
# insert some data so we can test the default value of the added fkey
db.execute("INSERT INTO test_addc (eggs, add1) VALUES (1, 2)")
db.add_column("test_addc",
"user",
models.ForeignKey(User, null=True),
keep_default=False)
# try selecting from the user_id column to make sure it was actually created
val = db.execute("SELECT user_id FROM test_addc")[0][0]
self.assertEquals(val, None)
db.delete_column("test_addc", "add1")
db.delete_table("test_addc")
def forwards(self):
# Mock Models
User = db.mock_model(
model_name="User",
db_table="auth_user",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField,
pk_field_args=[],
pk_field_kwargs={},
)
# Model 'Staffer'
db.create_table(
"staff_staffer",
(
("id", models.AutoField(verbose_name="ID", primary_key=True, auto_created=True)),
("user", models.OneToOneField(User, blank=True, null=True, help_text="Optional, but recommended.")),
("slug", models.SlugField()),
("position", models.CharField(max_length=50)),
("first_name", models.CharField(max_length=30, blank=True)),
("last_name", models.CharField(max_length=30, blank=True)),
),
)
db.create_index("staff_staffer", ["first_name", "last_name"], unique=True, db_tablespace="")
db.send_create_signal("staff", ["Staffer"])
def forwards(self):
# Adding model 'VCBindFilter'
VCDomain=db.mock_model(model_name="VCDomain",db_table="vc_vcdomain")
VRF=db.mock_model(model_name="VRF",db_table="ip_vrf")
VCFilter=db.mock_model(model_name="VCFilter",db_table="vc_vcfilter")
db.create_table('vc_vcbindfilter', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('vc_domain', models.ForeignKey(VCDomain,verbose_name="VC Domain")),
('vrf', models.ForeignKey(VRF,verbose_name="VRF")),
('prefix', CIDRField("Prefix")),
('vc_filter', models.ForeignKey(VCFilter,verbose_name="VC Filter")),
))
db.send_create_signal('vc', ['VCBindFilter'])
# Adding field 'VCDomain.enable_vc_bind_filter'
db.add_column('vc_vcdomain', 'enable_vc_bind_filter', models.BooleanField("Enable VC Bind filter",default=False))
def forwards(self):
Template = db.mock_model(model_name='Template',
db_table='main_template',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
db.add_column(
"sa_managedobjectprofile", "config_mirror_storage",
DocumentReferenceField("main.ExtStorage", null=True, blank=True))
db.add_column(
"sa_managedobjectprofile", "config_mirror_template",
models.ForeignKey(Template,
verbose_name="Config Mirror Template",
blank=True,
null=True))
db.add_column(
"sa_managedobjectprofile", "config_mirror_policy",
models.CharField("Config Mirror Policy",
max_length=1,
choices=[("D", "Disable"), ("A", "Always"),
("C", "Change")],
default="C"))
db.add_column(
"sa_managedobjectprofile", "config_validation_policy",
models.CharField("Config Validation Policy",
max_length=1,
choices=[("D", "Disable"), ("A", "Always"),
("C", "Change")],
default="C"))
def forwards(self):
db.create_table("main_prefixtable", (
("id",
models.AutoField(
verbose_name="ID", primary_key=True, auto_created=True)),
("name", models.CharField(_("Name"), max_length=128, unique=True)),
("description",
models.TextField(_("Description"), null=True, blank=True)),
))
PrefixTable = db.mock_model(model_name="PrefixTable",
db_table="main_prefixtable",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
db.create_table(
"main_prefixtableprefix",
(("id",
models.AutoField(
verbose_name="ID", primary_key=True, auto_created=True)),
("table",
models.ForeignKey(PrefixTable, verbose_name=_("Prefix Table"))),
("afi",
models.CharField(_("Address Family"),
max_length=1,
choices=[("4", _("IPv4")), ("6", _("IPv6"))])),
("prefix", CIDRField(_("Prefix")))))
db.send_create_signal("main", ["PrefixTable", "PrefixTablePrefix"])
def forwards(self):
# TimePattern
TimePattern = db.mock_model(model_name="TimePattern",
db_table="main_timepattern",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
# Model "TaskSchedule"
db.create_table(
"main_schedule",
(("id",
models.AutoField(
verbose_name="ID", primary_key=True, auto_created=True)),
("periodic_name", models.CharField("Periodic Task",
max_length=64)),
("is_enabled", models.BooleanField("Enabled?", default=False)),
("time_pattern",
models.ForeignKey(TimePattern, verbose_name="Time Pattern")),
("run_every",
models.PositiveIntegerField("Run Every (secs)", default=86400)),
("timeout",
models.PositiveIntegerField(
"Timeout (secs)", null=True, blank=True)),
("last_run",
models.DateTimeField("Last Run", blank=True, null=True)),
("last_status", models.BooleanField("Last Status",
default=True))))
db.send_create_signal("main", ["Schedule"])
def forwards(self):
# Mock model
ArticleCategory = db.mock_model(model_name='ArticleCategory', db_table='articles_articlecategory', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Adding field 'ArticleCategory.parent'
db.add_column('articles_articlecategory', 'parent', models.ForeignKey(ArticleCategory, verbose_name=_("Parent Category"), limit_choices_to={ "parent__isnull": True, }, blank=True, null=True, related_name="sub_categories"))
def forwards(self):
db.create_table("main_template", (
("id",
models.AutoField(
verbose_name="ID", primary_key=True, auto_created=True)),
("name", models.CharField(_("Name"), unique=True, max_length=128)),
("subject", models.TextField(_("Subject"))),
("body", models.TextField(_("Body"))),
))
Template = db.mock_model(model_name="Template",
db_table="main_template",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField)
db.create_table("main_systemtemplate", (
("id",
models.AutoField(
verbose_name="ID", primary_key=True, auto_created=True)),
("name", models.CharField(_("Name"), max_length=64, unique=True)),
("description",
models.TextField(_("Description"), null=True, blank=True)),
("template", models.ForeignKey(Template,
verbose_name=_("Template"))),
))
db.send_create_signal("main", ["Template", "SystemTemplate"])
def forwards(self):
# Mock Models
Event = db.mock_model(model_name='Event', db_table='events_event', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[])
Contact = db.mock_model(model_name='Contact', db_table='contacts_contact', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[])
# Model 'Registrant'
db.create_table('events_registrant', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('event', models.ForeignKey(Event)),
('contact', models.ForeignKey(Contact)),
('pending', models.BooleanField(default=True)),
))
db.send_create_signal('events', ['Registrant'])
def forwards(self):
# Model 'MIB'
db.create_table(
'fm_mib',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField("Name", max_length=64, unique=True)),
('description',
models.TextField("Description", blank=True, null=True)),
('last_updated', models.DateTimeField("Last Updated")),
('uploaded', models.DateTimeField("Uploaded"))))
# Mock Models
MIB = db.mock_model(model_name='MIB',
db_table='fm_mib',
db_tablespace='',
pk_field_name='id',
pk_field_type=models.AutoField)
# Model 'MIBData'
db.create_table(
'fm_mibdata',
(('id',
models.AutoField(
verbose_name='ID', primary_key=True, auto_created=True)),
('mib', models.ForeignKey(MIB, verbose_name=MIB)),
('oid', models.CharField("OID", max_length=128, unique=True)),
('name', models.CharField("Name", max_length=128, unique=True)),
('description',
models.TextField("Description", blank=True, null=True))))
db.send_create_signal('fm', ['MIB', 'MIBData'])
def forwards(self):
# Mock model
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Adding field 'Article.author'
db.add_column('articles_article', 'author', models.ForeignKey(User, related_name=_("Author"), blank=True, null=True))
def forwards(self):
# Model 'ArticleCategory'
db.create_table('articles_articlecategory', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField(_("Name"), max_length=255)),
('slug', models.SlugField(_("Slug"), max_length=255, unique=True)),
('theme', models.CharField(_("Colour Theme"), max_length=10, choices=THEME_CHOICES)),
('featured', models.BooleanField(_("Featured"), default=False)),
))
# Mock Models
ArticleCategory = db.mock_model(model_name='ArticleCategory', db_table='articles_articlecategory', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Model 'Article'
db.create_table('articles_article', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('title', models.CharField(_("Title"), max_length=255)),
('slug', models.SlugField(_("Slug"), max_length=255)),
('summary', models.TextField(_("Summary"), blank=True)),
('body', models.TextField(_("Body"), blank=True)),
('category', models.ForeignKey(ArticleCategory, verbose_name=_("Category"))),
('tags', TagField(_("Tags"))),
('featured', models.BooleanField(_("Featured"), default=False)),
('published', models.BooleanField(_("Published"), default=True)),
('publication_date', models.DateTimeField(_("Publication Date"), default=datetime.now)),
('expiration_date', models.DateTimeField(_("Expiration Date"), blank=True, null=True)),
('creation_date', models.DateTimeField(_("Creation Date"), editable=False, auto_now_add=True)),
('modification_date', models.DateTimeField(_("Modification Date"), editable=False, auto_now=True)),
('view_count', models.PositiveIntegerField(_("View Count"), editable=False, default=0)),
))
db.create_index('articles_article', ['slug','publication_date','category_id'], unique=True, db_tablespace='')
db.send_create_signal('articles', ['ArticleCategory','Article'])
def forwards(self):
# Mock Models
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
Syllabus = db.mock_model(model_name='Syllabus', db_table='user_model_syllabus', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Model 'UserProfile'
db.create_table('user_profile_userprofile', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('user', models.ForeignKey(User, unique=True)),
('syllabus', models.ForeignKey(Syllabus)),
('first_language', models.CharField(max_length=100)),
('second_languages', models.CharField(max_length=200, null=True, blank=True)),
))
db.send_create_signal('user_profile', ['UserProfile'])
def test_unique(self):
"""
Tests creating/deleting unique constraints.
"""
db.create_table("test_unique2", [("id", models.AutoField(primary_key=True))])
db.create_table(
"test_unique",
[
("spam", models.BooleanField(default=False)),
("eggs", models.IntegerField()),
("ham", models.ForeignKey(db.mock_model("Unique2", "test_unique2"))),
],
)
# Add a constraint
db.create_unique("test_unique", ["spam"])
# Shouldn't do anything during dry-run
db.dry_run = True
db.delete_unique("test_unique", ["spam"])
db.dry_run = False
db.delete_unique("test_unique", ["spam"])
db.create_unique("test_unique", ["spam"])
db.start_transaction()
# Test it works
db.execute("INSERT INTO test_unique2 (id) VALUES (1), (2)")
db.execute("INSERT INTO test_unique (spam, eggs, ham_id) VALUES (true, 0, 1), (false, 1, 2)")
try:
db.execute("INSERT INTO test_unique (spam, eggs, ham_id) VALUES (true, 2, 1)")
except:
db.rollback_transaction()
else:
self.fail("Could insert non-unique item.")
# Drop that, add one only on eggs
db.delete_unique("test_unique", ["spam"])
db.execute("DELETE FROM test_unique")
db.create_unique("test_unique", ["eggs"])
db.start_transaction()
# Test similarly
db.execute("INSERT INTO test_unique (spam, eggs, ham_id) VALUES (true, 0, 1), (false, 1, 2)")
try:
db.execute("INSERT INTO test_unique (spam, eggs, ham_id) VALUES (true, 1, 1)")
except:
db.rollback_transaction()
else:
self.fail("Could insert non-unique item.")
# Drop those, test combined constraints
db.delete_unique("test_unique", ["eggs"])
db.execute("DELETE FROM test_unique")
db.create_unique("test_unique", ["spam", "eggs", "ham_id"])
db.start_transaction()
# Test similarly
db.execute("INSERT INTO test_unique (spam, eggs, ham_id) VALUES (true, 0, 1), (false, 1, 1)")
try:
db.execute("INSERT INTO test_unique (spam, eggs, ham_id) VALUES (true, 0, 1)")
except:
db.rollback_transaction()
else:
self.fail("Could insert non-unique pair.")
db.delete_unique("test_unique", ["spam", "eggs", "ham_id"])
def forwards(self):
# Model 'Report'
db.create_table('reports_report', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('name', models.CharField("Name of this report", max_length=255)),
('page_size', models.CharField(default="Portrait", choices=(("Portrait", "Portrait"),("Landscape","Landscape")), max_length=8)),
('first_name', models.BooleanField("First Name")),
('middle_initial', models.BooleanField("Middle Initial")),
('last_name', models.BooleanField("Last Name")),
('title', models.BooleanField("Title")),
('email', models.BooleanField("Email")),
('phone1', models.BooleanField("Primary Phone Number")),
('phone2', models.BooleanField("Secondary Phone Number")),
('fax1', models.BooleanField("Primary Fax")),
('fax2', models.BooleanField("Secondary Fax")),
('employer', models.BooleanField("Employer")),
('position', models.BooleanField("Position")),
('addr1_row1', models.BooleanField("Row 1")),
('addr1_row2', models.BooleanField("Row 2")),
('addr1_city', models.BooleanField("City")),
('addr1_state', models.BooleanField("State")),
('addr1_zip', models.BooleanField("Zip Code")),
('addr2_row1', models.BooleanField("Row 1")),
('addr2_row2', models.BooleanField("Row 2")),
('addr2_city', models.BooleanField("City")),
('addr2_state', models.BooleanField("State")),
('addr2_zip', models.BooleanField("Zip Code")),
('degree1', models.BooleanField("Degree")),
('major1', models.BooleanField("Major")),
('year1', models.BooleanField("Year")),
('degree2', models.BooleanField("Degree")),
('major2', models.BooleanField("Major")),
('year2', models.BooleanField("Year")),
('tag_list', models.BooleanField("Tags")),
('do_not_email', models.BooleanField("Do Not Email")),
('preferred_comm', models.BooleanField("Preferred Comm")),
('notes', models.BooleanField("Notes")),
))
# Mock Models
Report = db.mock_model(model_name='Report', db_table='reports_report', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'SearchTerms'
db.create_table('reports_searchterms', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('field', models.CharField(max_length=255)),
('condition', models.CharField(max_length=255)),
('query', models.CharField(max_length=255)),
('operator', models.CharField(max_length=255, blank=True)),
('order', models.IntegerField()),
('report', models.ForeignKey(Report, related_name="searchterms")),
))
db.create_index('reports_searchterms', ['report_id','order'], unique=True, db_tablespace='')
db.send_create_signal('reports', ['Report','SearchTerms'])
def forwards(self):
Event = db.mock_model(
model_name="Event",
db_table="events_event",
db_tablespace="",
pk_field_name="id",
pk_field_type=models.AutoField,
pk_field_args=[],
)
db.add_column("emails_email", "event", models.ForeignKey(Event, blank=True, null=True))
def forwards(self):
# Model 'Category'
db.create_table('portfolio_category', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('title', models.CharField(_("Title"), max_length=255)),
('slug', AutoSlugField(_("Slug"), populate_from="title")),
))
# Mock Models
Piece = db.mock_model(model_name='Piece', db_table='portfolio_piece', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Model 'Photo'
db.create_table('portfolio_photo', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('title', models.CharField(_("Title"), max_length=255)),
('image', models.ImageField(_("Image"), upload_to="files/portfolio")),
('piece', models.ForeignKey(Piece, verbose_name=_("Piece"))),
))
# Model 'Piece'
db.create_table('portfolio_piece', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('title', models.CharField(_("Title"), max_length=255)),
('teaser', models.TextField(_("Teaser"), blank=True)),
('body', models.TextField(_("Body"), blank=True)),
('link', models.URLField(_("Link"), blank=True, null=True, verify_exists=True)),
('slug', AutoSlugField(_("Slug"), populate_from="title")),
('published', models.BooleanField(_("Published"), default=True)),
('creation_date', CreateDateTimeField(_("Creation Date"), editable=True)),
))
# Mock Models
Piece = db.mock_model(model_name='Piece', db_table='portfolio_piece', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
Category = db.mock_model(model_name='Category', db_table='portfolio_category', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# M2M field 'Piece.categories'
db.create_table('portfolio_piece_categories', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('piece', models.ForeignKey(Piece, null=False)),
('category', models.ForeignKey(Category, null=False))
))
db.send_create_signal('portfolio', ['Category','Photo','Piece'])
def forwards(self, orm):
Menu = db.mock_model(model_name='Menu', db_table='wizardcms_menu', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
db.create_table('wizardcms_menuitem', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('menu', models.ForeignKey(Menu)),
('display_order', models.PositiveIntegerField()),
('type', models.CharField(max_length=32)),
('value', models.CharField(max_length=255)),
('is_published', models.BooleanField(default=False)),
))
def forwards(self):
Spam = db.mock_model(model_name='Spam', db_table='southtest_spam', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
db.create_table("southtest_eggs", (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('size', models.FloatField()),
('quantity', models.IntegerField()),
('spam', models.ForeignKey(Spam)),
))
def forwards(self):
# Mock Models
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'Project'
db.create_table('nxtw_project', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('title', models.CharField(max_length=255)),
('description', models.TextField()),
('user', models.ForeignKey(User)),
('date', models.DateField(auto_now=True)),
('css', models.TextField()),
))
# Mock Models
Project = db.mock_model(model_name='Project', db_table='nxtw_project', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'ProjectEmail'
db.create_table('nxtw_projectemail', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('project', models.ForeignKey(Project)),
('email', models.EmailField()),
('date', models.DateField(auto_now=True)),
))
# Mock Models
Project = db.mock_model(model_name='Project', db_table='nxtw_project', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'EmailHistory'
db.create_table('nxtw_emailhistory', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('subject', models.CharField(max_length=255)),
('text', models.TextField()),
('project', models.ForeignKey(Project)),
('date', models.DateField(auto_now=True)),
))
db.send_create_signal('nxtw', ['Project','ProjectEmail','EmailHistory'])
def test_make_foreign_key_null(self):
# Table for FK to target
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Table with no foreign key
db.create_table("test_make_fk_null", [
('eggs', models.IntegerField()),
('foreik', models.ForeignKey(User))
])
db.execute_deferred_sql()
# Make the FK null
db.alter_column("test_make_fk_null", "foreik_id", models.ForeignKey(User, null=True))
db.execute_deferred_sql()
def test_recursive_foreign_key_delete(self):
"""
Test that recursive foreign keys are deleted correctly (see #1065)
"""
Test = db.mock_model(model_name='Test', db_table='test_rec_fk_del',
db_tablespace='', pk_field_name='id',
pk_field_type=models.AutoField, pk_field_args=[])
db.create_table('test_rec_fk_del', [
('id', models.AutoField(primary_key=True, auto_created=True)),
('fk', models.ForeignKey(Test)),
])
db.execute_deferred_sql()
db.delete_foreign_key('test_rec_fk_del', 'fk_id')
def forwards(self):
# Mock Models
ContentType = db.mock_model(model_name='ContentType', db_table='django_content_type', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Model 'EmailEvent'
db.create_table('emailthis_emailevent', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('content_type', models.ForeignKey(ContentType)),
('object_id', models.IntegerField()),
('mailed_by', models.ForeignKey(User, null=True, blank=True)),
('email_from', models.EmailField("Your Email", help_text="required")),
('email_to', models.CharField(max_length=300)),
('subject', models.CharField("Subject", max_length=120)),
('message', models.TextField("Personal Message", blank=True)),
('remote_ip', models.IPAddressField()),
('happened_at', models.DateTimeField(editable=False, default=datetime.datetime.now)),
))
db.send_create_signal('emailthis', ['EmailEvent'])
def test_foreign_keys(self):
"""
Tests foreign key creation, especially uppercase (see #61)
"""
Test = db.mock_model(model_name='Test', db_table='test5a',
db_tablespace='', pk_field_name='ID',
pk_field_type=models.AutoField, pk_field_args=[])
db.create_table("test5a", [('ID', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True))])
db.create_table("test5b", [
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('UNIQUE', models.ForeignKey(Test)),
])
db.execute_deferred_sql()
def forwards(self):
# Mock Models
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'UserProfile'
db.create_table('accounts_userprofile', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('user', models.ForeignKey(User, unique=True)),
('pagingprefs', models.IntegerField()),
))
db.send_create_signal('accounts', ['UserProfile'])
def forwards(self):
# Mock Models
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField)
# Model 'EmailAlias'
db.create_table('accounts_emailalias', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('email', models.EmailField()),
('user', models.ForeignKey(User, related_name="email_aliases")),
))
db.send_create_signal('accounts', ['EmailAlias'])
def forwards(self):
# Mock Models
GeneralPost = db.mock_model(model_name='GeneralPost', db_table='django_dzenlog_generalpost', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[])
# Model 'LinkPost'
db.create_table('dzenlog_link_linkpost', (
('generalpost_ptr', models.OneToOneField(GeneralPost)),
('url', models.URLField(_('URL'), verify_exists = not settings.DEBUG)),
('description', models.TextField(_('URL\'s description'), max_length = 255)),
))
db.send_create_signal('dzenlog_link', ['LinkPost'])
def forwards(self):
# Mock Models
Event = db.mock_model(model_name='Event', db_table='events_event', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
# Model 'Pricing'
db.create_table('events_pricing', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('event', models.ForeignKey(Event)),
('price', models.FloatField()),
))
db.send_create_signal('events', ['Pricing'])
def test_add_columns(self):
"""
Test adding columns
"""
db.create_table("test_addc", [
('spam', models.BooleanField(default=False)),
('eggs', models.IntegerField()),
])
# Add a column
db.add_column("test_addc", "add1", models.IntegerField(default=3), keep_default=False)
# Add a FK with keep_default=False (#69)
User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
db.add_column("test_addc", "user", models.ForeignKey(User, null=True), keep_default=False)
db.delete_column("test_addc", "add1")
db.delete_table("test_addc")
