carps 0.2.1

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,170 @@
+include CARPS
+
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to "(.*)"/ do |env_var, value|
+  ENV[env_var] = value
+end
+
+Given /"(.*)" folder is deleted/ do |folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  in_project_folder do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end

data/features/steps/character_sheet.rb

@@ -0,0 +1,89 @@
+require "carps/mod"
+
+Given /^a character sheet schema$/ do
+   $schema =Sheet::Schema.new(
+      {"name" => "text",
+       "fruit" => "text",
+       "days old" => "integer"
+      })
+end
+
+Given /^a sheet editor$/ do
+   $editor = Sheet::Editor.new $schema, Sheet::UserVerifier.new 
+end
+
+Then /^fill in the character sheet$/ do
+   $sheet = Sheet::Character.new 
+   $editor.fill $sheet
+end
+
+Then /^edit the character sheet again$/ do
+   $editor.fill $sheet
+end
+
+When /^a valid sheet is provided$/ do
+   $sheet = Sheet::Character.new({"name" => "billy", "fruit" => "apple", "days old" => 11})
+end
+
+When /^an invalid sheet is provided$/ do
+   $sheet = Sheet::Character.new({"name" => "billy", "fruit" => "apple", "days old" => "many"})
+end
+
+
+Then /^do not accept the invalid sheet$/ do
+   valid = $editor.valid? $sheet
+   if valid
+      raise StandardError, "Passed invalid sheet"
+   end
+end
+
+When /^an parsable sheet is provided$/ do
+   stats = <<-END
+Name: A
+Biography: 
+The Readies: 0
+The Old Grey Matter: 0
+The Outer Crust: 0
+Vim & Vigour: 0
+Luck: 0
+Chances: 0
+Romantic Resistance: 0
+Tolerance for Alcohol: 0
+Conscience: 0
+Etiquette: 0
+Gentleman's Gentleman: 
+Sports Car: 
+Student of the Turf: false
+Specialist Interest: 
+Connections: 
+Difficult Relation: 
+Good Sportsman: 
+END
+   $input = V.character_sheet stats
+end
+
+Then /^parse the sheet$/ do
+   sheet, blob = Sheet::NewSheet.parse $input
+   puts "Parsed:"
+   sheet.display
+end
+
+When /^an unparsable sheet is provided$/ do
+   $input = V.character_sheet "a: a: a"
+end
+
+Then /^do not parse the sheet$/ do
+   begin
+      Sheet::NewSheet.parse $input
+      raise Exception, "Parsed the sheet!"
+   rescue Expected => e
+      puts e.message
+   end
+end
+
+Then /^accept the valid sheet$/ do
+   valid = $editor.valid? $sheet
+   unless valid
+      raise StandardError, "Failed valid sheet."
+   end
+end

data/features/steps/crash.rb

@@ -0,0 +1,27 @@
+require "carps/util"
+
+Given /^a proc that won't crash$/ do
+   $proc = lambda {}
+end
+
+Then /^the crash reporter won't report a crash$/ do
+   CARPS::with_crash_report do
+      $proc.call
+   end
+end
+
+Given /^a proc that will crash$/ do
+   $proc = lambda do
+      raise StandardError, "This is a delibrate crash caused for testing purposes."
+   end
+end
+
+Then /^the crash reporter will report a crash$/ do
+   begin
+      CARPS::with_crash_report true do
+         $proc.call
+      end
+   rescue SystemExit => e
+      puts "Recovered from system exit."
+   end
+end

data/features/steps/crypt.rb

@@ -0,0 +1,166 @@
+# Test cryptography mechanism
+
+require "carps/service"
+
+require "carps/crypt/mailer"
+require "carps/crypt/mailbox"
+require "carps/crypt/default_messages"
+
+require "carps/protocol/message"
+
+require "carps/util/init"
+
+require "carps/service/session"
+
+require "fileutils"
+
+require "thread"
+
+class EvilMessage < Message
+
+   def emit
+      "EVIL"
+   end
+
+   def EvilMessage.parse blob
+      if blob.match(/EVIL/)
+         return [EvilMessage.new, ""]
+      else
+         raise Expected, "Could not parse evil message."
+      end
+   end
+
+end
+
+class TwistedMailbox < Mailbox
+   def forget person
+      @peers.delete person
+   end
+end
+
+class TwistedMailer < Mailer
+
+   # Expect someone else will begin the handshake
+   #
+   # British stereotype?
+   def expect_handshake
+      handshake = @mailbox.insecure_read Handshake
+      handle_handshake handshake
+   end
+
+   # Send an evil message.  The recipent should drop this.
+   def evil to, message
+      text = message.emit
+      # Sign the message
+      digest = Digest::MD5.digest text
+      puts "sent digest (as part of an evil scheme): " + digest
+      new_key = OpenSSL::PKey::DSA.new 2048
+      sig = new_key.syssign digest
+      mail = (V.addr @addr) + (V.sig sig) + (V.session "") + text + K.end
+      @mailbox.send to, mail
+      puts "Message sent to " + to
+   end
+
+   def forget person
+      @mailbox.forget person
+   end
+end
+
+class TestSender
+
+   def send to, message
+      @receiver.receive message
+   end
+
+   def send_to receiver
+      @receiver = receiver
+   end
+
+end
+
+class TestReceiver
+
+   def receive message
+      @message = message
+   end
+
+   def connect
+      puts "Pretending to connect."
+   end
+
+   def read
+      until @message
+         sleep 1
+      end
+      message = @message
+      @message = nil
+      [message]
+   end
+
+end
+
+def delete_keys 
+   path = $CONFIG + "/.peers/"
+   paths = files path
+   paths.each do |path|
+      FileUtils.rm path
+   end
+end
+
+Given /^two peers, Alice and Bob$/ do
+   receive_alice = TestReceiver.new
+   receive_bob = TestReceiver.new
+   send_bob = TestSender.new
+   send_bob.send_to receive_alice
+   send_alice = TestSender.new
+   send_alice.send_to receive_bob
+
+   $alice_address = "alice"
+   $bob_address = "bob"
+
+   # Alice's stuff
+   CARPS::init 0, "test/server"
+   delete_keys
+   $alice_box = Mailbox.new send_bob, receive_bob, MessageParser.new(default_messages), SessionManager.new
+   $alice = TwistedMailer.new $alice_address, $alice_box
+
+   # Bob's stuff
+   CARPS::init 0, "test/client"
+   delete_keys
+   $bob_box = TwistedMailbox.new send_alice, receive_alice, MessageParser.new(default_messages.push EvilMessage), SessionManager.new
+   $bob = TwistedMailer.new $bob_address, $bob_box
+end
+
+Then /^Alice initiates a handshake request and Bob accepts$/ do
+   Thread.fork { $alice.handshake $bob_address }
+   $bob.expect_handshake
+end
+
+Then /^bob tries to receive the message$/ do
+   thrd = Thread.fork do
+      loop do
+         $bob.check EvilMessage
+         sleep 1
+      end
+   end
+   UI::highlight "PRESS ENTER TO STOP CHECKING BOB'S MAIL"
+   UI::question ""
+   thrd.kill
+end
+
+Then /^a hacker pretending to be Alice sends a nefarious message to Bob$/ do
+   $alice.evil $bob_address, EvilMessage.new
+end
+
+Then /^a spoofer pretending to be Bob tries to make a handshake with Alice$/ do
+   $bob.forget $alice_address 
+   Thread.fork { $bob.handshake $alice_address }
+   $alice.expect_handshake
+end
+
+When /^the user presses enter, threading stops$/ do
+   UI::highlight "PRESS ENTER TO STOP"
+   UI::question ""
+   $bob.shutdown
+   $alice.shutdown
+end

data/features/steps/dice.rb

@@ -0,0 +1,91 @@
+require "carps/mod"
+
+include CARPS::Dice
+
+Then /^show the odds$/ do
+   $odds = $dice.odds
+   puts $odds
+end
+
+Given /^a d(\d+)$/ do |sides|
+   $dice = d sides.to_i
+end
+
+Then /^multiply by (\d+)$/ do |n|
+   $dice * n.to_i
+end
+
+Then /^multiply by (\d+) \/ (\d+)$/ do |num, den|
+   $dice * (num.to_f / den.to_f)
+end
+
+Then /^add (\d+)$/ do |n|
+   $dice + n.to_i
+end
+
+Then /^add a d(\d+)$/ do |sides|
+   $dice + CARPS::Dice::d(sides.to_i)
+end
+
+Then /^subtract a d(\d+)$/ do |sides|
+   $dice - CARPS::Dice::d(sides.to_i)
+end
+
+Then /^divide by (\d+)$/ do |n|
+   $dice / n.to_i
+end
+
+Then /^if it's greater or equal to (\d+), and less than or equal to (\d+), the result is (\d+)$/ do |gte, lte, out|
+   $dice.in_range gte.to_i..lte.to_i, out.to_i
+end
+
+Then /^if it's greater than (\d+), the result is (\d+)$/ do |compare, result|
+   $dice.is :>, compare.to_i, result.to_i
+end
+
+Then /^multiply by a d(\d+)$/ do |sides|
+   $dice * CARPS::Dice::d(sides.to_i)
+end
+
+Then /^divide by a d(\d+)$/ do |sides|
+   $dice / CARPS::Dice::d(sides.to_i)
+end
+
+Then /^if it's greater or equal to (\d+), and less than or equal to (\d+), the result is a d(\d+)$/ do |gte, lte, sides|
+   $dice.in_range gte.to_i..lte.to_i, CARPS::Dice::d(sides.to_i)
+end
+
+Then /^result (\d+) must be (\d+)$/ do |index, expect|
+   results = $odds.keys.sort
+   unless results[index.to_i] == expect.to_i
+      raise StandardError, "Unexpected result!"
+   end
+end
+
+Then /^each of the odds must be (\d+) \/ (\d+)$/ do |num, den|
+   odds = $odds.values
+   odds.each do |odd|
+      unless odd == num.to_f / den.to_f
+         raise StandardError, "Unexpected odds"
+      end
+   end
+end
+
+Then /^odd (\d+) must be (\d+) \/ (\d+)$/ do |index, num, den|
+   results = $odds.keys.sort
+   odds = results.map {|result| $odds[result]}
+   unless odds[index.to_i] == num.to_f / den.to_f
+      raise StandardError,  "Unexpected odd"
+   end
+end
+
+Then /^result (\d+) must be \-(\d+)$/ do |index, expect|
+   results = $odds.keys.sort
+   unless results[index.to_i] == - expect.to_i
+      raise StandardError, "Unexpected result!"
+   end
+end
+
+Then /^roll the dice$/ do
+   puts "The dice roll reads: #{$dice.roll}"
+end

data/features/steps/dm.rb

@@ -0,0 +1,147 @@
+require "carps/mod"
+
+require "carps/service"
+
+require "yaml"
+
+class TestMod < DM::Mod
+   def schema
+      $schema
+   end
+
+   def update_barry status
+      @reporter.update_player "barry", status
+   end
+
+end
+
+class TestMailer < DM::Mailer
+
+   def initialize
+      @dm = "johnny"
+      @about = "game description"
+      @session = "123"
+      @mod = "cool"
+   end
+
+   def relay addr, mail
+      puts "Sending to #{addr}:"
+      puts mail.emit
+   end
+
+   def save mod
+      puts "Saving: #{mod.to_yaml}" 
+   end
+
+   def barry
+      @sheet = Sheet::NewSheet.new({"name" => "bob", "fruit" => "kumquat", "days old" => 12})
+      @sheet.from = "barry"
+   end
+
+   def read klass, from=nil
+      msg = nil
+      until msg
+         msg = check
+         sleep 1
+      end
+      msg
+   end
+
+   def check klass, from=nil
+      if @sheet
+         sheet = @sheet
+         @sheet = nil
+         return sheet
+      end
+   end
+
+end
+
+Given /^a DM mod$/ do
+   resource = Resource.new "resource"
+   $mailer = TestMailer.new
+   $mod = TestMod.new resource
+   $mod.mailer = $mailer
+end
+
+$email = "barry@doodah.xxx"
+
+When /^(.+) joins the mod$/ do |name|
+   $mailer.barry
+end
+
+Then /^set (.+)'s status conditionally$/ do |name|
+   player = $mod.player_stats(name)
+   $mod.update_barry "You are a #{player["fruit"]}"
+end
+
+Then /^preview player turns$/ do
+   $mod.inspect_reports
+end
+
+Then /^check barry's sheet$/ do
+   received = false
+   until received
+      received = $mod.check_mail
+      sleep 1
+   end
+end
+
+Given /^a DM interface$/ do
+   $interface = DM::Interface.new $mod
+end
+
+Then /^test all inputs to interface$/ do
+   commands = []
+   commands.push [:invite, "carps@killersmurf.com"]
+   commands.push [:mail]
+   commands.push [:done]
+   commands.push [:players]
+   commands.push [:npcs]
+   commands.push [:describe, "bob"]
+   commands.push [:describe, "barry"]
+   commands.push [:spawn, "orange", "dick"]
+   commands.push [:describe, "dick"]
+   commands.push [:describe, "bob"]
+   commands.push [:npcs]
+   commands.push [:players]
+   commands.push [:done]
+   commands.push [:warp, "cave"]
+   commands.push [:warp, "hello"]
+   commands.push [:decree]
+   commands.push [:tell, "barry"]
+   commands.push [:tell, "bob"]
+   commands.push [:census]
+   commands.push [:edit, "bob"]
+   commands.push [:edit, "bob"]
+   commands.push [:edit, "barry"]
+   commands.push [:edit, "dick"]
+   commands.push [:survey]
+   commands.push [:ask, "bob"]
+   commands.push [:ask, "barry"]
+   commands.push [:inspect, "bob"]
+   commands.push [:inspect, "barry"]
+   commands.push [:nuke]
+   commands.push [:silence]
+   commands.push [:futile]
+   commands.push [:remit, "bob"]
+   commands.push [:remit, "barry"]
+   commands.push [:supress, "bob"]
+   commands.push [:supress, "barry"]
+   commands.push [:done]
+   commands.push [:save]
+   test_interface $interface, commands
+end
+
+Then /^present a user interface to the DM$/ do
+   $interface.run
+end
+
+Then /^create an NPC called (.+) of type (.+)$/ do |name, type|
+   $mod.new_npc type, name
+end
+
+Then /^report the strength of the NPC (.+) to (.+)$/ do |npc_name, name|
+   npc = $mod.npc_stats npc_name
+   $mod.update_player name, "#{npc_name}'s strength is #{npc["strength"]}"
+end