rubyslim-unofficial 0.0.1

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,38 @@
+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,127 @@
+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.jlength.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

data/spec/slim_helper_library_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require 'slim_helper_library'
+require 'statement_executor'
+
+SLIM_HELPER_LIBRARY_INSTANCE_NAME = "SlimHelperLibrary"
+ACTOR_INSTANCE_NAME = "scriptTableActor"
+
+describe SlimHelperLibrary do
+  before() do
+    @executor = StatementExecutor.new
+    @executor.add_module("TestModule")
+    @executor.create(ACTOR_INSTANCE_NAME, "TestSlim", ["0"]).should == "OK"
+    @instance = @executor.instance(ACTOR_INSTANCE_NAME)
+    @helper = SlimHelperLibrary.new(@executor)
+  end
+
+  it "can get current scriptTableActor" do
+    @helper.get_fixture.should be @instance
+  end
+
+  it "can push and pop" do
+    @helper.push_fixture
+    @executor.create(ACTOR_INSTANCE_NAME, "TestSlim", ["1"])
+    @helper.get_fixture.should_not be @instance
+    @helper.pop_fixture
+    @helper.get_fixture.should be @instance
+  end
+
+  it "can push and pop many" do
+    @helper.push_fixture
+    @executor.create(ACTOR_INSTANCE_NAME, "TestChain", []).should == "OK"
+    one = @executor.instance(ACTOR_INSTANCE_NAME)
+    one.should_not be_nil
+    @helper.push_fixture
+
+    @executor.create(ACTOR_INSTANCE_NAME, "SimpleScript", [])
+    two = @executor.instance(ACTOR_INSTANCE_NAME)
+    one.should_not be two
+    @helper.get_fixture.should be two
+
+    @helper.pop_fixture
+    @helper.get_fixture.should be one
+
+    @helper.pop_fixture
+    @helper.get_fixture.should be @instance
+
+  end
+
+end
+
+
+#@Test
+#public void testSlimHelperLibraryIsStoredInSlimExecutor() throws Exception {
+#  Object helperLibrary = caller.getInstance(SLIM_HELPER_LIBRARY_INSTANCE_NAME);
+#  assertTrue(helperLibrary instanceof SlimHelperLibrary);
+#}
+#
+#@Test
+#public void testSlimHelperLibraryHasStatementExecutor() throws Exception {
+#  SlimHelperLibrary helperLibrary = (SlimHelperLibrary) caller.getInstance(SLIM_HELPER_LIBRARY_INSTANCE_NAME);
+#  assertSame(caller, helperLibrary.getStatementExecutor());
+#}
+#
+#@Test
+#public void testSlimHelperLibraryCanPushAndPopFixture() throws Exception {
+#  SlimHelperLibrary helperLibrary = (SlimHelperLibrary) caller.getInstance(SLIM_HELPER_LIBRARY_INSTANCE_NAME);
+#  Object response = caller.create(ACTOR_INSTANCE_NAME, getTestClassName(), new Object[0]);
+#  Object firstActor = caller.getInstance(ACTOR_INSTANCE_NAME);
+#
+#  helperLibrary.pushFixture();
+#
+#  response = caller.create(ACTOR_INSTANCE_NAME, getTestClassName(), new Object[] {"1"});
+#  assertEquals("OK", response);
+#  assertNotSame(firstActor, caller.getInstance(ACTOR_INSTANCE_NAME));
+#
+#  helperLibrary.popFixture();
+#
+#  assertSame(firstActor, caller.getInstance(ACTOR_INSTANCE_NAME));
+#}
+#

data/spec/socket_service_spec.rb

@@ -0,0 +1,98 @@
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require 'socket_service'
+
+class SocketServiceTest < Test::Unit::TestCase
+  def setup
+  	@port = 12345
+    @ss = SocketService.new()
+    @connections = 0
+  end
+
+  def testOneConnection
+    @ss.serve(@port) {@connections += 1}
+    connect(@port)
+    @ss.close()
+    assert_equal(1, @connections)
+  end
+
+  def testManyConnections
+    @ss.serve(@port) {@connections += 1}
+    10.times {connect(@port)}
+    @ss.close()
+    assert_equal(10, @connections)
+    assert_equal(0, @ss.pendingSessions)
+  end
+
+  def testSocketSend
+    @ss.serve(@port) do |serverSocket|
+      serverSocket.write("hi")
+    end
+
+    clientSocket = TCPSocket.open("localhost", @port)
+    answer = clientSocket.gets
+    clientSocket.close
+    assert_equal("hi", answer)
+    @ss.close()
+  end
+
+  # TEST FREEZES!!!
+  # We should not be able to keep the service alive by hitting
+  # it with connections after we close it?
+  def _testCantKeepAliveByConnectingAfterClose
+    #set up a service that waits for a message and then dies.
+    @ss.serve(@port) do |serverSocket|
+      message = serverSocket.gets
+    end
+
+    #s1 is a connection to that service.
+    s1 = TCPSocket.open("localhost", @port)
+    sleep(0.1)
+
+    #now start closing the server in a separate thread. It cannot
+    #finish closing until s1 completes.
+    Thread.start {@ss.close}
+    sleep(0.1)
+
+    #try to connect to the dying server.
+    s2=nil
+    Thread.start {s2 = TCPSocket.open("localhost", @port)}
+    sleep(0.1)
+    assert_equal(nil, s2, "shouldn't have connected")
+    assert_not_equal(nil, s1, "Should have connected")
+
+    #Complete the s1 session.
+    s1.write("testCloseRaceCondition");
+    s1.close
+
+    #collect the pending s2 connection
+    testThread = Thread.current
+    @ss.serve(@port) {testThread.wakeup}
+    Thread.stop
+    assert_not_equal(nil, s2)
+    s2.close
+    @ss.close
+  end
+
+  def testSessionCount
+    @ss.serve(@port) do |serverSocket|
+      message = serverSocket.gets
+    end
+
+    s1 = nil;
+    Thread.start {s1 = TCPSocket.open("localhost", @port)}
+    sleep(0.2)
+    assert_equal(1, @ss.pendingSessions);
+    s1.write("testSessionCount");
+    s1.close
+    sleep(0.2)
+    assert_equal(0, @ss.pendingSessions)
+    @ss.close
+  end
+
+  def connect(port)
+    s = TCPSocket.open("localhost", @port)
+    sleep(0.1)
+    s.close
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib/rubyslim")
+require "rubygems"
+require "spec"
+require 'jcode'
+$KCODE="UTF8"
+require 'timeout'

data/spec/statement_executor_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require "statement_executor"
+
+describe StatementExecutor do
+  before do
+    @executor = StatementExecutor.new
+  end
+
+  it "can split class names" do
+    @executor.split_class_name("a::b::c").should == ["a", "b", "c"]
+  end
+
+  it "can convert module names to file names" do
+    @executor.to_file_name("MyModuleName").should == "my_module_name"
+  end
+
+  it "can build the path name to a class" do
+    @executor.make_path_to_class("ModuleOne::ModuleTwo::MyClass").should == "module_one/module_two/my_class"
+  end
+
+  it "can require a class" do
+    @executor.add_module("MyModule")
+    proc = proc {@executor.require_class("MyModule::MyClass")}
+    proc.should raise_error(SlimError, /message:<<COULD_NOT_INVOKE_CONSTRUCTOR MyModule::MyClass failed to find in/)
+  end
+
+  it "can handle symbols whose values are objects" do
+    @executor.set_symbol("foo", OpenStruct.new(:foo => "bar"))
+    @executor.get_symbol("foo").foo.should == "bar"
+    @executor.replace_symbol("$foo").foo.should == "bar"
+  end
+
+  describe "accessor translation" do
+    class TestInstance
+      attr_accessor :foo
+    end
+
+    before(:each) do
+      @instance = TestInstance.new
+      @executor.set_instance("test_instance", @instance)
+    end
+
+    it "should translate setters" do
+      @executor.call("test_instance", "set_foo", "123")
+      @instance.foo.should == "123"
+    end
+
+  end
+
+end

data/spec/statement_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require "statement"
+
+describe Statement do
+  before do
+    @statement = Statement.new("")
+  end
+
+  it "can translate slim class names to ruby class names" do
+    @statement.slim_to_ruby_class("myPackage.MyClass").should == "MyPackage::MyClass"
+    @statement.slim_to_ruby_class("this.that::theOther").should == "This::That::TheOther"
+  end
+
+  it "can translate slim method names to ruby method names" do
+    @statement.slim_to_ruby_method("myMethod").should == "my_method"
+  end
+end

data/spec/table_to_hash_converter_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require 'table_to_hash_converter'
+
+def shouldNotChange(string)
+  TableToHashConverter.convert(string).should == string
+end
+
+describe TableToHashConverter do
+  [
+    ["some string", "not a table"],
+    ["<table>blah", "incomplete table"],
+    ["<table><tr><td>hi</td></tr></table>", "too few columns"],
+    ["<table><tr><td>hi</td><td>med</td><td>lo</td></tr></table>", "too many columns"]
+  ].each do |string, reason|
+    it "#{reason}: should not change '#{string}'" do
+      shouldNotChange(string)
+    end
+  end
+end
+
+describe TableToHashConverter do
+  [
+    ["<table><tr><td>name</td><td>bob</td></tr></table>", {:name=>"bob"}],
+    [" <table> <tr> <td> name </td> <td> bob </td> </tr> </table> ", {:name=>"bob"}],
+    ["<table><tr><td>name</td><td>bob</td></tr><tr><td>addr</td><td>here</td></tr></table>", {:name=>'bob', :addr=>'here'}]
+  ].each do |table, hash|
+    it "should match #{table} to #{hash}" do
+      TableToHashConverter.convert(table).should == hash
+    end
+  end
+end