Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-11-12T04:34:27Z

Lcmcconn: /* Code Changes */

== ''' Introduction ''' ==
The [http://expertiza.ncsu.edu/ Expertiza] project takes advantage of peer-review among students to allow them to learn from each other. Tracking the time that a student spends on each submitted resources is meaningful to instructors to study and improve the teaching experience. Unfortunately, most peer assessment systems do not manage the content of students’ submission within the systems. They usually allow the authors submit external links to the submission (e.g. GitHub code / deployed application), which makes it difficult for the system to track the time that the reviewers spend on the submissions.

== ''' Problem Statement ''' ==
Expertiza allows students to peer review the work of other students in their course. To ensure the quality of the peer reviews, instructors would like to have the ability to track the time a student spends on a peer-review. These metrics need to be tracked and displayed in a way that the instructor is able to gain valuable insight into the quality of a review or set of reviews.

Various metrics will be tracked including
# The time spent on the primary review page
# The time spent on secondary/external links and downloadables

=== Previous Implementations ===
#[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E1791._Track_the_time_that_students_look_at_the_other_submissions_-_logging_improvement E1791] were able to implement the tracking mechanism for recording the time spent on looking at submissions that were of the type of links and downloadable files. The time spent on links were tracked using window popups when they are opened and closed. The downloadable files of the type text and images were displayed on a new HTML page to track the time spent on viewing that. Each time a submission link or downloadable file is clicked by the reviewer, a new record is created in the database. This causes a lot of database operations which degrades the performance of the application. Also, the way in which the results are displayed is not user-friendly. Other than these issues, the team provided a good [https://github.com/expertiza/expertiza/pull/1124 implementation] of the feature.
#[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2018/E1872_Track_Time_Students_Look_At_Other_Submissions E1872] started with E1971's implementation as their base and tried to display the results in a tabular format. The table included useful statistics but it is being displayed outside the review report to the right side which does not blend in with the review report table. Also, the table is hard to read as a lot of information is presented in a cluttered manner. It is hard to map each statistic with its corresponding review. Furthermore, the team did not include any tests.
#[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2019_-_E1989._Track_the_time_students_look_at_other_submissions E1989] is the most recent implementation, built from earlier designs, features a solid UI and ample tracking of review time across the board. They started off with project E1791 as their base and focused on displaying the results in a user-friendly manner. For this purpose, the results are displayed in a new window so that it does not look cluttered. The issue of extensive database operations still remains as future work in their [https://github.com/expertiza/expertiza/pull/1662 project].

== ''' Proposed Solution ''' ==
*From the suggestions of the previous team, [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2019_-_E1989._Track_the_time_students_look_at_other_submissions E1989], we plan to improve their implementation by reducing the frequency of database queries and insertions. In [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2019_-_E1989._Track_the_time_students_look_at_other_submissions E1989's] current implementation every time a start time is logged for expertiza/link/file, a new entry is created in the database. As a result the submission_viewing_event table increases in size very rapidly as it stores start and end times for each link if a particular event occurs. The solution is to save all entries locally on the users system and once the user presses Save or Submit, save the entry in the database.
*Secondly, [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2019_-_E1989._Track_the_time_students_look_at_other_submissions E1989's] implementation has a decent UI that effectively displays the necessary information to the user. We plan to add minor improvements to their UI to try to improve usability.
*The previous team also mentioned other issues involving the "Save review after 60 seconds" checkbox feature, that may be looked into in the case of extra time.
=== Design pattern ===

=== ''' Flowchart ''' ===
The following is the flowchart presented by E1989 that does a good job outlining the logic for tracking the time students spend reviewing:

[[File:E1989_Student_flowchart_modified.png | center]]
[[File:flowchart2.png | center]]

== ''' Code Changes ''' ==

Our implementation is centered around two different classes and the default 'pstore' gem

Our two classes work together to limit data written directly to the database.

<h4>'''Local Submitted Content'''</h4>
This class serves as a sort of "instance" or a standard for representing the tracking of the time for a single link which was visited.
<pre>
class LocalSubmittedContent
attr_accessor :map_id, :round, :link , :start_at, :end_at, :created_at, :updated_at

def initialize(**args)
@map_id = args.fetch(:map_id,nil)
@round = args.fetch(:round,nil)
@link = args.fetch(:link,nil)
@start_at = args.fetch(:start_at,nil)
@end_at = args.fetch(:end_at,nil)
@created_at = args.fetch(:created_at,nil)
@updated_at = args.fetch(:updated_at,nil)
end

def initialize(args)
@map_id = args.fetch(:map_id,nil)
@round = args.fetch(:round,nil)
@link = args.fetch(:link,nil)
@start_at = args.fetch(:start_at,nil)
@end_at = args.fetch(:end_at,nil)
@created_at = args.fetch(:created_at,nil)
@updated_at = args.fetch(:updated_at,nil)
end

def to_h()
return {map_id: @map_id, round: @round, link: @link, start_at: @start_at, end_at: @end_at, created_at: @created_at, updated_at: @updated_at}
end

def ==(other)
return @map_id = other.map_id && @round == other.round && @link == other.link &&
@start_at == other.start_at && @end_at == other.end_at &&
@created_at == other.created_at && @updated_at == other.updated_at
end

end
</pre>

<h4>'''LocalStorage'''</h4>
This class serves as the medium for transaction of data between the local @registry instance variable, pstore and the database

It manages the pstore "hash" by restricting access and saving instances of LocalSubmittedContent when required.

It has a lookup feature with .where() where the user can search for LocalSubmittedContent given specified parameters

Lastly it provides the functionality to save the entries from pstore into the database

<pre>
class LocalStorage

def initialize()
@registry = []
@pstore = PStore.new("local_submitted_content.pstore")
@pstore.transaction do
@pstore[:registry] ||= []
end
@registry = read()
end

def save(instance)
@pstore.transaction do
@registry << instance
@pstore[:registry] = @registry
end
end

def sync()
@pstore.transaction do
@pstore[:registry] = @registry
end
end

# Find all entries that meet every field in the params hash
# return list of matching entries
def where(params)
found = []

@registry.each do |item|
if item.to_h().values_at(*params.keys) == params.values
found << item
end
end
return found
end

# Reads and returns data from Pstore registry
def read()
@pstore.transaction do
return @pstore[:registry]
end
end

# Actually saves into the database
def hard_save(instance)
return SubmissionViewingEvent.create(instance.to_h())
end

def hard_save_all()
@registry.each do |item|
SubmissionViewingEvent.create(item.to_h())
end
end

def remove(instance)
@registry.each_with_index do |item,i|
if item.to_h() == instance.to_h()
@registry.delete_at(i)
end
end
sync()
end

def remove_all()
@registry = []
sync()
end

end
</pre>

== ''' Test Plan ''' ==
=== Automated Testing Using RSpec ===
The main feature that we want to test is that the intermediate review timings that we are planning to store on the browser's local storage are being accurately stored or not. There are already tests written to test the total time tracking feature. We will be adding additional tests to test the storage and retrieval of the intermediate timings.

=== Manual UI Testing ===
Our major focus for this project is to change the current implementation to use significantly less number of database operations by storing the intermediate timings in the local storage of the browser and write only the final time spent on viewing the submissions. So, the only manual UI testing that can be performed is to check if the total time spent by students is accurately tracked and can be viewed by the instructor.

This can be tested using the following steps:
# Log in to Expertiza as a student and go to the assignments tab.
# Click on a particular assignment and review the submission by click on links and spending some time viewing them.
# After reviewing is done, submit the review.
# Log out from the student account.
# To look at the time spent on the reviews, log in as the instructor.
# Click on the assignments tab.
# Click on the review report icon beside the specific assignment that you reviewed using the student's account.
# You should be able to see the total time spent on the submissions by the student.

== ''' Helpful Links ''' ==
#[https://github.com/LukeMccon/expertiza Our Fork]
== ''' Identified Issues ''' ==
TBD

== ''' Team Information ''' ==
#Luke McConnaughey (lcmcconn)
#Pedro Benitez (pbenite)
#Rohit Nair (rnair2)
#Surbhi Jha (sjha6)

Mentor: Yunkai 'Kai' Xiao (yxiao28)
<br>Professor: Dr. Edward F. Gehringer (efg)

===References===

#[https://github.com/expertiza/expertiza Expertiza on GitHub]
#[https://relishapp.com/rspec RSpec Documentation]

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-11-12T04:23:02Z

Lcmcconn: /* Flowchart */

File:Flowchart2.png

2020-11-12T04:20:41Z

Lcmcconn:

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-23T03:34:25Z

Lcmcconn:

File:E1989 Student flowchart modified.png

2020-10-23T03:33:02Z

Lcmcconn:

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T19:38:23Z

Lcmcconn:

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T19:38:02Z

Lcmcconn:

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T19:10:08Z

Lcmcconn: /* Identified Issues */

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T19:10:00Z

Lcmcconn: /* Code Changes */

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T04:23:31Z

Lcmcconn: /* Algorithm For Precise Timing Accuracy */

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T04:23:04Z

Lcmcconn: /* Team Information */

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T04:22:52Z

Lcmcconn: /* Team Information */

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T04:22:08Z

Lcmcconn:

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T03:48:30Z

Lcmcconn:

CSC/ECE 517 Fall 2020 - E2080. Track the time students look at other submissions

2020-10-22T03:39:01Z

Lcmcconn: Created page with "Intial edit"

Intial edit

CSC/ECE 517 Fall 2020 - E2055 write unit tests for student task.rb

2020-10-20T05:29:40Z

Lcmcconn: /* Implementation */

This page provides a description of the Expertiza based OSS project.

== About Expertiza ==

[https://expertiza.ncsu.edu/ Expertiza] is an open source project based on [https://rubyonrails.org/ Ruby on Rails] framework. Expertiza allows the instructor to create new assignments and customize new or existing assignments. It also allows the instructor to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions. Expertiza supports submission across various document types, including the URLs and wiki pages.

This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails,RSpec, DRY code,Test driven development etc. This provides an opportunity for students to contribute to an open source project and learn further about software deployment etc.

== About RSpec ==

RSpec is a unit test framework for the Ruby programming language. RSpec is different than traditional xUnit frameworks like JUnit because RSpec is a Behavior driven development tool. What this means is that, tests written in RSpec focus on the "behavior" of an application being tested. RSpec does not put emphasis on, how the application works but instead on how it behaves, in other words, what the application actually does.Each RSpec file contains one or more tests. Each test ensures if a particular feature of our website is working properly.The output of an RSpec run will tell you exactly what features aren't working. The benefit is that tested code is unlikely to break unnoticed.The tests are run every time someone makes, or updates, a [https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests Pull Request].

== DB Schema ==
Below are the tables that are related ti student task functionality
[http://wiki.expertiza.ncsu.edu/images/7/7a/ExpertizaDbSchema.jpg DB Schema]

== Description of the current project ==

The following is an Expertiza based OSS project which deals primarily with the student_task.rb and student_task_spec.rb. It focuses on writing RSpec unit tests for the code affected or added. The goal of this project is to attempt to add sufficient unit tests to this part of the application and increase its path coverage to above 90 percent.
The following tasks were accomplished in this project:

* Complete the insufficient unit tests for student_task.rb.
* Increase path coverage from only 31.91% with 30 lines covered to above 90% coverage
* Cover edge cases.
* High branch coverage to be achieved.

There are different tasks that a student can perform.
* They can see all the assignments that they have been assigned to.
* They can see details of each assignment like marks, their team, send invitation to student to join a team
* Review other students' work

== Tests Plan ==
*Mock Objects to test: Create a series of mock objects that will be used throughout the testing process
*The following are a list of the functions that were tested:
*Topic name
**Retrieves the topic name of an assignment
*Complete?
**Checks if a student task is complete
*Incomplete?
**If the assignment is not complete return true
*Not started?
**Checks if a student task is available to be worked on (i.e in submission/review/metareview stage) and if so has it been started
*Revision?
**Checks if a student task is now in the revision stage
*Met reviews given
*Teamed students
**Returns a list of students that an individual has teamed up with
*Get due date
**Gets the due date for each assignment assigned to a student
*Get peer review data
*Get author feedback
*Get submission data
*Get timeline data

== Implementation ==
The following are our written tests in the order listed above:

Details regarding what the test is testing can be seen as comments above each example block

'''Here were are creating all of the mock objects to test the functionality of the student_task model. We are using these from the previous implementation
''' describe StudentTask do
let(:participant) { build(:participant, id: 1, user_id: user.id, parent_id: assignment.id) }
let(:participant2) { build(:participant, id: 2, user_id: user2.id, parent_id: assignment.id) }
let(:participant3) { build(:participant, id: 3, user_id: user3.id, parent_id: assignment2.id) }
let(:user) { create(:student) }
let(:user2) { create(:student, name: "qwertyui", id: 5) }
let(:user3) { create(:student, name: "qwertyui1234", id: 6) }
let(:course) { build(:course) }
let(:assignment) { build(:assignment, name: 'assignment 1') }
let(:assignment2) { create(:assignment, name: 'assignment 2', is_calibrated: true) }
let(:team) { create(:assignment_team, id: 1, name: 'team 1', parent_id: assignment.id, users: [user, user2]) }
let(:team2) { create(:assignment_team, id: 2, name: 'team 2', parent_id: assignment2.id, users: [user3]) }
let(:team_user) { create(:team_user, id: 3, team_id: team.id, user_id: user.id) }
let(:team_user2) { create(:team_user, id: 4, team_id: team.id, user_id: user2.id) }
let(:team2_user3) { create(:team_user, id: 5, team_id: team2.id, user_id: user3.id) }
let(:course_team) { create(:course_team, id: 3, name: 'course team 1', parent_id: course.id) }
let(:cource_team_user) { create(:team_user, id: 6, team_id: course_team.id, user_id: user.id) }
let(:cource_team_user2) { create(:team_user, id: 7, team_id: course_team.id, user_id: user2.id) }
let(:topic) { build(:topic) }
let(:topic2) { create(:topic, topic_name: "TestReview") }
let(:topic3) { create(:topic) }
let(:due_date) { build(:assignment_due_date, deadline_type_id: 1) }
let(:deadline_type) { build(:deadline_type, id: 1) }
let(:review_response_map) { build(:review_response_map, assignment: assignment, reviewer: participant, reviewee: team2) }
let(:metareview_response_map) { build(:meta_review_response_map, reviewed_object_id: 1) }
let(:response) { build(:response, id: 1, map_id: 1, response_map: review_response_map) }
let(:response2) { build(:response, id: 2, map_id: 1, response_map: review_response_map) }
let(:submission_record) {build(:submission_record, id:1, team_id: 1, assignment_id: 1) }
let(:student_task) do
StudentTask.new(
user: user,
participant: participant,
assignment: assignment,
topic: topic3,
)
end
let(:student_task2) do
StudentTask.new(
user: user,
participant: participant2,
assignment: assignment,
topic: topic2,
)
end
''' Here we just verify that topic name is stored and that any values for topic name that are falsey will be set to "-"'''
# Tests topic name to ensure it is stored or set as "-"
describe "#topic_name" do
it 'returns the topic name if given one' do
allow(student_task2).to receive(:topic).and_return(topic2)
expect(student_task2.topic_name).to eq("TestReview")
end
it 'returns - for blank name' do
expect(student_task.topic_name).to eq("-")
end
end
'''Here we are testing the different values that the student tasks status can take on'''
# Verifies completion status of a student task
describe "#complete?" do
it 'verifies a student task is complete' do
allow(student_task).to receive(:stage_deadline).and_return('Complete')
expect(student_task.complete?).to be true
end
it 'verifies a nil stage_deadline to not be complete' do
allow(student_task).to receive(:stage_deadline).and_return('')
expect(student_task.complete?).to be false
end
end
'''Here we are making sure the content has been submitted during the current stage of the process, only occurss when current_stage is equal to "submission"'''
# tests if hyperlinks or other content is submitted during the submission stage
# current stage must be submission
# participant has to belong to a team
# the team has submitted some content
describe "content_submitted_in_current_stage?" do
it 'checks if hyperlinks is submitted during submission stage'do
student_task.current_stage = "submission"
allow(student_task).to receive_message_chain(:hyperlinks, :present).and_return(true)
expect(student_task.content_submitted_in_current_stage?).to eq(true)
end
end
'''Hyperlinks is modified based on the teams that a user is in. This will be updated if they are in a team or they already have hyperlinks it will remain the same'''
# Tests the updating of the @hyperlinks instance variable based on participant's team
# Does not verify operation of ||= call, only tests cases of right hand side
describe "#hyperlinks" do
it 'returns empty array if participant has no team' do
allow(student_task).to receive_message_chain(:participant, :team, :nil?).and_return(true)
expect(student_task.hyperlinks).to eq([])
end
it 'assigns returns populated hyperlinks instance if participant has team' do
allow(student_task).to receive_message_chain(:participant, :team, :hyperlinks).and_return(['something'])
allow(student_task).to receive_message_chain(:participant, :team, :nil?).and_return(false)
expect(student_task.hyperlinks).to eq(['something'])
end
end
'''Simply testing to see if the incomplete status is checked correctly'''
# Verifies incomplete status of student task
describe "#incomplete?" do
it 'checks a student_task is incomplete' do
expect(student_task.incomplete?).to be true
end
end
'''Verify the stage of a task and that a started task is evaluated correctly'''
# Verifies that a task has not started
describe "#not_started?" do
it 'verfies started status' do
allow(student_task).to receive(:in_work_stage?).and_return(true)
allow(student_task).to receive(:started?).and_return(true)
expect(student_task.not_started?).to eq(false)
end
it 'is not started due to work stage' do
allow(student_task).to receive(:in_work_stage?).and_return(false)
allow(student_task).to receive(:started?).and_return(true)
expect(student_task.not_started?).to eq(false)
end
end

# Tests relative_deadline for proper assignment when stage_deadline is present
describe "#relative_deadline" do
it 'returns false without a valid stage deadline' do
allow(student_task).to receive(:stage_deadline).and_return(nil)
expect(student_task.relative_deadline).to be_falsey
end
it 'verifies a valid case where stage_deadline is present' do
allow(student_task).to receive(:stage_deadline).and_return(true)
allow(student_task).to receive(:time_ago_in_words).and_return("astring")
expect(student_task.relative_deadline).to eq("astring")
end
end

# Examines a task to determine if the task is a revision
describe "#revision?" do
it 'returns true if content is submitted' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(true)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(false)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(false)
expect(student_task.revision?).to eq(true)
end
it 'returns true if reviews given is true' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(false)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(true)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(false)
expect(student_task.revision?).to eq(true)
end
it 'returns true if metareviews given is true' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(false)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(false)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(true)
expect(student_task.revision?).to eq(true)
end
end

# Checks if metareview was given in current task stage
describe "#metreviews_given_in_current_stage?" do
it 'return true' do
student_task.current_stage = "metareview"
allow(student_task).to receive(:metareviews_given?).and_return(true)
expect(student_task.metareviews_given_in_current_stage?).to eq(true)
end
end
# Checks if review was given in current task stage
describe "#reviews_given_in_current_stage?" do
it 'return true' do
student_task.current_stage = "review"
allow(student_task).to receive(:reviews_given?).and_return(true)
expect(student_task.reviews_given_in_current_stage?).to eq(true)
end
end

# tests whether a student task has been started
# if the task is not incomplete && is not in the revision stage
# started? returns false
# if the task is incomplete && is in the revision stage
# started? returns true
describe "#started?" do
it 'is not started' do
allow(student_task).to receive(:incomplete?).and_return(false)
allow(student_task).to receive(:revision?).and_return(false)
expect(student_task.started?).to eq(false)
end
it 'is started' do
allow(student_task).to receive(:incomplete?).and_return(true)
allow(student_task).to receive(:revision?).and_return(true)
expect(student_task.started?).to eq(true)
end
end

# Tests works stage to ensure state is represented correctly
describe "#in_work_stage?" do
it "is true, submission is a work stage" do
allow(student_task).to receive(:current_stage).and_return("submission")
expect(student_task.in_work_stage?).to eq(true)
end
it "is true, review is a work stage" do
allow(student_task).to receive(:current_stage).and_return("review")
expect(student_task.in_work_stage?).to eq(true)
end
it "is true, metareview is a work stage" do
allow(student_task).to receive(:current_stage).and_return("metareview")
expect(student_task.in_work_stage?).to eq(true)
end
it "is false, empty object" do
allow(student_task).to receive(:current_stage).and_return("")
expect(student_task.in_work_stage?).to eq(false)
end
end
'''The following test returns a list of students that the user has teamed with up to this point. Returns an empty list if they have yet to team with anyone'''
# Tests teamed students method which returns the unique students that are paired with the student at some point
# within their course
describe "#teamed_students" do
context 'when not in any team' do
it 'returns empty' do
expect(StudentTask.teamed_students(user3)).to eq({})
end
end
context 'when assigned in a cource_team ' do
it 'returns empty' do
allow(user).to receive(:teams).and_return([course_team])
expect(StudentTask.teamed_students(user)).to eq({})
end
end
context 'when assigned in a assignment_team ' do
it 'returns the students they are teamed with' do
allow(user).to receive(:teams).and_return([team])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: assignment.id).and_return(participant)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 5, parent_id: assignment.id).and_return(participant2)
allow(Assignment).to receive(:find_by).with(id: team.parent_id).and_return(assignment)
expect(StudentTask.teamed_students(user)).to eq({assignment.course_id => [user2.fullname]})
end
end
end

# Gets the due dates of an assigment
describe "#get_due_date_data" do
context 'when called with assignment having empty due dates' do
it "return empty time_list array" do
timeline_list = []
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when called with assignment having due date' do
context 'and due_at value nil' do
it "return empty time_list array" do
allow(due_date).to receive(:deadline_type).and_return(deadline_type)
timeline_list = []
due_date.due_at=nil;
assignment.due_dates = [due_date]
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([])
end
end
context 'and due_at value not nil' do
it "return time_list array" do
allow(due_date).to receive(:deadline_type).and_return(deadline_type)
timeline_list = []
assignment.due_dates = [due_date]
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([{
:label=>(due_date.deadline_type.name + ' Deadline').humanize,
:updated_at=>due_date.due_at.strftime('%a, %d %b %Y %H:%M')
}])
end
end
end
end
'''Here we fetch different timelines and account for edge cases where there are no reviews'''
# Verifies fetching of peer review data of a user and a timeline
describe "#get_peer_review_data" do
context 'when no review response mapped' do
it 'returns empty' do
timeline_list=[]
StudentTask.get_peer_review_data(user2,timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when mapped to review response map' do
it 'returns timeline array' do
timeline_list=[]
allow(ReviewResponseMap).to receive_message_chain(:where, :find_each).with(reviewer_id: 1).with(no_args).and_yield(review_response_map)
allow(review_response_map).to receive(:id).and_return(1)
allow(Response).to receive_message_chain(:where, :last).with(map_id: 1).with(no_args).and_return(response)
allow(response).to receive(:round).and_return(1)
allow(response).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_peer_review_data(1,timeline_list)).to eq([{:id=>1, :label=>"Round 1 peer review", :updated_at=>timevalue}])
end
end
end

# Verifies retrieval of feedback from author
describe "#get_author_feedback_data" do
context 'when no feedback response mapped' do
it 'returns empty' do
timeline_list=[]
StudentTask.get_author_feedback_data(user2,timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when mapped to feedback response map' do
it 'returns timeline array' do
timeline_list=[]
allow(FeedbackResponseMap).to receive_message_chain(:where, :find_each).with(reviewer_id: 1).with(no_args).and_yield(review_response_map)
allow(review_response_map).to receive(:id).and_return(1)
allow(Response).to receive_message_chain(:where, :last).with(map_id: 1).with(no_args).and_return(response)
allow(response).to receive(:updated_at).and_return(Time.now)
timevalue = Time.now.strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_author_feedback_data(1,timeline_list)).to eq([{:id=>1, :label=>"Author feedback", :updated_at=>timevalue}])
end
end
end
'''Here we verify different states of submission data and hyperlinks'''
# Verrifies retrieval of submission data from submission
describe '#get_submission_data' do
context 'when no submission data mapped' do
it 'returns nil' do
timeline_list=[]
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq(nil)
end
end
context 'when submission data mapped and not submit hyperlink or Remove hyperlink' do
it 'returns timeline_list' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('testing_label')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Testing label", :updated_at=>timevalue}])
end
end
context 'when submission data mapped and operation is submit_hyperlink' do
it 'returns timeline_list with link' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('Submit Hyperlink')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Submit hyperlink", :updated_at=>timevalue, :link=>"www.wolfware.edu"}])
end
end
context 'when submission data mapped and operation is Remove Hyperlink' do
it 'returns timeline_list with link' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('Remove Hyperlink')
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Remove hyperlink", :updated_at=>timevalue, :link=>"www.wolfware.edu"}])
end
end
end
''' Here we are ensuring that the timeline data is empty when data has not been mapped'''
# Verifies retrieval of timeline data
describe '#get_timeline_data' do
context 'when no timeline data mapped' do
it 'returns nil' do
allow(participant).to receive(:get_reviewer).and_return(participant)
expect(StudentTask.get_timeline_data(assignment, participant, team)).to eq([])
end
end
end end

== Line Coverage achieved ==
*94 relevant lines
*86 lines covered
*8 lines missed
*Coverage = 91.49%

== Issues ==
Some of the tests were rather shallow, get_timeline_data specifically needs depth added.

== Useful Links ==
[https://youtu.be/N6H1HtQ4eds/ YouTube Video Demo]

[https://github.com/johnbumgardner/expertiza/ GitHub Repo]

[https://github.com/expertiza/expertiza/pull/1811/ Pull Request]

== Team Members ==
John Bumgardner, Pedro Benitez, Luke McConnaughey

CSC/ECE 517 Fall 2020 - E2055 write unit tests for student task.rb

2020-10-20T05:26:49Z

Lcmcconn: /* Implementation */

This page provides a description of the Expertiza based OSS project.

== About Expertiza ==

[https://expertiza.ncsu.edu/ Expertiza] is an open source project based on [https://rubyonrails.org/ Ruby on Rails] framework. Expertiza allows the instructor to create new assignments and customize new or existing assignments. It also allows the instructor to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions. Expertiza supports submission across various document types, including the URLs and wiki pages.

This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails,RSpec, DRY code,Test driven development etc. This provides an opportunity for students to contribute to an open source project and learn further about software deployment etc.

== About RSpec ==

RSpec is a unit test framework for the Ruby programming language. RSpec is different than traditional xUnit frameworks like JUnit because RSpec is a Behavior driven development tool. What this means is that, tests written in RSpec focus on the "behavior" of an application being tested. RSpec does not put emphasis on, how the application works but instead on how it behaves, in other words, what the application actually does.Each RSpec file contains one or more tests. Each test ensures if a particular feature of our website is working properly.The output of an RSpec run will tell you exactly what features aren't working. The benefit is that tested code is unlikely to break unnoticed.The tests are run every time someone makes, or updates, a [https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests Pull Request].

== DB Schema ==
Below are the tables that are related ti student task functionality
[http://wiki.expertiza.ncsu.edu/images/7/7a/ExpertizaDbSchema.jpg DB Schema]

== Description of the current project ==

The following is an Expertiza based OSS project which deals primarily with the student_task.rb and student_task_spec.rb. It focuses on writing RSpec unit tests for the code affected or added. The goal of this project is to attempt to add sufficient unit tests to this part of the application and increase its path coverage to above 90 percent.
The following tasks were accomplished in this project:

* Complete the insufficient unit tests for student_task.rb.
* Increase path coverage from only 31.91% with 30 lines covered to above 90% coverage
* Cover edge cases.
* High branch coverage to be achieved.

There are different tasks that a student can perform.
* They can see all the assignments that they have been assigned to.
* They can see details of each assignment like marks, their team, send invitation to student to join a team
* Review other students' work

== Tests Plan ==
*Mock Objects to test: Create a series of mock objects that will be used throughout the testing process
*The following are a list of the functions that were tested:
*Topic name
**Retrieves the topic name of an assignment
*Complete?
**Checks if a student task is complete
*Incomplete?
**If the assignment is not complete return true
*Not started?
**Checks if a student task is available to be worked on (i.e in submission/review/metareview stage) and if so has it been started
*Revision?
**Checks if a student task is now in the revision stage
*Met reviews given
*Teamed students
**Returns a list of students that an individual has teamed up with
*Get due date
**Gets the due date for each assignment assigned to a student
*Get peer review data
*Get author feedback
*Get submission data
*Get timeline data

== Implementation ==
The following are our written tests in the order listed above:

Details regarding what the test is testing can be seen as comments above each example block

'''Here were are creating all of the mock objects to test the functionality of the student_task model. We are using these from the previous implementation
''' describe StudentTask do
let(:participant) { build(:participant, id: 1, user_id: user.id, parent_id: assignment.id) }
let(:participant2) { build(:participant, id: 2, user_id: user2.id, parent_id: assignment.id) }
let(:participant3) { build(:participant, id: 3, user_id: user3.id, parent_id: assignment2.id) }
let(:user) { create(:student) }
let(:user2) { create(:student, name: "qwertyui", id: 5) }
let(:user3) { create(:student, name: "qwertyui1234", id: 6) }
let(:course) { build(:course) }
let(:assignment) { build(:assignment, name: 'assignment 1') }
let(:assignment2) { create(:assignment, name: 'assignment 2', is_calibrated: true) }
let(:team) { create(:assignment_team, id: 1, name: 'team 1', parent_id: assignment.id, users: [user, user2]) }
let(:team2) { create(:assignment_team, id: 2, name: 'team 2', parent_id: assignment2.id, users: [user3]) }
let(:team_user) { create(:team_user, id: 3, team_id: team.id, user_id: user.id) }
let(:team_user2) { create(:team_user, id: 4, team_id: team.id, user_id: user2.id) }
let(:team2_user3) { create(:team_user, id: 5, team_id: team2.id, user_id: user3.id) }
let(:course_team) { create(:course_team, id: 3, name: 'course team 1', parent_id: course.id) }
let(:cource_team_user) { create(:team_user, id: 6, team_id: course_team.id, user_id: user.id) }
let(:cource_team_user2) { create(:team_user, id: 7, team_id: course_team.id, user_id: user2.id) }
let(:topic) { build(:topic) }
let(:topic2) { create(:topic, topic_name: "TestReview") }
let(:topic3) { create(:topic) }
let(:due_date) { build(:assignment_due_date, deadline_type_id: 1) }
let(:deadline_type) { build(:deadline_type, id: 1) }
let(:review_response_map) { build(:review_response_map, assignment: assignment, reviewer: participant, reviewee: team2) }
let(:metareview_response_map) { build(:meta_review_response_map, reviewed_object_id: 1) }
let(:response) { build(:response, id: 1, map_id: 1, response_map: review_response_map) }
let(:response2) { build(:response, id: 2, map_id: 1, response_map: review_response_map) }
let(:submission_record) {build(:submission_record, id:1, team_id: 1, assignment_id: 1) }
let(:student_task) do
StudentTask.new(
user: user,
participant: participant,
assignment: assignment,
topic: topic3,
)
end
let(:student_task2) do
StudentTask.new(
user: user,
participant: participant2,
assignment: assignment,
topic: topic2,
)
end

# Tests topic name to ensure it is stored or set as "-"
describe "#topic_name" do
it 'returns the topic name if given one' do
allow(student_task2).to receive(:topic).and_return(topic2)
expect(student_task2.topic_name).to eq("TestReview")
end
it 'returns - for blank name' do
expect(student_task.topic_name).to eq("-")
end
end
'''Here we are testing the different values that the student tasks status can take on'''
# Verifies completion status of a student task
describe "#complete?" do
it 'verifies a student task is complete' do
allow(student_task).to receive(:stage_deadline).and_return('Complete')
expect(student_task.complete?).to be true
end
it 'verifies a nil stage_deadline to not be complete' do
allow(student_task).to receive(:stage_deadline).and_return('')
expect(student_task.complete?).to be false
end
end
'''Here we are making sure the content has been submitted during the current stage of the process, only occurss when current_stage is equal to "submission"'''
# tests if hyperlinks or other content is submitted during the submission stage
# current stage must be submission
# participant has to belong to a team
# the team has submitted some content
describe "content_submitted_in_current_stage?" do
it 'checks if hyperlinks is submitted during submission stage'do
student_task.current_stage = "submission"
allow(student_task).to receive_message_chain(:hyperlinks, :present).and_return(true)
expect(student_task.content_submitted_in_current_stage?).to eq(true)
end
end
'''Hyperlinks is modified based on the teams that a user is in. This will be updated if they are in a team or they already have hyperlinks it will remain the same'''
# Tests the updating of the @hyperlinks instance variable based on participant's team
# Does not verify operation of ||= call, only tests cases of right hand side
describe "#hyperlinks" do
it 'returns empty array if participant has no team' do
allow(student_task).to receive_message_chain(:participant, :team, :nil?).and_return(true)
expect(student_task.hyperlinks).to eq([])
end
it 'assigns returns populated hyperlinks instance if participant has team' do
allow(student_task).to receive_message_chain(:participant, :team, :hyperlinks).and_return(['something'])
allow(student_task).to receive_message_chain(:participant, :team, :nil?).and_return(false)
expect(student_task.hyperlinks).to eq(['something'])
end
end
'''Simply testing to see if the incomplete status is checked correctly'''
# Verifies incomplete status of student task
describe "#incomplete?" do
it 'checks a student_task is incomplete' do
expect(student_task.incomplete?).to be true
end
end
'''Verify the stage of a task and that a started task is evaluated correctly'''
# Verifies that a task has not started
describe "#not_started?" do
it 'verfies started status' do
allow(student_task).to receive(:in_work_stage?).and_return(true)
allow(student_task).to receive(:started?).and_return(true)
expect(student_task.not_started?).to eq(false)
end
it 'is not started due to work stage' do
allow(student_task).to receive(:in_work_stage?).and_return(false)
allow(student_task).to receive(:started?).and_return(true)
expect(student_task.not_started?).to eq(false)
end
end

# Tests relative_deadline for proper assignment when stage_deadline is present
describe "#relative_deadline" do
it 'returns false without a valid stage deadline' do
allow(student_task).to receive(:stage_deadline).and_return(nil)
expect(student_task.relative_deadline).to be_falsey
end
it 'verifies a valid case where stage_deadline is present' do
allow(student_task).to receive(:stage_deadline).and_return(true)
allow(student_task).to receive(:time_ago_in_words).and_return("astring")
expect(student_task.relative_deadline).to eq("astring")
end
end

# Examines a task to determine if the task is a revision
describe "#revision?" do
it 'returns true if content is submitted' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(true)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(false)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(false)
expect(student_task.revision?).to eq(true)
end
it 'returns true if reviews given is true' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(false)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(true)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(false)
expect(student_task.revision?).to eq(true)
end
it 'returns true if metareviews given is true' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(false)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(false)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(true)
expect(student_task.revision?).to eq(true)
end
end

# Checks if metareview was given in current task stage
describe "#metreviews_given_in_current_stage?" do
it 'return true' do
student_task.current_stage = "metareview"
allow(student_task).to receive(:metareviews_given?).and_return(true)
expect(student_task.metareviews_given_in_current_stage?).to eq(true)
end
end
# Checks if review was given in current task stage
describe "#reviews_given_in_current_stage?" do
it 'return true' do
student_task.current_stage = "review"
allow(student_task).to receive(:reviews_given?).and_return(true)
expect(student_task.reviews_given_in_current_stage?).to eq(true)
end
end

# tests whether a student task has been started
# if the task is not incomplete && is not in the revision stage
# started? returns false
# if the task is incomplete && is in the revision stage
# started? returns true
describe "#started?" do
it 'is not started' do
allow(student_task).to receive(:incomplete?).and_return(false)
allow(student_task).to receive(:revision?).and_return(false)
expect(student_task.started?).to eq(false)
end
it 'is started' do
allow(student_task).to receive(:incomplete?).and_return(true)
allow(student_task).to receive(:revision?).and_return(true)
expect(student_task.started?).to eq(true)
end
end

# Tests works stage to ensure state is represented correctly
describe "#in_work_stage?" do
it "is true, submission is a work stage" do
allow(student_task).to receive(:current_stage).and_return("submission")
expect(student_task.in_work_stage?).to eq(true)
end
it "is true, review is a work stage" do
allow(student_task).to receive(:current_stage).and_return("review")
expect(student_task.in_work_stage?).to eq(true)
end
it "is true, metareview is a work stage" do
allow(student_task).to receive(:current_stage).and_return("metareview")
expect(student_task.in_work_stage?).to eq(true)
end
it "is false, empty object" do
allow(student_task).to receive(:current_stage).and_return("")
expect(student_task.in_work_stage?).to eq(false)
end
end

# Tests teamed students method which returns the unique students that are paired with the student at some point
# within their course
describe "#teamed_students" do
context 'when not in any team' do
it 'returns empty' do
expect(StudentTask.teamed_students(user3)).to eq({})
end
end
context 'when assigned in a cource_team ' do
it 'returns empty' do
allow(user).to receive(:teams).and_return([course_team])
expect(StudentTask.teamed_students(user)).to eq({})
end
end
context 'when assigned in a assignment_team ' do
it 'returns the students they are teamed with' do
allow(user).to receive(:teams).and_return([team])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: assignment.id).and_return(participant)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 5, parent_id: assignment.id).and_return(participant2)
allow(Assignment).to receive(:find_by).with(id: team.parent_id).and_return(assignment)
expect(StudentTask.teamed_students(user)).to eq({assignment.course_id => [user2.fullname]})
end
end
end

# Gets the due dates of an assigment
describe "#get_due_date_data" do
context 'when called with assignment having empty due dates' do
it "return empty time_list array" do
timeline_list = []
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when called with assignment having due date' do
context 'and due_at value nil' do
it "return empty time_list array" do
allow(due_date).to receive(:deadline_type).and_return(deadline_type)
timeline_list = []
due_date.due_at=nil;
assignment.due_dates = [due_date]
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([])
end
end
context 'and due_at value not nil' do
it "return time_list array" do
allow(due_date).to receive(:deadline_type).and_return(deadline_type)
timeline_list = []
assignment.due_dates = [due_date]
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([{
:label=>(due_date.deadline_type.name + ' Deadline').humanize,
:updated_at=>due_date.due_at.strftime('%a, %d %b %Y %H:%M')
}])
end
end
end
end

# Verifies fetching of peer review data of a user and a timeline
describe "#get_peer_review_data" do
context 'when no review response mapped' do
it 'returns empty' do
timeline_list=[]
StudentTask.get_peer_review_data(user2,timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when mapped to review response map' do
it 'returns timeline array' do
timeline_list=[]
allow(ReviewResponseMap).to receive_message_chain(:where, :find_each).with(reviewer_id: 1).with(no_args).and_yield(review_response_map)
allow(review_response_map).to receive(:id).and_return(1)
allow(Response).to receive_message_chain(:where, :last).with(map_id: 1).with(no_args).and_return(response)
allow(response).to receive(:round).and_return(1)
allow(response).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_peer_review_data(1,timeline_list)).to eq([{:id=>1, :label=>"Round 1 peer review", :updated_at=>timevalue}])
end
end
end

# Verifies retrieval of feedback from author
describe "#get_author_feedback_data" do
context 'when no feedback response mapped' do
it 'returns empty' do
timeline_list=[]
StudentTask.get_author_feedback_data(user2,timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when mapped to feedback response map' do
it 'returns timeline array' do
timeline_list=[]
allow(FeedbackResponseMap).to receive_message_chain(:where, :find_each).with(reviewer_id: 1).with(no_args).and_yield(review_response_map)
allow(review_response_map).to receive(:id).and_return(1)
allow(Response).to receive_message_chain(:where, :last).with(map_id: 1).with(no_args).and_return(response)
allow(response).to receive(:updated_at).and_return(Time.now)
timevalue = Time.now.strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_author_feedback_data(1,timeline_list)).to eq([{:id=>1, :label=>"Author feedback", :updated_at=>timevalue}])
end
end
end

# Verrifies retrieval of submission data from submission
describe '#get_submission_data' do
context 'when no submission data mapped' do
it 'returns nil' do
timeline_list=[]
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq(nil)
end
end
context 'when submission data mapped and not submit hyperlink or Remove hyperlink' do
it 'returns timeline_list' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('testing_label')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Testing label", :updated_at=>timevalue}])
end
end
context 'when submission data mapped and operation is submit_hyperlink' do
it 'returns timeline_list with link' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('Submit Hyperlink')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Submit hyperlink", :updated_at=>timevalue, :link=>"www.wolfware.edu"}])
end
end
context 'when submission data mapped and operation is Remove Hyperlink' do
it 'returns timeline_list with link' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('Remove Hyperlink')
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Remove hyperlink", :updated_at=>timevalue, :link=>"www.wolfware.edu"}])
end
end
end

# Verifies retrieval of timeline data
describe '#get_timeline_data' do
context 'when no timeline data mapped' do
it 'returns nil' do
allow(participant).to receive(:get_reviewer).and_return(participant)
expect(StudentTask.get_timeline_data(assignment, participant, team)).to eq([])
end
end
end end

== Line Coverage achieved ==
*94 relevant lines
*86 lines covered
*8 lines missed
*Coverage = 91.49%

== Issues ==
Some of the tests were rather shallow, get_timeline_data specifically needs depth added.

== Useful Links ==
[https://youtu.be/N6H1HtQ4eds/ YouTube Video Demo]

[https://github.com/johnbumgardner/expertiza/ GitHub Repo]

[https://github.com/expertiza/expertiza/pull/1811/ Pull Request]

== Team Members ==
John Bumgardner, Pedro Benitez, Luke McConnaughey

CSC/ECE 517 Fall 2020 - E2055 write unit tests for student task.rb

2020-10-20T05:23:55Z

Lcmcconn: /* Implementation */

This page provides a description of the Expertiza based OSS project.

== About Expertiza ==

[https://expertiza.ncsu.edu/ Expertiza] is an open source project based on [https://rubyonrails.org/ Ruby on Rails] framework. Expertiza allows the instructor to create new assignments and customize new or existing assignments. It also allows the instructor to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions. Expertiza supports submission across various document types, including the URLs and wiki pages.

This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails,RSpec, DRY code,Test driven development etc. This provides an opportunity for students to contribute to an open source project and learn further about software deployment etc.

== About RSpec ==

RSpec is a unit test framework for the Ruby programming language. RSpec is different than traditional xUnit frameworks like JUnit because RSpec is a Behavior driven development tool. What this means is that, tests written in RSpec focus on the "behavior" of an application being tested. RSpec does not put emphasis on, how the application works but instead on how it behaves, in other words, what the application actually does.Each RSpec file contains one or more tests. Each test ensures if a particular feature of our website is working properly.The output of an RSpec run will tell you exactly what features aren't working. The benefit is that tested code is unlikely to break unnoticed.The tests are run every time someone makes, or updates, a [https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests Pull Request].

== DB Schema ==
Below are the tables that are related ti student task functionality
[http://wiki.expertiza.ncsu.edu/images/7/7a/ExpertizaDbSchema.jpg DB Schema]

== Description of the current project ==

The following is an Expertiza based OSS project which deals primarily with the student_task.rb and student_task_spec.rb. It focuses on writing RSpec unit tests for the code affected or added. The goal of this project is to attempt to add sufficient unit tests to this part of the application and increase its path coverage to above 90 percent.
The following tasks were accomplished in this project:

* Complete the insufficient unit tests for student_task.rb.
* Increase path coverage from only 31.91% with 30 lines covered to above 90% coverage
* Cover edge cases.
* High branch coverage to be achieved.

There are different tasks that a student can perform.
* They can see all the assignments that they have been assigned to.
* They can see details of each assignment like marks, their team, send invitation to student to join a team
* Review other students' work

== Tests Plan ==
*Mock Objects to test: Create a series of mock objects that will be used throughout the testing process
*The following are a list of the functions that were tested:
*Topic name
**Retrieves the topic name of an assignment
*Complete?
**Checks if a student task is complete
*Incomplete?
**If the assignment is not complete return true
*Not started?
**Checks if a student task is available to be worked on (i.e in submission/review/metareview stage) and if so has it been started
*Revision?
**Checks if a student task is now in the revision stage
*Met reviews given
*Teamed students
**Returns a list of students that an individual has teamed up with
*Get due date
**Gets the due date for each assignment assigned to a student
*Get peer review data
*Get author feedback
*Get submission data
*Get timeline data

== Implementation ==
The following are our written tests in the order listed above:

Details regarding what the test is testing can be seen as comments above each example block

'''Here were are creating all of the mock objects to test the functionality of the student_task model. We are using these from the previous implementation
''' describe StudentTask do
let(:participant) { build(:participant, id: 1, user_id: user.id, parent_id: assignment.id) }
let(:participant2) { build(:participant, id: 2, user_id: user2.id, parent_id: assignment.id) }
let(:participant3) { build(:participant, id: 3, user_id: user3.id, parent_id: assignment2.id) }
let(:user) { create(:student) }
let(:user2) { create(:student, name: "qwertyui", id: 5) }
let(:user3) { create(:student, name: "qwertyui1234", id: 6) }
let(:course) { build(:course) }
let(:assignment) { build(:assignment, name: 'assignment 1') }
let(:assignment2) { create(:assignment, name: 'assignment 2', is_calibrated: true) }
let(:team) { create(:assignment_team, id: 1, name: 'team 1', parent_id: assignment.id, users: [user, user2]) }
let(:team2) { create(:assignment_team, id: 2, name: 'team 2', parent_id: assignment2.id, users: [user3]) }
let(:team_user) { create(:team_user, id: 3, team_id: team.id, user_id: user.id) }
let(:team_user2) { create(:team_user, id: 4, team_id: team.id, user_id: user2.id) }
let(:team2_user3) { create(:team_user, id: 5, team_id: team2.id, user_id: user3.id) }
let(:course_team) { create(:course_team, id: 3, name: 'course team 1', parent_id: course.id) }
let(:cource_team_user) { create(:team_user, id: 6, team_id: course_team.id, user_id: user.id) }
let(:cource_team_user2) { create(:team_user, id: 7, team_id: course_team.id, user_id: user2.id) }
let(:topic) { build(:topic) }
let(:topic2) { create(:topic, topic_name: "TestReview") }
let(:topic3) { create(:topic) }
let(:due_date) { build(:assignment_due_date, deadline_type_id: 1) }
let(:deadline_type) { build(:deadline_type, id: 1) }
let(:review_response_map) { build(:review_response_map, assignment: assignment, reviewer: participant, reviewee: team2) }
let(:metareview_response_map) { build(:meta_review_response_map, reviewed_object_id: 1) }
let(:response) { build(:response, id: 1, map_id: 1, response_map: review_response_map) }
let(:response2) { build(:response, id: 2, map_id: 1, response_map: review_response_map) }
let(:submission_record) {build(:submission_record, id:1, team_id: 1, assignment_id: 1) }
let(:student_task) do
StudentTask.new(
user: user,
participant: participant,
assignment: assignment,
topic: topic3,
)
end
let(:student_task2) do
StudentTask.new(
user: user,
participant: participant2,
assignment: assignment,
topic: topic2,
)
end

# Tests topic name to ensure it is stored or set as "-"
describe "#topic_name" do
it 'returns the topic name if given one' do
allow(student_task2).to receive(:topic).and_return(topic2)
expect(student_task2.topic_name).to eq("TestReview")
end
it 'returns - for blank name' do
expect(student_task.topic_name).to eq("-")
end
end
'''Here we are testing the different values that the student tasks status can take on'''
# Verifies completion status of a student task
describe "#complete?" do
it 'verifies a student task is complete' do
allow(student_task).to receive(:stage_deadline).and_return('Complete')
expect(student_task.complete?).to be true
end
it 'verifies a nil stage_deadline to not be complete' do
allow(student_task).to receive(:stage_deadline).and_return('')
expect(student_task.complete?).to be false
end
end

# tests if hyperlinks or other content is submitted during the submission stage
# current stage must be submission
# participant has to belong to a team
# the team has submitted some content
describe "content_submitted_in_current_stage?" do
it 'checks if hyperlinks is submitted during submission stage'do
student_task.current_stage = "submission"
allow(student_task).to receive_message_chain(:hyperlinks, :present).and_return(true)
expect(student_task.content_submitted_in_current_stage?).to eq(true)
end
end

# Tests the updating of the @hyperlinks instance variable based on participant's team
# Does not verify operation of ||= call, only tests cases of right hand side
describe "#hyperlinks" do
it 'returns empty array if participant has no team' do
allow(student_task).to receive_message_chain(:participant, :team, :nil?).and_return(true)
expect(student_task.hyperlinks).to eq([])
end
it 'assigns returns populated hyperlinks instance if participant has team' do
allow(student_task).to receive_message_chain(:participant, :team, :hyperlinks).and_return(['something'])
allow(student_task).to receive_message_chain(:participant, :team, :nil?).and_return(false)
expect(student_task.hyperlinks).to eq(['something'])
end
end

# Verifies incomplete status of student task
describe "#incomplete?" do
it 'checks a student_task is incomplete' do
expect(student_task.incomplete?).to be true
end
end

# Verifies that a task has not started
describe "#not_started?" do
it 'verfies started status' do
allow(student_task).to receive(:in_work_stage?).and_return(true)
allow(student_task).to receive(:started?).and_return(true)
expect(student_task.not_started?).to eq(false)
end
it 'is not started due to work stage' do
allow(student_task).to receive(:in_work_stage?).and_return(false)
allow(student_task).to receive(:started?).and_return(true)
expect(student_task.not_started?).to eq(false)
end
end

# Tests relative_deadline for proper assignment when stage_deadline is present
describe "#relative_deadline" do
it 'returns false without a valid stage deadline' do
allow(student_task).to receive(:stage_deadline).and_return(nil)
expect(student_task.relative_deadline).to be_falsey
end
it 'verifies a valid case where stage_deadline is present' do
allow(student_task).to receive(:stage_deadline).and_return(true)
allow(student_task).to receive(:time_ago_in_words).and_return("astring")
expect(student_task.relative_deadline).to eq("astring")
end
end

# Examines a task to determine if the task is a revision
describe "#revision?" do
it 'returns true if content is submitted' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(true)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(false)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(false)
expect(student_task.revision?).to eq(true)
end
it 'returns true if reviews given is true' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(false)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(true)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(false)
expect(student_task.revision?).to eq(true)
end
it 'returns true if metareviews given is true' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(false)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(false)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(true)
expect(student_task.revision?).to eq(true)
end
end

# Checks if metareview was given in current task stage
describe "#metreviews_given_in_current_stage?" do
it 'return true' do
student_task.current_stage = "metareview"
allow(student_task).to receive(:metareviews_given?).and_return(true)
expect(student_task.metareviews_given_in_current_stage?).to eq(true)
end
end
# Checks if review was given in current task stage
describe "#reviews_given_in_current_stage?" do
it 'return true' do
student_task.current_stage = "review"
allow(student_task).to receive(:reviews_given?).and_return(true)
expect(student_task.reviews_given_in_current_stage?).to eq(true)
end
end

# tests whether a student task has been started
# if the task is not incomplete && is not in the revision stage
# started? returns false
# if the task is incomplete && is in the revision stage
# started? returns true
describe "#started?" do
it 'is not started' do
allow(student_task).to receive(:incomplete?).and_return(false)
allow(student_task).to receive(:revision?).and_return(false)
expect(student_task.started?).to eq(false)
end
it 'is started' do
allow(student_task).to receive(:incomplete?).and_return(true)
allow(student_task).to receive(:revision?).and_return(true)
expect(student_task.started?).to eq(true)
end
end

# Tests works stage to ensure state is represented correctly
describe "#in_work_stage?" do
it "is true, submission is a work stage" do
allow(student_task).to receive(:current_stage).and_return("submission")
expect(student_task.in_work_stage?).to eq(true)
end
it "is true, review is a work stage" do
allow(student_task).to receive(:current_stage).and_return("review")
expect(student_task.in_work_stage?).to eq(true)
end
it "is true, metareview is a work stage" do
allow(student_task).to receive(:current_stage).and_return("metareview")
expect(student_task.in_work_stage?).to eq(true)
end
it "is false, empty object" do
allow(student_task).to receive(:current_stage).and_return("")
expect(student_task.in_work_stage?).to eq(false)
end
end

# Tests teamed students method which returns the unique students that are paired with the student at some point
# within their course
describe "#teamed_students" do
context 'when not in any team' do
it 'returns empty' do
expect(StudentTask.teamed_students(user3)).to eq({})
end
end
context 'when assigned in a cource_team ' do
it 'returns empty' do
allow(user).to receive(:teams).and_return([course_team])
expect(StudentTask.teamed_students(user)).to eq({})
end
end
context 'when assigned in a assignment_team ' do
it 'returns the students they are teamed with' do
allow(user).to receive(:teams).and_return([team])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: assignment.id).and_return(participant)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 5, parent_id: assignment.id).and_return(participant2)
allow(Assignment).to receive(:find_by).with(id: team.parent_id).and_return(assignment)
expect(StudentTask.teamed_students(user)).to eq({assignment.course_id => [user2.fullname]})
end
end
end

# Gets the due dates of an assigment
describe "#get_due_date_data" do
context 'when called with assignment having empty due dates' do
it "return empty time_list array" do
timeline_list = []
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when called with assignment having due date' do
context 'and due_at value nil' do
it "return empty time_list array" do
allow(due_date).to receive(:deadline_type).and_return(deadline_type)
timeline_list = []
due_date.due_at=nil;
assignment.due_dates = [due_date]
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([])
end
end
context 'and due_at value not nil' do
it "return time_list array" do
allow(due_date).to receive(:deadline_type).and_return(deadline_type)
timeline_list = []
assignment.due_dates = [due_date]
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([{
:label=>(due_date.deadline_type.name + ' Deadline').humanize,
:updated_at=>due_date.due_at.strftime('%a, %d %b %Y %H:%M')
}])
end
end
end
end

# Verifies fetching of peer review data of a user and a timeline
describe "#get_peer_review_data" do
context 'when no review response mapped' do
it 'returns empty' do
timeline_list=[]
StudentTask.get_peer_review_data(user2,timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when mapped to review response map' do
it 'returns timeline array' do
timeline_list=[]
allow(ReviewResponseMap).to receive_message_chain(:where, :find_each).with(reviewer_id: 1).with(no_args).and_yield(review_response_map)
allow(review_response_map).to receive(:id).and_return(1)
allow(Response).to receive_message_chain(:where, :last).with(map_id: 1).with(no_args).and_return(response)
allow(response).to receive(:round).and_return(1)
allow(response).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_peer_review_data(1,timeline_list)).to eq([{:id=>1, :label=>"Round 1 peer review", :updated_at=>timevalue}])
end
end
end

# Verifies retrieval of feedback from author
describe "#get_author_feedback_data" do
context 'when no feedback response mapped' do
it 'returns empty' do
timeline_list=[]
StudentTask.get_author_feedback_data(user2,timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when mapped to feedback response map' do
it 'returns timeline array' do
timeline_list=[]
allow(FeedbackResponseMap).to receive_message_chain(:where, :find_each).with(reviewer_id: 1).with(no_args).and_yield(review_response_map)
allow(review_response_map).to receive(:id).and_return(1)
allow(Response).to receive_message_chain(:where, :last).with(map_id: 1).with(no_args).and_return(response)
allow(response).to receive(:updated_at).and_return(Time.now)
timevalue = Time.now.strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_author_feedback_data(1,timeline_list)).to eq([{:id=>1, :label=>"Author feedback", :updated_at=>timevalue}])
end
end
end

# Verrifies retrieval of submission data from submission
describe '#get_submission_data' do
context 'when no submission data mapped' do
it 'returns nil' do
timeline_list=[]
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq(nil)
end
end
context 'when submission data mapped and not submit hyperlink or Remove hyperlink' do
it 'returns timeline_list' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('testing_label')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Testing label", :updated_at=>timevalue}])
end
end
context 'when submission data mapped and operation is submit_hyperlink' do
it 'returns timeline_list with link' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('Submit Hyperlink')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Submit hyperlink", :updated_at=>timevalue, :link=>"www.wolfware.edu"}])
end
end
context 'when submission data mapped and operation is Remove Hyperlink' do
it 'returns timeline_list with link' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('Remove Hyperlink')
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Remove hyperlink", :updated_at=>timevalue, :link=>"www.wolfware.edu"}])
end
end
end

# Verifies retrieval of timeline data
describe '#get_timeline_data' do
context 'when no timeline data mapped' do
it 'returns nil' do
allow(participant).to receive(:get_reviewer).and_return(participant)
expect(StudentTask.get_timeline_data(assignment, participant, team)).to eq([])
end
end
end
end

== Line Coverage achieved ==
*94 relevant lines
*86 lines covered
*8 lines missed
*Coverage = 91.49%

== Issues ==
Some of the tests were rather shallow, get_timeline_data specifically needs depth added.

== Useful Links ==
[https://youtu.be/N6H1HtQ4eds/ YouTube Video Demo]

[https://github.com/johnbumgardner/expertiza/ GitHub Repo]

[https://github.com/expertiza/expertiza/pull/1811/ Pull Request]

== Team Members ==
John Bumgardner, Pedro Benitez, Luke McConnaughey

CSC/ECE 517 Fall 2020 - E2055 write unit tests for student task.rb

2020-10-20T05:21:26Z

Lcmcconn: /* Implementation */

This page provides a description of the Expertiza based OSS project.

== About Expertiza ==

[https://expertiza.ncsu.edu/ Expertiza] is an open source project based on [https://rubyonrails.org/ Ruby on Rails] framework. Expertiza allows the instructor to create new assignments and customize new or existing assignments. It also allows the instructor to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions. Expertiza supports submission across various document types, including the URLs and wiki pages.

This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails,RSpec, DRY code,Test driven development etc. This provides an opportunity for students to contribute to an open source project and learn further about software deployment etc.

== About RSpec ==

RSpec is a unit test framework for the Ruby programming language. RSpec is different than traditional xUnit frameworks like JUnit because RSpec is a Behavior driven development tool. What this means is that, tests written in RSpec focus on the "behavior" of an application being tested. RSpec does not put emphasis on, how the application works but instead on how it behaves, in other words, what the application actually does.Each RSpec file contains one or more tests. Each test ensures if a particular feature of our website is working properly.The output of an RSpec run will tell you exactly what features aren't working. The benefit is that tested code is unlikely to break unnoticed.The tests are run every time someone makes, or updates, a [https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests Pull Request].

== DB Schema ==
Below are the tables that are related ti student task functionality
[http://wiki.expertiza.ncsu.edu/images/7/7a/ExpertizaDbSchema.jpg DB Schema]

== Description of the current project ==

The following is an Expertiza based OSS project which deals primarily with the student_task.rb and student_task_spec.rb. It focuses on writing RSpec unit tests for the code affected or added. The goal of this project is to attempt to add sufficient unit tests to this part of the application and increase its path coverage to above 90 percent.
The following tasks were accomplished in this project:

* Complete the insufficient unit tests for student_task.rb.
* Increase path coverage from only 31.91% with 30 lines covered to above 90% coverage
* Cover edge cases.
* High branch coverage to be achieved.

There are different tasks that a student can perform.
* They can see all the assignments that they have been assigned to.
* They can see details of each assignment like marks, their team, send invitation to student to join a team
* Review other students' work

== Tests Plan ==
*Mock Objects to test: Create a series of mock objects that will be used throughout the testing process
*The following are a list of the functions that were tested:
*Topic name
**Retrieves the topic name of an assignment
*Complete?
**Checks if a student task is complete
*Incomplete?
**If the assignment is not complete return true
*Not started?
**Checks if a student task is available to be worked on (i.e in submission/review/metareview stage) and if so has it been started
*Revision?
**Checks if a student task is now in the revision stage
*Met reviews given
*Teamed students
**Returns a list of students that an individual has teamed up with
*Get due date
**Gets the due date for each assignment assigned to a student
*Get peer review data
*Get author feedback
*Get submission data
*Get timeline data

== Implementation ==
The following are our written tests in the order listed above:

Details regarding what the test is testing can be seen as comments above each example block

describe StudentTask do
let(:participant) { build(:participant, id: 1, user_id: user.id, parent_id: assignment.id) }
let(:participant2) { build(:participant, id: 2, user_id: user2.id, parent_id: assignment.id) }
let(:participant3) { build(:participant, id: 3, user_id: user3.id, parent_id: assignment2.id) }
let(:user) { create(:student) }
let(:user2) { create(:student, name: "qwertyui", id: 5) }
let(:user3) { create(:student, name: "qwertyui1234", id: 6) }
let(:course) { build(:course) }
let(:assignment) { build(:assignment, name: 'assignment 1') }
let(:assignment2) { create(:assignment, name: 'assignment 2', is_calibrated: true) }
let(:team) { create(:assignment_team, id: 1, name: 'team 1', parent_id: assignment.id, users: [user, user2]) }
let(:team2) { create(:assignment_team, id: 2, name: 'team 2', parent_id: assignment2.id, users: [user3]) }
let(:team_user) { create(:team_user, id: 3, team_id: team.id, user_id: user.id) }
let(:team_user2) { create(:team_user, id: 4, team_id: team.id, user_id: user2.id) }
let(:team2_user3) { create(:team_user, id: 5, team_id: team2.id, user_id: user3.id) }
let(:course_team) { create(:course_team, id: 3, name: 'course team 1', parent_id: course.id) }
let(:cource_team_user) { create(:team_user, id: 6, team_id: course_team.id, user_id: user.id) }
let(:cource_team_user2) { create(:team_user, id: 7, team_id: course_team.id, user_id: user2.id) }
let(:topic) { build(:topic) }
let(:topic2) { create(:topic, topic_name: "TestReview") }
let(:topic3) { create(:topic) }
let(:due_date) { build(:assignment_due_date, deadline_type_id: 1) }
let(:deadline_type) { build(:deadline_type, id: 1) }
let(:review_response_map) { build(:review_response_map, assignment: assignment, reviewer: participant, reviewee: team2) }
let(:metareview_response_map) { build(:meta_review_response_map, reviewed_object_id: 1) }
let(:response) { build(:response, id: 1, map_id: 1, response_map: review_response_map) }
let(:response2) { build(:response, id: 2, map_id: 1, response_map: review_response_map) }
let(:submission_record) {build(:submission_record, id:1, team_id: 1, assignment_id: 1) }
let(:student_task) do
StudentTask.new(
user: user,
participant: participant,
assignment: assignment,
topic: topic3,
)
end
let(:student_task2) do
StudentTask.new(
user: user,
participant: participant2,
assignment: assignment,
topic: topic2,
)
end

# Tests topic name to ensure it is stored or set as "-"
describe "#topic_name" do
it 'returns the topic name if given one' do
allow(student_task2).to receive(:topic).and_return(topic2)
expect(student_task2.topic_name).to eq("TestReview")
end
it 'returns - for blank name' do
expect(student_task.topic_name).to eq("-")
end
end

# Verifies completion status of a student task
describe "#complete?" do
it 'verifies a student task is complete' do
allow(student_task).to receive(:stage_deadline).and_return('Complete')
expect(student_task.complete?).to be true
end
it 'verifies a nil stage_deadline to not be complete' do
allow(student_task).to receive(:stage_deadline).and_return('')
expect(student_task.complete?).to be false
end
end

# tests if hyperlinks or other content is submitted during the submission stage
# current stage must be submission
# participant has to belong to a team
# the team has submitted some content
describe "content_submitted_in_current_stage?" do
it 'checks if hyperlinks is submitted during submission stage'do
student_task.current_stage = "submission"
allow(student_task).to receive_message_chain(:hyperlinks, :present).and_return(true)
expect(student_task.content_submitted_in_current_stage?).to eq(true)
end
end

# Tests the updating of the @hyperlinks instance variable based on participant's team
# Does not verify operation of ||= call, only tests cases of right hand side
describe "#hyperlinks" do
it 'returns empty array if participant has no team' do
allow(student_task).to receive_message_chain(:participant, :team, :nil?).and_return(true)
expect(student_task.hyperlinks).to eq([])
end
it 'assigns returns populated hyperlinks instance if participant has team' do
allow(student_task).to receive_message_chain(:participant, :team, :hyperlinks).and_return(['something'])
allow(student_task).to receive_message_chain(:participant, :team, :nil?).and_return(false)
expect(student_task.hyperlinks).to eq(['something'])
end
end

# Verifies incomplete status of student task
describe "#incomplete?" do
it 'checks a student_task is incomplete' do
expect(student_task.incomplete?).to be true
end
end

# Verifies that a task has not started
describe "#not_started?" do
it 'verfies started status' do
allow(student_task).to receive(:in_work_stage?).and_return(true)
allow(student_task).to receive(:started?).and_return(true)
expect(student_task.not_started?).to eq(false)
end
it 'is not started due to work stage' do
allow(student_task).to receive(:in_work_stage?).and_return(false)
allow(student_task).to receive(:started?).and_return(true)
expect(student_task.not_started?).to eq(false)
end
end

# Tests relative_deadline for proper assignment when stage_deadline is present
describe "#relative_deadline" do
it 'returns false without a valid stage deadline' do
allow(student_task).to receive(:stage_deadline).and_return(nil)
expect(student_task.relative_deadline).to be_falsey
end
it 'verifies a valid case where stage_deadline is present' do
allow(student_task).to receive(:stage_deadline).and_return(true)
allow(student_task).to receive(:time_ago_in_words).and_return("astring")
expect(student_task.relative_deadline).to eq("astring")
end
end

# Examines a task to determine if the task is a revision
describe "#revision?" do
it 'returns true if content is submitted' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(true)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(false)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(false)
expect(student_task.revision?).to eq(true)
end
it 'returns true if reviews given is true' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(false)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(true)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(false)
expect(student_task.revision?).to eq(true)
end
it 'returns true if metareviews given is true' do
allow(student_task).to receive(:content_submitted_in_current_stage?).and_return(false)
allow(student_task).to receive(:reviews_given_in_current_stage?).and_return(false)
allow(student_task).to receive(:metareviews_given_in_current_stage?).and_return(true)
expect(student_task.revision?).to eq(true)
end
end

# Checks if metareview was given in current task stage
describe "#metreviews_given_in_current_stage?" do
it 'return true' do
student_task.current_stage = "metareview"
allow(student_task).to receive(:metareviews_given?).and_return(true)
expect(student_task.metareviews_given_in_current_stage?).to eq(true)
end
end
# Checks if review was given in current task stage
describe "#reviews_given_in_current_stage?" do
it 'return true' do
student_task.current_stage = "review"
allow(student_task).to receive(:reviews_given?).and_return(true)
expect(student_task.reviews_given_in_current_stage?).to eq(true)
end
end

# tests whether a student task has been started
# if the task is not incomplete && is not in the revision stage
# started? returns false
# if the task is incomplete && is in the revision stage
# started? returns true
describe "#started?" do
it 'is not started' do
allow(student_task).to receive(:incomplete?).and_return(false)
allow(student_task).to receive(:revision?).and_return(false)
expect(student_task.started?).to eq(false)
end
it 'is started' do
allow(student_task).to receive(:incomplete?).and_return(true)
allow(student_task).to receive(:revision?).and_return(true)
expect(student_task.started?).to eq(true)
end
end

# Tests works stage to ensure state is represented correctly
describe "#in_work_stage?" do
it "is true, submission is a work stage" do
allow(student_task).to receive(:current_stage).and_return("submission")
expect(student_task.in_work_stage?).to eq(true)
end
it "is true, review is a work stage" do
allow(student_task).to receive(:current_stage).and_return("review")
expect(student_task.in_work_stage?).to eq(true)
end
it "is true, metareview is a work stage" do
allow(student_task).to receive(:current_stage).and_return("metareview")
expect(student_task.in_work_stage?).to eq(true)
end
it "is false, empty object" do
allow(student_task).to receive(:current_stage).and_return("")
expect(student_task.in_work_stage?).to eq(false)
end
end

# Tests teamed students method which returns the unique students that are paired with the student at some point
# within their course
describe "#teamed_students" do
context 'when not in any team' do
it 'returns empty' do
expect(StudentTask.teamed_students(user3)).to eq({})
end
end
context 'when assigned in a cource_team ' do
it 'returns empty' do
allow(user).to receive(:teams).and_return([course_team])
expect(StudentTask.teamed_students(user)).to eq({})
end
end
context 'when assigned in a assignment_team ' do
it 'returns the students they are teamed with' do
allow(user).to receive(:teams).and_return([team])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: assignment.id).and_return(participant)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 5, parent_id: assignment.id).and_return(participant2)
allow(Assignment).to receive(:find_by).with(id: team.parent_id).and_return(assignment)
expect(StudentTask.teamed_students(user)).to eq({assignment.course_id => [user2.fullname]})
end
end
end

# Gets the due dates of an assigment
describe "#get_due_date_data" do
context 'when called with assignment having empty due dates' do
it "return empty time_list array" do
timeline_list = []
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when called with assignment having due date' do
context 'and due_at value nil' do
it "return empty time_list array" do
allow(due_date).to receive(:deadline_type).and_return(deadline_type)
timeline_list = []
due_date.due_at=nil;
assignment.due_dates = [due_date]
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([])
end
end
context 'and due_at value not nil' do
it "return time_list array" do
allow(due_date).to receive(:deadline_type).and_return(deadline_type)
timeline_list = []
assignment.due_dates = [due_date]
StudentTask.get_due_date_data(assignment, timeline_list)
expect(timeline_list).to eq([{
:label=>(due_date.deadline_type.name + ' Deadline').humanize,
:updated_at=>due_date.due_at.strftime('%a, %d %b %Y %H:%M')
}])
end
end
end
end

# Verifies fetching of peer review data of a user and a timeline
describe "#get_peer_review_data" do
context 'when no review response mapped' do
it 'returns empty' do
timeline_list=[]
StudentTask.get_peer_review_data(user2,timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when mapped to review response map' do
it 'returns timeline array' do
timeline_list=[]
allow(ReviewResponseMap).to receive_message_chain(:where, :find_each).with(reviewer_id: 1).with(no_args).and_yield(review_response_map)
allow(review_response_map).to receive(:id).and_return(1)
allow(Response).to receive_message_chain(:where, :last).with(map_id: 1).with(no_args).and_return(response)
allow(response).to receive(:round).and_return(1)
allow(response).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_peer_review_data(1,timeline_list)).to eq([{:id=>1, :label=>"Round 1 peer review", :updated_at=>timevalue}])
end
end
end

# Verifies retrieval of feedback from author
describe "#get_author_feedback_data" do
context 'when no feedback response mapped' do
it 'returns empty' do
timeline_list=[]
StudentTask.get_author_feedback_data(user2,timeline_list)
expect(timeline_list).to eq([])
end
end
context 'when mapped to feedback response map' do
it 'returns timeline array' do
timeline_list=[]
allow(FeedbackResponseMap).to receive_message_chain(:where, :find_each).with(reviewer_id: 1).with(no_args).and_yield(review_response_map)
allow(review_response_map).to receive(:id).and_return(1)
allow(Response).to receive_message_chain(:where, :last).with(map_id: 1).with(no_args).and_return(response)
allow(response).to receive(:updated_at).and_return(Time.now)
timevalue = Time.now.strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_author_feedback_data(1,timeline_list)).to eq([{:id=>1, :label=>"Author feedback", :updated_at=>timevalue}])
end
end
end

# Verrifies retrieval of submission data from submission
describe '#get_submission_data' do
context 'when no submission data mapped' do
it 'returns nil' do
timeline_list=[]
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq(nil)
end
end
context 'when submission data mapped and not submit hyperlink or Remove hyperlink' do
it 'returns timeline_list' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('testing_label')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Testing label", :updated_at=>timevalue}])
end
end
context 'when submission data mapped and operation is submit_hyperlink' do
it 'returns timeline_list with link' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('Submit Hyperlink')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Submit hyperlink", :updated_at=>timevalue, :link=>"www.wolfware.edu"}])
end
end
context 'when submission data mapped and operation is Remove Hyperlink' do
it 'returns timeline_list with link' do
timeline_list=[]
allow(SubmissionRecord).to receive_message_chain(:where, :find_each).with(team_id: 1, assignment_id: 1).with(no_args).and_yield(submission_record)
allow(submission_record).to receive(:operation).and_return('Remove Hyperlink')
timevalue = Time.new(2019).strftime('%a, %d %b %Y %H:%M')
allow(submission_record).to receive(:updated_at).and_return(Time.new(2019))
expect(StudentTask.get_submission_data(1,1,timeline_list)).to eq([{:label=>"Remove hyperlink", :updated_at=>timevalue, :link=>"www.wolfware.edu"}])
end
end
end

# Verifies retrieval of timeline data
describe '#get_timeline_data' do
context 'when no timeline data mapped' do
it 'returns nil' do
allow(participant).to receive(:get_reviewer).and_return(participant)
expect(StudentTask.get_timeline_data(assignment, participant, team)).to eq([])
end
end
end
end

== Line Coverage achieved ==
*94 relevant lines
*86 lines covered
*8 lines missed
*Coverage = 91.49%

== Issues ==
Some of the tests were rather shallow, get_timeline_data specifically needs depth added.

== Useful Links ==
[https://youtu.be/N6H1HtQ4eds/ YouTube Video Demo]

[https://github.com/johnbumgardner/expertiza/ GitHub Repo]

[https://github.com/expertiza/expertiza/pull/1811/ Pull Request]

== Team Members ==
John Bumgardner, Pedro Benitez, Luke McConnaughey

CSC/ECE 517 Fall 2020 - E2055 write unit tests for student task.rb

2020-10-20T03:08:55Z

Lcmcconn: /* Description of the current project */

CSC/ECE 517 Fall 2020 - E2055 write unit tests for student task.rb

2020-10-20T03:07:21Z

Lcmcconn: /* Issues */

CSC/ECE 517 Fall 2020 - E2055 write unit tests for student task.rb

2020-10-20T03:06:31Z

Lcmcconn: /* Line Coverage achieved */