Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T01:20:17Z

Kbyarbor: /* Classes Modified */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Database transactions paired with timestamps and user ids to group them together.

=== Classes Modified ===
*apps/
**controllers/
***application_controller.rb
***assignment_controller.rb
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***sign_up_sheet_controller.rb
***student_team_controller.rb
***team_controller.rb
***teams_users_controller.rb
***versions_controller.rb
**models/
***assignment_participant.rb
***course.rb
***participant.rb
***sign_up_topic.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit & Functional Tests ===
The implementation of the Undo functionality did not afford any testing opportunities applicable to unit or functional tests.

=== Bug Fixes & Other Improvements ===
The following bugs were found within Expertiza and fixed:
*ApplicationController enhanced to rescue from ActiveRecord::RecordNotFound errors and redirect to tree display.
*Copy of Assignment opened Edit page for the original Assignment and now correctly opens the Edit page for the copy of the assignment.

The following general improvements were made:
*Assignment object associated with an AssignmentNode to eliminate the manual deletion of a related AssignmentNode with the code.
*Edited the Copy of Course flash message to be more clear that the copy had already been created and to resolve a misspelling.

=== Problem Areas with Expertiza ===
There were some areas of functionality within Expertiza that did not work. There were some cases in which the undo functionality could not be added due to the inherent problems. These problem areas were:
*Assigning surveys in an assignment.
*Dates in assignments do not show up when the assignment is edited.
*Unable to assign random reviewers.
*Unable to edit advice for questions in questionnaire.
*Unable to remove participants from a course.

=== Future Recommendations ===
*Add integration tests.
*Add undo functionality to other areas of Expertiza.
*Determine appropriate methodology for cleaning up Versions table.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T01:19:17Z

Kbyarbor: /* Unit & Functional Tests */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Database transactions paired with timestamps and user ids to group them together.

=== Classes Modified ===
*apps/
**controllers/
***application_controller.rb
***assignment_controller.rb
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***sign_up_sheet_controller.rb
***student_team_controller.rb
***team_controller.rb
***teams_users_controller.rb
***versions_controller.rb
**models/
***assignment_participant.rb
***participant.rb
***sign_up_topic.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit & Functional Tests ===
The implementation of the Undo functionality did not afford any testing opportunities applicable to unit or functional tests.

=== Bug Fixes & Other Improvements ===
The following bugs were found within Expertiza and fixed:
*ApplicationController enhanced to rescue from ActiveRecord::RecordNotFound errors and redirect to tree display.
*Copy of Assignment opened Edit page for the original Assignment and now correctly opens the Edit page for the copy of the assignment.

The following general improvements were made:
*Assignment object associated with an AssignmentNode to eliminate the manual deletion of a related AssignmentNode with the code.
*Edited the Copy of Course flash message to be more clear that the copy had already been created and to resolve a misspelling.

=== Problem Areas with Expertiza ===
There were some areas of functionality within Expertiza that did not work. There were some cases in which the undo functionality could not be added due to the inherent problems. These problem areas were:
*Assigning surveys in an assignment.
*Dates in assignments do not show up when the assignment is edited.
*Unable to assign random reviewers.
*Unable to edit advice for questions in questionnaire.
*Unable to remove participants from a course.

=== Future Recommendations ===
*Add integration tests.
*Add undo functionality to other areas of Expertiza.
*Determine appropriate methodology for cleaning up Versions table.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T01:09:12Z

Kbyarbor: /* Future Recommendations */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Database transactions paired with timestamps and user ids to group them together.

=== Classes Modified ===
*apps/
**controllers/
***application_controller.rb
***assignment_controller.rb
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***sign_up_sheet_controller.rb
***student_team_controller.rb
***team_controller.rb
***teams_users_controller.rb
***versions_controller.rb
**models/
***assignment_participant.rb
***participant.rb
***sign_up_topic.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit & Functional Tests ===
The implementation of the Undo functionality did not afford any testing opportunities applicable to unit or functional tests.

=== Future Recommendations ===
*Add integration tests.
*Add undo functionality to other areas of Expertiza.
*Determine appropriate methodology for cleaning up Versions table.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T01:04:09Z

Kbyarbor: /* Framework Leveraged & Enhanced */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Database transactions paired with timestamps and user ids to group them together.

=== Classes Modified ===
*apps/
**controllers/
***application_controller.rb
***assignment_controller.rb
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***sign_up_sheet_controller.rb
***student_team_controller.rb
***team_controller.rb
***teams_users_controller.rb
***versions_controller.rb
**models/
***assignment_participant.rb
***participant.rb
***sign_up_topic.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit & Functional Tests ===
The implementation of the Undo functionality did not afford any testing opportunities applicable to unit or functional tests.

=== Future Recommendations ===
*Add integration tests.
*Add undo functionality to other areas of Expertiza.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T01:03:01Z

Kbyarbor: /* Functional Testing Plans */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***application_controller.rb
***assignment_controller.rb
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***sign_up_sheet_controller.rb
***student_team_controller.rb
***team_controller.rb
***teams_users_controller.rb
***versions_controller.rb
**models/
***assignment_participant.rb
***participant.rb
***sign_up_topic.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit & Functional Tests ===
The implementation of the Undo functionality did not afford any testing opportunities applicable to unit or functional tests.

=== Future Recommendations ===
*Add integration tests.
*Add undo functionality to other areas of Expertiza.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T01:01:46Z

Kbyarbor: /* Unit Tests */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***application_controller.rb
***assignment_controller.rb
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***sign_up_sheet_controller.rb
***student_team_controller.rb
***team_controller.rb
***teams_users_controller.rb
***versions_controller.rb
**models/
***assignment_participant.rb
***participant.rb
***sign_up_topic.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit & Functional Tests ===
The implementation of the Undo functionality did not afford any testing opportunities applicable to unit or functional tests.

=== Functional Testing Plans ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T00:59:11Z

Kbyarbor: /* Classes Modified */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***application_controller.rb
***assignment_controller.rb
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***sign_up_sheet_controller.rb
***student_team_controller.rb
***team_controller.rb
***teams_users_controller.rb
***versions_controller.rb
**models/
***assignment_participant.rb
***participant.rb
***sign_up_topic.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit Tests ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

=== Functional Testing Plans ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T00:56:56Z

Kbyarbor: /* Design Patterns and Designs */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***team_controller.rb
***teams_users_controller.rb
**models/
***participant.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit Tests ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

=== Functional Testing Plans ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T00:53:00Z

Kbyarbor: /* Design Patterns and Designs */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***team_controller.rb
***teams_users_controller.rb
**models/
***participant.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit Tests ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

=== Functional Testing Plans ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T00:50:03Z

Kbyarbor: /* List of Items to be Supported by Undo Functionality */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add Participants
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***team_controller.rb
***teams_users_controller.rb
**models/
***participant.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit Tests ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

=== Functional Testing Plans ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-22T00:42:33Z

Kbyarbor: /* Design Document */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Courses
**Create
**Delete
**Edit
*Import
**Import Participants
**Import Teams
**Import Users
*Teams
**Create (Manual)
**Create (Random)
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***team_controller.rb
***teams_users_controller.rb
**models/
***participant.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit Tests ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

=== Functional Testing Plans ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:30:39Z

Kbyarbor: /* Functional Testing Plans */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Courses
**Create
**Delete
**Edit
*Import
**Import Participants
**Import Teams
**Import Users
*Teams
**Create (Manual)
**Create (Random)
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***team_controller.rb
***teams_users_controller.rb
**models/
***participant.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit Tests ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

=== Functional Testing Plans ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:30:06Z

Kbyarbor: /* Unit Testing Plans */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Courses
**Create
**Delete
**Edit
*Import
**Import Participants
**Import Teams
**Import Users
*Teams
**Create (Manual)
**Create (Random)
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***team_controller.rb
***teams_users_controller.rb
**models/
***participant.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit Tests ===
*Modified Tests
**test file
***test method
*New Tests
**test file
***test method

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:28:41Z

Kbyarbor: /* Expected Classes to be Modified */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Courses
**Create
**Delete
**Edit
*Import
**Import Participants
**Import Teams
**Import Users
*Teams
**Create (Manual)
**Create (Random)
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Classes Modified ===
*apps/
**controllers/
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***team_controller.rb
***teams_users_controller.rb
**models/
***participant.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:26:05Z

Kbyarbor: /* Framework Leveraged */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Courses
**Create
**Delete
**Edit
*Import
**Import Participants
**Import Teams
**Import Users
*Teams
**Create (Manual)
**Create (Random)
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Description of modification...

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:23:42Z

Kbyarbor: /* Frameworks to Leverage */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Courses
**Create
**Delete
**Edit
*Import
**Import Participants
**Import Teams
**Import Users
*Teams
**Create (Manual)
**Create (Random)
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Framework Leveraged ===
*Paper Trail(https://github.com/airblade/paper_trail)
**PaperTrail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:23:07Z

Kbyarbor: /* Design Patterns and Designs */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Courses
**Create
**Delete
**Edit
*Import
**Import Participants
**Import Teams
**Import Users
*Teams
**Create (Manual)
**Create (Random)
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through PaperTrail, an open-source Ruby gem leveraged by the project.

=== Frameworks to Leverage ===
*Paper Trail(https://github.com/airblade/paper_trail)
**PaperTrail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
**Alternative Frameworks are listed [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here].

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:22:35Z

Kbyarbor: /* List of Items to be Supported by Undo Functionality */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Courses
**Create
**Delete
**Edit
*Import
**Import Participants
**Import Teams
**Import Users
*Teams
**Create (Manual)
**Create (Random)
**Edit

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice will be followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through open-source Ruby gems leveraged by the project.

=== Frameworks to Leverage ===
*Paper Trail(https://github.com/airblade/paper_trail)
**PaperTrail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
**Alternative Frameworks are listed [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here].

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:22:01Z

Kbyarbor: /* Overview of Undo Functionality */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Assignments
*Courses
*More items may be covered if time allows.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice will be followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through open-source Ruby gems leveraged by the project.

=== Frameworks to Leverage ===
*Paper Trail(https://github.com/airblade/paper_trail)
**PaperTrail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
**Alternative Frameworks are listed [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here].

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:21:02Z

Kbyarbor: /* Overview of Undo Functionality */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo covers the following functionalities:
**Courses
***Create
***Delete
***Edit
**Import
***Import Participants
***Import Teams
***Import Users
**Teams
***Create (Manual)
***Create (Random)
***Edit
*The undo of file submissions was not required; however, we did or did not do these....depends on if we complete it...
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items to be Supported by Undo Functionality ===
*Assignments
*Courses
*More items may be covered if time allows.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice will be followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through open-source Ruby gems leveraged by the project.

=== Frameworks to Leverage ===
*Paper Trail(https://github.com/airblade/paper_trail)
**PaperTrail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
**Alternative Frameworks are listed [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here].

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:12:23Z

Kbyarbor: /* E736. Undo Functionality for Expertiza */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo should cover any edit functionalities and any submissions of links. File submissions do not need to be included for the scope of this project.
*User should be able to undo any changes to an item (such as course or assignment) as long as no other user has edited that same item within the user's current session.
*If undo is attempted on an item already modified by another user, display a message stating why undo cannot be done.

=== List of Items to be Supported by Undo Functionality ===
*Assignments
*Courses
*More items may be covered if time allows.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice will be followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through open-source Ruby gems leveraged by the project.

=== Frameworks to Leverage ===
*Paper Trail(https://github.com/airblade/paper_trail)
**PaperTrail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
**Alternative Frameworks are listed [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here].

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-14T23:11:05Z

Kbyarbor: Created page with "= E736. Undo Functionality for Expertiza = *Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu) *Begin implementing SQL transactions (ActiveRecord:Transac..."

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*Begin implementing SQL transactions (ActiveRecord:Transactions). This should let the user "roll back" any creation or update of a SQL table (assignments, rubrics, etc.) Several issues arise, that you should discuss with me.
**Should students be able to roll back, e.g., submissions or reviews?
**Suppose an instructor is trying to roll back and a TA is editing the same assignment? How can conflicts be presented?
**Do rollbacks affect only what's in the db, or do they also affect submitted files?
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo should cover any edit functionalities and any submissions of links. File submissions do not need to be included for the scope of this project.
*User should be able to undo any changes to an item (such as course or assignment) as long as no other user has edited that same item within the user's current session.
*If undo is attempted on an item already modified by another user, display a message stating why undo cannot be done.

=== List of Items to be Supported by Undo Functionality ===
*Assignments
*Courses
*More items may be covered if time allows.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice will be followed.
*Memento
**The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback). The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change). When using this pattern, care should be taken if the originator may change other objects or resources - the memento pattern operates on a single object. Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.
**The Memento pattern will be followed through open-source Ruby gems leveraged by the project.

=== Frameworks to Leverage ===
*Paper Trail(https://github.com/airblade/paper_trail)
**PaperTrail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
**Alternative Frameworks are listed [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here].

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-04-02T00:44:09Z

Kbyarbor: /* Functional Testing Plans */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*Begin implementing SQL transactions (ActiveRecord:Transactions). This should let the user "roll back" any creation or update of a SQL table (assignments, rubrics, etc.) Several issues arise, that you should discuss with me.
**Should students be able to roll back, e.g., submissions or reviews?
**Suppose an instructor is trying to roll back and a TA is editing the same assignment? How can conflicts be presented?
**Do rollbacks affect only what's in the db, or do they also affect submitted files?

== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Design Document ==

=== Overview of Undo Functionality ===
*Undo should cover any edit functionalities and any submissions of links. File submissions do not need to be included for the scope of this project.
*User should be able to undo any changes to an item (such as course or assignment) as long as no other user has edited that same item within the user's current session.
*If undo is attempted on an item already modified by another user, display a message stating why undo cannot be done.

=== List of Items to be Supported by Undo Functionality ===
*Assignments
*Courses
*More items may be covered if time allows.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice will be followed.
*Memento
**The Memento pattern will be followed through open-source Ruby gems leveraged by the project.

=== Frameworks to Leverage ===
*Paper Trail(https://github.com/airblade/paper_trail)
**PaperTrail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
**Alternative Frameworks are listed [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here].

=== Expected Classes to be Modified ===
*Assignment-related Classes
*Course-related Classes
*More classes may be covered as time allows.

=== Unit Testing Plans ===
*Every class method modified will be tested via unit test.
*Every new method added will be tested via at least one unit test.
*All test methods shall be named with an appropriately descriptive name that is not too long.

=== Functional Testing Plans ===
*The following functional test plans will be followed for all items enhanced with the Undo functionality:
**Test that an item may be changed, then undo performed successfully.
**Test that a sequence of changes may be performed by one user, then undo performed successfully for each action from the sequence.
**Test that an item may be changed by one user, changed again by another user, then undo performed by the original user will display a failure message with description.

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-04-02T00:39:56Z

Kbyarbor: /* Expected Functional Tests to Include */

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-04-02T00:37:49Z

Kbyarbor: /* Expected Unit Tests to Include */

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-04-02T00:35:06Z

Kbyarbor: /* Expected Classes to be Modified */

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-04-02T00:34:45Z

Kbyarbor: /* Expected Classes to be Modified */

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-04-02T00:33:58Z

Kbyarbor: /* Frameworks to Leverage */

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-04-02T00:27:54Z

Kbyarbor: /* Design Patterns and Designs */

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-04-02T00:26:55Z

Kbyarbor: /* List of Items to be Supported by Undo Functionality */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-28T03:39:05Z

Kbyarbor: /* E608. Refactoring and Testing - Course Related Classes */

[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Write-up of This Topic.]
__TOC__

= Expertiza Project =
Expertiza is a web-based class management system. This page will discuss one of its related modification projects conducted in the CSC/ECE 517 Spring 2003 class at North Carolina State University. Learn more about Expertiza by visiting its main page: http://wikis.lib.ncsu.edu/index.php/Expertiza

= E608. Refactoring and Testing - Course Related Classes =
Classes Involved:
*/app/models/course.rb (76 lines)
*/app/models/course_participant.rb (94 lines)
*/app/models/course_team.rb (116 lines)
*/app/models/course_node.rb (95 lines)

What it does:
Involves creation and management of courses in Expertiza

What needs to be done:
*It is not clear what a method named 'create_node' is doing in the 'course' class. Refactor by renaming this method appropriately.
*In the course_team class the import method seems to be doing too many things. See if this method can be broken down into smaller methods with specific functionality.
*The 'get' method in course_node.rb appears to be doing a lot. Refactor this method by breaking it up into smaller methods.
*Look for any unused methods or variables in these files.
*Also apply other refactorings such as Rename variable, Rename method to give the variables and methods more meaningful names.
*Write unit tests for all the methods in each of the listed model classes.

== Changes for /app/models/course.rb ==
The following changes were made:
* Since the method create_node simply creates a course node associated with the newly created or copied course, we replaced its functionality by adding the line CourseNode.create(:node_object_id => course.id) in the course_controller's create method and copy method. The function of getting the CourseNode's parent id is extracted as a class method of CourseNode model since this parent id is independent of the course. With all of its functionalities refactored to other places, this method is hereby removed.
* Added the line "has_many :assigments, :dependent => :destroy" to allow CourseTest.test_destroy unit test to pass.

== Changes for /app/models/course_participant.rb ==
* CourseParticipant.get_parent_name is removed
** This method is never called in the project. Additionally, the method CourseParticipant.get_course_string provides the same functionality as CourseParticipant.get_parent_name, so it was deleted to follow the principle of DRY.

== Changes for /app/models/course_team.rb ==

=== ''import'' Method ===
Functionality: Import a single course team for a course from an input array. The first element in the array is optionally used to specify a name for the team that is being imported.

Usage: The method is used by the import file controller to import course teams to a course.

==== Decomposition ====
The import method can be decomposed into 5 separate parts:

===== Part 1 – Preparation =====

Functionality: Ensure that the array has enough elements and that the class in which the user wants to import the team exists.

if row.length < 2
raise ArgumentError, "Not enough items"
end
course = Course.find(id)
if course == nil
raise ImportError, "The course with id \""+id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
end

===== Part 2 – Naming the New Team =====

Functionality: The method will either import the team name from the array if has_column_name is set to true or generate a new team name if has_column_name is set to false.

if options[:has_column_names] == "true"
name = row[0].to_s.strip
index = 1
else
name = generate_team_name()
index = 0
end

===== Part 3 – Handling Duplicate Team =====

Functionality: If a team with the same team name exists, this part of the method will handle the conflict based on the option handle_duplicate.

currTeam = CourseTeam.find(:first, :conditions => ["name =? and parent_id =?",name,course.id])
if options[:handle_dups] == "ignore" && currTeam != nil
return
end
if currTeam != nil && options[:handle_dups] == "rename"
name = generate_team_name()
currTeam = nil
end
if options[:handle_dups] == "replace" && teams.first != nil
for teamsuser in TeamsUser.find(:all, :conditions => ["team_id =?", currTeam.id])
teamsuser.destroy
end
currTeam.destroy
currTeam = nil
end

===== Part 4 – Create the New Team and Node =====

Functionality: Creates a new team and team node base on the information gathered by the above parts.

if currTeam == nil
currTeam = CourseTeam.new
currTeam.name = name
currTeam.parent_id = course.id
currTeam.save
parent = CourseNode.find_by_node_object_id(course.id)
TeamNode.create(:parent_id => parent.id, :node_object_id => currTeam.id)
end

===== Part 5 – Import the Participants to the New Team =====

Functionality: Verify that the users specified in the array exist, then add the users to the newly created team.

while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user == nil
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
elsif currTeam != nil
currUser = TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", currTeam.id,user.id])
if currUser == nil
currTeam.add_member(user)
end
end
index = index+1
end

==== Refactor ====
From the decomposition, Part 5 can be seen as needing to be separated into its own method.

def import_participants(starting_index, row)
index = starting_index
while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user.nil?
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
else
if TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", id, user.id]).nil?
add_member(user)
end
end
index = index + 1
end
end

From the decomposition, the logic of Part 2 and Part 3 show that they could be simplified. Originally, Part 4 was executed regardless of if the team name was generated or imported. However, if the team name is generated instead of imported, there will not be another team with the same name. Therefore, we extracted Part 4 into its own method and modified the logic of Part 3.

def self.handle_duplicate(name, course_id, handle_dups)
team = find(:first, :conditions => ["name =? and parent_id =?", name, course_id])
if team.nil? #no duplicate
return name
end
if handle_dups == "ignore" #ignore: not create the new team
return nil
end
if handle_dups == "rename" #rename: rename new team
return generate_team_name
end
if handle_dups == "replace" #replace: delete old team
team.delete
return name
end
end

After the modifications to Part 3 and Part 4 are completed, the import method becomes:

if options[:has_column_names] == "true"
name = row[0].to_s.strip
name = handle_duplicate(name, course_id, options[:handle_dups])
index = 1
else
name = generate_team_name
index = 0
end

==== Miscellaneous Changes ====
The condition in Part 1 is incorrect because the number of elements could be less than 2 if the array does not have a team name column.

if (row.length < 2 and options[:has_column_names] == "true") or (row.length < 1 and options[:has_column_names] != "true")
raise ArgumentError, "Not enough items"
end

Part 4 of the method was simplified to improve the readability.

team = CourseTeam.create(:name => name, :parent_id => course_id)
course_node = CourseNode.find_by_node_object_id(course_id)
TeamNode.create(:parent_id => course_node.id, :node_object_id => team.id)

==== Other Issues ====
The input variable session was unused in the method; therefore, it needed to be removed. However, this change was not made in this project due to the way that the method is being called in the import file controller.

=== ''export'' Method ===
==== Functionality Bug ====
Originally, the export method in the CourseTeam class exported the assignment teams that were associated with the course to which a course team belonged. This is not the behavior that one would expect from the export method in the CourseTeam class.

Upon examining the AssignmentTeam class, the export method for CourseTeam was determined to export all of the course teams associated with a course.

def self.export(csv, parent_id, options)
currentCourse = Course.find(parent_id)
currentCourse.teams.each { |team|
tcsv = Array.new
teamUsers = Array.new
tcsv.push(team.name)
if (options["team_name"] == "false")
teamMembers = TeamsUser.find(:all, :conditions => ['team_id = ?', team.id])
teamMembers.each do |user|
teamUsers.push(user.name)
teamUsers.push(" ")
end
tcsv.push(teamUsers)
end
tcsv.push(currentCourse.name)
csv << tcsv
}
end

Note that this is a direct port of code from the source of the export function in the AssignmentTeam class.

The original export function was renamed to export_all_assignment_team_related_to_course to reflect its actual functionality. The function was marked deprecated and if the functionality is later found to be needed, the function should be re-written and moved to the Course class.

==== Analysis and Refactor ====
The part of the export method within the if block is used to export all of the participants of a team. This part can be separated into its own method to reduce the complexity of the export method.

def export_participants
userNames = Array.new
participants = TeamsUser.find(:all, :conditions => ['team_id = ?', self.id])
participants.each do |participant|
userNames.push(participant.name)
userNames.push(" ")
end
return userNames
end

Furthermore, an instance method was added to the CourseTeam class to export the team. The class method export can call the instance method to reduce the complexity and improve the readability.

def export(team_name_only)
output = Array.new
output.push(self.name)
if team_name_only == "false"
output.push(self.export_participants)
end
course = Course.find(self.parent_id)
output.push(course.name)
return output
end

The export function as it looked after refactoring:

def self.export(csv, parent_id, options)
course = Course.find(parent_id)
if course.nil?
raise ImportError, "The course with id \""+course_id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this course?"
end
teams = CourseTeam.find_all_by_parent_id(parent_id)
teams.each do |team|
csv << team.export(options[:team_name])
end
end

==== Other Issues ====
The method name export does not accurately describe the functionality of this method. It is recommended that this method name be changed to export_all. This change was not made due to the export method in the AssignmentTeam class and the way that the method is being called by the export file controller.

The meaning of the option team_name in the method is ambiguous. Upon further examination, it was discovered that the option team_name controls if the method should only export team names without exporting the name of the participants in the team. This option should be renamed to team_name_only for better clarity.

=== ''get_export_fields'' Method ===
Inferring from the code, the get_export_field method seems to return an array that contains the options used for controlling the export method.

As discussed earlier, the team_name option for expert method controls if the export should contain the name of the team participants.

Originally, the get_export_fields method will include the string “team member” if the option team_name is true.

Furthermore, the get_export_fields method is trying to get the value of string(“team_name”) in hash variable options instead of symbol(:team_name).

Here is the method after making the noted changes:

def self.get_export_fields(options)
fields = Array.new
fields.push("Team Name")
if (options[:team_name] == "false")
fields.push("Team members")
end
fields.push("Course Name")
end

=== ''copy'' Method ===
This method is inferred to be used to create a new assignment team and copy all of the participants of the course team to that new assignment team.

If this is later confirmed to be the intended functionality of this method, then this method should belong to AssignmentTeam class instead of CourseTeam class.

This method calls the create_node_object method in Team class, which does not work (explained in a later section) and has an ambiguous return type, functionality, and name.

Logically, the copy method should create a new course team and copy the participants of a team into the new course team.
Currently, this is dead code and not used in the program.

This function was marked deprecated and it is recommended to be removed from the program.

=== ''add_participant'' Method ===
This method is used to add a participant to the course that the course team to which it belongs.

This method is called by the add_member method in the Team class to add a participant to the course when a member is added to a course team.

This method does belong in the Course class and not the CourseTeam class. The Course class already has the method add_participant with similar functionality.

This function was marked deprecated and it is recommended that the function should be removed from the program and the add_member method in the Team class should call the add_participant method from Course class.

== Changes for /app/models/course_node.rb ==
* models/course_node.rb
** The "get" method was improved.
*** Added "get_courses_managed_by_user" method to hold logic extracted from the "get"method.
*** Added "get_course_query_conditions" method to hold logic extracted from the "get" method.
*** Modified any checks on if the user is a teaching assistant to use polymorphism to make the determination.
*** Removed the initial conditional for setting the "conditions" value since the remaining conditions was overwriting the value regardless of how the initial conditional was evaluated.
*** Renaming the "get" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment nodes. As such, a comment was added to explain why the method name should remain.
*** The "sortorder" parameter is given a default value of "ASC" for ascending. This allowed for a related conditional to be removed from the method.
*** The "sortvar" parameter is given a default value of "name" for sorting by course name. This allowed for a related conditional to be removed from the method.
** Renaming the "get_children" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment Nodes. As such, a comment was added to explain why the method name should remain.
** The "get_survey_distribution_id" method was removed after finding it to be dead code.
* models/ta.rb
** Added "is_teaching_assistant?" method to override the inherited method from the User model. This supported usage of polymorphism to determine if the user is a teaching assistant.
* models/user.rb
** Added "is_teaching_assistant?" method to enable usage of polymorphism to determine if the user is a teaching assistant.

== Methods Found That Are Not Currently Being Used ==
The following methods were not found to be used currently by the project, but have been left in the code for potential future usages of the functionality:
* /app/models/course.rb
** Course.get_participant(user_id)
* /app/models/course_participant.rb
** CourseParticipant.copy(assignment_id)
** CourseParticipant.get_parent_name
* /app/models/course_node.rb
** CourseNode.get_modified_date

== Other Observations and Suggestion for Future Work ==
=== Redundant Code in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

The class CourseTeam and AssignmentTeam both inherit from the class Team. However, there are a lot of duplicated functionalities. In order to adhere to the "DRY" principle, the refactoring mentioned earlier for the CourseTeam should be applied to AssignmentTeam and duplicated methods should be extracted to the super-class Team.

=== Naming Inconsistency in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

Participants in a team have many different names in these three classes. For example: member, user, participants. Common vocabulary should be established in order to eliminate confusion.

=== Bugs in Team Class ===
Class: Team

File: team.rb

Method: create_node_object

The create_node_object method in Team class does not work because the class method get_parent_model in both CourseTeam and Assignment team is an instance method and not a class method.

Based on the code of the object and the usage of this code, the method is supposed to create a new course or assignment team along with a new team node and then return the newly created team as output. This function should be deprecated and removed from the class. The functionality should be moved to the new method in the team controller if the functionality is found to be necessary.

=== Inelegance Code in Team Class ===
Class: Team

File: team.rb

Methods: randomize_all_by_parent, check_for_existing, create_node_object, copy_members

These methods uses Object.const_get() with an input string that dynamically locates the object that is associated with different team types (assignment or course); however, the uses of Object.const_get() are inconsistent throughout these methods.

It is recommended that instead of using query methods, such as get_participant_type and get_parent_model, in the assignment and course team to return a string containing the name of the object, these methods should be used to return the object itself. This will eliminate the need for Object.const_get().

== List of New Unit Tests and Testcases ==
The following lists shows new unit files and/or new testcases:
* test/unit/course_node_test.rb (new test file)
** test_get_children_with_show_true_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_true_and_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_nil_order_by_nil
** test_get_name
** test_get_directory
** test_get_creation_date
** test_get_modified_date
** test_get_teams
** test_get_parent_id
* test/unit/course_test.rb (previously existing test file)
** test_get_teams
** test_get_path
** test_get_participants
** test_get_participant
** test_add_participant
** test_copy_participants
* test/unit/course_participant_test.rb (previously existing test file)
** test_get_course_string
** test_import
** test_get_path
** test_export
** test_get_export_field
* test/unit/course_team_test.rb (new test file)
** test_retrieval
** test_import_participants
** test_export_participants
** test_instance_export
** test_handle_duplicate
** test_import
** test_class_export

== List of Modified Unit Tests ==
The following unit test files and/or testcases were modified:
* test/unit/course_test.rb
** The line "fixtures :courses" was changed to "fixtures :courses,:teams,:users,:participants,:assignments,:nodes,:tree_folders".

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO

2013-03-27T03:56:32Z

CSC/ECE 517 Spring 2013/OSS E608

2013-03-21T03:14:32Z

Kbyarbor: /* Other Observations and Suggestion for Future Work */

[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Write-up of This Topic.]
__TOC__

= E608. Refactoring and Testing - Course Related Classes =
Classes Involved:
*/app/models/course.rb (76 lines)
*/app/models/course_participant.rb (94 lines)
*/app/models/course_team.rb (116 lines)
*/app/models/course_node.rb (95 lines)

What it does:
Involves creation and management of courses in Expertiza

What needs to be done:
*It is not clear what a method named 'create_node' is doing in the 'course' class. Refactor by renaming this method appropriately.
*In the course_team class the import method seems to be doing too many things. See if this method can be broken down into smaller methods with specific functionality.
*The 'get' method in course_node.rb appears to be doing a lot. Refactor this method by breaking it up into smaller methods.
*Look for any unused methods or variables in these files.
*Also apply other refactorings such as Rename variable, Rename method to give the variables and methods more meaningful names.
*Write unit tests for all the methods in each of the listed model classes.

== Changes for /app/models/course.rb ==
The following changes were made:
* Since the method create_node simply creates a course node associated with the newly created or copied course, we replaced its functionality by adding the line CourseNode.create(:node_object_id => course.id) in the course_controller's create method and copy method. The function of getting the CourseNode's parent id is extracted as a class method of CourseNode model since this parent id is independent of the course. With all of its functionalities refactored to other places, this method is hereby removed.
* Added the line "has_many :assigments, :dependent => :destroy" to allow CourseTest.test_destroy unit test to pass.

== Changes for /app/models/course_participant.rb ==
* CourseParticipant.get_parent_name is removed
** This method is never called in the project. Additionally, the method CourseParticipant.get_course_string provides the same functionality as CourseParticipant.get_parent_name, so it was deleted to follow the principle of DRY.

== Changes for /app/models/course_team.rb ==

=== ''import'' Method ===
Functionality: Import a single course team for a course from an input array. The first element in the array is optionally used to specify a name for the team that is being imported.

Usage: The method is used by the import file controller to import course teams to a course.

==== Decomposition ====
The import method can be decomposed into 5 separate parts:

===== Part 1 – Preparation =====

Functionality: Ensure that the array has enough elements and that the class in which the user wants to import the team exists.

if row.length < 2
raise ArgumentError, "Not enough items"
end
course = Course.find(id)
if course == nil
raise ImportError, "The course with id \""+id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
end

===== Part 2 – Naming the New Team =====

Functionality: The method will either import the team name from the array if has_column_name is set to true or generate a new team name if has_column_name is set to false.

if options[:has_column_names] == "true"
name = row[0].to_s.strip
index = 1
else
name = generate_team_name()
index = 0
end

===== Part 3 – Handling Duplicate Team =====

Functionality: If a team with the same team name exists, this part of the method will handle the conflict based on the option handle_duplicate.

currTeam = CourseTeam.find(:first, :conditions => ["name =? and parent_id =?",name,course.id])
if options[:handle_dups] == "ignore" && currTeam != nil
return
end
if currTeam != nil && options[:handle_dups] == "rename"
name = generate_team_name()
currTeam = nil
end
if options[:handle_dups] == "replace" && teams.first != nil
for teamsuser in TeamsUser.find(:all, :conditions => ["team_id =?", currTeam.id])
teamsuser.destroy
end
currTeam.destroy
currTeam = nil
end

===== Part 4 – Create the New Team and Node =====

Functionality: Creates a new team and team node base on the information gathered by the above parts.

if currTeam == nil
currTeam = CourseTeam.new
currTeam.name = name
currTeam.parent_id = course.id
currTeam.save
parent = CourseNode.find_by_node_object_id(course.id)
TeamNode.create(:parent_id => parent.id, :node_object_id => currTeam.id)
end

===== Part 5 – Import the Participants to the New Team =====

Functionality: Verify that the users specified in the array exist, then add the users to the newly created team.

while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user == nil
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
elsif currTeam != nil
currUser = TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", currTeam.id,user.id])
if currUser == nil
currTeam.add_member(user)
end
end
index = index+1
end

==== Refactor ====
From the decomposition, Part 5 can be seen as needing to be separated into its own method.

def import_participants(starting_index, row)
index = starting_index
while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user.nil?
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
else
if TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", id, user.id]).nil?
add_member(user)
end
end
index = index + 1
end
end

From the decomposition, the logic of Part 2 and Part 3 show that they could be simplified. Originally, Part 4 was executed regardless of if the team name was generated or imported. However, if the team name is generated instead of imported, there will not be another team with the same name. Therefore, we extracted Part 4 into its own method and modified the logic of Part 3.

def self.handle_duplicate(name, course_id, handle_dups)
team = find(:first, :conditions => ["name =? and parent_id =?", name, course_id])
if team.nil? #no duplicate
return name
end
if handle_dups == "ignore" #ignore: not create the new team
return nil
end
if handle_dups == "rename" #rename: rename new team
return generate_team_name
end
if handle_dups == "replace" #replace: delete old team
team.delete
return name
end
end

After the modifications to Part 3 and Part 4 are completed, the import method becomes:

if options[:has_column_names] == "true"
name = row[0].to_s.strip
name = handle_duplicate(name, course_id, options[:handle_dups])
index = 1
else
name = generate_team_name
index = 0
end

==== Miscellaneous Changes ====
The condition in Part 1 is incorrect because the number of elements could be less than 2 if the array does not have a team name column.

if (row.length < 2 and options[:has_column_names] == "true") or (row.length < 1 and options[:has_column_names] != "true")
raise ArgumentError, "Not enough items"
end

Part 4 of the method was simplified to improve the readability.

team = CourseTeam.create(:name => name, :parent_id => course_id)
course_node = CourseNode.find_by_node_object_id(course_id)
TeamNode.create(:parent_id => course_node.id, :node_object_id => team.id)

==== Other Issues ====
The input variable session was unused in the method; therefore, it needed to be removed. However, this change was not made in this project due to the way that the method is being called in the import file controller.

=== ''export'' Method ===
==== Functionality Bug ====
Originally, the export method in the CourseTeam class exported the assignment teams that were associated with the course to which a course team belonged. This is not the behavior that one would expect from the export method in the CourseTeam class.

Upon examining the AssignmentTeam class, the export method for CourseTeam was determined to export all of the course teams associated with a course.

def self.export(csv, parent_id, options)
currentCourse = Course.find(parent_id)
currentCourse.teams.each { |team|
tcsv = Array.new
teamUsers = Array.new
tcsv.push(team.name)
if (options["team_name"] == "false")
teamMembers = TeamsUser.find(:all, :conditions => ['team_id = ?', team.id])
teamMembers.each do |user|
teamUsers.push(user.name)
teamUsers.push(" ")
end
tcsv.push(teamUsers)
end
tcsv.push(currentCourse.name)
csv << tcsv
}
end

Note that this is a direct port of code from the source of the export function in the AssignmentTeam class.

The original export function was renamed to export_all_assignment_team_related_to_course to reflect its actual functionality. The function was marked deprecated and if the functionality is later found to be needed, the function should be re-written and moved to the Course class.

==== Analysis and Refactor ====
The part of the export method within the if block is used to export all of the participants of a team. This part can be separated into its own method to reduce the complexity of the export method.

def export_participants
userNames = Array.new
participants = TeamsUser.find(:all, :conditions => ['team_id = ?', self.id])
participants.each do |participant|
userNames.push(participant.name)
userNames.push(" ")
end
return userNames
end

Furthermore, an instance method was added to the CourseTeam class to export the team. The class method export can call the instance method to reduce the complexity and improve the readability.

def export(team_name_only)
output = Array.new
output.push(self.name)
if team_name_only == "false"
output.push(self.export_participants)
end
course = Course.find(self.parent_id)
output.push(course.name)
return output
end

The export function as it looked after refactoring:

def self.export(csv, parent_id, options)
course = Course.find(parent_id)
if course.nil?
raise ImportError, "The course with id \""+course_id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this course?"
end
teams = CourseTeam.find_all_by_parent_id(parent_id)
teams.each do |team|
csv << team.export(options[:team_name])
end
end

==== Other Issues ====
The method name export does not accurately describe the functionality of this method. It is recommended that this method name be changed to export_all. This change was not made due to the export method in the AssignmentTeam class and the way that the method is being called by the export file controller.

The meaning of the option team_name in the method is ambiguous. Upon further examination, it was discovered that the option team_name controls if the method should only export team names without exporting the name of the participants in the team. This option should be renamed to team_name_only for better clarity.

=== ''get_export_fields'' Method ===
Inferring from the code, the get_export_field method seems to return an array that contains the options used for controlling the export method.

As discussed earlier, the team_name option for expert method controls if the export should contain the name of the team participants.

Originally, the get_export_fields method will include the string “team member” if the option team_name is true.

Furthermore, the get_export_fields method is trying to get the value of string(“team_name”) in hash variable options instead of symbol(:team_name).

Here is the method after making the noted changes:

def self.get_export_fields(options)
fields = Array.new
fields.push("Team Name")
if (options[:team_name] == "false")
fields.push("Team members")
end
fields.push("Course Name")
end

=== ''copy'' Method ===
This method is inferred to be used to create a new assignment team and copy all of the participants of the course team to that new assignment team.

If this is later confirmed to be the intended functionality of this method, then this method should belong to AssignmentTeam class instead of CourseTeam class.

This method calls the create_node_object method in Team class, which does not work (explained in a later section) and has an ambiguous return type, functionality, and name.

Logically, the copy method should create a new course team and copy the participants of a team into the new course team.
Currently, this is dead code and not used in the program.

This function was marked deprecated and it is recommended to be removed from the program.

=== ''add_participant'' Method ===
This method is used to add a participant to the course that the course team to which it belongs.

This method is called by the add_member method in the Team class to add a participant to the course when a member is added to a course team.

This method does belong in the Course class and not the CourseTeam class. The Course class already has the method add_participant with similar functionality.

This function was marked deprecated and it is recommended that the function should be removed from the program and the add_member method in the Team class should call the add_participant method from Course class.

== Changes for /app/models/course_node.rb ==
* models/course_node.rb
** The "get" method was improved.
*** Added "get_courses_managed_by_user" method to hold logic extracted from the "get"method.
*** Added "get_course_query_conditions" method to hold logic extracted from the "get" method.
*** Modified any checks on if the user is a teaching assistant to use polymorphism to make the determination.
*** Removed the initial conditional for setting the "conditions" value since the remaining conditions was overwriting the value regardless of how the initial conditional was evaluated.
*** Renaming the "get" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment nodes. As such, a comment was added to explain why the method name should remain.
*** The "sortorder" parameter is given a default value of "ASC" for ascending. This allowed for a related conditional to be removed from the method.
*** The "sortvar" parameter is given a default value of "name" for sorting by course name. This allowed for a related conditional to be removed from the method.
** Renaming the "get_children" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment Nodes. As such, a comment was added to explain why the method name should remain.
** The "get_survey_distribution_id" method was removed after finding it to be dead code.
* models/ta.rb
** Added "is_teaching_assistant?" method to override the inherited method from the User model. This supported usage of polymorphism to determine if the user is a teaching assistant.
* models/user.rb
** Added "is_teaching_assistant?" method to enable usage of polymorphism to determine if the user is a teaching assistant.

== Methods Found That Are Not Currently Being Used ==
The following methods were not found to be used currently by the project, but have been left in the code for potential future usages of the functionality:
* /app/models/course.rb
** Course.get_participant(user_id)
* /app/models/course_participant.rb
** CourseParticipant.copy(assignment_id)
** CourseParticipant.get_parent_name
* /app/models/course_node.rb
** CourseNode.get_modified_date

== Other Observations and Suggestion for Future Work ==
=== Redundant Code in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

The class CourseTeam and AssignmentTeam both inherit from the class Team. However, there are a lot of duplicated functionalities. In order to adhere to the "DRY" principle, the refactoring mentioned earlier for the CourseTeam should be applied to AssignmentTeam and duplicated methods should be extracted to the super-class Team.

=== Naming Inconsistency in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

Participants in a team have many different names in these three classes. For example: member, user, participants. Common vocabulary should be established in order to eliminate confusion.

=== Bugs in Team Class ===
Class: Team

File: team.rb

Method: create_node_object

The create_node_object method in Team class does not work because the class method get_parent_model in both CourseTeam and Assignment team is an instance method and not a class method.

Based on the code of the object and the usage of this code, the method is supposed to create a new course or assignment team along with a new team node and then return the newly created team as output. This function should be deprecated and removed from the class. The functionality should be moved to the new method in the team controller if the functionality is found to be necessary.

=== Inelegance Code in Team Class ===
Class: Team

File: team.rb

Methods: randomize_all_by_parent, check_for_existing, create_node_object, copy_members

These methods uses Object.const_get() with an input string that dynamically locates the object that is associated with different team types (assignment or course); however, the uses of Object.const_get() are inconsistent throughout these methods.

It is recommended that instead of using query methods, such as get_participant_type and get_parent_model, in the assignment and course team to return a string containing the name of the object, these methods should be used to return the object itself. This will eliminate the need for Object.const_get().

== List of New Unit Tests and Testcases ==
The following lists shows new unit files and/or new testcases:
* test/unit/course_node_test.rb (new test file)
** test_get_children_with_show_true_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_true_and_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_nil_order_by_nil
** test_get_name
** test_get_directory
** test_get_creation_date
** test_get_modified_date
** test_get_teams
** test_get_parent_id
* test/unit/course_test.rb (previously existing test file)
** test_get_teams
** test_get_path
** test_get_participants
** test_get_participant
** test_add_participant
** test_copy_participants
* test/unit/course_participant_test.rb (previously existing test file)
** test_get_course_string
** test_import
** test_get_path
** test_export
** test_get_export_field
* test/unit/course_team_test.rb (new test file)
** test_retrieval
** test_import_participants
** test_export_participants
** test_instance_export
** test_handle_duplicate
** test_import
** test_class_export

== List of Modified Unit Tests ==
The following unit test files and/or testcases were modified:
* test/unit/course_test.rb
** The line "fixtures :courses" was changed to "fixtures :courses,:teams,:users,:participants,:assignments,:nodes,:tree_folders".

CSC/ECE 517 Spring 2013/OSS E608

2013-03-21T03:07:00Z

Kbyarbor: /* Miscellaneous Changes for Quality Improvement and Readability */

[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Write-up of This Topic.]
__TOC__

= E608. Refactoring and Testing - Course Related Classes =
Classes Involved:
*/app/models/course.rb (76 lines)
*/app/models/course_participant.rb (94 lines)
*/app/models/course_team.rb (116 lines)
*/app/models/course_node.rb (95 lines)

What it does:
Involves creation and management of courses in Expertiza

What needs to be done:
*It is not clear what a method named 'create_node' is doing in the 'course' class. Refactor by renaming this method appropriately.
*In the course_team class the import method seems to be doing too many things. See if this method can be broken down into smaller methods with specific functionality.
*The 'get' method in course_node.rb appears to be doing a lot. Refactor this method by breaking it up into smaller methods.
*Look for any unused methods or variables in these files.
*Also apply other refactorings such as Rename variable, Rename method to give the variables and methods more meaningful names.
*Write unit tests for all the methods in each of the listed model classes.

== Changes for /app/models/course.rb ==
The following changes were made:
* Since the method create_node simply creates a course node associated with the newly created or copied course, we replaced its functionality by adding the line CourseNode.create(:node_object_id => course.id) in the course_controller's create method and copy method. The function of getting the CourseNode's parent id is extracted as a class method of CourseNode model since this parent id is independent of the course. With all of its functionalities refactored to other places, this method is hereby removed.
* Added the line "has_many :assigments, :dependent => :destroy" to allow CourseTest.test_destroy unit test to pass.

== Changes for /app/models/course_participant.rb ==
* CourseParticipant.get_parent_name is removed
** This method is never called in the project. Additionally, the method CourseParticipant.get_course_string provides the same functionality as CourseParticipant.get_parent_name, so it was deleted to follow the principle of DRY.

== Changes for /app/models/course_team.rb ==

=== ''import'' Method ===
Functionality: Import a single course team for a course from an input array. The first element in the array is optionally used to specify a name for the team that is being imported.

Usage: The method is used by the import file controller to import course teams to a course.

==== Decomposition ====
The import method can be decomposed into 5 separate parts:

===== Part 1 – Preparation =====

Functionality: Ensure that the array has enough elements and that the class in which the user wants to import the team exists.

if row.length < 2
raise ArgumentError, "Not enough items"
end
course = Course.find(id)
if course == nil
raise ImportError, "The course with id \""+id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
end

===== Part 2 – Naming the New Team =====

Functionality: The method will either import the team name from the array if has_column_name is set to true or generate a new team name if has_column_name is set to false.

if options[:has_column_names] == "true"
name = row[0].to_s.strip
index = 1
else
name = generate_team_name()
index = 0
end

===== Part 3 – Handling Duplicate Team =====

Functionality: If a team with the same team name exists, this part of the method will handle the conflict based on the option handle_duplicate.

currTeam = CourseTeam.find(:first, :conditions => ["name =? and parent_id =?",name,course.id])
if options[:handle_dups] == "ignore" && currTeam != nil
return
end
if currTeam != nil && options[:handle_dups] == "rename"
name = generate_team_name()
currTeam = nil
end
if options[:handle_dups] == "replace" && teams.first != nil
for teamsuser in TeamsUser.find(:all, :conditions => ["team_id =?", currTeam.id])
teamsuser.destroy
end
currTeam.destroy
currTeam = nil
end

===== Part 4 – Create the New Team and Node =====

Functionality: Creates a new team and team node base on the information gathered by the above parts.

if currTeam == nil
currTeam = CourseTeam.new
currTeam.name = name
currTeam.parent_id = course.id
currTeam.save
parent = CourseNode.find_by_node_object_id(course.id)
TeamNode.create(:parent_id => parent.id, :node_object_id => currTeam.id)
end

===== Part 5 – Import the Participants to the New Team =====

Functionality: Verify that the users specified in the array exist, then add the users to the newly created team.

while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user == nil
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
elsif currTeam != nil
currUser = TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", currTeam.id,user.id])
if currUser == nil
currTeam.add_member(user)
end
end
index = index+1
end

==== Refactor ====
From the decomposition, Part 5 can be seen as needing to be separated into its own method.

def import_participants(starting_index, row)
index = starting_index
while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user.nil?
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
else
if TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", id, user.id]).nil?
add_member(user)
end
end
index = index + 1
end
end

From the decomposition, the logic of Part 2 and Part 3 show that they could be simplified. Originally, Part 4 was executed regardless of if the team name was generated or imported. However, if the team name is generated instead of imported, there will not be another team with the same name. Therefore, we extracted Part 4 into its own method and modified the logic of Part 3.

def self.handle_duplicate(name, course_id, handle_dups)
team = find(:first, :conditions => ["name =? and parent_id =?", name, course_id])
if team.nil? #no duplicate
return name
end
if handle_dups == "ignore" #ignore: not create the new team
return nil
end
if handle_dups == "rename" #rename: rename new team
return generate_team_name
end
if handle_dups == "replace" #replace: delete old team
team.delete
return name
end
end

After the modifications to Part 3 and Part 4 are completed, the import method becomes:

if options[:has_column_names] == "true"
name = row[0].to_s.strip
name = handle_duplicate(name, course_id, options[:handle_dups])
index = 1
else
name = generate_team_name
index = 0
end

==== Miscellaneous Changes ====
The condition in Part 1 is incorrect because the number of elements could be less than 2 if the array does not have a team name column.

if (row.length < 2 and options[:has_column_names] == "true") or (row.length < 1 and options[:has_column_names] != "true")
raise ArgumentError, "Not enough items"
end

Part 4 of the method was simplified to improve the readability.

team = CourseTeam.create(:name => name, :parent_id => course_id)
course_node = CourseNode.find_by_node_object_id(course_id)
TeamNode.create(:parent_id => course_node.id, :node_object_id => team.id)

==== Other Issues ====
The input variable session was unused in the method; therefore, it needed to be removed. However, this change was not made in this project due to the way that the method is being called in the import file controller.

=== ''export'' Method ===
==== Functionality Bug ====
Originally, the export method in the CourseTeam class exported the assignment teams that were associated with the course to which a course team belonged. This is not the behavior that one would expect from the export method in the CourseTeam class.

Upon examining the AssignmentTeam class, the export method for CourseTeam was determined to export all of the course teams associated with a course.

def self.export(csv, parent_id, options)
currentCourse = Course.find(parent_id)
currentCourse.teams.each { |team|
tcsv = Array.new
teamUsers = Array.new
tcsv.push(team.name)
if (options["team_name"] == "false")
teamMembers = TeamsUser.find(:all, :conditions => ['team_id = ?', team.id])
teamMembers.each do |user|
teamUsers.push(user.name)
teamUsers.push(" ")
end
tcsv.push(teamUsers)
end
tcsv.push(currentCourse.name)
csv << tcsv
}
end

Note that this is a direct port of code from the source of the export function in the AssignmentTeam class.

The original export function was renamed to export_all_assignment_team_related_to_course to reflect its actual functionality. The function was marked deprecated and if the functionality is later found to be needed, the function should be re-written and moved to the Course class.

==== Analysis and Refactor ====
The part of the export method within the if block is used to export all of the participants of a team. This part can be separated into its own method to reduce the complexity of the export method.

def export_participants
userNames = Array.new
participants = TeamsUser.find(:all, :conditions => ['team_id = ?', self.id])
participants.each do |participant|
userNames.push(participant.name)
userNames.push(" ")
end
return userNames
end

Furthermore, an instance method was added to the CourseTeam class to export the team. The class method export can call the instance method to reduce the complexity and improve the readability.

def export(team_name_only)
output = Array.new
output.push(self.name)
if team_name_only == "false"
output.push(self.export_participants)
end
course = Course.find(self.parent_id)
output.push(course.name)
return output
end

The export function as it looked after refactoring:

def self.export(csv, parent_id, options)
course = Course.find(parent_id)
if course.nil?
raise ImportError, "The course with id \""+course_id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this course?"
end
teams = CourseTeam.find_all_by_parent_id(parent_id)
teams.each do |team|
csv << team.export(options[:team_name])
end
end

==== Other Issues ====
The method name export does not accurately describe the functionality of this method. It is recommended that this method name be changed to export_all. This change was not made due to the export method in the AssignmentTeam class and the way that the method is being called by the export file controller.

The meaning of the option team_name in the method is ambiguous. Upon further examination, it was discovered that the option team_name controls if the method should only export team names without exporting the name of the participants in the team. This option should be renamed to team_name_only for better clarity.

=== ''get_export_fields'' Method ===
Inferring from the code, the get_export_field method seems to return an array that contains the options used for controlling the export method.

As discussed earlier, the team_name option for expert method controls if the export should contain the name of the team participants.

Originally, the get_export_fields method will include the string “team member” if the option team_name is true.

Furthermore, the get_export_fields method is trying to get the value of string(“team_name”) in hash variable options instead of symbol(:team_name).

Here is the method after making the noted changes:

def self.get_export_fields(options)
fields = Array.new
fields.push("Team Name")
if (options[:team_name] == "false")
fields.push("Team members")
end
fields.push("Course Name")
end

=== ''copy'' Method ===
This method is inferred to be used to create a new assignment team and copy all of the participants of the course team to that new assignment team.

If this is later confirmed to be the intended functionality of this method, then this method should belong to AssignmentTeam class instead of CourseTeam class.

This method calls the create_node_object method in Team class, which does not work (explained in a later section) and has an ambiguous return type, functionality, and name.

Logically, the copy method should create a new course team and copy the participants of a team into the new course team.
Currently, this is dead code and not used in the program.

This function was marked deprecated and it is recommended to be removed from the program.

=== ''add_participant'' Method ===
This method is used to add a participant to the course that the course team to which it belongs.

This method is called by the add_member method in the Team class to add a participant to the course when a member is added to a course team.

This method does belong in the Course class and not the CourseTeam class. The Course class already has the method add_participant with similar functionality.

This function was marked deprecated and it is recommended that the function should be removed from the program and the add_member method in the Team class should call the add_participant method from Course class.

== Changes for /app/models/course_node.rb ==
* models/course_node.rb
** The "get" method was improved.
*** Added "get_courses_managed_by_user" method to hold logic extracted from the "get"method.
*** Added "get_course_query_conditions" method to hold logic extracted from the "get" method.
*** Modified any checks on if the user is a teaching assistant to use polymorphism to make the determination.
*** Removed the initial conditional for setting the "conditions" value since the remaining conditions was overwriting the value regardless of how the initial conditional was evaluated.
*** Renaming the "get" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment nodes. As such, a comment was added to explain why the method name should remain.
*** The "sortorder" parameter is given a default value of "ASC" for ascending. This allowed for a related conditional to be removed from the method.
*** The "sortvar" parameter is given a default value of "name" for sorting by course name. This allowed for a related conditional to be removed from the method.
** Renaming the "get_children" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment Nodes. As such, a comment was added to explain why the method name should remain.
** The "get_survey_distribution_id" method was removed after finding it to be dead code.
* models/ta.rb
** Added "is_teaching_assistant?" method to override the inherited method from the User model. This supported usage of polymorphism to determine if the user is a teaching assistant.
* models/user.rb
** Added "is_teaching_assistant?" method to enable usage of polymorphism to determine if the user is a teaching assistant.

== Methods Found That Are Not Currently Being Used ==
The following methods were not found to be used currently by the project, but have been left in the code for potential future usages of the functionality:
* /app/models/course.rb
** Course.get_participant(user_id)
* /app/models/course_participant.rb
** CourseParticipant.copy(assignment_id)
** CourseParticipant.get_parent_name
* /app/models/course_node.rb
** CourseNode.get_modified_date

== Other Observations and Suggestion for Future Work ==
=== Redundant Code in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

The class CourseTeam and AssignmentTeam both inherits from the class Team. However that are a lot of duplicated functionalities in order to adhere to the "DRY" principle refactor for the CourseTeam mentioned in this document should be applied to AssignmentTeam and duplicated methods should be extracted to the super-class Team.

=== Naming Inconsistency in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

Participant in a team have many different names in these three classes. For example: member, user, participants. Common vocabulary should be established in-order to eliminate confusion.

=== Bugs in Team Class ===
Class: Team

File: team.rb

Method: create_node_object

The create_node_object method in Team class does not work because the class method get_parent_model in both CourseTeam and Assignment team is an instance method not a class method.

From the code of the object and the usage of this code we inferred that the method supposed to create a new course or assignment team and a new team node and return the newly created team as output.
This function should be deprecated and removed from the class, the functionality should be move to the new method in the team controller if the functionality is truly necessary.

=== Inelegance Code in Team Class ===
Class: Team

File: team.rb

Methods: randomize_all_by_parent, check_for_existing, create_node_object, copy_members

These methods uses Object.const_get() with a input string that dynamically locate the object that are associated with different team types (assignment or course) however the use of Object.const_get() are inconsistent throughout these methods.

We suggests instead of using query methods such as get_participant_type and get_parent_model in the assignment and course team return string containing the name of the object we can use these method to return the object itself thus eliminating the need for Object.const_get().

== List of New Unit Tests and Testcases ==
The following lists shows new unit files and/or new testcases:
* test/unit/course_node_test.rb (new test file)
** test_get_children_with_show_true_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_true_and_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_nil_order_by_nil
** test_get_name
** test_get_directory
** test_get_creation_date
** test_get_modified_date
** test_get_teams
** test_get_parent_id
* test/unit/course_test.rb (previously existing test file)
** test_get_teams
** test_get_path
** test_get_participants
** test_get_participant
** test_add_participant
** test_copy_participants
* test/unit/course_participant_test.rb (previously existing test file)
** test_get_course_string
** test_import
** test_get_path
** test_export
** test_get_export_field
* test/unit/course_team_test.rb (new test file)
** test_retrieval
** test_import_participants
** test_export_participants
** test_instance_export
** test_handle_duplicate
** test_import
** test_class_export

== List of Modified Unit Tests ==
The following unit test files and/or testcases were modified:
* test/unit/course_test.rb
** The line "fixtures :courses" was changed to "fixtures :courses,:teams,:users,:participants,:assignments,:nodes,:tree_folders".

CSC/ECE 517 Spring 2013/OSS E608

2013-03-21T03:05:25Z

Kbyarbor: /* E608. Refactoring and Testing - Course Related Classes */

[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Write-up of This Topic.]
__TOC__

= E608. Refactoring and Testing - Course Related Classes =
Classes Involved:
*/app/models/course.rb (76 lines)
*/app/models/course_participant.rb (94 lines)
*/app/models/course_team.rb (116 lines)
*/app/models/course_node.rb (95 lines)

What it does:
Involves creation and management of courses in Expertiza

What needs to be done:
*It is not clear what a method named 'create_node' is doing in the 'course' class. Refactor by renaming this method appropriately.
*In the course_team class the import method seems to be doing too many things. See if this method can be broken down into smaller methods with specific functionality.
*The 'get' method in course_node.rb appears to be doing a lot. Refactor this method by breaking it up into smaller methods.
*Look for any unused methods or variables in these files.
*Also apply other refactorings such as Rename variable, Rename method to give the variables and methods more meaningful names.
*Write unit tests for all the methods in each of the listed model classes.

== Changes for /app/models/course.rb ==
The following changes were made:
* Since the method create_node simply creates a course node associated with the newly created or copied course, we replaced its functionality by adding the line CourseNode.create(:node_object_id => course.id) in the course_controller's create method and copy method. The function of getting the CourseNode's parent id is extracted as a class method of CourseNode model since this parent id is independent of the course. With all of its functionalities refactored to other places, this method is hereby removed.
* Added the line "has_many :assigments, :dependent => :destroy" to allow CourseTest.test_destroy unit test to pass.

== Changes for /app/models/course_participant.rb ==
* CourseParticipant.get_parent_name is removed
** This method is never called in the project. Additionally, the method CourseParticipant.get_course_string provides the same functionality as CourseParticipant.get_parent_name, so it was deleted to follow the principle of DRY.

== Changes for /app/models/course_team.rb ==

=== ''import'' Method ===
Functionality: Import a single course team for a course from an input array. The first element in the array is optionally used to specify a name for the team that is being imported.

Usage: The method is used by the import file controller to import course teams to a course.

==== Decomposition ====
The import method can be decomposed into 5 separate parts:

===== Part 1 – Preparation =====

Functionality: Ensure that the array has enough elements and that the class in which the user wants to import the team exists.

if row.length < 2
raise ArgumentError, "Not enough items"
end
course = Course.find(id)
if course == nil
raise ImportError, "The course with id \""+id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
end

===== Part 2 – Naming the New Team =====

Functionality: The method will either import the team name from the array if has_column_name is set to true or generate a new team name if has_column_name is set to false.

if options[:has_column_names] == "true"
name = row[0].to_s.strip
index = 1
else
name = generate_team_name()
index = 0
end

===== Part 3 – Handling Duplicate Team =====

Functionality: If a team with the same team name exists, this part of the method will handle the conflict based on the option handle_duplicate.

currTeam = CourseTeam.find(:first, :conditions => ["name =? and parent_id =?",name,course.id])
if options[:handle_dups] == "ignore" && currTeam != nil
return
end
if currTeam != nil && options[:handle_dups] == "rename"
name = generate_team_name()
currTeam = nil
end
if options[:handle_dups] == "replace" && teams.first != nil
for teamsuser in TeamsUser.find(:all, :conditions => ["team_id =?", currTeam.id])
teamsuser.destroy
end
currTeam.destroy
currTeam = nil
end

===== Part 4 – Create the New Team and Node =====

Functionality: Creates a new team and team node base on the information gathered by the above parts.

if currTeam == nil
currTeam = CourseTeam.new
currTeam.name = name
currTeam.parent_id = course.id
currTeam.save
parent = CourseNode.find_by_node_object_id(course.id)
TeamNode.create(:parent_id => parent.id, :node_object_id => currTeam.id)
end

===== Part 5 – Import the Participants to the New Team =====

Functionality: Verify that the users specified in the array exist, then add the users to the newly created team.

while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user == nil
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
elsif currTeam != nil
currUser = TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", currTeam.id,user.id])
if currUser == nil
currTeam.add_member(user)
end
end
index = index+1
end

==== Refactor ====
From the decomposition, Part 5 can be seen as needing to be separated into its own method.

def import_participants(starting_index, row)
index = starting_index
while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user.nil?
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
else
if TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", id, user.id]).nil?
add_member(user)
end
end
index = index + 1
end
end

From the decomposition, the logic of Part 2 and Part 3 show that they could be simplified. Originally, Part 4 was executed regardless of if the team name was generated or imported. However, if the team name is generated instead of imported, there will not be another team with the same name. Therefore, we extracted Part 4 into its own method and modified the logic of Part 3.

def self.handle_duplicate(name, course_id, handle_dups)
team = find(:first, :conditions => ["name =? and parent_id =?", name, course_id])
if team.nil? #no duplicate
return name
end
if handle_dups == "ignore" #ignore: not create the new team
return nil
end
if handle_dups == "rename" #rename: rename new team
return generate_team_name
end
if handle_dups == "replace" #replace: delete old team
team.delete
return name
end
end

After the modifications to Part 3 and Part 4 are completed, the import method becomes:

if options[:has_column_names] == "true"
name = row[0].to_s.strip
name = handle_duplicate(name, course_id, options[:handle_dups])
index = 1
else
name = generate_team_name
index = 0
end

==== Miscellaneous Changes ====
The condition in Part 1 is incorrect because the number of elements could be less than 2 if the array does not have a team name column.

if (row.length < 2 and options[:has_column_names] == "true") or (row.length < 1 and options[:has_column_names] != "true")
raise ArgumentError, "Not enough items"
end

Part 4 of the method was simplified to improve the readability.

team = CourseTeam.create(:name => name, :parent_id => course_id)
course_node = CourseNode.find_by_node_object_id(course_id)
TeamNode.create(:parent_id => course_node.id, :node_object_id => team.id)

==== Other Issues ====
The input variable session was unused in the method; therefore, it needed to be removed. However, this change was not made in this project due to the way that the method is being called in the import file controller.

=== ''export'' Method ===
==== Functionality Bug ====
Originally, the export method in the CourseTeam class exported the assignment teams that were associated with the course to which a course team belonged. This is not the behavior that one would expect from the export method in the CourseTeam class.

Upon examining the AssignmentTeam class, the export method for CourseTeam was determined to export all of the course teams associated with a course.

def self.export(csv, parent_id, options)
currentCourse = Course.find(parent_id)
currentCourse.teams.each { |team|
tcsv = Array.new
teamUsers = Array.new
tcsv.push(team.name)
if (options["team_name"] == "false")
teamMembers = TeamsUser.find(:all, :conditions => ['team_id = ?', team.id])
teamMembers.each do |user|
teamUsers.push(user.name)
teamUsers.push(" ")
end
tcsv.push(teamUsers)
end
tcsv.push(currentCourse.name)
csv << tcsv
}
end

Note that this is a direct port of code from the source of the export function in the AssignmentTeam class.

The original export function was renamed to export_all_assignment_team_related_to_course to reflect its actual functionality. The function was marked deprecated and if the functionality is later found to be needed, the function should be re-written and moved to the Course class.

==== Analysis and Refactor ====
The part of the export method within the if block is used to export all of the participants of a team. This part can be separated into its own method to reduce the complexity of the export method.

def export_participants
userNames = Array.new
participants = TeamsUser.find(:all, :conditions => ['team_id = ?', self.id])
participants.each do |participant|
userNames.push(participant.name)
userNames.push(" ")
end
return userNames
end

Furthermore, an instance method was added to the CourseTeam class to export the team. The class method export can call the instance method to reduce the complexity and improve the readability.

def export(team_name_only)
output = Array.new
output.push(self.name)
if team_name_only == "false"
output.push(self.export_participants)
end
course = Course.find(self.parent_id)
output.push(course.name)
return output
end

The export function as it looked after refactoring:

def self.export(csv, parent_id, options)
course = Course.find(parent_id)
if course.nil?
raise ImportError, "The course with id \""+course_id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this course?"
end
teams = CourseTeam.find_all_by_parent_id(parent_id)
teams.each do |team|
csv << team.export(options[:team_name])
end
end

==== Other Issues ====
The method name export does not accurately describe the functionality of this method. It is recommended that this method name be changed to export_all. This change was not made due to the export method in the AssignmentTeam class and the way that the method is being called by the export file controller.

The meaning of the option team_name in the method is ambiguous. Upon further examination, it was discovered that the option team_name controls if the method should only export team names without exporting the name of the participants in the team. This option should be renamed to team_name_only for better clarity.

=== ''get_export_fields'' Method ===
Inferring from the code, the get_export_field method seems to return an array that contains the options used for controlling the export method.

As discussed earlier, the team_name option for expert method controls if the export should contain the name of the team participants.

Originally, the get_export_fields method will include the string “team member” if the option team_name is true.

Furthermore, the get_export_fields method is trying to get the value of string(“team_name”) in hash variable options instead of symbol(:team_name).

Here is the method after making the noted changes:

def self.get_export_fields(options)
fields = Array.new
fields.push("Team Name")
if (options[:team_name] == "false")
fields.push("Team members")
end
fields.push("Course Name")
end

=== ''copy'' Method ===
This method is inferred to be used to create a new assignment team and copy all of the participants of the course team to that new assignment team.

If this is later confirmed to be the intended functionality of this method, then this method should belong to AssignmentTeam class instead of CourseTeam class.

This method calls the create_node_object method in Team class, which does not work (explained in a later section) and has an ambiguous return type, functionality, and name.

Logically, the copy method should create a new course team and copy the participants of a team into the new course team.
Currently, this is dead code and not used in the program.

This function was marked deprecated and it is recommended to be removed from the program.

=== ''add_participant'' Method ===
This method is used to add a participant to the course that the course team to which it belongs.

This method is called by the add_member method in the Team class to add a participant to the course when a member is added to a course team.

This method does belong in the Course class and not the CourseTeam class. The Course class already has the method add_participant with similar functionality.

This function was marked deprecated and it is recommended that the function should be removed from the program and the add_member method in the Team class should call the add_participant method from Course class.

== Changes for /app/models/course_node.rb ==
* models/course_node.rb
** The "get" method was improved.
*** Added "get_courses_managed_by_user" method to hold logic extracted from the "get"method.
*** Added "get_course_query_conditions" method to hold logic extracted from the "get" method.
*** Modified any checks on if the user is a teaching assistant to use polymorphism to make the determination.
*** Removed the initial conditional for setting the "conditions" value since the remaining conditions was overwriting the value regardless of how the initial conditional was evaluated.
*** Renaming the "get" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment nodes. As such, a comment was added to explain why the method name should remain.
*** The "sortorder" parameter is given a default value of "ASC" for ascending. This allowed for a related conditional to be removed from the method.
*** The "sortvar" parameter is given a default value of "name" for sorting by course name. This allowed for a related conditional to be removed from the method.
** Renaming the "get_children" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment Nodes. As such, a comment was added to explain why the method name should remain.
** The "get_survey_distribution_id" method was removed after finding it to be dead code.
* models/ta.rb
** Added "is_teaching_assistant?" method to override the inherited method from the User model. This supported usage of polymorphism to determine if the user is a teaching assistant.
* models/user.rb
** Added "is_teaching_assistant?" method to enable usage of polymorphism to determine if the user is a teaching assistant.

== Methods Found That Are Not Currently Being Used ==
The following methods were not found to be used currently by the project, but have been left in the code for potential future usages of the functionality:
* /app/models/course.rb
** Course.get_participant(user_id)
* /app/models/course_participant.rb
** CourseParticipant.copy(assignment_id)
** CourseParticipant.get_parent_name
* /app/models/course_node.rb
** CourseNode.get_modified_date

== Miscellaneous Changes for Quality Improvement and Readability ==

== Other Observations and Suggestion for Future Work ==
=== Redundant Code in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

The class CourseTeam and AssignmentTeam both inherits from the class Team. However that are a lot of duplicated functionalities in order to adhere to the "DRY" principle refactor for the CourseTeam mentioned in this document should be applied to AssignmentTeam and duplicated methods should be extracted to the super-class Team.

=== Naming Inconsistency in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

Participant in a team have many different names in these three classes. For example: member, user, participants. Common vocabulary should be established in-order to eliminate confusion.

=== Bugs in Team Class ===
Class: Team

File: team.rb

Method: create_node_object

The create_node_object method in Team class does not work because the class method get_parent_model in both CourseTeam and Assignment team is an instance method not a class method.

From the code of the object and the usage of this code we inferred that the method supposed to create a new course or assignment team and a new team node and return the newly created team as output.
This function should be deprecated and removed from the class, the functionality should be move to the new method in the team controller if the functionality is truly necessary.

=== Inelegance Code in Team Class ===
Class: Team

File: team.rb

Methods: randomize_all_by_parent, check_for_existing, create_node_object, copy_members

These methods uses Object.const_get() with a input string that dynamically locate the object that are associated with different team types (assignment or course) however the use of Object.const_get() are inconsistent throughout these methods.

We suggests instead of using query methods such as get_participant_type and get_parent_model in the assignment and course team return string containing the name of the object we can use these method to return the object itself thus eliminating the need for Object.const_get().

== List of New Unit Tests and Testcases ==
The following lists shows new unit files and/or new testcases:
* test/unit/course_node_test.rb (new test file)
** test_get_children_with_show_true_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_true_and_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_nil_order_by_nil
** test_get_name
** test_get_directory
** test_get_creation_date
** test_get_modified_date
** test_get_teams
** test_get_parent_id
* test/unit/course_test.rb (previously existing test file)
** test_get_teams
** test_get_path
** test_get_participants
** test_get_participant
** test_add_participant
** test_copy_participants
* test/unit/course_participant_test.rb (previously existing test file)
** test_get_course_string
** test_import
** test_get_path
** test_export
** test_get_export_field
* test/unit/course_team_test.rb (new test file)
** test_retrieval
** test_import_participants
** test_export_participants
** test_instance_export
** test_handle_duplicate
** test_import
** test_class_export

== List of Modified Unit Tests ==
The following unit test files and/or testcases were modified:
* test/unit/course_test.rb
** The line "fixtures :courses" was changed to "fixtures :courses,:teams,:users,:participants,:assignments,:nodes,:tree_folders".

CSC/ECE 517 Spring 2013/OSS E608

2013-03-21T02:51:15Z

Kbyarbor: /* E608. Refactoring and Testing - Course Related Classes */

[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Write-up of This Topic.]
__TOC__

= E608. Refactoring and Testing - Course Related Classes =
Classes Involved:
*/app/models/course.rb (76 lines)
*/app/models/course_participant.rb (94 lines)
*/app/models/course_team.rb (116 lines)
*/app/models/course_node.rb (95 lines)

What it does:
Involves creation and management of courses in Expertiza

What needs to be done:
*It is not clear what a method named 'create_node' is doing in the 'course' class. Refactor by renaming this method appropriately.
*In the course_team class the import method seems to be doing too many things. See if this method can be broken down into smaller methods with specific functionality.
*The 'get' method in course_node.rb appears to be doing a lot. Refactor this method by breaking it up into smaller methods.
*Look for any unused methods or variables in these files.
*Also apply other refactorings such as Rename variable, Rename method to give the variables and methods more meaningful names.
*Write unit tests for all the methods in each of the listed model classes.

== Changes for /app/models/course.rb ==
The following changes were made:
* Since the method create_node simply creates a course node associated with the newly created or copied course, we replaced its functionality by adding the line CourseNode.create(:node_object_id => course.id) in the course_controller's create method and copy method. The function of getting the CourseNode's parent id is extracted as a class method of CourseNode model since this parent id is independent of the course. With all of its functionalities refactored to other places, this method is hereby removed.
* Added the line "has_many :assigments, :dependent => :destroy" to allow CourseTest.test_destroy unit test to pass.

== Changes for /app/models/course_participant.rb ==
* CourseParticipant.get_parent_name is removed
** This method is never called in the project. Additionally, the method CourseParticipant.get_course_string provides the same functionality as CourseParticipant.get_parent_name, so it was deleted to follow the principle of DRY.

== Changes for /app/models/course_team.rb ==

=== ''import'' Method ===
Functionality: Import a single course team for a course from an input array. The first element in the array is optionally used to specify a name for the team that is being imported.

Usage: The method is used by the import file controller to import course teams to a course.

==== Decomposition ====
The import method can be decomposed into 5 separate parts:

===== Part 1 – Preparation =====

Functionality: Ensure that the array has enough elements and that the class in which the user wants to import the team exists.

if row.length < 2
raise ArgumentError, "Not enough items"
end
course = Course.find(id)
if course == nil
raise ImportError, "The course with id \""+id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
end

===== Part 2 – Naming the New Team =====

Functionality: The method will either import the team name from the array if has_column_name is set to true or generate a new team name if has_column_name is set to false.

if options[:has_column_names] == "true"
name = row[0].to_s.strip
index = 1
else
name = generate_team_name()
index = 0
end

===== Part 3 – Handling Duplicate Team =====

Functionality: If a team with the same team name exists, this part of the method will handle the conflict based on the option handle_duplicate.

currTeam = CourseTeam.find(:first, :conditions => ["name =? and parent_id =?",name,course.id])
if options[:handle_dups] == "ignore" && currTeam != nil
return
end
if currTeam != nil && options[:handle_dups] == "rename"
name = generate_team_name()
currTeam = nil
end
if options[:handle_dups] == "replace" && teams.first != nil
for teamsuser in TeamsUser.find(:all, :conditions => ["team_id =?", currTeam.id])
teamsuser.destroy
end
currTeam.destroy
currTeam = nil
end

===== Part 4 – Create the New Team and Node =====

Functionality: Creates a new team and team node base on the information gathered by the above parts.

if currTeam == nil
currTeam = CourseTeam.new
currTeam.name = name
currTeam.parent_id = course.id
currTeam.save
parent = CourseNode.find_by_node_object_id(course.id)
TeamNode.create(:parent_id => parent.id, :node_object_id => currTeam.id)
end

===== Part 5 – Import the Participants to the New Team =====

Functionality: Verify that the users specified in the array exist, then add the users to the newly created team.

while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user == nil
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
elsif currTeam != nil
currUser = TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", currTeam.id,user.id])
if currUser == nil
currTeam.add_member(user)
end
end
index = index+1
end

==== Refactor ====
From the decomposition, Part 5 can be seen as needing to be separated into its own method.

def import_participants(starting_index, row)
index = starting_index
while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user.nil?
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
else
if TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", id, user.id]).nil?
add_member(user)
end
end
index = index + 1
end
end

From the decomposition, the logic of Part 2 and Part 3 show that they could be simplified. Originally, Part 4 was executed regardless of if the team name was generated or imported. However, if the team name is generated instead of imported, there will not be another team with the same name. Therefore, we extracted Part 4 into its own method and modified the logic of Part 3.

def self.handle_duplicate(name, course_id, handle_dups)
team = find(:first, :conditions => ["name =? and parent_id =?", name, course_id])
if team.nil? #no duplicate
return name
end
if handle_dups == "ignore" #ignore: not create the new team
return nil
end
if handle_dups == "rename" #rename: rename new team
return generate_team_name
end
if handle_dups == "replace" #replace: delete old team
team.delete
return name
end
end

After the modifications to Part 3 and Part 4 are completed, the import method becomes:

if options[:has_column_names] == "true"
name = row[0].to_s.strip
name = handle_duplicate(name, course_id, options[:handle_dups])
index = 1
else
name = generate_team_name
index = 0
end

==== Miscellaneous Changes ====
Check in part 1 is wrong because number of element can be less than 2 if the array does not have a team name column.

if (row.length < 2 and options[:has_column_names] == "true") or (row.length < 1 and options[:has_column_names] != "true")
raise ArgumentError, "Not enough items"
end

Part 4 of the method was simplified to improve the readability.

team = CourseTeam.create(:name => name, :parent_id => course_id)
course_node = CourseNode.find_by_node_object_id(course_id)
TeamNode.create(:parent_id => course_node.id, :node_object_id => team.id)

==== Other Issues ====
The input variable session was unused in the method therefore it should be removed, however due to the way that the method is being called in the import file controller this change was not made in this project.

=== ''export'' Method ===
==== Functionality Bug ====
Originally the export method in the CourseTeam class export the assignment teams that are associated with the course that a course team belongs. This is not the behavior that one would expect from the export method in the CourseTeam class.

Upon examining the AssignmentTeam class and confirming with the professor we discover that the export method for CourseTeam should export all of the course teams associated with a course.

def self.export(csv, parent_id, options)
currentCourse = Course.find(parent_id)
currentCourse.teams.each { |team|
tcsv = Array.new
teamUsers = Array.new
tcsv.push(team.name)
if (options["team_name"] == "false")
teamMembers = TeamsUser.find(:all, :conditions => ['team_id = ?', team.id])
teamMembers.each do |user|
teamUsers.push(user.name)
teamUsers.push(" ")
end
tcsv.push(teamUsers)
end
tcsv.push(currentCourse.name)
csv << tcsv
}
end

Note that this is a director port from the source of export function in the AssignmentTeam class

The original export function was rename to export_all_assignment_team_related_to_course to reflect its actually functionality
the function was marked deprecated and if the functionality was truly needed we suggest that function should be re-written and move to the Course class

==== Analysis and Refactor ====
The part of the export method within the if block is use to export all of the participants of a team this part can be separated an turn into its own method to reduce the complexity of the export method

def export_participants
userNames = Array.new
participants = TeamsUser.find(:all, :conditions => ['team_id = ?', self.id])
participants.each do |participant|
userNames.push(participant.name)
userNames.push(" ")
end
return userNames
end

Furthermore, an instance method was added to the CourseTeam class to export the team and the class method export can call the instance method to reduce the complexity and improve the readability.

def export(team_name_only)
output = Array.new
output.push(self.name)
if team_name_only == "false"
output.push(self.export_participants)
end
course = Course.find(self.parent_id)
output.push(course.name)
return output
end

The export function after refactoring

def self.export(csv, parent_id, options)
course = Course.find(parent_id)
if course.nil?
raise ImportError, "The course with id \""+course_id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this course?"
end
teams = CourseTeam.find_all_by_parent_id(parent_id)
teams.each do |team|
csv << team.export(options[:team_name])
end
end

==== Other Issues ====
the method name export does not accurately describe the functionality of this method. We suggest that the name should be change to export_all. This change was not made due to the export method in the AssignmentTeam class and the way that the method is being called by the export file controller.

The meaning of the option team_name in the method is ambiguous. Upon further examination we discover that the option team_name control if the method should only export team names without exporting the name of the participants in the team. This option should be renamed to team_name_only for better clarity.

=== ''get_export_fields'' Method ===
Inferring from the code we think that get_export_field method supposed to returns an array that contains the options that used for controlling the export method.

As we discussed earlier the team_name option for expert method controls if the export should contain the name of the team participants.

Originally the get_export_fields method will include the string “team member” if the option team_name is true. This is the opposite of what we expected if our interpretation of the option team_name is correct.

Further more the get_export_fields method is trying to get the value of string(“team_name”) in hash variable options instead of symbol(:team_name).

After consulting with the professor we confirm that our suspicion is right and made the change accordingly

def self.get_export_fields(options)
fields = Array.new
fields.push("Team Name")
if (options[:team_name] == "false")
fields.push("Team members")
end
fields.push("Course Name")
end

=== ''copy'' Method ===
From reading the code we inferred that this method is used to create a new assignment team and copy all of the participants of the course team to that new assignment team.

If this is truly the intended functionality of this method than this method should belongs to AssignmentTeam class instead of CourseTeam class.

This method calls the create_node_object method in Team class which does not work (explained in the later section) and has ambiguous return type, functionality and name.

Logically the copy method should create a new course team and copy the participants of a team into the new course team.
Currently this is dead code and not used in the program.

This function was marked deprecated and we suggest that the function should be removed from the program.

=== ''add_participant'' Method ===
From reading the code we inferred that this method is used to add a participant to the course that the course team belongs to.

This method is called by the add_member method in the Team class to add a participant to the course when a member is added to a course team.

This method does belong in the Course class and not the CourseTeam class. The Course class already has the method add_participant with similar functionality.

This function was marked deprecated and we suggest that the function should be removed from the program and the add_member method in the Team class should call the add_participant method from Course class.

== Changes for /app/models/course_node.rb ==
* models/course_node.rb
** The "get" method was improved.
*** Added "get_courses_managed_by_user" method to hold logic extracted from the "get"method.
*** Added "get_course_query_conditions" method to hold logic extracted from the "get" method.
*** Modified any checks on if the user is a teaching assistant to use polymorphism to make the determination.
*** Removed the initial conditional for setting the "conditions" value since the remaining conditions was overwriting the value regardless of how the initial conditional was evaluated.
*** Renaming the "get" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment nodes. As such, a comment was added to explain why the method name should remain.
*** The "sortorder" parameter is given a default value of "ASC" for ascending. This allowed for a related conditional to be removed from the method.
*** The "sortvar" parameter is given a default value of "name" for sorting by course name. This allowed for a related conditional to be removed from the method.
** Renaming the "get_children" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment Nodes. As such, a comment was added to explain why the method name should remain.
** The "get_survey_distribution_id" method was removed after finding it to be dead code.
* models/ta.rb
** Added "is_teaching_assistant?" method to override the inherited method from the User model. This supported usage of polymorphism to determine if the user is a teaching assistant.
* models/user.rb
** Added "is_teaching_assistant?" method to enable usage of polymorphism to determine if the user is a teaching assistant.

== Methods Found That Are Not Currently Being Used ==
The following methods were not found to be used currently by the project, but have been left in the code for potential future usages of the functionality:
* /app/models/course.rb
** Course.get_participant(user_id)
* /app/models/course_participant.rb
** CourseParticipant.copy(assignment_id)
** CourseParticipant.get_parent_name
* /app/models/course_node.rb
** CourseNode.get_modified_date

== Miscellaneous Changes for Quality Improvement and Readability ==

== Other Observations and Suggestion for Future Work ==
=== Redundant Code in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

The class CourseTeam and AssignmentTeam both inherits from the class Team. However that are a lot of duplicated functionalities in order to adhere to the "DRY" principle refactor for the CourseTeam mentioned in this document should be applied to AssignmentTeam and duplicated methods should be extracted to the super-class Team.

=== Naming Inconsistency in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

Participant in a team have many different names in these three classes. For example: member, user, participants. Common vocabulary should be established in-order to eliminate confusion.

=== Bugs in Team Class ===
Class: Team

File: team.rb

Method: create_node_object

The create_node_object method in Team class does not work because the class method get_parent_model in both CourseTeam and Assignment team is an instance method not a class method.

From the code of the object and the usage of this code we inferred that the method supposed to create a new course or assignment team and a new team node and return the newly created team as output.
This function should be deprecated and removed from the class, the functionality should be move to the new method in the team controller if the functionality is truly necessary.

=== Inelegance Code in Team Class ===
Class: Team

File: team.rb

Methods: randomize_all_by_parent, check_for_existing, create_node_object, copy_members

These methods uses Object.const_get() with a input string that dynamically locate the object that are associated with different team types (assignment or course) however the use of Object.const_get() are inconsistent throughout these methods.

We suggests instead of using query methods such as get_participant_type and get_parent_model in the assignment and course team return string containing the name of the object we can use these method to return the object itself thus eliminating the need for Object.const_get().

== List of New Unit Tests and Testcases ==
The following lists shows new unit files and/or new testcases:
* test/unit/course_node_test.rb (new test file)
** test_get_children_with_show_true_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_true_and_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_nil_order_by_nil
** test_get_name
** test_get_directory
** test_get_creation_date
** test_get_modified_date
** test_get_teams
** test_get_parent_id
* test/unit/course_test.rb (previously existing test file)
** test_get_teams
** test_get_path
** test_get_participants
** test_get_participant
** test_add_participant
** test_copy_participants
* test/unit/course_participant_test.rb (previously existing test file)
** test_get_course_string
** test_import
** test_get_path
** test_export
** test_get_export_field
* test/unit/course_team_test.rb (new test file)
** test_retrieval
** test_import_participants
** test_export_participants
** test_instance_export
** test_handle_duplicate
** test_import
** test_class_export

== List of Modified Unit Tests ==
The following unit test files and/or testcases were modified:
* test/unit/course_test.rb
** The line "fixtures :courses" was changed to "fixtures :courses,:teams,:users,:participants,:assignments,:nodes,:tree_folders".

CSC/ECE 517 Spring 2013/OSS E608

2013-03-21T02:32:12Z

Kbyarbor: /* Changes for models/course_team.rb */

[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Write-up of This Topic.]
__TOC__

= E608. Refactoring and Testing - Course Related Classes =
Classes Involved:
*models/course.rb (76 lines)
*models/course_participant.rb (94 lines)
*models/course_team.rb (116 lines)
*models/course_node.rb (95 lines)

What it does:
Involves creation and management of courses in Expertiza

What needs to be done:
*It is not clear what a method named 'create_node' is doing in the 'course' class. Refactor by renaming this method appropriately.
*In the course_team class the import method seems to be doing too many things. See if this method can be broken down into smaller methods with specific functionality.
*The 'get' method in course_node.rb appears to be doing a lot. Refactor this method by breaking it up into smaller methods.
*Look for any unused methods or variables in these files.
*Also apply other refactorings such as Rename variable, Rename method to give the variables and methods more meaningful names.
*Write unit tests for all the methods in each of the listed model classes.

== Changes for models/course.rb ==
The following changes were made:
* Since the method create_node simply creates a course node associated with the newly created or copied course, we replaced its functionality by adding the line CourseNode.create(:node_object_id => course.id) in the course_controller's create method and copy method. The function of getting the CourseNode's parent id is extracted as a class method of CourseNode model, since this parent id is independent of the course. With all of its functionalities refactored to other places, this method is hereby removed.
* Added the line "has_many :assigments, :dependent => :destroy" to allow CourseTest.test_destroy unit test to pass.

== Changes for models/course_participant.rb ==
* CourseParticipant.get_parent_name is removed
** This method is never called in the project, plus method CourseParticipant.get_course_string provides the same functionality as CourseParticipant.get_parent_name. So we deleted this method following the principle of DRY.

== Changes for models/course_team.rb ==
File Location: /app/models/course_team.rb

=== ''import'' Method ===
Functionality: import a single course team for a course from an input array. The first element in the array optionally used to specify a name for the team that’s being imported.

Usage: the method is used by the import file controller to import course teams to a course.

==== Decomposition ====
The import method can be decompose into 5 separate parts

Part 1 – Preparation

Functionality: ensure that the array has enough elements also that the class that the use wishes to import the team to exist.

if row.length < 2
raise ArgumentError, "Not enough items"
end
course = Course.find(id)
if course == nil
raise ImportError, "The course with id \""+id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
end

Part 2 – Naming the New Team

Functionality: depending on the option has_column_name the method will either import the team name from the array if has_column_name is set to true or generate a new team name if has_column_name is set to false.

if options[:has_column_names] == "true"
name = row[0].to_s.strip
index = 1
else
name = generate_team_name()
index = 0
end

Part 3 – Handling Duplicate Team

Functionality: if a team with the same team name exist this part of the method will handle the conflict depending on the option handle_duplicate.

currTeam = CourseTeam.find(:first, :conditions => ["name =? and parent_id =?",name,course.id])
if options[:handle_dups] == "ignore" && currTeam != nil
return
end
if currTeam != nil && options[:handle_dups] == "rename"
name = generate_team_name()
currTeam = nil
end
if options[:handle_dups] == "replace" && teams.first != nil
for teamsuser in TeamsUser.find(:all, :conditions => ["team_id =?", currTeam.id])
teamsuser.destroy
end
currTeam.destroy
currTeam = nil
end

Part 4 – Create the New Team and Node

Functionality: creates a new team and team node base on the information gather by the above parts.

if currTeam == nil
currTeam = CourseTeam.new
currTeam.name = name
currTeam.parent_id = course.id
currTeam.save
parent = CourseNode.find_by_node_object_id(course.id)
TeamNode.create(:parent_id => parent.id, :node_object_id => currTeam.id)
end

Part 5 – Import the Participants to the New Team

Functionality: verify that the users specified in the array exist than add the users to the newly created team.

while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user == nil
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
elsif currTeam != nil
currUser = TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", currTeam.id,user.id])
if currUser == nil
currTeam.add_member(user)
end
end
index = index+1
end

==== Refactor ====
At the first glance from the decomposition we can clearly see that part 5 can be separated into its own method

def import_participants(starting_index, row)
index = starting_index
while(index < row.length)
user = User.find_by_name(row[index].to_s.strip)
if user.nil?
raise ImportError, "The user \""+row[index].to_s.strip+"\" was not found. <a href='/users/new'>Create</a> this user?"
else
if TeamsUser.find(:first, :conditions => ["team_id =? and user_id =?", id, user.id]).nil?
add_member(user)
end
end
index = index + 1
end
end

From the decomposition we notice that the logic of part 2 and part 3 can be simplified. Originally, part 4 gets executed regardless if the team name is generated or imported. However, if the team name is generated instead of imported there will not be another team with the same name. Therefore, we extracted part 4 into its own method and modified the logic of part 3.

def self.handle_duplicate(name, course_id, handle_dups)
team = find(:first, :conditions => ["name =? and parent_id =?", name, course_id])
if team.nil? #no duplicate
return name
end
if handle_dups == "ignore" #ignore: not create the new team
return nil
end
if handle_dups == "rename" #rename: rename new team
return generate_team_name
end
if handle_dups == "replace" #replace: delete old team
team.delete
return name
end
end

after modification part 3 and 4 in the import method becomes

if options[:has_column_names] == "true"
name = row[0].to_s.strip
name = handle_duplicate(name, course_id, options[:handle_dups])
index = 1
else
name = generate_team_name
index = 0
end

==== Miscellaneous Changes ====
Check in part 1 is wrong because number of element can be less than 2 if the array does not have a team name column.

if (row.length < 2 and options[:has_column_names] == "true") or (row.length < 1 and options[:has_column_names] != "true")
raise ArgumentError, "Not enough items"
end

Part 4 of the method was simplified to improve the readability.

team = CourseTeam.create(:name => name, :parent_id => course_id)
course_node = CourseNode.find_by_node_object_id(course_id)
TeamNode.create(:parent_id => course_node.id, :node_object_id => team.id)

==== Other Issues ====
The input variable session was unused in the method therefore it should be removed, however due to the way that the method is being called in the import file controller this change was not made in this project.

=== ''export'' Method ===
==== Functionality Bug ====
Originally the export method in the CourseTeam class export the assignment teams that are associated with the course that a course team belongs. This is not the behavior that one would expect from the export method in the CourseTeam class.

Upon examining the AssignmentTeam class and confirming with the professor we discover that the export method for CourseTeam should export all of the course teams associated with a course.

def self.export(csv, parent_id, options)
currentCourse = Course.find(parent_id)
currentCourse.teams.each { |team|
tcsv = Array.new
teamUsers = Array.new
tcsv.push(team.name)
if (options["team_name"] == "false")
teamMembers = TeamsUser.find(:all, :conditions => ['team_id = ?', team.id])
teamMembers.each do |user|
teamUsers.push(user.name)
teamUsers.push(" ")
end
tcsv.push(teamUsers)
end
tcsv.push(currentCourse.name)
csv << tcsv
}
end

Note that this is a director port from the source of export function in the AssignmentTeam class

The original export function was rename to export_all_assignment_team_related_to_course to reflect its actually functionality
the function was marked deprecated and if the functionality was truly needed we suggest that function should be re-written and move to the Course class

==== Analysis and Refactor ====
The part of the export method within the if block is use to export all of the participants of a team this part can be separated an turn into its own method to reduce the complexity of the export method

def export_participants
userNames = Array.new
participants = TeamsUser.find(:all, :conditions => ['team_id = ?', self.id])
participants.each do |participant|
userNames.push(participant.name)
userNames.push(" ")
end
return userNames
end

Furthermore, an instance method was added to the CourseTeam class to export the team and the class method export can call the instance method to reduce the complexity and improve the readability.

def export(team_name_only)
output = Array.new
output.push(self.name)
if team_name_only == "false"
output.push(self.export_participants)
end
course = Course.find(self.parent_id)
output.push(course.name)
return output
end

The export function after refactoring

def self.export(csv, parent_id, options)
course = Course.find(parent_id)
if course.nil?
raise ImportError, "The course with id \""+course_id.to_s+"\" was not found. <a href='/assignment/new'>Create</a> this course?"
end
teams = CourseTeam.find_all_by_parent_id(parent_id)
teams.each do |team|
csv << team.export(options[:team_name])
end
end

==== Other Issues ====
the method name export does not accurately describe the functionality of this method. We suggest that the name should be change to export_all. This change was not made due to the export method in the AssignmentTeam class and the way that the method is being called by the export file controller.

The meaning of the option team_name in the method is ambiguous. Upon further examination we discover that the option team_name control if the method should only export team names without exporting the name of the participants in the team. This option should be renamed to team_name_only for better clarity.

=== ''get_export_fields'' Method ===
Inferring from the code we think that get_export_field method supposed to returns an array that contains the options that used for controlling the export method.

As we discussed earlier the team_name option for expert method controls if the export should contain the name of the team participants.

Originally the get_export_fields method will include the string “team member” if the option team_name is true. This is the opposite of what we expected if our interpretation of the option team_name is correct.

Further more the get_export_fields method is trying to get the value of string(“team_name”) in hash variable options instead of symbol(:team_name).

After consulting with the professor we confirm that our suspicion is right and made the change accordingly

def self.get_export_fields(options)
fields = Array.new
fields.push("Team Name")
if (options[:team_name] == "false")
fields.push("Team members")
end
fields.push("Course Name")
end

=== ''copy'' Method ===
From reading the code we inferred that this method is used to create a new assignment team and copy all of the participants of the course team to that new assignment team.

If this is truly the intended functionality of this method than this method should belongs to AssignmentTeam class instead of CourseTeam class.

This method calls the create_node_object method in Team class which does not work (explained in the later section) and has ambiguous return type, functionality and name.

Logically the copy method should create a new course team and copy the participants of a team into the new course team.
Currently this is dead code and not used in the program.

This function was marked deprecated and we suggest that the function should be removed from the program.

=== ''add_participant'' Method ===
From reading the code we inferred that this method is used to add a participant to the course that the course team belongs to.

This method is called by the add_member method in the Team class to add a participant to the course when a member is added to a course team.

This method does belong in the Course class and not the CourseTeam class. The Course class already has the method add_participant with similar functionality.

This function was marked deprecated and we suggest that the function should be removed from the program and the add_member method in the Team class should call the add_participant method from Course class.

== Changes for models/course_node.rb ==
* models/course_node.rb
** The "get" method was improved.
*** Added "get_courses_managed_by_user" method to hold logic extracted from the "get"method.
*** Added "get_course_query_conditions" method to hold logic extracted from the "get" method.
*** Modified any checks on if the user is a teaching assistant to use polymorphism to make the determination.
*** Removed the initial conditional for setting the "conditions" value since the remaining conditions was overwriting the value regardless of how the initial conditional was evaluated.
*** Renaming the "get" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment nodes. As such, a comment was added to explain why the method name should remain.
*** The "sortorder" parameter is given a default value of "ASC" for ascending. This allowed for a related conditional to be removed from the method.
*** The "sortvar" parameter is given a default value of "name" for sorting by course name. This allowed for a related conditional to be removed from the method.
** Renaming the "get_children" method was considered; however, the name of the method is necessary for polymorphism reasons related to Assignment Nodes. As such, a comment was added to explain why the method name should remain.
** The "get_survey_distribution_id" method was removed after finding it to be dead code.
* models/ta.rb
** Added "is_teaching_assistant?" method to override the inherited method from the User model. This supported usage of polymorphism to determine if the user is a teaching assistant.
* models/user.rb
** Added "is_teaching_assistant?" method to enable usage of polymorphism to determine if the user is a teaching assistant.

== Methods Found That Are Not Currently Being Used ==
The following methods were not found to be used currently by the project, but have been left in the code for potential future usages of the functionality:
* models/course.rb
** Course.get_participant(user_id)
* models/course_participant.rb
** CourseParticipant.copy(assignment_id)
** CourseParticipant.get_parent_name
* models/course_node.rb
** CourseNode.get_modified_date

== Miscellaneous Changes for Quality Improvement and Readability ==

== Other Observations and Suggestion for Future Work ==
=== Redundant Code in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

The class CourseTeam and AssignmentTeam both inherits from the class Team. However that are a lot of duplicated functionalities in order to adhere to the "DRY" principle refactor for the CourseTeam mentioned in this document should be applied to AssignmentTeam and duplicated methods should be extracted to the super-class Team.

=== Naming Inconsistency in Team Related Classes ===
Classes: Team, CourseTeam, AssignmentTeam

Files: team.rb, course_team.rb, assignment_team.rb

Participant in a team have many different names in these three classes. For example: member, user, participants. Common vocabulary should be established in-order to eliminate confusion.

=== Bugs in Team Class ===
Class: Team

File: team.rb

Method: create_node_object

The create_node_object method in Team class does not work because the class method get_parent_model in both CourseTeam and Assignment team is an instance method not a class method.

From the code of the object and the usage of this code we inferred that the method supposed to create a new course or assignment team and a new team node and return the newly created team as output.
This function should be deprecated and removed from the class, the functionality should be move to the new method in the team controller if the functionality is truly necessary.

=== Inelegance Code in Team Class ===
Class: Team

File: team.rb

Methods: randomize_all_by_parent, check_for_existing, create_node_object, copy_members

These methods uses Object.const_get() with a input string that dynamically locate the object that are associated with different team types (assignment or course) however the use of Object.const_get() are inconsistent throughout these methods.

We suggests instead of using query methods such as get_participant_type and get_parent_model in the assignment and course team return string containing the name of the object we can use these method to return the object itself thus eliminating the need for Object.const_get().

== List of New Unit Tests and Testcases ==
The following lists shows new unit files and/or new testcases:
* test/unit/course_node_test.rb (new test file)
** test_get_children_with_show_true_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_true_and_TA_and_ascending_order_by_name
** test_get_children_with_show_true_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_TA_and_ascending_order_by_name
** test_get_children_with_show_false_and_TA_and_descending_order_by_name
** test_get_children_with_show_false_and_non_TA_and_nil_order_by_nil
** test_get_name
** test_get_directory
** test_get_creation_date
** test_get_modified_date
** test_get_teams
** test_get_parent_id
* test/unit/course_test.rb (previously existing test file)
** test_get_teams
** test_get_path
** test_get_participants
** test_get_participant
** test_add_participant
** test_copy_participants
* test/unit/course_participant_test.rb (previously existing test file)
** test_get_course_string
** test_import
** test_get_path
** test_export
** test_get_export_field
* test/unit/course_team_test.rb (new test file)
** test_retrieval
** test_import_participants
** test_export_participants
** test_instance_export
** test_handle_duplicate
** test_import
** test_class_export

== List of Modified Unit Tests ==
The following unit test files and/or testcases were modified:
* test/unit/course_test.rb
** The line "fixtures :courses" was changed to "fixtures :courses,:teams,:users,:participants,:assignments,:nodes,:tree_folders".

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T20:49:55Z

Kbyarbor: /* Methods Found That Are Not Currently Being Used */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T20:46:55Z

Kbyarbor: /* E608. Refactoring and Testing - Course Related Classes */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T20:26:55Z

Kbyarbor: /* Changes for models/course_node.rb */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T19:30:39Z

Kbyarbor: /* Changes for models/course_node.rb */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T19:17:49Z

Kbyarbor: /* Changes for models/course_node.rb */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T19:11:33Z

Kbyarbor: /* List of Modified Unit Tests */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T19:11:18Z

Kbyarbor: /* List of Modified Unit Tests */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T19:08:29Z

Kbyarbor: /* List of New Unit Tests and Testcases */

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T19:03:06Z

Kbyarbor:

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T18:52:58Z

Kbyarbor:

CSC/ECE 517 Spring 2013/OSS E608

2013-03-10T18:51:41Z

Kbyarbor:

CSC/ECE 517 Spring 2013/ch1 1a MK

2013-02-15T03:45:04Z

Kbyarbor: /* References */

= Writing Meaningful Test case =
== Introduction ==
When testing an application, there are several testing methods that can be followed. Ideally, an application will be tested using all appropriate methods of testing. This document details four types of testing. Unit testing deals with tests at an object or class level. Functional testing verifies the behavior of the application. Integration testing validates object interaction. Performance tests focus on the responsiveness and scalability of an application. A commonality of all these testing methods is that the test results are only as valuable as the tests are meaningful. Even with almost 100% code coverage, many tests could have assertions returning inaccurate results. Understanding the testing methods is key to writing meaningful tests cases aimed at testing the most valuable system components with industry best practices.

== Unit Test ==
The purpose of the unit test process is to ensure each line of code for a module functions correctly to meet functional and technical requirements. In Test Driven Development, test code is developed before or alongside application code. Automated unit tests execute application code after it is built and provide reports on test results. Furthermore, unit tests are a critical tool for any developer. They allow developers to quickly and easily test code in a repeatable and maintainable way. [http://www.javaworld.com/javaworld/jw-03-2009/jw-03-good-unit-tests-1.html (2)]

=== Advantages and Limitations ===
==== Advantages ====
Unit testing provides the following advantages
* Catch bugs at time of implementation by testing as you develop. Small units of work are easier to code and debug. If you write all of your code and start testing when coding is complete, then testing will be much more difficult.
* Easily test changes in code. Because the unit test is designed to test the business case, if the technical implementation changes, the unit test can be rerun to ensure that the technical redesign has not changed the program's result.
* Prove to your supervisor and yourself that the code works after refactoring or adding functionality.
* Verify 'corner' cases that may not be tested within the System Test phase.
* Demonstrate a level of quality to the client.
* Ensure that no other developer has undermined the quality of the code.

==== Limitation ====
Software testing is a combinatorial problem. For example, every boolean decision statement requires at least two tests: one with an outcome of "true" and one with an outcome of "false". As a result, for every line of code written, programmers often need 3 to 5 lines of test code.[http://en.wikipedia.org/wiki/Unit_testing (3)] This obviously takes time and its investment may not be worth the effort. There are also many problems that cannot easily be tested. For example, those that are nondeterministic or involve multiple threads. In addition, writing code for a unit test is as likely as the source code to be at least as buggy as the code it is testing.

=== Best Practices ===
[http://wiki.developerforce.com/index.php/How_to_Write_Good_Unit_Tests (4)]
[http://msdn.microsoft.com/en-us/magazine/cc163665.aspx (5)]
==== Testing Trivial Code ====
Unit tests should test those segments of code that are likely to have defects when first developed, or are likely to have defects introduced when changed. Like all software development activities, there is a cost benefit analysis that can be applied to writing unit tests. For normal enterprise business software, it is not worthwhile to test trivial code.

Typical examples of trivial code in Java include simple getter and setter methods for properties and simple constructors.

class User {
private String name;

public String getName() {
return name;
}

public void setName(String newName) {
name = newName;
}
}

class UserTest extends TestSuite {
public void testNameProperty() {
User user = new User();
assertNull(user.getName());

String testName = "test";
user.setName(testName);
assertEquals(testName, user.getName());
}
}

==== Using hardcoded values when checking test results ====
Some tests have a hardcoded value when checking the results of some operation. This value is often separately hardcoded in the application code being tested. When the value is changed in the application code, the test is guaranteed to fail. [http://wiki.developerforce.com/index.php/How_to_Write_Good_Unit_Tests (4)]

class CustomerWebController {
public String doOperationReturningNextPage(UserInput input) {
// some random logic...
return "newCustomer.jsp";
}
}

class CustomerWebControllerTest extends TestSuite {
public void testDoOperation() {
CustomerWebController controller = new CustomerWebController();
UserInput input = getInputForNewCustomer();
String result = controller.doOperationReturningNextPage(input);
assertEquals("newCustomer.jsp", result);
}
}

==== The DRY Principle (Don't Repeat Yourself) ====
The fix for this is simply the application of the DRY principle: Don't Repeat Yourself (from the book The Pragmatic Programmer: From Journeyman to Master by Andrew Hunt and David Thomas). When you go to use a magic value more than once, define it as a constant (or method) and then refer to that constant (or method).
To improve the example, we define a constant for the "newCustomer.jsp" value.

class CustomerWebController {
public static final NEW_CUSTOMER_PAGE = "newCustomer.jsp";
public String doOperationReturningNextPage(UserInput input) {
// some random logic...
return NEW_CUSTOMER_PAGE;
}
}

class CustomerWebControllerTest extends TestSuite {
public void testDoOperation() {
CustomerWebController controller = new CustomerWebController();
UserInput input = getInputForNewCustomer();
String result = controller.doOperationReturningNextPage(input);
assertEquals(CustomerWebController.NEW_CUSTOMER_PAGE, result);
}
}

==== Being too dependent on specific test data ====
There is some debate on whether or not unit tests should involve the database. In practice, this is actually quite common and serves a useful purpose. However, problems often occur because such tests are overly dependent on specific data in the database. As new tests are written and new test data is added, this can cause existing tests to fail regardless of if they are related.

class CustomerDataAccess {
public List findCustomers(CustomerCriteria criteria) {
// Logic to query database based on criteria
return customersFound;
}

class CustomerDataAccessTest extends TestSuite {
public void testFindCustomers {
CustomerDataAccess customerDataAccess = new CustomerDataAccess();
CustomerCriteria criteria = new CustomerCriteria();
String firstNameToFind = "Bob";
criteria.firstNameEquals(firstNameToFind);
List results = customerDataAcess.findCustomers(criteria);
assertEquals(2, results.size());
}
}

The following example code has a problem in that the test expects there to be only two customers with a first name of 'Bob', which must have been the case when the test was first written and executed. However, a developer could add another customer named 'Bob' at any point in time while unaware of the existing code. This could suddenly cause this test to fail. The general fix for situations such as this it to minimize the number of assumptions you make about the test data. This reduces the level of coupling between the test and the data, which makes either easier to change independently of the other.

To improve this particular example, we simply need to change the test to check that each result matches the criteria we specified.

class CustomerDataAccessTest extends TestSuite {
public void testFindCustomers {
CustomerDataAccess customerDataAccess = new CustomerDataAccess();
CustomerCriteria criteria = new CustomerCriteria();
String firstNameToFind = "Bob";
criteria.firstNameEquals(firstNameToFind);
List results = customerDataAcess.findCustomers(criteria);
for (Customer customer : results) {
assertEquals(firstNameToFind, customer.getFirstName());
}
}
}

=== Code Coverage ===
This is an analysis method that determines which parts of the software have been executed (covered) by the test case suite. It also determines which parts have not been executed and may require additional attention.

http://en.wikipedia.org/wiki/Code_coverage

=== Some Additional Best Practices ===
*Keep each test independent of others.
**Do not make unnecessary assumptions.
***It is counterproductive to assert anything that is already asserted by another test.
***Avoids increasing the frequency of failures related to the same root cause.
***Only apply asserts that apply to the functionality being tested.
***Follow a rule of one assertion per test.
**Test one set of code at a time.
**Avoid unnecessary preconditions.
***Only run preliminary code that is related to the test to be run.
***Use common preliminary code only when the associated tests actually require it.
*Keep configuration settings separate from the unit tests.
*Use clear and consistent naming for all unit tests.

[http://blog.stevensanderson.com/2009/08/24/writing-great-unit-tests-best-and-worst-practises/ (17)]

=== Effective Use of Assertions ===
*Make one logical assertion per test.
*Each assert should be made in relation to the functionality being tested.
*Avoid making any assertions that are already covered by another existing assertion.

=== Writing Effective Unit Tests ===
*Scope is crucial.
**Narrow scope may result in trivial test results that provide no real value.
**Broad scope may test too much that it becomes difficult to determine root cause of failures.
*Group tests according to a major feature/functionality.
**Include enough tests to cover that specific feature/functionality.
*Define unit tests at the method level.
**Some methods will involve groups of objects. In this case, testing should isolate the groups of objects for testing.
***Identifies segments of related code.
*Read the code and check if it catches an error or throws an error.
**Easy identification of a method with potential to break.
**Unit tests should cover error scenarios.
*Total unit tests should cover the functional requirements of the code at a minimum.

[http://users.csc.calpoly.edu/~cstaley/General/TestingHowTo.htm (8)][http://ubiquity.acm.org/article.cfm?id=358976 (18)]

=== Brief Description of Some Available Unit Testing Tools ===
[http://www.tejasconsulting.com/open-testware/feature/unit-test-tool-survey.html (6)][http://www.aptest.com/resources.html (9)]
*GrandTestAuto [http://grandtestauto.org/ (19)]
**Enables completely automated testing of Java software.
**More advanced than JUnit.
**Simple to use.
**Supports distribution of tests across a network.
**Integrates with additional tools.
*JUnit [http://www.softwaresummit.com/2004/speakers/SteltingTestingJ2EE.pdf (7)][http://www.javapractices.com/topic/TopicAction.do?Id=33 (20)]
**Enables automated testing of Java software.
**Simple to use.
**Makes it easy to identify test failures.
**Open source tool.
*NUnit [http://nunit.org/ (21)]
**Provides a unit testing framework for .NET software.
**Takes advantage of existing .NET language features.

== Functional Test ==
The purpose of functional test is to measure the behavioral quality of a software application. Functional tests verify that the system responds appropriately from the user perspective and functions according to the design requirements used to specify the application. The functional test must determine if each component of a software application performs in accordance to the specifications, responds correctly to all conditions that may be presented by incoming events, processes incoming events correctly from one business event to the other, and produces an appropriate outcome from incoming events.

=== Advantages ===
Functional has several benefits in order to develop a robust software application. Here are the advantages:
* It verifies that an application works as per specifications across multiple platforms, browsers and technologies.
* Make sure that a certain feature is completed from a user's point of view.
* A tester needs no knowledge of implementation, including specific programming languages in order to execute the test.
* Tester and programmer are independent from each other
* It will help to expose any ambiguities or inconsistencies in the specification
* Test cases can be designed as soon as the specification is completed.

=== Best Practices ===
Functional tests are the measurement for an application's code completion. It makes sure that all the feature and functionalities are working as expected from an end user perspective. Therefore, it is important to design functional tests that will expose any vulnerabilities and assure confidence in an application. Before writing a test, it is very important to understand how the software is supposed to behave. Functional specification documents will have all the details about the behavior of the application. The first thing to do before writing any test cases is to write the functional specification document. Once the specification is read, it is important to organize tests to make sure that they cover each and every feature and functionality of the application. This will make sure that all the components are thoroughly tested and enable identify any gaps in testing. Test cases should be written prior to developing functionality. This will lead to identification of preconditions and establish expected behavior. Additionally, this will help to automate the functional tests and enables another person to run the test regardless of their knowledge of the expected behavior. The test cases should also cover very rare situations. Software developers tend to develop applications strictly according to its specification. They may not appropriately code the program to work for rare cases. A majority of the bugs are found when applications are used in rare input conditions. Therefore, it is important to make sure that functional tests are created to test boundary conditions, error cases, and rare input cases.

=== Ensuring Effectiveness and Efficiency Through the Functional Testing Lifecycle ===
*Requirements Gathering
**Define clear and complete requirements that can be tested.
*Test Planning
**Establish guidelines and standards for creating tests.
**Identify the required hardware and software for the testing environment.
*Test Strategizing
**Utilize resources to achieve optimum test coverage.
*Test Execution
**Define an efficient test execution flow.
*Collect Testing Metrics
**Gauge the test progress and quality of the testing.
**Make continuous improvements as needed.

[http://www.infosys.com/engineering-services/white-papers/Documents/functional-testing.pdf (22)]

=== Writing functional tests ===
An application may have several features and each of those features have several functionalities of their own. With a vast number of overall functionalities, there is a possibility that a functionality may be overlooked. Therefore, it is a good practice to organize test cases by their features and functionalities. This can help ensure that no feature or functionality is missed.

The following is a sample organization structure of functional test cases:

<Feature 1>
<Function 1>
<Test 1>
<Test 1/>
<Test 2>
<Test 2/>
…
<Function 1/>
<Feature 1/>
<Feature 2>
<Function 1>
<Test 1>
<Test 1/>
…
<Function 1/>
…
<Feature 2/>

Test cases can be executed by anybody if they are written in a meaningful way for anyone to understand. In order to create a meaningful test case, a test case should have specific components. First, it should have a purpose statement on what it is intended to test. Second, the test case should have a setup component that is run prior to executing the test. Third, it should have steps to execute the test. Fourth, it should have expected behavior to compare against for the determination of if the test passed or failed. Finally, it should have a cleanup procedure to make sure that the system is reverting back to the original state.

Here is a sample of a test case:

<Test 1>
<Purpose>
“Purpose of the test case”
<Purpose/>
<Setup>
“Steps to prepare the system prior to executing the test case”
<Setup/>
<Execution>
“Steps required executing the test”
<Execution/>
<Expected Behavior>
“Expected behavior of the test case”
<Expected Behavior/>
<Cleanup>
“Steps required to cleaning up the environment to revert back”
<Cleanup/>
<Test 1/>

Writing functional test cases for 100% coverage can be a seemingly impossible task that would require a tester to continue writing functional test forever. Even when there are several functionalities requiring testing, there can be situations in which the functional testing of major functionalities and features must be completed in a short amount of time. This type of situation can be handled by assigning priorities to each functional test. Higher priority tests should cover key features. Lower priority tests should cover less important features.

=== Functionality test tools ===
Functional tests can become very large in size and that can make them difficult to maintain and time-consuming to execute manually. Therefore, it is a good practice to automate the test cases. Automating tests can reduce the amount of time between notifications of problem introductions and having such problems addressed. [http://dmcnulla.wordpress.com/2012/01/28/good-practices-for-automating-functional-tests/ (1)] There are several tools available that automate functional testing. Here are some lists of some of the tools available:

==== Quick Test Professional ====
The Quick Test Professional tool enables the automation of functional tests through an user interface. It detects objects in the user interface and performs desired operations simulating a mouse click or keyboard events. The tool can also be used to automate functional tests on graphical and non-graphical user interfaces. It allows collaboration through the storage of similar object definitions in a single repository manager, which can be shared among other testers. The same repository can maintain automated and manual test cases.

==== JFunc ====
JFunc is an open-source functional testing tool that helps to automate functional test cases. JFunc is an extension of the JUnit test framework. It serves to ease the creation of manual functional test suites. JFunc can handle multiple test failures by allowing the functional test to not exit after the first failure. Verbose assertions have more detail about the test failures and error messages. New arguments can be passed into a test each time it runs.

==== Waitir ====
Waitir is a web application testing tool for the Ruby language. Waitir tests the web application on all web browsers on different platforms. It distinguishes from other web application functional testing tools by executing tests at the web browser layer and by driving a web browser and the interacting with objects on a web page. This is more accurate than manual functional testing. Here is a sample test case that validates the search operation:

#------------------------------------------------------------------------------------------------------------------#
# Purpose: To Validate the search capability of the browser.
#------------------------------------------------------------------------------------------------------------------#
#------------------------------------------------------------------------------------------------------------------#
# Setup:
#------------------------------------------------------------------------------------------------------------------#
require "watir"
test_site = "http://www.google.com"
browser = Watir::Browser.new
browser.goto test_site
browser.text_field(:name, "q").set "pickaxe"
#------------------------------------------------------------------------------------------------------------------#
# Execution:
#------------------------------------------------------------------------------------------------------------------#
browser.button(:name, "btnG").click # "btnG" is the name of the Search button
#-------------------------------------------------------------#
# Expected Behavior: “A Google page with results should be shown. 'Programming Ruby' should be high on the list."
#------------------------------------------------------------------------------------------------------------------#
if browser.text.include? "Programming Ruby"
puts " Test Passed. Found the test string: 'Programming Ruby'. Actual Results match Expected Results."
else
puts " Test Failed! Could not find: 'Programming Ruby'."
End
#------------------------------------------------------------------------------------------------------------------#
#Cleanup:
#------------------------------------------------------------------------------------------------------------------#
browser.close

=== Additional Functional Testing Tools ===
*Arbiter [http://arbiter.sourceforge.net/ (24)]
**Document-based acceptance testing.
**Driven by requirements documents in Microsoft Word or RTF file formats.
**Requirements are used to establish a glossary and test suite.
*Blerby Test Runner [https://github.com/tmpvar/Blerby-Test-Runner (25)]
**Ajax test runner for php software.
**Allows for instant feedback while performing on-the-fly code refactoring.
**Tracks test dependencies.
**Automatically re-runs affected tests when corresponding code changes.
*Concordion [http://www.concordion.org/ (26)]
**Open source framework for testing Java software.
**Allows for plain English descriptions of requirements to be converted into automated tests.
**Specifications are linked to the software system itself and prevents tests from becoming outdated.
**Notifications inform when a change in system behavior causes associated test to fail.
*Eclipse Jubula [http://www.eclipse.org/jubula/ (27)]
**Provides automated UI functional testing for HTML and Java applications.
**Aimed at creating tests from the user perspective.
**Limited coding efforts required.
*Robotium [http://code.google.com/p/robotium/ (28)]
**Test framework to write black-box and white-box tests for Android applications.
**Requires test case suite to be installed on the same device or simulator as the application.
**Access the application to execute tests scenarios in a real environment.

[http://www.opensourcetesting.org/functional.php (23)]

== Integration Test ==
The purpose of integration testing is to test the combination of individual components working together. This type of testing can expose faults that result from the interaction between the integrated components. [http://softwaretestingfundamentals.com/integration-testing/ (13)]

=== Various Approaches to Integration Testing ===
*Big Bang - All or most of the individual components are combined and tested at one time. This approach is typically utilized when a test team receives an entire software bundle.
*Top Down - Top level components are tested initially. Lower level components are tested subsequently in a step by step method. This approach is used whenever development is taking the same type of approach. In this approach, test stubs are needed to simulate lower level components that are not yet available.
*Bottom Up - Bottom level components are tested initially. This approach is used whenever development is taking the same type of approach. In this approach, test stubs are needed to simulate higher level components that are not yet available.
*Sandwich/Hybrid - This approach is a combination of the Top Down and Bottom up approaches.

=== Advantages to Each Approach ===
*Big Bang
**Convenient for smaller systems.
**Quick.
**Cheap.
**No stubs or stand-in objects are needed.
*Top Down
**Potential for early identification of major flaws near the top of the product.
**Critical components are tested on priority.
**Easier to isolate root cause of interface errors due to the incremental approach.
*Bottom Up
**Potential for early identification of major flaws near the bottom of the product.
**Easier to create test conditions.
**No need to wait for all modules to be developed.
**Each component and unit gets tested for correctness before being integrated.
**Typically results in a more robust system.
*Sandwich/Hybrid
**Useful for larger projects with several subprojects.

[http://www.itdivisioninc.com/IntegrationTesting.aspx (15)]

=== Best Practices ===
*Create only the integration tests needed. These tests offer great value at the cost of a great amount of work to properly set up and time to execute. Consider only testing the default scenarios. There should be enough testing to validate that critical or high-severity defects no longer exist.
*Do not depend on specific data to be available to the test. Always have any necessary data created prior to the execution of a test. Anyone with proper access could delete or modify test data and break a test, which is another reason it should not be assumed to be available.
*Use multiple asserts for each test. Due to the time consumption of integration tests, it is recommended that tests be consolidated. In this type of testing, it is considered better to ignore following a one assert per test rule.
*When seeking to validate the same functionality and there is an option between creating a unit test or an integration test, always choose the unit test. Unit tests will run faster and be easier to set up.

[http://msdn.microsoft.com/en-us/library/vstudio/hh323698(v=vs.100).aspx#erg (14)]

=== Available Integration Testing Tools ===
*eggPlant [http://www.testplant.com/products/eggplant/ (30)]
**Focused on testing the user experience. [http://www.testplant.com/blog/2011/06/09/integration-testing/ (29)]
**Black-box test automation tool.
**Low overhead.
**Non-invasive. Not required to run on the same system under test.
**Image capture and search techniques prevent most UI changes from affecting existing tests.
*Ruby Capybara [https://www.ruby-toolbox.com/projects/capybara (31)]
**Designed for Ruby on Rails applications.
**Tests rack-based web applications.
**Simulates how a user interacts with a website.
*Selenium [http://seleniumhq.org/ (33)]
**Provides automated integration testing for Java web applications. [http://www.developer.com/java/web/article.php/3872691/Selenium-Automated-Integration-Testing-for-Java-Web-Apps.htm (32)]
**Provides automation-aided exploratory testing.
**Distributes testing across many environments.
**Supports testing on many types of web browsers.

== Performance Test ==
The purpose of performance testing is to determine speed and effectiveness. Various quantitative and qualitative attributes may be used. Examples of quantitative attributes include response time and number of MIPS (millions of instructions per second). Examples of qualitative attributes include scalability, interoperability, and reliability. [http://performance-testing.org/performance-testing-definitions (10)]

Performance testing can be used to determine the speed of a specific aspect of a system with a specific workload. This allows for the identification of poor performance areas and for the establishment of acceptable thresholds required to maintain acceptable response time.

There are several types of performance testing. Understanding the various types helps to minimize cost, reduce risk, and to know when it is appropriate to apply which type of test on a project.

=== Key Types of Performance Testing & Their Advantages ===
*Performance test - Determines speed, stability, and/or scalability.
**Focuses on determining user satisfaction with regards to performance.
**Identifies differences between the expectations and reality of existing performance.
**Supports optimization and capacity planning.
*Load test - Verifies application behavior under both normal and peak load conditions.
**The hardware environment is evaluated for adequacy.
**Detects concurrency issues.
**Detects functional errors that occur under load.
**Supports determination of maximum simultaneous users prior to performance being compromised.
**Supports determination of maximum load before limits of resource utilization are exceeded.
*Stress test - Determines behavior when conditions exceed normal or peak load conditions.
**Identifies if over-stressing the system can corrupt data.
**Supports establishment of application-monitoring triggers that can warn of impending failures.
**Determines side effects of failures related to hardware or applications.
**Identifies the kinds of failures to plan for.
*Capacity test - Determines the amount of users and/or transactions that can be supported while continuing to meet performance goals.
**Provides capacity data that can be used to validate or enhance models.
**Determines current usage and capacity of the system.
**Provides data on capacity and usage trends of the system.

[http://msdn.microsoft.com/en-us/library/bb924357.aspx (11)]

=== Best Practices ===
*Test the code with the same granularity as used for unit tests.
*Do not perform lots of assertions on the test results.
*Test enough to measure statistically significant performance differences.
*Ideal performance tests should run relatively fast.
*Test setup should be performed independent of the actual test method.

[http://www.mantidproject.org/Writing_Performance_Tests#Best_Practice_Advice (12)]

=== Available Performance Testing Tools ===
*AgileLoad
**Provides load testing for mobile and web applications.
**Designed to fit into the Agile Development methodology.
**Windows-based.
**Tests applications designed for use on cloud or internal networks.
*Forecast
**Tests IT systems for performance, reliability, and scalability.
**Realistically simulates multiple thousands of unique users simultaneously accessing functionalities.
**Avoids the overhead and expense associated with hardware costs.
*HP LoadRunner
**Detects bottlenecks.
**Emulates production workloads.
**Diagnoses root cause of performance issues.
**Improves performance prior to application deployment.
*IBM Rational Performance Tester
**Identifies both the presence and cause of performance bottlenecks.
**Provides problem identification and problem diagnosis.
**Root Cause Analysis features allows for identifying source code causing performance issues.
**Real-time reports are viewable via web browser.
*RTI
**Measures application performance based on response times for transactions with poor performance.
**Dynamically collects performance data and diagnoses problems throughout system aspects.
**Quantifies and validates application architectures.
*SilkPerformer
**Provides performance and load testing for software applications.
**Automates software load and stress.
**Enables identification of bottlenecks.
**Diagnostic tools may be applied to resolve performance issues.

[http://www.toolsjournal.com/tools-world/item/156-top-performance-testing-tools (34)]

== References ==
[1] http://dmcnulla.wordpress.com/2012/01/28/good-practices-for-automating-functional-tests/

[2] http://www.javaworld.com/javaworld/jw-03-2009/jw-03-good-unit-tests-1.html

[3] http://en.wikipedia.org/wiki/Unit_testing

[4] http://wiki.developerforce.com/index.php/How_to_Write_Good_Unit_Tests

[5] http://msdn.microsoft.com/en-us/magazine/cc163665.aspx

[6] http://www.tejasconsulting.com/open-testware/feature/unit-test-tool-survey.html

[7] http://www.softwaresummit.com/2004/speakers/SteltingTestingJ2EE.pdf

[8] http://users.csc.calpoly.edu/~cstaley/General/TestingHowTo.htm

[9] http://www.aptest.com/resources.html

[10] http://performance-testing.org/performance-testing-definitions

[11] http://msdn.microsoft.com/en-us/library/bb924357.aspx

[12] http://www.mantidproject.org/Writing_Performance_Tests#Best_Practice_Advice

[13] http://softwaretestingfundamentals.com/integration-testing/

[14] http://msdn.microsoft.com/en-us/library/vstudio/hh323698(v=vs.100).aspx#erg

[15] http://www.itdivisioninc.com/IntegrationTesting.aspx

[16] http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2010/ch1_2e_RI

[17] http://blog.stevensanderson.com/2009/08/24/writing-great-unit-tests-best-and-worst-practises/

[18] http://ubiquity.acm.org/article.cfm?id=358976

[19] http://grandtestauto.org/

[20] http://www.javapractices.com/topic/TopicAction.do?Id=33

[21] http://nunit.org/

[22] http://www.infosys.com/engineering-services/white-papers/Documents/functional-testing.pdf

[23] http://www.opensourcetesting.org/functional.php

[24] http://arbiter.sourceforge.net/

[25] https://github.com/tmpvar/Blerby-Test-Runner

[26] http://www.concordion.org/

[27] http://www.eclipse.org/jubula/

[28] http://code.google.com/p/robotium/

[29] http://www.testplant.com/blog/2011/06/09/integration-testing/

[30] http://www.testplant.com/products/eggplant/

[31] https://www.ruby-toolbox.com/projects/capybara

[32] http://www.developer.com/java/web/article.php/3872691/Selenium-Automated-Integration-Testing-for-Java-Web-Apps.htm

[33] http://seleniumhq.org/

[34] http://www.toolsjournal.com/tools-world/item/156-top-performance-testing-tools

CSC/ECE 517 Spring 2013/ch1 1a MK

2013-02-15T03:44:49Z

Kbyarbor: /* Functionality test tools */

= Writing Meaningful Test case =
== Introduction ==
When testing an application, there are several testing methods that can be followed. Ideally, an application will be tested using all appropriate methods of testing. This document details four types of testing. Unit testing deals with tests at an object or class level. Functional testing verifies the behavior of the application. Integration testing validates object interaction. Performance tests focus on the responsiveness and scalability of an application. A commonality of all these testing methods is that the test results are only as valuable as the tests are meaningful. Even with almost 100% code coverage, many tests could have assertions returning inaccurate results. Understanding the testing methods is key to writing meaningful tests cases aimed at testing the most valuable system components with industry best practices.

== Unit Test ==
The purpose of the unit test process is to ensure each line of code for a module functions correctly to meet functional and technical requirements. In Test Driven Development, test code is developed before or alongside application code. Automated unit tests execute application code after it is built and provide reports on test results. Furthermore, unit tests are a critical tool for any developer. They allow developers to quickly and easily test code in a repeatable and maintainable way. [http://www.javaworld.com/javaworld/jw-03-2009/jw-03-good-unit-tests-1.html (2)]

=== Advantages and Limitations ===
==== Advantages ====
Unit testing provides the following advantages
* Catch bugs at time of implementation by testing as you develop. Small units of work are easier to code and debug. If you write all of your code and start testing when coding is complete, then testing will be much more difficult.
* Easily test changes in code. Because the unit test is designed to test the business case, if the technical implementation changes, the unit test can be rerun to ensure that the technical redesign has not changed the program's result.
* Prove to your supervisor and yourself that the code works after refactoring or adding functionality.
* Verify 'corner' cases that may not be tested within the System Test phase.
* Demonstrate a level of quality to the client.
* Ensure that no other developer has undermined the quality of the code.

==== Limitation ====
Software testing is a combinatorial problem. For example, every boolean decision statement requires at least two tests: one with an outcome of "true" and one with an outcome of "false". As a result, for every line of code written, programmers often need 3 to 5 lines of test code.[http://en.wikipedia.org/wiki/Unit_testing (3)] This obviously takes time and its investment may not be worth the effort. There are also many problems that cannot easily be tested. For example, those that are nondeterministic or involve multiple threads. In addition, writing code for a unit test is as likely as the source code to be at least as buggy as the code it is testing.

=== Best Practices ===
[http://wiki.developerforce.com/index.php/How_to_Write_Good_Unit_Tests (4)]
[http://msdn.microsoft.com/en-us/magazine/cc163665.aspx (5)]
==== Testing Trivial Code ====
Unit tests should test those segments of code that are likely to have defects when first developed, or are likely to have defects introduced when changed. Like all software development activities, there is a cost benefit analysis that can be applied to writing unit tests. For normal enterprise business software, it is not worthwhile to test trivial code.

Typical examples of trivial code in Java include simple getter and setter methods for properties and simple constructors.

class User {
private String name;

public String getName() {
return name;
}

public void setName(String newName) {
name = newName;
}
}

class UserTest extends TestSuite {
public void testNameProperty() {
User user = new User();
assertNull(user.getName());

String testName = "test";
user.setName(testName);
assertEquals(testName, user.getName());
}
}

==== Using hardcoded values when checking test results ====
Some tests have a hardcoded value when checking the results of some operation. This value is often separately hardcoded in the application code being tested. When the value is changed in the application code, the test is guaranteed to fail. [http://wiki.developerforce.com/index.php/How_to_Write_Good_Unit_Tests (4)]

class CustomerWebController {
public String doOperationReturningNextPage(UserInput input) {
// some random logic...
return "newCustomer.jsp";
}
}

class CustomerWebControllerTest extends TestSuite {
public void testDoOperation() {
CustomerWebController controller = new CustomerWebController();
UserInput input = getInputForNewCustomer();
String result = controller.doOperationReturningNextPage(input);
assertEquals("newCustomer.jsp", result);
}
}

==== The DRY Principle (Don't Repeat Yourself) ====
The fix for this is simply the application of the DRY principle: Don't Repeat Yourself (from the book The Pragmatic Programmer: From Journeyman to Master by Andrew Hunt and David Thomas). When you go to use a magic value more than once, define it as a constant (or method) and then refer to that constant (or method).
To improve the example, we define a constant for the "newCustomer.jsp" value.

class CustomerWebController {
public static final NEW_CUSTOMER_PAGE = "newCustomer.jsp";
public String doOperationReturningNextPage(UserInput input) {
// some random logic...
return NEW_CUSTOMER_PAGE;
}
}

class CustomerWebControllerTest extends TestSuite {
public void testDoOperation() {
CustomerWebController controller = new CustomerWebController();
UserInput input = getInputForNewCustomer();
String result = controller.doOperationReturningNextPage(input);
assertEquals(CustomerWebController.NEW_CUSTOMER_PAGE, result);
}
}

==== Being too dependent on specific test data ====
There is some debate on whether or not unit tests should involve the database. In practice, this is actually quite common and serves a useful purpose. However, problems often occur because such tests are overly dependent on specific data in the database. As new tests are written and new test data is added, this can cause existing tests to fail regardless of if they are related.

class CustomerDataAccess {
public List findCustomers(CustomerCriteria criteria) {
// Logic to query database based on criteria
return customersFound;
}

class CustomerDataAccessTest extends TestSuite {
public void testFindCustomers {
CustomerDataAccess customerDataAccess = new CustomerDataAccess();
CustomerCriteria criteria = new CustomerCriteria();
String firstNameToFind = "Bob";
criteria.firstNameEquals(firstNameToFind);
List results = customerDataAcess.findCustomers(criteria);
assertEquals(2, results.size());
}
}

The following example code has a problem in that the test expects there to be only two customers with a first name of 'Bob', which must have been the case when the test was first written and executed. However, a developer could add another customer named 'Bob' at any point in time while unaware of the existing code. This could suddenly cause this test to fail. The general fix for situations such as this it to minimize the number of assumptions you make about the test data. This reduces the level of coupling between the test and the data, which makes either easier to change independently of the other.

To improve this particular example, we simply need to change the test to check that each result matches the criteria we specified.

class CustomerDataAccessTest extends TestSuite {
public void testFindCustomers {
CustomerDataAccess customerDataAccess = new CustomerDataAccess();
CustomerCriteria criteria = new CustomerCriteria();
String firstNameToFind = "Bob";
criteria.firstNameEquals(firstNameToFind);
List results = customerDataAcess.findCustomers(criteria);
for (Customer customer : results) {
assertEquals(firstNameToFind, customer.getFirstName());
}
}
}

=== Code Coverage ===
This is an analysis method that determines which parts of the software have been executed (covered) by the test case suite. It also determines which parts have not been executed and may require additional attention.

http://en.wikipedia.org/wiki/Code_coverage

=== Some Additional Best Practices ===
*Keep each test independent of others.
**Do not make unnecessary assumptions.
***It is counterproductive to assert anything that is already asserted by another test.
***Avoids increasing the frequency of failures related to the same root cause.
***Only apply asserts that apply to the functionality being tested.
***Follow a rule of one assertion per test.
**Test one set of code at a time.
**Avoid unnecessary preconditions.
***Only run preliminary code that is related to the test to be run.
***Use common preliminary code only when the associated tests actually require it.
*Keep configuration settings separate from the unit tests.
*Use clear and consistent naming for all unit tests.

[http://blog.stevensanderson.com/2009/08/24/writing-great-unit-tests-best-and-worst-practises/ (17)]

=== Effective Use of Assertions ===
*Make one logical assertion per test.
*Each assert should be made in relation to the functionality being tested.
*Avoid making any assertions that are already covered by another existing assertion.

=== Writing Effective Unit Tests ===
*Scope is crucial.
**Narrow scope may result in trivial test results that provide no real value.
**Broad scope may test too much that it becomes difficult to determine root cause of failures.
*Group tests according to a major feature/functionality.
**Include enough tests to cover that specific feature/functionality.
*Define unit tests at the method level.
**Some methods will involve groups of objects. In this case, testing should isolate the groups of objects for testing.
***Identifies segments of related code.
*Read the code and check if it catches an error or throws an error.
**Easy identification of a method with potential to break.
**Unit tests should cover error scenarios.
*Total unit tests should cover the functional requirements of the code at a minimum.

[http://users.csc.calpoly.edu/~cstaley/General/TestingHowTo.htm (8)][http://ubiquity.acm.org/article.cfm?id=358976 (18)]

=== Brief Description of Some Available Unit Testing Tools ===
[http://www.tejasconsulting.com/open-testware/feature/unit-test-tool-survey.html (6)][http://www.aptest.com/resources.html (9)]
*GrandTestAuto [http://grandtestauto.org/ (19)]
**Enables completely automated testing of Java software.
**More advanced than JUnit.
**Simple to use.
**Supports distribution of tests across a network.
**Integrates with additional tools.
*JUnit [http://www.softwaresummit.com/2004/speakers/SteltingTestingJ2EE.pdf (7)][http://www.javapractices.com/topic/TopicAction.do?Id=33 (20)]
**Enables automated testing of Java software.
**Simple to use.
**Makes it easy to identify test failures.
**Open source tool.
*NUnit [http://nunit.org/ (21)]
**Provides a unit testing framework for .NET software.
**Takes advantage of existing .NET language features.

== Functional Test ==
The purpose of functional test is to measure the behavioral quality of a software application. Functional tests verify that the system responds appropriately from the user perspective and functions according to the design requirements used to specify the application. The functional test must determine if each component of a software application performs in accordance to the specifications, responds correctly to all conditions that may be presented by incoming events, processes incoming events correctly from one business event to the other, and produces an appropriate outcome from incoming events.

=== Advantages ===
Functional has several benefits in order to develop a robust software application. Here are the advantages:
* It verifies that an application works as per specifications across multiple platforms, browsers and technologies.
* Make sure that a certain feature is completed from a user's point of view.
* A tester needs no knowledge of implementation, including specific programming languages in order to execute the test.
* Tester and programmer are independent from each other
* It will help to expose any ambiguities or inconsistencies in the specification
* Test cases can be designed as soon as the specification is completed.

=== Best Practices ===
Functional tests are the measurement for an application's code completion. It makes sure that all the feature and functionalities are working as expected from an end user perspective. Therefore, it is important to design functional tests that will expose any vulnerabilities and assure confidence in an application. Before writing a test, it is very important to understand how the software is supposed to behave. Functional specification documents will have all the details about the behavior of the application. The first thing to do before writing any test cases is to write the functional specification document. Once the specification is read, it is important to organize tests to make sure that they cover each and every feature and functionality of the application. This will make sure that all the components are thoroughly tested and enable identify any gaps in testing. Test cases should be written prior to developing functionality. This will lead to identification of preconditions and establish expected behavior. Additionally, this will help to automate the functional tests and enables another person to run the test regardless of their knowledge of the expected behavior. The test cases should also cover very rare situations. Software developers tend to develop applications strictly according to its specification. They may not appropriately code the program to work for rare cases. A majority of the bugs are found when applications are used in rare input conditions. Therefore, it is important to make sure that functional tests are created to test boundary conditions, error cases, and rare input cases.

=== Ensuring Effectiveness and Efficiency Through the Functional Testing Lifecycle ===
*Requirements Gathering
**Define clear and complete requirements that can be tested.
*Test Planning
**Establish guidelines and standards for creating tests.
**Identify the required hardware and software for the testing environment.
*Test Strategizing
**Utilize resources to achieve optimum test coverage.
*Test Execution
**Define an efficient test execution flow.
*Collect Testing Metrics
**Gauge the test progress and quality of the testing.
**Make continuous improvements as needed.

[http://www.infosys.com/engineering-services/white-papers/Documents/functional-testing.pdf (22)]

=== Writing functional tests ===
An application may have several features and each of those features have several functionalities of their own. With a vast number of overall functionalities, there is a possibility that a functionality may be overlooked. Therefore, it is a good practice to organize test cases by their features and functionalities. This can help ensure that no feature or functionality is missed.

The following is a sample organization structure of functional test cases:

<Feature 1>
<Function 1>
<Test 1>
<Test 1/>
<Test 2>
<Test 2/>
…
<Function 1/>
<Feature 1/>
<Feature 2>
<Function 1>
<Test 1>
<Test 1/>
…
<Function 1/>
…
<Feature 2/>

Test cases can be executed by anybody if they are written in a meaningful way for anyone to understand. In order to create a meaningful test case, a test case should have specific components. First, it should have a purpose statement on what it is intended to test. Second, the test case should have a setup component that is run prior to executing the test. Third, it should have steps to execute the test. Fourth, it should have expected behavior to compare against for the determination of if the test passed or failed. Finally, it should have a cleanup procedure to make sure that the system is reverting back to the original state.

Here is a sample of a test case:

<Test 1>
<Purpose>
“Purpose of the test case”
<Purpose/>
<Setup>
“Steps to prepare the system prior to executing the test case”
<Setup/>
<Execution>
“Steps required executing the test”
<Execution/>
<Expected Behavior>
“Expected behavior of the test case”
<Expected Behavior/>
<Cleanup>
“Steps required to cleaning up the environment to revert back”
<Cleanup/>
<Test 1/>

Writing functional test cases for 100% coverage can be a seemingly impossible task that would require a tester to continue writing functional test forever. Even when there are several functionalities requiring testing, there can be situations in which the functional testing of major functionalities and features must be completed in a short amount of time. This type of situation can be handled by assigning priorities to each functional test. Higher priority tests should cover key features. Lower priority tests should cover less important features.

=== Functionality test tools ===
Functional tests can become very large in size and that can make them difficult to maintain and time-consuming to execute manually. Therefore, it is a good practice to automate the test cases. Automating tests can reduce the amount of time between notifications of problem introductions and having such problems addressed. [http://dmcnulla.wordpress.com/2012/01/28/good-practices-for-automating-functional-tests/ (1)] There are several tools available that automate functional testing. Here are some lists of some of the tools available:

==== Quick Test Professional ====
The Quick Test Professional tool enables the automation of functional tests through an user interface. It detects objects in the user interface and performs desired operations simulating a mouse click or keyboard events. The tool can also be used to automate functional tests on graphical and non-graphical user interfaces. It allows collaboration through the storage of similar object definitions in a single repository manager, which can be shared among other testers. The same repository can maintain automated and manual test cases.

==== JFunc ====
JFunc is an open-source functional testing tool that helps to automate functional test cases. JFunc is an extension of the JUnit test framework. It serves to ease the creation of manual functional test suites. JFunc can handle multiple test failures by allowing the functional test to not exit after the first failure. Verbose assertions have more detail about the test failures and error messages. New arguments can be passed into a test each time it runs.

==== Waitir ====
Waitir is a web application testing tool for the Ruby language. Waitir tests the web application on all web browsers on different platforms. It distinguishes from other web application functional testing tools by executing tests at the web browser layer and by driving a web browser and the interacting with objects on a web page. This is more accurate than manual functional testing. Here is a sample test case that validates the search operation:

#------------------------------------------------------------------------------------------------------------------#
# Purpose: To Validate the search capability of the browser.
#------------------------------------------------------------------------------------------------------------------#
#------------------------------------------------------------------------------------------------------------------#
# Setup:
#------------------------------------------------------------------------------------------------------------------#
require "watir"
test_site = "http://www.google.com"
browser = Watir::Browser.new
browser.goto test_site
browser.text_field(:name, "q").set "pickaxe"
#------------------------------------------------------------------------------------------------------------------#
# Execution:
#------------------------------------------------------------------------------------------------------------------#
browser.button(:name, "btnG").click # "btnG" is the name of the Search button
#-------------------------------------------------------------#
# Expected Behavior: “A Google page with results should be shown. 'Programming Ruby' should be high on the list."
#------------------------------------------------------------------------------------------------------------------#
if browser.text.include? "Programming Ruby"
puts " Test Passed. Found the test string: 'Programming Ruby'. Actual Results match Expected Results."
else
puts " Test Failed! Could not find: 'Programming Ruby'."
End
#------------------------------------------------------------------------------------------------------------------#
#Cleanup:
#------------------------------------------------------------------------------------------------------------------#
browser.close

=== Additional Functional Testing Tools ===
*Arbiter [http://arbiter.sourceforge.net/ (24)]
**Document-based acceptance testing.
**Driven by requirements documents in Microsoft Word or RTF file formats.
**Requirements are used to establish a glossary and test suite.
*Blerby Test Runner [https://github.com/tmpvar/Blerby-Test-Runner (25)]
**Ajax test runner for php software.
**Allows for instant feedback while performing on-the-fly code refactoring.
**Tracks test dependencies.
**Automatically re-runs affected tests when corresponding code changes.
*Concordion [http://www.concordion.org/ (26)]
**Open source framework for testing Java software.
**Allows for plain English descriptions of requirements to be converted into automated tests.
**Specifications are linked to the software system itself and prevents tests from becoming outdated.
**Notifications inform when a change in system behavior causes associated test to fail.
*Eclipse Jubula [http://www.eclipse.org/jubula/ (27)]
**Provides automated UI functional testing for HTML and Java applications.
**Aimed at creating tests from the user perspective.
**Limited coding efforts required.
*Robotium [http://code.google.com/p/robotium/ (28)]
**Test framework to write black-box and white-box tests for Android applications.
**Requires test case suite to be installed on the same device or simulator as the application.
**Access the application to execute tests scenarios in a real environment.

[http://www.opensourcetesting.org/functional.php (23)]

== Integration Test ==
The purpose of integration testing is to test the combination of individual components working together. This type of testing can expose faults that result from the interaction between the integrated components. [http://softwaretestingfundamentals.com/integration-testing/ (13)]

=== Various Approaches to Integration Testing ===
*Big Bang - All or most of the individual components are combined and tested at one time. This approach is typically utilized when a test team receives an entire software bundle.
*Top Down - Top level components are tested initially. Lower level components are tested subsequently in a step by step method. This approach is used whenever development is taking the same type of approach. In this approach, test stubs are needed to simulate lower level components that are not yet available.
*Bottom Up - Bottom level components are tested initially. This approach is used whenever development is taking the same type of approach. In this approach, test stubs are needed to simulate higher level components that are not yet available.
*Sandwich/Hybrid - This approach is a combination of the Top Down and Bottom up approaches.

=== Advantages to Each Approach ===
*Big Bang
**Convenient for smaller systems.
**Quick.
**Cheap.
**No stubs or stand-in objects are needed.
*Top Down
**Potential for early identification of major flaws near the top of the product.
**Critical components are tested on priority.
**Easier to isolate root cause of interface errors due to the incremental approach.
*Bottom Up
**Potential for early identification of major flaws near the bottom of the product.
**Easier to create test conditions.
**No need to wait for all modules to be developed.
**Each component and unit gets tested for correctness before being integrated.
**Typically results in a more robust system.
*Sandwich/Hybrid
**Useful for larger projects with several subprojects.

[http://www.itdivisioninc.com/IntegrationTesting.aspx (15)]

=== Best Practices ===
*Create only the integration tests needed. These tests offer great value at the cost of a great amount of work to properly set up and time to execute. Consider only testing the default scenarios. There should be enough testing to validate that critical or high-severity defects no longer exist.
*Do not depend on specific data to be available to the test. Always have any necessary data created prior to the execution of a test. Anyone with proper access could delete or modify test data and break a test, which is another reason it should not be assumed to be available.
*Use multiple asserts for each test. Due to the time consumption of integration tests, it is recommended that tests be consolidated. In this type of testing, it is considered better to ignore following a one assert per test rule.
*When seeking to validate the same functionality and there is an option between creating a unit test or an integration test, always choose the unit test. Unit tests will run faster and be easier to set up.

[http://msdn.microsoft.com/en-us/library/vstudio/hh323698(v=vs.100).aspx#erg (14)]

=== Available Integration Testing Tools ===
*eggPlant [http://www.testplant.com/products/eggplant/ (30)]
**Focused on testing the user experience. [http://www.testplant.com/blog/2011/06/09/integration-testing/ (29)]
**Black-box test automation tool.
**Low overhead.
**Non-invasive. Not required to run on the same system under test.
**Image capture and search techniques prevent most UI changes from affecting existing tests.
*Ruby Capybara [https://www.ruby-toolbox.com/projects/capybara (31)]
**Designed for Ruby on Rails applications.
**Tests rack-based web applications.
**Simulates how a user interacts with a website.
*Selenium [http://seleniumhq.org/ (33)]
**Provides automated integration testing for Java web applications. [http://www.developer.com/java/web/article.php/3872691/Selenium-Automated-Integration-Testing-for-Java-Web-Apps.htm (32)]
**Provides automation-aided exploratory testing.
**Distributes testing across many environments.
**Supports testing on many types of web browsers.

== Performance Test ==
The purpose of performance testing is to determine speed and effectiveness. Various quantitative and qualitative attributes may be used. Examples of quantitative attributes include response time and number of MIPS (millions of instructions per second). Examples of qualitative attributes include scalability, interoperability, and reliability. [http://performance-testing.org/performance-testing-definitions (10)]

Performance testing can be used to determine the speed of a specific aspect of a system with a specific workload. This allows for the identification of poor performance areas and for the establishment of acceptable thresholds required to maintain acceptable response time.

There are several types of performance testing. Understanding the various types helps to minimize cost, reduce risk, and to know when it is appropriate to apply which type of test on a project.

=== Key Types of Performance Testing & Their Advantages ===
*Performance test - Determines speed, stability, and/or scalability.
**Focuses on determining user satisfaction with regards to performance.
**Identifies differences between the expectations and reality of existing performance.
**Supports optimization and capacity planning.
*Load test - Verifies application behavior under both normal and peak load conditions.
**The hardware environment is evaluated for adequacy.
**Detects concurrency issues.
**Detects functional errors that occur under load.
**Supports determination of maximum simultaneous users prior to performance being compromised.
**Supports determination of maximum load before limits of resource utilization are exceeded.
*Stress test - Determines behavior when conditions exceed normal or peak load conditions.
**Identifies if over-stressing the system can corrupt data.
**Supports establishment of application-monitoring triggers that can warn of impending failures.
**Determines side effects of failures related to hardware or applications.
**Identifies the kinds of failures to plan for.
*Capacity test - Determines the amount of users and/or transactions that can be supported while continuing to meet performance goals.
**Provides capacity data that can be used to validate or enhance models.
**Determines current usage and capacity of the system.
**Provides data on capacity and usage trends of the system.

[http://msdn.microsoft.com/en-us/library/bb924357.aspx (11)]

=== Best Practices ===
*Test the code with the same granularity as used for unit tests.
*Do not perform lots of assertions on the test results.
*Test enough to measure statistically significant performance differences.
*Ideal performance tests should run relatively fast.
*Test setup should be performed independent of the actual test method.

[http://www.mantidproject.org/Writing_Performance_Tests#Best_Practice_Advice (12)]

=== Available Performance Testing Tools ===
*AgileLoad
**Provides load testing for mobile and web applications.
**Designed to fit into the Agile Development methodology.
**Windows-based.
**Tests applications designed for use on cloud or internal networks.
*Forecast
**Tests IT systems for performance, reliability, and scalability.
**Realistically simulates multiple thousands of unique users simultaneously accessing functionalities.
**Avoids the overhead and expense associated with hardware costs.
*HP LoadRunner
**Detects bottlenecks.
**Emulates production workloads.
**Diagnoses root cause of performance issues.
**Improves performance prior to application deployment.
*IBM Rational Performance Tester
**Identifies both the presence and cause of performance bottlenecks.
**Provides problem identification and problem diagnosis.
**Root Cause Analysis features allows for identifying source code causing performance issues.
**Real-time reports are viewable via web browser.
*RTI
**Measures application performance based on response times for transactions with poor performance.
**Dynamically collects performance data and diagnoses problems throughout system aspects.
**Quantifies and validates application architectures.
*SilkPerformer
**Provides performance and load testing for software applications.
**Automates software load and stress.
**Enables identification of bottlenecks.
**Diagnostic tools may be applied to resolve performance issues.

[http://www.toolsjournal.com/tools-world/item/156-top-performance-testing-tools (34)]

== References ==
[1] http://codebetter.com/blogs/jeremy.miller/archive/2005/07/20/129552.aspx

[2] http://www.javaworld.com/javaworld/jw-03-2009/jw-03-good-unit-tests-1.html

[3] http://en.wikipedia.org/wiki/Unit_testing

[4] http://wiki.developerforce.com/index.php/How_to_Write_Good_Unit_Tests

[5] http://msdn.microsoft.com/en-us/magazine/cc163665.aspx

[6] http://www.tejasconsulting.com/open-testware/feature/unit-test-tool-survey.html

[7] http://www.softwaresummit.com/2004/speakers/SteltingTestingJ2EE.pdf

[8] http://users.csc.calpoly.edu/~cstaley/General/TestingHowTo.htm

[9] http://www.aptest.com/resources.html

[10] http://performance-testing.org/performance-testing-definitions

[11] http://msdn.microsoft.com/en-us/library/bb924357.aspx

[12] http://www.mantidproject.org/Writing_Performance_Tests#Best_Practice_Advice

[13] http://softwaretestingfundamentals.com/integration-testing/

[14] http://msdn.microsoft.com/en-us/library/vstudio/hh323698(v=vs.100).aspx#erg

[15] http://www.itdivisioninc.com/IntegrationTesting.aspx

[16] http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2010/ch1_2e_RI

[17] http://blog.stevensanderson.com/2009/08/24/writing-great-unit-tests-best-and-worst-practises/

[18] http://ubiquity.acm.org/article.cfm?id=358976

[19] http://grandtestauto.org/

[20] http://www.javapractices.com/topic/TopicAction.do?Id=33

[21] http://nunit.org/

[22] http://www.infosys.com/engineering-services/white-papers/Documents/functional-testing.pdf

[23] http://www.opensourcetesting.org/functional.php

[24] http://arbiter.sourceforge.net/

[25] https://github.com/tmpvar/Blerby-Test-Runner

[26] http://www.concordion.org/

[27] http://www.eclipse.org/jubula/

[28] http://code.google.com/p/robotium/

[29] http://www.testplant.com/blog/2011/06/09/integration-testing/

[30] http://www.testplant.com/products/eggplant/

[31] https://www.ruby-toolbox.com/projects/capybara

[32] http://www.developer.com/java/web/article.php/3872691/Selenium-Automated-Integration-Testing-for-Java-Web-Apps.htm

[33] http://seleniumhq.org/

[34] http://www.toolsjournal.com/tools-world/item/156-top-performance-testing-tools