peoplefinder 0.0.2

data/spec/models/peoplefinder/person_spec.rb

@@ -0,0 +1,153 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::Person, type: :model do
+  let(:person) { build(:person) }
+  it { should validate_presence_of(:surname) }
+  it { should have_many(:groups) }
+
+  describe '.name' do
+    before { person.surname = 'von Brown' }
+
+    context 'with a given_name and surname' do
+      it 'concatenates given_name and surname' do
+        person.given_name = 'Jon'
+        expect(person.name).to eql('Jon von Brown')
+      end
+    end
+
+    context 'with a surname only' do
+      it 'uses the surname' do
+        expect(person.name).to eql('von Brown')
+      end
+    end
+  end
+
+  context 'slug' do
+    it 'generates from the first part of the email address if present' do
+      person = create(:person, email: 'user.example@digital.justice.gov.uk')
+      person.reload
+      expect(person.slug).to eql('user-example')
+    end
+
+    it 'generates from the name if there is no email' do
+      person = create(:person, given_name: 'Bobby', surname: 'Tables')
+      person.reload
+      expect(person.slug).to eql('bobby-tables')
+    end
+  end
+
+  context 'search' do
+    it 'deletes indexes' do
+      expect(described_class.__elasticsearch__).to receive(:delete_index!).
+        with(index: 'test_peoplefinder-people')
+      described_class.delete_indexes
+    end
+  end
+
+  context 'elasticsearch indexing helpers' do
+    before do
+      person.save!
+      digital_services = create(:group, name: 'Digital Services')
+      estates = create(:group, name: 'Estates')
+      person.memberships.create(group: estates, role: 'Cleaner')
+      person.memberships.create(group: digital_services, role: 'Designer')
+    end
+
+    it 'writes the role and group as a string' do
+      expect(person.role_and_group).to match(/Digital Services, Designer/)
+      expect(person.role_and_group).to match(/Estates, Cleaner/)
+    end
+  end
+
+  context 'path' do
+    let(:person) { described_class.new }
+
+    context 'when there are no memberships' do
+      it 'contains only itself' do
+        expect(person.path).to eql([person])
+      end
+    end
+
+    context 'when there is one membership' do
+      it 'contains the group path' do
+        group_a = build(:group)
+        group_b = build(:group)
+        allow(group_b).to receive(:path) { [group_a, group_b] }
+        person.groups << group_b
+        expect(person.path).to eql([group_a, group_b, person])
+      end
+    end
+
+    context 'when there are multiple group memberships' do
+      let(:groups) { 4.times.map { build(:group) } }
+
+      before do
+        allow(groups[1]).to receive(:path) { [groups[0], groups[1]] }
+        allow(groups[3]).to receive(:path) { [groups[2], groups[3]] }
+        person.groups << groups[1]
+        person.groups << groups[3]
+      end
+
+      it 'uses the first group path' do
+        expect(person.path).to eql([groups[0], groups[1], person])
+      end
+
+      it 'uses the group hint to choose the path' do
+        expect(person.path(groups[3])).to eql([groups[2], groups[3], person])
+      end
+
+      it 'uses the first group path if the hint is unhelpful' do
+        expect(person.path(build(:group))).to eql([groups[0], groups[1], person])
+      end
+    end
+  end
+
+  describe '.phone' do
+    let(:person) { create(:person) }
+    let(:primary_phone_number) { '0207-123-4567' }
+    let(:secondary_phone_number) { '0208-999-8888' }
+
+    context 'with a primary and secondary phone' do
+      before do
+        person.primary_phone_number = primary_phone_number
+        person.secondary_phone_number = secondary_phone_number
+      end
+
+      it 'uses the primary phone number' do
+        expect(person.phone).to eql(primary_phone_number)
+      end
+    end
+
+    context 'with a blank primary and a valid secondary phone' do
+      before do
+        person.primary_phone_number = ''
+        person.secondary_phone_number = secondary_phone_number
+      end
+
+      it 'uses the secondary phone number' do
+        expect(person.phone).to eql(secondary_phone_number)
+      end
+    end
+  end
+
+  describe '.support_email' do
+    let(:person) { create(:person) }
+    subject { person.support_email }
+
+    context 'when the the person is a member of a group' do
+      before do
+        person.groups << create(:group, team_email_address: '123@example.com')
+      end
+
+      it 'uses the group email address' do
+        expect(subject).to eql('123@example.com')
+      end
+    end
+
+    context 'when the person is not in a group' do
+      it 'sets the application-wide support email' do
+        expect(subject).to eql(Rails.configuration.support_email)
+      end
+    end
+  end
+end

data/spec/models/peoplefinder/reported_profile_spec.rb

@@ -0,0 +1,11 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::ReportedProfile, type: :model do
+  it { should belong_to(:notifier) }
+  it { should belong_to(:subject) }
+
+  it { should validate_presence_of(:recipient_email) }
+  it { should validate_presence_of(:notifier_id) }
+  it { should validate_presence_of(:subject_id) }
+  it { should validate_presence_of(:reason_for_reporting) }
+end

data/spec/models/peoplefinder/tokens_spec.rb

@@ -0,0 +1,40 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::Token, type: :model do
+  it 'generates a token' do
+    token = create(:token)
+    expect(token.value).to match(/\A[a-z0-9\-]{36}\z/)
+  end
+
+  it 'preserves the same token after persisting' do
+    token = create(:token)
+    value = token.value
+    token.save!
+    token.reload
+    expect(token.value).to eql(value)
+  end
+
+  it 'will be valid with valid email address' do
+    token = build(:token)
+    expect(token).to be_valid
+  end
+
+  it 'will be invalid with invalid email address' do
+    token = build(:token, user_email: 'bob')
+    expect(token).not_to be_valid
+  end
+
+  it 'will be invalid with email address from wrong domain' do
+    token = build(:token, user_email: 'bob@example.com')
+    expect(token).not_to be_valid
+  end
+
+  describe '#for_person' do
+    let(:person) { create(:person, email: 'text.user@digital.justice.gov.uk') }
+    let(:token) { described_class.for_person(person) }
+
+    it 'creates a token for that person\'s email' do
+      expect(token.user_email).to eql(person.email)
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,62 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require 'spec_helper'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+require 'shoulda-matchers'
+
+require 'capybara/poltergeist'
+Capybara.javascript_driver = :poltergeist
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
+
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!
+
+RSpec.configure do |config|
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, :type => :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+
+  config.include Peoplefinder::Engine.routes.url_helpers, type: :feature
+end
+
+class ActiveRecord::Base
+  mattr_accessor :shared_connection
+  @@shared_connection = nil
+
+  def self.connection
+    @@shared_connection || retrieve_connection
+  end
+end
+
+# Forces all threads to share the same connection. This works on
+# Capybara because it starts the web server in a thread.
+ActiveRecord::Base.shared_connection = ActiveRecord::Base.connection

data/spec/spec_helper.rb

@@ -0,0 +1,102 @@
+require 'simplecov'
+require 'simplecov-rcov'
+SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+SimpleCov.start 'rails' do
+  add_filter '/gem/'
+end
+SimpleCov.minimum_coverage 100
+
+require "factory_girl"
+require "factory_girl_rails"
+FactoryGirl.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryGirl.find_definitions
+
+require 'pry-rails'
+
+# This file was generated by the `rails generate rspec:install` command.
+# Conventionally, all specs live under a `spec` directory, which RSpec adds to
+# the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # 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
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-
+    #     syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+
+  config.include FactoryGirl::Syntax::Methods
+  config.include SpecSupport::Login
+  config.include SpecSupport::Search
+  config.include SpecSupport::Carrierwave
+  config.include SpecSupport::OrgBrowser
+  config.include SpecSupport::Email
+  config.include SpecSupport::Profile
+end

data/spec/support/carrierwave.rb

@@ -0,0 +1,13 @@
+module SpecSupport
+  module Carrierwave
+    RSpec.configure do |config|
+      config.after(:suite) do
+        FileUtils.rm_rf(Dir["#{Rails.root}/spec/support/uploads"])
+      end
+    end
+
+    def sample_image
+      File.join(Peoplefinder::Engine.root, 'spec', 'fixtures', 'placeholder.png')
+    end
+  end
+end

data/spec/support/email.rb

@@ -0,0 +1,19 @@
+module SpecSupport
+  module Email
+    def last_email
+      ActionMailer::Base.deliveries.last
+    end
+
+    def links_in_email(delivery)
+      email_contains(delivery, /https?:\S+/)
+    end
+
+    def email_contains(delivery, matcher)
+      delivery.body.encoded.scan(matcher)
+    end
+
+    def check_email_has_token_link_to(person)
+      expect(last_email.body.encoded).to match("http.*tokens\/#{ Peoplefinder::Token.last.to_param }.*?desired_path=%2Fpeople%2F*#{ person.to_param }")
+    end
+  end
+end

data/spec/support/login.rb

@@ -0,0 +1,38 @@
+module SpecSupport
+  module Login
+    def mock_logged_in_user
+      controller.session[:current_user_id] =
+        create(:person, email: 'test.user@digital.moj.gov.uk').id
+    end
+
+    def current_user
+      Peoplefinder::Person.where(email: 'test.user@digital.moj.gov.uk').first
+    end
+
+    def omni_auth_log_in_as(email)
+      OmniAuth.config.test_mode = true
+
+      OmniAuth.config.mock_auth[:gplus] = OmniAuth::AuthHash.new(
+        provider: 'gplus',
+        info: {
+          email: email,
+          first_name: 'John',
+          last_name: 'Doe',
+          name: 'John Doe'
+        }
+      )
+
+      visit 'auth/gplus'
+    end
+
+    def token_log_in_as(email)
+      token = create(:token, user_email: email)
+      visit token_path(token)
+    end
+
+    def javascript_log_in
+      visit '/'
+      click_link 'Log in'
+    end
+  end
+end