本文将从单元测试这个话题开始，让Java的开发人员能够在实际工作中利用Ruby提高工作效率。
Martin Fowler：当然（愿意花掉一半的时间来写单元测试）！因为单元测试能够使你更快地完成工作。无数次的实践已经证明这一点。你的时间越是紧张，就越是要写单元测试，它看上去慢，但实际上能够帮助你更快、更舒服地达到目标。
单元测试很重要，但是……
单元测试的重要性，我想再多做一些强调也不为过。但实际情况是我经常听到Java开发人员抱怨单元测试繁琐、难写。虽然勉强为之，却疲于奔命，并没有体会到它的好处！最终造成的结果是出现了大量只能运行一次的单元测试。是将责任简单归结于开发人员？还是开发流程或制度的不完善？
平心而论，我自己在做TDD或单元测试的时候，有很多时候也确实觉得无趣，尤其是在一些准备测试数据或测试环境的工作上，例如我们经常需要随机生成特定长度的字符串用于测试，需要如下代码：
public String getRandomAlphabetic(int
count) {
count = count <= 0 ? 5 : count; //默认为5
//构建一个包含所有英文字母的字符串
String alphabet="abcdefghijklmnopqistuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
StringBuffer sb = new StringBuffer(count);
for (int i = 0; i < count; i++) {
int character=(int)(Math.random()*26);
sb.append(alphabet.substring(character, character+1));
}
return sb.toString();
} |
如果用Ruby的话：
def random_alphabetic(size=5)
chars = ('a'..'z').to_a + ('A'..'Z').to_a # 构建一个从a到Z的一个字母表数组
(0...size).collect { chars[rand(chars.length)] }.join
# 从chars数组中返回指定长度的随机字符数组（默认5个），调用join方法，将这个数组中的所有元素连接成一个字符串
end |
对比后大家感觉如何？有经验的开发人员马上会挑战说，我们有现成的commons-lang库，简单调用 RandomStringUtils.randomAlphabetic(5)就可以完成任务，可我想问的是，如果没有第三方库的支持，你更愿意用哪种方式？还可以想象构建一个树状结构的数据，Ruby的方式：
data =<<-EOF
{
"order_id": "xxx-xxxxx-xxx",
"books": [
{"ISBN": "2323-2323", "number":
2, "price": 20.00},
{"ISBN": "2323-2324", "number":
3, "price": 30.00},
{"ISBN": "2323-2325", "number":
2, "price": 20.00},
{"ISBN": "2323-2326", "number":
3, "price": 30.00},
{"ISBN": "2323-2327", "number":
2, "price": 20.00}
]
}
EOF
# 该数据为json格式的一段字符串
order = JSON.parse(data)
p order['books'][0]['ISBN']
#=> 2323-2323 |
用Java该怎样完成，很多人会祭出Java世界中最被滥用的七种武器之首“xml”，即便如此能完成的如此优雅吗？如果不是简单的“语言宗教崇拜”，至少我会毫不犹豫的选择用Ruby的方式完成任务。省点时间，早点下班陪陪老婆也好啊！:)
在Ruby的世界里
那作为一个Java的开发人员，如何享受到Ruby在测试方面给我们带来的好处呢？事实上Java早就为Ruby、Python等脚本语言做好了准备，JRuby是sun对Ruby
on JVM的官方支持，现在的版本是1.1.3，已经能够非常好的让Ruby运行在Java的世界里。
在开始之前，我想简单介绍一下跟本文相关的Ruby及JRuby的基本用法，具体参考Ruby Home。
# 这是一段注释
puts
'Hello, World !' #打印Hello, World!这个字符串，相当于Java中的System.out.println
('a'..'z') #声明一个a到z的range类型的数据，range表示一个连续的范围，当然也可以是一段连续的数字
('a'..'z').to_a #简单调用方法to_a将一个range类型的数据转换成一个数组
<<-EOF
...
EOF # Ruby通过配对EOF的方式声明一个多行的字符串
[1,2,3,4,5] #声明一个数组
[..].each {|it| puts it } #通过each方法遍历每个元素，其中{...}表示一个代码块，在这里的语义是在遍历每个元素时打印这个元素，其中it是隐式声明的参数，表示当前被遍历到的元素
对于数组可以用select, find, collect等方法遍历，用<<,
push, pop, delete等方法改变数组里的元素
h = {'id'=>'1', 'name'=>'foo',
'age'=>24} #简单声明一个Hash
h['name'] = 'bar' #对key为name的条目赋值
h['age'] #24
class Foo < Base #通过class关键字声明一个类，‘<
Base’表示从基类Base继承
@name
#声明一个实例变量
@@count
#声明一个类变量，相当于Java中static关键字修饰的变量
end |
在JRuby中可以直接使用所有的Ruby类和方法，也能够很轻松的调用Java的类库，实际上JRuby将Ruby代码动态编译成JVM的字节码，具体参考JRuby：
require 'java'
#引入对Java的支持
import 'java.util.ArrayList'
#导入需要的某个包
list = ArrayList.new
#创建一个ArrayList
[1,2,3,4,5].to_java
#将Ruby类型转成对应的Java类型 |
从上面简短的例子和基本介绍，我们能发现什么？Ruby对数组，字符串等基本类型提供了强大的支持，而这些恰恰是Java缺乏的，我们没有办法简单的创建一个数组，不能用简单的方式遍历这些集合，甚至都不能简单声明一个多行的字符串。而这些在进行测试工作，准备测试数据的时候都是必不可少的！利用Ruby
的这些特性，我们可以极大的增加开发的效率，摆脱相当多繁琐的工作。当然，这些只是Ruby为我们提供的诸多好处中最直观的部分，随着我们的讨论深入，我们将看到越来越多有意思的特性。
准备工作
用Ruby进行测试，我们需要JtestR这个专门为简化Java测试而准备的Ruby测试工具，当前的最新版本是0.3.1。如果你使用maven，在pom.xml中加入：
| <plugins>
...
<plugin>
<groupId>org.jtestr</groupId>
<artifactId>jtestr</artifactId>
<version>0.3.1</version>
<configuration>
<!-- Ruby测试文件所在目录 -->
<tests>src/test/ruby</tests>
</configuration>
<executions>
<execution>
<goals>
<goal>test</goal>
</goals>
</execution>
</executions>
</plugin>
...
</plugins> |
使用ant的开发人员请参考这里。用Ruby做单元测试和Java一样，简单从Test::Unit::TestCase继承即可：
class MyFirstJRubyTests <
Test::Unit::TestCase
def test_true
assert true
end
end |
可以将这个测试文件简单拷贝到myProj/src/test/ruby目录下，运行mvn test，你会看到JtestR产生的测试结果输出：
| [INFO] [jtestr:test {execution:
default}]
Other TestUnit: 1 tests, 0
failures, 0 errors |
在这段输出报告之上，你应该还能看到正常的Java unit testcase输出的测试结果，这表明，我们可以在开发的过程中同时选择用Java的方式测试，或用Ruby的方式测试！
JRuby测试之旅
好了，一切准备好之后，就可以开始我们的Ruby测试之旅了！你一定不希望自己苦心经营的blog或论坛上出现某些“不和谐”的词，尤其是在这举国欢庆的特殊阶段。你设计了一个专门用于过滤带有这些关键服务接口：
public interface KeywordFilterService
{
//过滤访客评论字符串数组，返回一个新的不包含敏感关键字的结果
String[] filter(String[] comments);
//获取被过滤的访客评论
String[] getFiltedComments();
} |
并写了一个很简单的实现类class KeywordFilterServiceImpl implements
KeywordFilterService，这个类的实现我们就暂不关心，把重点聚集在如何对这个实现类进行测试上。首先在myProj/src/test/ruby目录下新建test_keyword_filter_service.rb文件，键入以下内容：
| require 'test/unit'
class KeywordFilterServiceTest
< Test::Unit::TestCase
def
setup
@keywords = %w{X XX XXX XXXX XXXXX XXXXXX XXXXXXX}
#不用加引号，更方便
end
def
test_filter
end
end |
setup方法准备了我们要测试的关键字数据，在Ruby中%w{...}用来简单定义字符串数组。test_xxx方法就是我们的测试方法。有了关键字数据后我们还需要一组用来测试的测试数据，里面一部分包含我们的关键字。我决定用上面定义的随机生成字符串的方式产生这些测试数据：
def
random_alphabetic(size=5)
chars = ('a'..'z').to_a + ('A'..'Z').to_a
(0...size).collect { chars[rand(chars.length)] }.join
end
def random_comments
comments ||= []
10.times do
keyword = rand(10) % 3 == 0 ? ' ' : @keywords[rand(@keywords.length)]
#随机决定是否包含关键字
comment = random_alphabetic + keyword + random_alphabetic
comments << comment
end
return comments
end |
这样，每次产生10条数据，有近三分之一的数据中包含不和谐的关键字。有了测试数据剩下的工作就很简单了，我们只需调用写好的Java服务，对返回的测试数据进行验证即可，由于需要调用Java服务，和Java一样，我们首先要引入类：
| import 'com.alisoft.research.JRuby.service.KeywordFilterServiceImpl' |
测试方法实现如下：
def
test_filter
comments = random_comments
service = KeywordFilterServiceImpl.new(@keywords.to_java
:String)
filted = service.filter(comments.to_java :String)
forbiddens = service.getFiltedComments
assert forbiddens.length == comments.length -
filted.length
assert_equal forbiddens.sort, (comments - filted).sort
end |
其中，有两点需要注意，首先，我们可以通过to_java方法将Ruby类型转换成Java类型，例如上面将@keywords.to_java
:String表明将Ruby数组转换成Java的String数组。第二，Ruby对数组支持“-”的操作，表示将一个数组减去和另一个数组中相同的元素，非常的直观！很明显，被过滤的数组应该等于原来的数组减去过滤后的结果！运行mvn
test，我们将看到：
| [INFO] [jtestr:test {execution:
default}]
Other TestUnit: 2 tests, 0
failures, 0 errors |
结论
说明新增加的测试通过！最后我们来对比一下实现同样的功能Ruby和Java的差别：
Ruby:
require 'test/unit'
import 'com.alisoft.research.JRuby.service.KeywordFilterServiceImpl'
class KeywordFilterServiceTest
< Test::Unit::TestCase
def
setup
@keywords = %w{X XX XXX XXXX XXXXX XXXXXX XXXXXXX}
end
def
test_filter
comments = random_comments
service = KeywordFilterServiceImpl.new(@keywords.to_java
:String)
filted = service.filter(comments.to_java :String)
forbiddens = service.getFiltedComments
assert forbiddens.length == comments.length -
filted.length
assert_equal forbiddens.sort, (comments - filted).sort
end
def
random_alphabetic(size=5)
chars = ('a'..'z').to_a + ('A'..'Z').to_a
(0...size).collect { chars[rand(chars.length)]
}.join
end
def
random_comments
comments ||= []
10.times do
keyword = rand(10) % 3 == 0 ? ' ' : @keywords[rand(@keywords.length)]
comment = random_alphabetic + keyword + random_alphabetic
comments << comment
end
return comments
end
end
Java:
package com.alisoft.research.JRuby.test;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import Java.util.ArrayList;
import Java.util.Arrays;
import Java.util.List;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang.math.RandomUtils;
import org.junit.Test;
import com.alisoft.research.JRuby.service.KeywordFilterServiceImpl;
public class KeywordFilterServiceTest
{
@Test
public
void testFilteredResults() {
String[] comments = getRandomComments();
KeywordFilterServiceImpl service = new KeywordFilterServiceImpl(
getKeywords());
String[] filted = service.filter(comments);
String[] forbiddens = service.getFiltedComments();
assertEquals(filted.length + forbiddens.length,
comments.length);
assertArrayEquals(forbiddens, sub(comments, filted));
}
//实现减法操作
private
String[] sub(String[] all, String[] part) {
List allList = new ArrayList(Arrays.asList(all));
allList.removeAll(Arrays.asList(part));
return allList.toArray(new String[allList.size()]);
}
private
String[] getRandomComments() {
String[] comments = new String[RandomUtils.nextInt(10)];
for (int i = 0; i < comments.length; i++) {
String comment = RandomStringUtils.randomAlphabetic(5);
String keyword = RandomUtils.nextBoolean() ? getKeywords()[RandomUtils
.nextInt(getKeywords().length)]
: "";
comment += keyword + RandomStringUtils.randomAlphabetic(5);
comments[i] = comment;
}
return comments;
}
private
String[] getKeywords() {
String[] keywords = new String[] { "X",
"XX", "XXX", "XXXX",
"XXXXX", "XXXXXX", "XXXXXXX"
};
return keywords;
}
} |
在借助了apache-commons-lang之后，LOC: Java 58, Ruby 35。大家也可以注意一下Java中实现两个数组“减法”的代码对比Ruby的实现，Ruby明显更为直观，更有效率！
|
