mongoid-ultra 9.0.0.0.alpha1

data/spec/mongoid/validatable_spec.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Validatable do
+
+  let(:account) do
+    Account.new(name: "Testing a really long name.")
+  end
+
+  describe "#read_attribute_for_validation" do
+
+    let(:person) do
+      Person.new(title: "Mr")
+    end
+
+    let!(:address) do
+      person.addresses.build(street: "Wienerstr")
+    end
+
+    context "when reading a field" do
+
+      let(:value) do
+        person.read_attribute_for_validation(:title)
+      end
+
+      it "returns the value" do
+        expect(value).to eq("Mr")
+      end
+    end
+
+    context "when reading a relation" do
+
+      let(:value) do
+        person.read_attribute_for_validation(:addresses)
+      end
+
+      let(:documents) do
+        Mongoid::Association::Referenced::HasMany::Enumerable.new([ address ])
+      end
+
+      before do
+        person.instance_variable_set(:@addresses, documents)
+      end
+
+      it "returns the value" do
+        expect(value).to eq([ address ])
+      end
+    end
+
+    context "when validating a non field" do
+
+      let(:princess) do
+        Princess.new
+      end
+
+      let(:value) do
+        princess.read_attribute_for_validation(:color)
+      end
+
+      it "does not error on the read" do
+        expect(value).to be_empty
+      end
+    end
+  end
+
+  describe "#valid?" do
+
+    context "when provided a context" do
+
+      it "uses the provided context" do
+        expect(account).to be_valid(:update)
+      end
+
+      context 'when multiple contexts are provided' do
+
+        let(:princess) do
+          Princess.new
+        end
+
+        let(:validation) do
+          princess.valid?([:create, :update])
+        end
+
+        it 'validates using each context' do
+          expect(validation).to be(false)
+          expect(princess.errors.messages.keys).to eq([:color, :name])
+        end
+      end
+    end
+
+    context "when not provided a context" do
+
+      context "when the document is new" do
+
+        it "defaults the context to :create" do
+          expect(account).to_not be_valid
+        end
+      end
+
+      context "when the document is persisted" do
+
+        before do
+          account.name = "Testing"
+          account.save!
+          account.name = "Testing a really long name."
+        end
+
+        it "defaults the context to :update" do
+          expect(account).to be_valid
+        end
+      end
+    end
+
+    context "when the document is fresh from the database" do
+
+      let!(:pizza) do
+        Pizza.new(name: "chicago")
+      end
+
+      before do
+        pizza.build_topping(name: "cheese")
+        pizza.save!
+      end
+
+      let(:from_db) do
+        Pizza.first
+      end
+
+      it "loads the required association from the db" do
+        expect(from_db).to be_valid
+      end
+    end
+
+    context "when validating associated" do
+
+      context "when the child validates the parent" do
+
+        let(:movie) do
+          Movie.new
+        end
+
+        context "when the child is invalid" do
+
+          let(:rating) do
+            Rating.new(value: 1000)
+          end
+
+          before do
+            movie.ratings << rating
+          end
+
+          context "when validating once" do
+
+            it "returns false" do
+              expect(movie).to_not be_valid
+            end
+
+            it "adds the errors to the document" do
+              movie.valid?
+              expect(movie.errors[:ratings]).to eq([ "is invalid" ])
+            end
+          end
+
+          context "when validating multiple times" do
+
+            it "returns false every time" do
+              expect(movie).to_not be_valid
+              expect(movie).to_not be_valid
+            end
+          end
+        end
+      end
+
+      context "when the child does not validate the parent" do
+
+        before(:all) do
+          Person.validates_associated(:services)
+        end
+
+        after(:all) do
+          Person.reset_callbacks(:validate)
+        end
+
+        let(:person) do
+          Person.new
+        end
+
+        context "when the child is invalid" do
+
+          let(:service) do
+            Service.new(sid: "invalid")
+          end
+
+          before do
+            person.services << service
+          end
+
+          context "when validating once" do
+
+            it "returns false" do
+              expect(person).to_not be_valid
+            end
+
+            it "adds the errors to the document" do
+              person.valid?
+              expect(person.errors[:services]).to eq([ "is invalid" ])
+            end
+          end
+
+          context "when validating multiple times" do
+
+            it "returns false every time" do
+              expect(person).to_not be_valid
+              expect(person).to_not be_valid
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe ".validates_associated" do
+
+    let(:klass) do
+      Class.new do
+        include Mongoid::Document
+      end
+    end
+
+    context "when adding via the traditional macro" do
+
+      before do
+        klass.validates_associated(:name)
+      end
+
+      it "adds the validator" do
+        expect(klass.validators.first).to be_a(
+          Mongoid::Validatable::AssociatedValidator
+        )
+      end
+    end
+
+    context "when adding via the new syntax" do
+
+      before do
+        klass.validates(:name, associated: true)
+      end
+
+      it "adds the validator" do
+        expect(klass.validators.first).to be_a(
+          Mongoid::Validatable::AssociatedValidator
+        )
+      end
+    end
+  end
+
+  describe ".validates_uniqueness_of" do
+
+    let(:klass) do
+      Class.new do
+        include Mongoid::Document
+      end
+    end
+
+    context "when adding via the traditional macro" do
+
+      before do
+        klass.validates_uniqueness_of(:name)
+      end
+
+      it "adds the validator" do
+        expect(klass.validators.first).to be_a(
+          Mongoid::Validatable::UniquenessValidator
+        )
+      end
+    end
+
+    context "when adding via the new syntax" do
+
+      before do
+        klass.validates(:name, uniqueness: true)
+      end
+
+      it "adds the validator" do
+        expect(klass.validators.first).to be_a(
+          Mongoid::Validatable::UniquenessValidator
+        )
+      end
+    end
+  end
+
+  describe ".validates_presence_of" do
+
+    let(:klass) do
+      Class.new do
+        include Mongoid::Document
+      end
+    end
+
+    context "when adding via the traditional macro" do
+
+      before do
+        klass.validates_presence_of(:name)
+      end
+
+      it "adds the validator" do
+        expect(klass.validators.first).to be_a(
+          Mongoid::Validatable::PresenceValidator
+        )
+      end
+    end
+
+    context "when adding via the new syntax" do
+
+      before do
+        klass.validates(:name, presence: true)
+      end
+
+      it "adds the validator" do
+        expect(klass.validators.first).to be_a(
+          Mongoid::Validatable::PresenceValidator
+        )
+      end
+    end
+  end
+end

data/spec/mongoid/warnings_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Warnings do
+
+  describe ".warn_*" do
+
+    context "when calling a warn_* method" do
+
+      let(:id) { :geo_haystack_deprecated }
+      let(:message) do
+        'The geoHaystack type is deprecated.'
+      end
+
+      before do
+        warn_id = id
+        Mongoid::Warnings.class_eval do
+          instance_variable_set("@#{warn_id}", false)
+        end
+      end
+
+      it "logs the warning" do
+        expect_any_instance_of(Logger).to receive(:warn).once.with(message)
+        Mongoid::Warnings.send("warn_#{id}")
+      end
+
+      it "logs the warning only once" do
+        expect_any_instance_of(Logger).to receive(:warn).once.with(message)
+        Mongoid::Warnings.send("warn_#{id}")
+        Mongoid::Warnings.send("warn_#{id}")
+      end
+    end
+  end
+end

data/spec/mongoid_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid do
+
+  describe ".configure" do
+
+    context "when no block supplied" do
+
+      it "returns the config singleton" do
+        expect(Mongoid.configure).to eq(Mongoid::Config)
+      end
+    end
+
+    context "when a block is given" do
+      config_override :preload_models, false
+
+      context "with arity 0" do
+
+        before do
+          Mongoid.configure do
+            config.preload_models = true
+          end
+        end
+
+        it "sets the values on the config instance" do
+          expect(Mongoid.preload_models).to be true
+        end
+      end
+
+      context "with arity 1" do
+
+        before do
+          Mongoid.configure do |config|
+            config.preload_models = true
+          end
+        end
+
+        it "sets the values on the config instance" do
+          expect(Mongoid.preload_models).to be true
+        end
+      end
+
+      context "with arity 2" do
+
+        before do
+          Mongoid.configure do |config, _other|
+            config.preload_models = true
+          end
+        end
+
+        it "sets the values on the config instance" do
+          expect(Mongoid.preload_models).to be true
+        end
+      end
+    end
+  end
+
+  describe ".default_client" do
+
+    it "returns the default client" do
+      expect(Mongoid.default_client).to eq(Mongoid::Clients.default)
+    end
+  end
+
+  describe ".disconnect_clients" do
+
+    let(:clients) do
+      Mongoid::Clients.clients.values
+    end
+
+    before do
+      Band.all.entries
+    end
+
+    it "disconnects from all active clients" do
+      clients.each do |client|
+        expect(client.cluster).to receive(:disconnect!).and_call_original
+      end
+      Mongoid.disconnect_clients
+    end
+  end
+
+  describe ".client" do
+
+    it "returns the named client" do
+      expect(Mongoid.client(:default)).to eq(Mongoid::Clients.default)
+    end
+  end
+
+  describe ".models" do
+
+    it "returns the list of known models" do
+      expect(Mongoid.models).to include(Band)
+    end
+  end
+end

data/spec/rails/controller_extension/controller_runtime_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "mongoid/railties/controller_runtime"
+
+describe "Mongoid::Railties::ControllerRuntime" do
+  controller_runtime = Mongoid::Railties::ControllerRuntime
+  collector = controller_runtime::Collector
+
+  def set_metric value
+    Thread.current["Mongoid.controller_runtime"] = value
+  end
+
+  def clear_metric!
+    set_metric 0
+  end
+
+  describe "Collector" do
+
+    it "stores the metric in thread-safe manner" do
+      clear_metric!
+      expect(collector.runtime).to eq(0)
+      set_metric 42
+      expect(collector.runtime).to eq(42)
+    end
+
+    it "sets metric on both succeeded and failed" do
+      instance = collector.new
+      event_payload = OpenStruct.new duration: 42
+
+      clear_metric!
+      instance.succeeded event_payload
+      expect(collector.runtime).to eq(42000)
+
+      clear_metric!
+      instance.failed event_payload
+      expect(collector.runtime).to eq(42000)
+    end
+
+    it "resets the metric and returns the value" do
+      clear_metric!
+      expect(collector.reset_runtime).to eq(0)
+      set_metric 42
+      expect(collector.reset_runtime).to eq(42)
+      expect(collector.runtime).to eq(0)
+    end
+
+  end
+
+  reference_controller_class = Class.new do
+    def process_action *_
+      @process_action = true
+    end
+
+    def cleanup_view_runtime *_
+      @cleanup_view_runtime.call
+    end
+
+    def append_info_to_payload *_
+      @append_info_to_payload = true
+    end
+
+    def self.log_process_action *_
+      @log_process_action.call
+    end
+  end
+
+  controller_class = Class.new reference_controller_class do
+    include controller_runtime::ControllerExtension
+  end
+
+  let(:controller){ controller_class.new }
+
+  it "resets the metric before each action" do
+    set_metric 42
+    controller.send(:process_action, 'foo')
+    expect(collector.runtime).to be(0)
+    expect(controller.instance_variable_get "@process_action").to be(true)
+  end
+
+  it "strips the metric of other sources of the runtime" do
+    set_metric 1
+    controller.instance_variable_set "@cleanup_view_runtime", ->{
+      controller.instance_variable_set "@cleanup_view_runtime", true
+      set_metric 13
+      42
+    }
+    returned = controller.send :cleanup_view_runtime
+    expect(controller.instance_variable_get "@cleanup_view_runtime").to be(true)
+    expect(controller.mongoid_runtime).to eq(14)
+    expect(returned).to be(29)
+  end
+
+  it "appends the metric to payload" do
+    payload = {}
+    set_metric 42
+    controller.send :append_info_to_payload, payload
+    expect(controller.instance_variable_get "@append_info_to_payload").to be(true)
+    expect(payload[:mongoid_runtime]).to eq(42)
+  end
+
+  it "adds metric to log message" do
+    controller_class.instance_variable_set "@log_process_action", ->{
+      controller_class.instance_variable_set "@log_process_action", true
+      []
+    }
+    messages = controller_class.log_process_action mongoid_runtime: 42.101
+    expect(controller_class.instance_variable_get "@log_process_action").to be(true)
+    expect(messages).to eq(["MongoDB: 42.1ms"])
+  end
+
+end

data/spec/rails/mongoid_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/feature_sandbox"
+
+describe "Rails::Mongoid" do
+  let(:model_root) do
+    File.absolute_path(
+      File.join(
+        File.dirname(__FILE__),
+        "../support/models/sandbox"
+      ))
+  end
+
+  around :each do |example|
+    FeatureSandbox.quarantine do
+      require "rails/mongoid"
+      $LOAD_PATH.push(model_root)
+      example.run
+    end
+  end
+
+  describe ".preload_models" do
+    let(:app) { double(config: config) }
+    let(:config) { double(paths: paths) }
+    let(:paths) { { "app/models" => path } }
+    let(:path) { double(expanded: [ model_root ]) }
+
+    before { Rails::Mongoid.preload_models(app) }
+
+    context "when preload models config is false" do
+      config_override :preload_models, false
+
+      it "does not load any models" do
+        expect(defined?(SandboxMessage)).to be_nil
+        expect(defined?(SandboxUser)).to be_nil
+        expect(defined?(SandboxComment)).to be_nil
+      end
+    end
+
+    context "when preload models config is true" do
+      config_override :preload_models, true
+
+      context "when all models are in the models directory" do
+        it "requires the models" do
+          expect(SandboxMessage.ancestors).to include(Mongoid::Document)
+          expect(SandboxUser.ancestors).to include(Mongoid::Document)
+          expect(SandboxComment.ancestors).to include(Mongoid::Document)
+        end
+      end
+    end
+  end
+end

data/spec/shared/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2020 MongoDB, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/shared/bin/get-mongodb-download-url

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+desired_version, arch = ARGV
+if arch.nil?
+  STDERR.puts "Usage: get-mongodb-download-url desired-version arch"
+  exit 1
+end
+
+$: << File.join(File.dirname(__FILE__), '../lib')
+require 'mrss/server_version_registry'
+
+begin
+  puts Mrss::ServerVersionRegistry.new(desired_version, arch).download_url
+rescue Mrss::ServerVersionRegistry::Error => exc
+  STDERR.puts "Error: #{exc}"
+  exit 2
+end

data/spec/shared/bin/s3-copy

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'aws-sdk-s3'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: s3-copy options"
+
+  opts.on("-r", "--region=REGION", "AWS region to use (default us-east-1)") do |v|
+    options[:region] = v
+  end
+
+  opts.on("-p", "--param=KEY=VALUE", "Specify parameter for new files") do |v|
+    options[:params] ||= {}
+    k, v = v.split('=', 2)
+    options[:params][k.to_sym] = v
+  end
+
+  opts.on("-f", "--from=BUCKET:PATH", "Bucket name and key (or path) to copy from") do |v|
+    options[:from] = v
+  end
+
+  opts.on("-t", "--to=BUCKET:PATH", "Bucket name and key (or path) to write to (may be specified more than once)") do |v|
+    options[:to] ||= []
+    options[:to] << v
+  end
+end.parse!
+
+ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
+
+bucket, key = options.fetch(:from).split(':', 2)
+
+s3 = Aws::S3::Client.new
+
+options.fetch(:to).each do |dest|
+  STDERR.puts "Copying to #{dest}"
+  dbucket, dkey = dest.split(':', 2)
+  s3.copy_object(
+    bucket: dbucket,
+    key: dkey,
+    copy_source: "/#{bucket}/#{key}",
+    **options[:params] || {},
+  )
+end