carps 0.2.1

data/features/steps/dmll.rb

@@ -0,0 +1,47 @@
+require "carps/mod"
+
+Then /^the reporter is registered with the resource manager$/ do
+   $resource.reporter = $reporter
+end
+
+Given /^(.+) are in the (.+)$/ do |monikers_text, room|
+   monikers = monikers_text.split
+   $resource.players_in monikers, room
+end
+
+Given /^a resource manager$/ do
+   $resource = Resource.new "resource"
+end
+
+Given /^a reporter$/ do
+   $reporter = Reporter.new
+end
+
+Then /^customize report for (.+)$/ do |player|
+   $reporter.edit player
+end
+
+Then /^take turns for (.+)/ do |name_text|
+   names = name_text.split
+   turns = $reporter.player_turns names
+   turns.each do |moniker, turn|
+      answers = turn.take
+      answers.from = moniker
+      answers.display
+   end
+end
+
+Then /^ask (.+): (.+)$/ do |players_text, question|
+   players = players_text.split
+   players.each do |player|
+      $reporter.ask_player player, question
+   end
+end
+
+Then /^create an NPC of type human$/ do
+   npc = $resource.new_npc "human"
+   unless npc
+      raise "Could not load human"
+   end
+   puts npc.to_s
+end

data/features/steps/edit.rb

@@ -0,0 +1,7 @@
+Given /^a text editor$/ do
+   $editor = CARPS::Editor.load
+end
+
+Then /^edit some text$/ do
+   Test::editor $editor
+end

data/features/steps/email.rb

@@ -0,0 +1,108 @@
+# Test email functionality
+
+require "carps/email/config"
+
+require "carps/ui/question"
+
+require "yaml"
+
+# Clone the original settings and apply the changes to create an array of new settings
+def make_settings settings, changes
+   changes.map do |field, val|
+      new_setting = settings.clone
+      new_setting[field] = val
+      new_setting
+   end
+end
+
+class EmailConfig
+
+   def imap
+      @imap
+   end
+
+   def smtp
+      @smtp
+   end
+
+   def address
+      @address
+   end
+
+end
+
+Given /^default IMAP settings$/ do
+   $imap_options = {
+      "user" => "carps", 
+      "server" => "killersmurf.com", 
+      "tls" => true, 
+      "port" => 993, 
+      "certificate" => nil,
+      "verify" => false,
+      "login" => false, 
+      "cram_md5" => false}
+end
+
+Given /^default SMTP settings$/ do
+   $smtp_options = {
+      "login" => false,
+      "cram_md5" => false,
+      "starttls" => true,
+      "tls" => false,
+      "port" => 25,
+      "user" => "carps",
+      "server" => "killersmurf.com"}
+end
+
+Then /^attempt connections with various SMTP security settings$/ do
+   pass = UI::secret "Enter SMTP password for #{$smtp_options["user"]}"
+   log = ["login", true]
+   cram = ["cram_md5", true]
+   tls = ["tls", true]
+   nostarttls = ["starttls", false]
+   settings = make_settings $smtp_options, [log, cram, tls, nostarttls]
+   settings.each do |setting|
+      puts "Testing setting:"
+      puts setting.to_yaml
+      smtp = SMTP.new setting, pass
+      smtp.ok?
+   end
+end
+
+Then /^attempt connections with various IMAP security settings$/ do
+   pass = UI::secret "Enter IMAP password for #{$imap_options["user"]}"
+   log = ["login", true]
+   cram = ["cram_md5", true]
+   notls = ["tls", false]
+   cert = ["certificate", "/home/spoon/cert"]
+   verify = ["verify", true]
+   settings = make_settings $imap_options, [log, cram, notls, cert, verify]
+   settings.each do |setting|
+      puts "Testing setting:"
+      puts setting.to_yaml
+      imap = IMAP.new setting, pass
+      imap.ok?
+   end
+end
+
+
+Given /^the email account$/ do
+
+
+   $email_config = EmailConfig.new "carps@killersmurf.com", true, $imap_options, $smtp_options
+   $email_config.connect!
+end
+
+Then /^an email is sent$/ do
+   smtp = $email_config.smtp
+   smtp.send $email_config.address, "It works!" 
+end
+
+Then /^an email is received$/ do
+   puts "The email reads:"
+   imap = $email_config.imap
+   message = imap.read[0].to_s
+   puts "Ruby encodes the message as: #{message.encoding.name}"
+   puts message 
+   puts "End email."
+end

data/features/steps/general.rb

@@ -0,0 +1,5 @@
+require "carps/util/init"
+
+Given /^carps is initialized with (.+)$/ do |config|
+   CARPS::init 0, config
+end

data/features/steps/interface.rb

@@ -0,0 +1,64 @@
+require "carps/service/interface"
+
+class Cheesey < QuitInterface
+
+   include ControlInterface
+
+   def initialize
+      super
+      add_command "cheese", "Have some cheese.", "AGE", "TYPE"
+      add_raw_command "echo", "I say what you say!", "MESSAGE"
+      add_command "cracker", "Have a cracker."
+   end
+
+   def echo arg
+      puts arg
+   end
+
+   def cheese age, type
+      puts "Mmmmm, #{age} #{type}!"
+   end
+
+   def cracker
+      puts "You may have a cracker."
+   end
+
+end
+
+class Broken < Cheesey
+
+   def initialize
+      super
+      add_command "wine", "Have a glass of wine", "YEAR", "TYPE"
+   end
+
+end
+
+Given /^a cheesey interface$/ do
+   $interface = Cheesey.new
+end
+
+Then /^present the cheesey interface to the user$/ do
+   child = fork do
+      $interface.run
+   end
+   Process.wait child 
+end
+
+# Test an interface by calling the commands
+def test_interface interface, commands
+   commands.each do |cmd|
+      interface.send *cmd
+   end
+end
+
+Given /^a broken interface created by a drunk$/ do
+   $interface = Broken.new
+end
+
+Then /^present the interface, reporting the mistake to the user$/ do
+      child = fork do
+      $interface.run
+   end
+   Process.wait child 
+end

data/features/steps/ipc.rb

@@ -0,0 +1,22 @@
+require "carps/util/process"
+
+require "drb"
+
+include Test
+
+Given /an object to be mutated/ do
+   $mut = Mutate.new
+end
+
+Then /^I should see 'It works' from the server side$/ do
+   puts "On server side:"
+   puts "\t" + $mut.works?
+   unless $mut.working?
+      raise StandardError, "IPC fucked."
+   end
+end
+
+When /^the Process.launch method is called with the name of a ruby subprogram, which I should see in another window$/ do
+   test_ipc CARPS::Process.singleton, $mut
+   puts "DONE!"
+end

data/features/steps/mailbox.rb

@@ -0,0 +1,126 @@
+require "carps/crypt/mailbox"
+require "carps/crypt/mailer"
+
+require "carps/protocol/message"
+
+require "carps/service/session"
+
+require "fileutils"
+
+require "highline"
+
+class SessionManager
+   def session
+      @session
+   end
+end
+
+class MailboxTestMessage < Message
+
+   def MailboxTestMessage.parse blob
+      if blob.match(/uhh/)
+         [MailboxTestMessage.new, ""]
+      else
+         raise Expected, "Expected 'uhh'."
+      end
+   end
+
+   def emit
+      text = "uhh"
+      text = $mailbox.tag text
+      addr = "bobby"
+      sig = "hiya"
+      mail = (V.addr addr) + (V.sig sig) + text + K.end
+   end
+
+end
+
+
+# Test the mailbox by sending and receiving mails
+class TestingIO
+
+   def initialize
+      @messages = []
+   end
+
+   # send the mailbox a message with a given session_id
+   def in id
+      $session.session = id
+      $mailbox.send "wayhey", MailboxTestMessage.new.emit
+      $session.none
+   end
+
+   # receive a message from the mailbox within 10 seconds or return nil
+   def out
+      msg = nil
+      thrd = Thread.fork do
+         msg = $mailbox.insecure_read MailboxTestMessage
+      end
+      10.times do
+         if msg
+            break
+         else
+            sleep 1
+         end
+      end
+      thrd.kill
+      msg
+   end
+
+   def send to, msg
+      @messages.push msg
+   end
+
+   def read
+      messages = @messages
+      @messages = []
+      messages
+   end
+
+   
+end
+
+When /^the user presses enter, continue$/ do
+   h = HighLine.new
+   h.ask "Press enter to continue..."
+end
+
+Then /^\.mail is cleaned$/ do
+   FileUtils.rm_rf $CONFIG + ".mail"
+   FileUtils.mkdir $CONFIG + ".mail"
+end
+
+Given /^a testing mailbox$/ do
+   parser = MessageParser.new [MailboxTestMessage]
+   $io = TestingIO.new
+   if $mailbox
+      $mailbox.shutdown
+   end
+   $mailbox = Mailbox.new $io, $io, parser, $session 
+end
+
+Then /^send mail with session (\d+) to the mailbox$/ do |session|
+   $io.in session
+end
+
+Then /^receive mail with session (\d+)$/ do |session|
+   mail = $io.out
+   if not mail
+      raise StandardError, "Did not receive mail with session #{session}"
+   elsif not mail.session == session
+      raise StandardError, "Received mail with session #{session}"
+   end
+end
+
+Then /^set session to (\d+)$/ do |id|
+   $session.session = id
+end
+
+Then /^check that the mail with session (\d+) has not been received$/ do |session|
+   mail = $io.out
+   if mail
+      if mail.session == session
+         raise StandardError, "Received mail with session #{mail.session}"
+      end
+   end
+end

data/features/steps/mod.rb

@@ -0,0 +1,25 @@
+require "carps/service/dm/config"
+require "carps/service/player/config"
+
+require "carps/service/start/mailer"
+
+Given /^a dm game config, for mod (.+)$/ do |mod|
+   $game_config = DM::GameConfig.new "save_test", mod, "fun campaign", "game about stuff", $session.key, "dm@dm.dm"
+end
+
+Then /^resume the mod$/ do
+   game = $game_config.spawn
+   game.resume ModMailer.new nil, $game_config
+end
+
+Then /^load the DM mod$/ do
+   $game_config = DM::GameConfig.load "games/save_test.yaml"
+end
+
+Then /^load the Player mod$/ do
+   $game_config = Player::GameConfig.load "games/save_test.yaml"
+end
+
+Given /^a player game config, for mod (.+)$/ do |mod|
+   $game_config = Player::GameConfig.new "save_test", mod, "the dm", "game about stuff", $session.key
+end

data/features/steps/parser.rb

@@ -0,0 +1,23 @@
+require "carps/protocol"
+
+require "carps/service"
+
+When /^an invitation is sent$/ do
+   $message = Invite.new "the dm", "the mod", "the description", "The session" 
+end
+
+Given /^a parser$/ do
+   $parser = Player::parser 
+end
+
+Then /^emit the message$/ do
+   $mail = $message.emit
+end
+
+Then /^parse the message$/ do
+   message = $parser.parse $mail
+   newmsg = message.emit
+   unless $mail == newmsg
+      raise StandardError, "Did not correctly parse invite:\nold emitings:\n#{$mail}\nnew emittings:\n#{newmsg}"
+   end
+end

data/features/steps/persistent_protocol.rb

@@ -0,0 +1,29 @@
+require "carps/protocol/message"
+
+class TestMessage < Message
+end
+
+Given /^a persistent message$/ do
+   $message = TestMessage.new
+   $message.from = "someone"
+end
+
+Then /^save the message, noting the file name$/ do
+   $file = $message.save "BLAHBLAHBLAH"
+end
+
+Then /^make sure the file exists$/ do
+   unless File.exists?($file)
+      raise StandardError, "TestMessage did not save itself."
+   end
+end
+
+Then /^delete the message$/ do
+   $message.delete
+end
+
+Then /^make sure the file was deleted$/ do
+   if File.exists?($file)
+      raise StandardError, "TestMessage did not delete itself."
+   end
+end

data/features/steps/player.rb

@@ -0,0 +1,82 @@
+require "carps/mod/player/mod"
+require "carps/mod/player/interface"
+
+require "carps/mod/client_turn"
+require "carps/mod/status_report"
+
+class PlayerTestMod < Player::Mod
+   def schema
+      $schema
+   end
+
+   def description
+      <<-END
+You are testing the CARPS player mod system and interface.
+This text was returned by the description method of the test mod.
+
+You are about to fill in a character sheet for the 'fruit' game used
+throughout the CARPS testing utility.
+END
+   end
+
+end
+
+class PlayerModTestMailer
+   def relay message
+      puts "Sending:"
+      puts message.emit
+   end
+
+   def check type
+      mail = @mail
+      @mail = nil
+      return mail
+   end
+
+   def turn t
+      @mail = t
+   end
+
+   def save mod
+      puts "Saving"
+      puts mod.to_s
+   end
+
+end
+
+Then /^test all inputs to the player's interface$/ do
+   commands = []
+   commands.push [:act]
+   commands.push [:edit]
+   commands.push [:sheet]
+   test_interface $interface, commands
+end
+
+
+Given /^a player test mailer$/ do
+   $mailer = PlayerModTestMailer.new 
+end
+
+Given /^a player mod$/ do
+   $mod = PlayerTestMod.new
+   $mod.mailer = $mailer
+end
+
+When /^the player receives turn information$/ do
+   status = StatusReport.new "You are a player don't you know!"
+   questions = [Question.new("Who are you, you strange man?")]
+   t = ClientTurn.new Sheet::NewSheet.new({}), status, questions
+   $mailer.turn t 
+end
+
+Given /^a player interface$/ do
+   $interface = Player::Interface.new $mod
+end
+
+Then /^present a user interface to the player$/ do
+   begin
+      $interface.run
+   rescue SystemExit => e
+      "Quit program: #{e}"
+   end
+end

data/features/steps/player_turn.rb

@@ -0,0 +1,56 @@
+require "carps/mod"
+
+require "carps/protocol"
+
+Given /^a status report$/ do
+   $status = StatusReport.new "This is some might important information here!"
+end
+
+Then /^the status report should be printed$/ do
+   $status.display
+end
+
+Given /^a question$/ do
+   $question = Question.new "What do you do?"
+end
+
+Given /^a parser for the turn$/ do
+   $parser = MessageParser.new [ClientTurn]
+end
+
+Then /^the question should be asked$/ do
+   ans = Answers.new
+   $question.ask ans
+   puts "Our conversation:"
+   ans.display
+end
+
+Given /^a status report and a number of questions$/ do
+   s = StatusReport.new "Halt, mortal!"
+   q1 = Question.new "Who are you?"
+   q2 = Question.new "What are you doing here?"
+   $turn = ClientTurn.new Sheet::NewSheet.new({}), s, [q1, q2]
+end
+
+When /^a turn is sent$/ do
+   $message = $turn
+end
+
+Given /^answers from a player's turn$/ do
+   $message = Answers.new({"What do you do?" => "Things!", "Who are you?" => "me."})
+end
+
+Given /^a parser for the answers$/ do
+   $parser = MessageParser.new [Answers]
+end
+
+Then /^all the questions should be asked$/ do
+   class Tester
+      def send to, answers
+         puts "To be sent to #{to}"
+         answers.display
+      end
+   end
+   tester = Tester.new
+   tester.send "dungeon master", $turn.take
+end

data/features/steps/random.rb

@@ -0,0 +1,47 @@
+require "carps/mod/dice"
+
+require "carps/mod/interface"
+
+def fill_randoms n
+   $randoms = []
+   n.times do
+      $randoms.push yield
+   end
+end
+
+Given /^(\d+) random integers between (\d+) and (\d+)$/ do |n, min, max|
+   n = n.to_i
+   min = min.to_i
+   max = max.to_i
+   fill_randoms n do
+      Dice::rint min, max
+   end
+end
+
+Given /^(\d+) random floats between (\d+) and (\d+)$/ do |n, min, max|
+   n = n.to_i
+   min = min.to_f
+   max = max.to_f
+   fill_randoms n do
+      Dice::rfloat min, max
+   end
+end
+
+Then /^ensure each of the random numbers are between (.+) and (.+)$/ do |min, max|
+   min = min.to_i
+   max = max.to_i
+   works = $randoms.all? do |i|
+      i >= min and i <= max
+   end
+   unless works
+      raise StandardError, "Random generator is fucked."
+   end
+end
+
+Given /^an interface to dice rolling$/ do
+   $interface = RolePlayInterface.new
+end
+
+Then /^launch the probabalistic interface$/ do
+   $interface.run
+end

data/features/steps/rule.rb

@@ -0,0 +1,53 @@
+require "carps/mod"
+
+class OneTenAction < CARPS::Action
+
+   def summary
+      "The result was between one and ten."
+   end
+
+   def execute roll, sheet
+      puts "Executing, roll was #{roll}, sheet was #{sheet}"
+   end
+
+end
+
+class ElevenThirtyAction < CARPS::Action
+
+   def summary
+      "The result was between eleven and thirty."
+   end
+
+   def execute roll, sheet
+      puts "Executing, roll was #{roll}, sheet was #{sheet}"
+   end
+
+end
+
+class TestRule < CARPS::Rule
+
+   def initialize
+      super
+      add_action 1..10, OneTenAction
+      add_action :>=, 11, ElevenThirtyAction
+   end
+
+   protected
+
+   def dice sheet
+      CARPS::Dice::d 30
+   end
+
+end
+
+Then /^show the odds for the rule$/ do
+   $rule.show_odds $sheet
+end
+
+Given /^a rule which operates on a character sheet$/ do
+   $rule = TestRule.new
+end
+
+Then /^apply the rule$/ do
+   $rule.apply $sheet
+end