saasy 0.0.1

data/spec/models/limit_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Limit do
+  subject { Factory(:limit) }
+
+  it { should belong_to(:plan) }
+  it { should validate_presence_of(:name) }
+  it { should validate_presence_of(:value) }
+end
+
+describe Limit, "various kinds" do
+  let!(:users) { Factory(:limit, :name => "users", :value => 1) }
+  let!(:ssl) { Factory(:limit, :name => "ssl", :value => 0, :value_type => :boolean) }
+  let!(:lighthouse) { Factory(:limit, :name => "lighthouse", :value => 1, :value_type => :boolean) }
+
+  it "gives the numbered limits" do
+    Limit.numbered.should == [users]
+  end
+
+  it "gives the boolean limits" do
+    Limit.boolean.should == [ssl, lighthouse]
+  end
+
+  it "gives the limits by name" do
+    Limit.named(:users).should == users
+  end
+
+  it "reports true for booleans with 1" do
+    lighthouse.allowed?.should be
+  end
+
+  it "reports false for booleans with 0" do
+    ssl.allowed?.should_not be
+  end
+end
+
+describe Limit, "with account and limits" do
+  subject { Factory(:limit, :name => "users", :value => 1) }
+
+  before do
+    @account = Factory(:account, :plan => subject.plan)
+  end
+
+  it "indicates whether the account is below the limit" do
+    subject.within?(@account)
+  end
+
+  it "gives the current count for the account of the limit" do
+    @account.stubs(:users_count => 99)
+    subject.current_count(@account).should == 99
+  end
+
+  it "can query whether the given account is below the specified limit" do
+    Limit.within?("users", @account)
+  end
+
+  it "indicates whether the specified account can add one" do
+    Limit.can_add_one?("users", @account).should be
+   
+    Factory(:membership, :account => @account)
+    Factory(:project, :account => @account)
+
+    Limit.can_add_one?("users", @account).should_not be
+  end
+
+  it "returns true if there is no limit" do
+    Limit.can_add_one?("nomatch", @account).should be
+    Limit.within?("nomatch", @account).should be
+  end
+end

data/spec/models/membership_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Membership do
+  it { should belong_to(:account) }
+  it { should belong_to(:user) }
+  it { should validate_presence_of(:account_id) }
+  it { should validate_presence_of(:user_id) }
+  it { should have_many(:permissions).dependent(:destroy) }
+  it { should have_many(:projects).through(:permissions) }
+
+  describe "given an existing account membership" do
+    before { Factory(:membership) }
+    it { should validate_uniqueness_of(:user_id).scoped_to(:account_id) }
+  end
+
+  it "delegates the user's name" do
+    user = Factory(:user)
+    membership = Factory(:membership, :user => user)
+
+    membership.name.should == user.name
+  end
+
+  it "delegates the user's email" do
+    user = Factory(:user)
+    membership = Factory(:membership, :user => user)
+
+    membership.email.should == user.email
+  end
+
+  it "returns memberships by name" do
+    Factory(:membership, :user => Factory(:user, :name => "def"))
+    Factory(:membership, :user => Factory(:user, :name => "abc"))
+    Factory(:membership, :user => Factory(:user, :name => "ghi"))
+
+    Membership.by_name.map(&:name).should == %w(abc def ghi)
+  end
+end

data/spec/models/permission_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Permission do
+  it { should belong_to(:project) }
+  it { should belong_to(:membership) }
+  it { should belong_to(:user) }
+
+  it "doesn't allow the same member to be added to a project twice" do
+    original = Factory(:permission)
+    duplicate = Factory.build(:permission, :membership => original.membership, :project => original.project)
+    duplicate.should_not be_valid
+  end
+
+  it "allows different members to be added to a project" do
+    original = Factory(:permission)
+    duplicate = Factory.build(:permission, :project => original.project)
+    duplicate.should be_valid
+  end
+
+  it "caches the user from the account membership" do
+    membership = Factory(:membership)
+    permission = Factory(:permission, :membership => membership)
+    permission.user_id.should == membership.user_id
+  end
+
+  it "doesn't allow the user to be assigned" do
+    expect { subject.user = Factory.build(:user) }.to raise_error
+  end
+end
+

data/spec/models/plan_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Plan do
+  subject { Factory(:plan) }
+
+  it { should have_many(:limits) }
+  it { should have_many(:accounts) }
+  it { should validate_presence_of(:name) }
+
+  it "finds ordered paid plans" do
+    Factory(:plan, :name => "Free", :price => 0)
+    Factory(:plan, :name => "Two", :price => 2)
+    Factory(:plan, :name => "One", :price => 1)
+    Factory(:plan, :name => "Three", :price => 3)
+
+    Plan.paid_by_price.to_a.map(&:name).should == %w(Three Two One)
+  end
+
+  it "finds the trial plan" do
+    paid = Factory(:plan, :name => "Paid", :price => 1)
+    trial = Factory(:plan, :name => "Free", :price => 0)
+
+    Plan.trial.should == trial
+  end
+end
+
+describe Plan, "free" do
+  subject { Factory(:plan) }
+
+  it "is free" do
+    subject.free?.should be
+  end
+
+  it "is not billed" do
+    subject.billed?.should_not be
+  end
+end
+
+describe Plan, "paid" do
+  subject { Factory(:paid_plan) }
+
+  it "is not free" do
+    subject.free?.should_not be
+  end
+
+  it "is billed" do
+    subject.billed?.should be
+  end
+end
+
+describe Plan, "with limits" do
+  subject { Factory(:plan) }
+
+  before do
+    Factory(:limit, :name => "users", :value => 1, :plan => subject)
+    Factory(:limit, :name => "ssl", :value => 0, :value_type => :boolean, :plan => subject)
+    Factory(:limit, :name => "lighthouse", :value => 1, :value_type => :boolean, :plan => subject)
+  end
+
+  it "indicates whether or not more users can be created" do
+    subject.can_add_more?(:users, 0).should be
+    subject.can_add_more?(:users, 1).should_not be
+    subject.can_add_more?(:users, 2).should_not be
+  end
+
+  it "indicates whether a plan can do something or not" do
+    subject.allows?(:ssl).should_not be
+    subject.allows?(:lighthouse).should be
+  end
+end
+
+
+describe Plan, "with prices" do
+  let!(:free) { Factory(:plan, :price => 0) }
+  let!(:least) { Factory(:plan, :price => 1) }
+  let!(:most) { Factory(:plan, :price => 2) }
+
+  it "gives them from most to least expensive when ordered" do
+    Plan.ordered.should == [most, least, free]
+  end
+end

data/spec/models/project_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+describe Project do
+  it { should belong_to(:account) }
+  it { should validate_presence_of(:account_id) }
+  it { should have_many(:permissions) }
+  it { should validate_presence_of(:keyword) }
+  it { should validate_presence_of(:name) }
+
+  it { should allow_value("hello").for(:keyword) }
+  it { should allow_value("0123").for(:keyword) }
+  it { should allow_value("hello_world").for(:keyword) }
+  it { should allow_value("hello-world").for(:keyword) }
+  it { should_not allow_value("HELLO").for(:keyword) }
+  it { should_not allow_value("hello world").for(:keyword) }
+
+  it { should_not allow_mass_assignment_of(:account_id) }
+  it { should_not allow_mass_assignment_of(:account) }
+
+  it "finds projects visible to a user" do
+    account = Factory(:account)
+    user = Factory(:user)
+    membership = Factory(:membership, :user => user, :account => account)
+    visible_projects = [Factory(:project, :account => account),
+                        Factory(:project, :account => account)]
+    invisible_project = Factory(:project, :account => account)
+    visible_projects.each do |visible_project|
+      Factory(:permission, :project            => visible_project,
+                                   :membership => membership)
+    end
+
+    Project.visible_to(user).to_a.should =~ visible_projects
+  end
+
+  it "returns projects by name" do
+    Factory(:project, :name => "def")
+    Factory(:project, :name => "abc")
+    Factory(:project, :name => "ghi")
+
+    Project.by_name.map(&:name).should == %w(abc def ghi)
+  end
+
+  context "archived and non-archived projects" do
+    before do
+      @archived = [Factory(:project, :archived => true), Factory(:project, :archived => true)]
+      @active = [Factory(:project, :archived => false)]
+    end
+
+    it "returns only archived projects with archived" do
+      Project.archived.all.should == @archived
+    end
+
+    it "returns only active projects with active" do
+      Project.active.all.should == @active
+    end
+  end
+
+  context "archived project for an account at its project limit" do
+    before do
+      @archived = Factory(:project, :archived => true)
+      @account = @archived.account
+      Limit.stubs(:can_add_one?).with("projects", @account).returns(false)
+    end
+
+    it "cannot be unarchived" do
+      @archived.archived = false
+      @archived.save.should_not be
+      @archived.errors[:archived].first.should match(/at your limit/)
+    end
+  end
+
+  context "project moving to an account at its project limit" do
+    before do
+      @project = Factory(:project)
+      @account = Factory(:account)
+      Limit.stubs(:can_add_one?).with("projects", @account).returns(false)
+    end
+
+    it "cannot be moved" do
+      @project.account = @account
+      @project.save.should_not be
+      @project.errors[:account_id].first.should match(/at your limit/)
+    end
+  end
+
+  it "should give its keyword for to_param" do
+    project = Factory(:project)
+    project.to_param.should == project.keyword
+  end
+end
+
+describe Project, "keyword uniqueness" do
+  let(:project) { Factory(:project) }
+  subject do
+    Factory.build(:project, :account => project.account)
+  end
+
+  it "validates uniqueness of it's keyword" do
+    subject.keyword = project.keyword
+    subject.save
+    subject.errors[:keyword].should include("has already been taken")
+  end
+end
+
+share_examples_for "default project permissions" do
+  it "is viewable by admins by default" do
+    admins.each do |admin|
+      subject.users.should include(admin)
+    end
+  end
+
+  it "isn't viewable by non-members" do
+    subject.users.should_not include(non_admin)
+    subject.users.should_not include(non_member)
+  end
+end
+
+describe Project, "for an account with admin and non-admin users" do
+  let!(:account)       { Factory(:account, :name => "Account") }
+  let!(:other_account) { Factory(:account, :name => "Other") }
+  let!(:non_admin)     { Factory(:user) }
+  let!(:admins)        { [Factory(:user), Factory(:user)] }
+  let!(:non_member)    { Factory(:user) }
+  subject              { Factory.build(:project, :account => account) }
+
+  before do
+    Factory(:membership, :account => account, :user => non_admin, :admin => false)
+    Factory(:membership, :account => other_account,
+                                 :user    => non_member,
+                                 :admin   => true)
+    admins.each do |admin|
+      Factory(:membership, :user => admin, :account => account, :admin => true)
+    end
+
+    subject.assign_default_permissions 
+  end
+
+  context "before saving" do
+    it_behaves_like "default project permissions"
+  end
+
+  context "after saving" do
+    before do
+      subject.save!
+      subject.reload
+    end
+
+    it_behaves_like "default project permissions"
+  end
+end
+
+describe Project, "saved" do
+  subject { Factory(:project) }
+
+  it "has a member with a membership" do
+    user = Factory(:user)
+    membership = Factory(:membership, :account => subject.account,
+                                                      :user    => user)
+    membership = Factory(:permission, :project            => subject,
+                                              :membership => membership)
+    should have_member(user)
+  end
+
+  it "doesn't have a member without a membership" do
+    user = Factory(:user)
+    should_not have_member(user)
+  end
+end
+
+describe Project, "assigning users on update" do
+  subject { Factory(:project) }
+
+  let(:account) { subject.account }
+  let!(:user_to_remove) { Factory(:user) }
+  let!(:user_to_add) { Factory(:user) }
+  let!(:admin) { Factory(:user) }
+
+  before do
+    membership_to_remove =
+      Factory(:membership, :account => account, :user => user_to_remove)
+    membership_to_add =
+      Factory(:membership, :account => account, :user => user_to_add)
+    admin_membership =
+      Factory(:membership, :account => account, :user => admin, :admin => true)
+    Factory(:permission, :membership => membership_to_remove,
+                         :project    => subject)
+
+    subject.reload.update_attributes!(:user_ids => [user_to_add.id, ""])
+  end
+
+  it "adds an added user" do
+    user_to_add.should be_member_of(subject)
+  end
+
+  it "removes a removed user" do
+    user_to_remove.should_not be_member_of(subject)
+  end
+
+  it "keeps an admin" do
+    admin.should be_member_of(subject)
+  end
+end
+
+describe Project, "assigning users on create" do
+  subject       { Factory.build(:project) }
+  let(:account) { subject.account }
+  let!(:member) { Factory(:user) }
+  let!(:admin)  { Factory(:user) }
+
+  before do
+    Factory(:membership, :account => account, :user => member)
+    Factory(:membership, :account => account, :user => admin, :admin => true)
+    subject.save
+  end
+
+  it "adds admins to the project" do
+    admin.should be_member_of(subject)
+  end
+
+  it "ignores normal users" do
+    member.should_not be_member_of(subject)
+  end
+end

data/spec/models/signup_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe Signup do
+  it "complies with the activemodel api" do
+    subject.class.should be_kind_of(ActiveModel::Naming)
+    should_not be_persisted
+    should be_kind_of(ActiveModel::Conversion)
+    should be_kind_of(ActiveModel::Validations)
+  end
+end
+
+describe Signup, "with attributes in the constructor" do
+  subject { Signup.new(:email => 'person@example.com', :password => 'password') }
+  it "assigns attributes" do
+    subject.email.should == 'person@example.com'
+    subject.password.should == 'password'
+  end
+end
+
+describe Signup, "with nil to the constructor" do
+  subject { Signup.new(nil) }
+
+  it "assigns no attributes" do
+    subject.email.should be_blank
+    subject.password.should be_blank
+  end
+end
+
+share_examples_for "invalid signup" do
+  before { @previous_user_count = User.count }
+
+  it "returns false" do
+    @result.should be_false
+  end
+
+  it "doesn't create a user" do
+    User.count.should == @previous_user_count
+  end
+
+  it "doesn't create an account" do
+    subject.account.should be_new_record
+  end
+end
+
+share_examples_for "valid signup" do
+  it "returns true" do
+    @result.should be_true
+  end
+
+  it "saves the account" do
+    subject.account.should be_persisted
+  end
+end
+
+describe Signup, "with a valid user and account" do
+  it_should_behave_like "valid signup"
+  let(:email) { "user@example.com" }
+  subject { Factory.build(:signup, :email => email) }
+
+  before do
+    @result = subject.save
+  end
+
+  it "saves the user" do
+    subject.user.should be_persisted
+  end
+
+  it "assigns the user to the account" do
+    subject.user.reload.accounts.should include(subject.account)
+  end
+
+  it "creates an admin user" do
+    subject.user.should be_admin_of(subject.account)
+  end
+
+  it "gives a friendly account name" do
+    subject.account.name.should == "user"
+  end
+
+  it "gives a friendly account keyword" do
+    subject.account.keyword.should =~ /^user.+/
+  end
+
+  it "gives it's account a name and keyword" do
+    subject.account.name.should_not be_blank
+    subject.account.keyword.should_not be_blank
+  end
+
+  it "gives it's user a name that is the first part of it's email" do
+    subject.user.name.should == "user"
+  end
+end
+
+describe Signup, "with an email with symbols in it" do
+  subject { Factory.build(:signup, :email => "user+extra@example.com") }
+
+  before do
+    subject.save
+  end
+  
+  it "gives a friendly account name" do
+    subject.account.name.should == "user-extra"
+  end
+
+  it "gives a friendly account keyword" do
+    subject.account.keyword.should =~ /^user-extra+/
+  end
+end
+
+describe Signup, "with an invalid user" do
+  subject { Factory.build(:signup, :email => nil) }
+  it_should_behave_like "invalid signup"
+
+  before do
+    @result = subject.save
+  end
+
+  it "adds error messages" do
+    subject.errors[:email].should_not be_empty
+  end
+end
+
+describe Signup, "valid with an existing user and correct password" do
+  it_should_behave_like "valid signup"
+  let(:email) { "user@example.com" }
+  let(:password) { "test" }
+  let!(:user) { Factory(:user, :email => email, :password => password) }
+  subject { Factory.build(:signup, :email => email, :password => password) }
+  before { @result = subject.save }
+
+  it "doesn't create a user" do
+    User.count.should == 1
+  end
+
+  it "assigns the user to the account as an admin" do
+    user.reload.accounts.should include(subject.account)
+    user.should be_admin_of(subject.account)
+  end
+end
+
+describe Signup, "valid with a signed in user" do
+  it_should_behave_like "valid signup"
+  let!(:user) { Factory(:user) }
+  subject { Factory.build(:signup, :user => user, :password => '') }
+  before { @result = subject.save }
+
+  it "doesn't create a user" do
+    User.count.should == 1
+  end
+
+  it "assigns the user to the account as an admin" do
+    user.reload.accounts.should include(subject.account)
+    user.should be_admin_of(subject.account)
+  end
+end
+
+describe Signup, "valid with an existing user and incorrect password" do
+  it_should_behave_like "invalid signup"
+  let(:email) { "user@example.com" }
+  let(:password) { "test" }
+  let!(:user) { Factory(:user, :email => email, :password => password) }
+  subject { Factory.build(:signup, :email => email, :password => 'wrong') }
+  before { @result = subject.save }
+
+  it "adds error messages" do
+    subject.errors.full_messages.should include("Password is incorrect")
+  end
+end
+
+describe Signup, "with an account that doesn't save" do
+  subject { Factory.build(:signup) }
+
+  it "doesn't raise the transaction and returns false" do
+    Account.any_instance.stubs(:save!).raises(ActiveRecord::RecordNotSaved)
+    subject.save.should_not be
+  end
+end