Nordic Ruby 2011

bitcoin
==
con-currency?

Saturday, June 18, 2011

José! Me!


WWFMD?

Public Service
Announcements


SIGSEGV is bad


neversaydie


begin
# something dangerous
rescue NeverSayDie
# fix memory
end


"Not working in
production mode"


DO NOT USE THIS
SOFTWARE


ruby -w


def hello
x = Object.new # warning
10 + 10
end


warning: assigned but unused variable - x


How deprecation
notices SHOULD be
written


class Foo
def deprecated
if $VERBOSE
warn "hey bro, don't call this"
end
10
end
end


RSpec Problem


warning: useless use of == in void context


it "passes" do
10.should == 10
11.should == 11
end


def check(thing)
end

def deprecated
check 10.should == 10
check 11.should == 10
end


@tenderlove


AT&T, AT&T logo and all AT&T related marks are trademarks of AT&T Intellectual Property and/or AT&T affiliated companies.

Ruby Core Team


Rails Core Team


White Guy


Story about
Geethika and
pinochle, java, etc


Story about
Geethika and
pinochle, java, etc

It's TYRA!

<3 <3 <3


"Congratulations, you just
made us not consider Rails
for anything anymore despite
our coders liking it."


SWEDEN!


MEATBALLS!

SWEDISH FISH!

Made in Canada!

How do you catch
such tiny ﬁsh?


Will you share your
Swedish Fish
Fishing spot?


Talk about
Rails,
Talk about
work projects

Mountain Dew
and my
Trail of Tears


Legacy Code


What is
Legacy Code?


Untested


Old


Maintainers
are gone

Not Understood


Importance of
Legacy Code


Old code contains
Knowledge


Solves Today's
Problems


All Legacy Code is
Not Equal


Tenderlove
Tear Formula


Code Burden
Tears

Time


Tears cried at time T


Volume at time T


Last Week


I LOVE hacking
old code


Techniques


Techniques

Universal

Testing

Extending


Universal


Liskov substitution
principle


A subclass can be
used in place of it's
superclass


Object

Animal

Person


class Animal
end

class Person < Animal
end


def leg_count(animal)
animal.legs
end

def account_number(person)
person.account_number
end


Single Responsibility
Principal


Each class has one
and only one
responsibility


Each class has one
reason to change


Method Extraction


class WebClient
def get(url)
url = URI.parse url
Net::HTTP.get(url.host, url.path)
end
end


class WebClient
def get(url)
url = URI.parse url
http_get
end

private
def http_get
end
end


I don't like it, but
it helps us to
class WebClient reason
def get(url)
url = URI.parse url
http_get(url.host, url.path)
end

private
def http_get(host, path)
Net::HTTP.get(host, path)
end
end


Object#extend


class Foo
def metaclass
class << self; self; end
end
end

x = Foo.new
p x.metaclass.ancestors

x.extend(Module.new { })
p x.metaclass.ancestors


[Foo, Object, Kernel, BasicObject]

[#<Module:0x81c98>, Foo, Object, Kernel, BasicObject]


Code Seams


Testing


Load Path Hacking


$LOAD_PATH


ruby -Ifoo script.rb


require 'net/http'

class WebClient
def get(url)
url = URI.parse url
end
end


[aaron@higgins project (master)]$ find .
.
./test
./test/lib
./test/lib/net
./test/lib/net/http.rb
./web.rb


test/lib/net/http.rb

module Net
class HTTP
def self.get(host, path)
"hello world"
end
end
end


ruby -I test/lib web.rb


require 'web'
require 'minitest/autorun'

class WebTest < MiniTest::Unit::TestCase
def test_get
client = WebClient.new
response = client.get 'http://www.reddit.com/r/ruby'
assert_equal 'hello world', response
end
end


RSpec and
People don't know about -I test/unit will
set your -I for
you

require File.expand_path(
File.join('..', 'foo'))


Heavy Handed


Good for Small APIs


Constant Hacking


class MyHTTP
def self.get(host, path)
"hello world"
end
end

WebClient.const_set(:Net, Module.new)
WebClient::Net.const_set(:HTTP, MyHTTP)


def setup
WebClient.const_set(:Net, Module.new)
WebClient::Net.const_set(:HTTP, MyHTTP)
end

def teardown
WebClient.send(:remove_const, :Net)
end

def test_get
end
end


class WebClient
def get(url)
url = URI.parse url
::Net::HTTP.get(url.host, url.path)
end
end


Localized
Still must changes to
mock one class
entire API

Heavy Handed


Subclass Testing


require 'net/http'

class WebClient
def get(url)
url = URI.parse url
end

private
end
end


Class.new


def test_get
client = Class.new(WebClient) {
'hello world'
end
}.new

end
end


Annoying
Constructors


Many
parameters,
class Column
def initialize(name, default, sql_type = nil,don't care=about
null true)
some of them
@name = name
@sql_type = sql_type
@null = null
@limit = extract_limit(sql_type)
@precision = extract_precision(sql_type)
@scale = extract_scale(sql_type)
@type = simplified_type(sql_type)
@default = extract_default(default)
@primary = nil
@coder = nil
end
....
end


Just Pass nil


def test_type_cast_true
c = Column.new(nil, 1, 'int')

assert_equal 't', @conn.type_cast(true, nil)
assert_equal 1, @conn.type_cast(true, c)
end


Can't construct,
but want to
break
dependencies

Not Constructible


Too hard to
construct

pool = ActiveRecord::Base.connection_pool


pool = ActiveRecord::Base.connection_pool.dup

pool.extend(Module.new {
def checkin conn
@checkins << conn
conn.object_id
end
})


Detecting Changes


Measure http_get
class WebClient
def get(url)
url = URI.parse url
end

private
end
end

via Class.new


def test_http_get_count
call_count = 0
define_method(:http_get) { |host, path|
call_count += 1
"hello world"
}
}.new

assert_equal 0, call_count
client.get 'http://www.reddit.com/r/ruby'
end


Decide to call
def test_http_get_count super or not
call_count = 0
call_count += 1
"hello world"
}
}.new

end


via Module.new


def test_http_get_count

call_count = 0
client.extend(Module.new {
call_count += 1
"hello world"
}
})

end


Extending


Huge Methods!


def table_rows
rows[table_name] = fixtures.map do |label, fixture|
if model_class && model_class < ActiveRecord::Base
reflection_class.reflect_on_all_associations.each do |association|
case association.macro
when :belongs_to
# Do not replace association name with association foreign key if they are named the
same
fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s

if association.name.to_s != fk_name && value = row.delete(association.name.to_s)
if association.options[:polymorphic] && value.sub!(/s*(([^)]*))s*$/, "")
# support polymorphic belongs_to as "label (Type)"
row[association.foreign_type] = $1
end

row[fk_name] = ActiveRecord::Fixtures.identify(value)
end
when :has_and_belongs_to_many
if (targets = row.delete(association.name.to_s))
targets = targets.is_a?(Array) ? targets : targets.split(/s*,s*/)
table_name = association.options[:join_table]
rows[table_name].concat targets.map { |target|
{ association.foreign_key => row[primary_key_name],
association.association_foreign_key => ActiveRecord::Fixtures.identify
(target) }
}
end
end
end
end
row
end
rows
end


Extract Methods


def belongs_to_row(association, row)
# Do not replace association name with association foreign key if
they are named the same
fk_name = (association.options[:foreign_key] || "#
{association.name}_id").to_s

if association.name.to_s != fk_name && value = row.delete
(association.name.to_s)
if association.options[:polymorphic] && value.sub!(/s*(([^)]
*))s*$/, "")
# support polymorphic belongs_to as "label (Type)"
row[association.foreign_type] = $1
end

row[fk_name] = ActiveRecord::Fixtures.identify(value)
end


def habtm_row(association, row)
if (targets = row.delete(association.name.to_s))
targets = targets.is_a?(Array) ? targets : targets.split(/s*,
s*/)
table_name = association.options[:join_table]
rows[table_name].concat targets.map { |target|
{ association.foreign_key => row
[primary_key_name],
association.association_foreign_key =>
ActiveRecord::Fixtures.identify(target) }
}
end
end


def table_rows
rows[table_name] = fixtures.map do |label, fixture|
row = fixture.to_hash


# If STI is used, find the correct subclass for association reflection
reflection_class =
if row.include?(inheritance_column_name)
row[inheritance_column_name].constantize rescue model_class
else
model_class
end

when :belongs_to
belongs_to_row(association, row)
habtm_row(association, row)
end
end
end

row
end
rows
end


Extract Object


class RowFilter
def rows
fixtures.map do |label, fixture|
row = fixture.to_hash
# If STI is used, find the correct subclass for association reflection
reflection_class =
if row.include?(inheritance_column_name)
row[inheritance_column_name].constantize rescue model_class
else
model_class
end

when :belongs_to
belongs_to_row(association, row)
habtm_row(association, row)
end
end
end
row
end
end
end


class RowFilter
attr_reader :fixtures, :model_class

def initialize(fixtures, model_class)
@fixtures = fixtures
@model_class = model_class
end
end


def table_rows
filter = RowFilter.new(fixtures, model_class)
rows[table_name] = filter.rows
rows
end


Huge Classes!


Look at Method
Names


Look at shared
instance variables


Group Similar
Methods


Use SRP to create a
new class


Then Delegate.


All API calls


Once we had
extracted the HTTP
class WebClient methods to their
own functions, could
def get(url) reason about HTTP
url = URI.parse url api.
end

private
end
end


class WebClient
def initialize(client = Net::HTTP)
@client = client
end

def get(url)
url = URI.parse url
end

private
@client.get(host, path)
end
end


class TestHTTP < Struct.new(:data)
def get(host, path)
data[[host, path]]
end
end


class WebTest < Test::Unit::TestCase
def test_get_home
mockhttp = TestHTTP.new({
['localhost', '/~aaron/'] => 'hello'
})
wc = WebClient.new mockhttp
assert_equal 'hello',
wc.get('http://localhost/~aaron/')
end
end


We deﬁne
expectations


Not Bound to HTTP


Legacy code can
make you cry


But it doesn't have to


Don't be afraid!


Ruby is your
mocking framework


Credits & More Info


Open Questions?


Do you like
mocking / stubbing?


How do these testing
tools impact your API?


Do you like hearts?


How about kittens?


Nordic Ruby 2011

Recommandé

Recommandé

Contenu connexe

Similaire à Nordic Ruby 2011

Similaire à Nordic Ruby 2011 (14)

Dernier

Dernier (20)

Nordic Ruby 2011