ledermann-rails-settings 1.2.0 → 2.0.0

data/spec/scopes_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'scopes' do
+  let!(:user1) { User.create! :name => 'Mr. White' do |user| user.settings(:dashboard).theme = 'white' end }
+  let!(:user2) { User.create! :name => 'Mr. Blue' }
+
+  it "should find objects with existing settings" do
+    User.with_settings.should eq([user1])
+  end
+
+  it "should find objects with settings for key" do
+    User.with_settings_for(:dashboard).should eq([user1])
+    User.with_settings_for(:foo).should eq([])
+  end
+
+  it "should records without settings" do
+    User.without_settings.should eq([user2])
+  end
+
+  it "should records without settings for key" do
+    User.without_settings_for(:foo).should eq([user1, user2])
+    User.without_settings_for(:dashboard).should eq([user2])
+  end
+
+  it "should require symbol as key" do
+    [ nil, "string", 42 ].each do |invalid_key|
+      expect { User.without_settings_for(invalid_key) }.to raise_error(ArgumentError)
+      expect { User.with_settings_for(invalid_key)    }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/serialize_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe "Serialization" do
+  let!(:user) do
+    User.create! :name => 'Mr. White' do |user|
+      user.settings(:dashboard).theme = 'white'
+      user.settings(:calendar).scope = 'all'
+    end
+  end
+
+  describe 'created settings' do
+    it 'should be serialized' do
+      user.reload
+
+      dashboard_settings = user.setting_objects.where(:var => 'dashboard').first
+      calendar_settings = user.setting_objects.where(:var => 'calendar').first
+
+      dashboard_settings.var.should == 'dashboard'
+      dashboard_settings.value.should eq({'theme' => 'white'})
+
+      calendar_settings.var.should == 'calendar'
+      calendar_settings.value.should eq({'scope' => 'all'})
+    end
+  end
+
+  describe 'updated settings' do
+    it 'should be serialized' do
+      user.settings(:dashboard).update_attributes! :smart => true
+
+      dashboard_settings = user.setting_objects.where(:var => 'dashboard').first
+      calendar_settings = user.setting_objects.where(:var => 'calendar').first
+
+      dashboard_settings.var.should == 'dashboard'
+      dashboard_settings.value.should eq({'theme' => 'white', 'smart' => true})
+
+      calendar_settings.var.should == 'calendar'
+      calendar_settings.value.should eq({'scope' => 'all'})
+    end
+  end
+end

data/spec/setting_object_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe RailsSettings::SettingObject do
+  let(:user) { User.create! :name => 'Mr. Pink' }
+  let(:new_setting_object) { user.setting_objects.build :var => 'dashboard' }
+  let(:saved_setting_object) { user.setting_objects.create! :var => 'dashboard', :value => { 'theme' => 'pink', 'filter' => true } }
+
+  describe "Getter and Setter" do
+    context "on unsaved settings" do
+      it "should respond to setters" do
+        new_setting_object.should respond_to(:foo=)
+        new_setting_object.should respond_to(:bar=)
+      end
+
+      it "should not respond to some getters" do
+        expect { new_setting_object.foo! }.to raise_error(NoMethodError)
+        expect { new_setting_object.foo? }.to raise_error(NoMethodError)
+      end
+
+      it "should not respond if a block is given" do
+        expect {
+          new_setting_object.foo do
+          end
+        }.to raise_error(NoMethodError)
+      end
+
+      it "should not respond if params are given" do
+        expect { new_setting_object.foo(42) }.to raise_error(NoMethodError)
+        expect { new_setting_object.foo(42,43) }.to raise_error(NoMethodError)
+      end
+
+      it "should return nil for unknown attribute" do
+        new_setting_object.foo.should eq(nil)
+        new_setting_object.bar.should eq(nil)
+      end
+
+      it "should return defaults" do
+        new_setting_object.theme.should eq('blue')
+        new_setting_object.view.should eq('monthly')
+        new_setting_object.filter.should eq(false)
+      end
+
+      it "should store to value hash" do
+        new_setting_object.foo = 42
+        new_setting_object.bar = 'hello'
+
+        new_setting_object.value.should eq({'foo' => 42, 'bar' => 'hello'})
+      end
+
+      it "should set and return attributes" do
+        new_setting_object.theme = 'pink'
+        new_setting_object.foo = 42
+        new_setting_object.bar = 'hello'
+
+        new_setting_object.theme.should eq('pink')
+        new_setting_object.foo.should eq(42)
+        new_setting_object.bar.should eq('hello')
+      end
+
+      it "should set dirty trackers on change" do
+        new_setting_object.theme = 'pink'
+        new_setting_object.should be_value_changed
+        new_setting_object.should be_changed
+      end
+    end
+
+    context "on saved settings" do
+      it "should not set dirty trackers on setting same value" do
+        saved_setting_object.theme = 'pink'
+        saved_setting_object.should_not be_value_changed
+        saved_setting_object.should_not be_changed
+      end
+
+      it "should delete key on assigning nil" do
+        saved_setting_object.theme = nil
+        saved_setting_object.value.should == { 'filter' => true }
+      end
+    end
+  end
+
+  describe "update_attributes" do
+    it 'should save' do
+      new_setting_object.update_attributes(:foo => 42, :bar => 'string').should be_true
+      new_setting_object.reload
+
+      new_setting_object.foo.should eq(42)
+      new_setting_object.bar.should eq('string')
+      new_setting_object.should_not be_new_record
+      new_setting_object.id.should_not be_zero
+    end
+
+    it 'should not save blank hash' do
+      new_setting_object.update_attributes({}).should be_false
+    end
+  end
+
+  describe "save" do
+    it "should save" do
+      new_setting_object.foo = 42
+      new_setting_object.bar = 'string'
+      new_setting_object.save.should be_true
+      new_setting_object.reload
+
+      new_setting_object.foo.should eq(42)
+      new_setting_object.bar.should eq('string')
+      new_setting_object.should_not be_new_record
+      new_setting_object.id.should_not be_zero
+    end
+  end
+
+  describe "validation" do
+    it "should not validate for unknown var" do
+      new_setting_object.var = "unknown-var"
+
+      new_setting_object.should_not be_valid
+      new_setting_object.errors[:var].should be_present
+    end
+  end
+end

data/spec/settings_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+describe "Defaults" do
+  it "should be stored for simple class" do
+    Account.default_settings.should eq(:portal => {})
+  end
+
+  it "should be stored for parent class" do
+    User.default_settings.should eq(:dashboard => { 'theme' => 'blue', 'view' => 'monthly', 'filter' => false },
+                                    :calendar => { 'scope' => 'company'})
+  end
+
+  it "should be stored for child class" do
+    GuestUser.default_settings.should eq(:dashboard => { 'theme' => 'red', 'view' => 'monthly', 'filter' => false })
+  end
+end
+
+describe "Getter/Setter" do
+  let(:account) { Account.new :subdomain => 'foo' }
+
+  it "should handle method syntax" do
+    account.settings(:portal).enabled = true
+    account.settings(:portal).template = 'black'
+
+    account.settings(:portal).enabled.should eq(true)
+    account.settings(:portal).template.should eq('black')
+  end
+
+  it "should return nil for not existing key" do
+    account.settings(:portal).foo.should eq(nil)
+  end
+end
+
+describe 'Objects' do
+  context 'without defaults' do
+    let(:account) { Account.new :subdomain => 'foo' }
+
+    it 'should have blank settings' do
+      account.settings(:portal).value.should eq({})
+    end
+
+    it 'should not add settings on saving' do
+      account.save!
+      RailsSettings::SettingObject.count.should eq(0)
+    end
+
+    it "should save object with settings" do
+      account.settings(:portal).premium = true
+      account.settings(:portal).fee = 42.5
+      account.save!
+
+      account.reload
+      account.settings(:portal).premium.should eq(true)
+      account.settings(:portal).fee.should eq(42.5)
+
+      RailsSettings::SettingObject.count.should eq(1)
+      RailsSettings::SettingObject.first.value.should == { 'premium' => true, 'fee' => 42.5 }
+    end
+
+    it "should save settings separated" do
+      account.save!
+
+      settings = account.settings(:portal)
+      settings.enabled = true
+      settings.template = 'black'
+      settings.save!
+
+      account.reload
+      account.settings(:portal).enabled.should eq(true)
+      account.settings(:portal).template.should eq('black')
+    end
+  end
+
+  context 'with defaults' do
+    let(:user) { User.new :name => 'Mr. Brown' }
+
+    it 'should have default settings' do
+      user.settings(:dashboard).theme.should eq('blue')
+      user.settings(:dashboard).view.should eq('monthly')
+      user.settings(:dashboard).filter.should eq(false)
+      user.settings(:calendar).scope.should eq('company')
+    end
+
+    it 'should have default settings after changing one' do
+      user.settings(:dashboard).theme = 'gray'
+
+      user.settings(:dashboard).theme.should eq('gray')
+      user.settings(:dashboard).view.should eq('monthly')
+      user.settings(:dashboard).filter.should eq(false)
+      user.settings(:calendar).scope.should eq('company')
+    end
+
+    it "should overwrite settings" do
+      user.settings(:dashboard).theme = 'brown'
+      user.settings(:dashboard).filter = true
+      user.save!
+
+      user.reload
+      user.settings(:dashboard).theme.should eq('brown')
+      user.settings(:dashboard).filter.should eq(true)
+      RailsSettings::SettingObject.count.should eq(1)
+      RailsSettings::SettingObject.first.value.should == { 'theme' => 'brown', 'filter' => true }
+    end
+
+    it "should merge settings with defaults" do
+      user.settings(:dashboard).theme = 'brown'
+      user.save!
+
+      user.reload
+      user.settings(:dashboard).theme.should eq('brown')
+      user.settings(:dashboard).filter.should eq(false)
+      RailsSettings::SettingObject.count.should eq(1)
+      RailsSettings::SettingObject.first.value.should == { 'theme' => 'brown' }
+    end
+  end
+end
+
+describe "Object without settings" do
+  let!(:user) { User.create! :name => 'Mr. White' }
+
+  it "should respond to #settings?" do
+    user.settings?.should eq(false)
+    user.settings?(:dashboard).should eq(false)
+  end
+
+  it "should have no setting objects" do
+    RailsSettings::SettingObject.count.should eq(0)
+  end
+
+  it "should add settings" do
+    user.settings(:dashboard).update_attributes! :smart => true
+
+    user.reload
+    user.settings(:dashboard).smart.should eq(true)
+  end
+
+  it "should not save settings if assigned nil" do
+    expect {
+      user.settings = nil
+      user.save!
+    }.to_not change(RailsSettings::SettingObject, :count)
+  end
+end
+
+describe "Object with settings" do
+  let!(:user) do
+    User.create! :name => 'Mr. White' do |user|
+      user.settings(:dashboard).theme = 'white'
+      user.settings(:calendar).scope = 'all'
+    end
+  end
+
+  it "should respond to #settings?" do
+    user.settings?.should eq(true)
+
+    user.settings?(:dashboard).should eq(true)
+    user.settings?(:calendar).should eq(true)
+  end
+
+  it "should have two setting objects" do
+    RailsSettings::SettingObject.count.should eq(2)
+  end
+
+  it "should update settings" do
+    user.settings(:dashboard).update_attributes! :smart => true
+    user.reload
+
+    user.settings(:dashboard).smart.should eq(true)
+    user.settings(:dashboard).theme.should eq('white')
+    user.settings(:calendar).scope.should eq('all')
+  end
+
+  it "should update settings by saving object" do
+    user.settings(:dashboard).smart = true
+    user.save!
+
+    user.reload
+    user.settings(:dashboard).smart.should eq(true)
+  end
+
+  it "should destroy settings with nil" do
+    expect {
+      user.settings = nil
+      user.save!
+    }.to change(RailsSettings::SettingObject, :count).by(-2)
+
+    user.settings?.should == false
+  end
+end
+
+describe "Customized SettingObject" do
+  let(:project) { Project.create! :name => 'Heist' }
+
+  it "should not accept invalid attributes" do
+    project.settings(:info).owner_name = 42
+    project.settings(:info).should_not be_valid
+
+    project.settings(:info).owner_name = ''
+    project.settings(:info).should_not be_valid
+  end
+
+  it "should accept valid attributes" do
+    project.settings(:info).owner_name = 'Mr. Brown'
+    project.settings(:info).should be_valid
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,90 @@
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # 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'
+
+  config.before(:each) do
+    clear_db
+  end
+end
+
+require 'active_record'
+require 'rails-settings'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Migration.verbose = false
+
+class User < ActiveRecord::Base
+  has_settings do |s|
+    s.key :dashboard, :defaults => { :theme => 'blue', :view => 'monthly', :filter => false }
+    s.key :calendar,  :defaults => { :scope => 'company'}
+  end
+end
+
+class GuestUser < User
+  has_settings do |s|
+    s.key :dashboard, :defaults => { :theme => 'red', :view => 'monthly', :filter => false }
+  end
+end
+
+class Account < ActiveRecord::Base
+  has_settings :portal
+end
+
+class Project < ActiveRecord::Base
+  has_settings :info, :class_name => 'ProjectSettingObject'
+end
+
+class ProjectSettingObject < RailsSettings::SettingObject
+  validate do
+    unless self.owner_name.present? && self.owner_name.is_a?(String)
+      errors.add(:base, "Owner name is missing")
+    end
+  end
+end
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :settings do |t|
+      t.string     :var,    :null => false
+      t.text       :value,  :null => false
+      t.references :target, :null => false, :polymorphic => true
+      t.timestamps
+    end
+    add_index :settings, [ :target_type, :target_id, :var ], :unique => true
+
+    create_table :users do |t|
+      t.string :type
+      t.string :name
+    end
+
+    create_table :accounts do |t|
+      t.string :subdomain
+    end
+
+    create_table :projects do |t|
+      t.string :name
+    end
+  end
+end
+
+def clear_db
+  User.delete_all
+  Account.delete_all
+  RailsSettings::SettingObject.delete_all
+end
+
+puts "Testing with ActiveRecord #{ActiveRecord::VERSION::STRING}"
+setup_db