Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:55:12Z

Amaroo: /* References */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules<ref>http://guides.rubyonrails.org/action_controller_overview.html</ref>. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema <ref>http://guides.rubyonrails.org/migrations.html</ref>.
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data<ref>http://ar.rubyonrails.org/classes/Fixtures.html</ref>. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key<ref>http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/</ref>. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory<ref>http://guides.rubyonrails.org/testing.html</ref>. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications<ref>http://en.wikipedia.org/wiki/Functional_testing</ref>. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view <ref>http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/</ref>. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group<ref>http://en.wikipedia.org/wiki/Integration_testing</ref>. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
<references/>

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:54:25Z

Amaroo: /* Integration Tests */

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:53:58Z

Amaroo: /* Functional Tests */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules<ref>http://guides.rubyonrails.org/action_controller_overview.html</ref>. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema <ref>http://guides.rubyonrails.org/migrations.html</ref>.
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data<ref>http://ar.rubyonrails.org/classes/Fixtures.html</ref>. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key<ref>http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/</ref>. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory<ref>http://guides.rubyonrails.org/testing.html</ref>. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications<ref>http://en.wikipedia.org/wiki/Functional_testing</ref>. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view <ref>http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/</ref>. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
<references/>

* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:53:24Z

Amaroo: /* Unit tests */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules<ref>http://guides.rubyonrails.org/action_controller_overview.html</ref>. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema <ref>http://guides.rubyonrails.org/migrations.html</ref>.
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data<ref>http://ar.rubyonrails.org/classes/Fixtures.html</ref>. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key<ref>http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/</ref>. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory<ref>http://guides.rubyonrails.org/testing.html</ref>. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
<references/>

* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:52:50Z

Amaroo: /* Fixtures */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules<ref>http://guides.rubyonrails.org/action_controller_overview.html</ref>. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema <ref>http://guides.rubyonrails.org/migrations.html</ref>.
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data<ref>http://ar.rubyonrails.org/classes/Fixtures.html</ref>. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key<ref>http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/</ref>. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
<references/>

* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:51:39Z

Amaroo: /* Migrations */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules<ref>http://guides.rubyonrails.org/action_controller_overview.html</ref>. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema <ref>http://guides.rubyonrails.org/migrations.html</ref>.
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
<references/>

* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:50:53Z

Amaroo: /* Model, View and Controller */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules<ref>http://guides.rubyonrails.org/action_controller_overview.html</ref>. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
<references/>

* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:49:47Z

Amaroo: /* References */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
<references/>

* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:48:14Z

Amaroo: /* References */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:47:00Z

Amaroo: /* View */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend <ref>http://en.wikipedia.org/wiki/Model-View-Controller</ref>.

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:45:50Z

Amaroo: /* Model */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:43:47Z

Amaroo: /* Model */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref> http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:41:46Z

Amaroo: /* Model */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems <ref>http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/</ref>. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:37:29Z

Amaroo: /* Fixtures */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

[[File:42.png|1000px]]

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

File:42.png

2011-10-30T15:36:07Z

Amaroo:

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:30:44Z

Amaroo: /* Performance Tests */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found [http://guides.rubyonrails.org/performance_testing.html here].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-30T15:26:35Z

Amaroo: /* Testing */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Performance Tests===

Performance tests are used for profiling and benchmarking the test code. It helps to determine where the applications memory and speed problems are coming from and gives a more in-depth picture of these problems.

Performance testing is an integral part of development life cycle as you do not want your end users to have a bad experience. If your application is too slow then the user has to wait for long for each page to be completely loaded. Performance testing helps to give a pleasant browsing experience to end users and also helps in cutting the costs of unnecessary hardware.

Examples can be found here[http://guides.rubyonrails.org/performance_testing.html].

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:30:54Z

Amaroo: /* Integration Tests */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:30:32Z

Amaroo: /* Unit tests */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:29:58Z

Amaroo: /* References */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book Ruby on Rails Tutorial]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:28:37Z

Amaroo: /* References */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]
* 11. [http://ruby.railstutorial.org/ruby-on-rails-tutorial-book]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:26:48Z

Amaroo:

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==Conclusion==

In the lecture we have learn how to make a rails application using ruby mine. Also we have learn different types of testing and there usages. Since ruby is a dynamically typed language it makes testing an integral part of the rails application.

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:06:58Z

Amaroo: /* Fixtures */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

[[File:41.png|1000px]]

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]

File:41.png

2011-10-22T02:06:30Z

Amaroo:

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:05:17Z

Amaroo: /* Fixtures */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

[[File:40.png|1000px]]

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]

File:40.png

2011-10-22T02:04:38Z

Amaroo:

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:02:22Z

Amaroo: /* Unit tests */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:Fixtures.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T02:01:26Z

Amaroo: /* Unit tests */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

[[File:44.png|1000px]]

*assert – It evaluates an object (or expression) for expected results.

If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]

CSC/ECE 517 Fall 2011/ch4 4e ar

2011-10-22T01:59:58Z

Amaroo: /* Fixtures */

<big>'''Lecture 10'''</big>

==Model, View and Controller==
===Model===
'''Definition''': The model represents all the data in the application.

A model is typically mapped to a table in the database. It maintains the state of an application and responds to changes to alter it. The model provides the developer with a consistent interface to handle and manipulate the data in an application. It hides a object-relation-mapping underneath, allowing the application to be portable to various database management systems [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/]. The model also validates the data before storing it. The code for a model can be found in the ''apps/models'' directory of a rails project.

===View===
'''Definition''': A view renders the model in a form suitable for the user to comprehend[http://en.wikipedia.org/wiki/Model-View-Controller].

A view queries the model to obtain data and generates an interface to display it. Typically, the controller instructs a view to render itself. However, in some cases, the view is automatically notified by the model of changes in state. The view can render itself to the user in many ways, HTML, CSS, XML, Javascript, JSON are the common ones. The code for the views can be found in the ''app/views'' directory of a rails project.

===Controller===
'''Definition''': A controller accepts input from the user and instructs the rest of the framework to respond to it.

Typically, the user input is modeled as an event and the controller converts it to a user action, understandable by the model. Based on the input, it also decides which views to render. The controller is also responsible for a number of auxiliary services like session management, caching and helper modules[http://guides.rubyonrails.org/action_controller_overview.html]. Code for a controller can be found in the ''app/controllers/'' directory of a rails project.

==A Rails Project==
* [http://www.jetbrains.com/ruby/ RubyMine] is an IDE for Ruby. We will be developing out rails project using it.

===Start a rails project===
* To start a new rails project, click on the "New Project” link or select it from File Menu.
* Enter the project name, location and its type. In this case, it is a 'Rails application'.
[[File:Ch43-ar-1.PNG‎]]
* Select the ruby interpreter you want to use.
* Select the rails version. There are significant differences among different rails version, so it is important to select the correct version.
* Select a JavaScript library for your views.
* Rails can work with a variety of databases like [http://www.sqlite.org/ SQLite], [http://www.mysql.com/ MySQL], [http://www.postgresql.org/ PostgreSQL]. Select the one that you want from the drop down menu. We use SQLite3 for this project
[[File:Ch4e-ar-2.PNG‎]]
* Click Ok to finish your initial project configuration
* You can see Ruby Mine executes a command for you. If the projects gets successfully created then you will see “Process finished with exit code 0”.
[[File:Ch4e-ar-3.png|1000px]]
* Once the project gets created it is important to test if your project is running. To do this, start the server by pressing the green button on the top. On doing so, you should see a welcome screen if the server was started successfully.
[[File:Ch4e-ar-5.png|1000px]]

===The three things===
Before you start actual development of your application, there are three things that you need to do.
* Remove the index.html file from the public directory of your rails project. This is a static file, and static files are given preference over dynamic ones. Hence unless this file is deleted, it will the home page of your application.
* Modify the default route in the config/routes.rb file to point to the page that you want to be the home page of your application.
* Use rake to create tables in your database corresponding to your models (explained in subsequent section).

===Use scaffolds to build===
* Now generate the other components of the project. This is done using scaffolds.
* 'Scaffolding' is rails way to models, views, and controllers for a new resource in a single operation.
* To generate a scaffold, go to “Tools” and use “Run Rails Generator”. You will be prompted with what type of generator you want.
* Type Scaffold and press enter.
* Enter the scaffold name and the attributes along with their data types. Scaffold name should be singular.
* Attributes and data types are inserted as <Atrribute_name>:<data type>. Multiple attributes can be space separated.
[[File:Ch4e-ar-6.png|1000px]]
* Scaffolding provides the application developer with a template that has some of the common operations implemented. The developers needs to extend the scaffold by adding functionality required by that specific application
* For this project, we have created a scaffold for the 'category' resource.
[[File:Ch4e-ar-8.png|1000px]]
* The image below shows some of the methods generated by scaffolding in the controller for category.
[[File:Ch4e-ar-7.png|1000px]]

===Migrations===
* Migrations are ruby ways to alter the database in a structured and organized manner.
* Although, it is possible for a developer to write SQL statements and alter it, migrations make the changes noticeable to other developers as well.
* One of the major advantages of migrations is that they allow version control on the database schema [http://guides.rubyonrails.org/migrations.html].
* When you move between different versions of your code, Active Record will work out which migrations should be run. It will also update the db/schema.rb file to match the structure of your database at that version.
* Another advantage of migrations is that they allow database portability. Use migrations is similar to using an interface, using SQL is similar to using an implementation. Hence, using migrations can allow you to use SQLite3 for development and say MySQL in production. The migrations will transform you schema into the database specific construct, without having you worry about it.
* To create a migration, go to "Tools" menu, then "Rake tasks", then "db" and click on "migrate".
[[File:Ch4e-ar-9.png|1000px]]
* Now, select which migration you want to run from the drop down menu.
[[File:Ch4e-ar-10.png|1000px]]

==Testing==
===Fixtures===
Fixtures are used to provide our tests with data i.e. sample data[http://ar.rubyonrails.org/classes/Fixtures.html]. They come in three flavors:
* YAML fixtures
* CSV fixtures
* Single-file fixtures
YAML is the default format. It is a cleaner version of XML for representing data. Each model has a corresponding fixture file with the same name in test/fixtures/ path of your app’s root directory. The fixture file ends with .yml extension. Each YAML fixture is given a name and is followed by an indented list of key/value pairs in “key:value” format.

In the above fig. one is a name of fixture. It does not matter what name you use. The entries after one are the “column_name:value” for the record one.
You can use scaffold to generate the fixtures for you. But it’ll give just the basic features. If there are any relationships then you have to explicitly specify them. You can do it by adding just foreign key name and it’ll figure out from where to populate the foreign key[http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/]. For example if you have used scaffold to generate MVC components of categories and recipes then it’ll generate categories.yml and recipes.yml for you. But now you’ll need to add the relationships manually, as shown below

One thing you need to think is that for how long you want the data in test database. You need it just for testing and once it is finished you can throw it away. Also for the testing it does not make sense to read the data from a remote server or from a file because of the life span of a test. So instead it’s just handy to load the database into memory, run your tests and throw it away. Because when we run the tests the data gets corrupted anyway for the next sets of tests.

Steps to make changes in your app for fixtures
* Go to gem file and (bundler uses the gem file) and add a gem “memory_test_fix” inside “group :test” as shown in fig below. It’s a monkey patch which is specially written to load the database and throw in the end. If we do just the “rake:db:migrate” task then it is not sufficient as it’ll bring the data in memory but as soon as the task finishes everything is gone away. So we’ll not be able to run our tests. This patch will keep the data in memory during the iteration of our tests.
* Also add a gem “test_unit” to get a GUI to see the test results.
* Go to database.yml file (config/database.yml) and change the test database to “:memory:”. It’ll keep the test database in memory and never look at disk so our test will run fast. It is not required but will help when we are having so many tests to run.
* Update bundler as you have added new packages.

Sometimes for testing the content of the data is not as much important as is the volume. In those cases, you can mix ERB in your fixtures. For example if you want 100 categories in your category table then instead of writing them manually you can do it as –

Now in your tests you can use fixtures by specifying which fixture you want. For example, if you want posts fixture in one of your tests then you can specify it as

[[File:55.png|1000px]]

===Unit tests===
Unit tests are used for testing models. When we generate a model using the scaffold it also generates a unit test script for the model in the tests directory[http://guides.rubyonrails.org/testing.html]. In unit tests we can use the data generated using fixtures. As we write code in model classes we must write corresponding unit tests.
For example consider you want all the fields for Recipe to be present. It can be tested as shown below –

*assert – It evaluates an object (or expression) for expected results.
If you have used “test_unit” gem then on executing tests you will get a result screen as
[[File:UnitTests.png|1000px]]

The green bar means that all the tests have passed. If any of the tests fails then you’ll get a red var.

===Functional Tests===
Functional testing is a type of black-box testing which verifies the system behavior according to the specifications[http://en.wikipedia.org/wiki/Functional_testing]. In a rails projects, we apply functional tests on controllers to validate the workflow that they setup and verify if it results in the intended outcome. In rails, the controllers are primarily responsible for tasks such as routing of requests, handling user authentication, validating correctness of output produced etc. Of three entities in a rails project, there is tight coupling between the controller and the view [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/]. Hence, as a part of functional testing we also validate if the the content displayed by the view is of the correct format and content and the layout of the page is as expected.
The image below shows some of the functional test written for the categories controller. As you can see, tests like "should create category" checks if the categories controller can function as per specifications i.e. if it can create a new category.
[[File:Functional.png|1000px]]

===Integration Tests===
Integration testing is a testing technique in which various software modules are combined and tested as a group[http://en.wikipedia.org/wiki/Integration_testing]. Although each of the modules might function correctly, it is not necessary that they will function correctly as a group. In a rails project, integration tests are most useful to verify the interactions between controllers. Integration testing generally occurs in the latter part of the project testing life cycle. Unit and functional tests are written along with development. Once each component has been completed, its functionality tested in isolation, integration tests take precedence. In rails, a generator can create a integration test skeleton. In the image below some integration test for our rails application:

[[File:Integration.png|1000px]]

==References==
* 1. [http://betterexplained.com/articles/intermediate-rails-understanding-models-views-and-controllers/ Intermediate Rails: Understanding Models, Views and Controllers]
* 2. [http://en.wikipedia.org/wiki/Model-View-Controller Model–view–controller]
* 3. [http://guides.rubyonrails.org/action_controller_overview.html Action Controller Overview]
* 4. [http://guides.rubyonrails.org/migrations.html Migrations]
* 5. [http://ar.rubyonrails.org/classes/Fixtures.html Class Fixtures]
* 6. [http://biodegradablegeek.com/2008/07/how-to-use-fixtures-to-populate-your-database-in-rails/ How to use fixtures to Populate your database in rails ]
* 7. [http://guides.rubyonrails.org/testing.html A Guide to Testing Rails Applications]
* 8. [http://en.wikipedia.org/wiki/Functional_testing Functional testing]
* 9. [http://avdi.org/devblog/2010/12/21/object-oriented-programming-comes-to-rails/Object Oriented Programming Comes to Rails]
* 10. [http://en.wikipedia.org/wiki/Integration_testing Integration Testing]

File:55.png

2011-10-22T01:58:32Z

Amaroo:

File:43.png

2011-10-22T01:54:20Z

Amaroo:

CSC/ECE 517 Fall 2011/ch2 2b sa

2011-10-01T19:17:51Z

Amaroo:

'''Access Control in Object Oriented Languages'''
:Each Object Oriented Language has its own way of implementing Access Control .This page discusses the various ways in which Access control is implemented in some of the Object Oriented Languages.
=='''Access Control'''==
Access control in programming languages provides the programmer the ability to define standards that are needed to hide the implementation of the modules from the public interface.Access control provides the programmer ,the ability to prevent under privileged users from access to internal components of a program and restricts them from changing the data within the component to an inconsistent state(i.e elements(members functions and variables) within a program(class)) there by protecting the integrity of the components .This concept of hiding the information in object oriented languages is called [http://en.wikipedia.org/wiki/Encapsulation Encapsulation].

==Access Control in Ruby==
Access control in ruby is achieved using the following [http://en.wikipedia.org/wiki/Java_syntax#Access_modifiers access modifiers]for the methods.
*''public'' :The methods that are declared as public can be accessed by any object belong to the class .
*''private'' :The methods that are declared as private can only be invoked in the context of the current object.
*''protected'' :The methods that are declared as protected can be invoked by the objects of both the class and the sub-classes.

In Ruby these modifiers only apply to the methods but not the instance variables.

====Public Methods in Ruby====
Public methods in ruby can be accessed by any object or instance of a Class and its Sub-classes.
Declaration of public methods:

<pre>
class A
def method
puts "hello"
end
end
</pre>

<pre>
class A
def method
puts "hello"
end
public :method
end
</pre>

====Private Methods in Ruby====
private methods in Ruby can only be invoked by the current object in question and one cannot invoke other object's private methods.
In Ruby private methods are not private to the class but they are private to the objects. No method is perfectly private in Ruby.

======Declaration of Private methods======
<pre>
class A
private
def method
end
end

class A
def method
end
private :method
end
</pre>

An example to show that private methods in Ruby can only be invoked by the current object in context.
<pre>
class A
def method
puts "I am a private method"
end
def pubm
method
A.new.method // It gives an error because pubm method is called in the context of object 'a',so only object 'a' can
puts "I am a public method" invoke the private method but not the new object.
end
private :method
end

class B
def m1
method //private methods of the base class can be accessed by the sub class
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

===Protected Methods in Ruby===
protected methods are visible in both the base class as well as the sub-classes(i.e they can be invoked by the objects of both the class and its sub-classes).

Declaration of protected methods is ruby.
<pre>
class A
protected
def method
end
end

class A
def method
end
protected :method
end
</pre>
Unlike private methods ,In Ruby protected methods can be called with an explicit receiver.

<pre>
class A
def method
puts "I am a protected method"
end
def pubm
method
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
protected :method
end

class B
def m1
method //protected methods of the base class can be accessed by the sub class.
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

In Ruby both the private as well as the protected methods can be accessed from outside the class using send method.
<pre>
class A
def privateMethod
puts "I am a private method"
end
def pubm
privateMethod
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
private :privateMethod
end
a=A.new
a.method // gives an error
a.send(:privateMethod) // prints "I am a private method"
a.send :privateMethod // prints "I am a private method"
a.method(:privateMethod).call // prints "I am a private method"
</pre>

==Access Control in C++==

===Controlling Access to the Member Data and Member Functions===

In C++ one can restrict the level of access control on the member data a
nd function using the access specifiers public,private and protected.
A constructor should never be declared as private.
Access control is applied to all the names uniformly.

===Controlling the Level of accessibility of Base class and its Members===
If a class is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inherited]using a public access specifier than the public members of the base class are inherited as the public members of the derived class and protected members of the base class are inherited as the protected members of the derived class.If a class is inherited using a private access specifier than both the public and protected members of the base class become the private members of the derived class.If a class is inherited using a protected access specifier than both the public and protected members of the base class become the protected. members of the derived class.
[[File:Access.png|400px|center|upright=0.56|Diagram Depicting the Visibility of members and the Inheritance effect.]]
However, the sub-class members can determine the values of the base class private members by using the Base class public member functions.

<pre>
class A
{
int a;
public:
int value()
{
a=10;
return a;
}
};
class B:public A
{
public:
int b;
void bvalue()
{
b=value(); //now b is assigned a value 10 .This is how the sub class can determine the value of the base class private member
printf("%d",b); variables
}
};
int main()
{
B o;
o.bvalue();
return 1;
}
</pre>

[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding] can be used to access the members of the derived class using the Base class pointer.Dynamic binding or late-binding or run time binding is achieved using virtual functions in the Base class.If the Base class pointer pointing to the derived class object and the matching function is declared virtual in base class, then which function is call is decided at run-time using virtual table entry.

===Friendly Functions===
Like ''send'' method in Ruby,C++ allow the Friend Functions which are not within the scope of the class to access the private members of the class. The friend function are defined like any other function without using either the keyword friend or [http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=%2Fcom.ibm.vacpp7l.doc%2Flanguage%2Fref%2Fclrc05cplr175.htm :: scope resolution operator].Since they are not within the scope of the class ,they cannot be called using the objects of the class.Declaration of a friend function in either the public or private part of the class does not change it functionality.

===Friend Classes===
A class declared as a [http://en.wikipedia.org/wiki/Friend_class friend class] of an another class can access all the private and protected members of the class extending friendship.

==Access Control in Java==
Access control can be defined as the methods that limit accessibility of the resources to a set of users or programs to enforce integrity, confidentiality or availability constraints.
Java provides two levels of access controls

*"Top Level" – Public, or Package-Private (no explicit modifier, also known as default).

*"Member Level" – Public, Private, Protected or Package-Private (no explicit modifier, also known as default).
===Top Level===
On the Top level come classes and interfaces. An Interface can only be declared as public. While a class can be declared to be either public or default. If a class is declared as public then it is visible to all the classes in the same or a different package. But if a class is declared with no access specifier i.e. default, then it is public in its own package i.e. it cannot be accessed outside the package other than the one in which it is declared.
===Member Level===
At the member level we can declare fields, methods and constructors as public, private, protected and default. Public and default modifiers are used in the same way as the top level and with the same meaning. When a member of a class is declared as private then it can be accessed only within the class. Also, when a member is declared as protected then it can be accessed by all the classes in the same package and the sub classes (of its class) in other packages.
===Final Keyword===
When this keyword is used along with the class declaration, the class cannot be inherited by any other class.If a method is declared to be final then that method cannot be overridden and if a variable is declared as final then its value cannot be changed.

====Example====
To understand it in more detail consider the following the example.
[[File:Access1.png|400px|center]]
In the example each package contains two classes. Class C is a sub class of class A. Assuming class A as public then its members can be accessed like –
Class A – It can access all its members independent of their access modifier.
Class B – It can access all the members of class A except those are private.
Class C – It can access public and protected members of class A because it is a sub class of class A.
Class D – It can access only the public members of class A.
The access modifiers of the top level component govern whether its members are available in the other packages i.e. even if we are having public methods in a class but the class is declared as default then its methods will not be available in other packages.
If one’s class is going to be used by other coders then he must ensure that errors due to misuse do not happen. For this he must provide the most restrictive access to its members like always declare the fields as private and provide methods to access/modify them.

<pre>
package package1;

public class Parent {

/**
*
*/
private int privateVariable;
public int publicVariable;
protected int protectedVariable;
int defaultVariable;

private int getPrivateVariable() {
return privateVariable;
}

private void setPrivateVariable(int privateVariable) {
this.privateVariable = privateVariable;
}

public int getPublicVariable() {
return publicVariable;
}

public void setPublicVariable(int publicVariable) {
this.publicVariable = publicVariable;
}

protected int getProtectedVariable() {
return protectedVariable;
}

protected void setProtectedVariable(int protectedVariable) {
this.protectedVariable = protectedVariable;
}

int getDefaultVariable() {
return defaultVariable;
}

void setDefaultVariable(int defaultVariable) {
this.defaultVariable = defaultVariable;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent=new Parent();
parent.setDefaultVariable(5);
parent.setPrivateVariable(4);
parent.setProtectedVariable(6);
parent.setPublicVariable(9);
}

}

package package1;

public class ChildInSamePackage extends Parent{

/**
* Public, Protected and Default members available.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInSamePackage childInSamePackage = new ChildInSamePackage();
childInSamePackage.setDefaultVariable(1);
childInSamePackage.setProtectedVariable(5);
childInSamePackage.setPublicVariable(7);
//childInSamePackage.setPrivateVariable(7); // not allowed. Compile time Error

Parent parent =new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(1);
parent.setPublicVariable(0);
//parent.setPrivateVariable(0); //not allowed. compile time error
}

}

package package1;

public class ClassInSamePackage {

/**
* Public, Protected and Default available but only to parent class object.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent = new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(5);
parent.setPublicVariable(9);
//parent.setPrivateVariable(9); //not allowed
}

}

package package2;

import package1.Parent;

public class ChildInDifferentPackage extends Parent{

/**
* Both public and Protected members can be accessed.
* But Protected can be accessed only through inheritance.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInDifferentPackage childInDifferentPackage = new ChildInDifferentPackage();
childInDifferentPackage.setProtectedVariable(5);
childInDifferentPackage.setPublicVariable(4);

Parent parent = new Parent();
parent.setPublicVariable(7);
//parent.setProtectedVariable(7); // not allowed. protected members are available only through inheritance.
}

}

package package2;

import package1.Parent;

public class ClassInDifferentPackage {

/**
* Only public members of parent class can be accessed
* but using the object of parent class.
*/
public static void main(String[] args) {

Parent parent = new Parent();
parent.setPublicVariable(4); // only public members are available.
}

}

</pre>

==Access Control in C#==
The accessibility levels of the types (class, interface, struct, enum etc.) and the members, controls whether they can be used from the other code in our assembly (*) or other assemblies.

===Accessibility levels provided by C#===

*"Public": It can be used for the types and type members. It allows them to be accessed everywhere in the same assembly or the other assembly.
*"Private": It can be used only for the members. Private members are accessible only within the class or the struct in which they are declared.
*"Protected": It is a member access modifier. It allows the class to hide its members from the other classes except the child classes.
*"Internal": It can be used both for the types and type members. Internal types and members are accessible only by the code in the same assembly.
*"Protected Internal": It’s a combination of protected and internal modifier. It allows the types and the members to be used by any code in the same assembly or by any derived class in another assembly. A protected internal element can be accessed in a derived class in another assembly by using an instance of the derived class.
[[File:Access2.png|400px|center|upright=0.56]]

Usage of these access modifiers for all types or members is dependent on the conditions like the accessibility of the container restricts the accessibility of a type member.
*- Assembly is a physical unit that can be executed, deployed, versioned and secured.

====Example====
<pre>

internal class InternalClass
{
private int privateMember1;
protected int protectedMember2;
internal int internalMember3;
protected internal int protectedInternalMember4;

private class NestedClass
{
void Test(Class1 foo)
{
foo.Member1 = 0; //OK
foo.Member2 = 0; //OK
foo.Member3 = 0; //OK
foo.Member4 = 0; //OK
}
}
}

public class PublicClass
{
private void Method1()
{
}

private int privateMember1;

protected int Member1
{
get
{
return privateMember1;
}
set
{
Method1();
privateMember1 = value;
}
}

internal int internalMember2;
public int publicMember3;
protected internal int protectedInternalMember4;
}

class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //OK
internalClass.privateMember1 = 0; //Compilation error here
internalClass.protectedMember2 = 0; //Compilation error here
internalClass.internalMember3 = 0; //OK
internalClass.protectedInternalMember4 = 0; //OK
}
}

internal class DerivedClass : InternalClass
{
private void Test2()
{
privateMember1 = 0; //Compilation error here
protectedMember2 = 0; //OK
internalMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}

private class NestedClass
{
void Test(DerivedClass foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //OK
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class1 foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //Compilation error here
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
}
}

------------------ Class in a different assembly -------------------------------

public class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //Compilation error here

PublicClass publicClass = new PublicClass; //OK
publicClass.Method1(); //Compilation error here
publicClass.privateMember1 = 0; //Compilation error here
publicClass.Member1 = 0; //Compilation error here
publicClass.internalMember2 = 0; //Compilation error here
publicClass.publicMember3 = 0; //OK
publicClass.protectedInternalMember4 = 0; //Compilation error here
}
}

internal class DerivedClass : PublicClass
{
private void Test2()
{
Member1 = 0; //OK
internalMember2 = 0; //Compilation error here
publicMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}
private class NestedClass
{
void Test(DerivedClass foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class2 foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //Compilation error here
}
}
}

</pre>
==Conclusion==
Access controls is one of the important features provided by the Object Oriented Languages as it helps in achieving Encapsulation.Thus one can make his code less vulnerable from being exploited by others utilizing the features and capabilities provided by the access specifiers .
The philosophies of access controls in object oriented languages have not changed much over time but certainly the access control across different Object Oriented Languages are different if not completely.

==References==
# http://ruby-doc.org/core/
# http://rubylearning.com/satishtalim/ruby_access_control.html
# http://phrogz.net/programmingruby/tut_classes.html
# http://msdn.microsoft.com/en-us/library/kktasw36(v=VS.80).aspx
# http://www.kuzbass.ru:8086/docs/isocpp/access.html
# http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fcplr130.htm
# http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
# http://msdn.microsoft.com/en-us/library/wxh6fsc7.aspx
# http://stackoverflow.com/questions/2084801/c-using-declaration-scope-and-access-control
# http://en.wikipedia.org/wiki/Class_(computer_programming)#Member_accessibility
# http://www.jvoegele.com/software/langcomp.html
# http://csharp.net-informations.com/language/csharp-access-specifiers.htm
# http://blogs.oberon.ch/tamberg/2007-10-30/understanding-csharp-access-modifiers.html
# http://www.enscand.com/howtos/access/access.html

CSC/ECE 517 Fall 2011/ch2 2b sa

2011-10-01T19:16:21Z

Amaroo:

'''Access Control in Object Oriented Languages'''
:Each Object Oriented Language has its own way of implementing Access Control .This page discusses the various ways in which Access control is implemented in some of the Object Oriented Languages.
=='''Access Control'''==
Access control in programming languages provides the programmer the ability to define standards that are needed to hide the implementation of the modules from the public interface.Access control provides the programmer ,the ability to prevent under privileged users from access to internal components of a program and restricts them from changing the data within the component to an inconsistent state(i.e elements(members functions and variables) within a program(class)) there by protecting the integrity of the components .This concept of hiding the information in object oriented languages is called [http://en.wikipedia.org/wiki/Encapsulation Encapsulation].

==Access Control in Ruby==
Access control in ruby is achieved using the following [http://en.wikipedia.org/wiki/Java_syntax#Access_modifiers access modifiers]for the methods.
*''public'' :The methods that are declared as public can be accessed by any object belong to the class .
*''private'' :The methods that are declared as private can only be invoked in the context of the current object.
*''protected'' :The methods that are declared as protected can be invoked by the objects of both the class and the sub-classes.

In Ruby these modifiers only apply to the methods but not the instance variables.

====Public Methods in Ruby====
Public methods in ruby can be accessed by any object or instance of a Class and its Sub-classes.
Declaration of public methods:

<pre>
class A
def method
puts "hello"
end
end
</pre>

<pre>
class A
def method
puts "hello"
end
public :method
end
</pre>

====Private Methods in Ruby====
private methods in Ruby can only be invoked by the current object in question and one cannot invoke other object's private methods.
In Ruby private methods are not private to the class but they are private to the objects. No method is perfectly private in Ruby.

======Declaration of Private methods======
<pre>
class A
private
def method
end
end

class A
def method
end
private :method
end
</pre>

An example to show that private methods in Ruby can only be invoked by the current object in context.
<pre>
class A
def method
puts "I am a private method"
end
def pubm
method
A.new.method // It gives an error because pubm method is called in the context of object 'a',so only object 'a' can
puts "I am a public method" invoke the private method but not the new object.
end
private :method
end

class B
def m1
method //private methods of the base class can be accessed by the sub class
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

===Protected Methods in Ruby===
protected methods are visible in both the base class as well as the sub-classes(i.e they can be invoked by the objects of both the class and its sub-classes).

Declaration of protected methods is ruby.
<pre>
class A
protected
def method
end
end

class A
def method
end
protected :method
end
</pre>
Unlike private methods ,In Ruby protected methods can be called with an explicit receiver.

<pre>
class A
def method
puts "I am a protected method"
end
def pubm
method
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
protected :method
end

class B
def m1
method //protected methods of the base class can be accessed by the sub class.
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

In Ruby both the private as well as the protected methods can be accessed from outside the class using send method.
<pre>
class A
def privateMethod
puts "I am a private method"
end
def pubm
privateMethod
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
private :privateMethod
end
a=A.new
a.method // gives an error
a.send(:privateMethod) // prints "I am a private method"
a.send :privateMethod // prints "I am a private method"
a.method(:privateMethod).call // prints "I am a private method"
</pre>

==Access Control in C++==

===Controlling Access to the Member Data and Member Functions===

In C++ one can restrict the level of access control on the member data a
nd function using the access specifiers public,private and protected.
A constructor should never be declared as private.
Access control is applied to all the names uniformly.

===Controlling the Level of accessibility of Base class and its Members===
If a class is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inherited]using a public access specifier than the public members of the base class are inherited as the public members of the derived class and protected members of the base class are inherited as the protected members of the derived class.If a class is inherited using a private access specifier than both the public and protected members of the base class become the private members of the derived class.If a class is inherited using a protected access specifier than both the public and protected members of the base class become the protected. members of the derived class.
[[File:Access.png|400px|center|upright=0.56|Diagram Depicting the Visibility of members and the Inheritance effect.]]
However, the sub-class members can determine the values of the base class private members by using the Base class public member functions.

<pre>
class A
{
int a;
public:
int value()
{
a=10;
return a;
}
};
class B:public A
{
public:
int b;
void bvalue()
{
b=value(); //now b is assigned a value 10 .This is how the sub class can determine the value of the base class private member
printf("%d",b); variables
}
};
int main()
{
B o;
o.bvalue();
return 1;
}
</pre>

[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding] can be used to access the members of the derived class using the Base class pointer.Dynamic binding or late-binding or run time binding is achieved using virtual functions in the Base class.If the Base class pointer pointing to the derived class object and the matching function is declared virtual in base class, then which function is call is decided at run-time using virtual table entry.

===Friendly Functions===
Like ''send'' method in Ruby,C++ allow the Friend Functions which are not within the scope of the class to access the private members of the class. The friend function are defined like any other function without using either the keyword friend or [http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=%2Fcom.ibm.vacpp7l.doc%2Flanguage%2Fref%2Fclrc05cplr175.htm :: scope resolution operator].Since they are not within the scope of the class ,they cannot be called using the objects of the class.Declaration of a friend function in either the public or private part of the class does not change it functionality.

===Friend Classes===
A class declared as a [http://en.wikipedia.org/wiki/Friend_class friend class] of an another class can access all the private and protected members of the class extending friendship.

==Access Control in Java==
Access control can be defined as the methods that limit accessibility of the resources to a set of users or programs to enforce integrity, confidentiality or availability constraints.
Java provides two levels of access controls

*"Top Level" – Public, or Package-Private (no explicit modifier, also known as default).

*"Member Level" – Public, Private, Protected or Package-Private (no explicit modifier, also known as default).
===Top Level===
On the Top level come classes and interfaces. An Interface can only be declared as public. While a class can be declared to be either public or default. If a class is declared as public then it is visible to all the classes in the same or a different package. But if a class is declared with no access specifier i.e. default, then it is public in its own package i.e. it cannot be accessed outside the package other than the one in which it is declared.
===Member Level===
At the member level we can declare fields, methods and constructors as public, private, protected and default. Public and default modifiers are used in the same way as the top level and with the same meaning. When a member of a class is declared as private then it can be accessed only within the class. Also, when a member is declared as protected then it can be accessed by all the classes in the same package and the sub classes (of its class) in other packages.
===Final Keyword===

When this keyword is used along with the class declaration, the class cannot be inherited by any other class.If a method is declared to be final then that method cannot be overridden and if a variable is declared as final then its value cannot be changed.

====Example====
To understand it in more detail consider the following the example.
[[File:Access1.png|400px|center]]
In the example each package contains two classes. Class C is a sub class of class A. Assuming class A as public then its members can be accessed like –
Class A – It can access all its members independent of their access modifier.
Class B – It can access all the members of class A except those are private.
Class C – It can access public and protected members of class A because it is a sub class of class A.
Class D – It can access only the public members of class A.
The access modifiers of the top level component govern whether its members are available in the other packages i.e. even if we are having public methods in a class but the class is declared as default then its methods will not be available in other packages.
If one’s class is going to be used by other coders then he must ensure that errors due to misuse do not happen. For this he must provide the most restrictive access to its members like always declare the fields as private and provide methods to access/modify them.

<pre>
package package1;

public class Parent {

/**
*
*/
private int privateVariable;
public int publicVariable;
protected int protectedVariable;
int defaultVariable;

private int getPrivateVariable() {
return privateVariable;
}

private void setPrivateVariable(int privateVariable) {
this.privateVariable = privateVariable;
}

public int getPublicVariable() {
return publicVariable;
}

public void setPublicVariable(int publicVariable) {
this.publicVariable = publicVariable;
}

protected int getProtectedVariable() {
return protectedVariable;
}

protected void setProtectedVariable(int protectedVariable) {
this.protectedVariable = protectedVariable;
}

int getDefaultVariable() {
return defaultVariable;
}

void setDefaultVariable(int defaultVariable) {
this.defaultVariable = defaultVariable;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent=new Parent();
parent.setDefaultVariable(5);
parent.setPrivateVariable(4);
parent.setProtectedVariable(6);
parent.setPublicVariable(9);
}

}

package package1;

public class ChildInSamePackage extends Parent{

/**
* Public, Protected and Default members available.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInSamePackage childInSamePackage = new ChildInSamePackage();
childInSamePackage.setDefaultVariable(1);
childInSamePackage.setProtectedVariable(5);
childInSamePackage.setPublicVariable(7);
//childInSamePackage.setPrivateVariable(7); // not allowed. Compile time Error

Parent parent =new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(1);
parent.setPublicVariable(0);
//parent.setPrivateVariable(0); //not allowed. compile time error
}

}

package package1;

public class ClassInSamePackage {

/**
* Public, Protected and Default available but only to parent class object.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent = new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(5);
parent.setPublicVariable(9);
//parent.setPrivateVariable(9); //not allowed
}

}

package package2;

import package1.Parent;

public class ChildInDifferentPackage extends Parent{

/**
* Both public and Protected members can be accessed.
* But Protected can be accessed only through inheritance.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInDifferentPackage childInDifferentPackage = new ChildInDifferentPackage();
childInDifferentPackage.setProtectedVariable(5);
childInDifferentPackage.setPublicVariable(4);

Parent parent = new Parent();
parent.setPublicVariable(7);
//parent.setProtectedVariable(7); // not allowed. protected members are available only through inheritance.
}

}

package package2;

import package1.Parent;

public class ClassInDifferentPackage {

/**
* Only public members of parent class can be accessed
* but using the object of parent class.
*/
public static void main(String[] args) {

Parent parent = new Parent();
parent.setPublicVariable(4); // only public members are available.
}

}

</pre>

==Access Control in C#==
The accessibility levels of the types (class, interface, struct, enum etc.) and the members, controls whether they can be used from the other code in our assembly (*) or other assemblies.

===Accessibility levels provided by C#===

*"Public": It can be used for the types and type members. It allows them to be accessed everywhere in the same assembly or the other assembly.
*"Private": It can be used only for the members. Private members are accessible only within the class or the struct in which they are declared.
*"Protected": It is a member access modifier. It allows the class to hide its members from the other classes except the child classes.
*"Internal": It can be used both for the types and type members. Internal types and members are accessible only by the code in the same assembly.
*"Protected Internal": It’s a combination of protected and internal modifier. It allows the types and the members to be used by any code in the same assembly or by any derived class in another assembly. A protected internal element can be accessed in a derived class in another assembly by using an instance of the derived class.
[[File:Access2.png|400px|center|upright=0.56]]

Usage of these access modifiers for all types or members is dependent on the conditions like the accessibility of the container restricts the accessibility of a type member.
*- Assembly is a physical unit that can be executed, deployed, versioned and secured.

====Example====
<pre>

internal class InternalClass
{
private int privateMember1;
protected int protectedMember2;
internal int internalMember3;
protected internal int protectedInternalMember4;

private class NestedClass
{
void Test(Class1 foo)
{
foo.Member1 = 0; //OK
foo.Member2 = 0; //OK
foo.Member3 = 0; //OK
foo.Member4 = 0; //OK
}
}
}

public class PublicClass
{
private void Method1()
{
}

private int privateMember1;

protected int Member1
{
get
{
return privateMember1;
}
set
{
Method1();
privateMember1 = value;
}
}

internal int internalMember2;
public int publicMember3;
protected internal int protectedInternalMember4;
}

class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //OK
internalClass.privateMember1 = 0; //Compilation error here
internalClass.protectedMember2 = 0; //Compilation error here
internalClass.internalMember3 = 0; //OK
internalClass.protectedInternalMember4 = 0; //OK
}
}

internal class DerivedClass : InternalClass
{
private void Test2()
{
privateMember1 = 0; //Compilation error here
protectedMember2 = 0; //OK
internalMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}

private class NestedClass
{
void Test(DerivedClass foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //OK
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class1 foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //Compilation error here
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
}
}

------------------ Class in a different assembly -------------------------------

public class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //Compilation error here

PublicClass publicClass = new PublicClass; //OK
publicClass.Method1(); //Compilation error here
publicClass.privateMember1 = 0; //Compilation error here
publicClass.Member1 = 0; //Compilation error here
publicClass.internalMember2 = 0; //Compilation error here
publicClass.publicMember3 = 0; //OK
publicClass.protectedInternalMember4 = 0; //Compilation error here
}
}

internal class DerivedClass : PublicClass
{
private void Test2()
{
Member1 = 0; //OK
internalMember2 = 0; //Compilation error here
publicMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}
private class NestedClass
{
void Test(DerivedClass foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class2 foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //Compilation error here
}
}
}

</pre>
==Conclusion==
Access controls is one of the important features provided by the Object Oriented Languages as it helps in achieving Encapsulation.Thus one can make his code less vulnerable from being exploited by others utilizing the features and capabilities provided by the access specifiers .
The philosophies of access controls in object oriented languages have not changed much over time but certainly the access control across different Object Oriented Languages are different if not completely.

==References==
# http://ruby-doc.org/core/
# http://rubylearning.com/satishtalim/ruby_access_control.html
# http://phrogz.net/programmingruby/tut_classes.html
# http://msdn.microsoft.com/en-us/library/kktasw36(v=VS.80).aspx
# http://www.kuzbass.ru:8086/docs/isocpp/access.html
# http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fcplr130.htm
# http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
# http://msdn.microsoft.com/en-us/library/wxh6fsc7.aspx
# http://stackoverflow.com/questions/2084801/c-using-declaration-scope-and-access-control
# http://en.wikipedia.org/wiki/Class_(computer_programming)#Member_accessibility
# http://www.jvoegele.com/software/langcomp.html
# http://csharp.net-informations.com/language/csharp-access-specifiers.htm
# http://blogs.oberon.ch/tamberg/2007-10-30/understanding-csharp-access-modifiers.html
# http://www.enscand.com/howtos/access/access.html

CSC/ECE 517 Fall 2011/ch2 2b sa

2011-10-01T19:12:36Z

Amaroo:

'''Access Control in Object Oriented Languages'''
:Each Object Oriented Language has its own way of implementing Access Control .This page discusses the various ways in which Access control is implemented in some of the Object Oriented Languages.
=='''Access Control'''==
Access control in programming languages provides the programmer the ability to define standards that are needed to hide the implementation of the modules from the public interface.Access control provides the programmer ,the ability to prevent under privileged users from access to internal components of a program and restricts them from changing the data within the component to an inconsistent state(i.e elements(members functions and variables) within a program(class)) there by protecting the integrity of the components .This concept of hiding the information in object oriented languages is called [http://en.wikipedia.org/wiki/Encapsulation Encapsulation].

==Access Control in Ruby==
Access control in ruby is achieved using the following [http://en.wikipedia.org/wiki/Java_syntax#Access_modifiers access modifiers]for the methods.
*''public'' :The methods that are declared as public can be accessed by any object belong to the class .
*''private'' :The methods that are declared as private can only be invoked in the context of the current object.
*''protected'' :The methods that are declared as protected can be invoked by the objects of both the class and the sub-classes.

In Ruby these modifiers only apply to the methods but not the instance variables.

====Public Methods in Ruby====
Public methods in ruby can be accessed by any object or instance of a Class and its Sub-classes.
Declaration of public methods:

<pre>
class A
def method
puts "hello"
end
end
</pre>

<pre>
class A
def method
puts "hello"
end
public :method
end
</pre>

====Private Methods in Ruby====
private methods in Ruby can only be invoked by the current object in question and one cannot invoke other object's private methods.
In Ruby private methods are not private to the class but they are private to the objects. No method is perfectly private in Ruby.

======Declaration of Private methods======
<pre>
class A
private
def method
end
end

class A
def method
end
private :method
end
</pre>

An example to show that private methods in Ruby can only be invoked by the current object in context.
<pre>
class A
def method
puts "I am a private method"
end
def pubm
method
A.new.method // It gives an error because pubm method is called in the context of object 'a',so only object 'a' can
puts "I am a public method" invoke the private method but not the new object.
end
private :method
end

class B
def m1
method //private methods of the base class can be accessed by the sub class
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

===Protected Methods in Ruby===
protected methods are visible in both the base class as well as the sub-classes(i.e they can be invoked by the objects of both the class and its sub-classes).

Declaration of protected methods is ruby.
<pre>
class A
protected
def method
end
end

class A
def method
end
protected :method
end
</pre>
Unlike private methods ,In Ruby protected methods can be called with an explicit receiver.

<pre>
class A
def method
puts "I am a protected method"
end
def pubm
method
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
protected :method
end

class B
def m1
method //protected methods of the base class can be accessed by the sub class.
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

In Ruby both the private as well as the protected methods can be accessed from outside the class using send method.
<pre>
class A
def privateMethod
puts "I am a private method"
end
def pubm
privateMethod
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
private :privateMethod
end
a=A.new
a.method // gives an error
a.send(:privateMethod) // prints "I am a private method"
a.send :privateMethod // prints "I am a private method"
a.method(:privateMethod).call // prints "I am a private method"
</pre>

==Access Control in C++==

===Controlling Access to the Member Data and Member Functions===

In C++ one can restrict the level of access control on the member data a
nd function using the access specifiers public,private and protected.
A constructor should never be declared as private.
Access control is applied to all the names uniformly.

===Controlling the Level of accessibility of Base class and its Members===
If a class is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inherited]using a public access specifier than the public members of the base class are inherited as the public members of the derived class and protected members of the base class are inherited as the protected members of the derived class.If a class is inherited using a private access specifier than both the public and protected members of the base class become the private members of the derived class.If a class is inherited using a protected access specifier than both the public and protected members of the base class become the protected. members of the derived class.
[[File:Access.png|400px|center|upright=0.56|Diagram Depicting the Visibility of members and the Inheritance effect.]]
However, the sub-class members can determine the values of the base class private members by using the Base class public member functions.

<pre>
class A
{
int a;
public:
int value()
{
a=10;
return a;
}
};
class B:public A
{
public:
int b;
void bvalue()
{
b=value(); //now b is assigned a value 10 .This is how the sub class can determine the value of the base class private member
printf("%d",b); variables
}
};
int main()
{
B o;
o.bvalue();
return 1;
}
</pre>

[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding] can be used to access the members of the derived class using the Base class pointer.Dynamic binding or late-binding or run time binding is achieved using virtual functions in the Base class.If the Base class pointer pointing to the derived class object and the matching function is declared virtual in base class, then which function is call is decided at run-time using virtual table entry.

===Friendly Functions===
Like ''send'' method in Ruby,C++ allow the Friend Functions which are not within the scope of the class to access the private members of the class. The friend function are defined like any other function without using either the keyword friend or [http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=%2Fcom.ibm.vacpp7l.doc%2Flanguage%2Fref%2Fclrc05cplr175.htm :: scope resolution operator].Since they are not within the scope of the class ,they cannot be called using the objects of the class.Declaration of a friend function in either the public or private part of the class does not change it functionality.

===Friend Classes===
A class declared as a [http://en.wikipedia.org/wiki/Friend_class friend class] of an another class can access all the private and protected members of the class extending friendship.

==Access Control in Java==
Access control can be defined as the methods that limit accessibility of the resources to a set of users or programs to enforce integrity, confidentiality or availability constraints.
Java provides two levels of access controls

*"Top Level" – Public, or Package-Private (no explicit modifier, also known as default).

*"Member Level" – Public, Private, Protected or Package-Private (no explicit modifier, also known as default).
===Top Level===
On the Top level come classes and interfaces. An Interface can only be declared as public. While a class can be declared to be either public or default. If a class is declared as public then it is visible to all the classes in the same or a different package. But if a class is declared with no access specifier i.e. default, then it is public in its own package i.e. it cannot be accessed outside the package other than the one in which it is declared.
===Member Level===
At the member level we can declare fields, methods and constructors as public, private, protected and default. Public and default modifiers are used in the same way as the top level and with the same meaning. When a member of a class is declared as private then it can be accessed only within the class. Also, when a member is declared as protected then it can be accessed by all the classes in the same package and the sub classes (of its class) in other packages.
===Final Keyword===

When this keyword is used along with the class declaration, the class cannot be inherited by any other class.If a method is declared to be final then that method cannot be overridden and if a variable is declared as final then its value cannot be changed.

====Example====
To understand it in more detail consider the following the example.
[[File:Access1.png|400px|center]]
In the example each package contains two classes. Class C is a sub class of class A. Assuming class A as public then its members can be accessed like –
Class A – It can access all its members independent of their access modifier.
Class B – It can access all the members of class A except those are private.
Class C – It can access public and protected members of class A because it is a sub class of class A.
Class D – It can access only the public members of class A.
The access modifiers of the top level component govern whether its members are available in the other packages i.e. even if we are having public methods in a class but the class is declared as default then its methods will not be available in other packages.
If one’s class is going to be used by other coders then he must ensure that errors due to misuse do not happen. For this he must provide the most restrictive access to its members like always declare the fields as private and provide methods to access/modify them.

<pre>
package package1;

public class Parent {

/**
*
*/
private int privateVariable;
public int publicVariable;
protected int protectedVariable;
int defaultVariable;

private int getPrivateVariable() {
return privateVariable;
}

private void setPrivateVariable(int privateVariable) {
this.privateVariable = privateVariable;
}

public int getPublicVariable() {
return publicVariable;
}

public void setPublicVariable(int publicVariable) {
this.publicVariable = publicVariable;
}

protected int getProtectedVariable() {
return protectedVariable;
}

protected void setProtectedVariable(int protectedVariable) {
this.protectedVariable = protectedVariable;
}

int getDefaultVariable() {
return defaultVariable;
}

void setDefaultVariable(int defaultVariable) {
this.defaultVariable = defaultVariable;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent=new Parent();
parent.setDefaultVariable(5);
parent.setPrivateVariable(4);
parent.setProtectedVariable(6);
parent.setPublicVariable(9);
}

}

package package1;

public class ChildInSamePackage extends Parent{

/**
* Public, Protected and Default members available.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInSamePackage childInSamePackage = new ChildInSamePackage();
childInSamePackage.setDefaultVariable(1);
childInSamePackage.setProtectedVariable(5);
childInSamePackage.setPublicVariable(7);
//childInSamePackage.setPrivateVariable(7); // not allowed. Compile time Error

Parent parent =new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(1);
parent.setPublicVariable(0);
//parent.setPrivateVariable(0); //not allowed. compile time error
}

}

package package1;

public class ClassInSamePackage {

/**
* Public, Protected and Default available but only to parent class object.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent = new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(5);
parent.setPublicVariable(9);
//parent.setPrivateVariable(9); //not allowed
}

}

package package2;

import package1.Parent;

public class ChildInDifferentPackage extends Parent{

/**
* Both public and Protected members can be accessed.
* But Protected can be accessed only through inheritance.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInDifferentPackage childInDifferentPackage = new ChildInDifferentPackage();
childInDifferentPackage.setProtectedVariable(5);
childInDifferentPackage.setPublicVariable(4);

Parent parent = new Parent();
parent.setPublicVariable(7);
//parent.setProtectedVariable(7); // not allowed. protected members are available only through inheritance.
}

}

package package2;

import package1.Parent;

public class ClassInDifferentPackage {

/**
* Only public members of parent class can be accessed
* but using the object of parent class.
*/
public static void main(String[] args) {

Parent parent = new Parent();
parent.setPublicVariable(4); // only public members are available.
}

}

</pre>

==Access Control in C#==
The accessibility levels of the types (class, interface, struct, enum etc.) and the members, controls whether they can be used from the other code in our assembly (*) or other assemblies.

===Accessibility levels provided by C#===

*"Public": It can be used for the types and type members. It allows them to be accessed everywhere in the same assembly or the other assembly.
*"Private": It can be used only for the members. Private members are accessible only within the class or the struct in which they are declared.
*"Protected": It is a member access modifier. It allows the class to hide its members from the other classes except the child classes.
*"Internal": It can be used both for the types and type members. Internal types and members are accessible only by the code in the same assembly.
*"Protected Internal": It’s a combination of protected and internal modifier. It allows the types and the members to be used by any code in the same assembly or by any derived class in another assembly. A protected internal element can be accessed in a derived class in another assembly by using an instance of the derived class.
[[File:Access2.png|400px|center|upright=0.56]]

Usage of these access modifiers for all types or members is dependent on the conditions like the accessibility of the container restricts the accessibility of a type member.
*- Assembly is a physical unit that can be executed, deployed, versioned and secured.

<pre>

internal class InternalClass
{
private int privateMember1;
protected int protectedMember2;
internal int internalMember3;
protected internal int protectedInternalMember4;

private class NestedClass
{
void Test(Class1 foo)
{
foo.Member1 = 0; //OK
foo.Member2 = 0; //OK
foo.Member3 = 0; //OK
foo.Member4 = 0; //OK
}
}
}

public class PublicClass
{
private void Method1()
{
}

private int privateMember1;

protected int Member1
{
get
{
return privateMember1;
}
set
{
Method1();
privateMember1 = value;
}
}

internal int internalMember2;
public int publicMember3;
protected internal int protectedInternalMember4;
}

class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //OK
internalClass.privateMember1 = 0; //Compilation error here
internalClass.protectedMember2 = 0; //Compilation error here
internalClass.internalMember3 = 0; //OK
internalClass.protectedInternalMember4 = 0; //OK
}
}

internal class DerivedClass : InternalClass
{
private void Test2()
{
privateMember1 = 0; //Compilation error here
protectedMember2 = 0; //OK
internalMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}

private class NestedClass
{
void Test(DerivedClass foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //OK
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class1 foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //Compilation error here
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
}
}

------------------ Class in a different assembly -------------------------------

public class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //Compilation error here

PublicClass publicClass = new PublicClass; //OK
publicClass.Method1(); //Compilation error here
publicClass.privateMember1 = 0; //Compilation error here
publicClass.Member1 = 0; //Compilation error here
publicClass.internalMember2 = 0; //Compilation error here
publicClass.publicMember3 = 0; //OK
publicClass.protectedInternalMember4 = 0; //Compilation error here
}
}

internal class DerivedClass : PublicClass
{
private void Test2()
{
Member1 = 0; //OK
internalMember2 = 0; //Compilation error here
publicMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}
private class NestedClass
{
void Test(DerivedClass foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class2 foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //Compilation error here
}
}
}

</pre>
==Conclusion==
Access controls is one of the important features provided by the Object Oriented Languages as it helps in achieving Encapsulation.Thus one can make his code less vulnerable from being exploited by others utilizing the features and capabilities provided by the access specifiers .
The philosophies of access controls in object oriented languages have not changed much over time but certainly the access control across different Object Oriented Languages are different if not completely.

==References==
# http://ruby-doc.org/core/
# http://rubylearning.com/satishtalim/ruby_access_control.html
# http://phrogz.net/programmingruby/tut_classes.html
# http://msdn.microsoft.com/en-us/library/kktasw36(v=VS.80).aspx
# http://www.kuzbass.ru:8086/docs/isocpp/access.html
# http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fcplr130.htm
# http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
# http://msdn.microsoft.com/en-us/library/wxh6fsc7.aspx
# http://stackoverflow.com/questions/2084801/c-using-declaration-scope-and-access-control
# http://en.wikipedia.org/wiki/Class_(computer_programming)#Member_accessibility
# http://www.jvoegele.com/software/langcomp.html
# http://csharp.net-informations.com/language/csharp-access-specifiers.htm
# http://blogs.oberon.ch/tamberg/2007-10-30/understanding-csharp-access-modifiers.html
# http://www.enscand.com/howtos/access/access.html

CSC/ECE 517 Fall 2011/ch2 2b sa

2011-10-01T18:54:35Z

Amaroo:

'''Access Control in Object Oriented Languages'''
:Each Object Oriented Language has its own way of implementing Access Control .This page discusses the various ways in which Access control is implemented in some of the Object Oriented Languages.
=='''Access Control'''==
Access control in programming languages provides the programmer the ability to define standards that are needed to hide the implementation of the modules from the public interface.Access control provides the programmer ,the ability to prevent under privileged users from access to internal components of a program and restricts them from changing the data within the component to an inconsistent state(i.e elements(members functions and variables) within a program(class)) there by protecting the integrity of the components .This concept of hiding the information in object oriented languages is called [http://en.wikipedia.org/wiki/Encapsulation Encapsulation].

==Access Control in Ruby==
Access control in ruby is achieved using the following [http://en.wikipedia.org/wiki/Java_syntax#Access_modifiers access modifiers]for the methods.
*''public'' :The methods that are declared as public can be accessed by any object belong to the class .
*''private'' :The methods that are declared as private can only be invoked in the context of the current object.
*''protected'' :The methods that are declared as protected can be invoked by the objects of both the class and the sub-classes.

In Ruby these modifiers only apply to the methods but not the instance variables.

====Public Methods in Ruby====
Public methods in ruby can be accessed by any object or instance of a Class and its Sub-classes.
Declaration of public methods:

<pre>
class A
def method
puts "hello"
end
end
</pre>

<pre>
class A
def method
puts "hello"
end
public :method
end
</pre>

====Private Methods in Ruby====
private methods in Ruby can only be invoked by the current object in question and one cannot invoke other object's private methods.
In Ruby private methods are not private to the class but they are private to the objects. No method is perfectly private in Ruby.

======Declaration of Private methods======
<pre>
class A
private
def method
end
end

class A
def method
end
private :method
end
</pre>

An example to show that private methods in Ruby can only be invoked by the current object in context.
<pre>
class A
def method
puts "I am a private method"
end
def pubm
method
A.new.method // It gives an error because pubm method is called in the context of object 'a',so only object 'a' can
puts "I am a public method" invoke the private method but not the new object.
end
private :method
end

class B
def m1
method //private methods of the base class can be accessed by the sub class
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

===Protected Methods in Ruby===
protected methods are visible in both the base class as well as the sub-classes(i.e they can be invoked by the objects of both the class and its sub-classes).

Declaration of protected methods is ruby.
<pre>
class A
protected
def method
end
end

class A
def method
end
protected :method
end
</pre>
Unlike private methods ,In Ruby protected methods can be called with an explicit receiver.

<pre>
class A
def method
puts "I am a protected method"
end
def pubm
method
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
protected :method
end

class B
def m1
method //protected methods of the base class can be accessed by the sub class.
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

In Ruby both the private as well as the protected methods can be accessed from outside the class using send method.
<pre>
class A
def privateMethod
puts "I am a private method"
end
def pubm
privateMethod
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
private :privateMethod
end
a=A.new
a.method // gives an error
a.send(:privateMethod) // prints "I am a private method"
a.send :privateMethod // prints "I am a private method"
a.method(:privateMethod).call // prints "I am a private method"
</pre>

==Access Control in C++==

===Controlling Access to the Member Data and Member Functions===

In C++ one can restrict the level of access control on the member data a
nd function using the access specifiers public,private and protected.
A constructor should never be declared as private.
Access control is applied to all the names uniformly.

===Controlling the Level of accessibility of Base class and its Members===
If a class is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inherited]using a public access specifier than the public members of the base class are inherited as the public members of the derived class and protected members of the base class are inherited as the protected members of the derived class.If a class is inherited using a private access specifier than both the public and protected members of the base class become the private members of the derived class.If a class is inherited using a protected access specifier than both the public and protected members of the base class become the protected. members of the derived class.
[[File:Access.png|400px|center|upright=0.56|Diagram Depicting the Visibility of members and the Inheritance effect.]]
However, the sub-class members can determine the values of the base class private members by using the Base class public member functions.

<pre>
class A
{
int a;
public:
int value()
{
a=10;
return a;
}
};
class B:public A
{
public:
int b;
void bvalue()
{
b=value(); //now b is assigned a value 10 .This is how the sub class can determine the value of the base class private member
printf("%d",b); variables
}
};
int main()
{
B o;
o.bvalue();
return 1;
}
</pre>

[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding] can be used to access the members of the derived class using the Base class pointer.Dynamic binding or late-binding or run time binding is achieved using virtual functions in the Base class.If the Base class pointer pointing to the derived class object and the matching function is declared virtual in base class, then which function is call is decided at run-time using virtual table entry.

===Friendly Functions===
Like ''send'' method in Ruby,C++ allow the Friend Functions which are not within the scope of the class to access the private members of the class. The friend function are defined like any other function without using either the keyword friend or [http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=%2Fcom.ibm.vacpp7l.doc%2Flanguage%2Fref%2Fclrc05cplr175.htm :: scope resolution operator].Since they are not within the scope of the class ,they cannot be called using the objects of the class.Declaration of a friend function in either the public or private part of the class does not change it functionality.

===Friend Classes===
A class declared as a [http://en.wikipedia.org/wiki/Friend_class friend class] of an another class can access all the private and protected members of the class extending friendship.

==Access Control in Java==
Access control can be defined as the methods that limit accessibility of the resources to a set of users or programs to enforce integrity, confidentiality or availability constraints.
Java provides two levels of access controls

*"Top Level" – Public, or Package-Private (no explicit modifier, also known as default).

*"Member Level" – Public, Private, Protected or Package-Private (no explicit modifier, also known as default).
===Top Level===
On the Top level come classes and interfaces. An Interface can only be declared as public. While a class can be declared to be either public or default. If a class is declared as public then it is visible to all the classes in the same or a different package. But if a class is declared with no access specifier i.e. default, then it is public in its own package i.e. it cannot be accessed outside the package other than the one in which it is declared.
===Member Level===
At the member level we can declare fields, methods and constructors as public, private, protected and default. Public and default modifiers are used in the same way as the top level and with the same meaning. When a member of a class is declared as private then it can be accessed only within the class. Also, when a member is declared as protected then it can be accessed by all the classes in the same package and the sub classes (of its class) in other packages.
===Final Keyword===

When this keyword is used along with the class declaration, the class cannot be inherited by any other class.If a method is declared to be final then that method cannot be overridden and if a variable is declared as final then its value cannot be changed.

====Example====
To understand it in more detail consider the following the example.
[[File:Access1.png|400px|center]]
In the example each package contains two classes. Class C is a sub class of class A. Assuming class A as public then its members can be accessed like –
Class A – It can access all its members independent of their access modifier.
Class B – It can access all the members of class A except those are private.
Class C – It can access public and protected members of class A because it is a sub class of class A.
Class D – It can access only the public members of class A.
The access modifiers of the top level component govern whether its members are available in the other packages i.e. even if we are having public methods in a class but the class is declared as default then its methods will not be available in other packages.
If one’s class is going to be used by other coders then he must ensure that errors due to misuse do not happen. For this he must provide the most restrictive access to its members like always declare the fields as private and provide methods to access/modify them.

<pre>
package package1;

public class Parent {

/**
*
*/
private int privateVariable;
public int publicVariable;
protected int protectedVariable;
int defaultVariable;

private int getPrivateVariable() {
return privateVariable;
}

private void setPrivateVariable(int privateVariable) {
this.privateVariable = privateVariable;
}

public int getPublicVariable() {
return publicVariable;
}

public void setPublicVariable(int publicVariable) {
this.publicVariable = publicVariable;
}

protected int getProtectedVariable() {
return protectedVariable;
}

protected void setProtectedVariable(int protectedVariable) {
this.protectedVariable = protectedVariable;
}

int getDefaultVariable() {
return defaultVariable;
}

void setDefaultVariable(int defaultVariable) {
this.defaultVariable = defaultVariable;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent=new Parent();
parent.setDefaultVariable(5);
parent.setPrivateVariable(4);
parent.setProtectedVariable(6);
parent.setPublicVariable(9);
}

}

package package1;

public class ChildInSamePackage extends Parent{

/**
* Public, Protected and Default members available.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInSamePackage childInSamePackage = new ChildInSamePackage();
childInSamePackage.setDefaultVariable(1);
childInSamePackage.setProtectedVariable(5);
childInSamePackage.setPublicVariable(7);
//childInSamePackage.setPrivateVariable(7); // not allowed. Compile time Error

Parent parent =new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(1);
parent.setPublicVariable(0);
//parent.setPrivateVariable(0); //not allowed. compile time error
}

}

package package1;

public class ClassInSamePackage {

/**
* Public, Protected and Default available but only to parent class object.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent = new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(5);
parent.setPublicVariable(9);
//parent.setPrivateVariable(9); //not allowed
}

}

package package2;

import package1.Parent;

public class ChildInDifferentPackage extends Parent{

/**
* Both public and Protected members can be accessed.
* But Protected can be accessed only through inheritance.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInDifferentPackage childInDifferentPackage = new ChildInDifferentPackage();
childInDifferentPackage.setProtectedVariable(5);
childInDifferentPackage.setPublicVariable(4);

Parent parent = new Parent();
parent.setPublicVariable(7);
//parent.setProtectedVariable(7); // not allowed. protected members are available only through inheritance.
}

}

package package2;

import package1.Parent;

public class ClassInDifferentPackage {

/**
* Only public members of parent class can be accessed
* but using the object of parent class.
*/
public static void main(String[] args) {

Parent parent = new Parent();
parent.setPublicVariable(4); // only public members are available.
}

}

</pre>

==Access Control in C#==
The accessibility levels of the types (class, interface, struct, enum etc.) and the members, controls whether they can be used from the other code in our assembly (*) or other assemblies.

===Accessibility levels provided by C#===

*"Public": It can be used for the types and type members. It allows them to be accessed everywhere in the same assembly or the other assembly.
*"Private": It can be used only for the members. Private members are accessible only within the class or the struct in which they are declared.
*"Protected": It is a member access modifier. It allows the class to hide its members from the other classes except the child classes.
*"Internal": It can be used both for the types and type members. Internal types and members are accessible only by the code in the same assembly.
*"Protected Internal": It’s a combination of protected and internal modifier. It allows the types and the members to be used by any code in the same assembly or by any derived class in another assembly. A protected internal element can be accessed in a derived class in another assembly by using an instance of the derived class.
[[File:Access2.png|400px|center|upright=0.56]]

Usage of these access modifiers for all types or members is dependent on the conditions like the accessibility of the container restricts the accessibility of a type member.
*- Assembly is a physical unit that can be executed, deployed, versioned and secured.

<pre>

internal class InternalClass
{
private int privateMember1;
protected int protectedMember2;
internal int internalMember3;
protected internal int protectedInternalMember4;

private class NestedClass
{
void Test(Class1 foo)
{
foo.Member1 = 0; //OK
foo.Member2 = 0; //OK
foo.Member3 = 0; //OK
foo.Member4 = 0; //OK
}
}
}

public class PublicClass
{
private void Method1()
{
}

private int privateMember1;

protected int Member1
{
get
{
return privateMember1;
}
set
{
Method1();
privateMember1 = value;
}
}

internal int internalMember2;
public int publicMember3;
protected internal int protectedInternalMember4;
}

class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //OK
internalClass.privateMember1 = 0; //Compilation error here
internalClass.protectedMember2 = 0; //Compilation error here
internalClass.internalMember3 = 0; //OK
internalClass.protectedInternalMember4 = 0; //OK
}
}

internal class DerivedClass : InternalClass
{
private void Test2()
{
privateMember1 = 0; //Compilation error here
protectedMember2 = 0; //OK
internalMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}

private class NestedClass
{
void Test(DerivedClass foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //OK
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class1 foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //Compilation error here
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
}
}

------------------ Class in a different assembly -------------------------------

public class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //Compilation error here

PublicClass publicClass = new PublicClass; //OK
publicClass.Method1(); //Compilation error here
publicClass.privateMember1 = 0; //Compilation error here
publicClass.Member1 = 0; //Compilation error here
publicClass.internalMember2 = 0; //Compilation error here
publicClass.publicMember3 = 0; //OK
publicClass.protectedInternalMember4 = 0; //Compilation error here
}
}

internal class DerivedClass : PublicClass
{
private void Test2()
{
Member1 = 0; //OK
internalMember2 = 0; //Compilation error here
publicMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}
private class NestedClass
{
void Test(DerivedClass foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class2 foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //Compilation error here
}
}
}

</pre>
==Conclusion==
The philosophies of access controls in object oriented languages have not changed much over time but certainly the access control across different Object Oriented Languages are different if not completely.

Thus we can see that by using the access modifier's each OO language controls the access to its class members.

==References==
# http://ruby-doc.org/core/
# http://rubylearning.com/satishtalim/ruby_access_control.html
# http://phrogz.net/programmingruby/tut_classes.html
# http://msdn.microsoft.com/en-us/library/kktasw36(v=VS.80).aspx
# http://www.kuzbass.ru:8086/docs/isocpp/access.html
# http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fcplr130.htm
# http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
# http://msdn.microsoft.com/en-us/library/wxh6fsc7.aspx
# http://stackoverflow.com/questions/2084801/c-using-declaration-scope-and-access-control
# http://en.wikipedia.org/wiki/Class_(computer_programming)#Member_accessibility
# http://www.jvoegele.com/software/langcomp.html
# http://csharp.net-informations.com/language/csharp-access-specifiers.htm
# http://blogs.oberon.ch/tamberg/2007-10-30/understanding-csharp-access-modifiers.html
# http://www.enscand.com/howtos/access/access.html

CSC/ECE 517 Fall 2011/ch2 2b sa

2011-10-01T17:55:50Z

Amaroo:

'''Access Control in Object Oriented Languages'''
:Each Object Oriented Language has its own way of implementing Access Control .This page discusses the various ways in which Access control is implemented in some of the Object Oriented Languages.
=='''Access Control'''==
Access control in programming languages provides the programmer the ability to define standards that are needed to hide the implementation of the modules from the public interface.Access control provides the programmer ,the ability to prevent under privileged users from access to internal components of a program and restricts them from changing the data within the component to an inconsistent state(i.e elements(members functions and variables) within a program(class)) there by protecting the integrity of the components .This concept of hiding the information in object oriented languages is called [http://en.wikipedia.org/wiki/Encapsulation Encapsulation].

==Access Control in Ruby==
Access control in ruby is achieved using the following [http://en.wikipedia.org/wiki/Java_syntax#Access_modifiers access modifiers]for the methods.
*''public'' :The methods that are declared as public can be accessed by any object belong to the class .
*''private'' :The methods that are declared as private can only be invoked in the context of the current object.
*''protected'' :The methods that are declared as protected can be invoked by the objects of both the class and the sub-classes.

In Ruby these modifiers only apply to the methods but not the instance variables.

====Public Methods in Ruby====
Public methods in ruby can be accessed by any object or instance of a Class and its Sub-classes.
Declaration of public methods:

<pre>
class A
def method
puts "hello"
end
end
</pre>

<pre>
class A
def method
puts "hello"
end
public :method
end
</pre>

====Private Methods in Ruby====
private methods in Ruby can only be invoked by the current object in question and one cannot invoke other object's private methods.
In Ruby private methods are not private to the class but they are private to the objects. No method is perfectly private in Ruby.

======Declaration of Private methods======
<pre>
class A
private
def method
end
end

class A
def method
end
private :method
end
</pre>

An example to show that private methods in Ruby can only be invoked by the current object in context.
<pre>
class A
def method
puts "I am a private method"
end
def pubm
method
A.new.method // It gives an error because pubm method is called in the context of object 'a',so only object 'a' can
puts "I am a public method" invoke the private method but not the new object.
end
private :method
end

class B
def m1
method //private methods of the base class can be accessed by the sub class
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

===Protected Methods in Ruby===
protected methods are visible in both the base class as well as the sub-classes(i.e they can be invoked by the objects of both the class and its sub-classes).

Declaration of protected methods is ruby.
<pre>
class A
protected
def method
end
end

class A
def method
end
protected :method
end
</pre>
Unlike private methods ,In Ruby protected methods can be called with an explicit receiver.

<pre>
class A
def method
puts "I am a protected method"
end
def pubm
method
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
protected :method
end

class B
def m1
method //protected methods of the base class can be accessed by the sub class.
end
end
a=A.new
b=B.new
a.pubm
a.method //gives an error
b.m1
</pre>

In Ruby both the private as well as the protected methods can be accessed from outside the class using send method.
<pre>
class A
def method
puts "I am a private method"
end
def pubm
method
A.new.method // It does not give an error because in the context of the current object, another object belonging to same
puts "I am a public method" class can invoke the protected method .
end
private :method
end
a=A.new
a.method // gives an error
a.send(:method) // prints "I am a private method"
a.send :method // prints "I am a protected method"
</pre>
==Access Control in C++==

===Controlling Access to the Member Data and Member Functions===

In C++ one can restrict the level of access control on the member data and function using the access specifiers public,private and protected.
A constructor should never be declared as private.
Access control is applied to all the names uniformly.

===Controlling the Level of accessibility of Base class and its Members===
If a class is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) inherited]using a public access specifier than the public members of the base class are inherited as the public members of the derived class and protected members of the base class are inherited as the protected members of the derived class.If a class is inherited using a private access specifier than both the public and protected members of the base class become the private members of the derived class.If a class is inherited using a protected access specifier than both the public and protected members of the base class become the protected. members of the derived class.
[[File:Access.png|400px|center|upright=0.56|Diagram Depicting the Visibility of members and the Inheritance effect.]]
However, the sub-class members can determine the values of the base class private members by using the Base class public member functions.

<pre>
class A
{
int a;
public:
int value()
{
a=10;
return a;
}
};
class B:public A
{
public:
int b;
void bvalue()
{
b=value(); //now b is assigned a value 10 .This is how the sub class can determine the value of the base class private member
printf("%d",b); variables
}
};
int main()
{
B o;
o.bvalue();
return 1;
}
</pre>

[http://en.wikipedia.org/wiki/Dynamic_dispatch Dynamic Binding] can be used to access the members of the derived class using the Base class pointer.Dynamic binding or late-binding or run time binding is achieved using virtual functions in the Base class.If the Base class pointer pointing to the derived class object and the matching function is declared virtual in base class, then which function is call is decided at run-time using virtual table entry.

===Friendly Functions===
Like ''send'' method in Ruby,C++ allow the Friend Functions which are not within the scope of the class to access the private members of the class. The friend function are defined like any other function without using either the keyword friend or [http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=%2Fcom.ibm.vacpp7l.doc%2Flanguage%2Fref%2Fclrc05cplr175.htm :: scope resolution operator].Since they are not within the scope of the class ,they cannot be called using the objects of the class.Declaration of a friend function in either the public or private part of the class does not change it functionality.

===Friend Classes===
A class declared as a [http://en.wikipedia.org/wiki/Friend_class friend class] of an another class can access all the private and protected members of the class extending friendship.

==Access Control in Java==
Access control can be defined as the methods that limit accessibility of the resources to a set of users or programs to enforce integrity, confidentiality or availability constraints.
Java provides two levels of access controls

*"Top Level" – Public, or Package-Private (no explicit modifier, also known as default).

*"Member Level" – Public, Private, Protected or Package-Private (no explicit modifier, also known as default).
===Top Level===
On the Top level come classes and interfaces. An Interface can only be declared as public. While a class can be declared to be either public or default. If a class is declared as public then it is visible to all the classes in the same or a different package. But if a class is declared with no access specifier i.e. default, then it is public in its own package i.e. it cannot be accessed outside the package other than the one in which it is declared.
===Member Level===
At the member level we can declare fields, methods and constructors as public, private, protected and default. Public and default modifiers are used in the same way as the top level and with the same meaning. When a member of a class is declared as private then it can be accessed only within the class. Also, when a member is declared as protected then it can be accessed by all the classes in the same package and the sub classes (of its class) in other packages.

====Example====
To understand it in more detail consider the following the example.
In the example each package contains two classes. Class C is a sub class of class A. Assuming class A as public then its members can be accessed like –
Class A – It can access all its members independent of their access modifier.
Class B – It can access all the members of class A except those are private.
Class C – It can access public and protected members of class A because it is a sub class of class A.
Class D – It can access only the public members of class A.
The access modifiers of the top level component govern whether its members are available in the other packages i.e. even if we are having public methods in a class but the class is declared as default then its methods will not be available in other packages.
If one’s class is going to be used by other coders then he must ensure that errors due to misuse do not happen. For this he must provide the most restrictive access to its members like always declare the fields as private and provide methods to access/modify them.

<pre>
package package1;

public class Parent {

/**
*
*/
private int privateVariable;
public int publicVariable;
protected int protectedVariable;
int defaultVariable;

private int getPrivateVariable() {
return privateVariable;
}

private void setPrivateVariable(int privateVariable) {
this.privateVariable = privateVariable;
}

public int getPublicVariable() {
return publicVariable;
}

public void setPublicVariable(int publicVariable) {
this.publicVariable = publicVariable;
}

protected int getProtectedVariable() {
return protectedVariable;
}

protected void setProtectedVariable(int protectedVariable) {
this.protectedVariable = protectedVariable;
}

int getDefaultVariable() {
return defaultVariable;
}

void setDefaultVariable(int defaultVariable) {
this.defaultVariable = defaultVariable;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent=new Parent();
parent.setDefaultVariable(5);
parent.setPrivateVariable(4);
parent.setProtectedVariable(6);
parent.setPublicVariable(9);
}

}

package package1;

public class ChildInSamePackage extends Parent{

/**
* Public, Protected and Default members available.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInSamePackage childInSamePackage = new ChildInSamePackage();
childInSamePackage.setDefaultVariable(1);
childInSamePackage.setProtectedVariable(5);
childInSamePackage.setPublicVariable(7);
//childInSamePackage.setPrivateVariable(7); // not allowed. Compile time Error

Parent parent =new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(1);
parent.setPublicVariable(0);
//parent.setPrivateVariable(0); //not allowed. compile time error
}

}

package package1;

public class ClassInSamePackage {

/**
* Public, Protected and Default available but only to parent class object.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Parent parent = new Parent();
parent.setDefaultVariable(0);
parent.setProtectedVariable(5);
parent.setPublicVariable(9);
//parent.setPrivateVariable(9); //not allowed
}

}

package package2;

import package1.Parent;

public class ChildInDifferentPackage extends Parent{

/**
* Both public and Protected members can be accessed.
* But Protected can be accessed only through inheritance.
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ChildInDifferentPackage childInDifferentPackage = new ChildInDifferentPackage();
childInDifferentPackage.setProtectedVariable(5);
childInDifferentPackage.setPublicVariable(4);

Parent parent = new Parent();
parent.setPublicVariable(7);
//parent.setProtectedVariable(7); // not allowed. protected members are available only through inheritance.
}

}

package package2;

import package1.Parent;

public class ClassInDifferentPackage {

/**
* Only public members of parent class can be accessed
* but using the object of parent class.
*/
public static void main(String[] args) {

Parent parent = new Parent();
parent.setPublicVariable(4); // only public members are available.
}

}

</pre>

==Access Control in C#==
The accessibility levels of the types (class, interface, struct, enum etc.) and the members, controls whether they can be used from the other code in our assembly (*) or other assemblies.

===Accessibility levels provided by C#===

*"Public": It can be used for the types and type members. It allows them to be accessed everywhere in the same assembly or the other assembly.
*"Private": It can be used only for the members. Private members are accessible only within the class or the struct in which they are declared.
*"Protected": It is a member access modifier. It allows the class to hide its members from the other classes except the child classes.
*"Internal": It can be used both for the types and type members. Internal types and members are accessible only by the code in the same assembly.
*"Protected Internal": It’s a combination of protected and internal modifier. It allows the types and the members to be used by any code in the same assembly or by any derived class in another assembly. A protected internal element can be accessed in a derived class in another assembly by using an instance of the derived class.
[[File:Access2.png|400px|center|upright=0.56]]

Usage of these access modifiers for all types or members is dependent on the conditions like the accessibility of the container restricts the accessibility of a type member.
*- Assembly is a physical unit that can be executed, deployed, versioned and secured.

<pre>

internal class InternalClass
{
private int privateMember1;
protected int protectedMember2;
internal int internalMember3;
protected internal int protectedInternalMember4;

private class NestedClass
{
void Test(Class1 foo)
{
foo.Member1 = 0; //OK
foo.Member2 = 0; //OK
foo.Member3 = 0; //OK
foo.Member4 = 0; //OK
}
}
}

public class PublicClass
{
private void Method1()
{
}

private int privateMember1;

protected int Member1
{
get
{
return privateMember1;
}
set
{
Method1();
privateMember1 = value;
}
}

internal int internalMember2;
public int publicMember3;
protected internal int protectedInternalMember4;
}

class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //OK
internalClass.privateMember1 = 0; //Compilation error here
internalClass.protectedMember2 = 0; //Compilation error here
internalClass.internalMember3 = 0; //OK
internalClass.protectedInternalMember4 = 0; //OK
}
}

internal class DerivedClass : InternalClass
{
private void Test2()
{
privateMember1 = 0; //Compilation error here
protectedMember2 = 0; //OK
internalMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}

private class NestedClass
{
void Test(DerivedClass foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //OK
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class1 foo)
{
foo.privateMember1 = 0; //Compilation error here
foo.protectedMember2 = 0; //Compilation error here
foo.internalMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
}
}

------------------ Class in a different assembly -------------------------------

public class Test
{
void Test1()
{
InternalClass internalClass = new InternalClass(); //Compilation error here

PublicClass publicClass = new PublicClass; //OK
publicClass.Method1(); //Compilation error here
publicClass.privateMember1 = 0; //Compilation error here
publicClass.Member1 = 0; //Compilation error here
publicClass.internalMember2 = 0; //Compilation error here
publicClass.publicMember3 = 0; //OK
publicClass.protectedInternalMember4 = 0; //Compilation error here
}
}

internal class DerivedClass : PublicClass
{
private void Test2()
{
Member1 = 0; //OK
internalMember2 = 0; //Compilation error here
publicMember3 = 0; //OK
protectedInternalMember4 = 0; //OK
}
private class NestedClass
{
void Test(DerivedClass foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //OK
}
void Test(Class2 foo)
{
foo.Member1 = 0; //Compilation error here
foo.internalMember2 = 0; //Compilation error here
foo.publicMember3 = 0; //OK
foo.protectedInternalMember4 = 0; //Compilation error here
}
}
}

</pre>
==Conclusion==
The philosophies of access controls in object oriented languages have not changed much over time but certainly the access control across different Object Oriented Languages are different if not completely.

==References==
# http://ruby-doc.org/core/
# http://rubylearning.com/satishtalim/ruby_access_control.html
# http://phrogz.net/programmingruby/tut_classes.html
# http://msdn.microsoft.com/en-us/library/kktasw36(v=VS.80).aspx
# http://www.kuzbass.ru:8086/docs/isocpp/access.html
# http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fcplr130.htm
# http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
# http://msdn.microsoft.com/en-us/library/wxh6fsc7.aspx
# http://stackoverflow.com/questions/2084801/c-using-declaration-scope-and-access-control