+
+
+ Some edX courses ask you to enter an algebraic expression as an answer. Try entering the following algebraic expression in the box below. It’s easier than it looks.
+ \(A \cdot x^2 + \sqrt{y}\)
+
+
+The entry is case sensitive. The product must be indicated with an asterisk, and the exponentiation with a caret, so you would write
+"A*x^2 + sqrt(y)".
+
+
+
+
+
+
diff --git a/common/test/acceptance/tests/data/multiple_choice.xml b/common/test/acceptance/tests/data/multiple_choice.xml
new file mode 100644
index 0000000000..bdf9509d34
--- /dev/null
+++ b/common/test/acceptance/tests/data/multiple_choice.xml
@@ -0,0 +1,28 @@
+
+ Many edX courses have homework or exercises you need to complete. Notice the clock image to the left? That means this homework or exercise needs to be completed for you to pass the course. (This can be a bit confusing; the exercise may or may not have a due date prior to the end of the course.)
+ We’ve provided eight (8) examples of how a professor might ask you questions. While the multiple choice question types below are somewhat standard, explore the other question types in the sequence above, like the formula builder- try them all out.
+ As you go through the question types, notice how edX gives you immediate feedback on your responses - it really helps in the learning process.
+ What color is the open ocean on a sunny day?
+
+
+
+ Which piece of furniture is built for sitting?
+
+
+ a table
+ a desk
+ a chair
+ a bookshelf
+
+
+ Which of the following are musical instruments?
+
+
+ a piano
+ a tree
+ a guitar
+ a window
+
+
+
+
diff --git a/common/test/acceptance/tests/test_lms.py b/common/test/acceptance/tests/test_lms.py
new file mode 100644
index 0000000000..5b9407c2e5
--- /dev/null
+++ b/common/test/acceptance/tests/test_lms.py
@@ -0,0 +1,251 @@
+"""
+E2E tests for the LMS.
+"""
+
+from bok_choy.web_app_test import WebAppTest
+from bok_choy.promise import EmptyPromise, fulfill_before
+
+from .helpers import UniqueCourseTest, load_data_str
+from ..edxapp_pages.studio.auto_auth import AutoAuthPage
+from ..edxapp_pages.lms.login import LoginPage
+from ..edxapp_pages.lms.find_courses import FindCoursesPage
+from ..edxapp_pages.lms.course_about import CourseAboutPage
+from ..edxapp_pages.lms.register import RegisterPage
+from ..edxapp_pages.lms.course_info import CourseInfoPage
+from ..edxapp_pages.lms.tab_nav import TabNavPage
+from ..edxapp_pages.lms.course_nav import CourseNavPage
+from ..edxapp_pages.lms.progress import ProgressPage
+from ..edxapp_pages.lms.video import VideoPage
+from ..fixtures.course import CourseFixture, XBlockFixtureDesc, CourseUpdateDesc
+
+
+class RegistrationTest(UniqueCourseTest):
+ """
+ Test the registration process.
+ """
+
+ def setUp(self):
+ """
+ Initialize pages and install a course fixture.
+ """
+ super(RegistrationTest, self).setUp()
+
+ self.find_courses_page = FindCoursesPage(self.browser)
+ self.course_about_page = CourseAboutPage(self.browser, self.course_id)
+
+ # Create a course to register for
+ course_fix = CourseFixture(
+ self.course_info['org'], self.course_info['number'],
+ self.course_info['run'], self.course_info['display_name']
+ ).install()
+
+ def test_register(self):
+
+ # Visit the main page with the list of courses
+ self.find_courses_page.visit()
+
+ # Expect that the fixture course exists
+ course_ids = self.find_courses_page.course_id_list
+ self.assertIn(self.course_id, course_ids)
+
+ # Go to the course about page and click the register button
+ self.course_about_page.visit()
+ register_page = self.course_about_page.register()
+
+ # Fill in registration info and submit
+ username = "test_" + self.unique_id[0:6]
+ register_page.provide_info(
+ username + "@example.com", "test", username, "Test User"
+ )
+ dashboard = register_page.submit()
+
+ # We should end up at the dashboard
+ # Check that we're registered for the course
+ course_names = dashboard.available_courses
+ self.assertIn(self.course_info['display_name'], course_names)
+
+
+class HighLevelTabTest(UniqueCourseTest):
+ """
+ Tests that verify each of the high-level tabs available within a course.
+ """
+
+ def setUp(self):
+ """
+ Initialize pages and install a course fixture.
+ """
+ super(HighLevelTabTest, self).setUp()
+
+ self.course_info_page = CourseInfoPage(self.browser, self.course_id)
+ self.progress_page = ProgressPage(self.browser, self.course_id)
+ self.course_nav = CourseNavPage(self.browser)
+ self.tab_nav = TabNavPage(self.browser)
+ self.video = VideoPage(self.browser)
+
+ # Install a course with sections/problems, tabs, updates, and handouts
+ course_fix = CourseFixture(
+ self.course_info['org'], self.course_info['number'],
+ self.course_info['run'], self.course_info['display_name']
+ )
+
+ course_fix.add_update(
+ CourseUpdateDesc(date='January 29, 2014', content='Test course update')
+ )
+
+ course_fix.add_handout('demoPDF.pdf')
+
+ course_fix.add_children(
+ XBlockFixtureDesc('static_tab', 'Test Static Tab'),
+ XBlockFixtureDesc('chapter', 'Test Section').add_children(
+ XBlockFixtureDesc('sequential', 'Test Subsection').add_children(
+ XBlockFixtureDesc('problem', 'Test Problem 1', data=load_data_str('multiple_choice.xml')),
+ XBlockFixtureDesc('problem', 'Test Problem 2', data=load_data_str('formula_problem.xml')),
+ XBlockFixtureDesc('html', 'Test HTML'),
+ )),
+ XBlockFixtureDesc('chapter', 'Test Section 2').add_children(
+ XBlockFixtureDesc('sequential', 'Test Subsection 2'),
+ XBlockFixtureDesc('sequential', 'Test Subsection 3'),
+ )).install()
+
+ # Auto-auth register for the course
+ AutoAuthPage(self.browser, course_id=self.course_id).visit()
+
+ def test_course_info(self):
+ """
+ Navigate to the course info page.
+ """
+ # Navigate to the course info page from the progress page
+ self.progress_page.visit()
+ self.tab_nav.go_to_tab('Course Info')
+
+ # Expect just one update
+ self.assertEqual(self.course_info_page.num_updates, 1)
+
+ # Expect a link to the demo handout pdf
+ handout_links = self.course_info_page.handout_links
+ self.assertEqual(len(handout_links), 1)
+ self.assertIn('demoPDF.pdf', handout_links[0])
+
+ def test_progress(self):
+ """
+ Navigate to the progress page.
+ """
+ # Navigate to the progress page from the info page
+ self.course_info_page.visit()
+ self.tab_nav.go_to_tab('Progress')
+
+ # We haven't answered any problems yet, so assume scores are zero
+ # Only problems should have scores; so there should be 2 scores.
+ CHAPTER = 'Test Section'
+ SECTION = 'Test Subsection'
+ EXPECTED_SCORES = [(0, 3), (0, 1)]
+
+ actual_scores = self.progress_page.scores(CHAPTER, SECTION)
+ self.assertEqual(actual_scores, EXPECTED_SCORES)
+
+ def test_static_tab(self):
+ """
+ Navigate to a static tab (course content)
+ """
+ # From the course info page, navigate to the static tab
+ self.course_info_page.visit()
+ self.tab_nav.go_to_tab('Test Static Tab')
+ self.assertTrue(self.tab_nav.is_on_tab('Test Static Tab'))
+
+ def test_courseware_nav(self):
+ """
+ Navigate to a particular unit in the courseware.
+ """
+ # Navigate to the courseware page from the info page
+ self.course_info_page.visit()
+ self.tab_nav.go_to_tab('Courseware')
+
+ # Check that the courseware navigation appears correctly
+ EXPECTED_SECTIONS = {
+ 'Test Section': ['Test Subsection'],
+ 'Test Section 2': ['Test Subsection 2', 'Test Subsection 3']
+ }
+ actual_sections = self.course_nav.sections
+ for section, subsections in EXPECTED_SECTIONS.iteritems():
+ self.assertIn(section, actual_sections)
+ self.assertEqual(actual_sections[section], EXPECTED_SECTIONS[section])
+
+ # Navigate to a particular section
+ self.course_nav.go_to_section('Test Section', 'Test Subsection')
+
+ # Check the sequence items
+ EXPECTED_ITEMS = ['Test Problem 1', 'Test Problem 2', 'Test HTML']
+
+ actual_items = self.course_nav.sequence_items
+ self.assertEqual(len(actual_items), len(EXPECTED_ITEMS))
+ for expected in EXPECTED_ITEMS:
+ self.assertIn(expected, actual_items)
+
+
+class VideoTest(UniqueCourseTest):
+ """
+ Navigate to a video in the courseware and play it.
+ """
+ def setUp(self):
+ """
+ Initialize pages and install a course fixture.
+ """
+ super(VideoTest, self).setUp()
+
+ self.course_info_page = CourseInfoPage(self.browser, self.course_id)
+ self.course_nav = CourseNavPage(self.browser)
+ self.tab_nav = TabNavPage(self.browser)
+ self.video = VideoPage(self.browser)
+
+ # Install a course fixture with a video component
+ course_fix = CourseFixture(
+ self.course_info['org'], self.course_info['number'],
+ self.course_info['run'], self.course_info['display_name']
+ )
+
+ course_fix.add_children(
+ XBlockFixtureDesc('chapter', 'Test Section').add_children(
+ XBlockFixtureDesc('sequential', 'Test Subsection').add_children(
+ XBlockFixtureDesc('video', 'Video')
+ ))).install()
+
+
+ # Auto-auth register for the course
+ AutoAuthPage(self.browser, course_id=self.course_id).visit()
+
+ def test_video_player(self):
+ """
+ Play a video in the courseware.
+ """
+
+ # Navigate to a video
+ self.course_info_page.visit()
+ self.tab_nav.go_to_tab('Courseware')
+
+ # The video should start off paused
+ # Since the video hasn't loaded yet, it's elapsed time is 0
+ self.assertFalse(self.video.is_playing)
+ self.assertEqual(self.video.elapsed_time, 0)
+
+ # Play the video
+ self.video.play()
+
+ # Now we should be playing
+ self.assertTrue(self.video.is_playing)
+
+ # Wait for the video to load the duration
+ video_duration_loaded = EmptyPromise(
+ lambda: self.video.duration > 0,
+ 'video has duration', timeout=20
+ )
+
+ with fulfill_before(video_duration_loaded):
+
+ # Pause the video
+ self.video.pause()
+
+ # Expect that the elapsed time and duration are reasonable
+ # Again, we can't expect the video to actually play because of
+ # latency through the ssh tunnel
+ self.assertGreaterEqual(self.video.elapsed_time, 0)
+ self.assertGreaterEqual(self.video.duration, self.video.elapsed_time)
diff --git a/common/test/acceptance/tests/test_ora.py b/common/test/acceptance/tests/test_ora.py
index 39fc3fcd17..ab5b4940f9 100644
--- a/common/test/acceptance/tests/test_ora.py
+++ b/common/test/acceptance/tests/test_ora.py
@@ -23,36 +23,24 @@ class OpenResponseTest(UniqueCourseTest):
some helper functions used in the ORA tests.
"""
- page_object_classes = [
- AutoAuthPage, CourseInfoPage, TabNavPage,
- CourseNavPage, OpenResponsePage, ProgressPage
- ]
-
# Grade response (dict) to return from the XQueue stub
# in response to our unique submission text.
XQUEUE_GRADE_RESPONSE = None
def setUp(self):
"""
+ Install a test course with ORA problems.
Always start in the subsection with open response problems.
"""
- # Create a unique submission
- self.submission = "Test submission " + self.unique_id
-
- # Ensure fixtures are installed
super(OpenResponseTest, self).setUp()
- # Log in and navigate to the essay problems
- self.ui.visit('studio.auto_auth', course_id=self.course_id)
- self.ui.visit('lms.course_info', course_id=self.course_id)
- self.ui['lms.tab_nav'].go_to_tab('Courseware')
-
- @property
- def fixtures(self):
- """
- Create a test course with open response problems.
- Configure the XQueue stub to respond to submissions to the open-ended queue.
- """
+ # Create page objects
+ self.auth_page = AutoAuthPage(self.browser, course_id=self.course_id)
+ self.course_info_page = CourseInfoPage(self.browser, self.course_id)
+ self.tab_nav = TabNavPage(self.browser)
+ self.course_nav = CourseNavPage(self.browser)
+ self.open_response = OpenResponsePage(self.browser)
+ self.progress_page = ProgressPage(self.browser, self.course_id)
# Configure the test course
course_fix = CourseFixture(
@@ -61,7 +49,6 @@ class OpenResponseTest(UniqueCourseTest):
)
course_fix.add_children(
-
XBlockFixtureDesc('chapter', 'Test Section').add_children(
XBlockFixtureDesc('sequential', 'Test Subsection').add_children(
@@ -73,17 +60,21 @@ class OpenResponseTest(UniqueCourseTest):
XBlockFixtureDesc('combinedopenended', 'Peer-Assessed',
data=load_data_str('ora_peer_problem.xml'), metadata={'graded': True}),
- )
- )
- )
+
+ XBlockFixtureDesc('peergrading', 'Peer Module'),
+
+ ))).install()
# Configure the XQueue stub's response for the text we will submit
+ # The submission text is unique so we can associate each response with a particular test case.
+ self.submission = "Test submission " + self.unique_id[0:4]
if self.XQUEUE_GRADE_RESPONSE is not None:
- xqueue_fix = XQueueResponseFixture(self.submission, self.XQUEUE_GRADE_RESPONSE)
- return [course_fix, xqueue_fix]
+ XQueueResponseFixture(self.submission, self.XQUEUE_GRADE_RESPONSE).install()
- else:
- return [course_fix]
+ # Log in and navigate to the essay problems
+ self.auth_page.visit()
+ self.course_info_page.visit()
+ self.tab_nav.go_to_tab('Courseware')
def submit_essay(self, expected_assessment_type, expected_prompt):
"""
@@ -93,21 +84,21 @@ class OpenResponseTest(UniqueCourseTest):
"""
# Check the assessment type and prompt
- self.assertEqual(self.ui['lms.open_response'].assessment_type, expected_assessment_type)
- self.assertIn(expected_prompt, self.ui['lms.open_response'].prompt)
+ self.assertEqual(self.open_response.assessment_type, expected_assessment_type)
+ self.assertIn(expected_prompt, self.open_response.prompt)
# Enter a submission, which will trigger a pre-defined response from the XQueue stub.
- self.ui['lms.open_response'].set_response(self.submission)
+ self.open_response.set_response(self.submission)
# Save the response and expect some UI feedback
- self.ui['lms.open_response'].save_response()
+ self.open_response.save_response()
self.assertEqual(
- self.ui['lms.open_response'].alert_message,
+ self.open_response.alert_message,
"Answer saved, but not yet submitted."
)
# Submit the response
- self.ui['lms.open_response'].submit_response()
+ self.open_response.submit_response()
def get_asynch_feedback(self, assessment_type):
"""
@@ -142,9 +133,9 @@ class OpenResponseTest(UniqueCourseTest):
raise ValueError('Assessment type not recognized. Must be either "ai" or "peer"')
def _inner_check():
- self.ui['lms.course_nav'].go_to_sequential('Self-Assessed')
- self.ui['lms.course_nav'].go_to_sequential(section_name)
- feedback = self.ui['lms.open_response'].rubric_feedback
+ self.course_nav.go_to_sequential('Self-Assessed')
+ self.course_nav.go_to_sequential(section_name)
+ feedback = self.open_response.rubric_feedback
# Successful if `feedback` is a non-empty list
return (bool(feedback), feedback)
@@ -165,27 +156,25 @@ class SelfAssessmentTest(OpenResponseTest):
And I see my score in the progress page.
"""
# Navigate to the self-assessment problem and submit an essay
- self.ui['lms.course_nav'].go_to_sequential('Self-Assessed')
+ self.course_nav.go_to_sequential('Self-Assessed')
self.submit_essay('self', 'Censorship in the Libraries')
# Check the rubric categories
self.assertEqual(
- self.ui['lms.open_response'].rubric_categories,
- ["Writing Applications", "Language Conventions"]
+ self.open_response.rubric_categories, ["Writing Applications", "Language Conventions"]
)
# Fill in the self-assessment rubric
- self.ui['lms.open_response'].submit_self_assessment([0, 1])
+ self.open_response.submit_self_assessment([0, 1])
# Expect that we get feedback
self.assertEqual(
- self.ui['lms.open_response'].rubric_feedback,
- ['incorrect', 'correct']
+ self.open_response.rubric_feedback, ['incorrect', 'correct']
)
# Verify the progress page
- self.ui.visit('lms.progress', course_id=self.course_id)
- scores = self.ui['lms.progress'].scores('Test Section', 'Test Subsection')
+ self.progress_page.visit()
+ scores = self.progress_page.scores('Test Section', 'Test Subsection')
# The first score is self-assessment, which we've answered, so it's 1/2
# The other scores are AI- and peer-assessment, which we haven't answered so those are 0/2
@@ -217,22 +206,16 @@ class AIAssessmentTest(OpenResponseTest):
"""
# Navigate to the AI-assessment problem and submit an essay
- self.ui['lms.course_nav'].go_to_sequential('AI-Assessed')
+ self.course_nav.go_to_sequential('AI-Assessed')
self.submit_essay('ai', 'Censorship in the Libraries')
- # Expect UI feedback that the response was submitted
- self.assertEqual(
- self.ui['lms.open_response'].grader_status,
- "Your response has been submitted. Please check back later for your grade."
- )
-
# Refresh the page to get the updated feedback
# then verify that we get the feedback sent by our stub XQueue implementation
self.assertEqual(self.get_asynch_feedback('ai'), ['incorrect', 'correct'])
# Verify the progress page
- self.ui.visit('lms.progress', course_id=self.course_id)
- scores = self.ui['lms.progress'].scores('Test Section', 'Test Subsection')
+ self.progress_page.visit()
+ scores = self.progress_page.scores('Test Section', 'Test Subsection')
# First score is the self-assessment score, which we haven't answered, so it's 0/2
# Second score is the AI-assessment score, which we have answered, so it's 1/2
@@ -286,23 +269,17 @@ class PeerFeedbackTest(OpenResponseTest):
And I see my score in the progress page.
"""
# Navigate to the peer-assessment problem and submit an essay
- self.ui['lms.course_nav'].go_to_sequential('Peer-Assessed')
+ self.course_nav.go_to_sequential('Peer-Assessed')
self.submit_essay('peer', 'Censorship in the Libraries')
- # Expect UI feedback that the response was submitted
- self.assertEqual(
- self.ui['lms.open_response'].grader_status,
- "Your response has been submitted. Please check back later for your grade."
- )
-
# Refresh the page to get feedback from the stub XQueue grader.
# We receive feedback from all three peers, each of which
# provide 2 scores (one for each rubric item)
self.assertEqual(self.get_asynch_feedback('peer'), ['incorrect', 'correct'] * 3)
# Verify the progress page
- self.ui.visit('lms.progress', course_id=self.course_id)
- scores = self.ui['lms.progress'].scores('Test Section', 'Test Subsection')
+ self.progress_page.visit()
+ scores = self.progress_page.scores('Test Section', 'Test Subsection')
# First score is the self-assessment score, which we haven't answered, so it's 0/2
# Second score is the AI-assessment score, which we haven't answered, so it's 0/2
diff --git a/common/test/acceptance/tests/test_studio.py b/common/test/acceptance/tests/test_studio.py
index 1d233a7bb2..b4f8b64e6a 100644
--- a/common/test/acceptance/tests/test_studio.py
+++ b/common/test/acceptance/tests/test_studio.py
@@ -30,9 +30,9 @@ class LoggedOutTest(WebAppTest):
Smoke test for pages in Studio that are visible when logged out.
"""
- @property
- def page_object_classes(self):
- return [LoginPage, HowitworksPage, SignupPage]
+ def setUp(self):
+ super(LoggedOutTest, self).setUp()
+ self.pages = [LoginPage(self.browser), HowitworksPage(self.browser), SignupPage(self.browser)]
def test_page_existence(self):
"""
@@ -40,8 +40,8 @@ class LoggedOutTest(WebAppTest):
Rather than fire up the browser just to check each url,
do them all sequentially in this testcase.
"""
- for page in ['login', 'howitworks', 'signup']:
- self.ui.visit('studio.{0}'.format(page))
+ for page in self.pages:
+ page.visit()
class LoggedInPagesTest(WebAppTest):
@@ -49,16 +49,18 @@ class LoggedInPagesTest(WebAppTest):
Tests that verify the pages in Studio that you can get to when logged
in and do not have a course yet.
"""
- @property
- def page_object_classes(self):
- return [AutoAuthPage, DashboardPage]
+
+ def setUp(self):
+ super(LoggedInPagesTest, self).setUp()
+ self.auth_page = AutoAuthPage(self.browser, staff=True)
+ self.dashboard_page = DashboardPage(self.browser)
def test_dashboard_no_courses(self):
"""
Make sure that you can get to the dashboard page without a course.
"""
- self.ui.visit('studio.auto_auth', staff=True)
- self.ui.visit('studio.dashboard')
+ self.auth_page.visit()
+ self.dashboard_page.visit()
class CoursePagesTest(UniqueCourseTest):
@@ -69,23 +71,29 @@ class CoursePagesTest(UniqueCourseTest):
COURSE_ID_SEPARATOR = "."
- @property
- def page_object_classes(self):
- return [
- AutoAuthPage, AssetIndexPage, ChecklistsPage, ImportPage, CourseUpdatesPage,
- StaticPagesPage, ExportPage, CourseTeamPage, CourseOutlinePage,
- SettingsPage, AdvancedSettingsPage, GradingPage, TextbooksPage
- ]
+ def setUp(self):
+ """
+ Install a course with no content using a fixture.
+ """
+ super(UniqueCourseTest, self).setUp()
- @property
- def fixtures(self):
- course_fix = CourseFixture(
+ CourseFixture(
self.course_info['org'],
self.course_info['number'],
self.course_info['run'],
self.course_info['display_name']
- )
- return [course_fix]
+ ).install()
+
+ self.auth_page = AutoAuthPage(self.browser, staff=True)
+
+ self.pages = [
+ clz(self.browser, self.course_info['org'], self.course_info['number'], self.course_info['run'])
+ for clz in [
+ AssetIndexPage, ChecklistsPage, ImportPage, CourseUpdatesPage,
+ StaticPagesPage, ExportPage, CourseTeamPage, CourseOutlinePage, SettingsPage,
+ AdvancedSettingsPage, GradingPage, TextbooksPage
+ ]
+ ]
def test_page_existence(self):
"""
@@ -93,14 +101,9 @@ class CoursePagesTest(UniqueCourseTest):
Rather than fire up the browser just to check each url,
do them all sequentially in this testcase.
"""
- pages = [
- 'uploads', 'checklists', 'import', 'updates', 'tabs', 'export',
- 'team', 'outline', 'settings', 'advanced', 'grading', 'textbooks'
- ]
-
# Log in
- self.ui.visit('studio.auto_auth', staff=True)
+ self.auth_page.visit()
# Verify that each page is available
- for page in pages:
- self.ui.visit('studio.{0}'.format(page), course_id=self.course_id)
+ for page in self.pages:
+ page.visit()
diff --git a/lms/envs/bok_choy.auth.json b/lms/envs/bok_choy.auth.json
index 18c904d92a..931963c6d0 100644
--- a/lms/envs/bok_choy.auth.json
+++ b/lms/envs/bok_choy.auth.json
@@ -94,7 +94,7 @@
"password": "password",
"peer_grading": "peer_grading",
"staff_grading": "staff_grading",
- "url": "http://localhost:18060/",
+ "url": "** OVERRIDDEN **",
"username": "lms"
},
"SECRET_KEY": "",
diff --git a/lms/envs/bok_choy.py b/lms/envs/bok_choy.py
index 28a1d7d959..851ae22dd6 100644
--- a/lms/envs/bok_choy.py
+++ b/lms/envs/bok_choy.py
@@ -41,6 +41,9 @@ XML_MODULESTORE['OPTIONS']['data_dir'] = (TEST_ROOT / "data").abspath()
# Configure the LMS to use our stub XQueue implementation
XQUEUE_INTERFACE['url'] = 'http://localhost:8040'
+# Configure the LMS to use our stub ORA implementation
+OPEN_ENDED_GRADING_INTERFACE['url'] = 'http://localhost:8041/'
+
# Enable django-pipeline and staticfiles
STATIC_ROOT = (TEST_ROOT / "staticfiles").abspath()
PIPELINE = True
diff --git a/rakelib/bok_choy.rake b/rakelib/bok_choy.rake
index 7a47d53cb7..848590b57a 100644
--- a/rakelib/bok_choy.rake
+++ b/rakelib/bok_choy.rake
@@ -30,7 +30,11 @@ BOK_CHOY_SERVERS = {
}
BOK_CHOY_STUBS = {
- :xqueue => { :port => 8040, :log => File.join(BOK_CHOY_LOG_DIR, "bok_choy_xqueue.log") }
+
+ :xqueue => {
+ :port => 8040,
+ :log => File.join(BOK_CHOY_LOG_DIR, "bok_choy_xqueue.log")
+ }
}
# For the time being, stubs are used by both the bok-choy and lettuce acceptance tests
@@ -57,8 +61,8 @@ def start_servers()
)
end
end
-end
+end
# Wait until we get a successful response from the servers or time out
def wait_for_test_servers()
@@ -162,12 +166,6 @@ namespace :'test:bok_choy' do
desc "Process assets and set up database for bok-choy tests"
task :setup => [:check_services, :install_prereqs, BOK_CHOY_LOG_DIR] do
- # Clear any test data already in Mongo
- clear_mongo()
-
- # Invalidate the cache
- BOK_CHOY_CACHE.flush()
-
# Reset the database
sh("#{REPO_ROOT}/scripts/reset-test-db.sh")
@@ -182,20 +180,25 @@ namespace :'test:bok_choy' do
:check_services, BOK_CHOY_LOG_DIR, BOK_CHOY_REPORT_DIR, :clean_reports_dir
] do |t, args|
+ # Clear any test data already in Mongo or MySQL and invalidate the cache
+ clear_mongo()
+ BOK_CHOY_CACHE.flush()
+ sh(django_admin('lms', 'bok_choy', 'flush', '--noinput'))
+
# Ensure the test servers are available
- puts "Starting test servers...".red
+ puts "Starting test servers...".green
start_servers()
- puts "Waiting for servers to start...".red
+ puts "Waiting for servers to start...".green
wait_for_test_servers()
begin
- puts "Running test suite...".red
+ puts "Running test suite...".green
run_bok_choy(args.test_spec)
rescue
puts "Tests failed!".red
exit 1
ensure
- puts "Cleaning up databases...".red
+ puts "Cleaning up databases...".green
cleanup()
end
end
diff --git a/requirements/edx/github.txt b/requirements/edx/github.txt
index 4581b61194..06358f427e 100644
--- a/requirements/edx/github.txt
+++ b/requirements/edx/github.txt
@@ -21,4 +21,4 @@
-e git+https://github.com/edx/js-test-tool.git@v0.1.5#egg=js_test_tool
-e git+https://github.com/edx/django-waffle.git@823a102e48#egg=django-waffle
-e git+https://github.com/edx/event-tracking.git@f0211d702d#egg=event-tracking
--e git+https://github.com/edx/bok-choy.git@bc6f1adbe439618162079f1004b2b3db3b6f8916#egg=bok_choy
+-e git+https://github.com/edx/bok-choy.git@v0.1.0#egg=bok_choy