Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2016 E1621 Refactor and Test the Quizzing Feature

2016-04-24T14:58:53Z

Ychen71: /* Problem Statement */ Update google doc on quizzing feature

= Introduction to Expertiza =
Expertiza<ref>https://github.com/expertiza/expertiza</ref> is a project developed using Ruby on Rails<ref>http://guides.rubyonrails.org/getting_started.html</ref>. It provides features like peer review, team assignments and submission of projects. This can be achieved by submitting code base, URL of hosted code on remote server and Wiki submissions. It is an [https://en.wikipedia.org/wiki/Open_source open source] application and the code can be cloned from [https://github.com/expertiza/expertiza GitHub]. This application provides an efficient way to manage assignments, grades and reviews.

= Problem Statement =
The Expertiza quiz feature is in need of refactoring. Currently, quizzes are checked by <code>questionnaires_controller.valid_quiz</code>. This method is rather long, involved, and does not take advantage of object-oriented practices. It combs through the parameters hash received from a request and manually checks all quiz fields, all question fields, all question choice fields, and verifies that each question has a correct choice.

We will refactor the method to construct a quiz questionniare and then call <code>valid?</code> to recursively validate the object tree using ActiveRecord validations. This is an improvement over the current code which checks all questions manually. The purpose of refactoring in this manner is to enhance readability, DRYness, and maintainability of Expertiza code.

In addition to this refactoring we will implement integration testing on the quiz feature to verify that the expected behavior is present for all use cases.

A full description of the assignment may be found [https://docs.google.com/document/d/13oRmKemlwRzXG1ItcI2zTx4r3gAAfvmuobZjxiy0oVo/edit#heading=h.su78b3gdq1a7 here]

Program flow of this quizzing feature can be found [https://docs.google.com/document/d/1Rmq3-PfpmMeYFIOlP5Ik5pMWHbg-x-DzNfP5hDOXYfs/ here]

=Classes involved=
* questionnaires_controller.rb
* quiz_quesetionnaire.rb
* quiz_question.rb
* quiz_question_choice.rb
* spec/features/quiz_spec.rb

=Use Case and Scenarios=
The Quiz Use Case allows for instructors to create and manage assignments where students may write quizzes for reviewers on materials they have submitted. See the following scenarios for a complete description of how the feature is expected to work.

==Instructors are able to create and manage an assignment's quiz feature==
An instructor chooses to create an assignment that has a quiz [S1]. While editing the assignment they may choose the number of quiz questions [S2] and set which phases students are allowed to take the quizzes [S3].

* [S1] - When creating the assignment there is a checkbox labeled "has quiz." Checking this box creates an assignment that includes a quiz.
* [S2] - When an assignment has a quiz there is an input field that accepts the number of questions that will be on each quiz. Setting this number appropriately changes the number of quiz questions.
* [S3] - Students may not take quizzes on a phase that does not allow them to do so. When on a stage that does allow for quizzes, they may take quizzes on work that they have reviewed.

==Instructors can view quiz questions and scores from the tree view==
After an assignment has been created the instructor may choose to view student quizzes from the tree view [S1]. While on the quiz view page they see student quizzes [S2] and student responses [S3].

* [S1] - The instructor may navigate to the list of assignments. Assignments with quizzes enabled will provide a link for the instructor to follow and view student quizzes.
* [S2] - The instructor shall be presented with the quiz title, questions, and answer choices. The correct answer choices will be in bold.
* [S3] - The score for each student who has taken the quiz shall be listed along with the average quiz score.

==Students can create and edit quizzes==
A student navigates to the assignment work page and chooses to create a new quiz [S1] or edit an existing one [S2]. By doing so they are able to choose a quiz title and quiz questions [S3]. Invalid input results in an error message prompting the student to fix the issue [E1].

* [S1] - A student may only create a quiz if they have not yet done so.
* [S2] - A student may only edit a quiz if they have previously created one.
* [S3] - The quiz has the number of quiz questions defined by the instructor in the assignment.

* [E1] - Possible errors include:
** The quiz has no name.
** One or more questions is missing text.
** One or more choices is missing text.
** A question is missing a correct answer choice.

==Students can take quizzes on assignments they have reviewed==
A student decides to take a quiz [S1] on another team's assignment that they have previously reviewed. They select an artifact for review [S2] and fill in their answers. After submitting the quiz they can view their score on the take quizzes page [S3] and see question-by-question scores by clicking view [S4].

* [S1] - The student may only take a quiz during a stage in which the assignment is configured to allow them to do so.
* [S2] - Only quizzes from submissions they have reviewed are available.
* [S3] - The take quizzes page lists the final score for each quiz.
* [S4] - Choosing to view a quiz will show a student each question along with their answers and the correct answers.

=Design and Implementation=
Design for the refactoring has been driven by object oriented principles and test-driven-development, and makes use of the existing object hierarchy described in the following UML diagram.

[[File:Expertiza_quiz_hierarchy.png|Expertiza Quiz Hierarchy]]

See the below sections for a part-by-part breakdown of the planned implementation for this project.

==Tests==
Quiz tests will be added to the file spec/features/quiz_spec.rb and will make use of
* rspec
* capybara
* selenium

Tests will be made which fully cover the expected behavior of each listed scenario in the Use Case.

==Refactoring==
Each of the following files will be refactored as described.

===QuestionnaireController===
Refactor the <code>valid_quiz</code> method. It will be renamed to <code>validate_quiz</code> to more properly describe the action that occurs as a result of it being called. The behavior will be changed to construct a new quiz questionnaire with submitted questions wich will be validated using <code>quiz.valid?</code>.

===QuizQuestionnaire===
The following fields will be validated using ActiveRecord validations.
* Presence of name

===QuizQuestion===
The following fields will be validated using ActiveRecord validations
* Presence of text
* Presence of type
* Has a correct answer

===QuizQuestionChoice===
The following fields will be validated using ActiveRecord validations
* Presence of text

===Test Cases===
In order to verify that refactoring has been done correctly and maintains the same external behavior, we will write test cases to the existing implementation. These test cases will be the ground truth of the validation feature. Refactored code will not be considered complete until all of these test cases once again pass.

=Post Completion=
Testing and refactoring have been completed and a [https://github.com/expertiza/expertiza/pull/671 pull request] created to merge features back into master.

==Refactoring==
Refactoring went according to plan. The following model files were edited to use ActiveRecord validations on specific fields
* question.rb
* questionnaire.rb
* quiz_quesetion.rb
* quiz_question_choice.rb

In addition, tests were added to <code>spec/controllers/questionnaires_controller_spec.rb</code> to test quiz validation. With passing tests, the <code>validate_quiz</code> method in <code>questionnaires_controller</code> was refactored. It now constructs a quiz from params and returns it if it is valid. If the quiz is invalid an error message is returned.

===Before Refactoring===
<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
def valid_quiz
:num_quiz_questions = Assignment.find(params[:aid]).num_quiz_questions
:valid = "valid"

:(1..num_quiz_questions).each do |i|
:: if params[:new_question][i.to_s] == ''
:::// One of the questions text is not filled out
:::valid = "Please make sure all questions have text"
:::break
::elsif !params.has_key?(:question_type) || !params[:question_type].has_key?(i.to_s) || params[:question_type][i.to_s][:type] == nil
:::// A type isnt selected for a question
:::valid = "Please select a type for each question"
:::break
::elsif params[:questionnaire][:name]==""
:::// questionnaire name is not specified
:::valid = "Please specify quiz name (please do not use your name or id)."
:::break
::else
:::type = params[:question_type][i.to_s][:type]
:::if type == 'MultipleChoiceCheckbox' or type == 'MultipleChoiceRadio'
::::correct_selected = false
::::(1..4).each do |x|
:::::if params[:new_choices][i.to_s][type][x.to_s][:txt] == ''
::::::// Text isnt provided for an option
::::::valid = "Please make sure every question has text for all options"
::::::break
:::::elsif type == 'MultipleChoiceRadio' and not params[:new_choices][i.to_s][type][x.to_s][:iscorrect] == nil
::::::correct_selected = true
:::::elsif type == 'MultipleChoiceCheckbox' and not params[:new_choices][i.to_s][type][x.to_s][:iscorrect] == 0.to_s
::::::correct_selected = true
:::::end
::::end
::::if valid == "valid" && !correct_selected
:::::// A correct option isnt selected for a check box or radio question
:::::valid = "Please select a correct answer for all questions"
::::::break
::::end
:::elsif type == 'TF' # TF is not disabled. We need to test TF later.
::::if params[:new_choices][i.to_s]["TF"] == nil
:::::// A correct option isnt selected for a true/false question
:::::valid = "Please select a correct answer for all questions"
:::::break
::::end
:::end
::end
:end

:return valid
end
</div>

===After Refactoring===
<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
def validate_quiz
:num_quiz_questions = Assignment.find(params[:aid]).num_quiz_questions

:questionnaire = quiz_questionnaire num_quiz_questions

:if questionnaire.valid?
::return questionnaire
: end

:questionnaire_errors questionnaire
end
</div>

==Testing==
All tests were implemented as part of <code>spec/features/quiz_spec.rb</code> and thoroughly cover the Use Case, scenarios, and sub flows listed above. A factory file, <code>spec/factories/quiz_factory.rb</code> was added to aid testing.

= References =
<references/>

CSC/ECE 517 Spring 2016 E1621 Refactor and Test the Quizzing Feature

2016-04-16T15:06:30Z

Ychen71: /* CSC/ECE 517 Spring 2016 E1621: Refactor and test the quizzing feature */

CSC/ECE 517 Spring 2016 E1621 Refactor and Test the Quizzing Feature

2016-04-16T15:06:02Z

Ychen71: Created page with "===CSC/ECE 517 Spring 2016 E1621: Refactor and test the quizzing feature=== = Introduction to Expertiza = Expertiza<ref>https://github.com/expertiza/expertiza</ref> is a project..."

===CSC/ECE 517 Spring 2016 E1621: Refactor and test the quizzing feature===

= Introduction to Expertiza =
Expertiza<ref>https://github.com/expertiza/expertiza</ref> is a project developed using Ruby on Rails<ref>http://guides.rubyonrails.org/getting_started.html</ref>. It provides features like peer review, team assignments and submission of projects. This can be achieved by submitting code base, URL of hosted code on remote server and Wiki submissions. It is an [https://en.wikipedia.org/wiki/Open_source open source] application and the code can be cloned from [https://github.com/expertiza/expertiza GitHub]. This application provides an efficient way to manage assignments, grades and reviews.

= Problem Statement =
The Expertiza quiz feature is in need of refactoring. Currently, quizzes are checked by <code>questionnaires_controller.valid_quiz</code>. This method is rather long, involved, and does not take advantage of object-oriented practices. It combs through the parameters hash received from a request and manually checks all quiz fields, all question fields, all question choice fields, and verifies that each question has a correct choice.

We will refactor the method to construct a quiz questionniare and then call <code>valid?</code> to recursively validate the object tree using ActiveRecord validations. This is an improvement over the current code which checks all questions manually. The purpose of refactoring in this manner is to enhance readability, DRYness, and maintainability of Expertiza code.

In addition to this refactoring we will implement integration testing on the quiz feature to verify that the expected behavior is present for all use cases.

A full description of the assignment may be found [https://docs.google.com/document/d/13oRmKemlwRzXG1ItcI2zTx4r3gAAfvmuobZjxiy0oVo/edit#heading=h.su78b3gdq1a7 here]

=Classes involved=
* questionnaires_controller.rb
* quiz_quesetionnaire.rb
* quiz_question.rb
* quiz_question_choice.rb
* spec/features/quiz_spec.rb

=Use Case and Scenarios=
The Quiz Use Case allows for instructors to create and manage assignments where students may write quizzes for reviewers on materials they have submitted. See the following scenarios for a complete description of how the feature is expected to work.

==Instructors are able to create and manage an assignment's quiz feature==
An instructor chooses to create an assignment that has a quiz [S1]. While editing the assignment they may choose the number of quiz questions [S2] and set which phases students are allowed to take the quizzes [S3].

* [S1] - When creating the assignment there is a checkbox labeled "has quiz." Checking this box creates an assignment that includes a quiz.
* [S2] - When an assignment has a quiz there is an input field that accepts the number of questions that will be on each quiz. Setting this number appropriately changes the number of quiz questions.
* [S3] - Students may not take quizzes on a phase that does not allow them to do so. When on a stage that does allow for quizzes, they may take quizzes on work that they have reviewed.

==Instructors can view quiz questions and scores from the tree view==
After an assignment has been created the instructor may choose to view student quizzes from the tree view [S1]. While on the quiz view page they see student quizzes [S2] and student responses [S3].

* [S1] - The instructor may navigate to the list of assignments. Assignments with quizzes enabled will provide a link for the instructor to follow and view student quizzes.
* [S2] - The instructor shall be presented with the quiz title, questions, and answer choices. The correct answer choices will be in bold.
* [S3] - The score for each student who has taken the quiz shall be listed along with the average quiz score.

==Students can create and edit quizzes==
A student navigates to the assignment work page and chooses to create a new quiz [S1] or edit an existing one [S2]. By doing so they are able to choose a quiz title and quiz questions [S3]. Invalid input results in an error message prompting the student to fix the issue [E1].

* [S1] - A student may only create a quiz if they have not yet done so.
* [S2] - A student may only edit a quiz if they have previously created one.
* [S3] - The quiz has the number of quiz questions defined by the instructor in the assignment.

* [E1] - Possible errors include:
** The quiz has no name.
** One or more questions is missing text.
** One or more choices is missing text.
** A question is missing a correct answer choice.

==Students can take quizzes on assignments they have reviewed==
A student decides to take a quiz [S1] on another team's assignment that they have previously reviewed. They select an artifact for review [S2] and fill in their answers. After submitting the quiz they can view their score on the take quizzes page [S3] and see question-by-question scores by clicking view [S4].

* [S1] - The student may only take a quiz during a stage in which the assignment is configured to allow them to do so.
* [S2] - Only quizzes from submissions they have reviewed are available.
* [S3] - The take quizzes page lists the final score for each quiz.
* [S4] - Choosing to view a quiz will show a student each question along with their answers and the correct answers.

=Design and Implementation=
Design for the refactoring has been driven by object oriented principles and test-driven-development, and makes use of the existing object hierarchy described in the following UML diagram.

[[File:Expertiza_quiz_hierarchy.png|Expertiza Quiz Hierarchy]]

See the below sections for a part-by-part breakdown of the planned implementation for this project.

==Tests==
Quiz tests will be added to the file spec/features/quiz_spec.rb and will make use of
* rspec
* capybara
* selenium

Tests will be made which fully cover the expected behavior of each listed scenario in the Use Case.

==Refactoring==
Each of the following files will be refactored as described.

===QuestionnaireController===
Refactor the <code>valid_quiz</code> method. It will be renamed to <code>validate_quiz</code> to more properly describe the action that occurs as a result of it being called. The behavior will be changed to construct a new quiz questionnaire with submitted questions wich will be validated using <code>quiz.valid?</code>.

===QuizQuestionnaire===
The following fields will be validated using ActiveRecord validations.
* Presence of name

===QuizQuestion===
The following fields will be validated using ActiveRecord validations
* Presence of text
* Presence of type
* Has a correct answer

===QuizQuestionChoice===
The following fields will be validated using ActiveRecord validations
* Presence of text

===Test Cases===
In order to verify that refactoring has been done correctly and maintains the same external behavior, we will write test cases to the existing implementation. These test cases will be the ground truth of the validation feature. Refactored code will not be considered complete until all of these test cases once again pass.

= References =
<references/>

CSC/ECE 517 Spring 2016

2016-04-16T15:05:49Z

Ychen71:

==Writing Assignment 1==
*[[CSC/ECE 517 Spring 2016/Active Job]]

==Calibration Assignment Submissions==
*[[Calibration Assignment Submission (OmniAuth)]]
*[[Calibration Assignment Submission (Patch_verb)]]

==Writing Assignment 2==
*[[CSC/ECE 517 Spring 2016/Mozilla Implement HTML5 form validation]]

*[[CSC/ECE_517_Spring_2016/Mozilla Conforming Image Loading to HTML 5 Specs]]

*[[CSC/ECE 517 Spring 2016/Functional Tests for Questionnaire Controller]]

*[[CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature]]

*[[CSC/ECE 517 Spring 2016/Refactor different question types from quiz feature]]

*[[CSC/ECE 517 Spring 2016/Implement private browsing]]

*[[CSC/ECE 517 Spring 2016/Write automated tests for WebDriver]]

*[[CSC/ECE 517 Spring 2016/Refactor sign_up_sheet_controller.rb and sign_up_topic.rb]]

*[[CSC/ECE 517 Spring 2016/Implement Common Parts of the CSSOM API]]

*[[CSC/ECE 517 Spring 2016/Functional tests for assignment creation function]]

*[[CSC/ECE 517 Spring 2016/E1604. Functional tests for Calibration function]]

*[[CSC/ECE 517 Spring 2016/Refactor and write unit tests for question type.rb]]

*[[CSC/ECE 517 Spring 2016/Refactor response controller]]

*[[CSC/ECE_517_Spring_2016_OSS_M1606]]

*[[CSC/ECE_517_Spring_2016/OSS_E1601]]

==Final Project Design Document==
*[[CSC/ECE 517 Spring 2016 M1601 Implement HTML5 form validation]]
*[[CSC/ECE 517 Spring 2016 M1602 Make image loads conform with the spec]]
*[[CSC/ECE 517 Spring 2016 E1624 Compose functional tests for Suggest topics of student functionality ]]
*[[CSC/ECE 517 Spring 2016 E1631 Team-based reviewing]]
*[[CSC/ECE 517 Spring 2016 E1628 Visualization]]
*[[CSC/ECE 517 Spring 2016 E1625 Show confidence ratings for grade based on reputations of reviewers]]
*[[CSC/ECE 517 Spring 2016 E1629 Performance improvement for Course & Assignment Listing]]
*[[CSC/ECE 517 Spring 2016 M1603 Implement Common Parts of the CSSOM API]]
*[[M1606: Implementing HTTP authorization UI and persistent sessions]]
*[[CSC/ECE 517 Spring 2016 E1620 Improve Survey Functionality]]
*[[CSC/ECE 517 Spring 2016 E1621 Refactor and Test the Quizzing Feature]]

CSC/ECE 517 Spring 2016

2016-03-29T14:02:21Z

Ychen71: /* Writing Assignment 2 */

CSC/ECE 517 Spring 2016

2016-03-29T14:02:09Z

Ychen71:

CSC/ECE 517 Spring 2016/Active Job

2016-03-29T14:01:00Z

Ychen71: Created page with "== '''Introduction''' == Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interfac..."

== '''Introduction''' ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts various queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletters, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is an interface which you can work with common queueing backends.
The reason to have Active Job in place is to make sure Rails apps can have a job infrastructure. Other existing gems can build on this framework without the limitation of API difference between different job runners such as Delayed Job and Resque. With this feature choosing queueing backends can become an operational concern. Also, switching between those queueing backends without rewrite jobs become possible.<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref>

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting to carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher[https://rubygems.org/gems/mailcatcher/versions/0.6.1] is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''External links'''==

*[http://www.rubyonrails.org/ Ruby on Rails official website] – rubyonrails.org
*[http://railscasts.com/ Railscasts.com] – (defunct) Short Screencasts that focus on Ruby on Rails technique
*[http://rubycasts.io/ Rubycasts.io] – Weekly 15 minute screencasts on the whole Ruby/Rails development stack
*[http://www.railstutorial.org/ The Rails Tutorial] – The Ruby on Rails Tutorial book and screencast series teach you how to develop and deploy Ruby on Rails apps
*[https://github.com/rails/rails Rails source code]

=='''References'''==
<references/>

CSC/ECE 517 Spring 2016

2016-03-29T14:00:45Z

Ychen71: Update on writing assignment 1

==Writing Assignment 1==
[[CSC/ECE 517 Spring 2016/Active Job]]

==Calibration Assignment Submissions==
*[[Calibration Assignment Submission (OmniAuth)]]
*[[Calibration Assignment Submission (Patch_verb)]]

==Writing Assignment 2==
[[CSC/ECE 517 Spring 2016/Mozilla Implement HTML5 form validation]]

[[CSC/ECE 517 Spring 2016/Functional Tests for Questionnaire Controller]]

[[CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature]]

[[CSC/ECE 517 Spring 2016/Refactor different question types from quiz feature]]

[[CSC/ECE 517 Spring 2016/Implement private browsing]]

[[CSC/ECE 517 Spring 2016/Write automated tests for WebDriver]]

[[CSC/ECE 517 Spring 2016/Refactor sign_up_sheet_controller.rb and sign_up_topic.rb]]

[[CSC/ECE 517 Spring 2016/Implement Common Parts of the CSSOM API]]

[[CSC/ECE 517 Spring 2016/Functional tests for assignment creation function]]

[[CSC/ECE 517 Spring 2016/E1604. Functional tests for Calibration function]]

[[CSC/ECE 517 Spring 2016/Refactor and write unit tests for question type.rb]]

User:Ychen71

2016-03-28T22:27:31Z

Ychen71: moved User:Ychen71 to Active Job

#REDIRECT [[Active Job]]

Active Job

2016-03-28T22:27:31Z

Ychen71: moved User:Ychen71 to Active Job

User:Ewhorton

2016-03-21T22:00:43Z

Ychen71:

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is a suite of functional tests for the assignment calibration function. These tests are designed to provide integration, regression, and acceptance testing by using automation technologies.

===Problem Statement===
Expertiza has a feature called Calibration that can be turned on for an assignment. When this feature is enabled an expert, typically the instructor, can provide an expert review for the assignment artifacts. After students finish their own reviews they may compare their responses to the expert review. The instructor may also view calibration results to view the scores for the entire class.

While this is a preexisting feature within Expertiza, there currently exist no tests for it. The goal of this project is to fully test the entire flow of the calibration feature using the '''RSpec''' and '''Capybara''' frameworks.

===Motivation===
The moment a line of code is written it becomes legacy code in need of support. Test cases are used not only to ensure that code is operating properly, but also to ensure that it continues to do so after having been modified. An important aspect of this is acceptance testing to verify that the project meets customer requirements. Rather than performing these tests by hand, it is easier to combine an automated testing system like RSpec with a driver like Capybara which allows testing of an application's functionality from the outside by running in a browser.

===Flow of the calibration function===
A more detailed description of the calibration may be found [https://docs.google.com/document/d/1LcicJCUY0GHN1qzwRQPL9A1Nv89sVtNtxlADOzVQeBk/edit#heading=h.g4vilf87e3f0 here]

Before analyzing code, one must familiarize themselves with the steps involved in calibration on Expertiza. The steps involved are:
# Login with valid instructor username and password
# Click on "Assignment"
# Click on "New public assignment"
# Input all the information needed, check the “Calibrated peer-review for training?” box, click on Create
# Select the review rubric in “Rubrics” tab
# Go to “Due dates” tab, make sure that this assignment is currently in Review phase, also, make the submission allowed in review phase.
# Add a submitter to the assignment. This submitter will add documents to be reviewed.
# Go to the list of assignments, click “edit” icon of the assignment
# Go to the “Calibration” tab, click on the "Begin" link next to the student artifact for the expert review, and click “Submit Review”
# Go to “Review strategy” tab, select Instructor-Selected as review strategy, then select the radio button “Set number of reviews done by each student” and input the number of reviews
# Login with valid student username and password who is a reviewer for the assignment
# Click on the assignment
# Click on “Other’s work”
# After clicking “Begin”, Expertiza will display peer-review page
# Click “Submit Review”
# Click “Show calibration results” to see expert review
# Login with valid instructor username and password
# Click on "Assignment"
# Click on the “view review report” to see the calibration report

== Creating the Tests==

===Gems involved===
* rspec-rails
* capybara
* selenium-webdriver
* factory_girl_rails

====Rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====Capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====Selenium====
Selenium is a portable software testing framework for web applications. Selenium provides a record/playback tool for authoring tests without learning a test scripting language (Selenium IDE). It is the default javascript webdriver for Capybara.

====Factory Girl====
Factory Girl <ref>[https://github.com/thoughtbot/factory_girl Factory Girl]</ref> is a factory gem meant for use in testing. It allows for easy and highly configurable on-the-fly model creation that allows tests to request a new instance of a model template and optionally override any of the defaults.

===Test Scenarios===
The following scenarios were considered when writing tests for the calibration use case:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
An instructor creates a calibrated assignment
:An instructor authenticates to expertiza
:They select to add a new assignment
:While creating the assignment, the instructor selects to turn calibration on
:After creating the assignment the instructor sees a calibration tab on the assignment page
</div>

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
An instructor edits the calibration configuration
:An instructor authenticates to expertiza
:They select to edit an existing assignment
:The instructor clicks on the calibration tab and sees it is populated with submitted artifacts
</div>

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
An expert submits a review for calibration
:An expert has been added to an assignment to provide the expert review
:The expert authenticates to Expertiza and begins the expert review
:The expert finishes and submits the review
</div>

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Student Calibration
:A student has submitted a response for the assignment and it is currently in the review phase
:The student authenticates to Expertiza and chooses to view calibration for the assignment
:The student sees their own answers compared to the expert review.
:Answers that match are marked green, and answers that differ are marked red.
</div>

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Instructor Calibration
:It is currently the review phase for an assignment
:An instructor authenticates to Expertiza and chooses to view calibration
:The instructor can see the percentages relating to student responses for the assignment
</div>

===Code===
Code for the tests exists in two locations
* [https://github.com/EricHorton/expertiza/blob/master/spec/factories/factories.rb Factory]
* [https://github.com/EricHorton/expertiza/blob/master/spec/features/calibration_spec.rb CalibrationSpec]

====Design Pattern====
We attempted to follow good OO practices by implementing the CRUD<ref>[https://en.wikipedia.org/wiki/Create,_read,_update_and_delete Create Read Update and Delete]</ref> design pattern using Factory Girl and Capybara.

====Structure====
Our specs follow the standard RSpec describe/it syntax. For example:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">

describe 'Some Feature' do
:before :each do

:end

:it 'should do x' do
::expect(true).to be(true)
:end

:it 'should not do y' do
::expect(true).to be(false)
:end
end
</div>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ git clone https://github.com/EricHorton/expertiza
</pre>

Create and then prepare the test database
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:test:prepare
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/calibration_spec.rb --order default
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:calibration-tests.png|Calibration Tests]]

=== Test Analysis ===

* All test cases are green, which means there are no currently failing tests.
* Test cases are run through the Selenium driver on Firefox for javascript support. Because they are full acceptance tests they are slower than regular unit tests, but still beat evaluating the feature by hand.
* Tests are independent and repeatable. Database changes are made within a transaction that is rolled back after tests complete.

==Project Resources==
# [https://github.com/EricHorton/expertiza GitHub Fork]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-21T21:39:27Z

Ychen71: /* Creating the Tests */ Update on design pattern

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is a suite of functional tests for the assignment calibration function. These tests are designed to provide integration, regression, and acceptance testing by using automation technologies.

===Problem Statement===
Expertiza has a feature called Calibration that can be turned on for an assignment. When this feature is enabled an expert, typically the instructor, can provide an expert review for the assignment artifacts. After students finish their own reviews they may compare their responses to the expert review. The instructor may also view calibration results to view the scores for the entire class.

While this is a preexisting feature within Expertiza, there currently exist no tests for it. The goal of this project is to fully test the entire flow of the calibration feature using the '''RSpec''' and '''Capybara''' frameworks.

===Motivation===
The moment a line of code is written it becomes legacy code in need of support. Test cases are used not only to ensure that code is operating properly, but also to ensure that it continues to do so after having been modified. An important aspect of this is acceptance testing to verify that the project meets customer requirements. Rather than performing these tests by hand, it is easier to combine an automated testing system like RSpec with a driver like Capybara which allows testing of an application's functionality from the outside by running in a browser.

===Flow of the calibration function===
A more detailed description of the calibration may be found [https://docs.google.com/document/d/1LcicJCUY0GHN1qzwRQPL9A1Nv89sVtNtxlADOzVQeBk/edit#heading=h.g4vilf87e3f0 here]

Before analyzing code, one must familiarize themselves with the steps involved in calibration on Expertiza. The steps involved are:
# Login with valid instructor username and password
# Click on "Assignment"
# Click on "New public assignment"
# Input all the information needed, check the “Calibrated peer-review for training?” box, click on Create
# Select the review rubric in “Rubrics” tab
# Go to “Due dates” tab, make sure that this assignment is currently in Review phase, also, make the submission allowed in review phase.
# Add a submitter to the assignment. This submitter will add documents to be reviewed.
# Go to the list of assignments, click “edit” icon of the assignment
# Go to the “Calibration” tab, click on the "Begin" link next to the student artifact for the expert review, and click “Submit Review”
# Go to “Review strategy” tab, select Instructor-Selected as review strategy, then select the radio button “Set number of reviews done by each student” and input the number of reviews
# Login with valid student username and password who is a reviewer for the assignment
# Click on the assignment
# Click on “Other’s work”
# After clicking “Begin”, Expertiza will display peer-review page
# Click “Submit Review”
# Click “Show calibration results” to see expert review
# Login with valid instructor username and password
# Click on "Assignment"
# Click on the “view review report” to see the calibration report

== Creating the Tests==

===Gems involved===
* rspec-rails
* capybara
* selenium-webdriver
* factory_girl_rails

====Rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====Capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====Selenium====
Selenium is a portable software testing framework for web applications. Selenium provides a record/playback tool for authoring tests without learning a test scripting language (Selenium IDE). It is the default javascript webdriver for Capybara.

====Factory Girl====
Factory Girl <ref>[https://github.com/thoughtbot/factory_girl]</ref> is a factory gem meant for use in testing. It allows for easy and highly configurable on-the-fly model creation that allows tests to request a new instance of a model template and optionally override any of the defaults.

===Test Scenarios===
The following scenarios were considered when writing tests for the calibration use case:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
An instructor creates a calibrated assignment
:An instructor authenticates to expertiza
:They select to add a new assignment
:While creating the assignment, the instructor selects to turn calibration on
:After creating the assignment the instructor sees a calibration tab on the assignment page
</div>

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
An instructor edits the calibration configuration
:An instructor authenticates to expertiza
:They select to edit an existing assignment
:The instructor clicks on the calibration tab and sees it is populated with submitted artifacts
</div>

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
An expert submits a review for calibration
:An expert has been added to an assignment to provide the expert review
:The expert authenticates to Expertiza and begins the expert review
:The expert finishes and submits the review
</div>

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Student Calibration
:A student has submitted a response for the assignment and it is currently in the review phase
:The student authenticates to Expertiza and chooses to view calibration for the assignment
:The student sees their own answers compared to the expert review.
:Answers that match are marked green, and answers that differ are marked red.
</div>

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Instructor Calibration
:It is currently the review phase for an assignment
:An instructor authenticates to Expertiza and chooses to view calibration
:The instructor can see the percentages relating to student responses for the assignment
</div>

===Code===
Code for the tests exists in two locations
* [https://github.com/EricHorton/expertiza/blob/master/spec/factories/factories.rb Factory]
* [https://github.com/EricHorton/expertiza/blob/master/spec/features/calibration_spec.rb CalibrationSpec]

====Design Pattern====
We attempted to follow good OO practices by implementing the CRUD<ref>[https://en.wikipedia.org/wiki/Create,_read,_update_and_delete]</ref> design pattern using Factory Girl and Capybara.

====Structure====
Our specs follow the standard RSpec describe/it syntax. For example:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">

describe 'Some Feature' do
:before :each do

:end

:it 'should do x' do
::expect(true).to be(true)
:end

:it 'should not do y' do
::expect(true).to be(false)
:end
end
</div>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ git clone https://github.com/EricHorton/expertiza
</pre>

Create and then prepare the test database
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:test:prepare
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/calibration_spec.rb --order default
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:calibration-tests.png|Calibration Tests]]

=== Test Analysis ===

* All test cases are green, which means there are no currently failing tests.
* Test cases are run through the Selenium driver on Firefox for javascript support. Because they are full acceptance tests they are slower than regular unit tests, but still beat evaluating the feature by hand.
* Tests are independent and repeatable. Database changes are made within a transaction that is rolled back after tests complete.

==Project Resources==
# [https://github.com/EricHorton/expertiza GitHub Fork]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-21T21:31:30Z

Ychen71: /* Creating the Tests */ Adding reference to factory girl

User:Ewhorton

2016-03-21T21:30:04Z

Ychen71: /* rspec-rails */

User:Ewhorton

2016-03-21T21:29:54Z

Ychen71: /* capybara */

User:Ewhorton

2016-03-21T21:29:46Z

Ychen71: /* factory girl */

User:Ewhorton

2016-03-21T21:29:33Z

Ychen71: /* selenium */ Update on title

User:Ewhorton

2016-03-21T14:39:24Z

Ychen71: /* Running the tests */ update on running test on default order

User:Ewhorton

2016-03-18T23:59:45Z

Ychen71: /* Flow of the calibration function */ Update on calibration function testing procedure

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Flow of the calibration function===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid instructor username and password
# Click on "Assignment"
# Click on "New public assignment"
# Input all the information needed, check the “Calibrated peer-review for training?” box, click on Create
# Select the review rubric in “Rubrics” tab
# Go to “Due dates” tab, make sure that this assignment is currently in Review phase, also, make the submission allowed in review phase.
# Go to the list of assignments, click “edit” icon of the assignment
# Go to the “Calibration” tab, click on the "Begin" link next to the student artifact for the expert review, and click “Submit Review”
# Go to “Review strategy” tab, select Instructor-Selected as review strategy, then select the radio button “Set number of reviews done by each student” and input the number of reviews
# Login with valid student username and password who is a reviewer for the assignment
# Click on the assignment
# Click on“Other’s work”
# After clicking “Begin”, Expertiza will display peer-review page
# Click “Submit Review”
# Click “Show calibration results” to see expert review
# Login with valid instructor username and password
# Click on "Assignment"
# Click on the “view review report” to see the calibration report

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====selenium====
Selenium is a portable software testing framework for web applications. Selenium provides a record/playback tool for authoring tests without learning a test scripting language (Selenium IDE). It is the default javascript webdriver for Capybara.

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T23:48:21Z

Ychen71: /* selenium */

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Flow of the calibration function===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====selenium====
Selenium is a portable software testing framework for web applications. Selenium provides a record/playback tool for authoring tests without learning a test scripting language (Selenium IDE). It is the default javascript webdriver for Capybara.

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:12:16Z

Ychen71: /* flow of the calibration function */

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Flow of the calibration function===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====selenium====

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:12:04Z

Ychen71: /* Steps for manual submission */

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===flow of the calibration function===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====selenium====

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:10:39Z

Ychen71: /* Future Work */

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====selenium====

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:10:16Z

Ychen71: /* Existing Bugs */

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====selenium====

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

=== Future Work ===

* To prevent students from uploading a file to a finished assignment, like the upload link button, remove the upload file button.
* Executable files can sometimes be a part of the assignment. To there needs to be a check while creating the assignment whether .exe files are allowed or not.
* To run the test on test database using factories and fixtures, so that the tests are completely independent.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:10:03Z

Ychen71: /* Existing Bugs */ deleted

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====selenium====

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

=== Existing Bugs ===

=== Future Work ===

* To prevent students from uploading a file to a finished assignment, like the upload link button, remove the upload file button.
* Executable files can sometimes be a part of the assignment. To there needs to be a check while creating the assignment whether .exe files are allowed or not.
* To run the test on test database using factories and fixtures, so that the tests are completely independent.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:07:45Z

Ychen71: /* Gems involved */ update on selenium section

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

====selenium====

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

=== Existing Bugs ===
During the course of our testing, we encountered two potential bugs in the Expertiza system. These are:
# A student can upload file even after the assignment is finished.
# A student can upload an .exe file to any assignment.

The following screenshots show these bugs on the current version of Expertiza used by the batch of Fall 2015.

[[File:one_screenshot_expertiza.jpg|List of Assignments in Expertiza with Current Stage]]

<center>'''Figure''': This screenshot shows the list of assignments along with their current stage in Expertiza.</center>

[[File:two_screenshot_expertiza.jpg|Select file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can select a file in a finished assignment in Expertiza.</center>

[[File:three_screenshot_expertiza.jpg|Uploaded file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can upload a file in a finished assignment in Expertiza.</center>

[[File:four_screenshot_expertiza.jpg|Select .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can select an .exe file in any assignment in Expertiza.</center>

[[File:five_screenshot_expertiza.jpg|Uploaded .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can upload an .exe file in any assignment in Expertiza.</center>

=== Future Work ===

* To prevent students from uploading a file to a finished assignment, like the upload link button, remove the upload file button.
* Executable files can sometimes be a part of the assignment. To there needs to be a check while creating the assignment whether .exe files are allowed or not.
* To run the test on test database using factories and fixtures, so that the tests are completely independent.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:07:13Z

Ychen71: /* Gems involved */ Update on Gem invovled

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''', '''capybara''' and '''selenium'''.

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

=== Existing Bugs ===
During the course of our testing, we encountered two potential bugs in the Expertiza system. These are:
# A student can upload file even after the assignment is finished.
# A student can upload an .exe file to any assignment.

The following screenshots show these bugs on the current version of Expertiza used by the batch of Fall 2015.

[[File:one_screenshot_expertiza.jpg|List of Assignments in Expertiza with Current Stage]]

<center>'''Figure''': This screenshot shows the list of assignments along with their current stage in Expertiza.</center>

[[File:two_screenshot_expertiza.jpg|Select file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can select a file in a finished assignment in Expertiza.</center>

[[File:three_screenshot_expertiza.jpg|Uploaded file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can upload a file in a finished assignment in Expertiza.</center>

[[File:four_screenshot_expertiza.jpg|Select .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can select an .exe file in any assignment in Expertiza.</center>

[[File:five_screenshot_expertiza.jpg|Uploaded .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can upload an .exe file in any assignment in Expertiza.</center>

=== Future Work ===

* To prevent students from uploading a file to a finished assignment, like the upload link button, remove the upload file button.
* Executable files can sometimes be a part of the assignment. To there needs to be a check while creating the assignment whether .exe files are allowed or not.
* To run the test on test database using factories and fixtures, so that the tests are completely independent.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:05:17Z

Ychen71: /* Assumptions */ delete assumption

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''' and '''capybara'''

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

=== Existing Bugs ===
During the course of our testing, we encountered two potential bugs in the Expertiza system. These are:
# A student can upload file even after the assignment is finished.
# A student can upload an .exe file to any assignment.

The following screenshots show these bugs on the current version of Expertiza used by the batch of Fall 2015.

[[File:one_screenshot_expertiza.jpg|List of Assignments in Expertiza with Current Stage]]

<center>'''Figure''': This screenshot shows the list of assignments along with their current stage in Expertiza.</center>

[[File:two_screenshot_expertiza.jpg|Select file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can select a file in a finished assignment in Expertiza.</center>

[[File:three_screenshot_expertiza.jpg|Uploaded file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can upload a file in a finished assignment in Expertiza.</center>

[[File:four_screenshot_expertiza.jpg|Select .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can select an .exe file in any assignment in Expertiza.</center>

[[File:five_screenshot_expertiza.jpg|Uploaded .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can upload an .exe file in any assignment in Expertiza.</center>

=== Future Work ===

* To prevent students from uploading a file to a finished assignment, like the upload link button, remove the upload file button.
* Executable files can sometimes be a part of the assignment. To there needs to be a check while creating the assignment whether .exe files are allowed or not.
* To run the test on test database using factories and fixtures, so that the tests are completely independent.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T21:03:42Z

Ychen71: /* Problem Statement */

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
The instructor does expert reviews first, then after students review calibration assignments and submit peer review results, they can check the expert review. Instructor can check "calibration results" to check the calibration results of the whole class. Currently, there is no feature test for calibration function. The goal is to understand the flow of the calibration function by mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Assumptions===
To successfully implement each scenario in the test, the following assumptions are taken:
# The feature test will use the development environment. In particular, it will use the '''expertiza_development''' database.
# An instructor entry is assumed to be present in the database. The credentials for this instructor is '''instructor6''' as username and '''password''' as password.
# A student entry is also assumed to be present in the database. The credentials for this student is '''student13''' as username and '''password''' as password.
# The assignment created for testing contain no teams and topic for selection.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''' and '''capybara'''

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

=== Existing Bugs ===
During the course of our testing, we encountered two potential bugs in the Expertiza system. These are:
# A student can upload file even after the assignment is finished.
# A student can upload an .exe file to any assignment.

The following screenshots show these bugs on the current version of Expertiza used by the batch of Fall 2015.

[[File:one_screenshot_expertiza.jpg|List of Assignments in Expertiza with Current Stage]]

<center>'''Figure''': This screenshot shows the list of assignments along with their current stage in Expertiza.</center>

[[File:two_screenshot_expertiza.jpg|Select file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can select a file in a finished assignment in Expertiza.</center>

[[File:three_screenshot_expertiza.jpg|Uploaded file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can upload a file in a finished assignment in Expertiza.</center>

[[File:four_screenshot_expertiza.jpg|Select .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can select an .exe file in any assignment in Expertiza.</center>

[[File:five_screenshot_expertiza.jpg|Uploaded .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can upload an .exe file in any assignment in Expertiza.</center>

=== Future Work ===

* To prevent students from uploading a file to a finished assignment, like the upload link button, remove the upload file button.
* Executable files can sometimes be a part of the assignment. To there needs to be a check while creating the assignment whether .exe files are allowed or not.
* To run the test on test database using factories and fixtures, so that the tests are completely independent.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T20:54:35Z

Ychen71: /* Introduction */ update on introduction

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is to Functional tests for Calibration function.

===Problem Statement===
Once an assignment is created by the instructor the only call to action for the student is to submit the assignment. Currently, there is no feature test for assignment submission. The goal is to understand the flow of the assignment submission by student manually and mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Assumptions===
To successfully implement each scenario in the test, the following assumptions are taken:
# The feature test will use the development environment. In particular, it will use the '''expertiza_development''' database.
# An instructor entry is assumed to be present in the database. The credentials for this instructor is '''instructor6''' as username and '''password''' as password.
# A student entry is also assumed to be present in the database. The credentials for this student is '''student13''' as username and '''password''' as password.
# The assignment created for testing contain no teams and topic for selection.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''' and '''capybara'''

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

=== Existing Bugs ===
During the course of our testing, we encountered two potential bugs in the Expertiza system. These are:
# A student can upload file even after the assignment is finished.
# A student can upload an .exe file to any assignment.

The following screenshots show these bugs on the current version of Expertiza used by the batch of Fall 2015.

[[File:one_screenshot_expertiza.jpg|List of Assignments in Expertiza with Current Stage]]

<center>'''Figure''': This screenshot shows the list of assignments along with their current stage in Expertiza.</center>

[[File:two_screenshot_expertiza.jpg|Select file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can select a file in a finished assignment in Expertiza.</center>

[[File:three_screenshot_expertiza.jpg|Uploaded file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can upload a file in a finished assignment in Expertiza.</center>

[[File:four_screenshot_expertiza.jpg|Select .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can select an .exe file in any assignment in Expertiza.</center>

[[File:five_screenshot_expertiza.jpg|Uploaded .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can upload an .exe file in any assignment in Expertiza.</center>

=== Future Work ===

* To prevent students from uploading a file to a finished assignment, like the upload link button, remove the upload file button.
* Executable files can sometimes be a part of the assignment. To there needs to be a check while creating the assignment whether .exe files are allowed or not.
* To run the test on test database using factories and fixtures, so that the tests are completely independent.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

User:Ewhorton

2016-03-18T20:38:33Z

Ychen71: Created page with "'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by ..."

'''Expertiza''' is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). It is used in select courses at NC State and by professors at several other colleges and universities. <ref>[https://github.com/expertiza/expertiza Expertiza on GitHub]</ref>

==Introduction==
Our contribution to this project is toFunctional tests for Calibration function. The tests would mock steps taken by the student when he/she manually submit the assignment.

===Problem Statement===
Once an assignment is created by the instructor the only call to action for the student is to submit the assignment. Currently, there is no feature test for assignment submission. The goal is to understand the flow of the assignment submission by student manually and mock this flow in the '''Feature Tests''' using '''RSpec''' and '''Capybara''' framework.

===Motivation===
Once the application is built, it is necessary to test its functionality. More importantly, it is essential to test the functionality from users perspective. '''Feature spec''' allows testing of your application's functionality from the outside either by simulating a browser or by headless browser simulation. By manually clicking on the interface, the tests can discover bugs in the system and so has ours.

===Assumptions===
To successfully implement each scenario in the test, the following assumptions are taken:
# The feature test will use the development environment. In particular, it will use the '''expertiza_development''' database.
# An instructor entry is assumed to be present in the database. The credentials for this instructor is '''instructor6''' as username and '''password''' as password.
# A student entry is also assumed to be present in the database. The credentials for this student is '''student13''' as username and '''password''' as password.
# The assignment created for testing contain no teams and topic for selection.

===Steps for manual submission===
Before analyzing code, one must familiarize themselves with the steps involved in assignment submission by student on Expertiza. The steps involved are:
# Login with valid student username and password
# Click on an assignment to submit
# Click on "Your Work"
# Paste the link or browse to the file containing your work
# Click on "Upload Link" or "Upload File" to submit deliverable

== Creating the Tests==

===Gems involved===
The gems used in feature testing are '''rspec-rails''' and '''capybara'''

====rspec-rails====
Rspec-rails is a testing framework for Rails 3.x and 4.x. It supports testing of models, controllers, requests, features, views and routes. It does this by accepting test scenarios called specs.<ref>[https://github.com/rspec/rspec-rails rpsce-rails on GitHub]</ref>

====capybara====
Capybara helps you test web applications by simulating how a real user would interact with your application. It comes with built in Rack::Test and Selenium support. WebKit is supported through an external gem.<ref>[https://github.com/jnicklas/capybara capybara on GitHub]</ref> To control the environments in which the scenarios are run, it provides before and after hooks.<ref>[https://www.relishapp.com/rspec/rspec-core/v/2-2/docs/hooks/before-and-after-hooks Before and after hooks]</ref>
*before(:each) blocks are run before each scenario in the group
*before(:all) blocks are run once before all of the scenarios in the group
*after(:each) blocks are run after each scenario in the group
*after(:all) blocks are run once after all of the scenarios in the group

===Test Scenarios===
Based on the steps involved in manual submission of the assignment, the following test scenarios are considered:

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to login 
:Login with student13 and password 
:Click on Sign In button 
:Updated page should have text content Assignment 
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to submit valid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki> 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule</nowiki>
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit invalid link to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link http:// 
:Updated page should display flash message with text URI is not valid
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able to upload valid link and a file to an ongoing assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on OnGoing Assignment 
:Click on Your work 
:Upload link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Upload file users_spec.rb 
:Updated page should have link <nowiki>http://www.csc.ncsu.edu/faculty/efg/517/f15/assignments</nowiki> 
:Updated page should contain filename users_spec.rb
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is not able submit valid link to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Page should not have Upload link button
</div>

<div style="width:750px; margin-top:20px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
Scenario to check whether student is able upload file to a finished assignment 
:Login with student13 and password 
:Click on Sign In button 
:Click on Finished Assignment 
:Click on Your work 
:Upload file student_submission_spec.rb 
:Updated page should contain filename student_submission_spec.rb
</div>

===Code===
Code for the feature test consist in two files:
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/assignment_setup.rb assignment_setup.rb] which contains method for creating assignments using controller calls.
* [https://github.com/shrenujgandhi/expertiza/blob/master/spec/features/student_submission_spec.rb student_assignment_submission.rb] which contain calls to assignment_setup, scenarios to test assignment submission and commands to delete the created assignments.

====Structure====

<div style="width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require files

RSpec.feature 'assignment submission when student' do

:before(:all) do
::create assignments for submission
:end

:before(:each) do
::capybara steps to login
:end

:after(:all) do
::delete assignments created
:end

:scenario 'submits only valid link to ongoing assignment' do
::mock steps using capybara
::make assertions
:end

:....
:....
:....

end
</div>

====Sample Scenario====

<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
require 'rails_helper'
require 'spec_helper'
require 'assignment_setup'

RSpec.feature 'assignment submission when student' do

active_assignment="FeatureTest"
expired_assignment="LibraryRailsApp"
d = Date.parse(Time.now.to_s)
due_date1=(d >> 1).strftime("%Y-%m-%d %H:%M:00")
due_date2=(d << 1).strftime("%Y-%m-%d %H:%M:00")

# Before all block runs once before all the scenarios are tested
before(:all) do
# Create active/ongoing assignment
create_assignment(active_assignment, due_date1)

# Create expired/finished assignment
create_assignment(expired_assignment, due_date2)
end

# Before each block runs before every scenario
before(:each) do
# Login as a student before each scenario
visit root_path
fill_in 'User Name', :with => 'student13'
fill_in 'Password', :with => 'password'
click_on 'SIGN IN'
end

# After all block runs after all the scenarios are tested
after(:all)do
# Delete active/ongoing assignment created by the test
assignment = Assignment.find_by_name(active_assignment)
assignment.delete

# Delete expired/finished assignment created by the test
assignment = Assignment.find_by_name(expired_assignment)
assignment.delete
end

# Scenario to check whether student is able to submit valid link to an ongoing assignment
scenario 'submits only valid link to ongoing assignment' do
click_on active_assignment
click_on 'Your work'
fill_in 'submission', :with => 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
click_on 'Upload link'
expect(page).to have_content 'http://www.csc.ncsu.edu/faculty/efg/517/f15/schedule'
end

end
</pre>

==Running the tests==

The following are steps required to run the test

* Clone the repository in a new directory
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ mkdir review
$ cd review
$ git clone https://github.com/shrenujgandhi/expertiza.git
</pre>

In case you don't have a database with student and instructor entries then download the dump from https://drive.google.com/a/ncsu.edu/file/d/0B2vDvVjH76uESEkzSWpJRnhGbmc/view. Extract its contents.
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
$ cd expertiza
$ rake db:create:all
$ cd Downloads/
$ mysql -u root -p expertiza_development < expertiza_scrubbed_2015_08_14.sql
password:

$ cd expertiza
$ rake db:migrate
</pre>

* Type the command to run tests for assignment submission
<pre style="font-size:12.5px; width:750px; margin-top:10px; border:1px solid lightgrey; background:ivory; color:black; padding-left:15px; padding-top:15px; padding-bottom:15px;">
rspec spec/features/student_submission_spec.rb
</pre>

==Test Results==

The following screenshot shows the result of the rspec command.

[[File:test_result_temp2_expertiza.jpg|Feature Test Result]]

=== Test Analysis ===

* ''7 examples, 0 failures'' imply that there are 7 test scenarios and none of them failed.
* The tests take around 35 seconds to run, which implies that they are fast.
* They are also repeatable as the assignments that are created in the ''before all'' block are also deleted in the ''after all'' block.
* They are also self-verifying as all the results are in green, which mean that all the cases passed.

=== Existing Bugs ===
During the course of our testing, we encountered two potential bugs in the Expertiza system. These are:
# A student can upload file even after the assignment is finished.
# A student can upload an .exe file to any assignment.

The following screenshots show these bugs on the current version of Expertiza used by the batch of Fall 2015.

[[File:one_screenshot_expertiza.jpg|List of Assignments in Expertiza with Current Stage]]

<center>'''Figure''': This screenshot shows the list of assignments along with their current stage in Expertiza.</center>

[[File:two_screenshot_expertiza.jpg|Select file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can select a file in a finished assignment in Expertiza.</center>

[[File:three_screenshot_expertiza.jpg|Uploaded file for finished assignment]]

<center>'''Figure''': This screenshot shows that a student can upload a file in a finished assignment in Expertiza.</center>

[[File:four_screenshot_expertiza.jpg|Select .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can select an .exe file in any assignment in Expertiza.</center>

[[File:five_screenshot_expertiza.jpg|Uploaded .exe file for ongoing assignment]]

<center>'''Figure''': This screenshot shows that a student can upload an .exe file in any assignment in Expertiza.</center>

=== Future Work ===

* To prevent students from uploading a file to a finished assignment, like the upload link button, remove the upload file button.
* Executable files can sometimes be a part of the assignment. To there needs to be a check while creating the assignment whether .exe files are allowed or not.
* To run the test on test database using factories and fixtures, so that the tests are completely independent.

==Project Resources==
# [https://github.com/shrenujgandhi/expertiza GitHub Link]
# [https://youtu.be/_58l0VPy04M YouTube Demo]

=References=
<references></references>

=External links=
* [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]

Active Job

2016-02-14T21:59:51Z

Ychen71:

Active Job

2016-02-14T21:59:02Z

Ychen71: /* External links */

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts various queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletters, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is an interface which you can work with common queueing backends.
The reason to have Active Job in place is to make sure Rails apps can have a job infrastructure. Other existing gems can build on this framework without the limitation of API difference between different job runners such as Delayed Job and Resque. With this feature choosing queueing backends can become an operational concern. Also, switching between those queueing backends without rewrite jobs become possible.<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref>

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting to carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher[https://rubygems.org/gems/mailcatcher/versions/0.6.1] is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

==External links==

*[http://www.rubyonrails.org/ Ruby on Rails official website] – rubyonrails.org
*[http://railscasts.com/ Railscasts.com] – (defunct) Short Screencasts that focus on Ruby on Rails technique
*[http://rubycasts.io/ Rubycasts.io] – Weekly 15 minute screencasts on the whole Ruby/Rails development stack
*[http://www.railstutorial.org/ The Rails Tutorial] – The Ruby on Rails Tutorial book and screencast series teach you how to develop and deploy Ruby on Rails apps
*[https://github.com/rails/rails Rails source code]

=='''References'''==
<references/>

Active Job

2016-02-14T21:58:46Z

Ychen71:

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts various queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletters, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is an interface which you can work with common queueing backends.
The reason to have Active Job in place is to make sure Rails apps can have a job infrastructure. Other existing gems can build on this framework without the limitation of API difference between different job runners such as Delayed Job and Resque. With this feature choosing queueing backends can become an operational concern. Also, switching between those queueing backends without rewrite jobs become possible.<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref>

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting to carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher[https://rubygems.org/gems/mailcatcher/versions/0.6.1] is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

==External links==

{{Wikibooks|Ruby on Rails}}
*[http://www.rubyonrails.org/ Ruby on Rails official website] – rubyonrails.org
*[http://railscasts.com/ Railscasts.com] – (defunct) Short Screencasts that focus on Ruby on Rails technique
*[http://rubycasts.io/ Rubycasts.io] – Weekly 15 minute screencasts on the whole Ruby/Rails development stack
*[http://www.railstutorial.org/ The Rails Tutorial] – The Ruby on Rails Tutorial book and screencast series teach you how to develop and deploy Ruby on Rails apps
*[https://github.com/rails/rails Rails source code]

=='''References'''==
<references/>

Active Job

2016-02-14T21:53:18Z

Ychen71:

Active Job

2016-02-14T21:52:55Z

Ychen71:

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts various queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletters, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is an interface which you can work with common queueing backends.<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref>
The reason to have Active Job in place is to make sure Rails apps can have a job infrastructure. Other existing gems can build on this framework without the limitation of API difference between different job runners such as Delayed Job and Resque. With this feature choosing queueing backends can become an operational concern. Also, switching between those queueing backends without rewrite jobs become possible.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting to carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher[https://rubygems.org/gems/mailcatcher/versions/0.6.1] is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-14T21:52:20Z

Ychen71: /* Introduction */ introduction update

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts various queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletters, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is an interface which you can work with common queueing backends.
The reason to have Active Job in place is to make sure Rails apps can have a job infrastructure. Other existing gems can build on this framework without the limitation of API difference between different job runners such as Delayed Job and Resque. With this feature choosing queueing backends can become an operational concern. Also, switching between those queueing backends without rewrite jobs become possible.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting to carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher[https://rubygems.org/gems/mailcatcher/versions/0.6.1] is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-14T21:30:50Z

Ychen71: /* 5. Try execution */

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts various queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletters, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is an interface which you can work with common queueing backends.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting to carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher[https://rubygems.org/gems/mailcatcher/versions/0.6.1] is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:56:44Z

Ychen71: /* Create a Job */

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts various queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletters, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is an interface which you can work with common queueing backends.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting to carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:56:04Z

Ychen71: /* Introduction */

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts various queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletters, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is an interface which you can work with common queueing backends.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:52:25Z

Ychen71: /* 4. Active JobRails Guides “Active Job Basics” 2014 */ grammar correction

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and views need to be set in order to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:51:02Z

Ychen71: /* Download */ github link added

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub[https://en.wikipedia.org/wiki/GitHub], as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:50:18Z

Ychen71: /* Download */ RubyGem link added

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems[https://en.wikipedia.org/wiki/RubyGems] you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:49:15Z

Ychen71: /* How to use http://guides.rubyonrails.org/active_job_basics.html */

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to create a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:48:58Z

Ychen71: /* Introduction */

== Introduction ==
Active Job is a framework that helps developers to write codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:47:47Z

Ychen71: /* 5. Try execution */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before trying the Mailer, MailCatcher is needed for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, one need to add the following into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser and visit localhost:3000/users/new. Then sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:46:12Z

Ychen71: /* Examples */ grammar correction

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
Send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
This example uses [https://github.com/resque/resque Resque] as the enqueuing backend. It'll need [http://redis.io/ Redis] before running Resque. Redis can be installed using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but it can be found [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now a UserController is in place to put the job into the queue for later execution. Set the email to be sent one minute later for testing.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the Mailer, we need MailCatcher for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later Resque scheduler has following output:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-12T21:42:30Z

Ychen71: grammar error correction

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like [https://github.com/nesquena/backburner Backburner], [https://github.com/collectiveidea/delayed_job Delayed Job], [https://github.com/bkeepers/qu Qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
This chapter is an introduction on how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
Enqueue the Job so it can be processed as soon as the queuing system is free:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
Most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, this example uses the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

Control a job to run on a queue by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in.<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can get Redis using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft [https://en.wikipedia.org/wiki/Microsoft_Windows Windows] platform, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the Mailer, we need MailCatcher for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-06T02:41:45Z

Ychen71: /* Examples */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, a example is provided to demonstrate how to use ActiveJob in practice.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref>. Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can get Redis using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft Windows[https://en.wikipedia.org/wiki/Microsoft_Windows] platform, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the Mailer, we need MailCatcher for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>

Active Job

2016-02-06T02:32:36Z

Ychen71: /* Introduction */

== Introduction ==
Active Job is a framework that helps developers writing codes and run them on the background automatically under different scenarios. It’s an interface that adapts different queueing backends like Backburner[https://github.com/nesquena/backburner], Delayed Job[https://github.com/collectiveidea/delayed_job], Qu[https://github.com/bkeepers/qu] and so on. Jobs can vary from schedule newsletter, follow-up emails to database housekeeping. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” ]</ref> Overall, Active Job is a interface which you can work with common queues.

__TOC__

====Ruby On Rails versions support Active Job====
{| class="wikitable sortable" style="float:left;"
|+ Version history
|-
! Version !! Date
|-
| 4.2 || 2014/12/19
|-
| 4.2.5 || 2015/11/13
|-
|}
 
====Active Job adapters<ref name="Active-Job-Adapter">Active Job Adapter[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"Active Job Adapter" ]</ref>====
List of queueing backends Active Job support:
*Backburner[https://github.com/nesquena/backburner]
*Delayed Job[https://github.com/collectiveidea/delayed_job]
*Qu[https://github.com/bkeepers/qu]
*Que[https://github.com/chanks/que]
*queue_classic[https://github.com/QueueClassic/queue_classic]
*Resque 1.x[https://github.com/resque/resque]
*Sidekiq[http://sidekiq.org/]
*Sneakers[https://github.com/jondot/sneakers]
*Sucker Punch[https://github.com/brandonhilkert/sucker_punch]
*Active Job Async Job
*Active Job Inline[http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]

=='''How to use <ref>http://guides.rubyonrails.org/active_job_basics.html</ref>'''==
We will introduce how to creating a job and and how to add the job into a queue. <ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> 
=== Download ===
With RubyGems you can install Active Job:
<pre>
$ gem install activejob
</pre>

[https://github.com/rails/rails/tree/master/activejob Souce code of Active Job] available on GitHub, as part of Rails.<ref> GitHub [https://github.com/rails/rails/tree/master/activejob “Active Job -- Make work happen later” 2015] </ref>

=== Create a Job ===
In Active Job, a process inserted in a queue and waiting for carry out is called “Job”. It’s possible to generate a Job using the Generator provided by Rails. You can create a Job in app/jobs. By doing the following, we created a Job called “update_wiki”. 
<pre>
$ bin/rails generate job update_wiki
invoke test_unit
create test/jobs/update_wiki_job_test.rb
create app/jobs/update_wiki_job.rb
</pre>
Active Job provides the ability to run your Job on a specific queue by creating a job: 
<pre>
$ bin/rails generate job update_wiki --queue urgent
</pre>
Files inside of app/jobs can be created manually, instead of using a generator. In Rails 4.2 an ActiveJob class inherits from ActiveJob::Base. In Rails 5.0, it has changed to now inherit from ApplicationJob. When upgrading from Rails 4.2 to Rails 5.0, an application_job.rb file is needed to be created in app/jobs/ and add the following content:<ref> Rails Guides [http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-1-to-rails-4-2 “A Guide for Upgrading Ruby on Rails” 2015] </ref>
<pre>
class ApplicationJob < ActiveJob::Base
end
</pre>
In Rails 4.2 a Job class defined a perform method and set a “queue_as” value:
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :default

def perform(*wiki)
# Do something later
wiki.update_contents
end
end
</pre>
There is a perform method to be called when the Job was first enqueued. 

=== Adding a Job to the queue ===
If you wish your Job be processed as soon as the queuing system is free, you can enqueue a Job like:
<pre>
UpdateWikiJob.perform_later wiki
</pre>
Or you can add a Job be performed tomorrow at noon:
<pre>
UpdateWikiJob.set(wait_until: Date.tomorrow.noon).perform_later(wiki)
</pre>
If you want your Job be performed a week from now, most of the queueing backends ( Sidekiq
, Delayed Job, etc. ) allow you to set a delay time.
<pre>
UpdateWikiJob.set(wait: 1.week).perform_later(wiki)
</pre>
=== Execution of Job ===
Active Job provides adapters for multiple queueing backends ([https://github.com/mperham/sidekiq/wiki Sidekiq], [https://github.com/resque/resque Resque], [https://github.com/collectiveidea/delayed_job Delayed Job] and [http://edgeapi.rubyonrails.org/classes/ActiveJob/QueueAdapters.html others]).<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref> Without setting any adapter, the job would be performed immediately. 
Queueing backend can be set at: /config/application.rb, in this example we use the Sidekiq.
<pre>
module YourApp
class Application < Rails::Application
# Be sure to have the adapter's gem in your Gemfile and follow
# the adapter's specific installation and deployment instructions.
config.active_job.queue_adapter = :sidekiq
end
end
</pre>
=== Play with Queues ===
Active Job allows to schedule the job to be processed on a specific queue, this became helpful as common adapters support multiple queues.
<pre>
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end
</pre>
Queue name can be prefixed for all jobs using config.active_job.queue_name_prefixin application.rb:
<pre>
# config/application.rb
module YourApp
class Application < Rails::Application
config.active_job.queue_name_prefix = Rails.env
end
end

# app/jobs/update_wiki_job.rb
class UpdateWikiJob < ActiveJob::Base
queue_as :low_priority
#....
end

# Now your job will run on queue production_low_priority on your
# production environment and on staging_low_priority on your staging
# environment
</pre>

You can control a job to run on a queue you like, by passing a :queue option to #set :
<pre>
MyJob.set(queue: :another_queue).perform_later(record)
</pre>

All the code snippets are referred from the source<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>

== Examples ==
In this section, some examples are provided to demonstrate how to use ActiveJob in practices.
=== Background Mail Sender ===
You can send emails asynchronously with Action Mailer which Active Job is already integrated in<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref>. Here in this example, we try to use Active Job with Action Mailer. 
==== 1. Getting started with Rails<ref name= "Welcome_to_Rails">GitHub [https://github.com/rails/rails “Welcome to Rails” 2015]</ref> ====
<pre>
# Install Rails if you haven’t done it yet:
$ gem install rails

# Create a new Rails application, “myapp_activejob”
# is the name of the application:
$ rails new myapp_activejob

# Change your directory to myapp_activejob
$ cd myapp_activejob
</pre>
Edit the Gemfile in the folder, add following into it:
<pre>
gem 'responders'
</pre>
Run “ $ bundle update “ and make sure “$ rails server” works.

==== 2. Resque setup<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>====
We will use [https://github.com/resque/resque Resque] as the enqueuing backend. You need to install [http://redis.io/ Redis] before you can run Resque. You can get Redis using [http://brew.sh/ Homebrew]:
<pre>
$ brew install redis
</pre>
Or you can download, extract and compile Redis using:<ref name= "Download_Redis">Redis [http://redis.io/download “Download Redis” 2016]</ref>
<pre>
$ wget http://download.redis.io/releases/redis-3.0.7.tar.gz
$ tar xzf redis-3.0.7.tar.gz
$ cd redis-3.0.7
$ make
</pre>
Redis does not officially support Microsoft Windows[https://en.wikipedia.org/wiki/Microsoft_Windows] platform, but you can find [https://github.com/MSOpenTech/redis Redis on Windows] by Microsoft Open Tech group. 
Next get Resque be installed. To use resque with Active Job, we also need resque-scheduler.
Add the following into Gemfile, and run “$ bundle install”.
<pre>
gem 'resque'
gem 'resque-scheduler'
</pre>
After the installation, create a Resque configuration file resque.rb in config/initializers/
<pre>
#config/initializers/resque.rb

Resque.redis = Redis.new(host: 'localhost', post: 6379)
Resque.after_fork = Proc.new { ActiveRecord::Base.establish_connection }
</pre>

As the Resque tasks and Resque Scheduler rake tasks are needed in this example, we need to create a resque.rake file in lib/tasks/:

<pre>
#lib/tasks/resque.rake

require 'resque/tasks'
require 'resque/scheduler/tasks'

namespace :resque do
task setup: :environment do
ENV['TERM_CHILD'] ||= '1'
ENV['QUEUE'] ||= '*'
require 'resque'
require 'resque-scheduler'
end
end
</pre>

==== 3. Creating a Mailer<ref name= "Action-Mailer-Basics">Rails Guides [http://guides.rubyonrails.org/action_mailer_basics.html “Action Mailer Basics” 2014]</ref> ====
By doing the things above, we already have our Rails project and the Resque for queuing get set. Next we will create a Mailer.

<pre>
$ bin/rails generate mailer user_mailer
</pre>

Create a method and a view for sending the email. 
In app/mailer/user_mailer.rb:

<pre>
#app/mailers/user_mailer.rb

class UserMailer < ActionMailer::Base
default from: 'from@example.com'

def test_email(email)
mail(
to: email,
subject: 'We are testing Active Job!'
)
end
end
</pre>
In app/views/user_mailer/test_email.text
<pre>
#app/views/user_mailer/test_email.text

Hey, we are testing Active Job!
</pre>

==== 4. Active Job<ref name= "Active-Job-Basics">Rails Guides [http://guides.rubyonrails.org/active_job_basics.html “Active Job Basics” 2014]</ref>====
Create a configuration file active_job.rb in config/initializers/ , to set Resque as queue_adapter.
<pre>
#config/initializers/active_job.rb

ActiveJob::Base.queue_adapter = :resque
</pre>

Create a Job with generator.
<pre>
$ bin/rails generate job test_email
</pre>

In the generated file app/jobs/test_email_job.rb, define the perform method and set it’s queue_as.

<pre>
#app/jobs/test_email_job.rb

class TestEmailJob < ActiveJob::Base
queue_as :email

def perform(email)
UserMailer.test_email(email).deliver_now
end
end
</pre>

Now we can use a UserController to put the job into the queue for later execution. Here we set the email to be sent one minute later for test.
<pre>
$ bin/rails generate job test_email
</pre>

<pre>
#app/controllers/users_controller.rb

class UsersController < ApplicationController
def new
@user = User.new
end

def create
@user = User.create(user_params)
TestEmailJob.new(@user.email).deliver_later!(wait: 1.minute)
# redirect somewhere
end
end
</pre>

Routes and view need to set to make it work.
<pre>
#config/routes.rb

Rails.application.routes.draw do
resources :users, only: [:new, :create]
end
</pre>

<pre>
#app/views/users/new.html.erb

<%= form_for @user do |f| %>
<%= f.email_field :email %>
<%= f.submit %>
<% end %>
</pre>

==== 5. Try execution ====
Before we try the Mailer, we need MailCatcher for the test. Add following into Gemfile and “$ bundle install”
<pre>
gem 'mailcatcher'
</pre>

To set the environment, add following things into config/environments/development.rb.
<pre>
#config/environments/development.rb

Rails.application.configure do
...
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: "localhost", port: 1025 }
end
</pre>

Run it!
<pre>
# Start mailcatcher
$ mailcatcher

# Start redis-server
$ redis-server

# Start resque:work
$ bundle exec rake resque:work

# Start resque:scheduler
$ rake environment resque:scheduler

# Finally start rails server
$ rails server
</pre>

Open the browser, visit localhost:3000/users/new and sign up as a new user. One minute later you can see following in Resque scheduler:

<pre>
resque-scheduler: [INFO] 2016-02-05T22:53:15+09:00: Processing Delayed Items
</pre>
And in MailCatcher:
<pre>
==> SMTP: Received message from '<from@example.com>' (315 bytes)
</pre>

=='''References'''==
<references/>