peoplefinder 0.0.2

data/spec/models/peoplefinder/concerns/searchable_spec.rb

@@ -0,0 +1,53 @@
+require 'rails_helper'
+
+RSpec.describe 'Searchable', elastic: true do # rubocop:disable RSpec/DescribeClass
+  after(:all) do
+    clean_up_indexes_and_tables
+  end
+
+  let!(:alice) { create(:person, given_name: 'Alice', surname: 'Andrews') }
+  let!(:bob) { create(:person, given_name: 'Bob', surname: 'Browning', location: 'Petty France 10th floor', description: 'weekends only') }
+  let!(:digital_services) { create(:group, name: 'Digital Services') }
+  let!(:membership) { bob.memberships.create(group: digital_services, role: 'Cleaner') }
+
+  context 'with some people' do
+    before do
+      Peoplefinder::Person.import
+      sleep 1
+    end
+
+    it 'searches by surname' do
+      results = search_for('Andrews')
+      expect(results).to include(alice)
+      expect(results).to_not include(bob)
+    end
+
+    it 'searches by name' do
+      results = search_for('Alice')
+      expect(results).to include(alice)
+      expect(results).to_not include(bob)
+    end
+
+    it 'searches by given_name' do
+      results = search_for('Bob Browning')
+      expect(results).to_not include(alice)
+      expect(results).to include(bob)
+    end
+
+    it 'searches by group name and membership role' do
+      results = search_for('Cleaner at digiTAL Services')
+      expect(results).to_not include(alice)
+      expect(results).to include(bob)
+    end
+
+    it 'searches by description and location' do
+      results = search_for('weekends at petty france office')
+      expect(results).to_not include(alice)
+      expect(results).to include(bob)
+    end
+  end
+
+  def search_for(query)
+    Peoplefinder::Person.search(query).records
+  end
+end

data/spec/models/peoplefinder/concerns/work_days_spec.rb

@@ -0,0 +1,28 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::Concerns::WorkDays do
+
+  describe '.works_weekends?' do
+    let(:weekday_person) { create(:person) }
+    let(:weekend_person) { create(:person,  works_saturday: true) }
+
+    it 'returns true for a person who works only one day in the weekend' do
+      expect(weekend_person.works_saturday).to eql(true)
+      expect(weekend_person.works_sunday).to_not eql(true)
+      expect(weekend_person.works_weekends?).to eql(true)
+    end
+
+    it 'returns true for a person who works on both a Saturday and Sunday' do
+      weekend_person.update_attributes(works_sunday: true)
+      expect(weekend_person.works_sunday).to eql(true)
+      expect(weekend_person.works_saturday).to eql(true)
+      expect(weekend_person.works_weekends?).to eql(true)
+    end
+
+    it 'returns false if neither Saturday or Sunday is worked' do
+      expect(weekday_person.works_weekends?).to eql(false)
+    end
+
+  end
+
+end

data/spec/models/peoplefinder/email_address_spec.rb

@@ -0,0 +1,78 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::EmailAddress do
+  describe '.valid_domain' do
+    context 'when it is not in the list of valid_login_domains' do
+      it 'is not valid' do
+        expect(described_class.new('me@something.else.com')).not_to be_valid_domain
+      end
+    end
+
+    context 'when it is in the list of valid_login_domains' do
+      it 'is valid' do
+        expect(described_class.new("me@#{ Rails.configuration.valid_login_domains.first }")).to be_valid_domain
+      end
+    end
+  end
+
+  describe '.valid_format' do
+    it 'is badly formatted' do
+      expect(described_class.new('me-at-example.co.uk')).not_to be_valid_format
+    end
+
+    it 'is valid' do
+      expect(described_class.new('me@example.co.uk')).to be_valid_format
+    end
+  end
+
+  describe '.valid_address' do
+    it 'is nil' do
+      expect(described_class.new(nil)).not_to be_valid_address
+    end
+
+    it 'is an empty string' do
+      expect(described_class.new('')).not_to be_valid_address
+    end
+
+    it 'is badly formatted' do
+      expect(described_class.new('me-at-example.co.uk')).not_to be_valid_address
+    end
+
+    it 'is from an invalid domain' do
+      expect(described_class.new('me-at-example.co.uk')).not_to be_valid_address
+    end
+
+    it 'does not break the mail gem address_list initialiser' do
+      expect(described_class.new('me@')).not_to be_valid_address
+    end
+
+    it 'is valid' do
+      expect(described_class.new("me@#{ Rails.configuration.valid_login_domains.first }")).to be_valid_address
+    end
+  end
+
+  context 'name inferral' do
+    let(:email_john_smith) { described_class.new('john.smith.1@example.com') }
+    let(:email_smithy) { described_class.new('smithy@example.com') }
+
+    describe '.inferred_given_name' do
+      it 'returns john.smith' do
+        expect(email_john_smith.inferred_first_name).to eql('john')
+      end
+
+      it 'returns nil' do
+        expect(email_smithy.inferred_first_name).to be_nil
+      end
+    end
+
+    describe '.inferred_last_name' do
+      it 'returns smith' do
+        expect(email_john_smith.inferred_last_name).to eql('smith')
+      end
+
+      it 'returns smithy' do
+        expect(email_smithy.inferred_last_name).to eql('smithy')
+      end
+    end
+  end
+end

data/spec/models/peoplefinder/group_hierarchy_spec.rb

@@ -0,0 +1,75 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::GroupHierarchy, type: :model do
+  it "generates a tree of hashes with group information" do
+    a, b, c, d, e = create_hierarchy_of_groups
+    a.reload
+
+    expected = {
+      id: a.id,
+      name: 'A',
+      url: '/teams/a',
+      children: [
+        {
+          id: b.id,
+          name: 'B',
+          url: '/teams/b',
+          children: [
+            {
+              id: c.id,
+              name: 'C',
+              url: '/teams/c',
+              children: []
+            }, {
+              id: d.id,
+              name: 'D',
+              url: '/teams/d',
+              children: []
+            }
+          ]
+        }, {
+          id: e.id,
+          name: 'E',
+          url: '/teams/e',
+          children: []
+        }
+      ]
+    }
+
+    generated = described_class.new(a).to_hash
+
+    expect(generated).to eql(expected)
+  end
+
+  context 'Generating a group_id list' do
+    let(:root) { create_hierarchy_of_groups.first }
+    subject { described_class.new(root).to_group_id_list }
+
+    it 'has five elements' do
+      expect(subject.length).to eql(5)
+    end
+
+    it 'includes each of the five groups' do
+      %w[ A B C D E ].each do |name|
+        expect(subject).to include(Peoplefinder::Group.find_by_name(name).id)
+      end
+    end
+  end
+
+  context 'Handling initial state when there are no groups' do
+    subject { described_class.new(nil) }
+
+    it 'returns an empty hash' do
+      expect(subject.to_hash).to eql({})
+    end
+  end
+
+  def create_hierarchy_of_groups
+    a = create(:group, name: 'A')
+    b = create(:group, name: 'B', parent: a)
+    c = create(:group, name: 'C', parent: b)
+    d = create(:group, name: 'D', parent: b)
+    e = create(:group, name: 'E', parent: a)
+    [a, b, c, d, e]
+  end
+end

data/spec/models/peoplefinder/group_spec.rb

@@ -0,0 +1,197 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::Group, type: :model do
+  it { should have_many(:leaders) }
+  it { should validate_presence_of(:team_email_address) }
+
+  it "gives first orphaned groups as department" do
+    parent = create(:department)
+    create(:group, parent: parent)
+    expect(described_class.department).to eql(parent)
+  end
+
+  it "knows about its ancestors" do
+    grandparent = create(:group, parent: nil)
+    parent = create(:group, parent: grandparent)
+    child = create(:group, parent: parent)
+    grandchild = create(:group, parent: child)
+
+    expect(grandchild.path.to_a).to eql([grandparent, parent, child, grandchild])
+  end
+
+  it "knows when it has no ancestors" do
+    department = create(:group, parent: nil)
+
+    expect(department.path.to_a).to eql([department])
+  end
+
+  it "does not permit cyclic graphs" do
+    a = create(:group)
+    b = create(:group, parent: a)
+    c = create(:group, parent: b)
+
+    a.parent = c
+    expect(a).not_to be_valid
+  end
+
+  describe '.leaf_node?' do
+    let(:group) { create(:group) }
+
+    it "knows when it is a leaf_node (no children)" do
+      expect(group).to be_leaf_node
+    end
+
+    it "knows when it is not a leaf_node (no children)" do
+      expect(group).to be_leaf_node
+    end
+  end
+
+  describe '.deletable?' do
+    let(:group) { create(:group) }
+
+    it 'is only detable when there are no memberships' do
+      group.memberships.create(person: create(:person))
+      expect(group).not_to be_deletable
+    end
+
+    it 'is not detable when there are memberships' do
+      group.memberships.create(person: create(:person))
+      expect(group).not_to be_deletable
+    end
+
+    it 'is not detable when there are children' do
+      create(:group, parent: group)
+      expect(group.reload).not_to be_deletable
+    end
+
+    it 'is detable when there are unsaved memberships (e.g. in the groups#form)' do
+      group.memberships.build
+      expect(group).to be_deletable
+    end
+  end
+
+  describe '.destroy' do
+    let(:group) { create(:group) }
+
+    it 'persists the record and add an error message when it is not deletable' do
+      allow(group).to receive(:deletable?).once.and_return(false)
+      group.destroy
+      expect(group.errors[:base].to_s).to include('cannot be deleted')
+    end
+
+    it 'deletes the record when it is deletable' do
+      allow(group).to receive(:deletable?).once.and_return(true)
+      group.destroy
+      expect { described_class.find(group) }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  describe '.all_people' do
+    let(:team) { create(:group) }
+    let(:subteam) { create(:group, parent: team) }
+
+    let(:alice) { create(:person, surname: 'alice') }
+    let(:bob) { create(:person, surname: 'bob') }
+
+    subject { team.all_people }
+
+    context 'with bob in the team' do
+      before { team.people << bob }
+
+      it 'has 1 membership' do
+        expect(subject.length).to eq(1)
+      end
+
+      context 'and alice in the subteam' do
+        before { subteam.people << alice }
+
+        it 'has 2 membership' do
+          expect(subject.length).to eq(2)
+        end
+
+        context 'and bob also in the subteam' do
+          before { subteam.people << alice }
+
+          it 'still has 2 memberships' do
+            expect(subject.length).to eq(2)
+          end
+
+          it 'returns alice and bob in alphabetical order' do
+            expect(subject.map(&:name)).to eql(%w[ alice bob ])
+          end
+        end
+      end
+    end
+  end
+
+  describe '.leadership' do
+    it 'gets the first leader' do
+      group = create(:group)
+      leaderships = [create(:membership, group: group, leader: true)]
+      expect(group.leadership).to eql(leaderships.first)
+    end
+  end
+
+  describe '.editable_parent?' do
+    let(:department) { create(:department) }
+
+    it 'checks that there is no parent' do
+      expect(department.parent).to be_nil
+    end
+
+    it 'allows editing of the parent when there are no children (during application setup, for example)' do
+      expect(department.editable_parent?).to be true
+    end
+
+    it 'prevents editing of the parent when there are children' do
+      create(:group, parent: department)
+      expect(department.reload.editable_parent?).to be false
+    end
+  end
+
+  describe '.slug_candidates' do
+    let(:department) { create(:department, name: 'MOJ') }
+    let(:team) { create(:group, parent: department, name: 'CS') }
+
+    it 'sets the department slug_candidate' do
+      expect(department.slug_candidates).to eql(%w[MOJ])
+    end
+
+    it 'sets the team slug_candidate' do
+      expect(team.slug_candidates).to eql(['CS', %w[MOJ CS], %w[MOJ CS-2]])
+    end
+  end
+
+  describe '.should_generate_new_friendly_id?' do
+    let!(:team) { create(:group, name: 'Digital Services') }
+
+    context 'when the team is first created' do
+      it 'sets the slug' do
+        expect(team.slug).to eql('digital-services')
+      end
+
+      context 'when the team name is changed' do
+        it 'gets the updated slug when the name is changed' do
+          team.update_attributes(name: 'Analog Services')
+          expect(team.reload.slug).to eql('analog-services')
+        end
+      end
+    end
+
+    context 'when a group with a duplicate (name and parent name) is added' do
+      let!(:first_duplicate) { create(:group, name: 'Digital Services') }
+
+      it 'prepends the parent' do
+        expect(first_duplicate.slug).to eql('ministry-of-justice-digital-services')
+      end
+
+      context 'when a second duplicate (name and parent name) is added' do
+        let(:second_duplicate) { create(:group, name: 'Digital Services') }
+
+        it 'appends -1 to the group name' do
+          expect(second_duplicate.slug).to eql('ministry-of-justice-digital-services-2')
+        end
+      end
+    end
+  end
+end

data/spec/models/peoplefinder/information_request_spec.rb

@@ -0,0 +1,8 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::InformationRequest, type: :model do
+  it { should belong_to(:recipient) }
+  it { should validate_presence_of(:recipient_id) }
+  it { should validate_presence_of(:sender_email) }
+  it { should validate_presence_of(:message) }
+end

data/spec/models/peoplefinder/membership_spec.rb

@@ -0,0 +1,12 @@
+require 'rails_helper'
+
+RSpec.describe Peoplefinder::Membership, type: :model do
+  it { should validate_presence_of(:person).on(:update) }
+  it { should validate_presence_of(:group).on(:update) }
+
+  let!(:membership) { create(:membership) }
+
+  it 'is not be a leader by default' do
+    expect(membership.leader?).to be false
+  end
+end