← Back to branch summary

~developer-ubuntu-com-dev/developer-ubuntu-com/get-gadget-snaps

« back to all changes in this revision

Viewing changes to md_importer/tests/test_branch_import.py

Fix #1568861

Show diffs side-by-side

added added

removed removed

Lines of Context:
md_importer/tests/test_branch_import.py
10
10
    TEMPLATE_CHOICES,
11
11
)
12
12
from md_importer.importer.article import Article
13
 
from md_importer.importer.publish import find_text_plugin
 
13
from md_importer.importer.publish import get_text_plugin
14
14
from md_importer.importer.tools import remove_trailing_slash
15
15
 
16
 
from .utils import TestLocalBranchImport
 
16
from .utils import (
 
17
    PublishedPages,
 
18
    TestLocalBranchImport,
 
19
)
17
20
 
18
21
 
19
22
class TestImportDirectivesBuildHierarchyImport(TestLocalBranchImport):
50
53
        # Make sure we got the parents right
51
54
        for article in self.repo.imported_articles:
52
55
            parent_url = remove_trailing_slash(
53
 
                article.page.parent.get_absolute_url())
54
 
            url = remove_trailing_slash(article.page.get_absolute_url())
 
56
                article.article_page.page.parent.get_absolute_url())
 
57
            url = remove_trailing_slash(
 
58
                article.article_page.page.get_absolute_url())
55
59
            self.assertEqual(parent_url, os.path.split(url)[0])
56
60
            self.assertIsInstance(article, Article)
57
61
 
62
66
        self.repo.add_directive('docs', '')
63
67
        self.assertEqual(len(self.repo.directives), 1)
64
68
        self.assertTrue(self.repo.execute_import_directives())
65
 
        self.assertGreater(len(self.repo.imported_articles), 3)
 
69
        self.assertGreater(len(self.repo.imported_articles), 10)
66
70
        self.assertTrue(self.repo.publish())
67
 
        pages = Page.objects.all()
68
 
        self.assertGreater(pages.count(), len(self.repo.imported_articles))
 
71
        published_pages = PublishedPages()
 
72
        self.assertTrue(published_pages.has_size(
 
73
            len(self.repo.imported_articles)+1))  # + landing/index page
69
74
        for article in self.repo.imported_articles:
70
75
            self.assertIsInstance(article, Article)
71
76
 
78
83
        self.repo.add_directive('HACKING.md', 'hacking')
79
84
        self.assertEqual(len(self.repo.directives), 3)
80
85
        self.assertTrue(self.repo.execute_import_directives())
81
 
        self.assertGreater(len(self.repo.imported_articles), 5)
 
86
        self.assertGreater(len(self.repo.imported_articles), 10)
82
87
        self.assertTrue(self.repo.publish())
83
 
        pages = Page.objects.filter(publisher_is_draft=False)
84
 
        self.assertEqual(pages.count(), len(self.repo.imported_articles))
85
 
        self.assertGreater(pages.count(), 5)
86
 
        self.assertIn(u'/en/', [p.get_absolute_url() for p in pages])
87
 
        self.assertIn(u'/en/hacking/', [p.get_absolute_url() for p in pages])
 
88
        published_pages = PublishedPages()
 
89
        self.assertTrue(published_pages.has_size(
 
90
            len(self.repo.imported_articles)))
 
91
        self.assertTrue(published_pages.has_at_least_size(10))
 
92
        self.assertTrue(published_pages.contains_url(u'/en/'))
 
93
        self.assertTrue(published_pages.contains_url('/en/hacking/'))
88
94
 
89
95
 
90
96
class TestArticletreeOneFileImport(TestLocalBranchImport):
96
102
        self.assertTrue(self.repo.execute_import_directives())
97
103
        self.assertEqual(len(self.repo.imported_articles), 1)
98
104
        self.assertTrue(self.repo.publish())
99
 
        self.assertEqual(
 
105
        published_pages = PublishedPages()
 
106
        self.assertTrue(published_pages.has_size(
100
107
            1+1,  # readme + root
101
 
            Page.objects.filter(publisher_is_draft=False).count())
 
108
        ))
102
109
        self.assertEqual(self.repo.pages[0].parent, self.root)
103
110
 
104
111
 
109
116
        self.repo.add_directive('docs', '')
110
117
        self.assertTrue(self.repo.execute_import_directives())
111
118
        self.assertTrue(self.repo.publish())
112
 
        for page in Page.objects.filter(publisher_is_draft=False):
 
119
        published_pages = PublishedPages()
 
120
        for page in published_pages.pages:
113
121
            if page.parent is not None:
114
122
                self.assertEqual(page.parent_id, self.root.id)
115
123
 
120
128
        self.repo.add_directive('docs', '')
121
129
        self.assertEqual(len(self.repo.directives), 1)
122
130
        self.assertTrue(self.repo.execute_import_directives())
123
 
        self.assertGreater(len(self.repo.imported_articles), 3)
 
131
        self.assertGreater(len(self.repo.imported_articles), 10)
124
132
        self.assertTrue(self.repo.publish())
125
 
        pages = Page.objects.all()
126
 
        self.assertGreater(pages.count(), len(self.repo.imported_articles))
 
133
        published_pages = PublishedPages()
 
134
        self.assertTrue(published_pages.has_size(
 
135
            len(self.repo.imported_articles)+1))  # + landing/index page
127
136
        for article in self.repo.imported_articles:
128
137
            self.assertIsInstance(article, Article)
129
138
            self.assertNotIn('<body>', article.html)
136
145
        self.repo.add_directive('docs', '')
137
146
        self.assertEqual(len(self.repo.directives), 1)
138
147
        self.assertTrue(self.repo.execute_import_directives())
139
 
        self.assertGreater(len(self.repo.imported_articles), 3)
 
148
        self.assertGreater(len(self.repo.imported_articles), 10)
140
149
        self.assertTrue(self.repo.publish())
141
 
        pages = Page.objects.all()
142
 
        self.assertGreater(pages.count(), len(self.repo.imported_articles))
 
150
        published_pages = PublishedPages()
 
151
        self.assertTrue(published_pages.has_size(
 
152
            len(self.repo.imported_articles)+1))  # + landing/index page
143
153
        for article in self.repo.imported_articles:
144
154
            self.assertIsInstance(article, Article)
145
155
            self.assertNotIn('/None/', article.full_url)
146
 
        for page in pages:
 
156
        for page in published_pages.pages:
147
157
            self.assertIsNotNone(page.get_slug())
148
158
 
149
159
 
157
167
        for article in self.repo.imported_articles:
158
168
            self.assertTrue(article.advertise)
159
169
        self.assertTrue(self.repo.publish())
160
 
        for page in Page.objects.filter(publisher_is_draft=False):
 
170
        published_pages = PublishedPages()
 
171
        for page in published_pages.pages:
161
172
            if page.parent is not None:
162
173
                parent = page.parent.get_public_object()
163
174
                self.assertEqual(parent.id, self.root.id)
174
185
        for article in self.repo.imported_articles:
175
186
            self.assertFalse(article.advertise)
176
187
        self.assertTrue(self.repo.publish())
177
 
        for page in Page.objects.filter(publisher_is_draft=False):
 
188
        published_pages = PublishedPages()
 
189
        for page in published_pages.pages:
178
190
            if page.parent is not None:
179
191
                self.assertEqual(page.parent_id, self.root.id)
180
192
                self.assertFalse(page.in_navigation)
188
200
        self.repo.add_directive('docs', '')
189
201
        self.assertTrue(self.repo.execute_import_directives())
190
202
        self.assertTrue(self.repo.publish())
191
 
        self.assertEqual(
192
 
            Page.objects.filter(publisher_is_draft=False).count(),
193
 
            len(self.repo.imported_articles)+1)  # articles + root
 
203
        published_pages = PublishedPages()
 
204
        self.assertTrue(published_pages.has_size(
 
205
            len(self.repo.imported_articles)+1))  # articles + root
194
206
        # Run second import
195
207
        shutil.rmtree(self.tempdir)
196
208
        self.create_repo('data/snapcraft-test')
199
211
        self.assertEqual(len(self.repo.imported_articles), 0)
200
212
        self.assertTrue(self.repo.execute_import_directives())
201
213
        self.assertTrue(self.repo.publish())
202
 
        self.assertEqual(
203
 
            Page.objects.filter(publisher_is_draft=False).count(),
204
 
            len(self.repo.imported_articles)+1)  # articles + root
 
214
        published_pages = PublishedPages()
 
215
        self.assertTrue(published_pages.has_size(
 
216
            len(self.repo.imported_articles)+1))  # articles + root
205
217
 
206
218
 
207
219
class TestTwiceImportNoHtmlChange(TestLocalBranchImport):
212
224
        self.repo.add_directive('docs', '')
213
225
        self.assertTrue(self.repo.execute_import_directives())
214
226
        self.assertTrue(self.repo.publish())
215
 
        self.assertEqual(
216
 
            Page.objects.filter(publisher_is_draft=False).count(),
217
 
            len(self.repo.imported_articles)+1)  # articles + root
 
227
        published_pages = PublishedPages()
 
228
        self.assertTrue(published_pages.has_size(
 
229
            len(self.repo.imported_articles)+1))  # articles + root
218
230
        shutil.rmtree(self.tempdir)
219
231
        # Take the time before publishing the second import
220
232
        now = datetime.now(pytz.utc)
226
238
        self.assertTrue(self.repo.execute_import_directives())
227
239
        self.assertTrue(self.repo.publish())
228
240
        # Check the page's plugins
229
 
        for page in Page.objects.filter(publisher_is_draft=False):
 
241
        published_pages.update()
 
242
        for page in published_pages.pages:
230
243
            if page != self.root:
231
 
                (dummy, plugin) = find_text_plugin(page)
 
244
                (dummy, plugin) = get_text_plugin(page)
232
245
                self.assertGreater(now, plugin.changed_date)
233
246
 
234
247
 
241
254
        for article in self.repo.imported_articles:
242
255
            self.assertEqual(article.template, DEFAULT_TEMPLATE)
243
256
        self.assertTrue(self.repo.publish())
244
 
        for page in Page.objects.filter(publisher_is_draft=False):
 
257
        published_pages = PublishedPages()
 
258
        for page in published_pages.pages:
245
259
            if page.parent is not None:
246
260
                self.assertEqual(page.template, DEFAULT_TEMPLATE)
247
261
 
256
270
        for article in self.repo.imported_articles:
257
271
            self.assertEqual(article.template, template_to_use)
258
272
        self.assertTrue(self.repo.publish())
259
 
        for page in Page.objects.filter(publisher_is_draft=False):
 
273
        published_pages = PublishedPages()
 
274
        for page in published_pages.pages:
260
275
            if page.parent is not None:
261
276
                self.assertEqual(page.template, template_to_use)