Denis Hennessy

Unit Testing on the IPhone

2009-05-24T00:00:00+01:00

Writing unit tests for an IPhone application is unfortunately a bit more involved than it need be. Here’s how you can get it going for your project (it’s really worth your while doing this at the start of the project, and writing tests as you implement new features but you already know that, right?).

Google have a project called Google Toolbox for Mac located at http://code.google.com/p/google-toolbox-for-mac. Download the latest version and unpack it directly into your project. Rename the directory to google-toolbox-for-mac (it will make it easier to follow along).

Open your project in XCode and then choose Project > New Target... Pick Cocoa Touch Application as the template and name the target Unit Tests. Choose Project > Set Active Target > Unit Tests.

Choose Project > Add to Project... and pick the following files (make sure each are added to the Unit Tests target):

google-toolbox-for-mac/UnitTesting/GTMIPhoneUnitTestMain.m
google-toolbox-for-mac/UnitTesting/GTMIPhoneUnitTestDelegate.m
google-toolbox-for-mac/UnitTesting/GTMIPhoneUnitTestDelegate.h
google-toolbox-for-mac/UnitTesting/GTMSenTestCase.m
google-toolbox-for-mac/UnitTesting/GTMSenTestCase.h
google-toolbox-for-mac/GTMDefines.h

Right-click on Unit Tests in the Targets group and choose Add > New Build Phase > New Run Script Build Phase

Paste this text into the Script box:

${INPUT_FILE_DIR}/google-toolbox-for-mac/UnitTesting/RunIPhoneUnitTest.sh

Try a build now (Cmd-B) and look in the build log. You should see a line like this:

Executed 0 tests, with 0 failures (0 unexpected) in 0.002 (0.002) seconds

Switch back to your normal target and verify that it still builds OK. This is probably a good time to commit everything into source control.

Adding a unit test

Choose File > New File... and select Objective-C test case class from the Mac OS X Cocoa group. Call it FooTest.m if you’re testing a Foo class. Edit the FooTest.h file and replace the existing #import line with:

#import "GTMSenTestCase.h"

That’s it! Add individual test methods and run the tests by doing a build (Cmd-B)

Sending emails in the background with cron and rake

2009-04-16T00:00:00+01:00

Many web applications have to run periodic tasks and it’s really important to decouple these tasks from the clients request thread. One well-proven way to manage these is to use cron to execute the tasks. I had to do this recently to send reminder emails to authors in StatusHub and thought I’d share how easy it was.

First, create a rake task to provide an easy interface to the tasks. This makes it easy to test them out or manually run them. I created a file in lib/tasks called cron.rake:

namespace :cron do
  desc "Send email reminders to all authors on upcoming and overdue reports"
  task :send_reminders => :environment do
    Report.send_reminders
  end
end

Here, Report is one of my models and send_reminders is a class method on that:

def self.send_reminders
  Report.due_drafts.find_each do |report|
    Mailer.deliver_report_due report
  end
end

The Mailer model is a subclass of ActionMailer::Base and has methods for each type of message you want to send. This one looks like:

def report_due(report)
  recipients report.author.email
  from       "StatusHub<support@statushub.com>"
  subject    "Your report entitled '#{report.title}' is #{report.overdue? ? 'overdue' : 'due'}"
  sent_on    Time.now
  content_type "text/plain"
  body       :report => report, :url => design_report_url(report, :host => report.author.account.host)
end

Calling Mailer.deliver_report_due invokes the report_due method and then renders report_due.html.erb into the body of the email. You can now test the task with:

$ rake cron:send_reminders

On the production server, the job can now be automated by adding the following like to your crontab (edit with crontab -e):

00 04 * * * cd /app/statushub/current && /usr/bin/rake RAILS_ENV=production cron:send_reminders

Dressing for your wireframes

2009-03-08T00:00:00+00:00

I was at the Future of Web Apps Dublin conference on Friday and a one of the speakers (I think it was Des from contrast.ie) showed a screen from a wireframing tool called Balsamiq. Here are my thoughts after using it for a little while…

At its heart, Balsamiq is a vector drawing tool with a library of built in ’smart’ shapes like OmniGraffle or Visio. The key difference is that instead of having realistic-looking controls to place on the page, the controls are drawn in a cartoony style. A typical page looks like this:

The fact that the design is not pixel-perfect is actually a huge time saver. I’ve often started in OmniGraffle with the intent of just sketching out how the page should be laid out or how the user should interact with it, and then ended up many hours later tweaking colours and fonts and alignment because I can’t ignore the fact that they’re ‘wrong’. Well, in Balsamiq, the effect is much more like using a whiteboard – when’s the last time you rubbed out what you just wrote on a whiteboard because the font was wrong??

The timesaving in the design of a page also carries over to group review of the page. The fact that it’s ‘just a wireframe’ forces people to evaluate the design at that level.

In terms of negatives, the only gripe I have is that the interface is written using Adobe AIR which means that it definitely has a non-native feel to it. Nothing fatal, just a bit jarring in places.

Updates: Someone also recommended trying Konigi stencils, found here: http://konigi.com/tools/omnigraffle-wireframe-stencils

Adding SSL support for signup and login to a Rails app

2008-12-12T00:00:00+00:00

First, get an SSL Cert. In a quick search, GoDaddy seem to be one of the cheaper options at $29.99/year. Pick the ‘Standard SSL’ option.

Important: When prompted for a passphrase, just press enter. Otherwise you’ll have to enter it every time you start apache.

$ openssl genrsa -des3 -out clikboard.key 1024
$ openssl req -new -key clikboard.key -out clikboard.csr

On the GoDaddy site, click on the certificate you’ve just bought and you will be taken to a screen where you confirm the contact details and a place to host the certificate signing request. Paste the contents of clikboard.csr into this area. Click next and shortly afterwards you’ll receive an email with a link to the certificate zipfile (containing, in my case, 2 files – gd_bundle.crt and clikboard.com.crt). Copy these onto your production server.

On the server, edit /etc/apache2/sites-available/clikboard (replace this with your site config) to make a copy of the VirtualHost section and replace the :80 with :443 and add the following lines:

SSLEngine on
SSLCertificateFile /home/denis/ssl/clikboard.com.crt
SSLCertificateKeyFile /home/denis/ssl/clikboard.key
SSLCertificateChainFile /home/denis/ssl/gd_bundle.crt

Then, enable SSL and restart apache:

$ sudo a2enmod ssl
$ sudo /etc/init.d/apache2 force-reload

Verify that the site now works with both http and https urls. Of course, all this is apache stuff and really nothing to do with rails. The last part of getting it working with your rails app is actually trivial:

./plugin/install ssl_requirement

Then, follow the instructions in vendor/plugins/ssl_requirement/README.

Creating a Logo for your web 2.0 service

2008-12-04T00:00:00+00:00

As we were approaching the launch date for http://clikboard.com (at least once we were adding items to the Lighthouse list slower than we were implementing them), we realised that we needed a cool logo that people would remember and associate with the site. After briefly flirting with the idea drawing it ourselves, we decided to go with an outside designer.

I had heard of design contests before and thought this would be an interested excuse to try them out. Here’s what happened…

First, I picked http://99designs.com to run the contest. They’re pretty new but have a clean, transparent service and have a good number of designers available. The contests are fixed to run for exactly one week which seemed perfect. The cost for running a contest is $39 (assuming you don’t add any extras). You have to set a prize amount which is what you pay for the winning design. I set it to $300 which seemed typical.

Second, I wrote a design brief. This is pretty important because you have to give a design something to start from. The way it seems to work is that they come up with concepts from the brief, and then evolve the designs based on your feedback.

Once the contest was launched, we had the first designs within hours! We realised that it was really important to send meaningful feedback as quickly as possible so that the designers could act on it. Because the designers were from all over the world, new designs were coming in right around the clock!

By the end of the week, we had 45 designs. You can see them at our contest page – In the end we went with this design (it captured the ‘click’ and ‘board’ part best and has a distinctive favicon):

Overall, the experience was very positive. In the past I’ve worked with designers where you just don’t ‘click’ (no pun) and it’s hard to get him to understand what you’re looking for. By working with a group and scoring the designs as you go, it seems easier to steer the design and get what you want.

Switching rails apps from sqlite to mysql

2008-10-05T00:00:00+01:00

Since Rails 2.0.2, Sqlite has been the default database for new projects. This is great to get you started but at some stage you’re likely to want to move to a bigger DB like mysql or postgres. Here’s the steps involved:

Edit your config/database.yml file and make it look like this (change the database names, username and passwords to match your environment):

development:
  adapter: mysql
  encoding: utf8
  database: myapp_development
  username: root
  password:
  socket: /tmp/mysql.sock

test:
  adapter: mysql
  encoding: utf8
  database: myapp_test
  username: root
  password:
  socket: /tmp/mysql.sock

production:
  adapter: mysql
  encoding: utf8
  database: myapp_production
  username: root
  password:
  socket: /tmp/mysql.sock

Then, recreate your databases and tables:

$ rake db:create:all
$ rake db:migrate

That’s it!

Making sure rspec + rcov report on all your code

2008-10-01T00:00:00+01:00

One of the things that easily catches people out with rcov is that it doesn’t show you the coverage of all your code, it just shows the coverage of the code touched by your tests. So, if you completely forget to add tests for a new controller, that won’t appear in your coverage report.

Here’s an easy fix: save the following code as spec/app_spec.rb:

require File.dirname(__FILE__) + '/spec_helper'

dir = File.dirname(__FILE__)
Dir[File.expand_path("#{dir}/../app/**/*.rb")].uniq.each do |file|
  require file
end

It simply includes all the ruby files under your /app directory so that they’re reported properly by rcov.

Grouped Links in a Rails application

2008-09-26T00:00:00+01:00

Background – grouped links

Normally, when people talk about paging in a web application, they mean providing next/previous links and direct links to particular page numbers. Here’s some examples you should be familiar with:

This style of paging is supported very well by the will_paginate plugin. However, some types of information don’t readily lend themselves to this type of paging. When listing people, for instance, it’s natural to want to jump directly to the ‘M’ names, just like you would with a telephone directory. For this type of information, what you want is a set of links that take you directly to the page with the first occurrence of a particular letter:

The greyed letters indicate that there are no entries beginning with that letter.

I’ve needed this for a recent project and implemented it as a patch to will_paginate, it’s available at http://github.com/dhennessy/will_paginate/tree/master for anyone who feels like trying it out.

Adding grouped links to an existing project

The grouped links plugin depends on you having a grouping attribute on the data you want to display. For the example above, this might be the first letter of the name; for a recipe application, it might be the primary ingredient. The point is that this has to exist in the database as a separate column. One easy way to maintain this is to add a before_save filter to your model that computes the grouping attribute:

before_save :update_group_letter

def update_group_letter
  self.first_letter = name[0,1]
end

In your controller, you create a list of results as follows:

@people = Person.paginate :page => params[:page], :group_by => 'first_letter',  :order => 'name ASC'
@people.add_missing_links(('A'..'Z').to_a)

Normally, the paginate method will add a grouped link for every distinct value of the group_by attribute. The add_missing_links method in this example will add additional links for letters that don’t already exist (which looks better in this case).

Finally, add the following to your view:

<%= will_paginate @people, :draw_if_single => true, :next_previous_links => false %>

The draw_if_single option forces the links to be displayed, even if the results all fit on a single page. Note that the resulting links will have #A, #B, etc appended to them so that you can jump to a particular row (providing you set the anchor when the first letter changes in your list). As you can see, this is very similar to the way you’re already using the will_paginate plugin.

Health Warning: this plugin should probably be treated as experimental as I may change things a bit as I get feedback from real users.

Adding rspec to a new rails project

2008-08-20T00:00:00+01:00

There aren’t as many quick guides to using rspec as there should be. So, to help anyone wanting a fast jumpstart, here’s how to add rspec to a new project:

$ ./script/plugin install git://github.com/dchelimsky/rspec.git
$ ./script/plugin install git://github.com/dchelimsky/rspec-rails.git
$ ./script/generate rspec

That’s all there is to it! You can run your rspec tests with this command:

$ rake spec

.. or, with code coverage output:

$ rake spec:rcov
$ open coverage/index.html

Now you’re ready to write some tests. To get started, take a look at the examples at http://rspec.info/documentation/rails/

Pay More, Save Less

2008-07-25T00:00:00+01:00

I saw this today on monster.ie. Notice anything unusual about the last two rows?

Handling Irish postcodes in web forms

2008-06-27T00:00:00+01:00

I saw the following in an Apple iTunes web form today.

Billing Address

The Postcode may be empty, or for Dublin, enter a one or two digit code, or a digit followed by a letter.

Why is this a big deal?

There is no official country-wide postcode system in Ireland. We have a small set of codes for areas of Dublin instead (apparently because of a dispute with the postal worker when the government tried to introduce them). Successive governments have done no better.

Anyway most web users in Ireland are conditioned to enter ‘00000’ or the like into zipcode fields when required. This form from Apple is the first web site I’ve every seen to actually get it right. Well done.

Programming competition time again

2008-05-08T00:00:00+01:00

The dates have just appeared for this years ICFP contest:

July 11, 2008 — July 14, 2008

The weekend is now blocked out in my calendar and family, friends and pets warned to expect no care and attention. I’m hoping to organise a bigger team this year (2-3 people from last year was too small) – I think 5-6 might be the optimum size.

Here are some past contests:

Unit testing Spring/Hibernate code using JMock

2008-02-27T00:00:00+00:00

Unit testing a simple Java class like, say, a four-function calculator is trivially easy using JUnit. However, things get a lot harder when you’re using complex support frameworks like Spring or Hibernate. Here are some guidelines for using JMock to help isolate the framework and focus on the code you’re testing.

Before you start, take a minute to consider whether it’s truly a unit test you’re looking for. The key question is whether your code is really independent from the environment, or if it depends on some clever capability of the framework or database. For example, suppose it generated some complex SQL and then used the results of that SQL; you should consider whether your tests might need to interact with a real database to be sure that your code is correct. If that’s the case, then you probably shouldn’t be using mocks.

Mocking objects in java is actually quite hard to do (much harder than Ruby or Smalltalk) but JMock helps a lot. JMock (http://www.jmock.org) has improved hugely in version 2 – it’s practically a rewrite from version 1. Also, I’m going to use JUnit 4 which allows us to use annotations.

Let’s assume we’ve just written Shipper class with a method that computes the weight of a shipment by adding the weights of the individual components and the weight of a standard shipping box. There’s a catalog service that can retrieve the weight of a component and a config service that stores the standard shipping box weight. Spring is used to wire together the services and Hibernate is used to persist the data. Here’s what our class might look like (the database locking is just to make it interesting):

package com.sample;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.LockMode;
import org.springframework.orm.hibernate3.SessionFactoryUtils;

public class Shipper {
    Config config;
    Catalog catalog;
    SessionFactory sessionFactory;

    public void setConfig(Config config) {
        this.config = config;
    }

    public void setCatalog(Catalog catalog) {
        this.catalog = catalog;
    }

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public void updateTotalWeight(Shipment shipment, String[] ids) {
        Session session = SessionFactoryUtils.getSession(sessionFactory, true);
        session.refresh(shipment, LockMode.UPGRADE_NOWAIT);

        int weight = config.getStandardShippingWeight();
        if (ids != null) {
            for (String id : ids) {
                weight += catalog.getWeight(id);
            }
        }

        shipment.setWeight(weight);
    }
}

Now let’s look at the test code for this class (I’ve deleted most comments from both files to make them easier to follow). Our objective in the test is to verify the ‘happy route’ through the method, as well as the edge cases with a null or empty list:

package com.sample;

import static org.junit.Assert.assertEquals;
import org.junit.runner.RunWith;
import org.junit.Before;
import org.junit.Test;
import org.jmock.integration.junit4.JMock;
import org.jmock.integration.junit4.JUnit4Mockery;
import org.jmock.Mockery;
import org.jmock.Expectations;
import org.jmock.lib.legacy.ClassImposteriser;
import org.hibernate.SessionFactory;
import org.hibernate.Session;

@RunWith(JMock.class)
public class ShipperTestCase {
    Mockery context;
    Shipper shipper;
    Catalog catalog;
    Config config;
    SessionFactory sessionFactory;
    Session session;

    @Before
    public void prepareMocks() {
        context = new JUnit4Mockery() {
            {
                // Enable mocks of concrete classes
                setImposteriser(ClassImposteriser.INSTANCE);
            }
        };
        catalog = context.mock(Catalog.class);
        config = context.mock(Config.class);
        sessionFactory = context.mock(SessionFactory.class);
        session = context.mock(Session.class);

        // Create our test object and wire up mock services to it

        shipper = new Shipper();
        shipper.setCatalog(catalog);
        shipper.setConfig(config);
        shipper.setSessionFactory(sessionFactory);
    }

    @Test
    public void emptyOrNullList() {
        Shipment shipment = new Shipment();

        // Set up the expected behaviour in the support services
        context.checking(new Expectations() {
            {
                allowing(sessionFactory).openSession(); will(returnValue(session));
                allowing(session).getSessionFactory(); will(returnValue(sessionFactory));
                ignoring(session);

                // Set required expectations for test to pass
                atLeast(1).of(config).getStandardShippingWeight(); will(returnValue(8));
            }

        });
        shipper.updateTotalWeight(shipment, null);
        assertEquals(8, shipment.getWeight());
        shipment.setWeight(0);
        shipper.updateTotalWeight(shipment, new String[0]);
        assertEquals(8, shipment.getWeight());
    }

    @Test
    public void sampleList() {
        Shipment shipment = new Shipment();

        // Set up the expected behaviour in the support services
        context.checking(new Expectations() {
            {
                allowing(sessionFactory).openSession(); will(returnValue(session));
                allowing(session).getSessionFactory(); will(returnValue(sessionFactory));
                ignoring(session);

                // Set required expectations for test to pass
                atLeast(1).of(config).getStandardShippingWeight(); will(returnValue(4));
                atLeast(1).of(catalog).getWeight("a"); will(returnValue(1));
                atLeast(1).of(catalog).getWeight("b"); will(returnValue(2));
                atLeast(1).of(catalog).getWeight("c"); will(returnValue(4));
            }

        });
        shipper.updateTotalWeight(shipment, new String[] { "a", "b", "c"});
        assertEquals(15, shipment.getWeight());
    }
}

Let’s look at a few interesting parts of the test code:

@RunWith(JMock.class)
public class ShipperTestCase {

This causes JUnit to use the runner from JMock, instead of its built-it one.

@Before
public void prepareMocks() {
    context = new JUnit4Mockery() {
        {
            setImposteriser(ClassImposteriser.INSTANCE);    // Enable mocks of concrete classes
        }
    };
    catalog = context.mock(Catalog.class);
    config = context.mock(Config.class);
    sessionFactory = context.mock(SessionFactory.class);
    session = context.mock(Session.class);

    // Create our test object and wire up mock services to it

    shipper = new Shipper();
    shipper.setCatalog(catalog);
    shipper.setConfig(config);
    shipper.setSessionFactory(sessionFactory);
}

This method runs before each of the test cases. It’s (hopefully) very straightforward – it creates mock objects for each of the external services that our class relies on, and then creates an object to test with those mocks wired to it.

        // Set up the expected behaviour in the support services
        context.checking(new Expectations() {
            {
                allowing(sessionFactory).openSession(); will(returnValue(session));
                allowing(session).getSessionFactory(); will(returnValue(sessionFactory));
                ignoring(session);

                // Set required expectations for test to pass
                atLeast(1).of(config).getStandardShippingWeight(); will(returnValue(4));
                atLeast(1).of(catalog).getWeight("a"); will(returnValue(1));
                atLeast(1).of(catalog).getWeight("b"); will(returnValue(2));
                atLeast(1).of(catalog).getWeight("c"); will(returnValue(4));
            }

        });

This block sets the behaviour we want from our mocks. Notice that we can specify different behaviour based on different parameters to a method. The ignoring(session) line indicates that all other methods of session should simply return a default value.

        shipper.updateTotalWeight(shipment, new String[] { "a", "b", "c"});
        assertEquals(15, shipment.getWeight());

Finally, we call our test object and verify the results.

When writing expectations, it’s worth making sure you only set constraints (like the atLeast(1) line) where a mock method MUST be called or you consider the test as failed. If you make the constraints too tight, then your tests can get brittle and can fail when you change the implementation, even if that change hasn’t broken the functionality. For example, if I’d used exactly(1) instead of atLeast(1), the test would still pass but would be less resilient to implementation changes.

Protecting email addresses on web pages

2008-02-23T00:00:00+00:00

I was adding my email address to http://peerassembly.com and used a little javascript snippit to hide the email address from simple (read: stupid) email harvester bots. It’s so short, it hardly warrants a post but maybe someone will find it the next time they’re putting a contact email address on a web page and save themselves a ton of spam!

If you don’t have it already, add prototype.js to your page:

  <script src="javascripts/prototype.js" type="text/javascript" charset="utf-8"></script>

At the place in your page where you put your email address, replace it with:

<span id="email">info</span>

Then, add this to your page:

  <script type="text/javascript">
  var a = "info" + "&#64;" + "peerassembly.com";
  $('email').update('<a href="mailto:'+a+'">'+a+'</a>');
  </script>

That’s it – when the javascript executes, it will insert the email link in your page.

Using capistrano for static sites

2008-02-14T00:00:00+00:00

I’ve been using capistrano for rails deployment for a while. I thought I’d see how useful it was for managing some static sites – it turned out to be really useful. Here’s how to do it:

First, create the project in subversion and check it out. I really like the idea of everything being in source control. My normal process for updating a site is:

check out site files
make changes
review locally
check them in
publish updated site

Capistrano helps with the last step – to publish your updated site, you simply use:

$ cap deploy:update

In this example, my subversion repository is at dev.work.com/svn the site is mysite.com and the server is located at bighost.com

$ svn mkdir http://dev.work.com/svn/mysite
$ svn co http://dev.work.com/svn/mysite
$ cd mysite
$ mkdir -p config public public/images public/stylesheets public/javascripts
$ capify .
[add] writing './Capfile'
[add] writing './config/deploy.rb'
[done] capified!

If you already have content for the site, copy it into the ./public directory tree. Otherwise, create the content in place.

Edit config/deploy.rb as follows

set :application, "mysite"
set :repository,  "http://dev.work.com/svn/mysite"
set :deploy_via, :copy

set :deploy_to, "/home/denis/#{application}"

role :app, "bighost.com"
role :web, "bighost.com"
role :db,  "bighost.com", :primary => true

Check all of these into subversion and create the server-side directories with:

$ svn add *
$ svn ci
$ cap deploy:setup

Note that in this example, the web site is served from /home/denis/mysite/current/public. Here’s the apache config file (to be installed in /etc/apache2/sites-available) to make that work:

<VirtualHost *>
  ServerAdmin denis@hennessynet.com
  ServerName mysite.com
  ServerAlias www. mysite.com
  DocumentRoot /home/denis/mysite/current/public
  <Directory /home/denis/mysite/current/public>
    Options Indexes FollowSymLinks MultiViews
    AllowOverride All
    Order allow,deny
    allow from all
  </Directory>

  ErrorLog /var/log/apache2/error. mysite.log
  CustomLog /var/log/apache2/access. mysite.log combined
</VirtualHost>

Wil Shipley on Adwords, Indie Mac development and more

2008-02-10T00:00:00+00:00

I just watched Wil Shipley’s presentation from C4[1] (video). The topic is generally about how to best use hype to promote your application (it was in front of an audience of Mac Indie developers). Besides being thoroughly enjoyable to watch, it contained quite a number of interesting tidbits on Google adwords, beta and upgrade policies, …

Recommended.

Installing MacPorts and MySQL on Leopard

2008-01-15T00:00:00+00:00

I recently had to re-install a development environment on a Mac Pro so I kept track of the steps as I went. Here’s the simplest way to get MacPorts and MySQL installed on Leopard.

Install XCode 3.0 from Leopard Install Disk 2 Download MacPorts installer from http://www.macports.org/install.php and run. Then, add the following to ~/.bash_profile (and then restart your Terminal):

export PATH=/opt/local/bin:/opt/local/sbin:$PATH
export MANPATH=/opt/local/share/man:$MANPATH
export ARCHFLAGS="-arch i386"
bind 'set completion-ignore-case on'

That last line is not strictly needed but I like to be able to tab through directory names without caring about the capitalisation. Finally run:

$ sudo port -v selfupdate

OK, that’s MacPorts out of the way, on to MySQL:

$ sudo port install mysql5 +server
$ sudo -u mysql mysql_install_db5
$ cd /opt/local
$ sudo /opt/local/lib/mysql5/bin/mysqld_safe

Add the following as /opt/local/etc/mysql5/my.cnf:

[mysqld_safe]
socket=/tmp/mysql.sock

Lastly, try it out (and set it to start on reboot) with:

$ sudo /opt/local/lib/mysql5/bin/mysqld_safe
$ sudo launchctl load -w /Library/LaunchDaemons/org.macports.mysql5.plist
$ sudo ln -s /tmp/mysql.sock /opt/local/var/run/mysql5/mysqld.sock

If I’ve missed anything, let me know.