helioth 0.1.0

data/lib/helioth/version.rb

@@ -0,0 +1,3 @@
+module Helioth
+  VERSION = "0.1.0"
+end

data/spec/controller_additions_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Helioth::ControllerAdditions do
+
+  before(:each) do
+    stub_const("DSL", Helioth::Dsl.load("spec/fixtures/valid_dsl.rb"))
+  end
+
+  describe ".load_and_authorize_for" do
+    it "should be an ApplicationController method" do
+      expect(ApplicationController.public_methods.include?(:load_and_authorize_for)).to be(true)
+    end
+  end
+
+  describe "#access_to?" do
+    it "should return a boolean" do
+      expect_any_instance_of(User).to receive(:helioth_role?).and_return(:beta)
+      expect_any_instance_of(ActionController::Base).to receive(:current_user).and_return(User.new)
+
+      expect_any_instance_of(Instance).to receive(:helioth_role?).and_return(:beta)
+      expect_any_instance_of(ActionController::Base).to receive(:current_instance).and_return(Instance.new)
+
+      boolean = ActionController::Base.new.access_to?(:no_name)
+      expect( !!boolean ).to be(boolean)
+    end
+
+    it "should return false when locale_access is false" do
+      expect_any_instance_of(ActionController::Base).to receive(:locale_access_to?).and_return(false)
+      expect( ActionController::Base.new.access_to?(:no_name) ).to be(false)
+    end
+
+    describe "when locale_access is true" do
+      before(:each) do
+        expect_any_instance_of(ActionController::Base).to receive(:locale_access_to?).and_return(true)
+      end
+
+      it "should return true if user_access is true" do
+        expect_any_instance_of(ActionController::Base).to receive(:user_access_to?).and_return(true)
+        expect( ActionController::Base.new.access_to?(:no_name) ).to be(true)
+      end
+
+      describe "and user_access is false" do
+        before(:each) do
+          expect_any_instance_of(ActionController::Base).to receive(:user_access_to?).and_return(false)
+        end
+
+        it "should return true if instance_access is true" do
+          expect_any_instance_of(ActionController::Base).to receive(:instance_access_to?).and_return(true)
+          expect( ActionController::Base.new.access_to?(:no_name) ).to be(true)
+        end
+
+        it "should return false if instance_access is false" do
+          expect_any_instance_of(ActionController::Base).to receive(:instance_access_to?).and_return(false)
+          expect( ActionController::Base.new.access_to?(:no_name) ).to be(false)
+        end
+      end
+    end
+  end
+
+  describe "#locale_access_to?" do
+    it "should return a boolean" do
+      boolean = ActionController::Base.new.locale_access_to?(:no_name)
+      expect( !!boolean ).to be(boolean)
+    end
+
+    it "should thrown an error when no argument is used" do
+      expect{ ActionController::Base.new.locale_access_to? }.to raise_error(ArgumentError)
+    end
+
+    it "should accept a list of arguments" do
+      expect{ ActionController::Base.new.locale_access_to?(:no_name, :index, :search) }.to_not raise_error
+    end
+  end
+
+  describe "#user_access_to?" do
+    it "should return a boolean" do
+      expect_any_instance_of(User).to receive(:helioth_role?).and_return(:beta)
+      expect_any_instance_of(ActionController::Base).to receive(:current_user).and_return(User.new)
+
+      boolean = ActionController::Base.new.user_access_to?(:no_name)
+      expect( !!boolean ).to be(boolean)
+    end
+
+    it "should thrown an error when no argument is used" do
+      expect{ ActionController::Base.new.user_access_to? }.to raise_error(ArgumentError)
+    end
+
+    it "should accept a list of arguments" do
+      expect_any_instance_of(User).to receive(:helioth_role?).and_return(:beta)
+      expect_any_instance_of(ActionController::Base).to receive(:current_user).and_return(User.new)
+      expect{ ActionController::Base.new.user_access_to?(:no_name, :index, :search) }.to_not raise_error
+    end
+  end
+
+  describe "#instance_access_to?" do
+    it "should return a boolean" do
+      expect_any_instance_of(Instance).to receive(:helioth_role?).and_return(:beta)
+      expect_any_instance_of(ActionController::Base).to receive(:current_instance).and_return(Instance.new)
+
+      boolean = ActionController::Base.new.instance_access_to?(:no_name)
+      expect( !!boolean ).to be(boolean)
+    end
+
+    it "should thrown an error when no argument is used" do
+      expect{ ActionController::Base.new.instance_access_to? }.to raise_error(ArgumentError)
+    end
+
+    it "should accept a list of arguments" do
+      expect_any_instance_of(Instance).to receive(:helioth_role?).and_return(:beta)
+      expect_any_instance_of(ActionController::Base).to receive(:current_instance).and_return(Instance.new)
+
+      expect{ ActionController::Base.new.instance_access_to?(:no_name, :index, :search) }.to_not raise_error
+    end
+  end
+
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Helioth::Dsl do
+
+  before(:all) do
+    @dsl = Helioth::Dsl.load("spec/fixtures/valid_dsl.rb")
+  end
+
+  describe "#features" do
+    it "should retrieve all features" do
+      expect(@dsl.features.size).to be == 3
+    end
+  end
+
+  describe "#feature" do
+    it "should retrieve the feature :tutoring" do
+      expect(@dsl.feature(:tutoring)).to be_an_instance_of(Helioth::Feature)
+      expect(@dsl.feature(:tutoring).name).to be == :tutoring
+    end
+  end
+
+  describe "#action" do
+    it "should find the action :search for :tutoring" do
+      expect(@dsl.action(:tutoring, :search)).to be_an_instance_of(Helioth::Action)
+      expect(@dsl.action(:tutoring, :search).name).to be == :search
+    end
+
+    it "should not find the action :search for :no_name" do
+      expect(@dsl.action(:no_name, :search)).to be == nil
+    end
+  end
+
+  describe "#authorized_for_locale?" do
+    describe "when available locales locales is :en" do
+      it "should be true for feature :tutoring and locale :en" do
+        expect(@dsl.authorized_for_locale?(:tutoring, [], :en)).to be(true)
+      end
+
+      it "should be false for feature :tutoring and locale :fr" do
+        expect(@dsl.authorized_for_locale?(:tutoring, [], :fr)).to be(false)
+      end
+
+      it "should be true for feature :tutoring, action :search and locale :fr" do
+        expect(@dsl.authorized_for_locale?(:tutoring, [:search, :send], :fr)).to be(true)
+      end
+
+      it "should be false for feature :tutoring, action :search and locale :en" do
+        expect(@dsl.authorized_for_locale?(:tutoring, [:search, :send], :en)).to be(false)
+      end
+
+      it "should be true for feature :social_learning and locale :fr" do
+        expect(@dsl.authorized_for_locale?(:social_learning, [], :fr)).to be(true)
+      end
+
+      it "should be true for feature :social_learning and locale :en" do
+        expect(@dsl.authorized_for_locale?(:social_learning, [], :en)).to be(true)
+      end
+    end
+
+    describe "when available locales locales are [:fr, :en]" do
+      before(:all) do
+        I18n.available_locales = [:en, :fr]
+        @dsl2 = Helioth::Dsl.load("spec/fixtures/valid_dsl.rb")
+      end
+
+      it "should be true for feature :tutoring and locale :fr" do
+        expect(@dsl2.authorized_for_locale?(:tutoring, [], :fr)).to be(true)
+      end
+
+      it "should be true for feature :tutoring, action :search and locale :fr" do
+        expect(@dsl2.authorized_for_locale?(:tutoring, [:search, :send], :fr)).to be(true)
+      end
+
+      it "should be false for feature :tutoring, action :search and locale :en" do
+        expect(@dsl2.authorized_for_locale?(:tutoring, [:search, :send], :en)).to be(false)
+      end
+    end
+  end
+
+  describe "#authorized_for_user?" do
+    it "should be false for all user and feature :no_name" do
+      @dsl.roles.user.each{|role|
+        expect(@dsl.authorized_for_user?(:no_name, [], role)).to be(false)
+      }
+    end
+
+    it "should be true for user :beta and feature :tutoring" do
+      expect(@dsl.authorized_for_user?(:tutoring, [], :beta)).to be(true)
+    end
+
+    it "should be false for user not :beta and feature :tutoring" do
+      @dsl.roles.user.reject!{|e| e==:beta }.each{|role|
+        expect(@dsl.authorized_for_user?(:tutoring, [], role)).to be(false)
+      }
+    end
+
+    it "should be false for user :standard, feature :tutoring and action :search" do
+      expect(@dsl.authorized_for_user?(:tutoring, :search, :standard)).to be(false)
+    end
+
+    it "should be true for user :standard, feature :tutoring and action :index" do
+      expect(@dsl.authorized_for_user?(:tutoring, :index, :standard)).to be(true)
+    end
+  end
+
+  describe "#authorized_for_instance?" do
+    it "should be false for all instance and feature :no_name" do
+      @dsl.roles.instance.each{|role|
+        expect(@dsl.authorized_for_instance?(:no_name, [], role)).to be(false)
+      }
+    end
+
+    it "should be true for instance :beta and feature :tutoring" do
+      expect(@dsl.authorized_for_instance?(:tutoring, [], :beta)).to be(true)
+    end
+
+    it "should be true for instance :standard and feature :tutoring" do
+      expect(@dsl.authorized_for_instance?(:tutoring, [], :standard)).to be(true)
+    end
+
+    it "should be false for instance :critical and feature :tutoring" do
+      expect(@dsl.authorized_for_instance?(:tutoring, [], :critical)).to be(false)
+    end
+
+    it "should be true for instance :critical, feature :tutoring and action :index" do
+      expect(@dsl.authorized_for_instance?(:tutoring, :index, :critical)).to be(true)
+    end
+
+    it "should be true for instance :beta and feature :social_learning" do
+      expect(@dsl.authorized_for_instance?(:social_learning, [], :beta)).to be(true)
+    end
+
+    it "should be false for instance :standard and feature :social_learning" do
+      expect(@dsl.authorized_for_instance?(:social_learning, [], :standard)).to be(false)
+    end
+
+    it "should be false for instance :critical and feature :social_learning" do
+      expect(@dsl.authorized_for_instance?(:social_learning, [], :critical)).to be(false)
+    end
+  end
+
+end

data/spec/feature_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Helioth::Feature do
+
+  before(:all) do
+    @feature = Helioth::Feature.new :no_name do
+      status :disabled
+      locales :en, :fr, :br
+      actions :index do
+        status :beta
+      end
+    end
+  end
+
+  describe "#status" do
+    it "should find correct :status" do
+      expect(@feature.status).to be == :disabled
+    end
+  end
+
+  describe "#locales" do
+    it "should find correct :locales" do
+      expect(@feature.locales).to be == [:en, :fr, :br]
+    end
+
+    it 'should find correct :locales when not defined' do
+      @feature = Helioth::Feature.new :test do
+        status :disabled
+      end
+
+      expect(@feature.locales).to be == I18n.available_locales
+    end
+  end
+
+  describe "#actions" do
+    it "should find correct :actions" do
+      expect(@feature.actions.size).to be == 1
+      expect(@feature.actions.first).to be_an_instance_of(Helioth::Action)
+      expect(@feature.actions.first.name).to be == :index
+    end
+  end
+
+  describe "#action" do
+    it "should find specific related action" do
+      expect(@feature.action(:index)).to be_an_instance_of(Helioth::Action)
+      expect(@feature.action(:index).name).to be == :index
+    end
+  end
+end

data/spec/features_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Helioth::Features do
+
+  before(:all) do
+    @features = Helioth::Features.new do
+      feature :no_name do
+        status :disabled
+      end
+
+      feature :no_name2 do
+        status :beta
+      end
+    end
+  end
+
+  describe "#feature" do
+    it "should raise an ArgumentError error if no parameters passed" do
+      expect{@features.feature}.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#list" do
+    it "should be an Array" do
+      expect(@features.list).to be_an_instance_of(Array)
+    end
+
+    it "should contain 2 elements" do
+      expect(@features.list.size).to be == 2
+    end
+
+    it "should contain instances of Helioth::Feature" do
+      expect(@features.list.first).to be_an_instance_of(Helioth::Feature)
+    end
+  end
+
+end

data/spec/fixtures/invalid_dsl.rb

@@ -0,0 +1,3 @@
+invalid do
+  invalid
+end

data/spec/fixtures/valid_dsl.rb

@@ -0,0 +1,48 @@
+roles do
+  user :beta, :standard
+  instance :beta, :standard, :critical
+  feature :disabled, :beta, :pre_release, :production
+end
+
+relations do
+  feature :disabled
+
+  feature :beta do
+    instance :beta
+    user :beta
+  end
+
+  feature :pre_release do
+    instance :beta, :standard
+    user :beta
+  end
+
+  feature :production do
+    instance :beta, :standard, :critical
+    user :beta, :standard
+  end
+end
+
+features do
+  feature :no_name do
+    status :disabled
+  end
+
+  feature :tutoring do
+    status :pre_release
+
+    actions :search, :send do
+      status :pre_release
+      locales :fr
+    end
+
+    actions :index do
+      status :production
+    end
+  end
+
+  feature :social_learning do
+    status :beta
+    locales :fr, :en
+  end
+end

data/spec/helioth_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Helioth do
+  context "DSL" do
+    it 'should throw an error' do
+      expect { Helioth::DSL }.to raise_error
+    end
+  end
+
+  context ".dsl" do
+    it 'should throw an error with an invalid DSL file' do
+      expect { Helioth.dsl("spec/fixtures/invalid_dsl.rb") }.to raise_error
+    end
+
+    it 'should load the DSL with a valid DSL' do
+      expect { Helioth.dsl("spec/fixtures/valid_dsl.rb") }.to_not raise_error
+    end
+  end
+end

data/spec/model_additions_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Helioth::ModelAdditions do
+
+  before(:all) do
+    Helioth::Dsl.load("spec/fixtures/valid_dsl.rb")
+  end
+
+  describe "with standard column :role" do
+    before(:all) do
+      class User < ActiveRecord::Base
+        belongs_to :instance
+        accepts_nested_attributes_for :instance
+        has_helioth_role :user, column: :role
+      end
+
+      class Instance < ActiveRecord::Base
+        has_helioth_role :instance, column: :role
+      end
+    end
+
+    describe "#validations" do
+      it "should validate role based on DSL defintion" do
+        Helioth::DSL.roles.user.each{|role|
+          expect(User.create(role: role.to_s)).to be_valid
+        }
+
+        Helioth::DSL.roles.instance.each{|role|
+          expect(Instance.create(role: role.to_s)).to be_valid
+        }
+      end
+
+      it "shouldn't validate role based on DSL definition" do
+        expect(User.create(role: "none")).to be_invalid
+        expect(Instance.create(role: "none")).to be_invalid
+      end
+    end
+
+    describe "#role?" do
+      it "should return user role as a Symbol" do
+        expect(User.new(role: "beta").role?).to be(:beta)
+        expect(User.new(role: "beta").role?).to be_an_instance_of(Symbol)
+
+        expect(Instance.new(role: "production").role?).to be(:production)
+        expect(Instance.new(role: "production").role?).to be_an_instance_of(Symbol)
+      end
+    end
+
+    describe "#helioth_role?" do
+      it "should return user role as a Symbol" do
+        expect(User.new(role: "beta").helioth_role?).to be(:beta)
+        expect(User.new(role: "beta").helioth_role?).to be_an_instance_of(Symbol)
+
+        expect(Instance.new(role: "production").helioth_role?).to be(:production)
+        expect(Instance.new(role: "production").helioth_role?).to be_an_instance_of(Symbol)
+      end
+    end
+
+    describe "#is_role?" do
+      it "should return true if user role match argument" do
+        expect(User.new(role: "beta").is_role?(:beta)).to be(true)
+        expect(User.new(role: "beta").is_role?("beta")).to be(true)
+
+        expect(Instance.new(role: "production").is_role?(:production)).to be(true)
+        expect(Instance.new(role: "production").is_role?("production")).to be(true)
+      end
+
+      it "should return false if user role match argument" do
+        expect(User.new(role: "beta").is_role?(:none)).to be(false)
+        expect(User.new(role: "beta").is_role?("none")).to be(false)
+
+        expect(Instance.new(role: "production").is_role?(:none)).to be(false)
+        expect(Instance.new(role: "production").is_role?("none")).to be(false)
+      end
+    end
+  end
+
+  describe "with non standard column :status as role" do
+    before(:all) do
+      class User2 < ActiveRecord::Base
+        belongs_to :instance2
+        accepts_nested_attributes_for :instance2
+        has_helioth_role :user, column: :status
+      end
+
+      class Instance2 < ActiveRecord::Base
+        has_helioth_role :instance, column: :status
+      end
+    end
+
+    describe "#validations" do
+      it "should validate role based on DSL defintion" do
+        Helioth::DSL.roles.user.each{|role|
+          expect(User2.create(status: role.to_s)).to be_valid
+        }
+
+        Helioth::DSL.roles.instance.each{|role|
+          expect(Instance2.create(status: role.to_s)).to be_valid
+        }
+      end
+
+      it "shouldn't validate role based on DSL definition" do
+        expect(User2.create(status: "none")).to be_invalid
+        expect(Instance2.create(status: "none")).to be_invalid
+      end
+    end
+
+    describe "#role?" do
+      it "should return user role as a Symbol" do
+        expect(User2.new(status: "beta").status?).to be(:beta)
+        expect(User2.new(status: "beta").status?).to be_an_instance_of(Symbol)
+
+        expect(Instance2.new(status: "production").status?).to be(:production)
+        expect(Instance2.new(status: "production").status?).to be_an_instance_of(Symbol)
+      end
+    end
+
+    describe "#helioth_role?" do
+      it "should return user role as a Symbol" do
+        expect(User2.new(status: "beta").helioth_role?).to be(:beta)
+        expect(User2.new(status: "beta").helioth_role?).to be_an_instance_of(Symbol)
+
+        expect(Instance2.new(status: "production").helioth_role?).to be(:production)
+        expect(Instance2.new(status: "production").helioth_role?).to be_an_instance_of(Symbol)
+      end
+    end
+
+    describe "#is_role?" do
+      it "should return true if user role match argument" do
+        expect(User2.new(status: "beta").is_status?(:beta)).to be(true)
+        expect(User2.new(status: "beta").is_status?("beta")).to be(true)
+
+        expect(Instance2.new(status: "production").is_status?(:production)).to be(true)
+        expect(Instance2.new(status: "production").is_status?("production")).to be(true)
+      end
+
+      it "should return false if user role match argument" do
+        expect(User2.new(status: "beta").is_status?(:none)).to be(false)
+        expect(User2.new(status: "beta").is_status?("none")).to be(false)
+
+        expect(Instance2.new(status: "production").is_status?(:none)).to be(false)
+        expect(Instance2.new(status: "production").is_status?("none")).to be(false)
+      end
+    end
+  end
+end