user_plane 0.0.15

data/spec/models/user/identities/email_verification_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe User::Identities::EmailVerification do
+  subject :password_reset do
+    described_class.password_reset.create(recipient: Faker::Internet.safe_email)
+  end
+
+  it 'can be spent' do
+    password_reset.spend
+    expect(password_reset).to be_valid
+  end
+
+
+  context 'after two weeks' do
+    subject :old_password_reset do
+      verification_life_span = 2.weeks + 1.day
+      Timecop.travel verification_life_span.ago do
+        described_class.password_reset.create(recipient: Faker::Internet.safe_email)
+      end
+    end
+
+    it {is_expected.to be_stale}
+
+    it 'cannot be spent' do
+      old_password_reset.spend
+      expect(old_password_reset).not_to be_valid
+    end
+  end
+
+  context 'once spent' do
+    subject :spent_password_reset do
+      described_class.password_reset.create(recipient: Faker::Internet.safe_email, spent_at: Time.now)
+    end
+
+    it 'cannot be spent again' do
+      spent_password_reset.spend
+      expect(spent_password_reset).not_to be_valid
+    end
+
+  end
+
+end

data/spec/models/user/identities/facebook_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe User::Identities::Facebook do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/spec/models/user/identities/github_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe User::Identities::Github do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/spec/models/user/identities/id_token_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe User::Identities::IdToken do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/spec/models/user/identities/o_auth_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'shared_contexts/user'
+
+describe User::Identities::OAuth do
+  include_context 'user'
+
+  it 'creates the identity from oauth data' do
+    oauth_identity = described_class.find_or_build_from_omniauth(facebook_oauth_data)
+
+    expect(oauth_identity).to be_a(User::Identities::Facebook)
+  end
+end

data/spec/models/user/identities/twitter_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe User::Identities::Twitter do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/spec/models/user/reset_password_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'shared_contexts/user'
+
+describe User::ResetPassword do
+  include_context 'user'
+
+  def validated_reset_password token, password, confirmation=nil
+    confirmation = password if confirmation.nil?
+    reset_password = described_class.new(code: token,
+                                         password: password,
+                                         password_confirmation: confirmation)
+    reset_password.valid?
+    reset_password        
+  end
+
+
+  context 'with a valid reset token' do
+    let (:reset_token) do
+      password_reset_verification = a_user.email.reset_password!
+      password_reset_verification.token
+    end
+
+    let! (:old_password) {a_user.email.password}
+
+    context 'does not miss validation callbacks' do
+      subject :reset_password do
+        described_class.new(code: reset_token,
+                            password: new_password,
+                            password_confirmation: new_password)
+      end
+      
+      it 'resets the password without skipping the before_validation' do
+        reset_password.perform
+        a_user.reload
+        expect(a_user.email.authenticate(new_password)).not_to be false
+      end
+    end
+
+    context 'and a valid password' do
+      subject :reset_password do
+        described_class.new(code: reset_token,
+                            password: new_password,
+                            password_confirmation: new_password)
+      end
+
+      it {is_expected.to be_valid}
+
+      it 'resets the password' do
+        reset_password.perform!
+        a_user.reload
+        expect(a_user.email.authenticate(new_password)).not_to be false
+      end
+
+      context 'once performed' do
+        before do
+          reset_password.perform!
+          a_user.reload
+        end
+
+        it 'spends the verification token' do
+          reset_password.verification.reload
+          expect(reset_password.verification).to be_spent
+        end
+        
+        it 'the new password can be used to authenticate' do
+          expect(a_user.email.authenticate(new_password)).not_to be false
+        end
+
+        it 'a wrong password cannot be used to authenticate' do
+          expect(a_user.email.authenticate('not the new password')).to be false
+        end
+
+        it 'the old password cannot be used to authenticate' do
+          expect(a_user.email.authenticate(old_password)).to be false
+        end
+
+        it 'cannot be redeemed anymore' do
+          another_reset = described_class.new(code: reset_token,
+                                              password: new_password,
+                                              password_confirmation: new_password)
+          expect(another_reset).not_to be_valid        
+          expect(another_reset.errors[:code].size).to eq(1)
+          
+        end
+      end
+    end
+
+    context 'and a bad password' do
+
+      
+      let :empty_reset_password do
+        validated_reset_password(reset_token, '')
+      end
+
+      let :short_reset_password do
+        validated_reset_password(reset_token, 'pw')
+      end
+
+      let :mismatching_reset_password do
+        validated_reset_password(reset_token, new_password, 'mismatching confirmation')
+      end
+
+      it 'does not allow empty passwords' do
+        expect(empty_reset_password.errors.messages[:password].size).to eq(1)
+      end
+
+      it 'validates password length' do
+        expect(short_reset_password.errors.messages[:password].size).to eq(1)
+      end
+
+      it 'requires confirmation' do
+        expect(mismatching_reset_password.errors.messages[:password_confirmation].size).to eq(1)
+      end 
+    end
+  end
+
+  context 'without a valid reset token' do
+    subject :reset_password do
+      validated_reset_password('invalid token', new_password)
+    end
+
+    it {expect {subject}.to raise_error ActiveRecord::RecordNotFound}
+  end
+
+  context 'with an expired verification token' do
+    let (:stale_verification_token) do
+      Timecop.travel (2.weeks + 1.day).ago do
+        address_verification = a_user.email.reset_password!
+        address_verification.token        
+      end
+    end
+
+    subject :reset_password_with_stale_token do
+      validated_reset_password(stale_verification_token, new_password)
+    end
+
+    it {is_expected.not_to be_valid}
+    it {expect(reset_password_with_stale_token.errors.messages[:code].size).to eq(1)}
+  end
+
+end

data/spec/models/user/send_password_reset_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'shared_contexts/user'
+
+describe User::SendPasswordReset, type: :model do
+  include_context 'user'
+
+  let :dummy_verification do
+    double(User::Identities::EmailVerification, save: true, token: '123456')
+  end
+
+  context 'resetting the password for an existing account' do
+    subject(:send_reset) {described_class.new(email: a_user.email.address)}
+
+    it 'has a verification code' do
+      send_reset.perform!
+      expect(send_reset.code).not_to be_nil
+    end
+
+    it 'does create an email verification' do
+      expect(User::Identities::EmailVerification).to receive(:new).and_return(dummy_verification)
+      send_reset.perform!
+    end
+  end
+
+  context 'with an unknown email address' do
+    before do
+      allow(User::Identities::Email).to receive(:find_by_address).and_return(nil)
+    end
+
+    subject(:send_reset) {described_class.new(email: 'dont.find.me@example.com')}
+
+    it {is_expected.to be_valid}
+
+    it 'has no verification code' do
+      send_reset.perform!
+      expect(send_reset.code).to be_nil
+    end
+
+    it 'does not create an email verification' do
+      expect(User::Identities::EmailVerification).not_to receive(:new)
+      send_reset.perform!
+    end
+  end
+end

data/spec/models/user/send_sign_up_invite_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'shared_contexts/user'
+
+describe User::SendSignUpInvite do
+  include_context 'user'
+
+  subject(:send_invite) {described_class.new(sender: a_user, recipient: invite_recipient)}
+
+  context 'When the sender has one invite remaining' do
+    before do
+      a_user.invites_stack.update({remaining_invites: 1})
+    end
+
+    it 'is used to send invites' do
+      send_invite.perform!
+      expect(send_invite.invite).not_to be_nil
+      expect(send_invite.stack.remaining_invites).to eq(0)
+    end    
+  end
+
+  context 'if the user has no invites left' do
+    before do
+      a_user.invites_stack.update({remaining_invites: 0})
+    end
+
+    it 'is used to send invites' do
+      expect(send_invite).not_to be_valid
+    end
+  end
+end

data/spec/models/user/sign_in_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'shared_contexts/user'
+
+describe User::SignIn do
+  include_context 'user'
+
+  context 'with a valid email/password combination' do
+    subject :sign_in do
+      described_class.new(email: a_user.email.address, 
+                 password: a_user.email.password)
+            .sign_in_with(User::Identities::Email)
+    end
+
+    it {is_expected.to be_valid}
+  end
+
+  context 'with a bad email/password combination' do
+    subject :sign_in do
+      described_class.new(email: a_user.email.address, 
+                 password: '')
+            .sign_in_with(User::Identities::Email)
+    end
+
+    before {subject.valid?}
+
+    it {is_expected.not_to be_valid}
+    it {expect(subject.errors).to include(:base)}
+    it {expect(subject.errors).not_to include(:identity)}
+  end
+
+end

data/spec/models/user/sign_up_invites/invite_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe User::SignUpInvites::Invite, type: :model do
+  context 'validates the recipient format' do
+    subject(:invite) { described_class.new(recipient: 'not a vaild email') }
+
+    it 'is not allowed more invites' do
+      expect(invite).not_to be_valid
+    end    
+  end
+end
+
+

data/spec/models/user/sign_up_invites/stack_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe User::SignUpInvites::Stack, :type => :model do
+
+  subject(:invites_stack) {described_class.create(remaining_invites: 2)}
+
+  it 'decrements the available invites' do
+    invites_stack.invites.create(recipient: Faker::Internet.safe_email)
+    expect(invites_stack.remaining_invites).to eql(1)
+  end
+
+  context 'when the stack is out of invites' do
+    subject(:dry_invites_stack) {described_class.create(remaining_invites: 0)}
+
+    it 'is not allowed more invites' do
+      new_invite = dry_invites_stack.invites.create(recipient: Faker::Internet.safe_email)
+      expect(dry_invites_stack).not_to be_valid
+    end    
+  end
+
+end

data/spec/models/user/sign_up_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'shared_contexts/user'
+
+describe User::SignUp do
+  include_context 'user'
+
+  context 'with valid details' do
+    subject :sign_up do
+      p = 'some secret'
+      sign_up = described_class.new(user_name: 'foo', 
+                                    email: 'foo@example.com',
+                                    password: p,
+                                    password_confirmation: p)
+      sign_up.sign_up_with(User::Identities::Email)
+    end
+
+    it {is_expected.to be_valid}
+
+    context 'succeeds' do
+      before {sign_up.perform!}
+
+      it {expect { User::Account.find(sign_up.account.id) }.to_not raise_error}
+    end
+  end
+  
+  context 'with bad details' do   
+    subject :new_sign_up do
+      sign_up = described_class.new(user_name: a_user.name,
+                                    email: a_user.email.address,
+                                    password: p,
+                                    password_confirmation: p)
+      sign_up.sign_up_with(User::Identities::Email)
+    end
+
+    before {new_sign_up.valid?}
+      
+    it {is_expected.not_to be_valid}
+    it {expect(new_sign_up.errors).to include(:email)}
+    it {expect(new_sign_up.errors).not_to include(:email_identity)}
+  end
+
+  context 'with social media' do
+    it 'can be invited and register with twitter'
+
+    context 'can be created logging in with facebook' do
+      # User fills up the signup form with his user name and clicks to register with facebook
+      subject :sign_up do
+        sign_up = described_class.new(user_name: Faker::Internet.user_name,
+                                      oauth_data: facebook_oauth_data)
+        sign_up.sign_up_with(User::Identities::OAuth)
+      end
+
+      it {is_expected.to be_valid}      
+      it {expect(sign_up.identity).to be_a(User::Identities::Facebook)}
+    end
+  end
+
+end

data/spec/models/user/sign_up_with_invite_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'shared_contexts/user'
+
+describe User::SignUpWithInvite do
+  include_context 'user'
+
+  context 'without an invite' do
+    subject :sign_up_without_invite do
+      sign_up = described_class.new(user_name: invite_recipient_user_name,
+                                    email: Faker::Internet.safe_email,
+                                    password: new_password,
+                                    password_confirmation: new_password)
+    end
+
+    before {sign_up_without_invite.valid?}
+
+    it {is_expected.not_to be_valid}
+    it {expect(sign_up_without_invite.errors).to include(:invite)}
+  end
+
+  context 'with a spent invite' do
+
+    let :spent_invite do
+      a_user.create_invite! recipient: invite_recipient 
+    end
+
+    subject :sign_up_with_spent_invite do
+      user_name = Faker::Internet.user_name
+      sign_up = described_class.new(user_name: user_name,
+                                    code: spent_invite.code,
+                                    email: "#{user_name}@example.com",
+                                    password: new_password,
+                                    password_confirmation: new_password)
+      sign_up.sign_up_with(User::Identities::Email)
+    end
+
+    before {sign_up_with_spent_invite.valid?}
+
+    it {is_expected.not_to be_valid}
+    it {expect(sign_up_with_spent_invite.errors).to include(:invite)}
+  end
+
+  context 'with an invite' do
+    subject :sign_up_with_invite do
+      sign_up = described_class.new(user_name: invite_recipient,
+                                    code: a_sign_up_invite.code,
+                                    email: a_sign_up_invite.recipient,
+                                    password: new_password,
+                                    password_confirmation: new_password)
+      sign_up.sign_up_with(User::Identities::Email)
+    end
+
+    it {expect { sign_up_with_invite.perform! }.to_not raise_error}
+
+  end
+
+  context 'when redeemed' do
+    subject :sign_up_with_invite do
+      sign_up = described_class.new(user_name: invite_recipient,
+                                    code: a_sign_up_invite.code,
+                                    email: a_sign_up_invite.recipient,
+                                    password: new_password,
+                                    password_confirmation: new_password)
+      sign_up.sign_up_with(User::Identities::Email)
+    end
+
+    before {sign_up_with_invite.perform!}
+
+    it { expect(User::Account.where(id: sign_up_with_invite.account.id)).to  exist }
+  end
+
+  it 'can be created logging in with facebook' do
+    # User fills up the signup form with his user name and clicks to register with facebook
+    sign_up = described_class.new(code: a_sign_up_invite.code,
+                                  oauth_data: facebook_oauth_data)
+    sign_up.sign_up_with(User::Identities::OAuth)
+
+    expect(sign_up).to be_valid
+    expect(sign_up.identity).to be_a(User::Identities::Facebook)
+    sign_up.perform
+  end
+
+end