218 lines
8.0 KiB
Python
218 lines
8.0 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import os
|
|
import shutil
|
|
|
|
from migrate import exceptions
|
|
from migrate.versioning.repository import *
|
|
from migrate.versioning.script import *
|
|
|
|
from migrate.tests import fixture
|
|
from datetime import datetime
|
|
|
|
|
|
class TestRepository(fixture.Pathed):
|
|
def test_create(self):
|
|
"""Repositories are created successfully"""
|
|
path = self.tmp_repos()
|
|
name = 'repository_name'
|
|
|
|
# Creating a repository that doesn't exist should succeed
|
|
repo = Repository.create(path, name)
|
|
config_path = repo.config.path
|
|
manage_path = os.path.join(repo.path, 'manage.py')
|
|
self.assert_(repo)
|
|
|
|
# Files should actually be created
|
|
self.assert_(os.path.exists(path))
|
|
self.assert_(os.path.exists(config_path))
|
|
self.assert_(os.path.exists(manage_path))
|
|
|
|
# Can't create it again: it already exists
|
|
self.assertRaises(exceptions.PathFoundError, Repository.create, path, name)
|
|
return path
|
|
|
|
def test_load(self):
|
|
"""We should be able to load information about an existing repository"""
|
|
# Create a repository to load
|
|
path = self.test_create()
|
|
repos = Repository(path)
|
|
|
|
self.assert_(repos)
|
|
self.assert_(repos.config)
|
|
self.assert_(repos.config.get('db_settings', 'version_table'))
|
|
|
|
# version_table's default isn't none
|
|
self.assertNotEquals(repos.config.get('db_settings', 'version_table'), 'None')
|
|
|
|
def test_load_notfound(self):
|
|
"""Nonexistant repositories shouldn't be loaded"""
|
|
path = self.tmp_repos()
|
|
self.assert_(not os.path.exists(path))
|
|
self.assertRaises(exceptions.InvalidRepositoryError, Repository, path)
|
|
|
|
def test_load_invalid(self):
|
|
"""Invalid repos shouldn't be loaded"""
|
|
# Here, invalid=empty directory. There may be other conditions too,
|
|
# but we shouldn't need to test all of them
|
|
path = self.tmp_repos()
|
|
os.mkdir(path)
|
|
self.assertRaises(exceptions.InvalidRepositoryError, Repository, path)
|
|
|
|
|
|
class TestVersionedRepository(fixture.Pathed):
|
|
"""Tests on an existing repository with a single python script"""
|
|
|
|
def setUp(self):
|
|
super(TestVersionedRepository, self).setUp()
|
|
Repository.clear()
|
|
self.path_repos = self.tmp_repos()
|
|
Repository.create(self.path_repos, 'repository_name')
|
|
|
|
def test_version(self):
|
|
"""We should correctly detect the version of a repository"""
|
|
repos = Repository(self.path_repos)
|
|
|
|
# Get latest version, or detect if a specified version exists
|
|
self.assertEqual(repos.latest, 0)
|
|
# repos.latest isn't an integer, but a VerNum
|
|
# (so we can't just assume the following tests are correct)
|
|
self.assert_(repos.latest >= 0)
|
|
self.assert_(repos.latest < 1)
|
|
|
|
# Create a script and test again
|
|
repos.create_script('')
|
|
self.assertEqual(repos.latest, 1)
|
|
self.assert_(repos.latest >= 0)
|
|
self.assert_(repos.latest >= 1)
|
|
self.assert_(repos.latest < 2)
|
|
|
|
# Create a new script and test again
|
|
repos.create_script('')
|
|
self.assertEqual(repos.latest, 2)
|
|
self.assert_(repos.latest >= 0)
|
|
self.assert_(repos.latest >= 1)
|
|
self.assert_(repos.latest >= 2)
|
|
self.assert_(repos.latest < 3)
|
|
|
|
|
|
def test_timestmap_numbering_version(self):
|
|
repos = Repository(self.path_repos)
|
|
repos.config.set('db_settings', 'use_timestamp_numbering', 'True')
|
|
|
|
# Get latest version, or detect if a specified version exists
|
|
self.assertEqual(repos.latest, 0)
|
|
# repos.latest isn't an integer, but a VerNum
|
|
# (so we can't just assume the following tests are correct)
|
|
self.assert_(repos.latest >= 0)
|
|
self.assert_(repos.latest < 1)
|
|
|
|
# Create a script and test again
|
|
now = int(datetime.utcnow().strftime('%Y%m%d%H%M%S'))
|
|
repos.create_script('')
|
|
print repos.latest
|
|
self.assertEqual(repos.latest, now)
|
|
|
|
def test_source(self):
|
|
"""Get a script object by version number and view its source"""
|
|
# Load repository and commit script
|
|
repo = Repository(self.path_repos)
|
|
repo.create_script('')
|
|
repo.create_script_sql('postgres', 'foo bar')
|
|
|
|
# Source is valid: script must have an upgrade function
|
|
# (not a very thorough test, but should be plenty)
|
|
source = repo.version(1).script().source()
|
|
self.assertTrue(source.find('def upgrade') >= 0)
|
|
|
|
import pprint; pprint.pprint(repo.version(2).sql)
|
|
source = repo.version(2).script('postgres', 'upgrade').source()
|
|
self.assertEqual(source.strip(), '')
|
|
|
|
def test_latestversion(self):
|
|
"""Repository.version() (no params) returns the latest version"""
|
|
repos = Repository(self.path_repos)
|
|
repos.create_script('')
|
|
self.assert_(repos.version(repos.latest) is repos.version())
|
|
self.assert_(repos.version() is not None)
|
|
|
|
def test_changeset(self):
|
|
"""Repositories can create changesets properly"""
|
|
# Create a nonzero-version repository of empty scripts
|
|
repos = Repository(self.path_repos)
|
|
for i in range(10):
|
|
repos.create_script('')
|
|
|
|
def check_changeset(params, length):
|
|
"""Creates and verifies a changeset"""
|
|
changeset = repos.changeset('postgres', *params)
|
|
self.assertEqual(len(changeset), length)
|
|
self.assertTrue(isinstance(changeset, Changeset))
|
|
uniq = list()
|
|
# Changesets are iterable
|
|
for version, change in changeset:
|
|
self.assert_(isinstance(change, BaseScript))
|
|
# Changes aren't identical
|
|
self.assert_(id(change) not in uniq)
|
|
uniq.append(id(change))
|
|
return changeset
|
|
|
|
# Upgrade to a specified version...
|
|
cs = check_changeset((0, 10), 10)
|
|
self.assertEqual(cs.keys().pop(0),0 ) # 0 -> 1: index is starting version
|
|
self.assertEqual(cs.keys().pop(), 9) # 9 -> 10: index is starting version
|
|
self.assertEqual(cs.start, 0) # starting version
|
|
self.assertEqual(cs.end, 10) # ending version
|
|
check_changeset((0, 1), 1)
|
|
check_changeset((0, 5), 5)
|
|
check_changeset((0, 0), 0)
|
|
check_changeset((5, 5), 0)
|
|
check_changeset((10, 10), 0)
|
|
check_changeset((5, 10), 5)
|
|
|
|
# Can't request a changeset of higher version than this repository
|
|
self.assertRaises(Exception, repos.changeset, 'postgres', 5, 11)
|
|
self.assertRaises(Exception, repos.changeset, 'postgres', -1, 5)
|
|
|
|
# Upgrade to the latest version...
|
|
cs = check_changeset((0,), 10)
|
|
self.assertEqual(cs.keys().pop(0), 0)
|
|
self.assertEqual(cs.keys().pop(), 9)
|
|
self.assertEqual(cs.start, 0)
|
|
self.assertEqual(cs.end, 10)
|
|
check_changeset((1,), 9)
|
|
check_changeset((5,), 5)
|
|
check_changeset((9,), 1)
|
|
check_changeset((10,), 0)
|
|
|
|
# run changes
|
|
cs.run('postgres', 'upgrade')
|
|
|
|
# Can't request a changeset of higher/lower version than this repository
|
|
self.assertRaises(Exception, repos.changeset, 'postgres', 11)
|
|
self.assertRaises(Exception, repos.changeset, 'postgres', -1)
|
|
|
|
# Downgrade
|
|
cs = check_changeset((10, 0),10)
|
|
self.assertEqual(cs.keys().pop(0), 10) # 10 -> 9
|
|
self.assertEqual(cs.keys().pop(), 1) # 1 -> 0
|
|
self.assertEqual(cs.start, 10)
|
|
self.assertEqual(cs.end, 0)
|
|
check_changeset((10, 5), 5)
|
|
check_changeset((5, 0), 5)
|
|
|
|
def test_many_versions(self):
|
|
"""Test what happens when lots of versions are created"""
|
|
repos = Repository(self.path_repos)
|
|
for i in range(1001):
|
|
repos.create_script('')
|
|
|
|
# since we normally create 3 digit ones, let's see if we blow up
|
|
self.assert_(os.path.exists('%s/versions/1000.py' % self.path_repos))
|
|
self.assert_(os.path.exists('%s/versions/1001.py' % self.path_repos))
|
|
|
|
|
|
# TODO: test manage file
|
|
# TODO: test changeset
|