11 | {% block body %}
12 |
13 | {% block content_title %}{% endblock %}
14 |
15 |
16 | {% block content %}{% endblock %}
17 |
18 | {% endblock %}
19 |
11 | {% block body %}
12 |
13 | {% block content_title %}{% endblock %}
14 |
15 |
16 | {% block content %}{% endblock %}
17 |
18 | {% endblock %}
19 |
Post archive for {{ day|date:"d F Y" }}
10 | {% endblock %}
11 |
12 |
13 | {% block content %}
14 |
15 | {% for post in object_list %}
16 |
17 |
18 |
{{ post.publish|date:"Y F d" }}
19 |
{{ post.tease }}
20 |
21 | {% endfor %}
22 |
Post archive for {{ month|date:"F Y" }}
10 | {% endblock %}
11 |
12 |
13 | {% block content %}
14 |
15 | {% for post in object_list %}
16 |
17 |
18 |
{{ post.publish|date:"Y F d" }}
19 |
{{ post.tease }}
20 |
21 | {% endfor %}
22 |
Post archive for {{ day|date:"d F Y" }}
10 | {% endblock %}
11 |
12 |
13 | {% block content %}
14 |
15 | {% for post in object_list %}
16 |
17 |
18 |
{{ post.publish|date:"Y F d" }}
19 |
{{ post.tease }}
20 |
21 | {% endfor %}
22 |
Post archive for {{ month|date:"F Y" }}
10 | {% endblock %}
11 |
12 |
13 | {% block content %}
14 |
15 | {% for post in object_list %}
16 |
17 |
18 |
{{ post.publish|date:"Y F d" }}
19 |
{{ post.tease }}
20 |
21 | {% endfor %}
22 |
Posts for {{ category.title }}
11 | {% endblock %}
12 |
13 |
14 | {% block content %}
15 | {% load markup %}
16 |
17 | {% for post in object_list %}
18 |
19 |
20 |
{{ post.publish|date:"Y F d" }}
21 |
{{ post.tease }}
22 |
23 | {% endfor %}
24 |
Posts for {{ category.title }}
11 | {% endblock %}
12 |
13 |
14 | {% block content %}
15 | {% load markup %}
16 |
17 | {% for post in object_list %}
18 |
19 |
20 |
{{ post.publish|date:"Y F d" }}
21 |
{{ post.tease }}
22 |
23 | {% endfor %}
24 |
Post archive
10 | {% endblock %}
11 |
12 |
13 | {% block content %}
14 |
15 | {% for post in object_list %}
16 |
17 |
18 |
{{ post.publish|date:"Y F d" }}
19 |
{{ post.tease }}
20 |
21 | {% endfor %}
22 |
Post archive
10 | {% endblock %}
11 |
12 |
13 | {% block content %}
14 |
15 | {% for post in object_list %}
16 |
17 |
18 |
{{ post.publish|date:"Y F d" }}
19 |
{{ post.tease }}
20 |
21 | {% endfor %}
22 |
Search
10 | {% endblock %}
11 |
12 |
13 | {% block content %}
14 |
20 |
21 | {% if message %}
22 | {{ message }}
23 | {% endif %}
24 |
25 | {% if object_list %}
26 |
27 | {% for post in object_list %}
28 |
29 |
30 |
{{ post.publish|date:"Y F d" }}
31 |
{{ post.tease }}
32 |
33 |
34 | {% endfor %}
35 |
Search
10 | {% endblock %}
11 |
12 |
13 | {% block content %}
14 |
20 |
21 | {% if message %}
22 | {{ message }}
23 | {% endif %}
24 |
25 | {% if object_list %}
26 |
27 | {% for post in object_list %}
28 |
29 |
30 |
{{ post.publish|date:"Y F d" }}
31 |
{{ post.tease }}
32 |
33 |
34 | {% endfor %}
35 |
{{ object.title }}
11 |
12 | {% if object.get_previous_by_publish %}
13 | « {{ object.get_previous_post }}
14 | {% endif %}
15 | {% if object.get_next_by_publish %}
16 | | {{ object.get_next_post }} »
17 | {% endif %}
18 |
19 | {% endblock %}
20 |
21 |
22 | {% block content %}
23 | {% load blog markup comments tagging_tags %}
24 |
25 | {{ object.publish|date:"j F Y" }}
26 |
27 |
28 | {{ object.body|markdown:"safe" }}
29 |
30 |
31 | {% tags_for_object object as tag_list %}
32 | {% if tag_list %}
33 | Related tags:
34 | {% for tag in tag_list %}
35 | {{ tag }}{% if not forloop.last %}, {% endif %}
36 | {% endfor %}
37 |
38 | {% endif %}
39 |
40 | {% get_comment_list for object as comment_list %}
41 | {% if comment_list %}
42 |
58 | {% endif %}
59 | {% if object.allow_comments %}
60 | {% render_comment_form for object %}
61 | {% else %}
62 |
66 | {% endif %}
67 | {% endblock %}
--------------------------------------------------------------------------------
/fixture/test/test_loadable/test_django/test_djangoenv.py:
--------------------------------------------------------------------------------
1 | from nose.tools import raises, assert_raises, assert_equal
2 | from fixture.loadable.django_loadable import DjangoEnv, DjangoFixture
3 | from fixture.examples.django_example.blog.models import Post
4 | from fixture import DataSet
5 | from fixture.style import NamedDataStyle
6 |
7 | @raises(ValueError)
8 | def test_unsplittable_name():
9 | DjangoEnv.get('blog_Post')
10 |
11 | def test_invalid_app_returns_none():
12 | assert_equal(None, DjangoEnv.get('no_such_app__Post'))
13 |
14 | def test_invalid_model_returns_none():
15 | assert_equal(None, DjangoEnv.get('blog__NoSuchModel'))
16 |
17 | def test_model_lookup_by_qualified_model_name():
18 |
19 | class SomeDataset(DataSet):
20 | class Meta:
21 | django_model = "blog.Post"
22 | class foo:
23 | foo = 1
24 |
25 | fixture = DjangoFixture()
26 | ds = SomeDataset()
27 | fixture.attach_storage_medium(ds)
28 | assert_equal(ds.meta.storage_medium.medium, Post)
29 |
30 | def test_model_lookup_by_explicit_app_label_and_name():
31 |
32 | class SomeDataset(DataSet):
33 | class Meta:
34 | django_app_label = "blog"
35 | storable_name = "Post"
36 | class foo:
37 | foo = 1
38 |
39 | fixture = DjangoFixture()
40 | ds = SomeDataset()
41 | fixture.attach_storage_medium(ds)
42 | assert_equal(ds.meta.storage_medium.medium, Post)
43 |
44 | def test_model_lookup_by_app_label_and_style_derived_name():
45 |
46 | class PostData(DataSet):
47 | class Meta:
48 | django_app_label = "blog"
49 | class foo:
50 | foo = 1
51 |
52 | fixture = DjangoFixture(style=NamedDataStyle())
53 | ds = PostData()
54 | fixture.attach_storage_medium(ds)
55 | assert_equal(ds.meta.storage_medium.medium, Post)
56 |
57 | @raises(ValueError)
58 | def test_dataset_with_malformed_model_name():
59 |
60 | class SomeDataset(DataSet):
61 | class Meta:
62 | django_model = "not_dot_separated_model_name"
63 | class foo:
64 | foo = 1
65 |
66 | fixture = DjangoFixture()
67 | ds = SomeDataset()
68 | fixture.attach_storage_medium(ds)
69 |
70 | @raises(ValueError)
71 | def test_dataset_without_resolvable_model_name():
72 |
73 | class UnknownData(DataSet):
74 | class foo:
75 | foo = 1
76 |
77 | fixture = DjangoFixture()
78 | ds = UnknownData()
79 | fixture.attach_storage_medium(ds)
80 |
81 |
--------------------------------------------------------------------------------
/fixture/examples/django_example/blog/templates/blog/.svn/text-base/post_detail.html.svn-base:
--------------------------------------------------------------------------------
1 | {% extends "blog/base_blog.html" %}
2 |
3 |
4 | {% block title %}{{ object.title }}{% endblock %}
5 | {% block body_class %}{{ block.super }} post_detail{% endblock %}
6 | {% block body_id %}post_{{ object.id }}{% endblock %}
7 |
8 |
9 | {% block content_title %}
10 | {{ object.title }}
11 |
12 | {% if object.get_previous_by_publish %}
13 | « {{ object.get_previous_post }}
14 | {% endif %}
15 | {% if object.get_next_by_publish %}
16 | | {{ object.get_next_post }} »
17 | {% endif %}
18 |
19 | {% endblock %}
20 |
21 |
22 | {% block content %}
23 | {% load blog markup comments tagging_tags %}
24 |
25 | {{ object.publish|date:"j F Y" }}
26 |
27 |
28 | {{ object.body|markdown:"safe" }}
29 |
30 |
31 | {% tags_for_object object as tag_list %}
32 | {% if tag_list %}
33 | Related tags:
34 | {% for tag in tag_list %}
35 | {{ tag }}{% if not forloop.last %}, {% endif %}
36 | {% endfor %}
37 |
38 | {% endif %}
39 |
40 | {% get_comment_list for object as comment_list %}
41 | {% if comment_list %}
42 |
58 | {% endif %}
59 | {% if object.allow_comments %}
60 | {% render_comment_form for object %}
61 | {% else %}
62 |
66 | {% endif %}
67 | {% endblock %}
--------------------------------------------------------------------------------
/fixture/examples/db/sqlalchemy_examples.py:
--------------------------------------------------------------------------------
1 |
2 | """Examples for using sqlalchemy fixtures.
3 |
4 | See a complete, more accurate example in http://farmdev.com/projects/fixture/docs/
5 |
6 | """
7 |
8 | try:
9 | import sqlalchemy
10 | except ImportError:
11 | sqlalchemy = None
12 |
13 | Category, Product, Offer = None, None, None
14 |
15 | if sqlalchemy:
16 | from sqlalchemy import *
17 | from sqlalchemy.orm import *
18 | metadata = MetaData()
19 |
20 | categories = Table("fixture_sqlalchemy_category",
21 | metadata,
22 | Column("id", INT, primary_key=True),
23 | Column("name", String(100) )
24 | )
25 | class Category(object):
26 | pass
27 |
28 | products = Table("fixture_sqlalchemy_product",
29 | metadata,
30 | Column("id", INT, primary_key=True),
31 | Column("name", String(100) ),
32 | Column("category_id", INT,
33 | ForeignKey("fixture_sqlalchemy_category.id")),
34 | )
35 | class Product(object):
36 | pass
37 |
38 | offers = Table("fixture_sqlalchemy_offer",
39 | metadata,
40 | Column("id", INT, primary_key=True),
41 | Column("name", String(100) ),
42 | Column("category_id", INT,
43 | ForeignKey("fixture_sqlalchemy_category.id")),
44 | Column("product_id", INT,
45 | ForeignKey("fixture_sqlalchemy_product.id")),
46 | )
47 | class Offer(object):
48 | pass
49 |
50 | authors = Table('authors', metadata,
51 | Column('id', Integer, primary_key=True),
52 | Column('first_name', String(100)),
53 | Column('last_name', String(100)))
54 |
55 | class Author(object):
56 | pass
57 |
58 | books = Table('books', metadata,
59 | Column('id', Integer, primary_key=True),
60 | Column('title', String(100)),
61 | Column('author_id', Integer, ForeignKey('authors.id')))
62 |
63 | class Book(object):
64 | pass
65 |
66 | def connect(dsn):
67 | metadata.bind = create_engine(dsn)
68 |
69 | def setup_mappers():
70 | mapper(Category, categories)
71 | mapper(Product, products, properties={
72 | 'category': relation(Category),
73 | })
74 | mapper(Offer, offers, properties={
75 | 'category': relation(Category, backref='products'),
76 | 'product': relation(Product)
77 | })
78 | mapper(Author, authors)
79 | mapper(Book, books, properties={
80 | 'author': relation(Author)
81 | })
82 |
83 | if __name__ == '__main__':
84 | import doctest
85 | doctest.testmod()
--------------------------------------------------------------------------------
/fixture/loadable/storm_loadable.py:
--------------------------------------------------------------------------------
1 |
2 | """Components for loading and unloading data using `Storm`_.
3 |
4 | See :ref:`Using LoadableFixture` for examples.
5 |
6 | .. _Storm: https://storm.canonical.com/
7 |
8 | """
9 |
10 | from fixture.loadable import DBLoadableFixture
11 | from fixture.util import _mklog
12 |
13 | stlog = _mklog('fixture.loadable.storm')
14 |
15 | class StormMedium(DBLoadableFixture.StorageMediumAdapter):
16 |
17 | def clear(self, obj):
18 | self.transaction.remove(obj)
19 |
20 | def save(self, row, column_vals):
21 | from storm.info import get_cls_info
22 | from storm.locals import ReferenceSet, Store
23 |
24 | cls_info = get_cls_info(self.medium)
25 |
26 | column_vals = list(column_vals)
27 | pk = []
28 | for n, v in column_vals:
29 | propid = id(getattr(self.medium, n))
30 | if propid in cls_info.primary_key_idx:
31 | pk.append((cls_info.primary_key_idx[propid], v, n))
32 |
33 | assert len(pk) == 0 or len(pk) == len(cls_info.primary_key), (
34 | "Incomplete primary key see %s need %s" % (
35 | [x[2] for x in pk], [x.name for x in cls_info.primary_key]))
36 |
37 | if pk:
38 | obj = self.transaction.get(self.medium, tuple([x[1] for x in sorted(pk)]))
39 | else:
40 | obj = None
41 |
42 | if obj is None:
43 | obj = self.medium()
44 | self.transaction.add(obj)
45 |
46 | assert Store.of(obj) is self.transaction
47 |
48 | for n, v in column_vals:
49 | if isinstance(getattr(self.medium,n), ReferenceSet):
50 | getattr(obj, n).add(v)
51 | else:
52 | setattr(obj, n, v)
53 |
54 | self.transaction.flush()
55 | stlog.info("%s %s", obj, [(n,getattr(obj,n)) for n in row.columns()])
56 |
57 | return obj
58 |
59 | def visit_loader(self, loader):
60 | """Visit the loader and store a reference to the transaction connection"""
61 | self.transaction = loader.transaction
62 |
63 |
64 | pass
65 |
66 | class StormFixture(DBLoadableFixture):
67 | StormMedium = StormMedium
68 | Medium = StormMedium
69 |
70 | def __init__(self, store=None, use_transaction=True,
71 | close_store=False, **kw ):
72 | DBLoadableFixture.__init__(self, **kw)
73 | self.store = store
74 | self.close_store = close_store
75 | self.use_transaction = use_transaction
76 |
77 | def create_transaction(self):
78 | return self.store
79 |
80 |
81 |
82 | pass
83 |
--------------------------------------------------------------------------------
/fixture/examples/pylons_example/addressbook/addressbook/config/middleware.py:
--------------------------------------------------------------------------------
1 | """Pylons middleware initialization"""
2 | from beaker.middleware import CacheMiddleware, SessionMiddleware
3 | from paste.cascade import Cascade
4 | from paste.registry import RegistryManager
5 | from paste.urlparser import StaticURLParser
6 | from paste.deploy.converters import asbool
7 | from pylons import config
8 | from pylons.middleware import ErrorHandler, StatusCodeRedirect
9 | from pylons.wsgiapp import PylonsApp
10 | from routes.middleware import RoutesMiddleware
11 |
12 | from addressbook.config.environment import load_environment
13 |
14 | def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
15 | """Create a Pylons WSGI application and return it
16 |
17 | ``global_conf``
18 | The inherited configuration for this application. Normally from
19 | the [DEFAULT] section of the Paste ini file.
20 |
21 | ``full_stack``
22 | Whether this application provides a full WSGI stack (by default,
23 | meaning it handles its own exceptions and errors). Disable
24 | full_stack when this application is "managed" by another WSGI
25 | middleware.
26 |
27 | ``static_files``
28 | Whether this application serves its own static files; disable
29 | when another web server is responsible for serving them.
30 |
31 | ``app_conf``
32 | The application's local configuration. Normally specified in
33 | the [app:] section of the Paste ini file (where
34 | defaults to main).
35 |
36 | """
37 | # Configure the Pylons environment
38 | load_environment(global_conf, app_conf)
39 |
40 | # The Pylons WSGI app
41 | app = PylonsApp()
42 |
43 | # Routing/Session/Cache Middleware
44 | app = RoutesMiddleware(app, config['routes.map'])
45 | app = SessionMiddleware(app, config)
46 | app = CacheMiddleware(app, config)
47 |
48 | # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
49 |
50 | if asbool(full_stack):
51 | # Handle Python exceptions
52 | app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
53 |
54 | # Display error documents for 401, 403, 404 status codes (and
55 | # 500 when debug is disabled)
56 | if asbool(config['debug']):
57 | app = StatusCodeRedirect(app)
58 | else:
59 | app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
60 |
61 | # Establish the Registry for this application
62 | app = RegistryManager(app)
63 |
64 | if asbool(static_files):
65 | # Serve static files
66 | static_app = StaticURLParser(config['pylons.paths']['static_files'])
67 | app = Cascade([static_app, app])
68 |
69 | return app
70 |
--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
1 | # Makefile for Sphinx documentation
2 | #
3 |
4 | # You can set these variables from the command line.
5 | SPHINXOPTS =
6 | SPHINXBUILD = PATH=../bin sphinx-build
7 | PAPER =
8 |
9 | # Internal variables.
10 | PAPEROPT_a4 = -D latex_paper_size=a4
11 | PAPEROPT_letter = -D latex_paper_size=letter
12 | ALLSPHINXOPTS = -d build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
13 |
14 | .PHONY: help clean html web pickle htmlhelp latex changes linkcheck
15 |
16 | test:
17 | cd ..; nosetests
18 |
19 | docs_live:
20 | tar -czf ./build/fixture-docs.tgz build/html
21 | scp ./build/fixture-docs.tgz fisk.rcache.com:~/www/farmdev/projects/fixture/
22 | @echo "uploaded docs"
23 |
24 | help:
25 | @echo "Please use \`make ' where is one of"
26 | @echo " html to make standalone HTML files"
27 | @echo " pickle to make pickle files (usable by e.g. sphinx-web)"
28 | @echo " htmlhelp to make HTML files and a HTML help project"
29 | @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
30 | @echo " changes to make an overview over all changed/added/deprecated items"
31 | @echo " linkcheck to check all external links for integrity"
32 |
33 | clean:
34 | -rm -rf build/*
35 |
36 | html:
37 | mkdir -p build/html build/doctrees
38 | $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) build/html
39 | @echo
40 | @echo "Build finished. The HTML pages are in build/html."
41 |
42 | doctest:
43 | mkdir -p build/html build/doctrees
44 | $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) build/html
45 | @echo
46 | @echo "Doctest finished."
47 |
48 | pickle:
49 | mkdir -p build/pickle build/doctrees
50 | $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) build/pickle
51 | @echo
52 | @echo "Build finished; now you can process the pickle files or run"
53 | @echo " sphinx-web build/pickle"
54 | @echo "to start the sphinx-web server."
55 |
56 | web: pickle
57 |
58 | htmlhelp:
59 | mkdir -p build/htmlhelp build/doctrees
60 | $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) build/htmlhelp
61 | @echo
62 | @echo "Build finished; now you can run HTML Help Workshop with the" \
63 | ".hhp project file in build/htmlhelp."
64 |
65 | latex:
66 | mkdir -p build/latex build/doctrees
67 | $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) build/latex
68 | @echo
69 | @echo "Build finished; the LaTeX files are in build/latex."
70 | @echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \
71 | "run these through (pdf)latex."
72 |
73 | changes:
74 | mkdir -p build/changes build/doctrees
75 | $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) build/changes
76 | @echo
77 | @echo "The overview file is in build/changes."
78 |
79 | linkcheck:
80 | mkdir -p build/linkcheck build/doctrees
81 | $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) build/linkcheck
82 | @echo
83 | @echo "Link check complete; look for any errors in the above output " \
84 | "or in build/linkcheck/output.txt."
85 |
--------------------------------------------------------------------------------
/fixture/test/test_command/test_generate/test_generate.py:
--------------------------------------------------------------------------------
1 |
2 | import sys
3 | from nose.tools import eq_, raises, with_setup
4 | from fixture.test import attr
5 | from fixture.command.generate import *
6 |
7 | class Stranger(object):
8 | """something that cannot produce data."""
9 | pass
10 |
11 | @raises(UnrecognizedObject)
12 | @attr(unit=True)
13 | def test_unhandlable_object():
14 | generate = DataSetGenerator({})
15 | generate(".".join([Stranger.__module__, Stranger.__name__]))
16 |
17 | class MyHandler(DataHandler):
18 | @staticmethod
19 | def recognizes(obj_path, obj=None):
20 | if obj_path == "myhandler.object_path":
21 | return True
22 |
23 | def register_myhandler():
24 | register_handler(MyHandler)
25 |
26 | _saved_registry = [h for h in handler_registry]
27 | def reset_handlers():
28 | handler_registry[:] = [h for h in _saved_registry]
29 |
30 | @attr(unit=True)
31 | @with_setup(setup=register_myhandler, teardown=reset_handlers)
32 | def test_dataset_handler():
33 | g = DataSetGenerator({})
34 | hnd = g.get_handler("myhandler.object_path")
35 | assert isinstance(hnd, MyHandler)
36 |
37 |
38 | @attr(unit=True)
39 | @raises(UnrecognizedObject)
40 | @with_setup(setup=register_myhandler, teardown=reset_handlers)
41 | def test_unrecognized_dataset_handler():
42 | g = DataSetGenerator({})
43 | hnd = g.get_handler("NOTHONG")
44 |
45 | @attr(unit=True)
46 | def test_requires_option():
47 | required_idents = []
48 | def mock_require(ident):
49 | required_idents.append(ident)
50 | import pkg_resources
51 | orig_require = pkg_resources.require
52 | pkg_resources.require = mock_require
53 | sys.stderr = sys.stdout
54 | try:
55 | try:
56 | dataset_generator([ 'bad.object.path',
57 | '--require-egg=foo==1.0', '--require-egg=baz>=2.0b'])
58 | except SystemExit, e:
59 | pass
60 | finally:
61 | pkg_resources.require = orig_require
62 | sys.stderr = sys.__stderr__
63 | eq_(required_idents, ['foo==1.0', 'baz>=2.0b'])
64 |
65 | def some_function():
66 | pass
67 |
68 | class SomeClass(object):
69 | def some_method(self):
70 | pass
71 |
72 | @attr(unit=1)
73 | def test_resolve_path_to_function():
74 | eq_(resolve_function_path("%s:some_function" % __name__), some_function)
75 |
76 | @attr(unit=1)
77 | def test_resolve_path_to_method():
78 | eq_(resolve_function_path("%s:SomeClass.some_method" % __name__), SomeClass.some_method)
79 |
80 | @attr(unit=1)
81 | def test_resolve_path_to_module():
82 | # Note that this is not realistic. I think we'd always want a callable
83 | eq_(resolve_function_path("%s" % __name__), sys.modules[__name__])
84 |
85 | @attr(unit=1)
86 | @raises(ImportError)
87 | def test_resolve_bad_path():
88 | resolve_function_path("nomoduleshouldbenamedthis.nowhere:Babu")
89 |
--------------------------------------------------------------------------------
/fixture/examples/django_example/blog/.svn/text-base/models.py.svn-base:
--------------------------------------------------------------------------------
1 | from django.db import models
2 | from django.utils.translation import ugettext_lazy as _
3 | from django.db.models import permalink
4 | from django.contrib.auth.models import User
5 | from tagging.fields import TagField
6 | from basic.blog.managers import PublicManager
7 |
8 | import tagging
9 |
10 |
11 | class Category(models.Model):
12 | """Category model."""
13 | title = models.CharField(_('title'), max_length=100)
14 | slug = models.SlugField(_('slug'), unique=True)
15 |
16 | class Meta:
17 | verbose_name = _('category')
18 | verbose_name_plural = _('categories')
19 | db_table = 'blog_categories'
20 | ordering = ('title',)
21 |
22 | class Admin:
23 | pass
24 |
25 | def __unicode__(self):
26 | return u'%s' % self.title
27 |
28 | @permalink
29 | def get_absolute_url(self):
30 | return ('blog_category_detail', None, {'slug': self.slug})
31 |
32 |
33 | class Post(models.Model):
34 | """Post model."""
35 | STATUS_CHOICES = (
36 | (1, _('Draft')),
37 | (2, _('Public')),
38 | )
39 | title = models.CharField(_('title'), max_length=200)
40 | slug = models.SlugField(_('slug'), unique_for_date='publish')
41 | author = models.ForeignKey(User, blank=True, null=True)
42 | body = models.TextField(_('body'))
43 | tease = models.TextField(_('tease'), blank=True)
44 | status = models.IntegerField(_('status'), choices=STATUS_CHOICES, default=2)
45 | allow_comments = models.BooleanField(_('allow comments'), default=True)
46 | publish = models.DateTimeField(_('publish'))
47 | created = models.DateTimeField(_('created'), auto_now_add=True)
48 | modified = models.DateTimeField(_('modified'), auto_now=True)
49 | categories = models.ManyToManyField(Category, blank=True)
50 | tags = TagField()
51 | objects = PublicManager()
52 |
53 | class Meta:
54 | verbose_name = _('post')
55 | verbose_name_plural = _('posts')
56 | db_table = 'blog_posts'
57 | ordering = ('-publish',)
58 | get_latest_by = 'publish'
59 |
60 | class Admin:
61 | list_display = ('title', 'publish', 'status')
62 | list_filter = ('publish', 'categories', 'status')
63 | search_fields = ('title', 'body')
64 |
65 | def __unicode__(self):
66 | return u'%s' % self.title
67 |
68 | @permalink
69 | def get_absolute_url(self):
70 | return ('blog_detail', None, {
71 | 'year': self.publish.year,
72 | 'month': self.publish.strftime('%b').lower(),
73 | 'day': self.publish.day,
74 | 'slug': self.slug
75 | })
76 |
77 | def get_previous_post(self):
78 | return self.get_previous_by_publish(status__gte=2)
79 |
80 | def get_next_post(self):
81 | return self.get_next_by_publish(status__gte=2)
--------------------------------------------------------------------------------
/docs/source/api/fixture.loadable.django_loadable.rst:
--------------------------------------------------------------------------------
1 | ------------------------------------------
2 | fixture.loadable.django_loadable
3 | ------------------------------------------
4 |
5 | .. automodule:: fixture.loadable.django_loadable
6 |
7 |
8 | .. autoclass:: DjangoEnv
9 |
10 | .. automethod:: get
11 |
12 |
13 | .. autoclass:: fixture.loadable.django_loadable.DjangoFixture
14 | :show-inheritance:
15 | :members: create_transaction, then_finally, attach_storage_medium
16 |
17 | Django's transaction management is implemented as a module, which is returned by :meth:`create_transaction`. This means the the :meth:`~fixture.loadable.loadable.DBLoadableFixture.commit` and :meth:`~fixture.loadable.loadable.DBLoadableFixture.rollback` remain unchanged from :class:`fixture.loadable.loadable.DBLoadableFixture`.
18 |
19 | As far as mapping DataSets to models, if you don't supply an env kwarg you'll get the :class:`~DjangoEnv` class. This simply provides a :meth:`get method ` that proxies through to :meth:`django.db.models.get_model`.
20 | Alternatively you can use an inner :class:`Meta ` with the following attribute:
21 |
22 | .. attribute:: django_model
23 |
24 | Use this on an inner :class:`Meta ` class to specify the model.
25 | It must be of a form that can be passed to ``get_model`` after being split on a ``'.'`` e.g:
26 |
27 | .. code-block:: python
28 |
29 | class Meta:
30 | django_model = 'auth.User'
31 |
32 | .. autoclass:: fixture.loadable.django_loadable.DjangoMedium
33 | :show-inheritance:
34 |
35 | For now we're going to say that a Fixture can only define relations
36 | and fields defined locally to the target model. So given the :ref:`example models `, Where Book has a ForeignKey to Author, then you'll have a fixture like:
37 |
38 | .. code-block:: python
39 |
40 | class BookData(DataSet):
41 | class Meta:
42 | django_model = 'app.Book'
43 | class book1:
44 | # ...
45 | author = AuthorData.some_author
46 |
47 | and not like this:
48 |
49 | .. code-block:: python
50 |
51 | class AuthorData(DataSet):
52 | class Meta:
53 | django_model = 'app.Author'
54 | class author1:
55 | # ...
56 | books = [BookData.book1, BookData.book2]
57 |
58 | .. note:: This might change in future as it looks like it should be possible to be able to do it the other way round (if desirable).
59 |
60 | .. automethod:: save
61 |
62 | Validates first with :meth:`_check_schema`
63 |
64 | .. automethod:: _check_schema
65 |
66 | .. note:: see the internal function ``column_vals`` inside :meth:`fixture.loadable.LoadableFixture.load_dataset` for more info
67 |
68 | .. warning:: This will check the field names and related model types only - it won't validate field types
69 |
70 | See the :ref:`example models `
71 |
72 |
--------------------------------------------------------------------------------
/fixture/loadable/google_datastore_loadable.py:
--------------------------------------------------------------------------------
1 | """
2 | Components for loading and unloading data using the Google App Engine `Datastore`_.
3 |
4 | Added in version 1.1
5 |
6 | .. _Datastore: http://code.google.com/appengine/docs/datastore/
7 |
8 | """
9 |
10 | from fixture.loadable import EnvLoadableFixture
11 |
12 | class EntityMedium(EnvLoadableFixture.StorageMediumAdapter):
13 | """
14 | Adapts google.appengine.api.datastore.Entity objects and any
15 | other object that is an instance of Entity
16 | """
17 | def _entities_to_keys(self, mylist):
18 | """Converts an array of datastore objects to an array of keys.
19 |
20 | if the value passed in is not a list, this passes it through as is
21 | """
22 | if type(mylist)==type([]):
23 | if all(map(lambda x: hasattr(x,'key'),mylist)):
24 | return [ent.key() for ent in mylist]
25 | else: # ...no type checks...
26 | return mylist
27 | else:
28 | return mylist
29 |
30 | def clear(self, obj):
31 | """Delete this entity from the Datastore"""
32 | obj.delete()
33 |
34 | def save(self, row, column_vals):
35 | """Save this entity to the Datastore"""
36 | gen=[(k,self._entities_to_keys(v)) for k,v in column_vals]
37 | entity = self.medium(
38 | **dict(gen)
39 | )
40 | entity.put()
41 | return entity
42 |
43 | class GoogleDatastoreFixture(EnvLoadableFixture):
44 | """
45 | A fixture that knows how to load DataSet objects into Google Datastore `Entity`_ objects.
46 |
47 | >>> from fixture import GoogleDatastoreFixture
48 |
49 | See :ref:`Using Fixture With Google App Engine ` for a complete example.
50 |
51 | .. _Entity: http://code.google.com/appengine/docs/datastore/entitiesandmodels.html
52 |
53 | Keyword Arguments:
54 |
55 | ``style``
56 | A :class:`Style ` object to translate names with
57 |
58 | ``env``
59 | A dict or module that contains Entity classes. This will be searched when
60 | :class:`Style ` translates DataSet names into
61 | storage media. See :meth:`EnvLoadableFixture.attach_storage_medium ` for details on
62 | how ``env`` works.
63 |
64 | ``dataclass``
65 | :class:`SuperSet ` class to represent loaded data with
66 |
67 | ``medium``
68 | A custom :class:`StorageMediumAdapter `
69 | class to instantiate when storing a DataSet.
70 | By default, an Entity adapter will be used so you should only set a custom medium
71 | if you know what you doing.
72 |
73 | Added in version 1.1
74 | """
75 | Medium = EntityMedium
76 |
77 | def commit(self):
78 | pass
79 |
80 | def rollback(self):
81 | pass
82 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 |
2 | import sys, os
3 | import ez_setup
4 | ez_setup.use_setuptools()
5 | from setuptools import setup, find_packages
6 | import compiler
7 | import pydoc
8 | from compiler import visitor
9 |
10 | class ModuleVisitor(object):
11 | def __init__(self):
12 | self.mod_doc = None
13 | self.mod_version = None
14 |
15 | def default(self, node):
16 | for child in node.getChildNodes():
17 | self.visit(child)
18 |
19 | def visitModule(self, node):
20 | self.mod_doc = node.doc
21 | self.default(node)
22 |
23 | def visitAssign(self, node):
24 | if self.mod_version:
25 | return
26 | asn = node.nodes[0]
27 | assert asn.name == '__version__', (
28 | "expected __version__ node: %s" % asn)
29 | self.mod_version = node.expr.value
30 | self.default(node)
31 |
32 | def get_module_meta(modfile):
33 | ast = compiler.parseFile(modfile)
34 | modnode = ModuleVisitor()
35 | visitor.walk(ast, modnode)
36 | if modnode.mod_doc is None:
37 | raise RuntimeError(
38 | "could not parse doc string from %s" % modfile)
39 | if modnode.mod_version is None:
40 | raise RuntimeError(
41 | "could not parse __version__ from %s" % modfile)
42 | return (modnode.mod_version,) + pydoc.splitdoc(modnode.mod_doc)
43 |
44 | version, description, long_description = get_module_meta("./fixture/__init__.py")
45 |
46 | setup(
47 | name = 'fixture',
48 | version = version,
49 | author = 'Kumar McMillan',
50 | author_email = 'kumar dot mcmillan / gmail.com',
51 | description = description,
52 | classifiers = [ 'Environment :: Other Environment',
53 | 'Intended Audience :: Developers',
54 | ( 'License :: OSI Approved :: GNU Library or Lesser '
55 | 'General Public License (LGPL)'),
56 | 'Natural Language :: English',
57 | 'Operating System :: OS Independent',
58 | 'Programming Language :: Python',
59 | 'Topic :: Software Development :: Testing',
60 | 'Topic :: Software Development :: Quality Assurance',
61 | 'Topic :: Utilities'],
62 | long_description = long_description,
63 | license = 'GNU Lesser General Public License (LGPL)',
64 | keywords = ('test testing tools unittest fixtures setup teardown '
65 | 'database stubs IO tempfile'),
66 | url = 'http://farmdev.com/projects/fixture/',
67 |
68 | packages = find_packages(),
69 |
70 | test_suite="fixture.setup_test_not_supported",
71 | entry_points = {
72 | 'console_scripts': [ 'fixture = fixture.command.generate:main' ]
73 | },
74 | # the following allows e.g. easy_install fixture[django]
75 | extras_require = {
76 | 'decorators': ['nose>=0.9.2'],
77 | 'sqlalchemy': ['SQLAlchemy>=0.4'],
78 | 'sqlobject': ['SQLObject==0.8'],
79 | 'django': ['django'],
80 | },
81 | )
--------------------------------------------------------------------------------
/fixture/test/test_loadable/test_django/test_djangomeduim.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime
2 | from fixture import DjangoFixture
3 | from fixture.style import NamedDataStyle
4 | from fixture.loadable.django_loadable import field_is_required
5 | from fixtures import *
6 | from util import *
7 | from nose.tools import raises
8 | from fixture.examples.django_example.app import models
9 | from django.db import models as django_models
10 |
11 | def _check_row(medium, column_vals):
12 | medium._check_schema(column_vals)
13 |
14 | def test_schema_conformance():
15 |
16 | valid_rels = ValidNoRelationsData()
17 | invalid_rels = InvalidNoRelationsData()
18 |
19 | class NoRelations(django_models.Model):
20 | char = django_models.CharField(max_length=10)
21 | num = django_models.IntegerField()
22 |
23 | for dataset, model, callable in \
24 | [
25 | (valid_rels, NoRelations, _check_row),
26 | (invalid_rels, NoRelations,
27 | raises(ValueError)(_check_row))
28 | ]:
29 | djm = DjangoFixture.DjangoMedium(NoRelations, dataset)
30 | rows = [(row[0], list(get_column_vals(row[1]))) for row in dataset]
31 | for row in rows:
32 | callable.description = "schema.conformance: %s %s in %s" % (row[0], row[1],
33 | dataset.__class__.__name__)
34 | yield callable, djm, row[1]
35 |
36 | def test_is_field_required():
37 | from django.db import models
38 | class TestMod(models.Model):
39 | pk = models.CharField(primary_key=True)
40 | req = models.CharField()
41 | default_char = models.CharField(default='default_val')
42 | null = models.CharField(null=True)
43 | date = models.DateTimeField(auto_now=True)
44 | req_date = models.DateTimeField()
45 | nullable_date = models.DateTimeField(null=True, auto_now_add=True)
46 | default_date = models.DateTimeField(default=datetime.now)
47 |
48 |
49 | required_matrix = dict(
50 | pk=False,
51 | req=True,
52 | default_char=False,
53 | null=False,
54 | date=False,
55 | req_date=True,
56 | nullable_date=False,
57 | default_date=False,
58 | )
59 |
60 | def check_field_required(fld, result):
61 | msg = "field '%s': null=%s, primary_key=%s, auto_now=%s, auto_now_add=%s " \
62 | "should be %s"
63 | auto_now = getattr(fld, 'auto_now', None)
64 | auto_now_add = getattr(fld, 'auto_now_add', None)
65 | assert field_is_required(fld) == result, msg % (fld.name, fld.null,
66 | fld.primary_key,
67 | auto_now, auto_now_add,
68 | result)
69 |
70 | for item in required_matrix.items():
71 | fld, result = item
72 | check_field_required.description = "%s required? %s" % item
73 | yield check_field_required, TestMod._meta.get_field(fld), result
--------------------------------------------------------------------------------
/fixture/examples/django_example/settings.py:
--------------------------------------------------------------------------------
1 | # Django settings for project project.
2 | import os
3 | DEBUG = True
4 | TEMPLATE_DEBUG = DEBUG
5 |
6 | ADMINS = (
7 | # ('Your Name', 'your_email@domain.com'),
8 | )
9 |
10 | MANAGERS = ADMINS
11 |
12 |
13 | DATABASE_ENGINE = 'sqlite3'
14 | DATABASE_NAME = os.path.join(os.path.dirname(__file__), 'project.db')
15 | # MY POSTGRES SETTINGS
16 | #DATABASE_ENGINE = 'postgresql_psycopg2'
17 | #DATABASE_NAME = 'fixture' #
18 | #DATABASE_USER = 'ben' # Not used with sqlite3.
19 | DATABASE_PASSWORD = '' # Not used with sqlite3.
20 | DATABASE_HOST = '' # Set to empty string for localhost. Not used with sqlite3.
21 | DATABASE_PORT = '' # Set to empty string for default. Not used with sqlite3.
22 |
23 | # Local time zone for this installation. Choices can be found here:
24 | # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
25 | # although not all choices may be available on all operating systems.
26 | # If running in a Windows environment this must be set to the same as your
27 | # system time zone.
28 | TIME_ZONE = 'America/Chicago'
29 |
30 | # Language code for this installation. All choices can be found here:
31 | # http://www.i18nguy.com/unicode/language-identifiers.html
32 | LANGUAGE_CODE = 'en-us'
33 |
34 | SITE_ID = 1
35 |
36 | # If you set this to False, Django will make some optimizations so as not
37 | # to load the internationalization machinery.
38 | USE_I18N = True
39 |
40 | # Absolute path to the directory that holds media.
41 | # Example: "/home/media/media.lawrence.com/"
42 | MEDIA_ROOT = ''
43 |
44 | # URL that handles the media served from MEDIA_ROOT. Make sure to use a
45 | # trailing slash if there is a path component (optional in other cases).
46 | # Examples: "http://media.lawrence.com", "http://example.com/media/"
47 | MEDIA_URL = ''
48 |
49 | # URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a
50 | # trailing slash.
51 | # Examples: "http://foo.com/media/", "/media/".
52 | ADMIN_MEDIA_PREFIX = '/media/'
53 |
54 | # Make this unique, and don't share it with anybody.
55 | SECRET_KEY = 'ng5s##h+-wugvd2xwi2p*#p2g16%11on3=wv33dmx)yp#r*7gw'
56 |
57 | # List of callables that know how to import templates from various sources.
58 | TEMPLATE_LOADERS = (
59 | 'django.template.loaders.filesystem.load_template_source',
60 | 'django.template.loaders.app_directories.load_template_source',
61 | # 'django.template.loaders.eggs.load_template_source',
62 | )
63 |
64 | MIDDLEWARE_CLASSES = (
65 | 'django.middleware.common.CommonMiddleware',
66 | 'django.contrib.sessions.middleware.SessionMiddleware',
67 | 'django.contrib.auth.middleware.AuthenticationMiddleware',
68 | )
69 |
70 | ROOT_URLCONF = 'blog.urls'
71 |
72 | TEMPLATE_DIRS = (
73 | # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
74 | # Always use forward slashes, even on Windows.
75 | # Don't forget to use absolute paths, not relative paths.
76 | )
77 |
78 | INSTALLED_APPS = (
79 | 'django.contrib.auth',
80 | 'django.contrib.contenttypes',
81 | 'django.contrib.sessions',
82 | 'django.contrib.sites',
83 | 'app',
84 | 'blog',
85 | )
86 |
--------------------------------------------------------------------------------
/fixture/examples/django_example/blog/templatetags/blog.py:
--------------------------------------------------------------------------------
1 | from django import template
2 | from django.conf import settings
3 | from django.db import models
4 |
5 | import re
6 |
7 | Post = models.get_model('blog', 'post')
8 | Category = models.get_model('blog', 'category')
9 |
10 | register = template.Library()
11 |
12 |
13 | class LatestPosts(template.Node):
14 | def __init__(self, limit, var_name):
15 | self.limit = limit
16 | self.var_name = var_name
17 |
18 | def render(self, context):
19 | posts = Post.objects.published()[:int(self.limit)]
20 | if posts and (int(self.limit) == 1):
21 | context[self.var_name] = posts[0]
22 | else:
23 | context[self.var_name] = posts
24 | return ''
25 |
26 | @register.tag
27 | def get_latest_posts(parser, token):
28 | """
29 | Gets any number of latest posts and stores them in a varable.
30 |
31 | Syntax::
32 |
33 | {% get_latest_posts [limit] as [var_name] %}
34 |
35 | Example usage::
36 |
37 | {% get_latest_posts 10 as latest_post_list %}
38 | """
39 | try:
40 | tag_name, arg = token.contents.split(None, 1)
41 | except ValueError:
42 | raise template.TemplateSyntaxError, "%s tag requires arguments" % token.contents.split()[0]
43 | m = re.search(r'(.*?) as (\w+)', arg)
44 | if not m:
45 | raise template.TemplateSyntaxError, "%s tag had invalid arguments" % tag_name
46 | format_string, var_name = m.groups()
47 | return LatestPosts(format_string, var_name)
48 |
49 |
50 | class BlogCategories(template.Node):
51 | def __init__(self, var_name):
52 | self.var_name = var_name
53 |
54 | def render(self, context):
55 | categories = Category.objects.all()
56 | context[self.var_name] = categories
57 | return ''
58 |
59 | @register.tag
60 | def get_blog_categories(parser, token):
61 | """
62 | Gets all blog categories.
63 |
64 | Syntax::
65 |
66 | {% get_blog_categories as [var_name] %}
67 |
68 | Example usage::
69 |
70 | {% get_blog_categories as category_list %}
71 | """
72 | try:
73 | tag_name, arg = token.contents.split(None, 1)
74 | except ValueError:
75 | raise template.TemplateSyntaxError, "%s tag requires arguments" % token.contents.split()[0]
76 | m = re.search(r'as (\w+)', arg)
77 | if not m:
78 | raise template.TemplateSyntaxError, "%s tag had invalid arguments" % tag_name
79 | var_name = m.groups()[0]
80 | return BlogCategories(var_name)
81 |
82 |
83 | @register.filter
84 | def get_links(value):
85 | """
86 | Extracts links from a ``Post`` body and returns a list.
87 |
88 | Template Syntax::
89 |
90 | {{ post.body|markdown:"safe"|get_links }}
91 |
92 | """
93 | try:
94 | try:
95 | from BeautifulSoup import BeautifulSoup
96 | except ImportError:
97 | from beautifulsoup import BeautifulSoup
98 | soup = BeautifulSoup(value)
99 | return soup.findAll('a')
100 | except ImportError:
101 | if settings.DEBUG:
102 | raise template.TemplateSyntaxError, "Error in 'get_links' filter: BeautifulSoup isn't installed."
103 | return value
104 |
--------------------------------------------------------------------------------
/fixture/examples/django_example/blog/templatetags/.svn/text-base/blog.py.svn-base:
--------------------------------------------------------------------------------
1 | from django import template
2 | from django.conf import settings
3 | from django.db import models
4 |
5 | import re
6 |
7 | Post = models.get_model('blog', 'post')
8 | Category = models.get_model('blog', 'category')
9 |
10 | register = template.Library()
11 |
12 |
13 | class LatestPosts(template.Node):
14 | def __init__(self, limit, var_name):
15 | self.limit = limit
16 | self.var_name = var_name
17 |
18 | def render(self, context):
19 | posts = Post.objects.published()[:int(self.limit)]
20 | if posts and (int(self.limit) == 1):
21 | context[self.var_name] = posts[0]
22 | else:
23 | context[self.var_name] = posts
24 | return ''
25 |
26 | @register.tag
27 | def get_latest_posts(parser, token):
28 | """
29 | Gets any number of latest posts and stores them in a varable.
30 |
31 | Syntax::
32 |
33 | {% get_latest_posts [limit] as [var_name] %}
34 |
35 | Example usage::
36 |
37 | {% get_latest_posts 10 as latest_post_list %}
38 | """
39 | try:
40 | tag_name, arg = token.contents.split(None, 1)
41 | except ValueError:
42 | raise template.TemplateSyntaxError, "%s tag requires arguments" % token.contents.split()[0]
43 | m = re.search(r'(.*?) as (\w+)', arg)
44 | if not m:
45 | raise template.TemplateSyntaxError, "%s tag had invalid arguments" % tag_name
46 | format_string, var_name = m.groups()
47 | return LatestPosts(format_string, var_name)
48 |
49 |
50 | class BlogCategories(template.Node):
51 | def __init__(self, var_name):
52 | self.var_name = var_name
53 |
54 | def render(self, context):
55 | categories = Category.objects.all()
56 | context[self.var_name] = categories
57 | return ''
58 |
59 | @register.tag
60 | def get_blog_categories(parser, token):
61 | """
62 | Gets all blog categories.
63 |
64 | Syntax::
65 |
66 | {% get_blog_categories as [var_name] %}
67 |
68 | Example usage::
69 |
70 | {% get_blog_categories as category_list %}
71 | """
72 | try:
73 | tag_name, arg = token.contents.split(None, 1)
74 | except ValueError:
75 | raise template.TemplateSyntaxError, "%s tag requires arguments" % token.contents.split()[0]
76 | m = re.search(r'as (\w+)', arg)
77 | if not m:
78 | raise template.TemplateSyntaxError, "%s tag had invalid arguments" % tag_name
79 | var_name = m.groups()[0]
80 | return BlogCategories(var_name)
81 |
82 |
83 | @register.filter
84 | def get_links(value):
85 | """
86 | Extracts links from a ``Post`` body and returns a list.
87 |
88 | Template Syntax::
89 |
90 | {{ post.body|markdown:"safe"|get_links }}
91 |
92 | """
93 | try:
94 | try:
95 | from BeautifulSoup import BeautifulSoup
96 | except ImportError:
97 | from beautifulsoup import BeautifulSoup
98 | soup = BeautifulSoup(value)
99 | return soup.findAll('a')
100 | except ImportError:
101 | if settings.DEBUG:
102 | raise template.TemplateSyntaxError, "Error in 'get_links' filter: BeautifulSoup isn't installed."
103 | return value
104 |
--------------------------------------------------------------------------------
/fixture/test/test_dataset/test_converter.py:
--------------------------------------------------------------------------------
1 |
2 | from fixture.test import attr
3 | from decimal import Decimal
4 | import datetime
5 | from fixture import DataSet
6 | from nose.tools import eq_, raises
7 | from fixture.dataset.converter import *
8 | try:
9 | import json
10 | except ImportError:
11 | import simplejson as json
12 | from cStringIO import StringIO
13 |
14 | class FooData(DataSet):
15 | class bar:
16 | name = "call me bar"
17 | is_alive = False
18 | class foo:
19 | name = "name's foo"
20 | is_alive = True
21 |
22 | class MuchoData(DataSet):
23 | class mucho:
24 | d = datetime.date(2008,1,1)
25 | dt = datetime.datetime(2008,1,1,2,30,59)
26 | dec = Decimal("1.45667")
27 | fl = float(1.45667)
28 |
29 | class DummyError(Exception):
30 | pass
31 |
32 | class TestDatasetToJson(object):
33 |
34 | @attr(unit=1)
35 | @raises(TypeError)
36 | def test_must_be_dataset(self):
37 | class NotADataSet(object):
38 | pass
39 | dataset_to_json(NotADataSet)
40 |
41 | @attr(unit=1)
42 | def test_convert_cls(self):
43 | eq_(dataset_to_json(FooData),
44 | json.dumps(
45 | [{'name': "call me bar",
46 | 'is_alive': False},
47 | {'name': "name's foo",
48 | 'is_alive': True}]))
49 |
50 | @attr(unit=1)
51 | def test_convert_instance(self):
52 | foo = FooData()
53 | eq_(dataset_to_json(foo),
54 | json.dumps(
55 | [{'name': "call me bar",
56 | 'is_alive': False},
57 | {'name': "name's foo",
58 | 'is_alive': True}]))
59 |
60 | @attr(unit=1)
61 | def test_dump_to_file(self):
62 | fp = StringIO()
63 | dataset_to_json(FooData, fp=fp)
64 | eq_(fp.getvalue(),
65 | json.dumps(
66 | [{'name': "call me bar",
67 | 'is_alive': False},
68 | {'name': "name's foo",
69 | 'is_alive': True}]))
70 |
71 | @attr(unit=1)
72 | def test_types(self):
73 | eq_(json.loads(dataset_to_json(MuchoData)),
74 | [{
75 | 'd': "2008-01-01",
76 | "dt": "2008-01-01 02:30:59",
77 | "dec": "1.45667",
78 | "fl": 1.45667
79 | }])
80 |
81 | @attr(unit=1)
82 | @raises(DummyError)
83 | def test_custom_converter(self):
84 |
85 | def my_default(obj):
86 | raise DummyError()
87 |
88 | ds = dataset_to_json(MuchoData, default=my_default)
89 | assert not ds, (
90 | "dataset_to_json() should have died but it returned: %s" % ds)
91 |
92 | @attr(unit=1)
93 | def test_wrap(self):
94 |
95 | def wrap_in_dict(objects):
96 | return {'data': objects}
97 |
98 | eq_(dataset_to_json(FooData, wrap=wrap_in_dict),
99 | json.dumps({
100 | 'data':
101 | [{'name': "call me bar",
102 | 'is_alive': False},
103 | {'name': "name's foo",
104 | 'is_alive': True}]
105 | }))
106 |
--------------------------------------------------------------------------------
/fixture/test/test_loadable/test_django/fixture-with-django-doctests.rst:
--------------------------------------------------------------------------------
1 |
2 | .. _django-doctests:
3 |
4 | -----------------------------------
5 | Old django doctests
6 | -----------------------------------
7 |
8 | Back to :ref:`using-fixture-with-django`
9 |
10 | We'll be using a simple django project and application (found in fixture/examples/django_example/). The models.py is included here for reference:
11 |
12 | .. _doctest-models:
13 |
14 | .. literalinclude:: ../../fixture/examples/django_example/app/models.py
15 | :language: python
16 | :linenos:
17 |
18 | .. currentmodule:: fixture.loadable.django_loadable
19 |
20 | Given the above models and the following fixtures:
21 |
22 | .. doctest::
23 |
24 | >>> from fixture import DataSet
25 | >>> class AuthorData(DataSet):
26 | ... class Meta:
27 | ... django_model = 'app.Author'
28 | ... class frank_herbert:
29 | ... first_name = "Frank"
30 | ... last_name = "Herbert"
31 | ... class guido:
32 | ... first_name = "Guido"
33 | ... last_name = "Van rossum"
34 | ...
35 | >>> class BookData(DataSet):
36 | ... class Meta:
37 | ... django_model = 'app.Book'
38 | ... class dune:
39 | ... title = "Dune"
40 | ... author = AuthorData.frank_herbert
41 | ...
42 | ... class python:
43 | ... title = 'Python'
44 | ... author = AuthorData.guido
45 | ...
46 | >>> class ReviewerData(DataSet):
47 | ... class Meta:
48 | ... django_model = 'app.Reviewer'
49 | ... class ben:
50 | ... name = 'ben'
51 | ... reviewed = [BookData.dune, BookData.python]
52 |
53 | We can do the following:
54 |
55 | .. doctest::
56 |
57 | >>> from fixture import DjangoFixture
58 | >>> from django.db.models.loading import get_model, get_app
59 | >>> from fixture.test.test_loadable.test_django.util import assert_empty
60 | >>> app = get_app('app')
61 | >>> assert_empty(app)
62 | >>> Book = get_model('app', 'Book')
63 | >>> django_fixture = DjangoFixture()
64 | >>> data = django_fixture.data(BookData)
65 | >>> data.setup()
66 |
67 | All the books are here:
68 |
69 | .. doctest::
70 |
71 | >>> [(b.title, b.author.first_name) for b in Book.objects.all()]
72 | [(u'Dune', u'Frank'), (u'Python', u'Guido')]
73 |
74 | And fixture has pulled in all the Authors too:
75 |
76 | .. doctest::
77 |
78 | >>> Author = get_model('app', 'Author')
79 | >>> [a.first_name for a in Author.objects.all()]
80 | [u'Frank', u'Guido']
81 |
82 | But not the Reviewers:
83 |
84 | .. doctest::
85 |
86 | >>> get_model('app', 'Reviewer').objects.count()
87 | 0
88 |
89 | If we load the ReviewerDatas DataSet, all of the others will be pulled in:
90 |
91 | .. doctest::
92 |
93 | >>> data.teardown() # Get rid of the old data
94 | >>> assert_empty(app)
95 |
96 |
97 | .. doctest::
98 |
99 | >>> data = django_fixture.data(ReviewerData)
100 | >>> data.setup()
101 | >>> get_model('app', 'Reviewer').objects.count()
102 | 1
103 | >>> Book.objects.count()
104 | 2
105 | >>> Author.objects.count()
106 | 2
107 | >>> data.teardown()
108 |
109 |
110 |
--------------------------------------------------------------------------------
/fixture/examples/django_example/blog/.svn/text-base/CHANGELOG.yml.svn-base:
--------------------------------------------------------------------------------
1 | changes:
2 | date: 2008-09-17
3 | change: Enabled the ability to override the default template names.
4 |
5 | date: 2008-08-26
6 | change: Upgraded post_detail.html to now use new Django refactored comments. Sidenote: basic.remarks have been removed.
7 |
8 | date: 2008-07-14
9 | change: Removed get_query_set from Blog manager to fix a problem where saving a post marked as Draft would not save.
10 | change: Added a get_previous_post and get_next_post method for front end template. These will not return Draft posts.
11 |
12 | date: 2008-06-17
13 | change: BlogPostFeed is now BlogPostsFeed and there is a new BlogPostsByCategory.
14 |
15 | date: 2008-05-18
16 | change: Converted everything to 4 space tabs and made a few other changes to comply with Python Style Guide.
17 |
18 | date: 2008-04-23
19 | change: Added an inline admin interface helper for choosing inlines to go into posts.
20 | change: The inline app is now a dependancy of the blog.
21 |
22 | date: 2008-04-22
23 | change: Removed the 'render_inlines' filter from the Blog template tags. The tag is now in an app called inlines which can be used with any django app.
24 |
25 | date: 2008-02-27
26 | change: Added 'allow_comments' field to the Post model.
27 | change: Removed 'Closed' choice from status field of Post model
28 |
29 | date: 2008-02-18
30 | fix: Fixed feed pointing to hardcoded url.
31 |
32 | date: 2008-02-15
33 | change: Internationalized models
34 |
35 | date: 2008-02-04
36 | change: Added 'get_links' template filter.
37 | change: Templates: added a {% block content_title %}
38 |
39 | date: 2008-02-02
40 | change: Added a sitemap
41 |
42 | date: 2008-01-30
43 | change: Renamed 'do_inlines' filter to 'render_inlines'
44 |
45 | date: 2008-01-29
46 | change: BeautifulSoup is no longer a dependancy unless you want to use the do_inlines filter.
47 |
48 | date: 2008-01-27
49 | fix: removed 'tagging.register(Post)' from model. It was causing too many unnecessary SQL JOINS.
50 | change: Changed the inlines tag to a filter. (Example: {{ object.text|do_inlines }})
51 |
52 | date: 2008-01-22
53 | change: Registered the Post model with the tagging app
54 |
55 | date: 2008-01-19
56 | change: Renamed the 'list' class to 'link_list'
57 |
58 | date: 2008-01-09
59 | change: Changed urls.py so you can have /posts/page/2/ or /posts/?page=2
60 |
61 | date: 2008-01-07
62 | change: Removed PublicPostManager in favor of ManagerWithPublished.
63 | change: Made wrappers for generic views.
64 |
65 | date: 2008-01-06
66 | fix: In blog.py changed 'beautifulsoup' to 'BeautifulSoup'
67 |
68 | date: 2007-12-31
69 | change: Changed some syntax in managers.py to hopefully fix a bug.
70 | change: Removed an inline template that didn't belong.
71 |
72 | date: 2007-12-21
73 | change: Added markup tag that formats inlines.
74 |
75 | date: 2007-12-12
76 | change: Cleaned up unit tests.
77 |
78 | date: 2007-12-11
79 | change: Add documentation to templatetags and views.
80 | change: Smartened up the previous/next blog part of the post_detail.html template.
81 |
82 | date: 2007-12-09
83 | change: Added feed templates and wrapped up feeds.py.
84 | change: Changed Post.live manager to Post.public
85 | change: Added a search view along with templates
86 |
--------------------------------------------------------------------------------
/fixture/test/__init__.py:
--------------------------------------------------------------------------------
1 |
2 | """The fixture test suite.
3 |
4 | There are several things to build before you can run the tests.
5 | Hopefully this will be simplified in the future but for now, do this:
6 |
7 | Create the buildout::
8 |
9 | $ python2.5 setup_test_buildout.py
10 |
11 | Check out the trunk of Django (until 1.1 is released) into a src dir for buildout ::
12 |
13 | $ svn co http://code.djangoproject.com/svn/django/trunk/ src/django
14 |
15 | Build everything ::
16 |
17 | $ ./bin/buildout
18 |
19 | Run syncdb on the Django test DB and create a superuser ::
20 |
21 | $ ./bin/manage syncdb
22 |
23 | Run the tests ::
24 |
25 | $ ./bin/test-fixture
26 |
27 | Environment Variables
28 | ---------------------
29 |
30 | The test suite is affected by several environment variables:
31 |
32 | - FIXTURE_TEST_HEAVY_DSN
33 |
34 | - a database connection that can support operations like foreign key relations
35 | (sqlite won't through foreign key errors)
36 | - defaults to None.
37 | - typically this would be a postgres connection where temp tables can be
38 | created and destroyed
39 | - a special DSN, "sqlite:///:tmp:", will create a connection to a temporary
40 | file-based sqlite db. This is necessary because :memory: dbs can't be
41 | shared easily using sqlalchemy (connections are not pooled)
42 |
43 | - FIXTURE_TEST_LITE_DSN
44 |
45 | - a database as lite as possible, for speed
46 | - defaults to sqlite:///:memory:
47 |
48 | As a shortcut, you can run this to set these variables in your shell ::
49 |
50 | $ source fixture/test/profile/full.sh
51 |
52 | """
53 |
54 | import unittest, nose, os
55 | from fixture.test import conf
56 |
57 | def setup():
58 | # super hack:
59 | if conf.HEAVY_DSN == 'sqlite:///:tmp:':
60 | conf.HEAVY_DSN_IS_TEMPIO = True
61 | conf.reset_heavy_dsn()
62 |
63 | # this is here because the doc generator also runs doctests.
64 | # should fix that to use proper _test() methods for a module
65 | teardown_examples()
66 |
67 | def teardown():
68 | teardown_examples()
69 |
70 | def teardown_examples():
71 | if os.path.exists('/tmp/fixture_example.db'):
72 | os.unlink('/tmp/fixture_example.db')
73 | if os.path.exists('/tmp/fixture_generate.db'):
74 | os.unlink('/tmp/fixture_generate.db')
75 |
76 |
77 | class PrudentTestResult(unittest.TestResult):
78 | """A test result that raises an exception immediately"""
79 | def _raise_err(self, err):
80 | exctype, value, tb = err
81 | raise Exception("%s: %s" % (exctype, value)), None, tb
82 |
83 | def addFailure(self, test, err):
84 | self._raise_err(err)
85 | def addError(self, test, err):
86 | self._raise_err(err)
87 |
88 | class _SilentTestResult(PrudentTestResult):
89 | def printErrors(self):
90 | pass
91 | def printErrorList(self, flavour, errors):
92 | pass
93 |
94 | class SilentTestRunner(unittest.TextTestRunner):
95 | """a test runner that doesn't print output but raises
96 | exceptions immediately
97 | """
98 | def _makeResult(self):
99 | return _SilentTestResult()
100 |
101 | def run(self, test):
102 | "Run the given test case or test suite."
103 | result = self._makeResult()
104 | test(result)
105 | return result
106 |
107 | def attr(**kwargs):
108 | """Add attributes to a test function/method/class"""
109 | def wrap(func):
110 | func.__dict__.update(kwargs)
111 | return func
112 | return wrap
113 |
114 |
115 |
--------------------------------------------------------------------------------
/fixture/examples/django_example/blog/templates/blog/.svn/entries:
--------------------------------------------------------------------------------
1 | 9
2 |
3 | dir
4 | 102
5 | http://django-basic-apps.googlecode.com/svn/trunk/blog/templates/blog
6 | http://django-basic-apps.googlecode.com/svn
7 |
8 |
9 |
10 | 2008-10-06T01:31:58.796932Z
11 | 83
12 | nathan@playgroundblues.com
13 |
14 |
15 | svn:special svn:externals svn:needs-lock
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 | 5ae32e2a-df40-0410-a01d-45158a99d8df
28 |
29 | base_blog.html
30 | file
31 |
32 |
33 |
34 |
35 | 2009-03-04T15:11:18.000000Z
36 | b9986c0b0e12f6f0e39be84d9a393375
37 | 2008-04-27T15:53:25.835450Z
38 | 32
39 | nathan@playgroundblues.com
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 | 68
62 |
63 | category_detail.html
64 | file
65 |
66 |
67 |
68 |
69 | 2009-03-04T15:11:18.000000Z
70 | d1850d7ac8182c538b91ed4074cc4b9d
71 | 2008-10-06T01:31:58.796932Z
72 | 83
73 | nathan@playgroundblues.com
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 | 668
96 |
97 | post_list.html
98 | file
99 |
100 |
101 |
102 |
103 | 2009-03-04T15:11:18.000000Z
104 | f2cad2bbc52296d70a217f574f196558
105 | 2008-10-06T01:31:58.796932Z
106 | 83
107 | nathan@playgroundblues.com
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 | 866
130 |
131 | post_archive_day.html
132 | file
133 |
134 |
135 |
136 |
137 | 2009-03-04T15:11:18.000000Z
138 | ddce1084c8d3344c423b4e9cf85047e8
139 | 2008-10-06T01:31:58.796932Z
140 | 83
141 | nathan@playgroundblues.com
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 | 607
164 |
165 | post_archive_year.html
166 | file
167 |
168 |
169 |
170 |
171 | 2009-03-04T15:11:18.000000Z
172 | ea695ee6a108d20ebb7f691621c6bfe9
173 | 2008-10-06T01:31:58.796932Z
174 | 83
175 | nathan@playgroundblues.com
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 |
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 | 494
198 |
199 | post_detail.html
200 | file
201 |
202 |
203 |
204 |
205 | 2009-03-04T15:11:18.000000Z
206 | 7547f3497a66a8a8384b77a90f8fc7cb
207 | 2008-10-06T01:31:58.796932Z
208 | 83
209 | nathan@playgroundblues.com
210 |
211 |
212 |
213 |
214 |
215 |
216 |
217 |
218 |
219 |
220 |
221 |
222 |
223 |
224 |
225 |
226 |
227 |
228 |
229 |
230 |
231 | 2238
232 |
233 | category_list.html
234 | file
235 |
236 |
237 |
238 |
239 | 2009-03-04T15:11:18.000000Z
240 | f5034dbc2454b0024c90a50ed6e6416b
241 | 2008-10-06T01:31:58.796932Z
242 | 83
243 | nathan@playgroundblues.com
244 |
245 |
246 |
247 |
248 |
249 |
250 |
251 |
252 |
253 |
254 |
255 |
256 |
257 |
258 |
259 |
260 |
261 |
262 |
263 |
264 |
265 | 441
266 |
267 | post_search.html
268 | file
269 |
270 |
271 |
272 |
273 | 2009-03-04T15:11:18.000000Z
274 | d1ab8c7e13584d9bd21d0cd14d29be0e
275 | 2008-10-06T01:31:58.796932Z
276 | 83
277 | nathan@playgroundblues.com
278 |
279 |
280 |
281 |
282 |
283 |
284 |
285 |
286 |
287 |
288 |
289 |
290 |
291 |
292 |
293 |
294 |
295 |
296 |
297 |
298 |
299 | 989
300 |
301 | post_archive_month.html
302 | file
303 |
304 |
305 |
306 |
307 | 2009-03-04T15:11:18.000000Z
308 | f13c119ed586afc5beb7b1af117517e9
309 | 2008-10-06T01:31:58.796932Z
310 | 83
311 | nathan@playgroundblues.com
312 |
313 |
314 |
315 |
316 |
317 |
318 |
319 |
320 |
321 |
322 |
323 |
324 |
325 |
326 |
327 |
328 |
329 |
330 |
331 |
332 |
333 | 609
334 |
335 |
--------------------------------------------------------------------------------
/docs/source/using-fixture-cmd.rst:
--------------------------------------------------------------------------------
1 | .. _using-fixture-command:
2 |
3 | -------------------------
4 | Using the fixture command
5 | -------------------------
6 |
7 | .. contents:: :local:
8 |
9 | There are several issues you may run into while working with fixtures:
10 |
11 | 1. The data model of a program is usually an implementation detail. It's bad practice to "know" about implementation details in tests because it means you have to update your tests when those details change; you should only have to update your tests when an interface changes.
12 | 2. Data accumulates very fast and there is already a useful tool for slicing and dicing data: the database! Hand-coding DataSet classes is not always the way to go.
13 | 3. When regression testing or when trying to reproduce a bug, you may want to grab a "snapshot" of the existing data.
14 |
15 | ``fixture`` is a shell command to address these and other issues. It gets installed along with this module. Specifically, the ``fixture`` command accepts a path to a single object and queries that object using the command options. The output is python code that you can use in a test to reload the data retrieved by the query.
16 |
17 | .. note:: WARNING: This feature is not fully implemented and doesn't support all backends.
18 |
19 | Usage
20 | ~~~~~
21 |
22 | .. shell::
23 | :run_on_method: fixture.command.generate.main
24 |
25 | fixture --help
26 |
27 | An Example With SQLAlchemy
28 | ~~~~~~~~~~~~~~~~~~~~~~~~~~
29 |
30 | Here is a data model defined in `SQLAlchemy `_ code. (For complete code see ``fixture/examples/db/sqlalchemy_examples.py``.)
31 |
32 | .. doctest:: command
33 |
34 | >>> from sqlalchemy import *
35 | >>> from sqlalchemy.orm import *
36 | >>> metadata = MetaData()
37 | >>> authors = Table('authors', metadata,
38 | ... Column('id', Integer, primary_key=True),
39 | ... Column('first_name', String(100)),
40 | ... Column('last_name', String(100)))
41 | ...
42 | >>> class Author(object):
43 | ... pass
44 | ...
45 | >>> books = Table('books', metadata,
46 | ... Column('id', Integer, primary_key=True),
47 | ... Column('title', String(100)),
48 | ... Column('author_id', Integer, ForeignKey('authors.id')))
49 | ...
50 | >>> class Book(object):
51 | ... pass
52 | ...
53 | >>> def setup_mappers():
54 | ... mapper(Author, authors)
55 | ... mapper(Book, books, properties={
56 | ... 'author': relation(Author)
57 | ... })
58 | ...
59 | >>> def connect(dsn):
60 | ... metadata.bind = create_engine(dsn)
61 | ...
62 | >>>
63 |
64 | After inserting some data, it would be possible to run a command that points at the ``Book`` object. The above command uses ``Book`` to send a select query with a where clause ``WHERE title='Dune'``, and turns the record sets into ``DataSet`` classes:
65 |
66 | .. shell::
67 | :setup: fixture.docs.setup_command_data
68 | :teardown: fixture.test.teardown_examples
69 |
70 | fixture fixture.examples.db.sqlalchemy_examples.Book \
71 | --dsn=sqlite:////tmp/fixture_example.db \
72 | --where="title='Dune'" \
73 | --connect=fixture.examples.db.sqlalchemy_examples:connect \
74 | --setup=fixture.examples.db.sqlalchemy_examples:setup_mappers
75 |
76 | Notice that we queried the ``Book`` object but got back Table objects. Also notice that all foreign keys were followed to reproduce the complete chain of data (in this case, the ``authors`` table data).
77 |
78 | Also notice that several hooks were used, one to connect the ``metadata`` object by DSN and another to setup the mappers. See *Usage* above for more information on the ``--connect`` and ``--setup`` options.
79 |
80 | Creating a custom data handler
81 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
82 |
83 | No documentation yet
84 |
--------------------------------------------------------------------------------
/fixture/test/test_command/test_generate/__init__.py:
--------------------------------------------------------------------------------
1 |
2 | import sys
3 | import os
4 | from nose.tools import eq_
5 | from nose.exc import SkipTest
6 | from fixture.test import conf
7 | from fixture.command.generate import DataSetGenerator, dataset_generator
8 |
9 | def setup():
10 | # every tests needs a real db conn :
11 | if not conf.HEAVY_DSN:
12 | raise SkipTest
13 |
14 | def compile_(code):
15 | """compiles code string for a module.
16 |
17 | returns dict w/ attributes of that module.
18 | """
19 | mod = {}
20 | eval(compile(code, 'stdout', 'exec'), mod)
21 | return mod
22 |
23 | class GenerateTest(object):
24 | """tests that a fixture code generator can run with the specified arguments
25 | and produce a loadable fixture.
26 |
27 | the details of which arguments, how that fixture loads data, and how the
28 | data load is proven is defined in the concrete implementation of this test
29 | class
30 |
31 | """
32 | args = []
33 |
34 | def __init__(self, *a, **kw):
35 | super(GenerateTest, self).__init__(*a, **kw)
36 | self.env = None
37 |
38 | def assert_env_is_clean(self):
39 | raise NotImplementedError
40 |
41 | def assert_env_generated_ok(self, env):
42 | raise NotImplementedError
43 |
44 | def assert_data_loaded(self, data):
45 | raise NotImplementedError
46 |
47 | def create_fixture(self):
48 | raise NotImplementedError("must return a concrete LoadableFixture instance, i.e. SQLAlchemyFixture")
49 |
50 | def load_env(self, module):
51 | raise NotImplementedError
52 |
53 | def dataset_generator(self, extra_args=[]):
54 | args = [a for a in self.args]
55 | if extra_args:
56 | args.extend(extra_args)
57 |
58 | self.assert_env_is_clean()
59 | code = dataset_generator(args)
60 | try:
61 | self.env = compile_(code)
62 | self.assert_env_generated_ok(self.env)
63 | data = self.load_env(self.env)
64 | self.assert_data_loaded(data)
65 | except:
66 | print code
67 | raise
68 |
69 | def test_query(self):
70 | self.dataset_generator(['-w', "name = 'super cash back!'"])
71 |
72 | def test_query_no_data(self):
73 | _stderr = sys.stderr
74 | sys.stderr = sys.stdout
75 | def wrong_exc(exc=None):
76 | raise AssertionError("expected exit 2 %s" % (
77 | exc and ("(raised: %s: %s)" % (exc.__class__, exc)) or ""))
78 | try:
79 | try:
80 | self.dataset_generator(['-w', "name = 'fooobzarius'"])
81 | except SystemExit, e:
82 | eq_(e.code, 2)
83 | except Exception, e:
84 | wrong_exc(e)
85 | else:
86 | wrong_exc()
87 | finally:
88 | sys.stderr = _stderr
89 |
90 |
91 | class UsingTesttoolsTemplate(object):
92 | def __init__(self, *a,**kw):
93 | super(UsingTesttoolsTemplate, self).__init__(*a,**kw)
94 | self.args = [a for a in self.args] + ["--template=testtools"]
95 |
96 | def load_datasets(self, module, datasets):
97 | from testtools.fixtures import affix
98 | fxt = affix(*[d() for d in datasets])
99 | return fxt
100 |
101 | class UsingFixtureTemplate(object):
102 | def __init__(self, *a,**kw):
103 | super(UsingFixtureTemplate, self).__init__(*a,**kw)
104 | self.args = [a for a in self.args] + ["--template=fixture"]
105 |
106 | def visit_loader(self, loader):
107 | pass
108 |
109 | def load_datasets(self, module, datasets):
110 | fixture = self.create_fixture()
111 | self.visit_loader(fixture.loader)
112 | d = fixture.data(*datasets)
113 | d.setup()
114 | return d
--------------------------------------------------------------------------------
/fixture/dataset/converter.py:
--------------------------------------------------------------------------------
1 |
2 | """Utilities for converting datasets."""
3 |
4 | import datetime
5 | import decimal
6 | import types
7 | from fixture.dataset import DataSet, DataRow
8 | json = None
9 | try:
10 | # 2.6
11 | import json
12 | except ImportError:
13 | try:
14 | import simplejson as json
15 | except ImportError:
16 | pass
17 |
18 | def _obj_items(obj):
19 | for name in dir(obj):
20 | if name.startswith('__'):
21 | continue
22 | yield name, getattr(obj, name)
23 |
24 | def default_json_converter(obj):
25 | """converts obj to a value safe for JSON serialization."""
26 | if isinstance(obj, (datetime.date, datetime.datetime, decimal.Decimal, float)):
27 | return str(obj)
28 | raise TypeError("%r is not JSON serializable" % (obj,))
29 |
30 | def dataset_to_json(dataset, fp=None, default=default_json_converter, wrap=None):
31 | """Converts a :class:`DataSet ` class or
32 | instance to JSON (JavaScript Object Notation).
33 |
34 | See :ref:`using-dataset-to-json` for detailed usage.
35 |
36 | Keyword Arguments
37 |
38 | **fp**
39 | An optional file-like object (must implement ``fp.write()``). When
40 | this is not None, the output is written to the fp object, otherwise
41 | the output is returned
42 |
43 | **default**
44 | A callable that takes one argument (an object) and returns output
45 | suitable for JSON serialization. This will *only* be called if the
46 | object cannot be serialized. For example::
47 |
48 | >>> def encode_complex(obj):
49 | ... if isinstance(obj, complex):
50 | ... return [obj.real, obj.imag]
51 | ... raise TypeError("%r is not JSON serializable" % (o,))
52 | ...
53 | >>> from fixture import DataSet
54 | >>> class ComplexData(DataSet):
55 | ... class math_stuff:
56 | ... complex = 2 + 1j
57 | ...
58 | >>> dataset_to_json(ComplexData, default=encode_complex)
59 | '[{"complex": [2.0, 1.0]}]'
60 |
61 | **wrap**
62 | A callable that takes one argument, the list of dictionaries before
63 | they are converted to JSON. For example::
64 |
65 | >>> def wrap_in_dict(objects):
66 | ... return {'data': objects}
67 | ...
68 | >>> from fixture import DataSet
69 | >>> class ColorData(DataSet):
70 | ... class red:
71 | ... color = "red"
72 | ...
73 | >>> dataset_to_json(ColorData, wrap=wrap_in_dict)
74 | '{"data": [{"color": "red"}]}'
75 |
76 | Returns a JSON encoded string unless you specified the **fp** keyword
77 |
78 | """
79 | assert json, (
80 | "You must have the simplejson or json module installed. "
81 | "Neither could be imported")
82 | if isinstance(dataset, type):
83 | # we got a class so make it an instance
84 | # so that rows are resolved
85 | dataset = dataset()
86 | if not isinstance(dataset, DataSet):
87 | raise TypeError("First argument must be a class or instance of a DataSet")
88 | objects = []
89 | for name, row in _obj_items(dataset):
90 | try:
91 | if not issubclass(row, DataRow):
92 | continue
93 | except TypeError:
94 | continue
95 | row_dict = {}
96 | for col, val in _obj_items(row):
97 | if col=='_reserved_attr' or callable(val):
98 | continue
99 | row_dict[col] = val
100 | objects.append(row_dict)
101 | if wrap:
102 | objects = wrap(objects)
103 | if fp:
104 | return json.dump(objects, fp, default=default)
105 | else:
106 | return json.dumps(objects, default=default)
107 |
108 | if __name__ == '__main__':
109 | import doctest
110 | doctest.testmod()
--------------------------------------------------------------------------------
/fixture/test/test_command/test_generate/test_generate_sqlobject.py:
--------------------------------------------------------------------------------
1 |
2 | import os
3 | from nose.tools import eq_
4 | from nose.exc import SkipTest
5 | from fixture import SQLObjectFixture
6 | from fixture.command.generate import DataSetGenerator, dataset_generator
7 | from fixture.dataset import MergedSuperSet
8 | from fixture.style import NamedDataStyle
9 | from fixture.test.test_command.test_generate import (
10 | compile_, GenerateTest, UsingTesttoolsTemplate, UsingFixtureTemplate)
11 | from fixture.test import env_supports, conf
12 | from fixture.examples.db.sqlobject_examples import (
13 | Category, Product, Offer, setup_db, teardown_db)
14 |
15 | sqlhub = None
16 | realconn = None
17 | memconn = None
18 |
19 | def setup():
20 | global memconn, realconn, sqlhub
21 | if not env_supports.sqlobject:
22 | raise SkipTest
23 |
24 | from sqlobject import connectionForURI, sqlhub
25 |
26 | realconn = connectionForURI(conf.HEAVY_DSN)
27 | memconn = connectionForURI("sqlite:/:memory:")
28 |
29 | def teardown():
30 | realconn.close()
31 | globals()['realconn'] = None
32 | memconn.close()
33 | globals()['memconn'] = None
34 |
35 | class SQLObjectGenerateTest(GenerateTest):
36 | args = [
37 | "fixture.examples.db.sqlobject_examples.Offer",
38 | "--dsn", str(conf.HEAVY_DSN) ]
39 |
40 | def assert_data_loaded(self, fxt):
41 | rs = Category.select()
42 | eq_(rs.count(), 2)
43 | parkas = rs[0]
44 | rebates = rs[1]
45 | eq_(parkas.name, "parkas")
46 | eq_(rebates.name, "rebates")
47 |
48 | rs = Product.select()
49 | eq_(rs.count(), 1)
50 | eq_(rs[0].name, "jersey")
51 |
52 | rs = Offer.select()
53 | eq_(rs.count(), 1)
54 | eq_(rs[0].name, "super cash back!")
55 |
56 | # note that here we test that colliding fixture key links
57 | # got resolved correctly :
58 | eq_(Category.get(fxt.product_1.category_id), parkas)
59 | eq_(Category.get(fxt.offer_1.category_id), rebates)
60 |
61 | def assert_env_is_clean(self):
62 | # sanity check :
63 | assert Product.select(connection=realconn).count()
64 | assert not Product.select(connection=memconn).count()
65 |
66 | def assert_env_generated_ok(self, e):
67 | CategoryData = e['CategoryData']
68 | ProductData = e['ProductData']
69 | OfferData = e['OfferData']
70 |
71 | # another sanity check, wipe out the source data
72 | Offer.clearTable(connection=realconn)
73 | Product.clearTable(connection=realconn)
74 | Category.clearTable(connection=realconn)
75 |
76 | def create_fixture(self):
77 | return SQLObjectFixture(
78 | env = self.env,
79 | style = NamedDataStyle(),
80 | dataclass = MergedSuperSet,
81 | )
82 |
83 | def load_datasets(self, module, conn, datasets):
84 | raise NotImplementedError
85 |
86 | def load_env(self, env):
87 | # set our conn back to memory then load the fixture.
88 | # hmm, seems hoky
89 | sqlhub.processConnection = memconn
90 | data = self.load_datasets(env,
91 | [env['CategoryData'], env['ProductData'], env['OfferData']])
92 | return data
93 |
94 | def setUp(self):
95 | setup_db(realconn)
96 | sqlhub.processConnection = realconn
97 |
98 | parkas = Category(name="parkas")
99 | jersey = Product(name="jersey", category=parkas)
100 | rebates = Category(name="rebates")
101 | super_cashback = Offer( name="super cash back!",
102 | product=jersey, category=rebates)
103 | sqlhub.processConnection = None
104 |
105 | # now get the loading db as a sqlite mem connection :
106 | setup_db(memconn)
107 |
108 | def tearDown(self):
109 | sqlhub.processConnection = None
110 | teardown_db(realconn)
111 | teardown_db(memconn)
112 |
113 | class TestSQLObjectTesttools(UsingTesttoolsTemplate, SQLObjectGenerateTest):
114 | pass
115 |
116 | class TestSQLObjectFixture(UsingFixtureTemplate, SQLObjectGenerateTest):
117 | def visit_loader(self, loader):
118 | loader.connection = memconn
119 |
120 |
--------------------------------------------------------------------------------
/fixture/examples/django_example/blog/.svn/entries:
--------------------------------------------------------------------------------
1 | 9
2 |
3 | dir
4 | 102
5 | http://django-basic-apps.googlecode.com/svn/trunk/blog
6 | http://django-basic-apps.googlecode.com/svn
7 |
8 |
9 |
10 | 2009-01-23T18:24:47.940314Z
11 | 100
12 | nathan@playgroundblues.com
13 |
14 |
15 | svn:special svn:externals svn:needs-lock
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 | 5ae32e2a-df40-0410-a01d-45158a99d8df
28 |
29 | admin.py
30 | file
31 |
32 |
33 |
34 |
35 | 2009-03-04T15:11:19.000000Z
36 | dee1ad0e6d7452f90112602a2974d54c
37 | 2008-07-19T05:34:54.894082Z
38 | 54
39 | nathan@playgroundblues.com
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 | 465
62 |
63 | views.py
64 | file
65 |
66 |
67 |
68 |
69 | 2009-03-04T15:11:19.000000Z
70 | 379961557784d427d46c3dcf072c4729
71 | 2008-10-16T20:54:22.265570Z
72 | 92
73 | nathan@playgroundblues.com
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 | 6260
96 |
97 | managers.py
98 | file
99 |
100 |
101 |
102 |
103 | 2009-03-04T15:11:19.000000Z
104 | 4da04472e778f6fa4d09f77709a52622
105 | 2008-10-15T16:18:25.512182Z
106 | 91
107 | nathan@playgroundblues.com
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 | 272
130 |
131 | __init__.py
132 | file
133 |
134 |
135 |
136 |
137 | 2009-03-04T15:11:19.000000Z
138 | d41d8cd98f00b204e9800998ecf8427e
139 | 2008-03-27T00:51:14.650785Z
140 | 2
141 | nathan@playgroundblues.com
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 | 0
164 |
165 | CHANGELOG.yml
166 | file
167 |
168 |
169 |
170 |
171 | 2009-03-04T15:11:19.000000Z
172 | e57bdbfe15d62b49836728e36fe1fc2a
173 | 2008-09-17T17:07:56.790973Z
174 | 70
175 | nathan@playgroundblues.com
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 |
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 | 3252
198 |
199 | sitemap.py
200 | file
201 |
202 |
203 |
204 |
205 | 2009-03-04T15:11:19.000000Z
206 | 698a38257b08aed5f449b0435b1c7a0c
207 | 2008-05-18T17:37:22.333574Z
208 | 39
209 | nathan@playgroundblues.com
210 |
211 |
212 |
213 |
214 |
215 |
216 |
217 |
218 |
219 |
220 |
221 |
222 |
223 |
224 |
225 |
226 |
227 |
228 |
229 |
230 |
231 | 278
232 |
233 | tests.py
234 | file
235 |
236 |
237 |
238 |
239 | 2009-03-04T15:11:19.000000Z
240 | 425a601d5f1a5df84eeb8b5d2eaac456
241 | 2008-11-12T02:37:11.794388Z
242 | 94
243 | nathan@playgroundblues.com
244 |
245 |
246 |
247 |
248 |
249 |
250 |
251 |
252 |
253 |
254 |
255 |
256 |
257 |
258 |
259 |
260 |
261 |
262 |
263 |
264 |
265 | 1962
266 |
267 | templatetags
268 | dir
269 |
270 | models.py
271 | file
272 |
273 |
274 |
275 |
276 | 2009-03-04T15:11:19.000000Z
277 | a7ec56cc39339200eb74fc590e58afec
278 | 2008-09-02T16:40:48.316008Z
279 | 63
280 | nathan@playgroundblues.com
281 |
282 |
283 |
284 |
285 |
286 |
287 |
288 |
289 |
290 |
291 |
292 |
293 |
294 |
295 |
296 |
297 |
298 |
299 |
300 |
301 |
302 | 2664
303 |
304 | README.txt
305 | file
306 |
307 |
308 |
309 |
310 | 2009-03-04T15:11:19.000000Z
311 | 7f4894c170b0c0cd5eeca63d69215ce8
312 | 2009-01-23T18:24:47.940314Z
313 | 100
314 | nathan@playgroundblues.com
315 |
316 |
317 |
318 |
319 |
320 |
321 |
322 |
323 |
324 |
325 |
326 |
327 |
328 |
329 |
330 |
331 |
332 |
333 |
334 |
335 |
336 | 873
337 |
338 | urls.py
339 | file
340 |
341 |
342 |
343 |
344 | 2009-03-04T15:11:19.000000Z
345 | b49132e6416b14894ad3b7d3b2d510f6
346 | 2008-09-17T17:07:56.790973Z
347 | 70
348 | nathan@playgroundblues.com
349 |
350 |
351 |
352 |
353 |
354 |
355 |
356 |
357 |
358 |
359 |
360 |
361 |
362 |
363 |
364 |
365 |
366 |
367 |
368 |
369 |
370 | 1139
371 |
372 | feeds.py
373 | file
374 |
375 |
376 |
377 |
378 | 2009-03-04T15:11:19.000000Z
379 | aa9b874c68a3551f4f5270af4053dcc2
380 | 2008-06-17T16:01:59.652184Z
381 | 50
382 | nathan@playgroundblues.com
383 |
384 |
385 |
386 |
387 |
388 |
389 |
390 |
391 |
392 |
393 |
394 |
395 |
396 |
397 |
398 |
399 |
400 |
401 |
402 |
403 |
404 | 1209
405 |
406 | templates
407 | dir
408 |
409 |
--------------------------------------------------------------------------------
/fixture/loadable/sqlobject_loadable.py:
--------------------------------------------------------------------------------
1 |
2 | """Components for loading and unloading data using `SQLObject`_.
3 |
4 | See :ref:`Using LoadableFixture` for examples.
5 |
6 | .. _SQLObject: http://www.sqlobject.org/
7 |
8 | """
9 |
10 | from fixture.loadable import DBLoadableFixture
11 |
12 | class SQLObjectMedium(DBLoadableFixture.StorageMediumAdapter):
13 | """
14 | Adapter for storing data using `SQLObject`_ classes
15 | """
16 | def clear(self, obj):
17 | """Delete this object from the DB"""
18 | obj.destroySelf()
19 |
20 | def save(self, row, column_vals):
21 | """Save this row to the DB"""
22 | from sqlobject.styles import getStyle
23 | so_style = getStyle(self.medium)
24 |
25 | if hasattr(row, 'connection'):
26 | raise ValueError(
27 | "cannot name a key 'connection' in row %s" % row)
28 | dbvals = dict([(so_style.dbColumnToPythonAttr(k), v)
29 | for k,v in column_vals])
30 | dbvals['connection'] = self.transaction
31 | return self.medium(**dbvals)
32 |
33 | def visit_loader(self, loader):
34 | """Visit the loader and store a reference to the transaction connection"""
35 | self.transaction = loader.transaction
36 |
37 | class SQLObjectFixture(DBLoadableFixture):
38 | """
39 | A fixture that knows how to load DataSet objects via `SQLObject`_ classes.
40 |
41 | >>> from fixture import SQLObjectFixture
42 |
43 | Keyword Arguments:
44 |
45 | ``style``
46 | A :class:`Style ` object to translate names with
47 |
48 | ``env``
49 | A dict or module that contains `SQLObject`_ classes. The :class:`Style ` object will
50 | look here when translating DataSet names into `SQLObject`_ class names.
51 | See :meth:`EnvLoadableFixture.attach_storage_medium ` for details on
52 | how ``env`` works.
53 |
54 | ``dsn``
55 | A dsn to create a connection with.
56 |
57 | ``dataclass``
58 | :class:`SuperSet ` class to represent loaded data with
59 |
60 | ``medium``
61 | A custom :class:`StorageMediumAdapter ` to instantiate when storing a DataSet.
62 |
63 | ``use_transaction``
64 | If this is true (default), data will be loaded or torn down inside a
65 | transaction. You may have to set this to false to avoid deadlocks.
66 | However, setting it to false may leave partially loaded data behind
67 | if you create an error with your DataSet.
68 |
69 | ``close_conn``
70 | True if the connection can be closed, helpful for releasing connections.
71 | If you are passing in a connection object this will be False by default.
72 |
73 | """
74 |
75 | def __init__(self, connection=None, use_transaction=True,
76 | close_conn=False, **kw ):
77 | DBLoadableFixture.__init__(self, **kw)
78 | self.connection = connection
79 | self.close_conn = close_conn
80 | self.use_transaction = use_transaction
81 |
82 | SQLObjectMedium = SQLObjectMedium
83 | Medium = SQLObjectMedium
84 |
85 | def create_transaction(self):
86 | """Return a new transaction for connection"""
87 | from sqlobject import connectionForURI
88 | if not self.connection:
89 | self.connection = connectionForURI(self.dsn)
90 | self.close_conn = True # because we made it
91 | if self.use_transaction:
92 | return self.connection.transaction()
93 | else:
94 | return self.connection
95 |
96 | def commit(self):
97 | """Commit transaction"""
98 | if self.use_transaction:
99 | DBLoadableFixture.commit(self)
100 |
101 | def then_finally(self, unloading=False):
102 | """Unconditionally close the transaction (if configured to do so) after loading data"""
103 | if unloading and self.close_conn:
104 | self.connection.close()
105 | self.connection = None # necessary for gc
106 |
107 | def rollback(self):
108 | """Rollback the transaction"""
109 | if self.use_transaction:
110 | DBLoadableFixture.rollback(self)
111 |
--------------------------------------------------------------------------------
/fixture/test/test_loadable/test_sqlobject_loadable.py:
--------------------------------------------------------------------------------
1 |
2 | import os, sys
3 | from nose.tools import eq_
4 | from nose.exc import SkipTest
5 | from fixture import SQLObjectFixture
6 | from fixture.test import env_supports
7 | from fixture import (
8 | SQLObjectFixture, NamedDataStyle, PaddedNameStyle, CamelAndUndersStyle,
9 | DataSet)
10 | from fixture.dataset import MergedSuperSet
11 | from fixture.test.test_loadable import *
12 | from fixture.examples.db.sqlobject_examples import *
13 | from fixture.test import conf
14 |
15 | def setup():
16 | if not env_supports.sqlobject: raise SkipTest
17 |
18 | class SQLObjectFixtureTest:
19 | fixture = SQLObjectFixture(
20 | style=( NamedDataStyle() + CamelAndUndersStyle()),
21 | dsn=conf.LITE_DSN, env=globals(),
22 | use_transaction=False,
23 | dataclass=MergedSuperSet )
24 |
25 | def setUp(self, dsn=conf.LITE_DSN):
26 | """should load the dataset"""
27 | from sqlobject import connectionForURI
28 | self.conn = connectionForURI(dsn)
29 | self.fixture.connection = self.conn
30 |
31 | from sqlobject import sqlhub
32 | sqlhub.processConnection = self.conn
33 |
34 | setup_db(self.conn)
35 |
36 | def tearDown(self):
37 | """should unload the dataset."""
38 | conn = self.conn
39 | teardown_db(conn)
40 | conn.close()
41 | conf.reset_heavy_dsn()
42 |
43 | class SQLObjectCategoryTest(SQLObjectFixtureTest):
44 | def assert_data_loaded(self, dataset):
45 | """assert that the dataset was loaded."""
46 | eq_(Category.get( dataset.gray_stuff.id).name,
47 | dataset.gray_stuff.name)
48 | eq_(Category.get( dataset.yellow_stuff.id).name,
49 | dataset.yellow_stuff.name)
50 |
51 | def assert_data_torndown(self):
52 | """assert that the dataset was torn down."""
53 | eq_(Category.select().count(), 0)
54 |
55 | class TestSQLObjectCategory(
56 | HavingCategoryData, SQLObjectCategoryTest, LoadableTest):
57 | pass
58 |
59 | class HavingCategoryDataStorable:
60 | """mixin that adds data to a LoadableTest."""
61 | def datasets(self):
62 | class WhateverIWantToCallIt(DataSet):
63 | class Meta:
64 | storable = Category
65 | class gray_stuff:
66 | id=1
67 | name='gray'
68 | class yellow_stuff:
69 | id=2
70 | name='yellow'
71 | return [WhateverIWantToCallIt]
72 |
73 | class TestSQLObjectCategoryStorable(
74 | HavingCategoryDataStorable, SQLObjectCategoryTest, LoadableTest):
75 | pass
76 | class TestSQLObjectCategoryAsDataType(
77 | HavingCategoryAsDataType, SQLObjectCategoryTest, LoadableTest):
78 | pass
79 |
80 | class TestSQLObjectPartialLoad(
81 | SQLObjectFixtureTest, LoaderPartialRecoveryTest):
82 | def assert_partial_load_aborted(self):
83 | raise SkipTest("I don't think sqlobject can support this feature")
84 |
85 | # t = self.conn.transaction()
86 | # eq_(Category.select(connection=t).count(), 0)
87 |
88 | class SQLObjectFixtureCascadeTest(SQLObjectFixtureTest):
89 | def assert_data_loaded(self, dataset):
90 | """assert that the dataset was loaded."""
91 | eq_(Offer.get(dataset.free_truck.id).name, dataset.free_truck.name)
92 |
93 | eq_(Product.get(
94 | dataset.truck.id).name,
95 | dataset.truck.name)
96 |
97 | eq_(Category.get(
98 | dataset.cars.id).name,
99 | dataset.cars.name)
100 | eq_(Category.get(
101 | dataset.free_stuff.id).name,
102 | dataset.free_stuff.name)
103 |
104 | def assert_data_torndown(self):
105 | """assert that the dataset was torn down."""
106 | eq_(Category.select().count(), 0)
107 | eq_(Offer.select().count(), 0)
108 | eq_(Product.select().count(), 0)
109 |
110 | class SQLObjectFixtureCascadeTestWithHeavyDB(SQLObjectFixtureCascadeTest):
111 | def setUp(self):
112 | if not conf.HEAVY_DSN:
113 | raise SkipTest
114 |
115 | SQLObjectFixtureCascadeTest.setUp(self, dsn=conf.HEAVY_DSN)
116 |
117 | class TestSQLObjectFixtureCascade(
118 | HavingOfferProductData, SQLObjectFixtureCascadeTest,
119 | LoadableTest):
120 | pass
121 | class TestSQLObjectFixtureCascadeWithHeavyDB(
122 | HavingOfferProductData, SQLObjectFixtureCascadeTestWithHeavyDB,
123 | LoadableTest):
124 | pass
125 | class TestSQLObjectFixtureCascadeAsType(
126 | HavingOfferProductAsDataType, SQLObjectFixtureCascadeTest,
127 | LoadableTest):
128 | pass
129 | class TestSQLObjectFixtureCascadeAsRef(
130 | HavingReferencedOfferProduct, SQLObjectFixtureCascadeTest,
131 | LoadableTest):
132 | pass
133 | class TestSQLObjectFixtureCascadeAsRefInherit(
134 | HavingRefInheritedOfferProduct, SQLObjectFixtureCascadeTest,
135 | LoadableTest):
136 | pass
137 | class TestSQLObjectFixtureCascadeAsRefInheritWithHeavyDB(
138 | HavingRefInheritedOfferProduct, SQLObjectFixtureCascadeTestWithHeavyDB,
139 | LoadableTest):
140 | pass
141 |
--------------------------------------------------------------------------------
Comments
45 | {% for comment in comment_list %} 46 | {% if comment.is_public %} 47 |49 | {{ forloop.counter }} 50 | {% if comment.user_url %}{{ comment.user_name }}{% else %}{{ comment.user_name }}{% endif %} says... 51 |
52 | {{ comment.comment|urlizetrunc:"60"|markdown:"safe" }} 53 |Posted at {{ comment.submit_date|date:"P" }} on {{ comment.submit_date|date:"F j, Y" }}
54 |