objectified_sessions 1.0.0

data/spec/objectified_sessions/helpers/controller_helper.rb

@@ -0,0 +1,55 @@
+module ObjectifiedSessions
+  module Helpers
+    module ControllerHelper
+      def new_spec_controller_instance
+        klass = Class.new(::ActionController::Base)
+        klass_name = "SpecController#{rand(1_000_000_000)}"
+        ::Object.const_set(klass_name, klass)
+
+        underlying_session = double("underlying_session")
+
+        instance = klass.new
+        allow(instance).to receive(:session).with().and_return(underlying_session)
+        instance
+      end
+
+      def define_objsession_class(name = nil, &block)
+        @objsession_class = Class.new(::ObjectifiedSessions::Base)
+        @objsession_class.class_eval(&block)
+
+        if name
+          ::Object.send(:remove_const, name) if ::Object.const_defined?(name)
+          ::Object.send(:const_set, name, @objsession_class)
+        end
+
+        ::ObjectifiedSessions.session_class = @objsession_class
+      end
+
+      def set_new_controller_instance
+        @controller_instance = new_spec_controller_instance
+        @controller_class = @controller_instance.class
+        @controller_class_name = @controller_class.name
+        @underlying_session = @controller_instance.session
+      end
+
+      def should_be_using_prefix(prefix, should_require_set = false)
+        prefix_set = (! should_require_set)
+
+        if should_require_set
+          expect(@underlying_session).to receive(:[]=).once.with(prefix, { }) do
+            prefix_set = true
+          end
+        end
+
+        @prefixed_underlying_session = double("prefixed_underlying_session")
+        allow(@underlying_session).to receive(:[]).with(prefix) do
+          if prefix_set
+            @prefixed_underlying_session
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/objectified_sessions/helpers/exception_helpers.rb

@@ -0,0 +1,20 @@
+module ObjectifiedSessions
+  module Helpers
+    module ExceptionHelpers
+      def capture_exception(required_class = Exception, &block)
+        e = nil
+        begin
+          block.call
+        rescue required_class => x
+          e = x
+        end
+
+        unless e
+          raise "Expected an exception of class #{required_class.inspect}, but none was raised"
+        end
+
+        e
+      end
+    end
+  end
+end

data/spec/objectified_sessions/system/basic_system_spec.rb

@@ -0,0 +1,135 @@
+require 'objectified_sessions'
+require "objectified_sessions/helpers/controller_helper"
+require "objectified_sessions/helpers/exception_helpers"
+
+describe "ObjectifiedSessions basic operations" do
+  include ObjectifiedSessions::Helpers::ControllerHelper
+  include ObjectifiedSessions::Helpers::ExceptionHelpers
+
+  before :each do
+    set_new_controller_instance
+  end
+
+  it "should have an object at #objsession, even with an empty class" do
+    define_objsession_class { }
+    @controller_instance.objsession.should be
+  end
+
+  it "should allow setting and getting a defined field, and read/write that on the underlying session" do
+    define_objsession_class { field :foo }
+
+    expect(@underlying_session).to receive(:[]=).once.with('foo', 123)
+    @controller_instance.objsession.foo = 123
+
+    expect(@underlying_session).to receive(:[]).once.with('foo').and_return(234)
+    @controller_instance.objsession.foo.should == 234
+  end
+
+  it "should allow specifying a defined field as a String" do
+    define_objsession_class { field 'FoO' }
+
+    expect(@underlying_session).to receive(:[]=).once.with('FoO', 123)
+    @controller_instance.objsession.foo = 123
+
+    expect(@underlying_session).to receive(:[]).once.with('FoO').and_return(234)
+    @controller_instance.objsession.foo.should == 234
+  end
+
+  it "should allow hash access to the underlying session" do
+    define_objsession_class do
+      field :foo, :visibility => :private
+
+      def set_foo(x)
+        self[:foo] = x
+      end
+
+      def get_foo
+        self[:foo]
+      end
+    end
+
+    expect(@underlying_session).to receive(:[]=).once.with('foo', 123)
+    @controller_instance.objsession.set_foo(123)
+
+    expect(@underlying_session).to receive(:[]).once.with('foo').and_return(234)
+    @controller_instance.objsession.get_foo.should == 234
+  end
+
+  it "should tell you what fields are defined, and which have data" do
+    define_objsession_class do
+      field :foo
+      field :bar
+    end
+
+    @controller_instance.objsession.field_names.sort_by(&:to_s).should == [ :foo, :bar ].sort_by(&:to_s)
+
+    expect(@underlying_session).to receive(:[]).once.with('foo').and_return(123)
+    expect(@underlying_session).to receive(:[]).once.with('bar').and_return(nil)
+    @controller_instance.objsession.keys.should == [ :foo ]
+
+    expect(@underlying_session).to receive(:[]).once.with('foo').and_return(nil)
+    expect(@underlying_session).to receive(:[]).once.with('bar').and_return(false)
+    @controller_instance.objsession.keys.should == [ :bar ]
+  end
+
+  it "should turn itself into a string reasonably well" do
+    define_objsession_class do
+      field :foo
+      field :bar
+    end
+
+    ::Object.const_set(:ObjectifiedSessionsSpecBasicString, @objsession_class)
+
+    allow(@underlying_session).to receive(:[]).with('foo').and_return(123)
+    allow(@underlying_session).to receive(:[]).with('bar').and_return(nil)
+    @controller_instance.objsession.to_s.should == "<ObjectifiedSessionsSpecBasicString: foo: 123>"
+    @controller_instance.objsession.inspect.should == @controller_instance.objsession.to_s
+
+    allow(@underlying_session).to receive(:[]).with('foo').and_return(123)
+    allow(@underlying_session).to receive(:[]).with('bar').and_return("a" * 200)
+    @controller_instance.objsession.to_s.should == "<ObjectifiedSessionsSpecBasicString: bar: \"#{"a" * 36}..., foo: 123>"
+    @controller_instance.objsession.inspect.should == @controller_instance.objsession.to_s
+
+    @controller_instance.objsession.to_s(false).should == "<ObjectifiedSessionsSpecBasicString: bar: \"#{"a" * 200}\", foo: 123>"
+    @controller_instance.objsession.inspect(false).should == @controller_instance.objsession.to_s(false)
+  end
+
+  it "should allow setting a storage name for a field, and should use that when talking to the underlying session" do
+    define_objsession_class do
+      unknown_fields :delete
+
+      field :foo, :storage => :f
+      field :bar, :storage => :b
+    end
+
+    allow(@underlying_session).to receive(:keys).and_return([ :foo, :b ])
+    expect(@underlying_session).to receive(:delete).once.with([ :foo ])
+
+
+    expect(@underlying_session).to receive(:[]=).once.with('f', 123)
+    @controller_instance.objsession.foo = 123
+
+    expect(@underlying_session).to receive(:[]).once.with('f').and_return(234)
+    @controller_instance.objsession.foo.should == 234
+
+    allow(@underlying_session).to receive(:[]).once.with('b').and_return(456)
+    @controller_instance.objsession.bar.should == 456
+
+    lambda { @controller_instance.objsession.send(:f) }.should raise_error(NoMethodError)
+    lambda { @controller_instance.objsession.send(:f=) }.should raise_error(NoMethodError)
+    lambda { @controller_instance.objsession.send(:b) }.should raise_error(NoMethodError)
+    lambda { @controller_instance.objsession.send(:b=) }.should raise_error(NoMethodError)
+
+    lambda { @controller_instance.objsession.send(:[], :f) }.should raise_error(ObjectifiedSessions::Errors::NoSuchFieldError)
+    lambda { @controller_instance.objsession.send(:[]=, :f, 123) }.should raise_error(ObjectifiedSessions::Errors::NoSuchFieldError)
+    lambda { @controller_instance.objsession.send(:[], :b) }.should raise_error(ObjectifiedSessions::Errors::NoSuchFieldError)
+    lambda { @controller_instance.objsession.send(:[]=, :b, 123) }.should raise_error(ObjectifiedSessions::Errors::NoSuchFieldError)
+  end
+
+  it "should call the included module something sane" do
+    define_objsession_class(:IncludedModuleSpecObjSession) { field :foo }
+
+    included = @controller_instance.objsession.class.included_modules.detect { |m| m.name =~ /objectifiedsessions/i }
+    included.should be
+  end
+end

data/spec/objectified_sessions/system/error_handling_system_spec.rb

@@ -0,0 +1,217 @@
+require 'objectified_sessions'
+require "objectified_sessions/helpers/controller_helper"
+require "objectified_sessions/helpers/exception_helpers"
+
+describe "ObjectifiedSessions error handling" do
+  include ObjectifiedSessions::Helpers::ControllerHelper
+  include ObjectifiedSessions::Helpers::ExceptionHelpers
+
+  before :each do
+    set_new_controller_instance
+    ::ObjectifiedSessions.instance_variable_set("@session_class", nil)
+    ::ObjectifiedSessions.instance_variable_set("@_session_class_object", nil)
+  end
+
+  describe "session-class specification" do
+    it "should raise a nice exception if you haven't specified a session class, nor defined one" do
+      e = capture_exception(NameError) { @controller_instance.objsession }
+      e.message.should match(/Objsession/)
+    end
+
+    it "should raise a relevant exception if the specified session class doesn't exist" do
+      ::ObjectifiedSessions.session_class = :NonexistentSessionClass1
+
+      e = capture_exception(NameError) { @controller_instance.objsession }
+      e.message.should match(/NonexistentSessionClass1/i)
+    end
+
+    it "should raise a relevant exception if the specified class can't be instantiated" do
+      class FooError < StandardError; end
+
+      define_objsession_class(:CannotInstantiateObjsessionClass) do
+        def initialize(*args)
+          raise FooError, "kaboomba"
+        end
+      end
+
+      e = capture_exception(ObjectifiedSessions::Errors::CannotCreateSessionError) { @controller_instance.objsession }
+      e.message.should match(/kaboomba/i)
+      e.message.should match(/fooerror/i)
+      e.message.should match(/CannotInstantiateObjsessionClass/i)
+    end
+
+    it "should raise a relevant exception if the specified class isn't a subclass of ObjectifiedSessions::Base" do
+      class SomeOtherClass
+        def initialize(*args)
+        end
+
+        def to_s
+          "woomba"
+        end
+
+        def inspect
+          "woomba"
+        end
+      end
+
+      ::ObjectifiedSessions.session_class = :SomeOtherClass
+
+      e = capture_exception(ObjectifiedSessions::Errors::CannotCreateSessionError) { @controller_instance.objsession }
+      e.message.should match(/SomeOtherClass/i)
+      e.message.should match(/ObjectifiedSessions::Base/i)
+      e.message.should match(/woomba/i)
+    end
+  end
+
+  describe "visibility and prefix specification" do
+    it "should raise a nice error if you try to set the default visibility to something bogus" do
+      e = capture_exception(ArgumentError) do
+        define_objsession_class do
+          default_visibility true
+        end
+      end
+
+      e.message.should match(/true/)
+      e.message.should match(/public/)
+      e.message.should match(/private/)
+    end
+
+    it "should raise a nice error if you try to set the prefix to something bogus" do
+      e = capture_exception(ArgumentError) do
+        define_objsession_class do
+          prefix true
+        end
+      end
+
+      e.message.should match(/true/)
+    end
+
+    it "should raise a nice error if you try to set the unknown-fields setting to something bogus" do
+      e = capture_exception(ArgumentError) do
+        define_objsession_class do
+          unknown_fields true
+        end
+      end
+
+      e.message.should match(/delete/)
+      e.message.should match(/preserve/)
+    end
+  end
+
+  describe "field specification" do
+    it "should raise a nice error if you don't pass a String or Symbol as your field name" do
+      e = capture_exception(ArgumentError) do
+        define_objsession_class do
+          field 123
+        end
+      end
+
+      e.message.should match(/123/)
+    end
+
+    it "should raise a nice error if you pass an invalid option" do
+      e = capture_exception(ArgumentError) do
+        define_objsession_class do
+          field :foo, :a => :b
+        end
+      end
+
+      e.message.should match(/a/)
+    end
+
+    it "should raise a nice error if you pass an invalid :storage option" do
+      e = capture_exception(ArgumentError) do
+        define_objsession_class do
+          field :foo, :storage => false
+        end
+      end
+
+      e.message.should match(/false/)
+    end
+
+    it "should raise a nice error if you pass an invalid :visibility option" do
+      e = capture_exception(ArgumentError) do
+        define_objsession_class do
+          field :foo, :visibility => 12345
+        end
+      end
+
+      e.message.should match(/12345/)
+    end
+  end
+
+  it "should not allow hash access to the underlying session for undefined fields" do
+    define_objsession_class do
+      field :foo, :visibility => :private
+      field :baz
+
+      def set_bar(x)
+        self[:bar] = x
+      end
+
+      def get_bar
+        self[:bar]
+      end
+    end
+
+    e = capture_exception(ObjectifiedSessions::Errors::NoSuchFieldError) { @controller_instance.objsession.set_bar(123) }
+    e.session_class.should be(@objsession_class)
+    e.field_name.should == :bar
+    e.accessible_field_names.sort_by(&:to_s).should == [ :foo, :baz ].sort_by(&:to_s)
+    e.message.should match(/bar/i)
+    e.message.should match(/foo/i)
+    e.message.should match(/baz/i)
+
+    e = capture_exception(ObjectifiedSessions::Errors::NoSuchFieldError) { @controller_instance.objsession.get_bar }
+    e.session_class.should be(@objsession_class)
+    e.field_name.should == :bar
+    e.accessible_field_names.sort_by(&:to_s).should == [ :foo, :baz ].sort_by(&:to_s)
+    e.message.should match(/bar/i)
+    e.message.should match(/foo/i)
+    e.message.should match(/baz/i)
+  end
+
+  it "should not let you define more than one field with the same name" do
+    e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldNameError) do
+      define_objsession_class do
+        field :foo
+        field 'foo'
+      end
+    end
+
+    e.session_class.should be(@objsession_class)
+    e.field_name.should == :foo
+    e.message.should match(/foo/i)
+  end
+
+  it "should not let you define more than one field with the same storage name" do
+    e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldStorageNameError) do
+      define_objsession_class do
+        field :foo, :storage => :bar
+        field :baz, :storage => :bar
+      end
+    end
+
+    e.session_class.should be(@objsession_class)
+    e.original_field_name.should == :foo
+    e.new_field_name.should == :baz
+    e.storage_name.should == 'bar'
+    e.message.should match(/foo/i)
+    e.message.should match(/baz/i)
+    e.message.should match(/bar/i)
+
+    e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldStorageNameError) do
+      define_objsession_class do
+        field :foo, :storage => :bar
+        field :bar
+      end
+    end
+
+    e.session_class.should be(@objsession_class)
+    e.original_field_name.should == :foo
+    e.new_field_name.should == :bar
+    e.storage_name.should == 'bar'
+    e.message.should match(/foo/i)
+    e.message.should match(/bar/i)
+  end
+end

data/spec/objectified_sessions/system/prefix_system_spec.rb

@@ -0,0 +1,62 @@
+require 'objectified_sessions'
+require "objectified_sessions/helpers/controller_helper"
+require "objectified_sessions/helpers/exception_helpers"
+
+describe "ObjectifiedSessions prefix" do
+  include ObjectifiedSessions::Helpers::ControllerHelper
+  include ObjectifiedSessions::Helpers::ExceptionHelpers
+
+  before :each do
+    set_new_controller_instance
+  end
+
+  it "should allow setting a prefix, and then the underlying session should always be accessed via that Hash" do
+    define_objsession_class do
+      prefix :prf
+
+      field :foo
+      field :bar
+    end
+
+    @objsession_class.prefix.should == 'prf'
+
+    should_be_using_prefix('prf', true)
+
+    expect(@prefixed_underlying_session).to receive(:[]=).once.with('foo', 123)
+    @controller_instance.objsession.foo = 123
+
+    expect(@prefixed_underlying_session).to receive(:[]).once.with('foo').and_return(234)
+    @controller_instance.objsession.foo.should == 234
+  end
+
+  it "should allow setting a prefix, and return nil for everything if nothing's been set there" do
+    define_objsession_class do
+      prefix :prf
+
+      field :foo
+      field :bar
+    end
+
+    allow(@underlying_session).to receive(:[]).with('prf').and_return(nil)
+
+    @controller_instance.objsession.foo.should == nil
+    @controller_instance.objsession.bar.should == nil
+  end
+
+  it "should allow setting the prefix to nil, which shouldn't change anything" do
+    define_objsession_class do
+      prefix nil
+
+      field :foo
+      field :bar
+    end
+
+    @objsession_class.prefix.should == nil
+
+    expect(@underlying_session).to receive(:[]=).once.with('foo', 123)
+    @controller_instance.objsession.foo = 123
+
+    expect(@underlying_session).to receive(:[]).once.with('foo').and_return(234)
+    @controller_instance.objsession.foo.should == 234
+  end
+end

data/spec/objectified_sessions/system/retired_inactive_system_spec.rb

@@ -0,0 +1,188 @@
+require 'objectified_sessions'
+require "objectified_sessions/helpers/controller_helper"
+require "objectified_sessions/helpers/exception_helpers"
+
+describe "ObjectifiedSessions retired and inactive field handling" do
+  include ObjectifiedSessions::Helpers::ControllerHelper
+  include ObjectifiedSessions::Helpers::ExceptionHelpers
+
+  before :each do
+    set_new_controller_instance
+  end
+
+
+  describe "retired fields" do
+    it "should prevent you from defining a field with the same storage name" do
+      e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldNameError) do
+        define_objsession_class do
+          field :foo
+
+          retired :foo
+        end
+      end
+
+      e.session_class.should be(@objsession_class)
+      e.field_name.should == :foo
+      e.message.should match(/foo/i)
+
+      e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldNameError) do
+        define_objsession_class do
+          retired :foo
+          field :foo
+        end
+      end
+
+      e.session_class.should be(@objsession_class)
+      e.field_name.should == :foo
+      e.message.should match(/foo/i)
+
+      e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldStorageNameError) do
+        define_objsession_class do
+          retired :foo
+          field :bar, :storage => :foo
+        end
+      end
+
+      e.session_class.should be(@objsession_class)
+      e.original_field_name.should == :foo
+      e.new_field_name.should == :bar
+      e.storage_name.should == 'foo'
+      e.message.should match(/foo/i)
+      e.message.should match(/bar/i)
+    end
+
+    it "should not allow access to a retired field's data" do
+      define_objsession_class do
+        field :foo
+        retired :bar
+      end
+
+      allow(@underlying_session).to receive(:[]).with('foo').and_return(234)
+
+      @controller_instance.objsession.foo.should == 234
+
+      @controller_instance.objsession.respond_to?(:bar).should_not be
+      @controller_instance.objsession.respond_to?(:bar=).should_not be
+
+      lambda { @controller_instance.objsession.send(:bar) }.should raise_error(NoMethodError)
+      lambda { @controller_instance.objsession.send(:bar=, 123) }.should raise_error(NoMethodError)
+
+      e = capture_exception(ObjectifiedSessions::Errors::NoSuchFieldError) { @controller_instance.objsession.send(:[], :bar) }
+      e.accessible_field_names.should == [ :foo ]
+      lambda { @controller_instance.objsession.send(:[]=, :bar, 123) }.should raise_error(ObjectifiedSessions::Errors::NoSuchFieldError)
+    end
+
+    it "should still delete such a field's data if the field is retired" do
+      define_objsession_class do
+        unknown_fields :delete
+
+        field :foo
+        retired :bar
+      end
+
+      allow(@underlying_session).to receive(:keys).with().and_return([ :foo, :bar ])
+      expect(@underlying_session).to receive(:delete).once.with([ :bar ])
+
+      allow(@underlying_session).to receive(:[]).with('foo').and_return(234)
+
+      @controller_instance.objsession.foo.should == 234
+    end
+  end
+
+  describe "inactive fields" do
+    it "should prevent you from defining a field with the same storage name" do
+      e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldNameError) do
+        define_objsession_class do
+          field :foo
+
+          inactive :foo
+        end
+      end
+
+      e.session_class.should be(@objsession_class)
+      e.field_name.should == :foo
+      e.message.should match(/foo/i)
+
+      e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldNameError) do
+        define_objsession_class do
+          inactive :foo
+          field :foo
+        end
+      end
+
+      e.session_class.should be(@objsession_class)
+      e.field_name.should == :foo
+      e.message.should match(/foo/i)
+
+      e = capture_exception(ObjectifiedSessions::Errors::DuplicateFieldStorageNameError) do
+        define_objsession_class do
+          inactive :foo
+          field :bar, :storage => :foo
+        end
+      end
+
+      e.session_class.should be(@objsession_class)
+      e.original_field_name.should == :foo
+      e.new_field_name.should == :bar
+      e.storage_name.should == 'foo'
+      e.message.should match(/foo/i)
+      e.message.should match(/bar/i)
+    end
+
+    it "should not allow access to an inactive field's data" do
+      define_objsession_class do
+        field :foo
+        inactive :bar
+      end
+
+      allow(@underlying_session).to receive(:[]).with('foo').and_return(234)
+
+      @controller_instance.objsession.foo.should == 234
+
+      @controller_instance.objsession.respond_to?(:bar).should_not be
+      @controller_instance.objsession.respond_to?(:bar=).should_not be
+
+      lambda { @controller_instance.objsession.send(:bar) }.should raise_error(NoMethodError)
+      lambda { @controller_instance.objsession.send(:bar=, 123) }.should raise_error(NoMethodError)
+
+      e = capture_exception(ObjectifiedSessions::Errors::NoSuchFieldError) { @controller_instance.objsession.send(:[], :bar) }
+      e.accessible_field_names.should == [ :foo ]
+      lambda { @controller_instance.objsession.send(:[]=, :bar, 123) }.should raise_error(ObjectifiedSessions::Errors::NoSuchFieldError)
+    end
+
+    it "should NOT delete such a field's data if the field is inactive" do
+      define_objsession_class do
+        unknown_fields :delete
+
+        field :foo
+        inactive :bar
+      end
+
+      allow(@underlying_session).to receive(:keys).with().and_return([ :foo, :bar ])
+
+      allow(@underlying_session).to receive(:[]).with('foo').and_return(234)
+
+      @controller_instance.objsession.foo.should == 234
+    end
+  end
+
+  it "should let you override a method, and #super should still work" do
+    define_objsession_class do
+      field :foo
+
+      def foo
+        "X" + super + "Y"
+      end
+
+      def foo=(x)
+        super("A" + x + "B")
+      end
+    end
+
+    expect(@underlying_session).to receive(:[]=).once.with('foo', "AzB")
+    @controller_instance.objsession.foo = 'z'
+
+    expect(@underlying_session).to receive(:[]).once.with('foo').and_return("q")
+    @controller_instance.objsession.foo.should == 'XqY'
+  end
+end