mongoscript 0.0.8

data/spec/cases/execution_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe MongoScript::Execution do
+  module ObjectWithExecution
+    include MongoScript::ORM::MongoidAdapter
+    include MongoScript::Execution
+  end
+
+  before :all do
+    @original_script_dirs = ObjectWithExecution.script_dirs
+  end
+
+  before :each do
+    ObjectWithExecution.script_dirs = @original_script_dirs
+  end
+
+  it "has a constant for LOADED_SCRIPTS" do
+    MongoScript::Execution::LOADED_SCRIPTS.should be_a(Hash)
+  end
+
+  it "defines ScriptNotFound error < Errno::ENOENT" do
+    MongoScript::Execution::ScriptNotFound.superclass.should == Errno::ENOENT
+  end
+
+  it "defines ExecutionFailure error < RuntimeError" do
+    MongoScript::Execution::ExecutionFailure.superclass.should == RuntimeError
+  end
+
+  it "has a script_dir accessor" do
+    stubby = stub("dir")
+    ObjectWithExecution.script_dirs = stubby
+    ObjectWithExecution.script_dirs.should == stubby
+  end
+
+  it "defaults to the built-in scripts" do
+    location_pieces = File.dirname(__FILE__).split("/")
+    # strip out /spec/cases to get back to the root directory
+    gem_path = location_pieces[0, location_pieces.length - 2].join("/")
+    ObjectWithExecution.script_dirs.should == [File.join(gem_path, "lib", "mongoscript", "javascripts")]
+  end
+
+  describe ".code_for" do
+    before :all do
+      @script_code = File.open(File.join(SCRIPTS_PATH, "sample_script.js")).read
+    end
+
+    before :each do
+      ObjectWithExecution.script_dirs = @original_script_dirs + [SCRIPTS_PATH]
+    end
+
+    it "loads and returns the code for a given file" do
+      ObjectWithExecution.code_for("sample_script").should == @script_code
+    end
+
+    it "loads and returns the code for a given file by symbol" do
+      ObjectWithExecution.code_for(:sample_script).should == @script_code
+    end
+
+    it "stores the value in LOADED_SCRIPTS" do
+      ObjectWithExecution.code_for(:sample_script)
+      ObjectWithExecution::LOADED_SCRIPTS["sample_script"].should == @script_code
+    end
+
+    it "raises a ScriptNotFound error if the file doesn't exist" do
+      File.stubs(:exist?).returns(false)
+      expect { ObjectWithExecution.code_for("i don't exist") }.to raise_exception(ObjectWithExecution::ScriptNotFound)
+    end
+
+    it "will look in all the directories provided" do
+      dir = "/foo/bar"
+      my_script = "a script"
+      ObjectWithExecution.script_dirs << dir
+      File.stubs(:exists?).returns(*(ObjectWithExecution.script_dirs.map {|f| f == dir}))
+
+      # make sure that we try to load the script
+      stubby = stub("file contents")
+      File.expects(:read).with(File.join(dir, "#{my_script}.js")).returns(stubby)
+      ObjectWithExecution.code_for(my_script).should == stubby
+    end
+  end
+
+  describe ".execute_readonly_routine" do
+    it "gets and passes the appropriate code and arguments to be run in readonly mode" do
+      args = [1, 2, {}]
+      name = "scriptname"
+      stubby = stub("code")
+      ObjectWithExecution.expects(:code_for).with(name).returns(stubby)
+      ObjectWithExecution.expects(:execute_readonly_code).with(stubby, *args)
+      ObjectWithExecution.execute_readonly_routine(name, *args)
+    end
+  end
+
+  describe ".execute_readwrite_routine" do
+    it "gets and passes the appropriate code and arguments to be run in readwrite mode" do
+      args = [1, 2, {}]
+      name = "scriptname"
+      stubby = stub("code")
+      ObjectWithExecution.expects(:code_for).with(name).returns(stubby)
+      ObjectWithExecution.expects(:execute_readwrite_code).with(stubby, *args)
+      ObjectWithExecution.execute_readwrite_routine(name, *args)
+    end
+  end
+
+  describe ".execute_readonly_code" do
+    it "executes provided code and arguments in with nolock mode" do
+      args = [1, 2, {}]
+      code = stub("code")
+      ObjectWithExecution.expects(:execute).with(code, args, {:nolock => true})
+      ObjectWithExecution.execute_readonly_code(code, *args)
+    end
+  end
+
+  describe ".execute_readwrite_code" do
+    it "executes provided code and arguments with no Mongo options" do
+      args = [1, 2, {}]
+      code = stub("code")
+      ObjectWithExecution.expects(:execute).with(code, args)
+      ObjectWithExecution.execute_readwrite_code(code, *args)
+    end
+  end
+
+  describe ".execute" do
+    it "executes the command via the Mongo database" do
+      MongoScript.database.expects(:command).returns({"ok" => 1.0})
+      ObjectWithExecution.execute("code")
+    end
+
+    it "executes the code using the eval command" do
+      code = stub("code")
+      MongoScript.database.expects(:command).with(has_entries(:$eval => code)).returns({"ok" => 1.0})
+      ObjectWithExecution.execute(code)
+    end
+
+    it "passes in any arguments provided" do
+      args = [:a, :r, :g, :s]
+      MongoScript.database.expects(:command).with(has_entries(:args => args)).returns({"ok" => 1.0})
+      ObjectWithExecution.execute("code", args)
+    end
+
+    it "merges in any additional options" do
+      options = {:a => stub("options")}
+      MongoScript.database.expects(:command).with(has_entries(options)).returns({"ok" => 1.0})
+      ObjectWithExecution.execute("code", [], options)
+    end
+
+    it "raises an ExecutionFailure error if the result[ok] != 1.0" do
+      MongoScript.database.expects(:command).returns({"result" => {}})
+      expect { ObjectWithExecution.execute("code") }.to raise_exception(MongoScript::Execution::ExecutionFailure)
+    end
+
+    it "returns the retval" do
+      result = stub("result")
+      MongoScript.database.expects(:command).returns({"ok" => 1.0, "retval" => result})
+      ObjectWithExecution.execute("code").should == result
+    end
+  end
+end

data/spec/cases/mongoid_adapter_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe MongoScript::ORM::MongoidAdapter do
+  module ObjectWithMongoidAdapter
+    include MongoScript::ORM::MongoidAdapter
+  end
+
+  class AMongoidClass
+    include Mongoid::Document
+  end
+
+
+  before :all do
+    @adapter = ObjectWithMongoidAdapter
+  end
+
+  describe "#database" do
+    it "returns Mongo::Config.database" do
+      db_stub = stub("database")
+      Mongoid::Config.stubs(:database).returns(db_stub)
+      @adapter.database.should == db_stub
+    end
+  end
+
+  describe "#rehydrate" do
+    it "uses Mongoid::Factory to create the Mongoid doc" do
+      klass = stub("class")
+      hash = stub("document attributes")
+      Mongoid::Factory.expects(:from_db).with(klass, hash)
+      @adapter.rehydrate(klass, hash)
+    end
+
+    it "returns the rehydrated value" do
+      result = stub("document")
+      Mongoid::Factory.stubs(:from_db).returns(result)
+      @adapter.rehydrate("foo", "bar").should == result
+    end
+  end
+
+  describe "#resolve_arguments" do
+    it "resolves any hashes in the arguments" do
+      args = [{}, 2, 3, [], {:c.in => 2}]
+      args.each {|a| @adapter.expects(:resolve_complex_criteria).with(a) if a.is_a?(Hash)}
+      @adapter.resolve_arguments(args)
+    end
+
+    it "returns the mapped results" do
+      args = [{}, 2, 3, [], {:c.in => 2}]
+      stubby = stub("result")
+      @adapter.stubs(:resolve_complex_criteria).returns(stubby)
+      @adapter.resolve_arguments(args).should == args.map {|a| a.is_a?(Hash) ? stubby : a}
+    end
+  end
+
+  describe "#resolve_complex_criteria" do
+    it "recursively replaces any hash values with their own resolve_complex_criteria results" do
+      hash = {:a.in => [1, 2], :c => {:e.exists => false, :f => {:y.ne => 2}}, :f => 3}
+      @adapter.resolve_complex_criteria(hash).should ==
+        {:a=>{"$in"=>[1, 2]}, :c=>{:e=>{"$exists"=>false}, :f=>{:y=>{"$ne"=>2}}}, :f=>3}
+    end
+  end
+
+  describe "#processable_into_parameters?" do
+    it "returns true for Mongoid criteria" do
+      ObjectWithMongoidAdapter.processable_into_parameters?(AMongoidClass.all).should be_true
+    end
+
+    it "returns false for everything else" do
+      ObjectWithMongoidAdapter.processable_into_parameters?(Hash.new).should be_false
+      ObjectWithMongoidAdapter.processable_into_parameters?(Array.new).should be_false
+    end
+  end
+
+  describe "#build_multiquery_parameters" do
+    # this is a mishmash of stubbing and testing against the values assigned via let :)
+
+    let(:criteria) {
+      AMongoidClass.where(:_ids.in => [1, 2, 3]).only(:_id).ascending(:date).limit(4)
+    }
+
+    it "returns nil if provided something other than a Criteria" do
+      ObjectWithMongoidAdapter.build_multiquery_parameters({}).should be_nil
+    end
+
+    it "doesn't change the criteria's options" do
+      expect {
+        ObjectWithMongoidAdapter.build_multiquery_parameters(criteria)
+      }.not_to change(criteria, :options)
+    end
+
+    it "returns the selector as :selector" do
+      selecty = stub("selector")
+      criteria.stubs(:selector).returns(selecty)
+      ObjectWithMongoidAdapter.build_multiquery_parameters(criteria)[:selector].should == selecty
+    end
+
+    it "returns the klass as :klass" do
+      ObjectWithMongoidAdapter.build_multiquery_parameters(criteria)[:klass].should == AMongoidClass
+    end
+
+    it "returns the name of the collection as :collection" do
+      name = stub("name")
+      criteria.collection.stubs(:name).returns(name)
+      ObjectWithMongoidAdapter.build_multiquery_parameters(criteria)[:collection].should == name
+    end
+
+    it "returns the fields to get as :fields" do
+      ObjectWithMongoidAdapter.build_multiquery_parameters(criteria)[:fields].should == {_id: 1, _type: 1}
+    end
+
+    it "returns all other options as :modifiers" do
+      modifiers = criteria.options.dup.delete_if {|k, v| k == :fields}
+      ObjectWithMongoidAdapter.build_multiquery_parameters(criteria)[:modifiers].keys.should == modifiers.keys
+    end
+
+    it "uses Mongo::Support to expand the sort criteria" do
+      sorts = stub("sorted info")
+      Mongo::Support.expects(:array_as_sort_parameters).with(criteria.options[:sort]).returns(sorts)
+      ObjectWithMongoidAdapter.build_multiquery_parameters(criteria)[:modifiers][:sort].should == sorts
+    end
+
+    it "works fine with no sort order" do
+      ObjectWithMongoidAdapter.build_multiquery_parameters(AMongoidClass.all)[:modifiers][:sort].should == {}
+    end
+  end
+end

data/spec/cases/mongoscript_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe MongoScript do
+  describe "modules" do
+    it "includes Execution" do
+      MongoScript.included_modules.should include(MongoScript::Execution)
+    end
+
+    it "includes whatever's determined by orm_adapter" do
+      MongoScript.included_modules.should include(MongoScript.orm_adapter)
+    end
+  end
+
+  describe ".orm_adapter" do
+    it "returns the Mongoid adapter if Mongoid is defined" do
+      Object.stubs(:const_defined?).with("Mongoid").returns(true)
+      MongoScript.orm_adapter.should == MongoScript::ORM::MongoidAdapter
+    end
+
+    it "raises a NoORMError if no Mongo ORM is available" do
+      MongoScript.stubs(:const_defined?).with("Mongoid").returns(false)
+      expect { MongoScript.orm_adapter }.to raise_exception(MongoScript::NoORMError)
+    end
+  end
+end

data/spec/cases/multiquery_spec.rb

@@ -0,0 +1,295 @@
+require 'spec_helper'
+
+describe MongoScript::Multiquery do
+  module ObjectWithMultiquery
+    include MongoScript::ORM::MongoidAdapter
+    include MongoScript::Execution
+    include MongoScript::Multiquery
+  end
+
+  let(:results) {
+    {
+      :cars => 3.times.collect { Car.new.attributes },
+      :canines => 3.times.collect { Car.new.attributes }
+    }
+  }
+
+  let(:queries) {
+    {
+      :cars => {:query => {:_id => {:"$in" => [1, 2, 3]}}},
+      :canines => {:collection => :dogs, :query => {:deleted_at => Time.now}}
+    }
+  }
+
+  let(:normalized_queries) {
+    MongoScript.normalize_queries(queries)
+  }
+
+  let(:mongoized_queries) {
+    MongoScript.mongoize_queries(normalized_queries)
+  }
+
+  it "defines QueryFailedError error < RuntimeError" do
+    MongoScript::Multiquery::QueryFailedError.superclass.should == RuntimeError
+  end
+
+  describe "#multiquery" do
+    # here we just want to test the flow of the method
+    # further tests ensure that each individual call works as expected
+    # we also will have integration tests soon
+    let(:normalized_queries) { stub("normalized queries") }
+    let(:mongoized_queries)  { stub("mongoized queries") }
+    let(:raw_results)        { stub("raw results") }
+    let(:processed_results)  { stub("processed results") }
+
+    before :each do
+      MongoScript.stubs(:normalize_queries).returns(normalized_queries)
+      MongoScript.stubs(:validate_queries!)
+      MongoScript.stubs(:mongoize_queries).returns(mongoized_queries)
+      MongoScript.stubs(:execute_readonly_routine).returns(raw_results)
+      MongoScript.stubs(:process_results).returns(raw_results)
+    end
+
+    it "returns {} without hitting the database if passed {}" do
+      MongoScript.expects(:execute).never
+      MongoScript.multiquery({}).should == {}
+    end
+
+    it "normalizes the queries" do
+      MongoScript.expects(:normalize_queries).with(queries)
+      MongoScript.multiquery(queries)
+    end
+
+    it "validates the normalized queries" do
+      MongoScript.expects(:validate_queries!).with(normalized_queries)
+      MongoScript.multiquery(queries)
+    end
+
+    it "mongoizes the the normalized queries before execution" do
+      MongoScript.expects(:mongoize_queries).with(normalized_queries)
+      MongoScript.multiquery(queries)
+    end
+
+    it "executes the multiquery routine with the mongoized results" do
+      MongoScript.expects(:execute_readonly_routine).with("multiquery", mongoized_queries).returns({})
+      MongoScript.multiquery(queries)
+    end
+
+    it "processes the results and returns them" do
+      MongoScript.expects(:process_results).with(raw_results, normalized_queries)
+      MongoScript.multiquery(queries)
+    end
+
+    it "processes the results and returns them" do
+      MongoScript.stubs(:process_results).returns(processed_results)
+      MongoScript.multiquery(queries).should == processed_results
+    end
+  end
+
+  describe "#normalize_queries" do
+    it "doesn't change the underlying hash" do
+      expect {
+        MongoScript.normalize_queries(queries)
+        # inspect will display all info inside the hash
+        # a good proxy to make sure inside values don't change
+      }.not_to change(queries, :inspect)
+    end
+
+    context "for hashes" do
+      let(:normalized_queries) { MongoScript.normalize_queries(queries) }
+
+      context "determining collection" do
+        it "derives the collection from the name if none is provided" do
+          queries[:cars].delete(:collection)
+          # normalized_query isn't executed until we call it,
+          # so the changes to queries are respected
+          normalized_queries[:cars][:collection].to_s.should == "cars"
+        end
+
+        it "leaves the collection alone if it's provided" do
+          queries[:canines][:collection] = :dogs
+          normalized_queries[:canines][:collection].to_s.should == queries[:canines][:collection].to_s
+        end
+
+        it "checks with indifferent access" do
+          queries[:canines].delete(:collection)
+          queries[:canines]["collection"] = :dogs
+          normalized_queries[:canines][:collection].to_s.should == queries[:canines]["collection"].to_s
+        end
+      end
+
+      context "determining the class" do
+        it "uses the klass entry if it's provided" do
+          queries[:cars][:klass] = Car
+          normalized_queries[:cars][:klass].should == Car
+        end
+
+        it "derives the klass (if not provided) from the specified collection (if provided)" do
+          queries[:cars].delete(:klass)
+          queries[:cars][:collection] = :cars
+          normalized_queries[:cars][:klass].should == Car
+        end
+
+        it "derives the klass (if not provided) from the collection (derived from name)" do
+          queries[:cars].delete(:klass)
+          queries[:cars].delete(:collection)
+          normalized_queries[:cars][:klass].should == Car
+        end
+
+        it "sets klass to false if the klass can't be determined from the collection" do
+          queries[:canines].delete(:collection)
+          queries[:canines].delete(:klass)
+          Object.const_defined?("Canine").should be_false
+          normalized_queries[:canines][:klass].should be_false
+        end
+      end
+    end
+
+    context "for objects processable into queries" do
+      let(:sample_query) {
+        {
+          :cars => stub("Mongoid or other object"),
+          :canines => stub("another object"),
+          :hashy => {:query_type => :hash}
+        }.with_indifferent_access
+      }
+
+      before :each do
+        MongoScript.stubs(:processable_into_parameters?).returns(true)
+      end
+
+      it "sees if it's processable" do
+        MongoScript.stubs(:build_multiquery_parameters)
+        sample_query.values.each do |val|
+          unless val.is_a?(Hash)
+            MongoScript.expects(:processable_into_parameters?).with(val).returns(true)
+          else
+            MongoScript.expects(:processable_into_parameters?).with(val).never
+          end
+        end
+        MongoScript.normalize_queries(sample_query)
+      end
+
+      it "returns the processed values" do
+        # ensure that non-hash values are processed...
+        sample_query.inject({}) do |return_vals, (key, val)|
+          unless val.is_a?(Hash)
+            MongoScript.expects(:build_multiquery_parameters).with(val).returns("my stub value for #{key}")
+          end
+        end
+        # ...and returned appropriately
+        MongoScript.normalize_queries(sample_query).each do |k, v|
+          unless sample_query[k].is_a?(Hash)
+            v.should == "my stub value for #{k}"
+          end
+        end
+      end
+    end
+
+    context "for objects not processable into queries" do
+      let(:sample_query) {
+        {
+          :cars => stub("Mongoid or other object"),
+          :canines => stub("another object"),
+          :hashy => {:query_type => :hash}
+        }.with_indifferent_access
+      }
+
+      it "throws an ArgumentError" do
+        MongoScript.stubs(:processable_into_parameters?).returns(false)
+        expect { MongoScript.normalize_queries(sample_query) }.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe "#validate_queries!" do
+    it "throws an error if any of the queries are missing a collection" do
+      normalized_queries.first.tap {|k, v| v.delete(:collection) }
+      expect { MongoScript.validate_queries!(normalized_queries) }.to raise_exception(ArgumentError)
+    end
+
+    it "throws an error if any of the queries are missing a klass" do
+      normalized_queries.first.tap {|k, v| v.delete(:klass) }
+      expect { MongoScript.validate_queries!(normalized_queries) }.to raise_exception(ArgumentError)
+    end
+
+    it "has detailed error descriptions"
+  end
+
+  describe "#mongoize_queries" do
+    it "returns copy of queries without the klass value" do
+      mongoized_queries.each_pair do |k, v|
+        v[:klass].should be_nil
+      end
+    end
+
+    it "leaves all other values the same" do
+      mongoized_queries.each_pair do |k, v|
+        # avoid symbol/string differences by using JSON
+        MultiJson.encode(v).should == MultiJson.encode(normalized_queries[k].tap {|h| h.delete(:klass) })
+      end
+    end
+
+    it "doesn't change the underlying hash" do
+      expect {
+        MongoScript.mongoize_queries(queries)
+        # inspect will display all info inside the hash
+        # a good proxy to make sure inside values don't change
+      }.not_to change(queries, :inspect)
+    end
+  end
+
+  describe "#process_results" do
+    def process_results(results, queries)
+      results.each_pair do |name, response|
+        if response["error"]
+          results[name] = QueryFailedError.new(name, queries[name], response)
+        else
+          # turn all the individual responses into real objects
+          response.map! {|data| MongoScript.rehydrate(queries[name][:klass], data)}
+        end
+      end
+    end
+
+    it "rehydrates all objects" do
+      normalized_queries = ObjectWithMultiquery.normalize_queries(queries)
+      processed_results = ObjectWithMultiquery.process_results(results, normalized_queries)
+
+      # in our test case, we could check to make sure that the ids match up
+      # in real life, of course, there's no guarantee the database would return
+      # all the objects we expect
+      processed_results[:canines].each {|d| d.should be_a(Dog)}
+      processed_results[:cars].each {|c| c.should be_a(Car)}
+    end
+
+    context "when a query errors" do
+      before :each do
+        results[:canines] = {"error" => "ssh mongo is sleeping!"}
+      end
+
+      let(:processed_results) {
+        ObjectWithMultiquery.process_results(results, normalized_queries)
+      }
+
+      let(:error) {
+        processed_results[:canines]
+      }
+
+      it "turns any errors into QueryFailedErrors" do
+        error.should be_a(MongoScript::Multiquery::QueryFailedError)
+      end
+
+      it "makes the normalized query available in the error" do
+        error.query_parameters.should == normalized_queries[:canines]
+      end
+
+      it "identifies the query name in the error" do
+        error.query_name.to_s.should == "canines"
+      end
+
+      it "makes the raw db response available in the error" do
+        error.db_response.should == results[:canines]
+      end
+    end
+  end
+end

data/spec/fixtures/mongoid.yml

@@ -0,0 +1,9 @@
+mongoscript_settings: &mongoscript_settings
+  host: localhost
+  database: mongoscript_dev
+
+development:
+  <<: *mongoscript_settings
+
+test:
+  <<: *mongoscript_settings

data/spec/fixtures/sample_script.js

@@ -0,0 +1,3 @@
+function() {
+  return "I am a sample script";
+}

data/spec/javascripts/helpers/SpecHelper.js

@@ -0,0 +1,82 @@
+// mock a Mongo DB
+// if you're using IE < 9, you'll need to implement map
+// but I doubt that will ever come up :)
+
+var MockMongo = function(dbName) {
+  var Collection = function(name, data) {
+    // we have to declare this as a local var
+    // since we need to embed it into the find scope
+    var collection = {
+      name: name,
+      find: function(params, fields) {
+        this.findResult = this.findResult || new Query(params, fields, collection);
+        return this.findResult;
+      },
+      data: data || []
+    };
+    return collection;
+  }
+
+  var Query = function(params, fields, collection) {
+    return {
+      params: params,
+      fields: fields,
+      collection: collection,
+      limit: function() { this.limitArgs = arguments; return this; },
+      sort: function() { this.sortArgs = arguments; return this; },
+      toArray: function() {
+        // always return the collection's data
+        return collection.data;
+      },
+      map: function() {
+        var data = this.toArray();
+        return data.map.apply(data, arguments)
+      }
+    }
+  }
+
+  var prototype = {
+    toString: function() {
+      return this.name;
+    },
+
+    addCollection: function(name, data) {
+      if (!this[name]) {
+        this[name] = new Collection(name, data);
+
+        // set up the system namespaces collection if it doesn't exist
+        if (!this["system.namespaces"]) {
+          this.addCollection("system.namespaces");
+        }
+
+        // and add the entry to the system.namespace array
+        this["system.namespaces"].data.push({
+          name: dbName + "." + name
+        })
+      }
+    }
+  }
+
+  var db = Object.create(prototype);
+  db.name = dbName;
+
+  return db;
+}
+
+var db;
+
+beforeEach(function() {
+  db = MockMongo("mongoscript_test");
+  db.addCollection("vehicles", [
+    {car: 1},
+    {truck: 2},
+    {spaceship: 100000}
+  ])
+
+  db.addCollection("paths", [
+    {road: 1},
+    {rail: 2},
+    {wormhole: 100000}
+  ])
+})
+