rubyslim 0.1.1

data/lib/test_module/test_slim_with_arguments.rb

@@ -0,0 +1,23 @@
+module TestModule
+  class TestSlimWithArguments
+    def initialize(arg)
+      @arg = arg
+    end
+
+    def arg
+      @arg
+    end
+
+    def name
+      @arg[:name]
+    end
+
+    def addr
+      @arg[:addr]
+    end
+
+    def set_arg(hash)
+      @arg = hash
+    end
+  end
+end

data/lib/test_module/test_slim_with_no_sut.rb

@@ -0,0 +1,5 @@
+module TestModule
+  class TestSlimWithNoSut
+
+  end
+end

data/rubyslim.gemspec

@@ -0,0 +1,21 @@
+
+Gem::Specification.new do |s|
+  s.name = "rubyslim"
+  s.version = "0.1.1"
+  s.summary = "Ruby SliM protocol for FitNesse"
+  s.description = <<-EOS
+    RubySliM implements the SliM protocol for the FitNesse
+    acceptance testing framework.
+  EOS
+  s.authors = ["Robert C. Martin", "Doug Bradbury"]
+  s.email = "unclebob@cleancoder.com"
+  s.platform = Gem::Platform::RUBY
+
+  s.add_development_dependency 'rspec', '~> 1.3.0'
+
+  s.files = `git ls-files`.split("\n")
+  s.require_path = 'lib'
+
+  s.executables = ['rubyslim']
+end
+

data/spec/instance_creation_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require "statement_executor"
+
+describe StatementExecutor do
+  before do
+    @caller = StatementExecutor.new
+  end
+
+  it "can create an instance" do
+    response = @caller.create("x", "TestModule::TestSlim", [])
+    response.should == "OK"
+    x = @caller.instance("x")
+    x.class.name.should == "TestModule::TestSlim"
+  end
+
+  it "can create an instance with arguments" do
+    response = @caller.create("x", "TestModule::TestSlimWithArguments", ["3"])
+    response.should == "OK"
+    x = @caller.instance("x")
+    x.arg.should == "3"
+  end
+
+  it "can create an instance with arguments that are symbols" do
+    @caller.set_symbol("X", "3")
+    response = @caller.create("x", "TestModule::TestSlimWithArguments", ["$X"])
+    response.should == "OK"
+    x = @caller.instance("x")
+    x.arg.should == "3"
+  end
+
+  it "can't create an instance with the wrong number of arguments" do
+    result = @caller.create("x", "TestModule::TestSlim", ["1", "noSuchArgument"])
+    result.should include(Statement::EXCEPTION_TAG + "message:<<COULD_NOT_INVOKE_CONSTRUCTOR TestModule::TestSlim[2]>>")
+  end
+
+  it "can't create an instance if there is no class" do
+    result = @caller.create("x", "TestModule::NoSuchClass", [])
+    result.should include(Statement::EXCEPTION_TAG + "message:<<COULD_NOT_INVOKE_CONSTRUCTOR TestModule::NoSuchClass failed to find in []>>")
+  end
+end

data/spec/it8f_spec.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe "characters" do
+  it "should be able to deal with it8f chars" do
+    "Köln".should == "Köln"
+    "Köln".size.should == 4
+  end
+end

data/spec/list_deserializer_spec.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require "list_serializer"
+require "list_deserializer"
+
+describe ListDeserializer do
+  before do
+    @list = []
+  end
+
+  it "can't deserialize a null string" do
+    proc {ListDeserializer.deserialize(nil)}.should raise_error(ListDeserializer::SyntaxError)
+  end
+
+  it "can't deserialize empty string" do
+    proc {ListDeserializer.deserialize("")}.should raise_error(ListDeserializer::SyntaxError)
+  end
+
+  it "can't deserialize string that doesn't start with an open bracket" do
+    proc {ListDeserializer.deserialize("hello")}.should raise_error(ListDeserializer::SyntaxError)
+  end
+
+  it "can't deserialize string that doesn't end with a bracket" do
+    proc {ListDeserializer.deserialize("[000000:")}.should raise_error(ListDeserializer::SyntaxError)
+  end
+
+  def check()
+    serialized = ListSerializer.serialize(@list)
+    deserialized = ListDeserializer.deserialize(serialized)
+    deserialized.should == @list
+  end
+
+  it "can deserialize and empty list" do
+    check
+  end
+
+  it "can deserialize a list with one element" do
+    @list = ["hello"]
+    check
+  end
+
+  it "can deserialize a list with two elements" do
+    @list = ["hello", "bob"]
+    check
+  end
+
+  it "can deserialize sublists" do
+    @list = ["hello", ["bob", "micah"], "today"]
+    check
+  end
+
+  it "can deserialize lists with multibyte strings" do
+    @list = ["Köln"]
+    check
+  end
+
+  it "can deserialize lists of strings that end with multibyte chars" do
+    @list = ["Kö"]
+    check
+  end
+
+  it "can deserialize lists with utf8" do
+    @list = ["123456789012345", "Espa\357\277\275ol"]
+    check
+  end
+
+end

data/spec/list_executor_spec.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require "statement_executor"
+require "list_executor"
+
+describe ListExecutor do
+  before do
+    @executor = ListExecutor.new
+    @statements = []
+    @table = "<table><tr><td>name</td><td>bob</td></tr><tr><td>addr</td><td>here</td></tr></table>"
+    add_statement "i1", "import", "TestModule"
+    add_statement "m1", "make", "test_slim", "TestSlim"
+  end
+
+  def get_result(id, result_list)
+    pairs_to_map(result_list)[id]
+  end
+
+  def pairs_to_map(pairs)
+    map = {}
+    pairs.each {|pair| map[pair[0]] = pair[1]}
+    map
+  end
+
+  def add_statement(*args)
+    @statements << args
+  end
+
+  def check_results expectations
+    results = @executor.execute(@statements)
+    expectations.each_pair {|id, expected|
+      get_result(id, results).should == expected
+    }
+  end
+
+  it "can respond with OK to import" do
+    check_results "i1"=>"OK"
+  end
+
+  it "can't execute an invalid operation" do
+    add_statement "inv1", "invalidOperation"
+    results = @executor.execute(@statements)
+    get_result("inv1", results).should include(Statement::EXCEPTION_TAG+"message:<<INVALID_STATEMENT: [\"inv1\", \"invalidOperation\"].")
+  end
+
+  it "can't execute a malformed instruction" do
+    add_statement "id", "call", "notEnoughArguments"
+    message = "message:<<MALFORMED_INSTRUCTION [\"id\", \"call\", \"notEnoughArguments\"].>>"
+    results = @executor.execute(@statements)
+    get_result("id", results).should include(Statement::EXCEPTION_TAG+message)
+  end
+
+  it "can't call a method on an instance that doesn't exist" do
+    add_statement "id", "call", "no_such_instance", "no_such_method"
+    results = @executor.execute(@statements)
+    get_result("id", results).should include(Statement::EXCEPTION_TAG+"message:<<NO_INSTANCE no_such_instance>>")
+  end
+
+  it "should respond to an empty set of instructions with an empty set of results" do
+    @executor.execute([]).length.should == 0
+  end
+
+  it "can make an instance given a fully qualified name in dot format" do
+    @executor.execute([["m1", "make", "instance", "testModule.TestSlim"]]).should == [["m1", "OK"]]
+  end
+
+  it "can call a simple method in ruby form" do
+    add_statement "id", "call", "test_slim", "return_string"
+
+    check_results "m1" => "OK", "id"=>"string"
+  end
+
+  it "can call a simple method in ruby form" do
+    add_statement "id", "call", "test_slim", "utf8"
+
+    check_results "m1" => "OK", "id"=>"Espa\357\277\275ol"
+  end
+
+
+  it "can call a simple method in FitNesse form" do
+    add_statement "id", "call", "test_slim", "returnString"
+
+    check_results "m1"=>"OK", "id"=>"string"
+  end
+
+  it "will allow later imports to take precendence over early imports" do
+    @statements.insert(0, ["i2", "import", "TestModule.ShouldNotFindTestSlimInHere"])
+    add_statement "id", "call", "test_slim", "return_string"
+    check_results "m1"=>"OK", "id"=>"string"
+  end
+
+  it "can pass arguments to constructor" do
+    add_statement "m2", "make", "test_slim_2", "TestSlimWithArguments", "3"
+    add_statement "c1", "call", "test_slim_2", "arg"
+
+    check_results "m2"=>"OK", "c1"=>"3"
+  end
+
+  it "can pass tables to constructor" do
+    add_statement "m2", "make", "test_slim_2", "TestSlimWithArguments", @table
+    add_statement "c1", "call", "test_slim_2", "name"
+    add_statement "c2", "call", "test_slim_2", "addr"
+
+    check_results "m2"=>"OK", "c1"=>"bob", "c2"=>"here"
+  end
+
+  it "can pass tables to functions" do
+    add_statement "m2", "make", "test_slim_2", "TestSlimWithArguments", "nil"    
+    add_statement "c0", "call", "test_slim_2", "set_arg", @table
+    add_statement "c1", "call", "test_slim_2", "name"
+    add_statement "c2", "call", "test_slim_2", "addr"
+
+    check_results "m2"=>"OK", "c1"=>"bob", "c2"=>"here"
+  end
+
+  it "can call a function more than once" do
+    add_statement "c1", "call", "test_slim", "add", "x", "y"
+    add_statement "c2", "call", "test_slim", "add", "a", "b"
+
+    check_results "c1" => "xy", "c2" => "ab"
+  end
+
+  it "can assign the return value to a symbol" do
+    add_statement "id1", "callAndAssign", "v", "test_slim", "add", "x", "y"
+    add_statement "id2", "call", "test_slim", "echo", "$v"
+    check_results "id1" => "xy", "id2" => "xy"
+  end
+
+  it "can replace multiple symbols in a single argument" do
+    add_statement "id1", "callAndAssign", "v1", "test_slim", "echo", "Bob"
+    add_statement "id2", "callAndAssign", "v2", "test_slim", "echo", "Martin"
+    add_statement "id3", "call", "test_slim", "echo", "name: $v1 $v2"
+    check_results "id3" => "name: Bob Martin"
+  end
+
+  it "should ignore '$' if what follows is not a symbol" do
+    add_statement "id3", "call", "test_slim", "echo", "$v1"
+    check_results "id3" => "$v1"
+  end
+
+  it "can pass and return a list" do
+    l = ["1", "2"]
+    add_statement "id", "call", "test_slim", "echo", l
+    check_results "id"=> l
+  end
+
+  it "can pass a symbol in a list" do
+    add_statement "id1", "callAndAssign", "v", "test_slim", "echo", "x"
+    add_statement "id2", "call", "test_slim", "echo", ["$v"]
+    check_results "id2" => ["x"]
+  end
+
+  it "can return null" do
+    add_statement "id", "call", "test_slim", "null"
+    check_results "id" => nil
+  end
+
+  it "can survive executing a syntax error" do
+    add_statement "id", "call", "test_slim", "syntax_error"
+    results = @executor.execute(@statements)
+    get_result("id", results).should include(Statement::EXCEPTION_TAG)
+  end
+
+  it "can make a fixture from the name in a symbol" do
+    add_statement "id1", "callAndAssign", "test_system", "test_slim", "echo", "TestChain"
+    add_statement "id2", "make", "fixture_instance1", "$test_system"
+    check_results "id2"=>"OK"
+  end
+
+  it "can make a fixture from a concatonated symbol" do
+    add_statement "id1", "callAndAssign", "test_system", "test_slim", "echo", "Chain"
+    add_statement "id2", "make", "fixture_instance1", "Test$test_system"
+    check_results "id2"=>"OK"
+  end
+
+  it "can use a fixture method that returns a fixture object" do
+    add_statement "id1", "callAndAssign", "object", "test_slim", "echo_object", "let_me_see", "Boogaloo"
+    add_statement "id2", "call", "test_slim", "call_on", "let_me_see", "$object"
+    check_results "id2" => "Boogaloo"
+  end
+
+  it "can use an instance that was stored as a symbol" do
+    add_statement "id1", "callAndAssign", "test_slim_instance", "test_slim", "create_test_slim_with_string", "Boogaloo"
+    add_statement "m2", "make", "test_slim", "$test_slim_instance"
+    check_results "m2" => "OK"
+  end
+
+end

data/spec/list_serialzer_spec.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require "list_serializer"
+
+describe ListSerializer do
+  it "can serialize and empty list" do
+    ListSerializer.serialize([]).should == "[000000:]"
+  end
+
+  it "can serialize a one item list" do
+    ListSerializer.serialize(["hello"]).should == "[000001:000005:hello:]"
+  end
+
+  it "can serialize a two item list" do
+    ListSerializer.serialize(["hello", "world"]).should == "[000002:000005:hello:000005:world:]"
+  end
+
+  it "can serialize a nested list" do
+    ListSerializer.serialize([["element"]]).should == "[000001:000024:[000001:000007:element:]:]"
+  end
+
+  it "can serialize a list with a non-string" do
+    ListSerializer.serialize([1]).should == "[000001:000001:1:]"
+  end
+
+  it "can serialize a null element" do
+    ListSerializer.serialize([nil]).should == "[000001:000004:null:]"
+  end
+  
+  it "can serialize a string with multibyte chars" do
+    ListSerializer.serialize(["Köln"]).should == "[000001:000004:Köln:]"
+  end
+
+  it "can serialize a string with UTF8" do
+    ListSerializer.serialize(["Español"]).should == "[000001:000007:Espa\xc3\xb1ol:]"
+  end
+  
+  
+end

data/spec/method_invocation_spec.rb

@@ -0,0 +1,128 @@
+# coding: utf-8
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require "statement_executor"
+
+describe StatementExecutor do
+  before do
+    @executor = StatementExecutor.new
+  end
+  context "Simple Method Invocations" do
+    before do
+      @executor.create("test_slim", "TestModule::TestSlim", [])
+      @test_slim = @executor.instance("test_slim")
+    end
+
+    it "can call a method with no arguments" do
+      @test_slim.should_receive(:no_args).with()
+      @executor.call("test_slim", "no_args")
+    end
+
+    it "can't call a method that doesn't exist" do
+      result = @executor.call("test_slim", "no_such_method")
+      result.should include(Statement::EXCEPTION_TAG + "message:<<NO_METHOD_IN_CLASS no_such_method[0] TestModule::TestSlim.>>")
+    end
+
+    it "can call a method that returns a value" do
+      @test_slim.should_receive(:return_value).and_return("arg")
+      @executor.call("test_slim", "return_value").should == "arg"
+    end
+
+    it "can call a method that returns a value" do
+      @test_slim.should_receive(:return_value).and_return("Español")
+      val = @executor.call("test_slim", "return_value")
+      val.should == "Español"
+      val.length.should == 7
+    end
+
+
+    it "can call a method that takes an argument" do
+      @test_slim.should_receive(:one_arg).with("arg")
+      @executor.call("test_slim", "one_arg", "arg")
+    end
+
+    it "can't call a method on an instance that doesn't exist" do
+      result = @executor.call("no_such_instance", "no_such_method")
+      result.should include(Statement::EXCEPTION_TAG + "message:<<NO_INSTANCE no_such_instance>>")
+    end
+
+    it "can replace symbol expressions with their values" do
+      @executor.set_symbol("v", "bob")
+      @executor.call("test_slim", "echo", "hi $v.").should == "hi bob."
+    end
+
+    it "can call a method on the @sut" do
+      @test_slim.sut.should_receive(:sut_method).with()
+      @executor.call("test_slim", "sut_method")
+    end
+
+    it "should call attributes on sut" do
+      @executor.call("test_slim", "set_attribute", "a")
+      @executor.call("test_slim", "attribute").should == "a"
+    end
+  end
+
+  context "Method invocations using fixture with no sut" do
+    before do
+      @executor.create("test_slim", "TestModule::TestSlimWithNoSut", []);
+      @test_slim = @executor.instance("test_slim")
+    end
+
+    it "can't call method that doesn't exist if no 'sut' exists" do
+      result = @executor.call("test_slim", "no_such_method")
+      result.should include(Statement::EXCEPTION_TAG + "message:<<NO_METHOD_IN_CLASS no_such_method[0] TestModule::TestSlimWithNoSut.>>")
+    end
+  end
+
+  context "Method invocations when library instances have been created." do
+    before do
+      @executor.create("library_old", "TestModule::LibraryOld", [])
+      @executor.create("library_new", "TestModule::LibraryNew", [])
+      @library_old = @executor.instance("library_old")
+      @library_new = @executor.instance("library_new")
+      @executor.create("test_slim", "TestModule::TestSlim", [])
+      @test_slim = @executor.instance("test_slim")
+    end
+
+    it "should throw normal exception if no such method is found." do
+      result = @executor.call("test_slim", "no_such_method")
+      result.should include(Statement::EXCEPTION_TAG + "message:<<NO_METHOD_IN_CLASS no_such_method[0] TestModule::TestSlim.>>")
+    end
+
+    it "should still call normal methods in fixture" do
+      @test_slim.should_receive(:no_args).with()
+      @executor.call("test_slim", "no_args")
+    end
+
+    it "should still call methods on the sut" do
+      @test_slim.sut.should_receive(:sut_method).with()
+      @executor.call("test_slim", "sut_method")
+    end
+
+    it "should call a specific method on library_old" do
+      @library_old.should_receive(:method_on_library_old).with()
+      @executor.call("test_slim", "method_on_library_old")
+    end
+
+    it "should call a specific method on library_new" do
+      @library_new.should_receive(:method_on_library_new).with()
+      @executor.call("test_slim", "method_on_library_new")
+    end
+
+    it "should call method on library_new but not on library_old" do
+      @library_new.should_receive(:a_method).with()
+      @library_old.should_not_receive(:a_method).with()
+      @executor.call("test_slim", "a_method")
+    end
+
+    it "should call built-in library methods" do
+      @executor.call("test_slim", "push_fixture").should == nil
+      @executor.call("test_slim", "pop_fixture").should == nil
+    end
+
+    it "should translate getters and setters" do
+      @executor.call("test_slim", "set_lib_attribute", "lemon")
+      @executor.call("test_slim", "lib_attribute").should == "lemon"
+    end
+
+  end
+end