reduced_fat_crm 0.14.0

data/spec/lib/errors_spec.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'ActiveModel Validation Errors' do
+  it 'should render explicit error message if it starts with a caret' do
+    class Adam < User
+      validates_presence_of :title, message: '^Missing title'
+    end
+
+    adam = Adam.create(username: 'adam', email: 'adam@example.com')
+    expect(adam.valid?).to eq(false)
+    expect(adam.errors[:title]).to eq(['^Missing title'])
+    expect(adam.errors.full_messages[0]).to eq('Missing title')
+  end
+
+  it 'should exhibit default behavior' do
+    class Eve < User
+      validates_presence_of :title, message: 'missing'
+    end
+
+    eve = Eve.create(username: 'eve', email: 'eve@example.com')
+    expect(eve.valid?).to eq(false)
+    expect(eve.errors[:title]).to eq(['missing'])
+    expect(eve.errors.full_messages[0]).to eq('Title missing')
+  end
+end

data/spec/lib/fields_spec.rb

@@ -0,0 +1,99 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'FatFreeCRM::Fields' do
+  class Foo
+    include FatFreeCRM::Fields
+    include ActiveModel::Validations
+    has_fields
+  end
+
+  class Bar
+    include FatFreeCRM::Fields
+    include ActiveModel::Validations
+  end
+
+  it do
+    expect(Foo.new).to respond_to(:field_groups)
+  end
+
+  it do
+    expect(Foo).to respond_to(:serialize_custom_fields!)
+  end
+
+  it do
+    expect(Foo).to respond_to(:fields)
+  end
+
+  it "calling has_fields should invoke serialize_custom_fields!" do
+    expect(Bar).to receive(:serialize_custom_fields!)
+    Bar.has_fields
+  end
+
+  describe "field_groups" do
+    it "should call FieldGroup" do
+      expect(ActiveRecord::Base.connection).to receive(:table_exists?).with('field_groups').and_return(true)
+      dummy_scope = double
+      expect(dummy_scope).to receive(:order).with(:position)
+      expect(FieldGroup).to receive(:where).and_return(dummy_scope)
+      Foo.new.field_groups
+    end
+
+    it "should not call FieldGroup if table doesn't exist (migrations not yet run)" do
+      expect(ActiveRecord::Base.connection).to receive(:table_exists?).with('field_groups').and_return(false)
+      expect(Foo.new.field_groups).to eq([])
+    end
+  end
+
+  describe "fields" do
+    before(:each) do
+      @f1 = double(Field)
+      @f2 = double(Field)
+      @f3 = double(Field)
+      @field_groups = [double(FieldGroup, fields: [@f1, @f2]), double(FieldGroup, fields: [@f3])]
+    end
+
+    it "should convert field_groups into a flattened list of fields" do
+      expect(Foo).to receive(:field_groups).and_return(@field_groups)
+      expect(Foo.fields).to eq([@f1, @f2, @f3])
+    end
+  end
+
+  describe "serialize_custom_fields!" do
+    before(:each) do
+      @f1 = double(Field, as: 'check_boxes', name: 'field1')
+      @f2 = double(Field, as: 'date', name: 'field2')
+    end
+
+    it "should serialize checkbox fields as Array" do
+      allow(Foo).to receive(:serialized_attributes).and_return(field1: @f1, field2: @f2)
+      expect(Foo).to receive(:fields).and_return([@f1, @f2])
+      expect(Foo).to receive(:serialize).with(:field1, Array)
+      Foo.serialize_custom_fields!
+    end
+  end
+
+  it "should validate custom fields" do
+    foo = Foo.new
+    expect(foo).to receive(:custom_fields_validator)
+    expect(foo).to be_valid
+  end
+
+  describe "custom_fields_validator" do
+    before(:each) do
+      @f1 = double(Field)
+      @field_groups = [double(FieldGroup, fields: [@f1])]
+    end
+
+    it "should call custom_validator on each custom field" do
+      foo = Foo.new
+      expect(@f1).to receive(:custom_validator).with(foo)
+      expect(foo).to receive(:field_groups).and_return(@field_groups)
+      expect(foo).to be_valid
+    end
+  end
+end

data/spec/lib/mail_processor/base_spec.rb

@@ -0,0 +1,167 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require File.dirname(__FILE__) + '/sample_emails/dropbox'
+
+require "fat_free_crm/mail_processor/base"
+
+describe FatFreeCRM::MailProcessor::Base do
+  include MockIMAP
+
+  before do
+    @mock_address = "base-mail-processor@example.com"
+  end
+
+  before(:each) do
+    @crawler = FatFreeCRM::MailProcessor::Base.new
+    # MailProcessor::Base doesn't load any settings by default
+    @crawler.instance_variable_set "@settings",
+                                   server:   "example.com",
+                                   port:     "123",
+                                   ssl:      true,
+                                   address:  "test@example.com",
+                                   user:     "test@example.com",
+                                   password: "123"
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Connecting to the IMAP server" do
+    it "should connect to the IMAP server and login as user, and select folder" do
+      mock_imap
+      expect(@imap).to receive(:login).once.with(@settings[:user], @settings[:password])
+      expect(@imap).to receive(:select).once.with(@settings[:scan_folder])
+      @crawler.send(:connect!)
+    end
+
+    it "should connect to the IMAP server, login as user, but not select folder when requested so" do
+      mock_imap
+      expect(@imap).to receive(:login).once.with(@settings[:user], @settings[:password])
+      expect(@imap).not_to receive(:select).with(@settings[:scan_folder])
+      @crawler.send(:connect!, setup: true)
+    end
+
+    it "should raise the error if connection fails" do
+      expect(Net::IMAP).to receive(:new).and_raise(SocketError) # No mocks this time! :-)
+      expect(@crawler.send(:connect!)).to eq(nil)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Disconnecting from the IMAP server" do
+    it "should logout and diconnect" do
+      mock_connect
+      mock_disconnect
+      expect(@imap).to receive(:logout).once
+      expect(@imap).to receive(:disconnect).once
+
+      @crawler.send(:connect!)
+      @crawler.send(:disconnect!)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Discarding a message" do
+    before(:each) do
+      mock_connect
+      @uid = double
+      @crawler.send(:connect!)
+    end
+
+    it "should copy message to invalid folder if it's set and flag the message as deleted" do
+      @settings[:move_invalid_to_folder] = "invalid"
+      expect(@imap).to receive(:uid_copy).once.with(@uid, @settings[:move_invalid_to_folder])
+      expect(@imap).to receive(:uid_store).once.with(@uid, "+FLAGS", [:Deleted])
+      @crawler.send(:discard, @uid)
+    end
+
+    it "should not copy message to invalid folder if it's not set and flag the message as deleted" do
+      @settings[:move_invalid_to_folder] = nil
+      expect(@imap).not_to receive(:uid_copy)
+      expect(@imap).to receive(:uid_store).once.with(@uid, "+FLAGS", [:Deleted])
+      @crawler.send(:discard, @uid)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Archiving a message" do
+    before(:each) do
+      mock_connect
+      @uid = double
+      @crawler.send(:connect!)
+    end
+
+    it "should copy message to archive folder if it's set and flag the message as seen" do
+      @settings[:move_to_folder] = "processed"
+      expect(@imap).to receive(:uid_copy).once.with(@uid, @settings[:move_to_folder])
+      expect(@imap).to receive(:uid_store).once.with(@uid, "+FLAGS", [:Seen])
+      @crawler.send(:archive, @uid)
+    end
+
+    it "should not copy message to archive folder if it's not set and flag the message as seen" do
+      @settings[:move_to_folder] = nil
+      expect(@imap).not_to receive(:uid_copy)
+      expect(@imap).to receive(:uid_store).once.with(@uid, "+FLAGS", [:Seen])
+      @crawler.send(:archive, @uid)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Validating email" do
+    before(:each) do
+      @email = double
+    end
+
+    it "should be valid email if its contents type is text/plain" do
+      allow(@email).to receive(:content_type).and_return("text/plain")
+      expect(@crawler.send(:is_valid?, @email)).to eq(true)
+    end
+
+    it "should be invalid email if its contents type is not text/plain" do
+      allow(@email).to receive(:content_type).and_return("text/html")
+      expect(@crawler.send(:is_valid?, @email)).to eq(false)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Finding email sender among users" do
+    before(:each) do
+      @from = ["Aaron@Example.Com", "Ben@Example.com"]
+      @email = double
+      allow(@email).to receive(:from).and_return(@from)
+    end
+
+    it "should find non-suspended user that matches From: field" do
+      @user = FactoryGirl.create(:user, email: @from.first, suspended_at: nil)
+      expect(@crawler.send(:sent_from_known_user?, @email)).to eq(true)
+      expect(@crawler.instance_variable_get("@sender")).to eq(@user)
+    end
+
+    it "should not find user if his email doesn't match From: field" do
+      FactoryGirl.create(:user, email: "nobody@example.com")
+      expect(@crawler.send(:sent_from_known_user?, @email)).to eq(false)
+      expect(@crawler.instance_variable_get("@sender")).to eq(nil)
+    end
+
+    it "should not find user if his email matches From: field but is suspended" do
+      FactoryGirl.create(:user, email: @from.first, suspended_at: Time.now)
+      expect(@crawler.send(:sent_from_known_user?, @email)).to eq(false)
+      expect(@crawler.instance_variable_get("@sender")).to eq(nil)
+    end
+
+    #------------------------------------------------------------------------------
+    describe "Extracting plain text body" do
+      it "should extract text from multipart text/plain" do
+        text = @crawler.send(:plain_text_body, Mail.new(DROPBOX_EMAILS[:plain]))
+        expect(text).to be_present
+      end
+
+      it "should extract text and strip tags from multipart text/html" do
+        text = @crawler.send(:plain_text_body, Mail.new(DROPBOX_EMAILS[:multipart]))
+        expect(text).to eql('Hello,')
+      end
+    end
+  end
+end

data/spec/lib/mail_processor/comment_replies_spec.rb

@@ -0,0 +1,68 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require "fat_free_crm/mail_processor/comment_replies"
+
+describe FatFreeCRM::MailProcessor::CommentReplies do
+  include MockIMAP
+
+  before do
+    @mock_address = "crm-comment@example.com"
+  end
+
+  before(:each) do
+    @crawler = FatFreeCRM::MailProcessor::CommentReplies.new
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Processing new emails" do
+    before do
+      FactoryGirl.create(:user, email: "aaron@example.com")
+    end
+
+    before(:each) do
+      mock_connect
+      mock_disconnect
+    end
+
+    it "should attach a new comment to a contact" do
+      @contact = FactoryGirl.create(:contact)
+      comment_reply = "This is a new comment reply via email"
+
+      mail = Mail.new from:    "Aaron Assembler <aaron@example.com>",
+                      to:      "FFCRM Comments <crm-commment@example.com>",
+                      subject: "[contact:#{@contact.id}] Test Contact",
+                      body:    comment_reply
+      mock_message mail.to_s
+
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_recipients)
+      @crawler.run
+
+      expect(@contact.comments.size).to eq(1)
+      expect(@contact.comments.first.comment).to eq(comment_reply)
+    end
+
+    it "should attach a new comment to an opportunity, using the 'op' shortcut in subject" do
+      @opportunity = FactoryGirl.create(:opportunity)
+      comment_reply = "This is a new comment reply via email"
+
+      mail = Mail.new from:    "Aaron Assembler <aaron@example.com>",
+                      to:      "FFCRM Comments <crm-commment@example.com>",
+                      subject: "[op:#{@opportunity.id}] Test Opportunity",
+                      body:    comment_reply
+      mock_message mail.to_s
+
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_recipients)
+      @crawler.run
+
+      expect(@opportunity.comments.size).to eq(1)
+      expect(@opportunity.comments.first.comment).to eq(comment_reply)
+    end
+  end
+end

data/spec/lib/mail_processor/dropbox_spec.rb

@@ -0,0 +1,304 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require File.dirname(__FILE__) + '/sample_emails/dropbox'
+
+require "fat_free_crm/mail_processor/dropbox"
+
+describe FatFreeCRM::MailProcessor::Dropbox do
+  include MockIMAP
+
+  before(:each) do
+    @mock_address = "dropbox@example.com"
+    @crawler = FatFreeCRM::MailProcessor::Dropbox.new
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Running the crawler" do
+    before(:each) do
+      mock_connect
+      mock_disconnect
+      mock_message(DROPBOX_EMAILS[:plain])
+    end
+
+    it "should discard a message if it's invalid" do
+      expect(@crawler).to receive(:is_valid?).once.and_return(false)
+      FactoryGirl.create(:user, email: "aaron@example.com")
+      expect(@crawler).not_to receive(:archive)
+      expect(@crawler).to receive(:discard).once
+      @crawler.run
+    end
+
+    it "should discard a message if it can't find the user" do
+      expect(@crawler).to receive(:is_valid?).once.and_return(true)
+      expect(@crawler).not_to receive(:archive)
+      expect(@crawler).to receive(:discard).once
+      @crawler.run
+    end
+
+    it "should process a message if it finds the user" do
+      FactoryGirl.create(:user, email: "aaron@example.com")
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:discard)
+      @crawler.run
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Pipeline: processing keywords on the first line" do
+    before(:each) do
+      mock_connect
+      mock_disconnect
+      FactoryGirl.create(:user, email: "aaron@example.com")
+    end
+
+    it "should find the named asset and attach the email message" do
+      mock_message(DROPBOX_EMAILS[:first_line])
+      @campaign = FactoryGirl.create(:campaign, name: "Got milk!?")
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_recipients)
+      @crawler.run
+
+      expect(@campaign.emails.size).to eq(1)
+      expect(@campaign.emails.first.mediator).to eq(@campaign)
+    end
+
+    it "should create the named asset and attach the email message" do
+      mock_message(DROPBOX_EMAILS[:first_line])
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_recipients)
+      @crawler.run
+
+      @campaign = Campaign.find_by(name: 'Got milk')
+      expect(@campaign).to be_instance_of(Campaign)
+      expect(@campaign.emails.size).to eq(1)
+      expect(@campaign.emails.first.mediator).to eq(@campaign)
+    end
+
+    it "should find the lead and attach the email message" do
+      mock_message(DROPBOX_EMAILS[:first_line_lead])
+      @lead = FactoryGirl.create(:lead, first_name: "Cindy", last_name: "Cluster")
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_recipients)
+      @crawler.run
+
+      expect(@lead.emails.size).to eq(1)
+      expect(@lead.emails.first.mediator).to eq(@lead)
+    end
+
+    it "should create the lead and attach the email message" do
+      mock_message(DROPBOX_EMAILS[:first_line_lead])
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_recipients)
+      @crawler.run
+
+      @lead = Lead.find_by(first_name: 'Cindy', last_name: 'Cluster')
+      expect(@lead).to be_instance_of(Lead)
+      expect(@lead.status).to eq("contacted")
+      expect(@lead.emails.size).to eq(1)
+      expect(@lead.emails.first.mediator).to eq(@lead)
+    end
+
+    it "should find the contact and attach the email message" do
+      mock_message(DROPBOX_EMAILS[:first_line_contact])
+      @contact = FactoryGirl.create(:contact, first_name: "Cindy", last_name: "Cluster")
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_recipients)
+      @crawler.run
+
+      expect(@contact.emails.size).to eq(1)
+      expect(@contact.emails.first.mediator).to eq(@contact)
+    end
+
+    it "should create the contact and attach the email message" do
+      mock_message(DROPBOX_EMAILS[:first_line_contact])
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_recipients)
+      @crawler.run
+
+      @contact = Contact.find_by(first_name: 'Cindy', last_name: 'Cluster')
+      expect(@contact).to be_instance_of(Contact)
+      expect(@contact.emails.size).to eq(1)
+      expect(@contact.emails.first.mediator).to eq(@contact)
+    end
+
+    it "should move on if first line has no keyword" do
+      mock_message(DROPBOX_EMAILS[:plain])
+      expect(@crawler).to receive(:with_recipients).twice
+      expect(@crawler).to receive(:with_forwarded_recipient).twice
+      @crawler.run
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Pipeline: processing recipients (To: recipient, Bcc: dropbox)" do
+    before(:each) do
+      mock_connect
+      mock_disconnect
+      mock_message(DROPBOX_EMAILS[:plain])
+      FactoryGirl.create(:user, email: "aaron@example.com")
+    end
+
+    it "should find the asset and attach the email message" do
+      @lead = FactoryGirl.create(:lead, email: "ben@example.com", access: "Public")
+      expect(@crawler).to receive(:archive).once
+      expect(@crawler).not_to receive(:with_forwarded_recipient)
+      @crawler.run
+
+      expect(@lead.emails.size).to eq(1)
+      expect(@lead.emails.first.mediator).to eq(@lead)
+    end
+
+    it "should create the asset and attach the email message" do
+      expect(@crawler).to receive(:archive).once
+      expect { @crawler.run }.to change(Contact, :count).by(1)
+
+      @contact = Contact.last
+      expect(@contact.emails.size).to eq(1)
+      expect(@contact.emails.first.mediator).to eq(@contact)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Pipeline: processing forwarded recipient (To: dropbox)" do
+    before(:each) do
+      mock_connect
+      mock_disconnect
+      FactoryGirl.create(:user, email: "aaron@example.com")
+      mock_message(DROPBOX_EMAILS[:forwarded])
+    end
+
+    it "should find the asset and attach the email message" do
+      @lead = FactoryGirl.create(:lead, email: "ben@example.com", access: "Public")
+      expect(@crawler).to receive(:archive).once
+      @crawler.run
+
+      expect(@lead.emails.size).to eq(1)
+      expect(@lead.emails.first.mediator).to eq(@lead)
+    end
+
+    it "should touch the asset" do
+      now = Time.zone.now
+      timezone = ActiveRecord::Base.default_timezone
+      begin
+        ActiveRecord::Base.default_timezone = :utc
+        @lead = FactoryGirl.create(:lead, email: "ben@example.com", access: "Public", updated_at: 5.day.ago)
+
+        @crawler.run
+        expect(@lead.reload.updated_at.to_i).to be >= now.to_i
+      ensure
+        ActiveRecord::Base.default_timezone = timezone
+      end
+    end
+
+    it "should change lead's status (:new => :contacted)" do
+      @lead = FactoryGirl.create(:lead, email: "ben@example.com", access: "Public", status: "new")
+
+      @crawler.run
+      expect(@lead.reload.status).to eq("contacted")
+    end
+
+    it "should move on if forwarded recipient did not match" do
+      expect(@crawler).to receive(:with_forwarded_recipient).twice
+      @crawler.run
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Pipeline: processing forwarded recipient from email sent to dropbox alias address" do
+    before(:each) do
+      @mock_address = "dropbox-alias-address@example.com"
+      mock_connect
+      mock_disconnect
+
+      @settings = @crawler.instance_variable_get("@settings")
+      @settings[:address_aliases] = ["dropbox@example.com"]
+
+      FactoryGirl.create(:user, email: "aaron@example.com")
+      mock_message(DROPBOX_EMAILS[:forwarded])
+    end
+
+    it "should not match the dropbox email address if routed to an alias" do
+      @lead = FactoryGirl.create(:lead, email: "ben@example.com", access: "Public")
+      @lead_dropbox = FactoryGirl.create(:lead, email: "dropbox@example.com", access: "Public")
+
+      expect(@crawler).to receive(:archive).once
+      @crawler.run
+
+      expect(@lead_dropbox.emails.size).to eq(0)
+      expect(@lead.emails.size).to eq(1)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Pipeline: creating recipient if s/he was not found" do
+    before(:each) do
+      mock_connect
+      mock_disconnect
+      FactoryGirl.create(:user, email: "aaron@example.com")
+    end
+
+    it "should create a contact from the email recipient (To: recipient, Bcc: dropbox)" do
+      mock_message(DROPBOX_EMAILS[:plain])
+      expect(@crawler).to receive(:archive).once
+      @crawler.run
+
+      @contact = Contact.first
+      expect(@contact.email).to eq("ben@example.com")
+      expect(@contact.emails.size).to eq(1)
+      expect(@contact.emails.first.mediator).to eq(@contact)
+    end
+
+    it "should create a contact from the forwarded email (To: dropbox)" do
+      mock_message(DROPBOX_EMAILS[:forwarded])
+      expect(@crawler).to receive(:archive).once
+      @crawler.run
+
+      @contact = Contact.first
+      expect(@contact.email).to eq("ben@example.com")
+      expect(@contact.emails.size).to eq(1)
+      expect(@contact.emails.first.mediator).to eq(@contact)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Extracting body" do
+    before do
+      @dropbox = FatFreeCRM::MailProcessor::Dropbox.new
+    end
+
+    it "should extract text from multipart text/plain" do
+      text = @dropbox.send(:plain_text_body, Mail.new(DROPBOX_EMAILS[:plain]))
+      expect(text).to be_present
+    end
+
+    it "should extract text and strip tags from multipart text/html" do
+      text = @dropbox.send(:plain_text_body, Mail.new(DROPBOX_EMAILS[:html]))
+      expect(text).to be_present
+      expect(text).not_to match(/<\/?[^>]*>/)
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe "Default values" do
+    describe "'access'" do
+      it "should be 'Private' if default setting is 'Private'" do
+        allow(Setting).to receive(:default_access).and_return('Private')
+        expect(@crawler.send(:default_access)).to eq("Private")
+      end
+
+      it "should be 'Public' if default setting is 'Public'" do
+        allow(Setting).to receive(:default_access).and_return('Public')
+        expect(@crawler.send(:default_access)).to eq("Public")
+      end
+
+      it "should be 'Private' if default setting is 'Shared'" do
+        allow(Setting).to receive(:default_access).and_return('Shared')
+        expect(@crawler.send(:default_access)).to eq("Private")
+      end
+    end
+  end
+end