[#708] Fix tests

ckan/lib/create_test_data.py

@@ -464,7 +464,7 @@ def create(cls, auth_profile="", package_type=None):
         model.Session.add_all([
             model.User(name=u'tester', apikey=u'tester', password=u'tester'),
             model.User(name=u'joeadmin', password=u'joeadmin'),
-            model.User(name=u'annafan', about=u'I love reading Annakarenina. My site: <a href="http://anna.com">anna.com</a>', password=u'annafan'),
+            model.User(name=u'annafan', about=u'I love reading Annakarenina. My site: http://anna.com', password=u'annafan'),
             model.User(name=u'russianfan', password=u'russianfan'),
             sysadmin,
             ])

ckan/tests/functional/test_package.py

@@ -309,10 +309,6 @@ def test_read(self):
         assert anna.version in res
         assert anna.url in res
         assert 'Some test notes' in res
-        self.check_named_element(res, 'a',
-                                 'http://ckan.net/',
-                                 'target="_blank"',
-                                 'rel="nofollow"')
         assert '<strong>Some bolded text.</strong>' in res
         self.check_tag_and_data(res, 'left arrow', '&lt;')
         self.check_tag_and_data(res, 'umlaut', u'\xfc')
@@ -350,17 +346,17 @@ def test_read_internal_links(self):
         pkg_name = u'link-test',
         CreateTestData.create_arbitrary([
             {'name':pkg_name,
-             'notes':'Decoy link here: decoy:decoy, real links here: package:pkg-1, ' \
+             'notes':'Decoy link here: decoy:decoy, real links here: dataset:pkg-1, ' \
                    'tag:tag_1 group:test-group-1 and a multi-word tag: tag:"multi word with punctuation."',
              }
             ])
         offset = url_for(controller='package', action='read', id=pkg_name)
         res = self.app.get(offset)
         def check_link(res, controller, id):
             id_in_uri = id.strip('"').replace(' ', '%20') # remove quotes and percent-encode spaces
-            self.check_tag_and_data(res, 'a ', '/%s/%s' % (controller, id_in_uri),
-                                    '%s:%s' % (controller, id))
-        check_link(res, 'package', 'pkg-1')
+            self.check_tag_and_data(res, 'a ', '%s/%s' % (controller, id_in_uri),
+                                    '%s:%s' % (controller, id.replace('"', '&#34;')))
+        check_link(res, 'dataset', 'pkg-1')
         check_link(res, 'tag', 'tag_1')
         check_link(res, 'tag', '"multi word with punctuation."')
         check_link(res, 'group', 'test-group-1')
@@ -1557,10 +1553,10 @@ def teardown(self):
 
     def test_markdown_html_whitelist(self):
         self.body = str(self.res)
-        self.assert_fragment('<table width="100%" border="1">')
-        self.assert_fragment('<td rowspan="2"><b>Description</b></td>')
-        self.assert_fragment('<a href="http://www.nber.org/patents/subcategories.txt" target="_blank" rel="nofollow">subcategory.txt</a>')
-        self.assert_fragment('<td colspan="2"><center>--</center></td>')
+        self.fail_if_fragment('<table width="100%" border="1">')
+        self.fail_if_fragment('<td rowspan="2"><b>Description</b></td>')
+        self.fail_if_fragment('<a href="http://www.nber.org/patents/subcategories.txt" target="_blank" rel="nofollow">subcategory.txt</a>')
+        self.fail_if_fragment('<td colspan="2"><center>--</center></td>')
         self.fail_if_fragment('<script>')
 
     def assert_fragment(self, fragment):

ckan/tests/functional/test_user.py

@@ -89,50 +89,6 @@ def test_user_read_logged_in(self):
         assert 'checkpoint:is-myself' in main_res, main_res
         assert 'Edit Profile' in main_res, main_res
 
-    def test_user_read_about_unfinished(self):
-        user = model.User.by_name(u'unfinisher')
-        offset = '/user/%s' % user.id
-        res = self.app.get(offset, status=200)
-        main_res = self.main_div(res)
-        assert 'unfinisher' in res, res
-        assert '<a href="http://unfinished.tag' in main_res, main_res
-
-    def test_user_read_about_unclosed(self):
-        user = model.User.by_name(u'uncloser')
-        offset = '/user/%s' % user.id
-        res = self.app.get(offset, status=200)
-        main_res = self.main_div(res)
-        assert 'unclosed' in res, res
-        # tag gets closed by genshi
-        assert '<a href="http://unclosed.tag" target="_blank" rel="nofollow">\n</a>' in main_res, main_res
-
-    def test_user_read_about_spam(self):
-        user = model.User.by_name(u'spammer')
-        offset = '/user/%s' % user.id
-        res = self.app.get(offset, status=200)
-        main_res = self.main_div(res)
-        assert 'spammer' in res, res
-        self.check_named_element(res, 'a',
-                                 'href="http://mysite"',
-                                 'target="_blank"',
-                                 'rel="nofollow"')
-
-        self.check_named_element(res, 'a',
-                                 'href="TAG MALFORMED"',
-                                 'target="_blank"',
-                                 'rel="nofollow"')
-
-    def test_user_read_about_spam2(self):
-        user = model.User.by_name(u'spammer2')
-        offset = '/user/%s' % user.id
-        res = self.app.get(offset, status=200)
-        main_res = self.main_div(res)
-        assert 'spammer2' in res, res
-        assert 'spamsite2' not in res, res
-        # some computers have the Genshi exception and some insert "malformed"
-        # but either are fine
-        assert 'Error: Could not parse About text' in res or\
-               'malformed' in res, res
 
     def test_user_login_page(self):
         offset = url_for(controller='user', action='login', id=None)

ckan/tests/lib/test_dictization.py

@@ -928,7 +928,7 @@ def test_16_group_dictized(self):
                                'title': u'simple',
                                'type': u'organization',
                                'approval_status': u'approved'}],
-                    'users': [{'about': u'I love reading Annakarenina. My site: <a href="http://anna.com">anna.com</a>',
+                    'users': [{'about': u'I love reading Annakarenina. My site: http://anna.com',
                               'display_name': u'annafan',
                               'capacity' : 'public',
                               'sysadmin': False,

ckan/tests/logic/test_action.py

@@ -292,7 +292,7 @@ def test_04_user_list(self):
         assert res_obj['success'] == True
         assert len(res_obj['result']) == 7
         assert res_obj['result'][0]['name'] == 'annafan'
-        assert res_obj['result'][0]['about'] == 'I love reading Annakarenina. My site: <a href="http://anna.com">anna.com</a>'
+        assert res_obj['result'][0]['about'] == 'I love reading Annakarenina. My site: http://anna.com'
         assert not 'apikey' in res_obj['result'][0]
 
     def test_05_user_show(self):
@@ -304,7 +304,7 @@ def test_05_user_show(self):
         assert res_obj['success'] == True
         result = res_obj['result']
         assert result['name'] == 'annafan'
-        assert result['about'] == 'I love reading Annakarenina. My site: <a href="http://anna.com">anna.com</a>'
+        assert result['about'] == 'I love reading Annakarenina. My site: http://anna.com'
         assert 'activity' in result
         assert 'created' in result
         assert 'display_name' in result

ckan/tests/misc/test_format_text.py

@@ -1,4 +1,4 @@
-from ckan.misc import MarkdownFormat
+import ckan.lib.helpers as h
 
 class TestFormatText:
 
@@ -14,92 +14,79 @@ def test_markdown(self):
 </p>
 <p><em>Some italicized text.</em>
 </p>'''
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert out == exp
 
     def test_markdown_blank(self):
         instr = None
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert out == ''
 
     def test_evil_markdown(self):
         instr = 'Evil <script src="http://evilserver.net/evil.js";>'
-        exp = '''<p>Evil [HTML_REMOVED]
-</p>'''
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        exp = '''<p>Evil \n</p>'''
+        out = h.render_markdown(instr)
         assert out == exp, out
-        
+
     def test_internal_link(self):
-        instr = 'package:test-_pkg'
-        exp = '<a href="/package/test-_pkg">package:test-_pkg</a>'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        instr = 'dataset:test-_pkg'
+        exp = '<p><a href="/dataset/test-_pkg">dataset:test-_pkg</a>\n</p>'
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_internal_tag_link(self):
         """Asserts links like 'tag:test-tag' work"""
         instr = 'tag:test-tag foobar'
         exp = '<a href="/tag/test-tag">tag:test-tag</a> foobar'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_internal_tag_linked_with_quotes(self):
         """Asserts links like 'tag:"test-tag"' work"""
         instr = 'tag:"test-tag" foobar'
-        exp = '<a href="/tag/test-tag">tag:"test-tag"</a> foobar'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        exp = '<p><a href="/tag/test-tag">tag:&#34;test-tag&#34;</a> foobar\n</p>'
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_internal_tag_linked_with_quotes_and_space(self):
         """Asserts links like 'tag:"test tag"' work"""
         instr = 'tag:"test tag" foobar'
-        exp = '<a href="/tag/test%20tag">tag:"test tag"</a> foobar'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        exp = '<p><a href="/tag/test%20tag">tag:&#34;test tag&#34;</a> foobar\n</p>'
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_internal_tag_with_no_opening_quote_only_matches_single_word(self):
         """Asserts that without an opening quote only one word is matched"""
         instr = 'tag:test tag" foobar' # should match 'tag:test'
         exp = '<a href="/tag/test">tag:test</a> tag" foobar'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_internal_tag_with_no_opening_quote_wont_match_the_closing_quote(self):
         """Asserts that 'tag:test" tag' is matched, but to 'tag:test'"""
         instr = 'tag:test" foobar' # should match 'tag:test'
         exp = '<a href="/tag/test">tag:test</a>" foobar'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_internal_tag_with_no_closing_quote_does_not_match(self):
         """Asserts that without an opening quote only one word is matched"""
         instr = 'tag:"test tag foobar'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert "<a href" not in out
 
     def test_tag_names_match_simple_punctuation(self):
         """Asserts punctuation and capital letters are matched in the tag name"""
         instr = 'tag:"Test- _." foobar'
-        exp = '<a href="/tag/Test-%20_.">tag:"Test- _."</a> foobar'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        exp = '<p><a href="/tag/Test-%20_.">tag:&#34;Test- _.&#34;</a> foobar\n</p>'
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_tag_names_do_not_match_commas(self):
         """Asserts commas don't get matched as part of a tag name"""
         instr = 'tag:Test,tag foobar'
         exp = '<a href="/tag/Test">tag:Test</a>,tag foobar'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_tag_names_dont_match_non_space_whitespace(self):
@@ -108,59 +95,38 @@ def test_tag_names_dont_match_non_space_whitespace(self):
         for ch in whitespace_characters:
             instr = 'tag:Bad' + ch + 'space'
             exp = '<a href="/tag/Bad">tag:Bad</a>'
-            format = MarkdownFormat()
-            out = format.to_html(instr)
+            out = h.render_markdown(instr)
             assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
-    
+
     def test_tag_names_with_unicode_alphanumeric(self):
         """Asserts that unicode alphanumeric characters are captured"""
         instr = u'tag:"Japanese katakana \u30a1" blah'
-        exp = u'<a href="/tag/Japanese%20katakana%20%E3%82%A1">tag:"Japanese katakana \u30a1"</a>'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        exp = u'<p><a href="/tag/Japanese%20katakana%20%E3%82%A1">tag:&#34;Japanese katakana \u30a1&#34;</a> blah\n</p>'
+        out = h.render_markdown(instr)
         assert exp in out, u'\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_normal_link(self):
-        instr = '<http://somelink/>'
+        instr = 'http://somelink/'
         exp = '<a href="http://somelink/" target="_blank" rel="nofollow">http://somelink/</a>'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_auto_link(self):
         instr = 'http://somelink.com'
         exp = '<a href="http://somelink.com" target="_blank" rel="nofollow">http://somelink.com</a>'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_auto_link_after_whitespace(self):
         instr = 'go to http://somelink.com'
         exp = 'go to <a href="http://somelink.com" target="_blank" rel="nofollow">http://somelink.com</a>'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_malformed_link_1(self):
         instr = u'<a href=\u201dsomelink\u201d>somelink</a>'
-        exp = '<a href="TAG MALFORMED" target="_blank" rel="nofollow">somelink</a>'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
-        assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
-
-    def test_malformed_link_2(self):
-        instr = u'<a href="http://url.com> url >'
-        exp = '<a href="TAG MALFORMED" target="_blank" rel="nofollow"> url &gt;'
-        format = MarkdownFormat()
-        out = format.to_html(instr)
-        assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
-
-    def test_malformed_link_3(self):
-        instr = u'<a href="http://url.com"> url'
-        exp = '<a href="http://url.com" target="_blank" rel="nofollow"> url'
-        # NB when this is put into Genshi, it will close the tag for you.
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        exp = '<p>somelink\n</p>'
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)
 
     def test_multiline_links(self):
@@ -170,9 +136,9 @@ def test_multiline_links(self):
   [google]: http://google.com/        "Google"
   [yahoo]:  http://search.yahoo.com/  "Yahoo Search"
   [msn]:    http://search.msn.com/    "MSN Search"'''
-        exp = '''I get 10 times more traffic from <a href="http://google.com/" title="Google">Google</a> than from
-   <a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.'''
+        exp = '''<p>I get 10 times more traffic from <a href="http://google.com/" title="Google">Google</a> than from
+   <a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.
+</p>'''
         # NB when this is put into Genshi, it will close the tag for you.
-        format = MarkdownFormat()
-        out = format.to_html(instr)
+        out = h.render_markdown(instr)
         assert exp in out, '\nGot: %s\nWanted: %s' % (out, exp)

ckan/tests/models/test_package.py

@@ -109,7 +109,7 @@ def test_as_dict(self):
         assert out['metadata_modified'] == pkg.metadata_modified.isoformat()
         assert out['metadata_created'] == pkg.metadata_created.isoformat()
         assert_equal(out['notes'], pkg.notes)
-        assert_equal(out['notes_rendered'], '<p>A <b>great</b> package [HTML_REMOVED] like <a href="/package/pollution_stats">package:pollution_stats</a>\n</p>')
+        assert_equal(out['notes_rendered'], '<p>A great package  like <a href="/dataset/pollution_stats">package:pollution_stats</a>\n</p>')
 
     def test_metadata_created_and_modified(self):
         # create a new package