fat_free_crm 0.20.1 → 0.21.0

data/spec/lib/errors_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-# 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', password: 'ouchmyrib')
-    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', password: 'doyoulikeapples')
-    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

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-# 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(:data_source_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(:data_source_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

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-# 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 = 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
-      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
-      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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-# 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
-      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 = 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 = 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

@@ -1,306 +0,0 @@
-# frozen_string_literal: true
-
-# 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)
-      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
-      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
-      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 = 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 = 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 = 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])
-      create(:user, email: "aaron@example.com")
-    end
-
-    it "should find the asset and attach the email message" do
-      @lead = 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
-      create(:user, email: "aaron@example.com")
-      mock_message(DROPBOX_EMAILS[:forwarded])
-    end
-
-    it "should find the asset and attach the email message" do
-      @lead = 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 = 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 = 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"]
-
-      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 = create(:lead, email: "ben@example.com", access: "Public")
-      @lead_dropbox = 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
-      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(%r{</?[^>]*>})
-    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