Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T15:48:17Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implement the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

* http://java.dzone.com/articles/design-patterns-visitor : The article explains the use of the Visitor pattern in Java. A real world analogy is given initially and then Java implementation of a Visitor pattern is explained. The author maintains a good flow and then concludes with a mention of few disadvantages of the pattern

* http://www.javaworld.com/javatips/jw-javatip98.html : This article provides a very detailed example of a Visitor pattern implementation in Java. The author guides the reader through each step, explaining the process as he goes along

* http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html : The article starts of by providing a brief description of the pattern, it's advantages and disadvantages and then provides a detailed example of the Visitor pattern. The flow is good and the code example is good, but the explanation of the code is not provided. However the code is quite self explanatory

* http://en.wikipedia.org/wiki/Visitor_pattern#Java_example : Another good example of the Java implementation obtained from Wikipedia

==Visitor Pattern in C++==
Following are the links which provide examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here : http://sourcemaking.com/design_patterns/visitor
* http://sourcemaking.com/design_patterns/visitor/cpp/2
* http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
Following are the links which provide examples based on Ruby

*http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby : This link provides a good discussion about all design patterns including the Visitor pattern. Implementation is done in Ruby and there are sufficient code examples

*https://gist.github.com/989193 : This link provides a singular example of Ruby implementation of the Visitor pattern

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Tutorials:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk : Provides a brief explanation of the motivation behind Visitor patterns, an example, a simple UML diagram for the pattern and mentions advantages of using the pattern

(2) https://www.youtube.com/watch?v=UYUopyMcWjw : Similar to the example before, but provides a sample Java implementation as well

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T15:47:14Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

* http://java.dzone.com/articles/design-patterns-visitor : The article explains the use of the Visitor pattern in Java. A real world analogy is given initially and then Java implementation of a Visitor pattern is explained. The author maintains a good flow and then concludes with a mention of few disadvantages of the pattern

* http://www.javaworld.com/javatips/jw-javatip98.html : This article provides a very detailed example of a Visitor pattern implementation in Java. The author guides the reader through each step, explaining the process as he goes along

* http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html : The article starts of by providing a brief description of the pattern, it's advantages and disadvantages and then provides a detailed example of the Visitor pattern. The flow is good and the code example is good, but the explanation of the code is not provided. However the code is quite self explanatory

* http://en.wikipedia.org/wiki/Visitor_pattern#Java_example : Another good example of the Java implementation obtained from Wikipedia

==Visitor Pattern in C++==
Following are the links which provide examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here : http://sourcemaking.com/design_patterns/visitor
* http://sourcemaking.com/design_patterns/visitor/cpp/2
* http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
Following are the links which provide examples based on Ruby

*http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby : This link provides a good discussion about all design patterns including the Visitor pattern. Implementation is done in Ruby and there are sufficient code examples

*https://gist.github.com/989193 : This link provides a singular example of Ruby implementation of the Visitor pattern

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Tutorials:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk : Provides a brief explanation of the motivation behind Visitor patterns, an example, a simple UML diagram for the pattern and mentions advantages of using the pattern

(2) https://www.youtube.com/watch?v=UYUopyMcWjw : Similar to the example before, but provides a sample Java implementation as well

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T15:43:46Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

* http://java.dzone.com/articles/design-patterns-visitor : The article explains the use of the Visitor pattern in Java. A real world analogy is given initially and then Java implementation of a Visitor pattern is explained. The author maintains a good flow and then concludes with a mention of few disadvantages of the pattern

* http://www.javaworld.com/javatips/jw-javatip98.html : This article provides a very detailed example of a Visitor pattern implementation in Java. The author guides the reader through each step, explaining the process as he goes along

* http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html : The article starts of by providing a brief description of the pattern, it's advantages and disadvantages and then provides a detailed example of the Visitor pattern. The flow is good and the code example is good, but the explanation of the code is not provided. However the code is quite self explanatory

* http://en.wikipedia.org/wiki/Visitor_pattern#Java_example : Another good example of the Java implementation obtained from Wikipedia

==Visitor Pattern in C++==
Following are the links which provide examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here : http://sourcemaking.com/design_patterns/visitor
* http://sourcemaking.com/design_patterns/visitor/cpp/2
* http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
Following are the links which provide examples based on Ruby

*http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby : This link provides a good discussion about all design patterns including the Visitor pattern. Implementation is done in Ruby and there are sufficient code examples

*https://gist.github.com/989193 : This link provides a singular example of Ruby implementation of the Visitor pattern

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Tutorials:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk

(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T15:43:06Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor : The article explains the use of the Visitor pattern in Java. A real world analogy is given initially and then Java implementation of a Visitor pattern is explained. The author maintains a good flow and then concludes with a mention of few disadvantages of the pattern
(2) http://www.javaworld.com/javatips/jw-javatip98.html : This article provides a very detailed example of a Visitor pattern implementation in Java. The author guides the reader through each step, explaining the process as he goes along
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html : The article starts of by providing a brief description of the pattern, it's advantages and disadvantages and then provides a detailed example of the Visitor pattern. The flow is good and the code example is good, but the explanation of the code is not provided. However the code is quite self explanatory
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example : Another good example of the Java implementation obtained from Wikipedia

==Visitor Pattern in C++==
Following are the links which provide examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here : http://sourcemaking.com/design_patterns/visitor
* http://sourcemaking.com/design_patterns/visitor/cpp/2
* http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
Following are the links which provide examples based on Ruby

*http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby : This link provides a good discussion about all design patterns including the Visitor pattern. Implementation is done in Ruby and there are sufficient code examples

*https://gist.github.com/989193 : This link provides a singular example of Ruby implementation of the Visitor pattern

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Tutorials:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk

(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T12:55:31Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provide examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here : http://sourcemaking.com/design_patterns/visitor
* http://sourcemaking.com/design_patterns/visitor/cpp/2
* http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
Following are the links which provide examples based on Ruby

*http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby : This link provides a good discussion about all design patterns including the Visitor pattern. Implementation is done in Ruby and there are sufficient code examples

*https://gist.github.com/989193 : This link provides a singular example of Ruby implementation of the Visitor pattern

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Tutorials:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk

(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:44:22Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provide examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here :
*http://sourcemaking.com/design_patterns/visitor
** http://sourcemaking.com/design_patterns/visitor/cpp/2
** http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
Following are the links which provide examples based on Ruby

*http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby : This link provides a good discussion about all design patterns including the Visitor pattern. Implementation is done in Ruby and there are sufficient code examples

*https://gist.github.com/989193 : This link provides a singular example of Ruby implementation of the Visitor pattern

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Tutorials:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk

(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:40:06Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here :
*http://sourcemaking.com/design_patterns/visitor
** http://sourcemaking.com/design_patterns/visitor/cpp/2
** http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Lectures:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk

(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:39:47Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here :
*http://sourcemaking.com/design_patterns/visitor
** http://sourcemaking.com/design_patterns/visitor/cpp/2
** http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Lectures:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk

(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:39:30Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here :
*http://sourcemaking.com/design_patterns/visitor
** http://sourcemaking.com/design_patterns/visitor/cpp/2
** http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

==Links to Video Lectures:==
(1) https://www.youtube.com/watch?v=mTJodk3vfdk
(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:31:47Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html : This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern : Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern : Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html : One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor : This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx : Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 : A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here :
*http://sourcemaking.com/design_patterns/visitor
** http://sourcemaking.com/design_patterns/visitor/cpp/2
** http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html : This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/ : The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html : The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

Video Lecture:
(1) https://www.youtube.com/watch?v=mTJodk3vfdk
(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:30:31Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html
This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern
Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern
Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html
One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor
This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx
Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1
A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here :
*http://sourcemaking.com/design_patterns/visitor
** http://sourcemaking.com/design_patterns/visitor/cpp/2
** http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html
This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/
The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html
The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

Video Lecture:
(1) https://www.youtube.com/watch?v=mTJodk3vfdk
(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:30:09Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html
This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern
Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern
Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html
One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor
This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx
Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1
A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here : http://sourcemaking.com/design_patterns/visitor

** http://sourcemaking.com/design_patterns/visitor/cpp/2
** http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html
This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/
The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html
The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

Video Lecture:
(1) https://www.youtube.com/watch?v=mTJodk3vfdk
(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:29:02Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html
This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern
Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern
Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html
One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor
This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx
Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1
A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here :
* http://sourcemaking.com/design_patterns/visitor
** http://sourcemaking.com/design_patterns/visitor/cpp/2
** http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html
This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/
The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html
The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

Video Lecture:
(1) https://www.youtube.com/watch?v=mTJodk3vfdk
(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:27:00Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html
This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern
Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader

* http://en.wikipedia.org/wiki/Visitor_pattern
Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html
One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor
This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx
Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==

(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1
A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here : http://sourcemaking.com/design_patterns/visitor

* http://sourcemaking.com/design_patterns/visitor/cpp/2
* http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html
This page explains visitor pattern in detail from the basics till implementation using C++. It has implementation details and also discusses issues that could possibly arise when using the Visitor pattern.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/
The author sets up the explanation by using the example of an Abstract syntax tree traversal. A brief comparison is also provided about the differences in a Java implementation and a Python implementation for the same.

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html
The author presents a similar example as the link before. A point to note about this link, is that there is sufficient amount of code, but not enough explanation. However, the code is still useful.

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

Video Lecture:
(1) https://www.youtube.com/watch?v=mTJodk3vfdk
(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T07:12:53Z

Avranade:

=Visitor Pattern, Directory of sites=
The Purpose of this article is to act as a "directory of sites", or a simple quick jump page for the reader. The effort is to try and collect good sources (blog posts, forum chats, general articles etc.) which deal with the Visitor pattern and to make this available to the readers with summary. The readers can then explore the links provided, to understand certain topics that they are interested in. Readers are also encouraged to edit the document in case they are able to contribute good material.
Since this is just a quick jump page, there will be an apparent lack of examples. This is in line with the requirements given in the writeup, since we are re-directing you to pages where you will get plenty of information.

==Introduction==
In Object Oriented Programming, the Visitor Pattern is a way of decoupling algorithms to be performed by an object. The way to do this is to create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

For more information on the Visitor pattern, you can visit the following links
* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html
This page can provide more introductory information on visitor pattern

* http://en.wikipedia.org/wiki/Visitor_pattern
Wikipedia provides a good condensed view on the topic of the Visitor pattern.

==Motivation==

Now that some information is present about what the Visitor pattern is and what it should do, let us explore the motivation behind using the Visitor pattern. Some links are provided for the reader to explore the topic and a brief summary is presented to guide the reader
* http://en.wikipedia.org/wiki/Visitor_pattern
Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html
One of the top visited sites for design pattern basics , oodesign.com has good introduction, examples and implementation details. Sample code is also available for the reader. The article is good not only from the point of view of explaining the motivation behind Visitor patterns, but also because it follows a good flow in setting up the topic, explanation using examples and concluding with a brief summary

* http://sourcemaking.com/design_patterns/visitor
This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx
Simple introductory page which describes and talks about the pattern in short. It is a very 'bare-bones' reference article, but is a good introductory piece

==Visitor Pattern in Java==
(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1 A comparison is provided between the 'before' and 'after' code based on the Visitor pattern implementation. This link and the next couple of links are part of the same discussion provided here : http://sourcemaking.com/design_patterns/visitor

* http://sourcemaking.com/design_patterns/visitor/cpp/2

* http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html
This page explains visitor pattern in detail from the basics upto implementation using C++ as language. It has implementation details and also have discussed issues that arise.

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

Video Lecture:
(1) https://www.youtube.com/watch?v=mTJodk3vfdk
(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T06:58:33Z

Avranade:

CSC/ECE 517 Fall 2012/ch2b 2w51 aa

2012-11-19T06:43:28Z

Avranade:

=Visitor Pattern, Directory of sites=

==Introduction==
In Object Oriented Programming, visitor pattern is a way of decoupling algorithms to be performed by an object. The way to do this is create a visitor class which would help to add new virtual function to the classes without modifying their structures. This is accomplished by creating appropriate specializations of the virtual function in visitor class which will take instance reference as input and implements the algorithm using double dispatch.

* http://kasunpanorama.blogspot.com/2010/04/understanding-visitor-pattern.html This page can provide more introductory information on visitor pattern

==Motivation==
* http://en.wikipedia.org/wiki/Visitor_pattern - Motivation for visitor patterns is nicely depicted in Wikipedia for Visitor pattern.

* http://www.oodesign.com/visitor-pattern.html - One of the top visited sites for design pattern basics to implementation, oodesign.com has good introduction, implementation details.

* http://sourcemaking.com/design_patterns/visitor This page has good detailed description of visitor pattern and the worth reading part is the discussion section of this page which also talks about how double dispatch is related to visitor.

* http://www.dofactory.com/Patterns/PatternVisitor.aspx - Simple introductory page which describes and talks about the pattern in short.
==Visitor Pattern in Java==
(1) http://java.dzone.com/articles/design-patterns-visitor
(2) http://www.javaworld.com/javatips/jw-javatip98.html
(3) http://snehaprashant.blogspot.com/2009/01/visitor-pattern-in-java.html
(4) http://en.wikipedia.org/wiki/Visitor_pattern#Java_example

==Visitor Pattern in C++==
Following are the links which provides examples based on C++:

* http://sourcemaking.com/design_patterns/visitor/cpp/1

* http://sourcemaking.com/design_patterns/visitor/cpp/3

* http://sourcemaking.com/design_patterns/visitor/cpp/2

* This page explains visitor pattern in detail from the basics upto implementation using C++ as language. It has implementation details and also have discussed issues that arise. http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.defaultroles.c++.html

==Visitor Pattern in Python==
Following are two links which provide good examples of implementation of visitor patterns in python:

* https://chris-lamb.co.uk/2006/12/08/visitor-pattern-in-python/

* http://curtis.schlak.com/2012/01/04/python-visitor-pattern-helper.html

==Visitor Pattern in Ruby==
(1) https://gist.github.com/989193
(2) http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby

==Advantages==
* This links helps to understand the advantage of a design pattern like visitor, which are the features it combines and how it makes it easy for programmer to implement those ideas. http://compilers.cs.ucla.edu/jtb/jtb-2003/whyvisitors/whyvisitors.html

* The applicability of visitor pattern can be found here: http://www.swe.uni-linz.ac.at/research/deco/designPatterns/visitor/visitor.abstract.html#Applicability

==Disadvantages==
* http://www.developerfusion.com/article/84939/iterators-composites-and-visitors/ This page has a subsection in the visitor pattern section which discusses issues related to visitor pattern.

* http://www.oodesign.com/visitor-pattern.html This page describes issues with visitor pattern in section Specific problems and implementation

Video Lecture:
(1) https://www.youtube.com/watch?v=mTJodk3vfdk
(2) https://www.youtube.com/watch?v=UYUopyMcWjw&feature=related

File:RottenPotatoes1.jpg

2012-10-27T17:53:41Z

Avranade:

The Cucumber Test with Features and Scenarios

Source : https://class.coursera.org/saas-2012-003/class/index

File:RottenPotatoes2.jpg

2012-10-27T17:53:35Z

Avranade:

Step for Home Page Passes

Source : https://class.coursera.org/saas-2012-003/class/index

File:RottenPotatoes3.jpg

2012-10-27T17:53:27Z

Avranade:

However Step for the "search_tmdb" link fails and others after that are skipped

Source : https://class.coursera.org/saas-2012-003/class/index

File:RottenPotatoes4.jpg

2012-10-27T17:53:20Z

Avranade:

The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped

Source : https://class.coursera.org/saas-2012-003/class/index

File:RottenPotatoes5.jpg

2012-10-27T17:53:09Z

Avranade:

Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario

Source : https://class.coursera.org/saas-2012-003/class/index

File:Storyboard.jpg

2012-10-27T17:52:51Z

Avranade:

Storyboard for the User Story

Source : https://class.coursera.org/saas-2012-003/class/index

File:BackgroundCucumber.jpg

2012-10-27T17:52:21Z

Avranade:

Cucumber Background

Source : https://class.coursera.org/saas-2012-003/class/index

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:51:41Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

<b>Note : </b>All images used in this article have been taken from screen captures of Coursera video lectures available [https://class.coursera.org/saas-2012-003/class/index here]. All content is owned by original authors and there is no copyright infringement intended. References have been provided in the image descriptions wherever necessary

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning [http://en.wikipedia.org/wiki/Test-driven_development Test-Driven Development (TDD)]. Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>
Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The Storyboard===
The [http://en.wikipedia.org/wiki/Storyboard#Software Storyboard] is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) Source : https://class.coursera.org/saas-2012-003/class/index ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. E.g. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. E.g. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action.

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios. (Click Image to expand) https://class.coursera.org/saas-2012-003/class/index ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) https://class.coursera.org/saas-2012-003/class/index]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped. (Click Image to expand) https://class.coursera.org/saas-2012-003/class/index]]

Now, we add the link for the “search_tmdb” action. For this, the [http://en.wikipedia.org/wiki/HAML HAML] for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped. (Click Image to expand) https://class.coursera.org/saas-2012-003/class/index]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario. (Click Image to expand) https://class.coursera.org/saas-2012-003/class/index]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the [http://en.wikipedia.org/wiki/Don't_repeat_yourself DRY principle]. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background. (Click Image to expand) https://class.coursera.org/saas-2012-003/class/index]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:50:15Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

<b>Note : </b>All images used in this article have been taken from screen captures of Coursera video lectures available [https://class.coursera.org/saas-2012-003/class/index here]. All content is owned by original authors and there is no copyright infringement intended. References have been provided in the image descriptions wherever necessary

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning [http://en.wikipedia.org/wiki/Test-driven_development Test-Driven Development (TDD)]. Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>
Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The Storyboard===
The [http://en.wikipedia.org/wiki/Storyboard#Software Storyboard] is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) Source : https://class.coursera.org/saas-2012-003/class/index ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. E.g. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. E.g. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action.

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios. (Click Image to expand) ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped. (Click Image to expand) ]]

Now, we add the link for the “search_tmdb” action. For this, the [http://en.wikipedia.org/wiki/HAML HAML] for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped. (Click Image to expand) ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario. (Click Image to expand) ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the [http://en.wikipedia.org/wiki/Don't_repeat_yourself DRY principle]. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background. (Click Image to expand) ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

File:Storyboard.jpg

2012-10-27T17:49:33Z

Avranade:

Storyboard for the User Story

https://class.coursera.org/saas-2012-003/class/index

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:46:39Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

<b>Note : </b>All images used in this article have been taken from screen captures of Coursera video lectures available [https://class.coursera.org/saas-2012-003/class/index here]. All content is owned by original authors and there is no copyright infringement intended. References have been provided in the image descriptions wherever necessary

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning [http://en.wikipedia.org/wiki/Test-driven_development Test-Driven Development (TDD)]. Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>
Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The Storyboard===
The [http://en.wikipedia.org/wiki/Storyboard#Software Storyboard] is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. E.g. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. E.g. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action.

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios. (Click Image to expand) ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped. (Click Image to expand) ]]

Now, we add the link for the “search_tmdb” action. For this, the [http://en.wikipedia.org/wiki/HAML HAML] for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped. (Click Image to expand) ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario. (Click Image to expand) ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the [http://en.wikipedia.org/wiki/Don't_repeat_yourself DRY principle]. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background. (Click Image to expand) ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:45:49Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

<b>Note : </b>All images used in this article have been taken from screen captures of Coursera video lectures available [here]. All content is owned by original authors and there is no copyright infringement intended. References have been provided in the image descriptions wherever necessary

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning [http://en.wikipedia.org/wiki/Test-driven_development Test-Driven Development (TDD)]. Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>
Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The Storyboard===
The [http://en.wikipedia.org/wiki/Storyboard#Software Storyboard] is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. E.g. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. E.g. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action.

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios. (Click Image to expand) ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped. (Click Image to expand) ]]

Now, we add the link for the “search_tmdb” action. For this, the [http://en.wikipedia.org/wiki/HAML HAML] for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped. (Click Image to expand) ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario. (Click Image to expand) ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the [http://en.wikipedia.org/wiki/Don't_repeat_yourself DRY principle]. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background. (Click Image to expand) ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:40:44Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning [http://en.wikipedia.org/wiki/Test-driven_development Test-Driven Development (TDD)]. Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>
Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The Storyboard===
The [http://en.wikipedia.org/wiki/Storyboard#Software Storyboard] is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. E.g. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. E.g. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action.

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios. (Click Image to expand) ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped. (Click Image to expand) ]]

Now, we add the link for the “search_tmdb” action. For this, the [http://en.wikipedia.org/wiki/HAML HAML] for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped. (Click Image to expand) ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario. (Click Image to expand) ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the [http://en.wikipedia.org/wiki/Don't_repeat_yourself DRY principle]. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background. (Click Image to expand) ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:39:56Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning [http://en.wikipedia.org/wiki/Test-driven_development Test-Driven Development (TDD)]. Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>
Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The Storyboard===
The [http://en.wikipedia.org/wiki/Storyboard#Software Storyboard] is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. E.g. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. E.g. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action.

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios. (Click Image to expand) ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped. (Click Image to expand) ]]

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped. (Click Image to expand) ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario. (Click Image to expand) ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the [http://en.wikipedia.org/wiki/Don't_repeat_yourself DRY principle]. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background. (Click Image to expand) ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:38:53Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning [http://en.wikipedia.org/wiki/Test-driven_development Test-Driven Development (TDD)]. Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>
Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The Storyboard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. E.g. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. E.g. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action.

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios. (Click Image to expand) ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped. (Click Image to expand) ]]

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped. (Click Image to expand) ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario. (Click Image to expand) ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the [http://en.wikipedia.org/wiki/Don't_repeat_yourself DRY principle]. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background. (Click Image to expand) ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:30:09Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>
Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The StoryBoard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios. (Click Image to expand) ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped. (Click Image to expand) ]]

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped. (Click Image to expand) ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario. (Click Image to expand) ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background. (Click Image to expand) ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T17:28:06Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the [http://www.themoviedb.org/ TMDb database] rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon [http://en.wikipedia.org/wiki/Behavior-driven_development Behavior-Driven Development (BDD)] basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The StoryBoard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:56:16Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The StoryBoard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
<pre>
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:54:13Z

Avranade: /* Further Reading */

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The StoryBoard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .

[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.

[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.

[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.

[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.

[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.

[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.

[http://cukes.info/ Cucumber] : Cucumber.

[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:53:31Z

Avranade: /* Further Reading */

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The StoryBoard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .
[http://railscasts.com/episodes/275-how-i-test Railscast on testing in Capybara] : Railscast on testing in Capybara.
[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs Capybara and Cucumber] : Capybara and Cucumber.
[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd The Truth about BDD] : The Truth about BDD.
[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html BDD and RSpec] : BDD and RSpec.
[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/ Cucumber and Capybara for Rails] : Cucumber and Capybara for Rails.
[http://rubysource.com/smelly-cucumbers/ Smelly Cucumbers] : Smelly Cucumbers.
[http://cukes.info/ Cucumber] : Cucumber.
[http://railscasts.com/episodes/155-beginning-with-cucumber Beginning with Cucumber] : Testing with Cucumber.

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:52:01Z

Avranade: /* Further Reading */

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The StoryBoard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara Capybara] : Capybara introduction .
[http://railscasts.com/episodes/275-how-i-test] : Railscast on testing in Capybara.
[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs] : Capybara and Cucumber.
[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd] : The Truth about BDD.
[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html] : BDD and RSpec.
[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/] : Cucumber and Capybara for Rails.
[http://rubysource.com/smelly-cucumbers/] : Smelly Cucumbers
[http://cukes.info/] : Cucumber
[http://railscasts.com/episodes/155-beginning-with-cucumber] : Testing with Cucumber

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:49:53Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The StoryBoard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara] : Capybara.
[http://railscasts.com/episodes/275-how-i-test] : Railscast on testing in Capybara.
[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs] : Capybara and Cucumber.
[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd] : The Truth about BDD.
[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html] : BDD and RSpec.
[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/] : Cucumber and Capybara for Rails.
[http://rubysource.com/smelly-cucumbers/] : Smelly Cucumbers
[http://cukes.info/] : Cucumber
[http://railscasts.com/episodes/155-beginning-with-cucumber] : Testing with Cucumber

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:46:55Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

===The StoryBoard===
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad<ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

===Elaboration of the User Story===
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara] : Capybara
[http://railscasts.com/episodes/275-how-i-test] : Railscast on testing in Capybara
[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs] : Capybara and Cucumber
[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd] : The Truth about BDD
[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html] : BDD and RSpec
[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/] : Cucumber and Capybara for Rails
[http://rubysource.com/smelly-cucumbers/] : Smelly Cucumbers
[http://cukes.info/] : Cucumber
[http://railscasts.com/episodes/155-beginning-with-cucumber] : Testing with Cucumber

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:45:43Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

==The StoryBoard==
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path <ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

==Elaboration of the User Story==
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==
[https://github.com/jnicklas/capybara] : Capybara
[http://railscasts.com/episodes/275-how-i-test] : Railscast on testing in Capybara
[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2012/ch1b_1w71_gs] : Capybara and Cucumber
[http://blog.objectmentor.com/articles/2008/11/27/the-truth-about-bdd] : The Truth about BDD
[http://benmabey.com/2008/05/10/slides-and-code-from-my-bddrspec-presentation.html] : BDD and RSpec
[http://www.allenwei.cn/cucumber-capybara-what-we-need-for-rails-integration-test/] : Cucumber and Capybara for Rails
[http://rubysource.com/smelly-cucumbers/] : Smelly Cucumbers
[http://cukes.info/] : Cucumber
[http://railscasts.com/episodes/155-beginning-with-cucumber] : Testing with Cucumber

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:36:27Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

==The StoryBoard==
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path <ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

==Elaboration of the User Story==
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

==Summary==

In summary, this article demonstrates the BDD/Cucumber test behaviour with the help of examples. It discusses the enhancement of Rotten Potatoes webpage for implementing a new feature, which is addition of a new movie by looking up the TMDb database rather than manually entering the movie name. This includes designing a Lo-Fi UI, writing scenarios and step definitions, even writing new methods for successfully executing the test cases using Cucumber. The article also introduces and explains the concept of Background in Cucumber, which helps in DRYing out the repeated code in scenarios of the same feature. The next chapter will discuss the TDD/RSpec behaviour and the approach to make all the scenarios pass.

== Topical References ==

<references/>
== Further Reading ==

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:35:35Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

==The StoryBoard==
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path <ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

==Elaboration of the User Story==
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:BackgroundCucumber.jpg|200 px|thumb|center|The Cucumber Background ]]

== Topical References ==

<references/>
== Further Reading ==

File:BackgroundCucumber.jpg

2012-10-27T02:33:41Z

Avranade: Cucumber Background

Cucumber Background

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:31:58Z

Avranade:

=SaaS 4.6 Enhancing Rotten Potatoes again=

== Introduction ==
The article is intended to be an accompaniment to the SaaS video lecture 4.6 titled “Enhancing Rotten Potatoes again” <ref name="video">Enhancing Rotten Potatoes again, http://www.youtube.com/watch?v=2l9uLw3y6J8<br></ref>, part of the SaaS video lecture series for the Software Engineering for SaaS hosted on the Coursera learning network. <ref>Coursera, https://www.coursera.org/</ref><br>The Rotten Potatoes webpage, designed in the previous lectures is enhanced for implementing a new feature to add a new movie by looking up the TMDb database<ref> TMDb — The Movie Database, http://www.themoviedb.org/</ref> rather than manually entering the movie name. The flow of this article is as follows :

*The scope of discussion
*Brief description of the storyboard used for the Lo-Fi UI design discussed in previous lectures in the video lecture series,
*Explanation of Sad path, Happy Path and Bad Path
*Description of the User Story developed in the video lecture
*Elaboration of the test scenarios written for the particular User story (including scenarios for happy and sad paths) in Cucumber
*Explanation of the Background facility in Cucumber

==Scope==
The scope of this article is limited only to the scope covered in the video lecture. The lecture builds upon Behavior-Driven Development (BDD) basics discussed in the video lectures before it and sets the reader up for upcoming lectures concerning Test-Driven Development (TDD). Hence for the purpose of this article, it is assumed that the reader has already read the material and watched the video lectures before this one in the series. Hence the setup for Cucumber, Capybara and BDD basics are excluded from this article. The resources dealing with these can be found in the SaaS lectures 4.1 to 4.5 in the series. Similarly, the theory and implementation of TDD as well as further discussion on BDD is excluded from the scope of this article. More details on these can be found in lectures 4.7 to 5.11 of the SaaS lecture series .<ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

==A Brief Recap==
Behavior-Driven Development (BDD) is a specialized development process which concentrates more on the behavioral aspects of the application as against the actual implementation of the application. <ref>Software Engineering for SaaS, https://class.coursera.org/saas-2012-003/class/index </ref>

Storyboards are used to show how UI changes based on user actions. Even if it is tedious to draw sketches and storyboards, it helps build a ‘bigger picture’ understanding of the flow of the application for the non-technical stakeholders.

Cucumber is one of the shining tools of Rails that is used for testing purposes. It acts as a halfway between the customer and the developer by converting user stories of 3x5 cards into tests.
These tests act as Acceptance tests for ensuring the satisfaction of the customer. Also, the tests act as Integration tests that ensures the communication between modules is consistent and correct

==The User Story==
The aim of the User story described in the video is to add a new feature to the Rotten Potatoes web page, to add a new movie to the movies list on Rotten Potatoes page. But, for adding the movie to the list, it populates the data from TMDb rather than entering the information by hand. This is aimed at reducing repetitive work since the TMDb already has a good database of movies.
To do so, the ability to search TMDb from Rotten Potatoes home page needs to be incorporated in the webpage. Users can then search in TMDb if the movie is present in it and then its details can be imported into Rotten Potatoes. For integrating this feature into the application, first, a Lo-Fi UI and Storyboard is designed, which is described next.

==The StoryBoard==
The Storyboard is to be interpreted as follows
When a person wants to add a new movie to the Movies list on Rotten Potatoes, he/she will enter the new movie name and click “Search”. The controller method should search the TMDb database for the given movie. If a match is found, i.e. the movie is present in the TMDb, then the “Match” page is displayed. If there is no match, otherwise “No Match” page is displayed. These two scenarios, are the Happy Path and Sad Path implementations respectively.
[[File:Storyboard.jpg|200 px|thumb|center|The Storyboard for the User Story. (Click Image to expand) ]]

==Happy Path, Sad Path and Bad path <ref>http://www.nishantverma.com/2010/03/test-case-paths-happy-sad-bad.html
</ref>==
Many of us are aware of the test cases being categorized as Positive or Negative test cases. Similarly, for testing using Rails Cucumber, the tests cases are being categorized as Happy, Sad of Bad. A test case that results in a positive result is called a Happy Path. Ex. On entering correct username and password on login page, the application logs the user in.
A test case that yields no result is called a Sad Path. Ex. Entering invalid username or password on login page, which normally returns an ‘Incorrect username or password’ message
A test case to handle an exceptional condition or situation, which the system should handle elegantly and show some message to the user is a Bad Path. E.g. Uploading image size exceeds a limited amount. User can then take corrective action

==Elaboration of the User Story==
Let us consider the sad path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add non-existent movie (sad path)

Given I am on the RottenPotatoes home page
Then I should see "Search TMDb for a movie"
When I ﬁll in "Search Terms" with "Movie That Does Not Exist"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "'Movie That Does Not Exist' was not found in TMDb."
</pre>

The Test shown above has 6 steps (The logic and code for implementing this is provided in the TDD lectures in the Coursera series).
[[File:RottenPotatoes1.jpg|200 px|thumb|center|The Cucumber Test with Features and Scenarios ]]

*First the test checks if the user is on the Home Page, viz. the Home page for the application exists.
*Next, it checks for presence of the link to “Search TMDb for movie”. The test essentially simulates what a normal user would do when testing the application manually.
*In the third step, the test populates the form for the Search, with a movie name that is not present in the TMDb (since this is a sad path implementation, the search should essentially fail.)
*Next, the test checks (simulates) if the link can be clicked.
*As a consequence of this, the user should navigate to the Rotten Potatoes home page.
*For a Sad path, the user is shown a message mentioning that there was no match, on the home page itself.

When we run the test, since there is already a home page, the first step of the scenario passes.
[[File:RottenPotatoes2.jpg|200 px|thumb|center|Step for Home Page Passes. (Click Image to expand) ]]
In the second step of the scenario, there is no link on the view for adding a new movie. Hence the second step fails and the following steps are skipped.
[[File:RottenPotatoes3.jpg|200 px|thumb|center|However Step for the "search_tmdb" link fails and others after that are skipped ]]
<pre>

Now, we add the link for the “search_tmdb” action. For this, the HAML for Search TMDb page should contain the following:
%h1 Search TMDb for a movie

= form_tag :action => 'search_tmdb' do

%label{:for => 'search_terms'} Search Terms
= text_field_tag 'search_terms'
= submit_tag 'Search TMDb'
</pre>

These are added into the end of <code>app/views/movies/index.html.haml</code>

The last two lines in the above code will be expanded into the HTML code:

<pre>
<label for='search_terms'>Search Terms</label>

<input id="search_terms" name="search_terms"type="text" />
</pre>

Now there is a page and a link in place for the test. On running the test using Cucumber again, the test fails again. This is because there is still no method defined in the controller (movies_controller.rb) for actually searching in TMDb.

[[File:RottenPotatoes4.jpg|200 px|thumb|center|The Link for search_tmdb is added to the view, but there is no method for search_tmdb in controller. Also there is no route. Hence these steps fail or are skipped ]]

However the video tutorial in this discussion considers only the sad path scenario. To test this Sad path implementation, a dummy/fake method is defined in the movies_controller.rb which fails everytime, i.e. the search for the movie in TMDb never returns a match.

So, the following code for the fake controller method is added to the movies_controller.rb:
<pre>
def search_tmdb
# hardwire to simulate failure
flash[:warning] = "'#{params[:search_terms]}' was not found in TMDb."
redirect_to movies_path
end
</pre>

and since a new method has been added, we need to add a route to this controller method too. The following route is added to routes.db, just before or just after <code>‘resources :movies’</code>:
<pre>
# Route that posts 'Search TMDb' form
post '/movies/search_tmdb'
</pre>

Now, on running the test again using Cucumber, every time the method is called, it returns a failure message (since it is hard-coded). This implies that the sad path implementation passed.
[[File:RottenPotatoes5.jpg|200 px|thumb|center|Dummy method added to controller for 'search_tmdb' and then a route is also added. The dummy method fails everytime thereby satisfying the sad path scenario ]]

The actual code and logic for implementation of this action (search_tmdb) is discussed in later lectures which discuss the TDD (Test Driven Development) process

So far we have considered the Sad path scenario.

Let us consider the happy path scenario for the Search TMDb User Story Feature.
<pre>
Feature: User can add movie by searching in The Movie Database(TMDb)

User Story:
As a movie fan
So that I can add new movies without manual tedium
I want to add movies by looking up their details in TMDb

Scenario: Try to add existing movie (happy path)

When I fill in "Search Terms" with "Inception"
And I press "Search TMDb"
Then I should be on the RottenPotatoes home page
And I should see "Inception"
And I should see "PG-13"
</pre>

For implementation of this, instead of the hard coded Controller method, an actual controller method will have to written which searches TMDb and returns the details of the movie which will then be added to the Rotten Potatoes database. (However, this implementation is out of scope for our article. Further details of this can be found in the TDD lectures of this series.)

Now, the Happy and the Sad paths have some code in common which violates the DRY principle. So, to make it DRY, Cucumber offers a solution called Background <ref>Background in Cucumber, https://github.com/cucumber/cucumber/wiki/Background</ref>. The steps which are common to both the paths are written in Background and those steps will run in the background before all the other scenarios. No matter what scenario one runs, the steps in the Background will run first, which will DRY out the code. This also helps in reducing the effort in case any steps leading up to the scenarios (setup) are to be modified. The tester will only have to change the code in one location. In this example there is only one happy path and sad path scenario i.e. only two scenarios. However, in real world examples, there would be a larger list of scenarios which could have the same ‘setup’. The advantages of the Background facility are more pronounced in this case.
[[File:Background.jpg|200 px|thumb|center|The Cucumber Background ]]

== Topical References ==

<references/>
== Further Reading ==

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T02:24:09Z

Avranade:

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T01:25:50Z

Avranade:

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T01:24:10Z

Avranade:

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T01:20:52Z

Avranade:

CSC/ECE 517 Fall 2012/ch2a 2w26 aj

2012-10-27T01:20:31Z

Avranade: