85     def test_rqltable_nocontent(self):

    86         context = self.context()

    87         out = rest_publish(context, """.. rql-table::""")

    88         self.assertIn("System Message: ERROR", out)

    89         self.assertIn("Content block expected for the "rql-table" "

    90                       "directive; none found" , out)

    91 

    92     def test_rqltable_norset(self):

    93         context = self.context()

    94         rql = "Any X WHERE X is CWUser, X firstname 'franky'"

    95         out = rest_publish(

    96             context, """\

    97 .. rql-table::

    98 

    99             %(rql)s""" % {'rql': rql})

   100         self.assertIn("System Message: WARNING", out)

   101         self.assertIn("empty result set", out)

   102 

   103     def test_rqltable_nooptions(self):

   104         rql = """Any S,F,L WHERE X is CWUser, X surname S,

   105                                  X firstname F, X login L"""

   106         out = rest_publish(

   107             self.context(), """\

   108 .. rql-table::

   109 

   110    %(rql)s

   111             """ % {'rql': rql})

   112         req = self.request()

   113         view = self.vreg['views'].select('table', req, rset=req.execute(rql))

   114         self.assertEqual(view.render(w=None)[49:], out[49:])

   115 

   116     def test_rqltable_vid(self):

   117         rql = """Any S,F,L WHERE X is CWUser, X surname S,

   118                                  X firstname F, X login L"""

   119         vid = 'mytable'

   120         out = rest_publish(

   121             self.context(), """\

   122 .. rql-table::

   123    :vid: %(vid)s

   124 

   125    %(rql)s

   126             """ % {'rql': rql, 'vid': vid})

   127         req = self.request()

   128         view = self.vreg['views'].select(vid, req, rset=req.execute(rql))

   129         self.assertEqual(view.render(w=None)[49:], out[49:])

   130         self.assertIn(vid, out[:49])

   131 

   132     def test_rqltable_badvid(self):

   133         rql = """Any S,F,L WHERE X is CWUser, X surname S,

   134                                  X firstname F, X login L"""

   135         vid = 'mytabel'

   136         out = rest_publish(

   137             self.context(), """\

   138 .. rql-table::

   139    :vid: %(vid)s

   140 

   141    %(rql)s

   142             """ % {'rql': rql, 'vid': vid})

   143         self.assertIn("fail to select '%s' view" % vid, out)

   144 

   145     def test_rqltable_headers(self):

   146         rql = """Any S,F,L WHERE X is CWUser, X surname S,

   147                                  X firstname F, X login L"""

   148         headers = ["nom", "prenom", "identifiant"]

   149         out = rest_publish(

   150             self.context(), """\

   151 .. rql-table::

   152    :headers: %(headers)s

   153 

   154    %(rql)s

   155             """ % {'rql': rql, 'headers': ', '.join(headers)})

   156         req = self.request()

   157         view = self.vreg['views'].select('table', req, rset=req.execute(rql))

   158         view.headers = headers

   159         self.assertEqual(view.render(w=None)[49:], out[49:])

   160 

   161     def test_rqltable_headers_missing(self):

   162         rql = """Any S,F,L WHERE X is CWUser, X surname S,

   163                                  X firstname F, X login L"""

   164         headers = ["nom", "", "identifiant"]

   165         out = rest_publish(

   166             self.context(), """\

   167 .. rql-table::

   168    :headers: %(headers)s

   169 

   170    %(rql)s

   171             """ % {'rql': rql, 'headers': ', '.join(headers)})

   172         req = self.request()

   173         view = self.vreg['views'].select('table', req, rset=req.execute(rql))

   174         view.headers = [headers[0], None, headers[2]]

   175         self.assertEqual(view.render(w=None)[49:], out[49:])

   176 

   177     def test_rqltable_headers_missing_edges(self):

   178         rql = """Any S,F,L WHERE X is CWUser, X surname S,

   179                                  X firstname F, X login L"""

   180         headers = [" ", "prenom", ""]

   181         out = rest_publish(

   182             self.context(), """\

   183 .. rql-table::

   184    :headers: %(headers)s

   185 

   186    %(rql)s

   187             """ % {'rql': rql, 'headers': ', '.join(headers)})

   188         req = self.request()

   189         view = self.vreg['views'].select('table', req, rset=req.execute(rql))

   190         view.headers = [None, headers[1], None]

   191         self.assertEqual(view.render(w=None)[49:], out[49:])

   192 

   193     def test_rqltable_colvids(self):

   194         rql = """Any X,S,F,L WHERE X is CWUser, X surname S,

   195                                    X firstname F, X login L"""

   196         colvids = {0: "oneline"}

   197         out = rest_publish(

   198             self.context(), """\

   199 .. rql-table::

   200    :colvids: %(colvids)s

   201 

   202    %(rql)s

   203             """ % {'rql': rql,

   204                    'colvids': ', '.join(["%d=%s" % (k, v)

   205                                          for k, v in colvids.iteritems()])

   206                   })

   207         req = self.request()

   208         view = self.vreg['views'].select('table', req, rset=req.execute(rql))

   209         view.cellvids = colvids

   210         self.assertEqual(view.render(w=None)[49:], out[49:])

   211 

   212