carbonmu 0.0.1

data/spec/lib/core/connection_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Connection do
+  let(:id) { "foo" }
+  let(:connection) { Connection.new(id) }
+  let(:message) { "Watson, come here" }
+  let(:expected_sent_message) { "Watson, come here\n"}
+  let(:player) { double(Player) }
+
+  context ".id" do
+    it "has an ID" do
+      expect(connection.id).to eq(id)
+    end
+
+    it "won't let you set the ID" do
+      expect { connection.id = id }.to raise_exception(NameError)
+    end
+  end
+
+  context ".locale" do
+    it "has a locale" do
+      expect(connection.locale).to eq("en")
+    end
+
+    it "lets you set the locale" do
+      c = Connection.new(id)
+      c.locale = "nl"
+      expect(c.locale).to eq("nl")
+    end
+  end
+
+  context ".write_translated" do
+    it "sends .write to CarbonMU.server" do
+      expect(I18n).to receive(:t) { message }
+      server = stub_carbonmu_server
+      expect(server).to receive(:write_to_connection).with(id, expected_sent_message)
+      connection.write_translated(message)
+    end
+  end
+
+  context ".player" do
+    it "is nil for new connections" do
+      expect(connection.player).to eq(nil)
+    end
+  end
+end

data/spec/lib/core/internationalization_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Internationalization do
+
+  context ".setup" do
+    include FakeFS::SpecHelpers
+
+    it "loads the right loadpath" do
+      FileUtils.mkdir_p("config/locales")
+      FileUtils.touch("config/locales/boo.yml")
+      CarbonMU::Internationalization.setup
+      expect(I18n.load_path).to eq(["/config/locales/boo.yml"])
+    end
+  end
+
+  context ".translate" do
+    it "calls I18n.t" do
+      str = "foo"
+      opts = {foo: "bar"}
+      expect(I18n).to receive(:t).with(str, [opts])
+      CarbonMU::Internationalization.translate(str, opts)
+    end
+  end
+end

data/spec/lib/core/parser_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Parser do
+  class ParseTestCommand < Command
+    syntax "testing_good_command"
+  end
+
+  let (:connection) { double(Connection).as_null_object }
+
+  context '.parse_and_execute' do
+    it "handles a bad command" do
+      expect_any_instance_of(UnknownCommand).to receive(:execute)
+
+      subject.parse_and_execute(connection, "DEFINITELY_NEVER_GOING_TO_BE_A_GOOD_COMMAND")
+    end
+
+    it "calls .execute on a good command" do
+      expect_any_instance_of(ParseTestCommand).to receive(:execute)
+      subject.parse_and_execute(connection, "testing_good_command")
+    end
+  end
+
+  context '.register_syntax' do
+    it "remembers a given syntax and class" do
+      class TestEmptyClass; end
+      Parser.register_syntax("foo", TestEmptyClass)
+      expect(Parser.syntaxes["foo"]).to eq(TestEmptyClass)
+    end
+  end
+end

data/spec/lib/core/server_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Server do
+  context "minimal objects" do
+    it "should create the starter Room" do
+      r = Room.where(_special: :starting_room).first
+      expect(r.class).to eq(Room)
+      expect(r.name).to eq("Starting Room")
+      expect(r.description).to eq("This is the starting room for newly-created players. Feel free to rename and re-describe it.")
+    end
+
+    it "should create the lost & found Room" do
+      r = Room.where(_special: :lostandfound_room).first
+      expect(r.class).to eq(Room)
+      expect(r.name).to eq("Lost & Found Room")
+      expect(r.description).to eq("This is the room where objects and players go if the thing that was holding them gets destroyed.")
+    end
+
+    it "should create the superadmin player" do
+      p = Player.where(_special: :superadmin_player).first
+      expect(p.class).to eq(Player)
+      expect(p.name).to eq("Superadmin")
+      expect(p.description).to eq("Obviously the most powerful of his race, it could kill us all.")
+    end
+  end
+
+  context "connections" do
+    it "temporarily should set new connections to be the super-admin" do #TODO
+      s = Server.new(true)
+      s.add_connection(1)
+      c = s.connections.first
+      expect(c.player).to eq(Player.superadmin)
+    end
+  end
+end

data/spec/lib/edge_router/edge_connection_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe EdgeConnection do
+  it "has a unique id" do
+    c1 = EdgeConnection.new
+    c2 = EdgeConnection.new
+    expect(c1.id).to_not eq(c2)
+  end
+end

data/spec/lib/game_objects/container_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+class MyContainer
+  include Container
+end
+
+describe MyContainer do
+  it_behaves_like "a Container"
+end

data/spec/lib/game_objects/exit_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Exit do
+  it_behaves_like "a GameObject or descendant"
+  it_behaves_like "a Movable"
+  it { is_expected.to belong_to(:destination).of_type(Exit).as_inverse_of(:incoming_exits).with_index }
+end

data/spec/lib/game_objects/game_object_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe GameObject do
+  it_behaves_like "a GameObject or descendant"
+
+  context ".description" do
+    it "has a default description" do
+      g = GameObject.new
+      expect(g.description).to eq("You see nothing special.")
+    end
+  end
+end

data/spec/lib/game_objects/movable_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+class MyMovable
+  include Movable
+end
+
+describe MyMovable do
+  it_behaves_like "a Movable"
+end

data/spec/lib/game_objects/player_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Player do
+  it_behaves_like "a GameObject or descendant"
+  it_behaves_like "a Movable"
+  it_behaves_like "a Container"
+
+  it "gets a location of the starter room if not otherwise specified" do
+    p = Player.create!(location: nil)
+    expect(p.location).to eq(Room.starting)
+  end
+
+  it "still can be given a location" do
+    r = Room.create!
+    p = Player.create!(location: r)
+    expect(p.location).to eq(r)
+  end
+
+  context ".superadmin" do
+    it "returns the actual superadmin player" do
+      expect(Player.superadmin._special).to eq(:superadmin_player)
+    end
+  end
+end

data/spec/lib/game_objects/room_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Room do
+  it_behaves_like "a GameObject or descendant"
+  it_behaves_like "a Container"
+
+  it { is_expected.to have_many(:incoming_exits).of_type(Exit).with_foreign_key(:destination) }
+
+  context ".starting" do
+    it "returns the actual starting room" do
+      expect(Room.starting._special).to eq(:starting_room)
+    end
+  end
+
+  context ".lostandfound" do
+    it "returns the actual lost & found room" do
+      expect(Room.lostandfound._special).to eq(:lostandfound_room)
+    end
+  end
+end

data/spec/lib/game_objects/thing_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Thing do
+  it_behaves_like "a GameObject or descendant"
+  it_behaves_like "a Movable"
+  it_behaves_like "a Container"
+end

data/spec/lib/interactions/notify_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Notify do
+  before(:each) do
+    @server = stub_carbonmu_server
+    allow(@server).to receive(:connections) { [connection1, connection2] }
+  end
+
+  let(:connection1) { double(Connection) }
+  let(:connection2) { double(Connection) }
+
+  context '.all' do
+    it "writes to all connections with the input specified" do
+      expect(connection1).to receive(:write_translated).with("foo", {})
+      expect(connection2).to receive(:write_translated).with("foo", {})
+      Notify.all("foo")
+    end
+  end
+
+  context '.one' do
+    it "writes to the connection specified with the input" do
+      expect(connection1).to receive(:write_translated).with("foo", {})
+      Notify.one(connection1, "foo")
+    end
+  end
+end

data/spec/lib/interactions/reboot_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Reboot do
+  it "notifies all of reboot and signals server" do
+    expect(Notify).to receive(:all).with(/Rebooting, please wait/)
+    expect(Server).to receive(:trigger_reboot)
+    Reboot.reboot
+  end
+end

data/spec/lib/ipc/carbon_ipc_socket_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe CarbonIPCSocket do
+  it_behaves_like "a CarbonIPCSocket implementation"
+
+  it "closes a socket if one is defined" do
+    sock = CarbonIPCSocket.new
+    sock.zmq_socket = double("socket")
+    expect(sock.zmq_socket).to receive(:close)
+    sock.close
+  end
+end

data/spec/lib/ipc/ipc_message_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe IPCMessage do
+  it "sets its operation properly" do
+    ipc = IPCMessage.new(:started)
+    expect(ipc.op).to eq(:started)
+  end
+
+  it "supports equality" do
+    ipc1 = IPCMessage.new(:write, connection_id: "123", output: "foo")
+    ipc2 = IPCMessage.new(:write, connection_id: "123", output: "foo")
+    expect(ipc1).to eq(ipc2)
+  end
+
+  it "accepts op parameters" do
+    ipc = IPCMessage.new(:write, connection_id: "123", output: "foo")
+    expect(ipc.params[:connection_id]).to eq("123")
+    expect(ipc.params[:output]).to eq("foo")
+  end
+
+  it "supports direct method access for op parameters" do
+    ipc = IPCMessage.new(:write, connection_id: "123", output: "foo")
+    expect(ipc.params[:connection_id]).to eq(ipc.connection_id)
+  end
+
+  it "enforces required op parameters" do
+    expect { IPCMessage.new(:write, connection_id: '123') }.to raise_error(ArgumentError,/output/)
+  end
+
+  it "raises if given an unknown op" do
+    expect { IPCMessage.new(:definitely_not_a_good_op) }.to raise_error(ArgumentError,/definitely_not_a_good_op/)
+  end
+
+  it "knows how to serialize and unserialize itself" do
+    original = IPCMessage.new(:write, connection_id: "123", output: "foo")
+    round_trip = IPCMessage.unserialize(original.serialize)
+    expect(round_trip).to eq(original)
+  end
+end

data/spec/lib/ipc/read_socket_spec.bak

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe ReadSocket do
+  it_behaves_like "a CarbonIPCSocket implementation"
+
+  it "raises on send(msg)" do
+    expect { ReadSocket.new.send('foo') }.to raise_error(NotImplementedError)
+  end
+
+  it "reads from the underlying socket" do
+    sock = ReadSocket.new
+    sock.zmq_socket = double("zmq")
+    sock.zmq_socket.should_receive(:read)
+    sock.read
+  end
+
+  it "attempts to BIND to tcp://127.0.0.1:<specified port>" do
+    port_number = rand(10000..20000)
+    zmqsocket = double("zmqsocket")
+    zmqsocket.stub(:connect).with(anything)
+    zmqsocket.should_receive(:bind).with("tcp://127.0.0.1:#{port_number}")
+    Celluloid::ZMQ::PullSocket.stub(:new) { zmqsocket }
+    ReadSocket.new(port_number)
+  end
+
+  it "knows its own port number" do
+    port_number = rand(10000..20000)
+    r = ReadSocket.new(port_number)
+    r.port_number.should eq(port_number)
+  end
+
+  context "ephemeral ports" do
+    it "supports binding to an ephemeral port" do
+      zmqsocket = double("zmqsocket")
+      zmqsocket.stub(:bind).with(anything)
+      zmqsocket.should_receive(:bind).with("tcp://127.0.0.1:*")
+      Celluloid::ZMQ::PullSocket.stub(:new) { zmqsocket }
+      ReadSocket.new
+    end
+
+    it "returns a valid port number when bound to an ephemeral port" do
+      ReadSocket.new.port_number.should be_between(1024,65535)
+    end
+
+    it "returns a different port number on successive instantiations" do
+      r1 = ReadSocket.new
+      r2 = ReadSocket.new
+      r1.port_number.should_not eq(r2.port_number)
+    end
+  end
+end

data/spec/lib/ipc/write_socket_spec.bak

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe WriteSocket do
+  it_behaves_like "a CarbonIPCSocket implementation"
+
+  it "raises on read" do
+    expect { WriteSocket.new.read }.to raise_error(NotImplementedError)
+  end
+
+  it "writes to the underlying socket" do
+    sock = WriteSocket.new
+    sock.zmq_socket = double("zmq")
+    expect(sock.zmq_socket).to receive(:send).with("foo")
+    sock.send("foo")
+  end
+
+  it "attempts to CONNECT to tcp://127.0.0.1:<specified port>" do
+    port_number = rand(10000..20000)
+    zmqsocket = double("zmqsocket")
+    allow(zmqsocket).to receive(:bind)
+    expect(zmqsocket).to receive(:connect).with("tcp://127.0.0.1:#{port_number}")
+    allow(Celluloid::ZMQ::PushSocket).to receive(:new) { zmqsocket }
+    WriteSocket.new(port_number)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,118 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+
+ENV['MONGOID_ENV'] = "testing"
+
+require 'bundler'
+require 'timecop'
+require_relative '../lib/carbonmu.rb'
+require 'pry'
+require 'mongoid-rspec'
+require 'database_cleaner'
+require 'fakefs/spec_helpers'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+include CarbonMU
+CarbonMU.configure do |c|
+  c.logger = Logger.new(nil)
+end
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.filter_run_excluding :i18n => true
+  config.raise_errors_for_deprecations!
+  config.include Helpers
+  config.include Mongoid::Matchers
+
+  config.before(:suite) do
+    Server.initialize_database
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      Server.create_starter_objects
+      example.run
+    end
+  end
+
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  # config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = false
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end