示例#1
0
def localtyperegistry(request):
    registry = TypeRegistry()
    type_registry.set(registry)
    if hasattr(request.cls, 'type') and request.cls.type:
        registry.register(request.cls.type)
    if hasattr(request.cls, 'other') and request.cls.other:
        registry.register(request.cls.other)
    for type in getattr(request.cls, 'types', []):
        registry.register(type)
    for type in getattr(request.cls, 'extra_types', []):
        registry.register(type)
示例#2
0
class BaseLocalRegistry(object):
    """
        Make sure registries are local to the test
    """
    type = None
    types = ()

    def setup(self):
        """ override the global registry """
        self.registry = TypeRegistry()
        type_registry.set(self.registry)
        if self.type:
            self.registry.register(self.type)
        for type in self.types:
            self.registry.register(type)
示例#3
0
 def setup(self):
     """ override the global registry """
     self.registry = TypeRegistry()
     type_registry.set(self.registry)
     if self.type:
         self.registry.register(self.type)
     for type in self.types:
         self.registry.register(type)
示例#4
0
    def setup(self):
        site._registry = {}

        self.registry = TypeRegistry()
        type_registry.set(self.registry)
        self.registry.register(self.type)
        self.registry.register(self.other)
        self.sqs = SearchQuerySet()
示例#5
0
class TestImageCreateUpdate(object):
    def setup(self):
        self.registry = TypeRegistry()
        self.old_registry = type_registry.wrapped
        type_registry.set(self.registry)
        self.registry.register(TestImageType)

    def teardown(self):
        type_registry.set(self.old_registry)
        
    def test_create_image(self, client):
        request = superuser_request("/create", method="POST",
                                      title="Test",
                                      slug="test",
                                      language="en",
                                      storage=filedata)
        root = Node.root()
        handler = MainHandler(request=request, post=True,
                              instance=dict(instance=root))
        pytest.raises(Redirect, handler.create, type=TestImage.get_name())

        node = Node.get("/test")
        filedata.seek(0)
        assert node.content().storage.read() == filedata.read()

    def test_update_image(self, client):
        root = Node.root()
        node = root.add("test")
        TestImage(node=node, title="image", storage=filedata).save()
        request = superuser_request("/test/edit", method="POST",
                                      title="Test",
                                      slug="",
                                      language="en",
                                      storage=filedata2)
        handler = MainHandler(request=request, post=True, instance=node)
        pytest.raises(Redirect, handler.update)

        node = Node.get("/test")
        filedata2.seek(0)
        assert node.content().storage.read() == filedata2.read()
示例#6
0
class BaseTestSearch(object):
    type = None
    other = Type1Type

    def construct_type(self, **kw):
        """ allow construction to be overridden for more complex types """
        return self.type.model(**kw).save()

    def construct_other(self, **kw):
        """ 'other' is a type unequal to 'type', to test against """
        return self.other.model(**kw).save()

    def setup(self):
        self.registry = TypeRegistry()
        type_registry.set(self.registry)
        self.registry.register(self.type)
        self.registry.register(self.other)
        self.sqs = SearchQuerySet()

    @pytest.mark.xfail
    def test_trivial_match(self, client):
        t = self.construct_type(title="hi")

        res = self.sqs.auto_query("hi")
        assert res[0].object == t

    def test_trivial_nonmatch(self, client):
        t = self.construct_type(title="hi")

        res = self.sqs.auto_query("frop")
        assert not res

    ## randomly failing with tox
    @pytest.mark.xfail
    def test_find_metatype(self, client):
        """ should become a spoke-related match """
        t = self.construct_type(title="hi")
        o = self.construct_other(title="hi")

        res = self.sqs.filter(content="hi", type=self.type.model.classname)
        assert len(res) == 1   ## not 2!
        assert res[0].object == t

    ## randomly failing with tox
    def disabled_test_find_metaother(self, client):
        """ should become a spoke-related match """
        t = self.construct_type(title="hi")
        o = self.construct_other(title="hi")

        res = self.sqs.filter(content="hi", type=self.other.model.classname)
        assert len(res) == 1   ## not 2!
        assert res[0].object == o

    @pytest.mark.xfail
    def test_workflow_state(self, client):
        t1 = self.construct_type(title="hi", state="private")
        t2 = self.construct_type(title="hi", state="published")

        res = self.sqs.filter(state="published")
        assert len(res) == 1
        assert res[0].object == t2

    def xtest_path(self, client):
        """ One of the few node attributes to be indexed """
        ## Test won't work on simple backend
        root = Node.root()
        c1 = root.add("child1")
        c2 = c1.add("child2")
        t1 = self.construct_type(title="hi", node=c2)
        t2 = self.construct_type(title="hi", node=c1)

        res = self.sqs.filter(content="hi", path="/child1/child2")
        assert len(res) == 1
        assert res[0].object == t1

    def xtest_slug(self, client):
        ## Test won't work on simple backend
        root = Node.root()
        c1 = root.add("child1")
        c2 = c1.add("child2")
        t1 = self.construct_type(title="hi", node=c2)
        t2 = self.construct_type(title="hi", node=c1)

        res = self.sqs.filter(content="hi", slug="child2")
        assert len(res) == 1
        assert res[0].object == t1

    @pytest.mark.xfail
    def test_searchable(self, client):
        t1 = self.construct_type(title="hello world")
        t2 = self.construct_type(description="hello world")

        res = self.sqs.filter(content="hello")
        assert len(res) == 2
        assert res[0].object in (t1, t2)
        assert res[1].object in (t1, t2)

    @pytest.mark.xfail
    def test_indexfactory(self, client):
        root = Node.root()
        c1 = root.add("child1")
        c2 = c1.add("child2")
        t1 = self.construct_type(title="hi", state="private", node=c2)
        idf = indexfactory(self.type)
        idx = idf(self.type.model)
        data = idx.prepare(t1)

        assert data['title'] == 'hi'
        assert data['state'] == 'private'
        assert data['path'] == c2.get_absolute_url()
示例#7
0
 def setup(self):
     """ local registry, install it globally """
     self.registry = TypeRegistry()
     type_registry.set(self.registry)
示例#8
0
class TestImplicitAddition(object):
    """
        Test implicit/explicit addition of children
    """
    def setup(self):
        """ local registry, install it globally """
        self.registry = TypeRegistry()
        type_registry.set(self.registry)

    def test_explicit(self, client):
        """ Simple case, no restrictions """
        class T1(ModellessSpoke):
            implicit_add = True  ## default

        class T2(ModellessSpoke):
            children = None

        self.registry.register(T1)
        self.registry.register(T2)

        assert T1 in T2.addable_children()

    def test_non_implicit(self, client):
        """ T1 cannot be added explicitly """
        class T1(ModellessSpoke):
            implicit_add = False

        class T2(ModellessSpoke):
            children = None

        self.registry.register(T1)
        self.registry.register(T2)

        assert T1 not in T2.addable_children()

    def test_non_implicit_but_children(self, client):
        """ T1 cannot be added explicitly but is in T2's children """
        class T1(ModellessSpoke):
            implicit_add = False

        class T2(ModellessSpoke):
            children = (T1, )

        self.registry.register(T1)
        self.registry.register(T2)

        assert T1 in T2.addable_children()

    def test_non_implicit_but_exp_children(self, client):
        """ T1 cannot be added explicitly but is in T2's explicit
            children """
        class T1(ModellessSpoke):
            implicit_add = False

        class T2(ModellessSpoke):
            explicit_children = (T1, )

        self.registry.register(T1)
        self.registry.register(T2)

        assert T1 in T2.addable_children()
示例#9
0
 def setup(self):
     self.registry = TypeRegistry()
     self.old_registry = type_registry.wrapped
     type_registry.set(self.registry)
     self.registry.register(TestImageType)