codersdojo 0.9.0

data/app/personal_codersdojo.rb

@@ -0,0 +1,645 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "tempfile"
+require "rexml/document"
+
+class Scheduler
+
+  def initialize runner
+    @runner = runner
+  end
+
+  def start
+    @runner.start
+    while true do
+      sleep 1
+      @runner.execute
+    end
+  end
+
+end
+
+class Runner
+
+  attr_accessor :file, :run_command
+
+  def initialize shell, session_provider
+    @filename_formatter = FilenameFormatter.new
+    @shell = shell
+    @session_provider = session_provider
+  end
+
+  def start
+    init_session
+    execute
+  end
+
+  def init_session
+    @step = 0
+    @session_id = @session_provider.generate_id
+    @shell.mkdir_p(@filename_formatter.session_dir @session_id)
+  end
+
+  def execute
+    change_time = @shell.ctime @file
+    if change_time == @previous_change_time then
+      return
+    end
+    result = @shell.execute "#{@run_command} #{@file}"
+    state_dir = @filename_formatter.state_dir @session_id, @step
+    @shell.mkdir state_dir
+    @shell.cp @file, state_dir
+    @shell.write_file @filename_formatter.result_file(state_dir), result
+    @step += 1
+    @previous_change_time = change_time
+  end
+
+end
+
+class Shell
+
+  MAX_STDOUT_LENGTH = 100000
+
+  def cp source, destination
+    FileUtils.cp source, destination
+  end
+
+  def mkdir dir
+    FileUtils.mkdir dir
+  end
+
+  def mkdir_p dirs
+    FileUtils.mkdir_p dirs
+  end
+
+  def execute command
+    spec_pipe = IO.popen(command, "r")
+    result = spec_pipe.read MAX_STDOUT_LENGTH
+    spec_pipe.close
+    puts result
+    result
+  end
+
+  def write_file filename, content
+    file = File.new filename, "w"
+    file << content
+    file.close
+  end
+
+  def read_file filename
+    file = File.new filename
+    content = file.read
+    file.close
+    content
+  end
+
+  def ctime filename
+    File.new(filename).ctime
+  end
+
+	def make_os_specific text
+		text.gsub('%sh%', shell_extension).gsub('%:%', path_separator).gsub('%rm%', remove_command_name)
+	end
+
+	def remove_command_name
+		windows? ? 'delete' : 'rm'
+	end
+
+	def shell_extension
+		windows? ? 'cmd' : 'sh'
+	end
+	
+	def path_separator
+		windows? ? ';' : ':'
+	end
+	
+	def windows?
+		RUBY_PLATFORM.downcase.include? "windows"
+	end
+
+end
+
+class SessionIdGenerator
+
+  def generate_id time=Time.new
+		year = format_to_length time.year, 4
+		month = format_to_length time.month, 2
+		day = format_to_length time.day, 2
+		hour = format_to_length time.hour, 2
+		minute = format_to_length time.min, 2
+		second = format_to_length time.sec, 2
+    "#{year}-#{month}-#{day}_#{hour}-#{minute}-#{second}"
+  end
+
+  def format_to_length value, len
+		value.to_s.rjust len,"0"
+	end
+
+end
+
+class StateReader
+
+  attr_accessor :session_id, :next_step
+
+  def initialize shell
+    @filename_formatter = FilenameFormatter.new
+    @shell = shell
+    @next_step = 0
+  end
+
+  def state_count
+    Dir.new(@filename_formatter.session_dir @session_id).count - 2
+  end
+
+  def enough_states?
+    state_count >= 2
+  end
+
+  def get_state_dir
+    @filename_formatter.state_dir(@session_id, @next_step)
+  end
+
+  def has_next_state
+    File.exist?(get_state_dir)
+  end
+
+  def read_next_state
+    state = State.new
+    state_dir = get_state_dir
+    state.time = @shell.ctime state_dir
+    state.code = @shell.read_file @filename_formatter.source_code_file(state_dir)
+    state.result = @shell.read_file @filename_formatter.result_file(state_dir)
+    @next_step += 1
+    state
+  end
+
+end
+
+class FilenameFormatter
+
+  CODERSDOJO_WORKSPACE = ".codersdojo"
+  RESULT_FILE = "result.txt"
+  STATE_DIR_PREFIX = "state_"
+
+
+  def source_code_file state_dir
+    Dir.entries(state_dir).each { |file|
+      return state_file state_dir, file unless file =='..' || file == '.' ||file == RESULT_FILE }
+  end
+
+  def result_file state_dir
+    state_file state_dir, RESULT_FILE
+  end
+
+  def state_file state_dir, file
+    "#{state_dir}/#{file}"
+  end
+
+  def state_dir session_id, step
+    session_directory = session_dir session_id
+    "#{session_directory}/#{STATE_DIR_PREFIX}#{step}"
+  end
+
+  def session_dir session_id
+    "#{CODERSDOJO_WORKSPACE}/#{session_id}"
+  end
+
+end
+
+class Progress
+
+  def self.write_empty_progress states
+    STDOUT.print "#{states} states to upload"
+    STDOUT.print "["+" "*states+"]"
+    STDOUT.print "\b"*(states+1)
+    STDOUT.flush
+  end
+
+  def self.next
+    STDOUT.print "."
+    STDOUT.flush
+  end
+
+  def self.end
+    STDOUT.puts
+  end
+end
+
+class Uploader
+
+  def initialize hostname, framework, session_dir, state_reader = StateReader.new(Shell.new)
+		@hostname = hostname
+	  @framework = framework
+    @state_reader = state_reader
+    @state_reader.session_id = session_dir.gsub('.codersdojo/', '')
+  end
+
+  def upload_kata
+    RestClient.post "#{@hostname}#{@@kata_path}", {:framework => @framework}
+  end
+
+  def upload_state kata_id
+    state = @state_reader.read_next_state
+    RestClient.post "#{@hostname}#{@@kata_path}/#{kata_id}#{@@state_path}", {:code => state.code, :result => state.result, :created_at => state.time}
+    Progress.next
+  end
+
+  def upload_states kata_id
+    Progress.write_empty_progress @state_reader.state_count
+    while @state_reader.has_next_state
+      upload_state kata_id
+    end
+    Progress.end
+  end
+
+  def upload_kata_and_states
+    kata = upload_kata
+    upload_states(XMLElementExtractor.extract('kata/id', kata))
+    "This is the link to review and comment your kata #{XMLElementExtractor.extract('kata/short-url', kata)}"
+  end
+
+  def upload
+    begin
+      require 'rest_client'
+    rescue LoadError
+      return 'Cant find gem rest-client. Please install it.'
+    end
+    return upload_kata_and_states if @state_reader.enough_states?
+    return "You need at least two states"
+  end
+
+  private
+  @@kata_path = '/katas'
+  @@state_path = '/states'
+
+end
+
+class XMLElementExtractor
+  def self.extract element, xml_string
+    doc = REXML::Document.new xml_string
+    return doc.elements.each(element) do |found|
+      return found.text
+    end
+  end
+end
+
+class State
+
+  attr_accessor :time, :code, :result
+
+  def initialize time=nil, code=nil, result=nil
+    @time = time
+    @code = code
+    @result = result
+  end
+
+end
+
+class ArgumentParser
+	
+	def initialize controller
+		@controller = controller
+	end
+	
+	def parse params
+		command = params[0] ? params[0] : ""
+		if command.downcase == "help" then
+			@controller.help params[1]
+		elsif command.downcase == "show-examples" then
+				@controller.show_examples
+		elsif command.downcase == "setup" then
+			@controller.generate params[1], params[2] ? params[2] : '<kata_file>'
+		elsif command.downcase == "upload" then
+			@controller.upload params[1], params[2]
+		elsif command.downcase == "start" then
+			run_command = expand_run_command params[1]
+			@controller.start run_command, params[2]
+		elsif command.downcase == "spec" then
+			# 'spec" is for testing purpose only: do nothing special
+		else
+			raise ArgumentError
+		end
+	end
+
+	def expand_run_command command
+		if command.end_with?(".sh") then
+			"bash #{command}"
+		elsif command.end_with?(".bat") or command.end_with?(".cmd") then
+			"start #{command}"
+		else
+			command
+		end
+	end
+	
+end
+
+class Controller
+
+	def initialize view, hostname
+		@view = view
+		@hostname = hostname
+	end
+
+	def help command=nil
+		if command then
+			@view.show_detailed_help command.downcase
+		else
+			@view.show_help
+		end
+	end
+
+	def show_examples
+		@view.show_examples
+	end
+
+	def generate framework, kata_file
+		generator = GeneratorFactory.new.create_generator framework
+		shell = Shell.new
+		generator_text = generator.generate kata_file
+		generator_text = shell.make_os_specific generator_text
+		puts generator_text
+	end
+
+	def start command, file
+		if not command or not file then
+			@view.show_missing_command_argument_error "start"
+			return
+		end
+	  @view.show_start_kata command, file
+	  dojo = Runner.new Shell.new, SessionIdGenerator.new
+	  dojo.file = file
+	  dojo.run_command = command
+	  scheduler = Scheduler.new dojo
+	  scheduler.start
+	end
+
+	def upload framework, session_directory
+		@view.show_upload_start @hostname
+		if session_directory then
+		  uploader = Uploader.new @hostname, framework, session_directory
+		  p uploader.upload
+		else
+			@view.show_missing_command_argument_error "upload"
+		end
+	end
+
+end
+
+
+class ConsoleView
+	
+	@@VERSION = '0.9'
+	
+	def show_help
+		puts <<-helptext
+Personal CodersDojo, Version #{@@VERSION}, http://www.codersdojo.com, Copyright by it-agile GmbH (http://www.it-agile.de)
+PersonalCodersDojo automatically runs your tests of a code kata.
+
+helptext
+		show_usage
+	end
+	
+	def show_usage
+		puts <<-helptext
+Usage: #{$0} command [options]
+Commands:
+  help, -h, --help                   Print this help text.
+  help <command>                     See the details of the command.
+  setup <framework> <kata_file>      Setup the environment for running the kata.
+  upload <framework> <session_dir>   Upload the kata to http://www.codersdojo.org
+  show-examples                      Show some example usages.
+
+Report bugs to <codersdojo@it-agile.de>
+helptext
+	end
+
+	def show_examples
+		puts <<-helptext
+Examples:
+    :/dojo/my_kata% #{$0} setup ruby.test/unit prime
+      Show the instructions how to setup the environment for kata execution with ruby.
+
+    :/dojo/my_kata$ #{$0} start ruby prime.rb
+      Run the tests of prime.rb. The test runs automatically every second if prime.rb was modified.
+
+    :/dojo/my_kata$ #{$0} upload  ruby.test/unit .codersdojo/2010-11-02_16-21-53
+      Upload the kata (written in Ruby with the test/unit framework) located in directory ".codersdojo/2010-11-02_16-21-53" to codersdojo.com.
+helptext
+	end
+
+	def show_detailed_help command
+		if command == 'setup' then
+			show_help_setup
+		elsif command == 'start' then
+			show_help_start
+		elsif command == 'upload' then
+			show_help_upload
+		else
+			show_help_unknown command
+		end
+	end
+
+	def show_help_setup
+			puts <<-helptext
+setup <framework> <kata_file_no_ext>  Setup the environment for the kata for the given framework and kata file.
+                                      The kata_file should not have an extension. Use 'prime' and not 'prime.java'.
+                                      By now <framework> is one of clojure.is-test, java.junit, javascript.jspec, 
+                                      python.unittest, ruby.test/unit.
+                                      Use ??? as framework if your framework isn't in the list.
+helptext
+	end
+
+	def show_help_start
+		puts <<-helptext
+start <shell_command> <kata_file>  Start the continuous test runner, that runs <shell-command> whenever <kata_file>
+                                   changes. The <kata_file> has to include the whole source code of the kata.
+                                   Whenever the test runner is started, it creates a new session directory in the 
+                                   directory .codersdojo where it logs the steps of the kata.
+helptext
+	end
+
+	def show_help_upload
+		puts <<-helptext
+upload <framework> <session_directory>  Upload the kata written with <framework> in <session_directory> to codersdojo.com. 
+                                        <session_directory> is relative to the working directory.
+                                        Take a look at the generate command for the supported frameworks.
+                                        If you used another framework, use ??? and send an email to codersdojo@it-agile.de
+helptext
+	end
+	
+	def show_help_unknown command
+		puts <<-helptext
+Command #{command} not known. Try '#{$0} help' to list the supported commands.
+helptext
+	end
+	
+	def show_start_kata command, file
+	  puts "Starting PersonalCodersDojo with command #{command} and kata file #{file}. Use Ctrl+C to finish the kata."		
+	end
+	
+	def show_missing_command_argument_error command
+		puts "Command <#{command}> recognized but no argument was provided (at least one argument is required).\n\n"
+		show_usage
+	end
+	
+	def show_upload_start hostname
+		puts "Start upload to #{hostname}"
+	end
+	
+	def show_upload_result result
+		puts result
+	end
+	
+	def show_socket_error command
+		puts "Encountered network error while <#{command}>. Is http://www.codersdojo.com down?"
+	end
+	
+end
+
+class GeneratorFactory
+		
+	def initialize
+		@frameworks = {"clojure.is-test" => ClosureGenerator,
+									 "java.junit" => JavaGenerator, 
+								   "javascript.jspec" => JavascriptGenerator,
+									 "python.unittest" => PythonGenerator,
+									 "ruby.test/unit" => RubyGenerator}	
+	end
+	
+	def create_generator framework
+		generator_class = @frameworks[framework]
+		if generator_class.nil? then
+			generator_class = AnyGenerator
+		end
+		generator_class.new
+	end
+	
+end
+
+class AnyGenerator
+	
+	def generate kata_file
+<<-generate_help
+You have to create two shell scripts manually:
+  Create a shell script run-once.%sh% that runs the tests of your kata once.
+
+  Create a second shell script run-endless.sh with this content:
+    #{$0} start run-once.%sh% #{kata_file}.<extension>
+
+Run run-endless.%sh% and start your kata.
+
+Assumptions:
+  - The whole kata source code is in the one #{kata_file}.<extension>.
+generate_help
+	end
+end
+
+class ClosureGenerator
+	def generate kata_file
+<<-generate_help
+You have to create two shell scripts manually:
+  Create a shell script run-once.%sh% with this content:
+    java -cp clojure-contrib.jar%:%clojure.jar clojure.main #{kata_file}.clj
+
+  Create a second shell script run-endless.sh with this content:
+    #{$0} start run-once.%sh% #{kata_file}.clj
+
+Run run-endless.%sh% and start your kata.
+
+Assumptions:
+  - Java is installed on your system and 'java' is in the path.
+  - clojure.jar and clojure-contrib.jar are placed in your work directory.
+generate_help
+	end
+end
+
+class JavaGenerator
+	def generate kata_file
+<<-generate_help
+You have to create two shell scripts manually:
+  Create a shell script run-once.%sh% with this content:
+    %rm% bin/#{kata_file}.class
+    javac -cp lib/junit.jar -d bin #{kata_file}.java
+    java -cp lib/junit.jar%:%bin #{kata_file}
+
+  Create a second shell script run-endless.sh with this content:
+    #{$0} start run-once.%sh% src/#{kata_file}.java
+
+Run run-endless.%sh% and start your kata.
+
+Assumptions:
+  - A Java JDK is installed on your system and 'java' and 'javac' are in the path.
+  - junit.jar is placed in a directory named 'lib'.
+  - The kata source file is placed in the 'src' directory.
+  - The kata class file is generated into the 'class' directory.
+  - In the source file the classes are placed in the default package.
+  - The kata source file has a main method that starts the tests.
+  - If your IDE (like Eclipse) compiles the source file, you should remove the first two lines
+    in the run-once.%sh% file.
+generate_help
+	end
+end
+
+
+class JavascriptGenerator
+	def generate kata_file
+<<-generate_help
+You have to create two shell scripts manually:
+  Create a shell script run-once.%sh% with this content:
+    jspec --rhino run
+
+  Create a second shell script run-endless.sh with this content:
+    #{$0} start run-once.%sh% #{kata_file}.js
+
+Run run-endless.%sh% and start your kata.
+generate_help
+	end
+end
+
+
+class PythonGenerator
+	def generate kata_file
+<<-generate_help
+You have to create two shell scripts manually:
+  Create a shell script run-once.%sh% with this content:
+    python #{kata_file}.py
+
+  Create a second shell script run-endless.sh with this content:
+    #{$0} start run-once.%sh% #{kata_file}.py
+
+Run run-endless.%sh% and start your kata.
+generate_help
+	end
+end
+
+
+class RubyGenerator
+	def generate kata_file
+<<-generate_help
+You have to create one shell script manually:
+  Create a shell script run-endless.%sh% with this content:
+    #{$0} start ruby #{kata_file}.rb
+
+Run run-endless.%sh% and start your kata.
+generate_help
+	end
+end
+
+def called_from_spec args
+  args[0] == "spec"
+end
+
+# entry from shell
+if not called_from_spec(ARGV) then
+	view = ConsoleView.new
+	hostname = "http://www.codersdojo.com"
+	#hostname = "http://localhost:3000"
+	controller = Controller.new view, hostname
+	begin
+		arg_parser = ArgumentParser.new controller
+		command = arg_parser.parse ARGV
+	rescue ArgumentError
+		controller.help
+	end
+end

data/spec/personal_codersdojo_spec.rb

@@ -0,0 +1,272 @@
+ARGV[0] = "spec" # to be first line to suppress help text output of shell command
+require 'rubygems'
+require "app/personal_codersdojo"
+require "restclient"
+require "spec"
+
+
+describe Runner, "in run mode" do
+
+  WORKSPACE_DIR = ".codersdojo"
+  SESSION_ID = "id0815"
+  SESSION_DIR = "#{WORKSPACE_DIR}/#{SESSION_ID}"
+  STATE_DIR_PREFIX = "#{SESSION_DIR}/state_"
+
+  before (:each) do
+    @shell_mock = mock.as_null_object
+    @session_id_provider_mock = mock.as_null_object
+    @session_id_provider_mock.should_receive(:generate_id).and_return SESSION_ID
+    @runner = Runner.new @shell_mock, @session_id_provider_mock
+    @runner.file = "my_file.rb"
+    @runner.run_command = "ruby"
+  end
+
+  it "should create codersdojo directory if it doesn't exist with session sub-directory" do
+    @shell_mock.should_receive(:mkdir_p).with SESSION_DIR
+    @runner.start
+  end
+
+  it "should run ruby command on kata file given as argument" do
+    @shell_mock.should_receive(:execute).with "ruby my_file.rb"
+    @runner.start
+  end
+
+  it "should create a state directory for every state" do
+    @shell_mock.should_receive(:ctime).with("my_file.rb").and_return 1
+    @shell_mock.should_receive(:mkdir).with "#{STATE_DIR_PREFIX}0"
+    @shell_mock.should_receive(:cp).with "my_file.rb", "#{STATE_DIR_PREFIX}0"
+    @runner.start
+    @shell_mock.should_receive(:ctime).with("my_file.rb").and_return 2
+    @shell_mock.should_receive(:mkdir).with "#{STATE_DIR_PREFIX}1"
+    @shell_mock.should_receive(:cp).with "my_file.rb", "#{STATE_DIR_PREFIX}1"
+    @runner.execute
+  end
+
+  it "should not run if the kata file wasn't modified" do
+    a_time = Time.new
+    @shell_mock.should_receive(:ctime).with("my_file.rb").and_return a_time
+    @shell_mock.should_receive(:mkdir).with "#{STATE_DIR_PREFIX}0"
+    @shell_mock.should_receive(:cp).with "my_file.rb", "#{STATE_DIR_PREFIX}0"
+    @runner.start
+    @shell_mock.should_receive(:ctime).with("my_file.rb").and_return a_time
+    @shell_mock.should_not_receive(:mkdir).with "#{STATE_DIR_PREFIX}1"
+    @shell_mock.should_not_receive(:cp).with "my_file.rb", "#{STATE_DIR_PREFIX}1"
+    @runner.execute
+  end
+
+  it "should capture run result into state directory" do
+    @shell_mock.should_receive(:execute).and_return "spec result"
+    @shell_mock.should_receive(:write_file).with "#{STATE_DIR_PREFIX}0/result.txt", "spec result"
+    @runner.start
+  end
+
+end
+
+
+describe SessionIdGenerator do
+	
+	before (:each) do
+		@time_mock = mock
+		@generator = SessionIdGenerator.new
+	end
+	
+	it "should format id as yyyy-mm-dd_hh-mm-ss" do
+		@time_mock.should_receive(:year).and_return 2010
+		@time_mock.should_receive(:month).and_return 8
+		@time_mock.should_receive(:day).and_return 7
+		@time_mock.should_receive(:hour).and_return 6
+		@time_mock.should_receive(:min).and_return 5
+		@time_mock.should_receive(:sec).and_return 0
+		@generator.generate_id(@time_mock).should == "2010-08-07_06-05-00"
+	end
+	
+end
+
+describe StateReader do
+
+  before (:each) do
+    @a_time = Time.new
+    @shell_mock = mock
+    @state_reader = StateReader.new @shell_mock
+    @state_reader.session_id = "id0815"
+  end
+
+  it "should read a stored kata state" do
+    @shell_mock.should_receive(:ctime).with("#{STATE_DIR_PREFIX}0").and_return @a_time
+    Dir.should_receive(:entries).with("#{STATE_DIR_PREFIX}0").and_return(['.','..','file.rb', 'result.txt'])
+    @shell_mock.should_receive(:read_file).with("#{STATE_DIR_PREFIX}0/file.rb").and_return "source code"
+    @shell_mock.should_receive(:read_file).with("#{STATE_DIR_PREFIX}0/result.txt").and_return "result"
+    state = @state_reader.read_next_state
+    state.time.should == @a_time
+    state.code.should == "source code"
+    state.result.should == "result"
+    @state_reader.next_step.should == 1
+  end
+
+end
+
+describe Uploader do
+
+  before (:each) do
+    @state_reader_mock = mock StateReader
+  end
+
+  it "should convert session-dir to session-id" do
+    @state_reader_mock.should_receive(:session_id=).with("session_id")
+    Uploader.new "http://dummy_host", "dummy.framework", ".codersdojo/session_id", @state_reader_mock
+  end
+
+    context'upload' do
+
+      before (:each) do
+        @state_reader_mock = mock StateReader
+        @state_reader_mock.should_receive(:session_id=).with("path_to_kata")
+        @uploader = Uploader.new "http://dummy_host", "dummy.framework", "path_to_kata", @state_reader_mock
+      end
+
+      it "should return error message if rest-client not installed" do
+        @uploader.stub(:require).and_raise(LoadError)
+        message = @uploader.upload
+        message.should == 'Cant find gem rest-client. Please install it.'
+      end
+
+      it "should upload a kata through a rest-interface" do
+        RestClient.should_receive(:post).with('http://dummy_host/katas', {:framework => "dummy.framework"}).and_return '<id>222</id>'
+        @uploader.upload_kata
+      end
+
+      it "should upload kata and states" do
+        @uploader.stub(:upload_kata).and_return 'kata_xml'
+        XMLElementExtractor.should_receive(:extract).with('kata/id', 'kata_xml').and_return 'kata_id'
+        @uploader.stub(:upload_states).with 'kata_id'
+        XMLElementExtractor.should_receive(:extract).with('kata/short-url', 'kata_xml').and_return 'short_url'
+        @uploader.upload_kata_and_states
+      end
+
+      it 'should upload if enugh states are there' do
+        @state_reader_mock.should_receive(:enough_states?).and_return 'true'
+        @uploader.stub!(:upload_kata_and_states).and_return 'kata_link'
+        @uploader.upload
+      end
+
+      it 'should return a helptext if not enught states are there' do
+        @state_reader_mock.should_receive(:enough_states?).and_return nil
+        help_text = @uploader.upload
+        help_text.should == 'You need at least two states'
+      end
+
+      context 'states' do
+        it "should read all states and starts/ends progress" do
+          @state_reader_mock.should_receive(:state_count).and_return(1)
+          Progress.should_receive(:write_empty_progress).with(1)
+
+          @state_reader_mock.should_receive(:has_next_state).and_return 'true'
+          @uploader.should_receive(:upload_state)
+          @state_reader_mock.should_receive(:has_next_state).and_return nil
+
+          Progress.should_receive(:end)
+
+          @uploader.upload_states "kata_id"
+        end
+
+
+        it "through a rest interface and log process" do
+          state = mock State
+          @state_reader_mock.should_receive(:read_next_state).and_return state
+          state.should_receive(:code).and_return 'code'
+          state.should_receive(:time).and_return 'time'
+          state.should_receive(:result).and_return 'result'
+          RestClient.should_receive(:post).with('http://dummy_host/katas/kata_id/states', {:code=> 'code', :result => 'result', :created_at => 'time'})
+          Progress.should_receive(:next)
+          @uploader.upload_state "kata_id"
+        end
+
+      end
+
+    end
+
+  end
+
+describe XMLElementExtractor do
+	
+  it "should extract first element from a xml string" do
+    xmlString = "<?xml version='1.0' encoding='UTF-8'?>\n<kata>\n  <created-at type='datetime'>2010-07-16T16:02:00+02:00</created-at>\n  <end-date type='datetime' nil='true'/>\n  <id type='integer'>60</id>\n  <short-url nil='true'/>\n  <updated-at type='datetime'>2010-07-16T16:02:00+02:00</updated-at>\n  <uuid>2a5a83dc71b8ad6565bd99f15d01e41ec1a8f3f2</uuid>\n</kata>\n"
+    element = XMLElementExtractor.extract 'kata/id', xmlString
+    element.should == "60"
+  end
+
+end
+
+describe ArgumentParser do
+	
+	before (:each) do
+		@controller_mock = mock.as_null_object
+		@parser = ArgumentParser.new @controller_mock
+	end
+	
+	it "should reject empty command" do
+		lambda{@parser.parse []}.should raise_error
+	end
+	
+	it "should reject unknown command" do
+		lambda{@parser.parse "unknown command"}.should raise_error
+	end
+	
+	it "should accept help command" do
+		@controller_mock.should_receive(:help).with(nil)
+		@parser.parse ["help"]
+	end
+	
+	it "should accept start command" do
+		@controller_mock.should_receive(:start).with "aCommand", "aFile"
+		@parser.parse ["start", "aCommand","aFile"]
+	end
+	
+	it "should prepend *.sh start scripts with 'bash'" do
+		@controller_mock.should_receive(:start).with "bash aCommand.sh", "aFile"
+		@parser.parse ["start", "aCommand.sh","aFile"]		
+	end
+	
+	it "should prepend *.bat start scripts with 'start'" do
+		@controller_mock.should_receive(:start).with "start aCommand.bat", "aFile"
+		@parser.parse ["start", "aCommand.bat","aFile"]		
+	end
+	
+	it "should prepend *.cmd start scripts with 'start'" do
+		@controller_mock.should_receive(:start).with "start aCommand.cmd", "aFile"
+		@parser.parse ["start", "aCommand.cmd","aFile"]		
+	end
+	
+	it "should accept upload command" do
+		@controller_mock.should_receive(:upload).with "framework", "dir"
+		@parser.parse ["upload", "framework", "dir"]
+	end
+	
+	it "should accept uppercase commands" do
+		@controller_mock.should_receive(:help).with(nil)
+		@parser.parse ["HELP"]
+	end
+
+end
+
+describe Progress do
+
+  it 'should print infos and empty progress in initialization' do
+    STDOUT.should_receive(:print).with("2 states to upload")
+    STDOUT.should_receive(:print).with("[  ]")
+    STDOUT.should_receive(:print).with("\b\b\b")
+    Progress.write_empty_progress 2
+  end
+
+  it 'should print dots and flush in next' do
+    STDOUT.should_receive(:print).with(".")
+    STDOUT.should_receive(:flush) 
+    Progress.next
+  end
+
+  it 'should print empty line in end' do
+    STDOUT.should_receive(:puts)
+    Progress.end
+  end
+
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: codersdojo
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- CodersDojo-Team
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-10 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Client executes tests in an endless loop and logs source code and test result.
+email: codersdojo@it-agile.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- app/personal_codersdojo.rb
+has_rdoc: true
+homepage: http://www.codersdojo.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: codersdojo
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Client for CodersDojo.org
+test_files: 
+- spec/personal_codersdojo_spec.rb