RubyWorks

faster tests

2006-06-08T16:26:00.000+05:30

If you are using sqlite, this plugin is a nice way to speed up your tests

assertions when using rjs

2006-05-22T17:40:00.000+05:30

rjs is a pretty neat way to avoid javascript code and implement the required functionality using ruby/rails itself.

When rails comes across a rjs template, it renders the html page and inserts the JavaScript into that page and returns it to the browser for execution.

Which is good, until you figure out that the functional testing assertion framework that ships with Rails suddenly does not hold good ! Basically the asserts work on the assumption that after an action is performed, the response object holds valid HTML code which it can hook into and perform the assertions, whereas when we use rjs the respose body actually contains Javascript code too.

Came across this nice assertions plugin(rjs_assertions) which helped us test the code which had the rjs bits. Good stuff.

Creating a Synchronous call using Prototype

2006-04-20T11:20:00.000+05:30

Tried to make a Synchronous Ajax call using the Script.aculo.us Library. Damn how do you do it ?

new Ajax.Request('/foo/bar', {asynchronous:true});

Looking at the code, setting the 'asynchronous' flag to 'false' should do the trick. Unfortunately, this does not seem to work.


new Ajax.Request('/foo/bar', {asynchronous:false});

Wierd

But got a chance to peek into prototype.js. Wow. Javascript can be beautiful.

App Wide settings

2006-04-16T14:28:00.000+05:30

We recently played a card which read something along these lines - 'As a user of this system I should be able to set some application settings in the database'

Till date we had kept all the 'settings' (for the lack of a better word) in a module and we were using it off the module.

module Prefs
 BASE_DIR='blah'
 REMOTE_SERVER='blah blah'
 ...
end

usage in the code was

  Prefs::BASE_DIR

Had not heard about this Settings plugin by Alex Wayne, but I think we came up with a simpler solution using the 'const_missing' on an object. The Settings plugin uses 'method_missing' to do pretty much the same, but it needed constants to be called like this - Prefs.constant(which I feel is confusing) rather than Prefs::CONSTANT.

module Prefs
 def self.const_missing(constant)
   const_set(constant, Preference.value(constant))
 end
end

So basically whenever we access a constant on Prefs (like Prefs::BASE_DIR) the const_missing is triggered and we dip into the Preference table to fetch the constant and set it on Prefs.

So a bunch of hardcoded constants were easily turned into a few lines of code that fetched the information from the database. And the best part was that we did not have to go and change the way we access constants all over the code.

What ?

2006-04-07T22:54:00.000+05:30

just came across this today !

Looks like .id is going to be deprecated soon and we're going to be heading the .object_id soon !

create YAML Fixtures

2006-03-30T17:06:00.000+05:30

Very cool.
This makes it very simple to convert your data into YAML fixtures to be used in tests.

Test Databases - do a rake migrate if you change the structure

2006-03-25T13:02:00.000+05:30

Some of the functional tests were failing because of a missing column in a table. Took us some time to figure out the real issue.

Added an extra column 'x' using rails migration. Ran the functional tests to make sure that they all pass.

They failed, complaining that there was no column 'x' present.

Decided to check the test_database to see if that new column was created in the table. And it was not.

The way rails handles testing, it creates a test_database using the structure of the tables in the development_database and populates the tables using the fixtures. Hence if the development_database is not current (w.r.t the migration scripts) then the test database too does not have the latest structure.

Ran the migrate task. Got the development_database synched up and ran the tests.
Voila. All passed :-)

Puzzling behavior

2006-03-21T22:45:00.000+05:30

Was debugging some code today that was working on a windows box, but was not working in a Linux box.


class MapController
 model :Roads

 def draw_roads
   render :text => "No Routes to show" if no_roads
 end
end

On the linux box, draw_roads would always look for a draw_roads.rhtml template and go ahead with the execution. Whereas in a Windows box, the check would be performed and accordingly a render of "No Routes to Show" would happen or draw_roads.rhtml would have gotten rendered.

After some debugging and placing of puts statements in the code figured that the issue was with the


 model :Roads

bit. It should have been


 model :roads

But still not sure why this worked on a windows box and not a linux box !!

Javascript development

2006-03-21T22:44:00.000+05:30

Stumbled upon an interesting Plugin for Eclipse today. JSEclipse. Very useful when you dabble a bit in Javascript at work and during play

Ruby Hacking Guide

2006-03-18T23:38:00.000+05:30

Awesome News.

Vincent has started translating the Ruby Hacking Guide into English !!
Currently only one chapter has been translated. And its awesome. The original book is in Japanese. Had tried converting it into English using Google Translate, but things did not make too much sense.

After reading the chapter on Objects in the translated version, lotsa small things started falling into place. Like for example I finally understood why we have symbols in Ruby.

Great going Vincent.

require 'pain_in_the_ass'

2006-03-07T19:01:00.000+05:30

disclaimer: I might be doing something wrong, hence the experience.

Using Stubs in Rails has been one hell-of-an-experience.
The concept of using mocks/stubs in Rails is very simple (just open a class and add stuff to it). But in practise, this has never been the experience. Whenever I have tried to use mocks, trying to require the original file has been very painful.

For example I have this file called song_search.rb under app/controllers
Tried writing a mock under /test/mock

require File.dirname(__FILE__) + '/../../../app/controllers/song_search'
class SongSearch
def page
end
end

But the tests indicated that this file was not being picked up !! Tried all combinations to get the require right. To no avail. Im sure Im doing something wrong. It cant be that difficult.

Anyways in the end, I just added this to the test class

require 'song_search'
class SongSearch; def page() @page end; end

That worked. But gotto find a better way to do this. :-(

sqlite3 database meta information

2006-03-07T09:34:00.000+05:30

After being pretty unsuccesful trying to read the docs for sqlite3 table metadata, last evening we managed to pull these sql statements out of the rails sqlite3 adatapter code:

PRAGMA table_info(table_name)
SELECT name FROM sqlite_master WHERE type = 'table'
PRAGMA index_list(table_name)
PRAGMA index_info('index_name')

Faster testing with Rails

2006-03-02T02:07:00.000+05:30

Just came across this article Faster testing with Rails 1.0 by Mike Clark
Decided to check out the impact of it on our application.

Currently we are using both transactional_fixtures as well as instantiated_fixtures.

UnitTests
Finished in 2.197282 seconds.
48 tests, 247 assertions, 0 failures, 0 errors

Functional Tests
Finished in 3.798338 seconds.
56 tests, 226 assertions, 0 failures, 0 errors

on turning off instantiated_fixtures (as suggested by Mike)

UnitTests
Finished in 1.999902 seconds.
48 tests, 247 assertions, 0 failures, 0 errors

Functional Tests
Finished in 3.59077 seconds.
56 tests, 226 assertions, 0 failures, 0 errors

Not too much of a difference. But then we still dont have too many tests and I guess every second counts.

Extension vs Mixin

2006-03-02T00:40:00.000+05:30

Rocking post at The LunchRoom.

Performance Issues - With produces

2006-02-28T21:31:00.000+05:30

We seem to be having an issue with the periodical on this project.

There is a small portion of the application which needs to be updated whenever a user interacts with a hardware device connected to the machine.

Our initial take on this was to have a periodical which would poll the server every '0.5' seconds to figure out if the event had happened. Very simple indeed.

Until we were hit with some insane performance issues !!

Initially we saw that all the development machines, but one, seemed to be hogging more and more memory as time passed by, and eventually some of them just froze up. After some poking around the only difference we could see was that on that 'one' machine we had ruby compiled for the i386 whereas all the others seem to be i686 (thats what ruby -version told us). So we went ahead and installed the precompiled i386 version of ruby on some machines and that seemed to solve the issue for sometime (still dont understand why)

Anyways. The issue resurfaced and today we went about trying to fix it.

Initially we thought that instead of doing a Pull from the client we should Push this information from the server. The basic idea behind a Push from the server being that once a connection is opened to the server by a client, the server keeps this connection open by never closing it and periodically (or whenever the need arises) sending information to the client.

So spent a bit of time today reading up on how to push information from the server and trying to implement it with Rails. There are quite a few interesting examples on how to do this. But we ended up digging into the Rails code to figure out how rendering actually works in rails and figured that it was not easy to bypass the rails way of doing things. Rails prevents us from doing this kind of stuff(keeping the connection open and rendering continuously) because of the Double Render issue. So we tried to get the response object and tried to work with the output stream on the response object. But dipping into the Rails code we figured that the output stream is just a StringIO and later the rails actually picks up the data and uses it to create the body and header and pushes this info to webrick.

In the end found this link. Basically it mentions that in the development mode the rails app reloads itself on every request.

Daaam !! Had forgotten about this. So just tried to run the application in production mode and things seem to be fine now !!

whew ...

Found another Web server mongrel. This seems to be much faster than webrick. It consumed half the memory that Webrick was consuming and the app seemed snappier when using mongrel.

Creating a production db in rails

2006-02-28T20:56:00.001+05:30

To setup your database for production -
1) Add an entry for production in the database.yml file
2) Run "rake environment RAILS_ENV=production migrate"

Calling methods on another Controller in Functional Tests

2006-02-24T21:05:00.000+05:30

Today while trying to write a functional test in our rails app we came across an issue wherein the session had to be setup in a particular manner before we could actually test this action we were interested in.


post :delete_flower

so we wanted delete_flower action to be called on the FlowerController. But for the test to pass we needed some action on GardenController to be called (so as to mimic what would happen on the GUI)

but get and post methods are called only on the current controller. So we wrote up this helper method in the test_helper.rb file


class Test::Unit::TestCase
 def switch_controller(klass)       
  old_controller = @controller       
  @controller = klass.new       
  yield
  @controller = old_controller
 end
end

So in our code we could do something like


def test_delete
 switch_controller(GardenController) do
   post :plant_flower
 end
 post :delete_flower
 assert_no_flower_in_garden
end


[Updated later] - Just saw that they have added the concept of an Integration Test for the next release of rails.
So Looks like all this might not be necessary !!

Active Record, Observer and troubles

2006-02-21T19:39:00.000+05:30

When you attach an observer to an ActiveRecord you normally would expect certain callbacks like after_update etc. to occur on appropriate events. But there could be workflows where this callback may not occur. Atleast thats what we found out today.
We have a search box where the user can key in the name of a song and this causes all the songs matching the criteria to be loaded. We were trying to observe the Song object for updates to any of its fields.
In the siprit of TDD we started by writing our tests first and within a few mins our test that asserted that the callback's occurrance was passing.
Now we tried the same in the development environment from the browser. And it did not work.
After digging for sometime we saw that the only difference between the development and test envs was that class caching was turned on in the test env while it was not in the dev env. We turned on class caching in the dev env and it worked like a chum (config.cache_classes = true).