objectified_sessions 1.0.0

data/spec/objectified_sessions/unit/objectified_sessions/field_definition_spec.rb

@@ -0,0 +1,138 @@
+require 'objectified_sessions'
+
+describe ObjectifiedSessions::FieldDefinition do
+  def klass
+    ObjectifiedSessions::FieldDefinition
+  end
+
+  before :each do
+    @session_class = double("session_class")
+    allow(@session_class).to receive(:kind_of?).with(Class).and_return(true)
+
+    @dmm = Module.new do
+      class << self
+        public :define_method, :private
+      end
+    end
+    allow(@session_class).to receive(:_dynamic_methods_module).with().and_return(@dmm)
+  end
+
+  it "should normalize field names properly" do
+    lambda { klass.normalize_name(nil) }.should raise_error(ArgumentError)
+    lambda { klass.normalize_name(12345) }.should raise_error(ArgumentError)
+
+    klass.normalize_name(" fOo  ").should == :fOo
+    klass.normalize_name(:' fOo ').should == :fOo
+    klass.normalize_name(:foo).should == :foo
+    klass.normalize_name("foo").should == :foo
+  end
+
+  it "should validate its constructor arguments appropriately" do
+    lambda { klass.new(double("not_a_class"), :foo, { :type => :normal, :visibility => :private }) }.should raise_error(ArgumentError, /not_a_class/i)
+    lambda { klass.new(@session_class, 12345, { :type => :normal, :visibility => :private }) }.should raise_error(ArgumentError, /12345/i)
+    lambda { klass.new(@session_class, :foo, { :type => :whatever, :visibility => :private }) }.should raise_error(ArgumentError, /whatever/i)
+    lambda { klass.new(@session_class, :foo, { :visibility => :private }) }.should raise_error(ArgumentError, /:type/i)
+    lambda { klass.new(@session_class, :foo, { :type => :normal, :visibility => :whatever }) }.should raise_error(ArgumentError, /whatever/i)
+    lambda { klass.new(@session_class, :foo, { :type => :normal }) }.should raise_error(ArgumentError, /:visibility/i)
+    lambda { klass.new(@session_class, :foo, { :type => :normal, :visibility => :public, :foo => :bar }) }.should raise_error(ArgumentError, /foo/i)
+    lambda { klass.new(@session_class, :foo, { :type => :normal, :visibility => :public, :storage => 12345 }) }.should raise_error(ArgumentError, /12345/i)
+  end
+
+  it "should return the right storage name" do
+    klass.new(@session_class, :foo, { :type => :normal, :visibility => :public }).storage_name.should == 'foo'
+  end
+
+  it "should return the right storage name if aliased" do
+    klass.new(@session_class, :foo, { :type => :normal, :visibility => :public, :storage => :bar }).storage_name.should == 'bar'
+  end
+
+  it "should return the right value for #delete_data_with_storage_name?" do
+    klass.new(@session_class, :foo, { :type => :normal, :visibility => :public }).delete_data_with_storage_name?.should_not be
+    klass.new(@session_class, :foo, { :type => :inactive, :visibility => :public }).delete_data_with_storage_name?.should_not be
+    klass.new(@session_class, :foo, { :type => :retired, :visibility => :public }).delete_data_with_storage_name?.should be
+  end
+
+  it "should return the right value for #allow_access_to_data?" do
+    klass.new(@session_class, :foo, { :type => :normal, :visibility => :public }).allow_access_to_data?.should be
+    klass.new(@session_class, :foo, { :type => :inactive, :visibility => :public }).allow_access_to_data?.should_not be
+    klass.new(@session_class, :foo, { :type => :retired, :visibility => :public }).allow_access_to_data?.should_not be
+  end
+
+  context "with dynamic-methods module testing" do
+    before :each do
+      dmm = @dmm
+      @underlying_session = double("underlying_session")
+
+      @dmm_class = Class.new do
+        include dmm
+
+        def initialize(h)
+          @h = h
+        end
+
+        def [](x)
+          @h[x]
+        end
+
+        def []=(x, y)
+          @h[x] = y
+        end
+      end
+
+      @instance = @dmm_class.new(@underlying_session)
+    end
+
+    it "should create methods on the dynamic-methods module for a normal field" do
+      field = klass.new(@session_class, :foo, { :type => :normal, :visibility => :public })
+
+      expect(@underlying_session).to receive(:[]).once.with(:foo).and_return(:xxx)
+      @instance.foo.should == :xxx
+
+      expect(@underlying_session).to receive(:[]=).once.with(:foo, :zzz).and_return(:yyy)
+      (@instance.foo = :zzz).should == :zzz
+    end
+
+    it "should downcase the field name on the dynamic-methods module for a normal field" do
+      field = klass.new(@session_class, :FoO, { :type => :normal, :visibility => :public })
+
+      expect(@underlying_session).to receive(:[]).once.with(:FoO).and_return(:xxx)
+      @instance.foo.should == :xxx
+
+      expect(@underlying_session).to receive(:[]=).once.with(:FoO, :zzz).and_return(:yyy)
+      (@instance.foo = :zzz).should == :zzz
+    end
+
+    it "should create private methods on the dynamic-methods module for a normal field if marked as private" do
+      field = klass.new(@session_class, :foo, { :type => :normal, :visibility => :private })
+
+      @instance.respond_to?(:foo).should_not be
+      lambda { @instance.foo }.should raise_error(NoMethodError)
+      @instance.respond_to?(:foo=).should_not be
+      lambda { @instance.foo = 123 }.should raise_error(NoMethodError)
+
+      expect(@underlying_session).to receive(:[]).once.with(:foo).and_return(:xxx)
+      @instance.send(:foo).should == :xxx
+
+      expect(@underlying_session).to receive(:[]=).once.with(:foo, :zzz).and_return(:yyy)
+      (@instance.send(:foo=, :zzz)).should == :zzz
+    end
+
+    it "should not create methods on the dynamic-methods module for an inactive field" do
+      field = klass.new(@session_class, :foo, { :type => :inactive, :visibility => :public })
+
+      @instance.respond_to?(:foo).should_not be
+      lambda { @instance.send(:foo) }.should raise_error(NoMethodError)
+      @instance.respond_to?(:foo=).should_not be
+      lambda { @instance.send(:foo=, 123) }.should raise_error(NoMethodError)
+    end
+
+    it "should not create methods on the dynamic-methods module for a retired field" do
+      field = klass.new(@session_class, :foo, { :type => :retired, :visibility => :public })
+
+      @instance.respond_to?(:foo).should_not be
+      lambda { @instance.send(:foo) }.should raise_error(NoMethodError)
+      @instance.respond_to?(:foo=).should_not be
+      lambda { @instance.send(:foo=, 123) }.should raise_error(NoMethodError)
+    end
+  end
+end

data/spec/objectified_sessions/unit/objectified_sessions_spec.rb

@@ -0,0 +1,149 @@
+require 'objectified_sessions'
+require 'objectified_sessions/helpers/exception_helpers'
+
+describe ObjectifiedSessions do
+  include ObjectifiedSessions::Helpers::ExceptionHelpers
+
+  describe "session_class" do
+    before :each do
+      ObjectifiedSessions.instance_variable_set("@session_class", nil)
+    end
+
+    it "should return the default name, by default" do
+      ObjectifiedSessions.session_class.should == "Objsession"
+    end
+
+    it "should accept a String and return that" do
+      ObjectifiedSessions.session_class = "Foo"
+      ObjectifiedSessions.session_class.should == "Foo"
+    end
+
+    it "should accept a Symbol and return a String" do
+      ObjectifiedSessions.session_class = :Foo
+      ObjectifiedSessions.session_class.should == 'Foo'
+    end
+
+    it "should camelize its input" do
+      ObjectifiedSessions.session_class = "foo/bar_baz"
+      ObjectifiedSessions.session_class.should == "Foo::BarBaz"
+
+      ObjectifiedSessions.session_class = :"foo/bar_baz"
+      ObjectifiedSessions.session_class.should == "Foo::BarBaz"
+    end
+
+    it "should accept a Class and return that" do
+      class FooBar; end
+
+      ObjectifiedSessions.session_class = FooBar
+      ObjectifiedSessions.session_class.should == FooBar
+    end
+  end
+
+  describe "_create_new_objsession" do
+    before :each do
+      @underlying_session = double("underlying_session")
+
+      @session_class_instance = double("session_class_instance")
+
+      @session_class = Class.new(::ObjectifiedSessions::Base)
+      allow(@session_class).to receive(:new).once.with(@underlying_session).and_return(@session_class_instance)
+      allow(@session_class).to receive(:name).with().and_return("scname")
+
+      allow(@session_class_instance).to receive(:kind_of?).with(::ObjectifiedSessions::Base).and_return(true)
+
+      ObjectifiedSessions.session_class = @session_class
+    end
+
+    it "should happily return a new instance of a valid class, and return new ones each time" do
+      ObjectifiedSessions._create_new_objsession(@underlying_session).should be(@session_class_instance)
+
+      new_instance = double("session_class_instance_2")
+      allow(new_instance).to receive(:kind_of?).with(::ObjectifiedSessions::Base).and_return(true)
+
+      expect(@session_class).to receive(:new).once.with(@underlying_session).and_return(new_instance)
+      ObjectifiedSessions._create_new_objsession(@underlying_session).should be(new_instance)
+    end
+
+    it "should pass through the underlying session correctly" do
+      ObjectifiedSessions._create_new_objsession(@underlying_session).should be(@session_class_instance)
+
+      session_class_instance_2 = double("session_class_instance_2")
+      allow(session_class_instance_2).to receive(:kind_of?).with(::ObjectifiedSessions::Base).and_return(true)
+
+      underlying_session_2 = double("underlying_session_2")
+      allow(@session_class).to receive(:new).once.with(underlying_session_2).and_return(session_class_instance_2)
+
+      ObjectifiedSessions._create_new_objsession(underlying_session_2).should be(session_class_instance_2)
+    end
+
+    it "should fail with a nice exception if #new fails" do
+      class FooError < StandardError; end
+
+      allow(@session_class).to receive(:new).once.with(@underlying_session) do |*args|
+        raise FooError, "kaboomba"
+      end
+
+      e = capture_exception(ObjectifiedSessions::Errors::CannotCreateSessionError) { ObjectifiedSessions._create_new_objsession(@underlying_session) }
+      e.message.should match(/fooerror/i)
+      e.message.should match(/kaboomba/i)
+      e.message.should match(/scname/i)
+    end
+
+    it "should fail with a nice exception if the returned instance isn't of the right type" do
+      allow(@session_class_instance).to receive(:kind_of?).with(::ObjectifiedSessions::Base).and_return(false)
+      allow(@session_class_instance).to receive(:class).with().and_return(@session_class)
+      allow(@session_class_instance).to receive(:inspect).with().and_return("sciinspect")
+
+      e = capture_exception(ObjectifiedSessions::Errors::CannotCreateSessionError) { ObjectifiedSessions._create_new_objsession(@underlying_session) }
+      e.message.should match(/scname/i)
+      e.message.should match(/sciinspect/i)
+    end
+
+    context "with constantization needed" do
+      before :each do
+        @class_name_string = "foo/bar_baz"
+        allow(@class_name_string).to receive(:to_s).with().and_return(@class_name_string)
+
+        @underscored_class_name_string = "bonko"
+
+        @camelized_class_name_string = "Foo::BarBaz"
+        allow(@class_name_string).to receive(:camelize).with().and_return(@camelized_class_name_string)
+        allow(@camelized_class_name_string).to receive(:constantize).once.with().and_return(@session_class)
+        allow(@camelized_class_name_string).to receive(:underscore).with().and_return(@underscored_class_name_string)
+
+        ObjectifiedSessions.session_class = @class_name_string
+      end
+
+      it "should require paths to classes, convert between underscored and camelized, and call #constantize properly" do
+        expect(::ObjectifiedSessions).to receive(:require).once.with(@underscored_class_name_string)
+        ObjectifiedSessions._create_new_objsession(@underlying_session).should be(@session_class_instance)
+      end
+
+      it "should raise an error if the class can't be #constantize'd" do
+        expect(::ObjectifiedSessions).to receive(:require).once.with(@underscored_class_name_string)
+        allow(@camelized_class_name_string).to receive(:constantize).once.with() do |*args|
+          raise NameError, "noway"
+        end
+
+        e = capture_exception(NameError) { ObjectifiedSessions._create_new_objsession(@underlying_session) }
+        e.message.should match(/noway/)
+        e.message.should match(/#{@camelized_class_name_string}/)
+      end
+
+      it "should include a LoadError, if there is one" do
+        expect(::ObjectifiedSessions).to receive(:require).once.with(@underscored_class_name_string) do |*args|
+          raise LoadError, "blahblahload"
+        end
+
+        allow(@camelized_class_name_string).to receive(:constantize).once.with() do |*args|
+          raise NameError, "noway"
+        end
+
+        e = capture_exception(NameError) { ObjectifiedSessions._create_new_objsession(@underlying_session) }
+        e.message.should match(/noway/)
+        e.message.should match(/#{@camelized_class_name_string}/)
+        e.message.should match(/blahblahload/)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: objectified_sessions
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Andrew Geweke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-12-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id005 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.14"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+    - - <=
+      - !ruby/object:Gem::Version 
+        version: 4.99.99
+  type: :runtime
+  version_requirements: *id004
+description: Encapsulate and carefully manage access to your Rails session.
+email: 
+- andrew@geweke.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/objectified_session_generator.rb
+- lib/objectified_sessions.rb
+- lib/objectified_sessions/base.rb
+- lib/objectified_sessions/errors.rb
+- lib/objectified_sessions/field_definition.rb
+- lib/objectified_sessions/version.rb
+- objectified_sessions.gemspec
+- spec/objectified_sessions/helpers/controller_helper.rb
+- spec/objectified_sessions/helpers/exception_helpers.rb
+- spec/objectified_sessions/system/basic_system_spec.rb
+- spec/objectified_sessions/system/error_handling_system_spec.rb
+- spec/objectified_sessions/system/prefix_system_spec.rb
+- spec/objectified_sessions/system/retired_inactive_system_spec.rb
+- spec/objectified_sessions/system/setup_system_spec.rb
+- spec/objectified_sessions/system/strings_symbols_system_spec.rb
+- spec/objectified_sessions/system/unknown_data_system_spec.rb
+- spec/objectified_sessions/system/visibility_system_spec.rb
+- spec/objectified_sessions/unit/objectified_session_generator_spec.rb
+- spec/objectified_sessions/unit/objectified_sessions/base_spec.rb
+- spec/objectified_sessions/unit/objectified_sessions/errors_spec.rb
+- spec/objectified_sessions/unit/objectified_sessions/field_definition_spec.rb
+- spec/objectified_sessions/unit/objectified_sessions_spec.rb
+homepage: https://github.com/ageweke/objectified_sessions
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id005
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id005
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Encapsulate and carefully manage access to your Rails session.
+test_files: []
+