Rss Feed Tweeter button Facebook button Technorati button Reddit button Linkedin button Webonews button Delicious button Digg button Flickr button Stumbleupon button Newsvine button

A Waage Blog

Ruby, Rails, Life

Archive for October, 2008

Converting Timezones in Ruby: TZInfo

with one comment

In a recent Rails project, I was trying to figure out how to allow users to view any email’s “Date:” header in his/her own timezone. Here’s a short explanation about how I accomplished this using Ruby’s TZInfo gem!

Purpose:
If an email was sent out from New York, the header would contain a Date string like the following (notice the offset):

Fri, 24 Oct 2008 18:35:07 -0400 (EST)

Now, it makes sense for a user in Los Angeles to be able to view the Date/time as 15:35 pm, while a user in New York City should be able to view it as 18:35pm.

Here’s what I did.

Of course, I installed TZinfo first:

%>sudo gem install tzinfo

Each user should have a timezone associated. Try the following method for a list of timezones in US:

 >>TZInfo::Country.get('US').zone_identifiers

Let’s take two users as an example. We have lakersfan is on the west coast, and knicksfan is on the east coast:

>> lakersfan.timezone = TZInfo::Timezone.get('America/Los_Angeles')
>> knicksfan.timezone = TZInfo::Timezone.get('America/New_York')

Given a date/time string like the following (could be taken from the email header or elsewhere):

>>timestring = "Fri, 24 Oct 2008 18:35:07 -0400 (EST)"

first call Time.parse(timestring) which will create a time object with offset info. **Note that this is different from calling timestring.to_time (which will disregard offset info and store the Time object as UTC).

>> timestring = "Fri, 24 Oct 2008 18:35:07 -0400 (EST)"
>> Time.parse(timestring)
=> Fri Oct 24 18:35:07 -0400 2008 #Stores the Time object with offset
>> timestring.to_time
=> Fri Oct 24 18:35:07 UTC 2008 #Incorrect - the offset is ignored

Now, once you’ve got the Time object in proper format (with offset), you can just call the ‘utc’ method to convert the time into UTC format:

>> utctime = Time.parse(timestring).utc

Lastly, once the time is in UTC format, you can use any user’s timezone object to call ‘utc_to_local’ method and convert that utc time into the user’s timezone!

>> lakersfan.tz.utc_to_local(utctime)
=> Fri Oct 24 15:35:07 UTC 2008
>> knicksfan.tz.utc_to_local(utctime)
=> Fri Oct 24 18:35:07 UTC 2008

Voila! Lakers fan (west coast) sees the time as 15:35, while the Knicks fan (on east coast) sees the time as 18:35 – the same as the email header.

Written by Andrew Waage

October 25th, 2008 at 6:14 pm

Posted in Ruby and Rails

Tagged with , , ,

Functional Testing Cookies in Ruby on Rails 1.2.3

with 2 comments

After spending a good couple hours + trying to figure out why my functional tests were failing when working with cookies, I came across a couple great resources for rails + testing cookies.

Here’s a good basic explanation of using cookies on Pluit solutions website. Then I came across the Robby on Rails blog that led me to understand (and misunderstand) the asssert_cookie plugin.

However, I was still having a lot of trouble figuring out why I was setting my @request.cookies['foo'] in my functional test, but later (in the same test method) checking for cookies['foo'] and not finding anything in the cookie jar!

I then tried setting cookies['foo'] in my controller test, but found that when I did a check for the existance of that cookie in my actual controller code, it was not there! I thought that I should be able to set up a cookie in a test and have my controller recognize it. This is true, however, not by setting cookies['foo'].

So… I opened up a blank controller and functional test and began testing out different combinations to find out exactly what was going on. I hope this little example helps to save someone else’s precious time. Here it goes…

This is the controller I will be referring to for my example tests:

========= controller
  def foo
    if cookies['oreo'] == 'yesitis'
      @info =  "Oreos are tasty"
    else
      @info = "Only Milk here"
    end
     render :nothing => true
  end

1. In your functional test, do not test for presence of a cookie after a get request to a particular action, unless the action you are testing specifically sets up that cookie. In other words, if your controller action is not setting the cookie, do not test for that cookie’s presence.

In the above controller, no cookies are ever being set. Therefore, testing for the presence of a cookie after the get request (in a test method) will return false.

In other words, the cookie is recognized by the controller, however, notice that cookies['oreo'] is nil after the get request:

  def test_oreo
    @request.cookies['oreo'] = CGI::Cookie.new("oreo", "yesitis")
    get :foo
    assert_equal({}, @response.cookies)
    assert_equal(nil, cookies['oreo'])
    #Assert cookie will be nil here so do not test it:
    #assert_cookie :o reo
    puts assigns['info'] #"Oreos are tasty"
  end

Note:
1. After your get request, the @response.cookies will be empty
2. After your get request, cookies['oreo'] will still be nil.
3. After your get request, you cannot use assert_cookie because it will be nil

2. If your controller action expects a cookie to be there, you cannot set it up in your functional test by assigning:

  • cookies['oreo'] = true (incorrect) OR
  • @request.cookies['oreo'] = true (incorrect)
  • The only way to set up your cookie for a subsequent request, so that your controller will see it is:

    • @request.cookies['oreo'] = CGI::Cookies.new(’oreo’, true) (correct)
      #INCORRECT
      def test_oreo
        cookies['oreo'] = 'yesitis'
        get :foo
        puts assigns['info'] #"Only Milk here"
      end
    
    #INCORRECT
      def test_oreo
        cookies['oreo'] =  CGI::Cookie.new("oreo", "yesitis")
        get :foo
        puts assigns['info'] #"Only Milk here"
      end
    
    #INCORRECT
      def test_oreo
        @request.cookies['oreo'] = 'yesitis'
        get :foo
        puts assigns['info'] #"Only Milk here"
      end

    The only way to set up your cookie in a functional test and have your controller recognize it.

    #CORRECT
      def test_oreo
        @request.cookies['oreo'] = CGI::Cookie.new("oreo", "yesitis")
        get :foo
        puts assigns['info'] # Will print out "Oreos are tasty"
      end

    3. Avoid the temptation to use symbols in your tests with cookies.

    • cookies[:foo] -> BAD
    • cookies['foo'] -> GOOD

    4. Only use assert_cookie (plugin: see above for link) if you are testing that the controller action is creating a new cookie.

    5. If you are testing multiple actions and redirects from one action to another action in the same controller, you do not need to set the cookie before each action, explicitly. The cookie will remain in the @request object that you created in the setup method of your test.

    EXAMPLE TWO (Testing persistent cookies)
    You DONT set up the cookie for each subsequent request.
    It does “persist” throughout your test-method because you are
    using the same @request object!!

    ========controller
      def foo
        if cookies['oreo'] == 'yesitis'
    	puts "Foo has OREO"
        else
     	puts "Foo has NOTHING"
        end
          redirect_to :action => :bar
          return true
      end
    
      def bar
        if cookies['oreo'] == 'yesitis'
          puts "Oreos are tasty"
        else
          puts "Only Milk here"
        end
         render :nothing => true
      end
    
    ========= Test
      def test_oreo
       @request.cookies['oreo'] =  CGI::Cookie.new('oreo', "yesitis")
        get :foo    #OUTPUTS: Foo has OREO
    
        # COOKIE PERSISTS HERE!!
        # Don't need to explicitly set cookie again in the
        # @request.cookies object
        get :bar   #OUTPUTS: Oreos are tasty
      end

    Written by Andrew Waage

    October 13th, 2008 at 7:33 am