active-fedora 2.3.3 → 2.3.4

data/lib/active_fedora/active_fedora_configuration_exception.rb

@@ -0,0 +1,2 @@
+class ActiveFedoraConfigurationException < Exception
+end

data/lib/active_fedora/base.rb

@@ -89,6 +89,20 @@ module ActiveFedora
       @ds_specs[args[:name]]= [args[:type], args.fetch(:label,""), block]
     end
 
+    def method_missing(name, *args)
+      if datastreams.has_key? name.to_s
+        ### Create and invoke a proxy method 
+        self.class.class_eval <<-end_eval
+          def #{name}()
+            datastreams["#{name.to_s}"]
+          end
+        end_eval
+        self.send(name)
+      else 
+        super
+      end
+    end
+
     #Saves a Base object, and any dirty datastreams, then updates 
     #the Solr index for this object.
     def save
@@ -149,7 +163,6 @@ module ActiveFedora
         @datastreams = datastreams_in_memory
       else
         @datastreams = (@datastreams == {}) ? datastreams_in_fedora : datastreams_in_memory
-        #@datastreams = datastreams_in_fedora.merge(datastreams_in_memory)
       end
 
     end
@@ -713,8 +726,8 @@ module ActiveFedora
     # Add a Rels-Ext relationship to the Object.
     # @param predicate
     # @param object Either a string URI or an object that responds to .pid 
-    def add_relationship(predicate, obj)
-      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj)
+    def add_relationship(predicate, obj, literal=false)
+      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj, :is_literal=>literal)
       unless relationship_exists?(r.subject, r.predicate, r.object)
         rels_ext.add_relationship(r)
         #need to call here to indicate update of named_relationships
@@ -728,8 +741,8 @@ module ActiveFedora
     # Remove a Rels-Ext relationship from the Object.
     # @param predicate
     # @param object Either a string URI or an object that responds to .pid 
-    def remove_relationship(predicate, obj)
-      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj)
+    def remove_relationship(predicate, obj, literal=false)
+      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj, :is_literal=>literal)
       rels_ext.remove_relationship(r)
       #need to call here to indicate update of named_relationships
       @relationships_are_dirty = true

data/lib/active_fedora/model.rb

@@ -9,7 +9,6 @@ module ActiveFedora
   module Model 
     extend ActiveFedora::FedoraObject
 
-    attr_accessor :properties
 
     def self.included(klass) # :nodoc:
       klass.extend(ClassMethods)
@@ -221,7 +220,6 @@ module ActiveFedora
 
       #wrapper around instance_variable_get, returns current value of @name
       def attribute_get(name)
-        #instance_variable_get(properties[":#{name}"].instance_variable_name)
         instance_variable_get("@#{name}")
       end
 

data/lib/active_fedora/nokogiri_datastream.rb

@@ -309,7 +309,6 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     result = {}
     unless current_params.empty?
       result = update_values( current_params )
-      self.dirty = true
     end
     
     return result
@@ -329,7 +328,9 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     if @internal_solr_doc
       raise "No update performed, this object was initialized via Solr instead of Fedora and is therefore read-only.  Please utilize ActiveFedora::Base.load_instance to first load object via Fedora instead."
     else
-      om_update_values(params)
+      result = om_update_values(params)
+      self.dirty= true
+      return result
     end
   end
 

data/lib/active_fedora/relationship.rb

@@ -1,14 +1,15 @@
+require 'uri'
 module ActiveFedora
   
   class Relationship 
     
     attr_accessor :subject, :predicate, :object, :is_literal, :data_type
     def initialize(attr={})
-      attr.merge!({:is_literal => false})
+      attr = {:is_literal => false}.merge(attr)
+      @is_literal = attr[:is_literal] # must happen first
       self.subject = attr[:subject]
       @predicate = attr[:predicate]
       self.object = attr[:object]
-      @is_literal = attr[:is_literal]
       @data_type = attr[:data_type]
     end
     
@@ -21,7 +22,7 @@ module ActiveFedora
     end
     
     def object=(object)
-      @object = generate_uri(object)
+      @object = (is_literal)? object : generate_uri(object)
     end
     
     def object_pid=(pid)
@@ -31,6 +32,8 @@ module ActiveFedora
     def generate_uri(input)
       if input.class == Symbol || input == nil
         return input
+      elsif input.is_a? URI::Generic
+        return input.to_s
       elsif input.respond_to?(:pid)
         return "info:fedora/#{input.pid}"
       else
@@ -40,4 +43,4 @@ module ActiveFedora
   
   end
   
-end
+end

data/lib/active_fedora/rels_ext_datastream.rb

@@ -1,4 +1,5 @@
 require 'solrizer/field_name_mapper'
+require 'uri'
 
 module ActiveFedora
   class RelsExtDatastream < Datastream
@@ -44,8 +45,9 @@ module ActiveFedora
             logger.warn "You have a predicate without a namespace #{f.name}. Verify your rels-ext is correct."
             predicate = "#{f.name}"
           end
-          object = f["resource"] ? f["resource"] : f.inner_text
-          r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>object)
+          is_obj = f["resource"]
+          object = is_obj ? f["resource"] : f.inner_text
+          r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>object, :is_literal=>!is_obj)
           tmpl.add_relationship(r)
       end
       tmpl.send(:dirty=, false)
@@ -84,11 +86,15 @@ module ActiveFedora
         unless value.nil? 
           if value.is_a? Array
             value.each do |obj|
-              r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj)
+              o_uri = URI.parse(obj)
+              literal = o_uri.scheme.nil?
+              r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>obj, :is_literal=>literal)
               add_relationship(r)
             end
           else
-            r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>value)
+            o_uri = URI.parse(value)
+            literal = o_uri.scheme.nil?
+            r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>value, :is_literal=>literal)
             add_relationship(r)
           end
         end

data/lib/active_fedora/semantic_node.rb

@@ -95,6 +95,7 @@ module ActiveFedora
         objects.each do |object|
           if (response_format == :uri)    
             #create a Relationship object so that it generates the appropriate uri
+            #inbound relationships are always object properties
             r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>object)
             items.push(r.object)
           else
@@ -437,7 +438,12 @@ module ActiveFedora
             rel_predicate, xmlns = self.class.find_predicate(predicate)
           end
           # puts ". #{predicate} #{target} #{xmlns}"
-          xml.root.elements["rdf:Description"].add_element(rel_predicate, {"xmlns" => "#{xmlns}", "rdf:resource"=>target})
+          literal = URI.parse(target).scheme.nil?
+          if literal
+            xml.root.elements["rdf:Description"].add_element(rel_predicate, {"xmlns" => "#{xmlns}"}).add_text(target)
+          else
+            xml.root.elements["rdf:Description"].add_element(rel_predicate, {"xmlns" => "#{xmlns}", "rdf:resource"=>target})
+          end
         end
       end
       xml.to_s
@@ -787,7 +793,6 @@ module ActiveFedora
             return predicates[predicate], namespace
           end
         end
-        debugger
         raise ActiveFedora::UnregisteredPredicateError
       end
 

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-    VERSION = "2.3.3"
+    VERSION = "2.3.4"
 end

data/lib/tasks/active_fedora_dev.rake

@@ -15,6 +15,17 @@ EOS
 end
 
 $: << 'lib'
+def jetty_params 
+  project_root = File.expand_path("#{File.dirname(__FILE__)}/../../")
+  {
+      :quiet => false,
+      :jetty_home => File.join(project_root,'jetty'),
+      :jetty_port => 8983,
+      :solr_home => File.expand_path(File.join(project_root,'jetty','solr')),
+      :fedora_home => File.expand_path(File.join(project_root,'jetty','fedora','default')),
+      :startup_wait=>30
+    }
+end
 
 desc "Run active-fedora rspec tests"
 task :spec do
@@ -24,19 +35,10 @@ end
 desc "Hudson build"
 task :hudson do
   require 'jettywrapper'
-  project_root = File.expand_path("#{File.dirname(__FILE__)}/../../")
   
   if (ENV['environment'] == "test")
     Rake::Task["active_fedora:doc"].invoke
     Rake::Task["active_fedora:configure_jetty"].invoke
-    jetty_params = {
-      :quiet => false,
-      :jetty_home => File.join(project_root,'jetty'),
-      :jetty_port => 8983,
-      :solr_home => File.expand_path(File.join(project_root,'jetty','solr')),
-      :fedora_home => File.expand_path(File.join(project_root,'jetty','fedora','default')),
-      :startup_wait=>30
-    }
     error = Jettywrapper.wrap(jetty_params) do
       ENV["FEDORA_HOME"]=File.expand_path(File.join(File.dirname(__FILE__),'..','..','jetty','fedora','default'))
       Rake::Task["active_fedora:load_fixtures"].invoke
@@ -114,6 +116,19 @@ namespace :active_fedora do
     end
   end
 
+  namespace :jetty do
+    desc "start jetty" 
+    task :start do
+      require 'jettywrapper'
+      Jettywrapper.start(jetty_params)
+    end
+    desc "stop jetty" 
+    task :stop do
+      require 'jettywrapper'
+      Jettywrapper.stop(jetty_params)
+    end
+  end
+
 end
 
 # Provides an :environment task for use while working within a working copy of active-fedora

data/spec/fixtures/rails_root/config/fake_fedora.yml

@@ -0,0 +1,7 @@
+development:
+  url: http://development.com/fedora
+test:
+  url: http://test.com/fedora
+production:
+  url: http://production.com/fedora
+    

data/spec/fixtures/rails_root/config/solr.yml

@@ -0,0 +1,15 @@
+development:
+  default:
+    url: http://localhost:8983/solr/development
+  full_text:
+    url: http://localhost:8983/solr/development
+test: 
+  default:
+    url: http://localhost:8983/solr/test
+  full_text:
+    url: http://localhost:8983/solr/test
+production:
+  default:
+    url: http://localhost:8080/solr/production 
+  full_text:
+    url: http://localhost:8080/solr/production

data/spec/integration/full_featured_model_spec.rb

@@ -134,6 +134,15 @@ describe ActiveFedora::Base do
     
   end
 
+  it "should create proxies to all the datastreams" do
+    properties_ds = @test_history.datastreams["properties"]
+    dublin_core_ds = @test_history.datastreams["dublin_core"]
+    @test_history.should_not respond_to(:properties)
+    @test_history.properties.should be properties_ds    
+    @test_history.should respond_to(:properties)
+    OralHistory.new.should respond_to(:properties)
+  end 
+
   it "t1" do# should load all of the metadata fields from fedora xml" do
     pending
     properties_ds = @test_history.datastreams["properties"]

data/spec/unit/active_fedora_spec.rb

@@ -1,9 +1,269 @@
 require File.join( File.dirname(__FILE__), "../spec_helper" )
+require 'equivalent-xml'
 
 # For testing Module-level methods like ActiveFedora.init
 
 describe ActiveFedora do
   
+  describe "initialization methods" do
+    
+    describe "environment" do
+      it "should use config_options[:environment] if set" do
+        ActiveFedora.expects(:config_options).at_least_once.returns(:environment=>"ballyhoo")
+        ActiveFedora.environment.should eql("ballyhoo")
+      end
+
+      it "should use Rails.env if no config_options and Rails.env is set" do
+        stub_rails(:env => "bedbugs")
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        ActiveFedora.environment.should eql("bedbugs")
+        unstub_rails
+      end
+
+      it "should use ENV['environment'] if neither config_options nor Rails.env are set" do
+        ENV['environment'] = "wichita"
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        ActiveFedora.environment.should eql("wichita")
+      end
+
+      it "should use ENV['RAILS_ENV'] and log a warning if none of the above are set" do
+        ENV['environment']=nil
+        ENV['RAILS_ENV'] = "rails_env"
+        logger.expects(:warn)
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        ActiveFedora.environment.should eql("rails_env")
+        ENV['environment']='test'
+      end
+
+      it "should raise an exception if none of the above are present" do
+        ENV['environment']=nil
+        ENV['RAILS_ENV'] = nil
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        lambda { ActiveFedora.environment }.should raise_exception
+        ENV['environment']="test"
+      end
+    end
+
+    describe "get_config_path(:fedora)" do
+      it "should use the config_options[:config_path] if it exists" do
+        ActiveFedora.expects(:config_options).at_least_once.returns({:fedora_config_path => "/path/to/fedora.yml"})
+        File.expects(:file?).with("/path/to/fedora.yml").returns(true)
+        ActiveFedora.get_config_path(:fedora).should eql("/path/to/fedora.yml")
+      end
+
+      it "should look in Rails.root/config/fedora.yml if it exists and no fedora_config_path passed in" do
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        stub_rails(:root => "/rails/root")
+        File.expects(:file?).with("/rails/root/config/fedora.yml").returns(true)
+        ActiveFedora.get_config_path(:fedora).should eql("/rails/root/config/fedora.yml")
+        unstub_rails
+      end
+
+      it "should look in ./config/fedora.yml if neither rails.root nor :fedora_config_path are set" do
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        Dir.expects(:getwd).at_least_once.returns("/current/working/directory")
+        File.expects(:file?).with("/current/working/directory/config/fedora.yml").returns(true)
+        ActiveFedora.get_config_path(:fedora).should eql("/current/working/directory/config/fedora.yml")
+      end
+
+      it "should return default fedora.yml that ships with active-fedora if none of the above" do
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        Dir.expects(:getwd).at_least_once.returns("/current/working/directory")
+        File.expects(:file?).with("/current/working/directory/config/fedora.yml").returns(false)
+        File.expects(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml'))).returns(true)
+        ActiveFedora.get_config_path(:fedora).should eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml')))
+      end
+    end
+
+    describe "get_config_path(:solr)" do
+      it "should return the solr_config_path if set in config_options hash" do
+        ActiveFedora.expects(:config_options).at_least_once.returns({:solr_config_path => "/path/to/solr.yml"})
+        File.expects(:file?).with("/path/to/solr.yml").returns(true)
+        ActiveFedora.get_config_path(:solr).should eql("/path/to/solr.yml")
+      end
+      
+      it "should return the solr.yml file in the same directory as the fedora.yml if it exists" do
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        ActiveFedora.expects(:fedora_config_path).returns("/path/to/fedora/config/fedora.yml")
+        File.expects(:file?).with("/path/to/fedora/config/solr.yml").returns(true)
+        ActiveFedora.get_config_path(:solr).should eql("/path/to/fedora/config/solr.yml")
+      end
+      
+      it "should raise an error if there is not a solr.yml in the same directory as the fedora.yml and the fedora.yml has a solr url defined" do
+        ActiveFedora.expects(:config_options).at_least_once.returns({})
+        ActiveFedora.expects(:fedora_config_path).returns("/path/to/fedora/config/fedora.yml")
+        File.expects(:file?).with("/path/to/fedora/config/solr.yml").returns(false)
+        ActiveFedora.expects(:fedora_config).returns({"test"=>{"solr"=>{"url"=>"http://some_url"}}})
+        lambda { ActiveFedora.get_config_path(:solr) }.should raise_exception
+      end
+
+      context "no solr.yml in same directory as fedora.yml and fedora.yml does not contain solr url" do
+
+        before :each do
+          ActiveFedora.expects(:config_options).at_least_once.returns({})
+          ActiveFedora.expects(:fedora_config_path).returns("/path/to/fedora/config/fedora.yml")
+          File.expects(:file?).with("/path/to/fedora/config/solr.yml").returns(false)
+          ActiveFedora.expects(:fedora_config).returns({"test"=>{"url"=>"http://some_url"}})
+        end
+        after :each do
+          unstub_rails
+        end
+
+        it "should not raise an error if there is not a solr.yml in the same directory as the fedora.yml and the fedora.yml has a solr url defined and look in rails.root" do
+          stub_rails(:root=>"/rails/root")
+          File.expects(:file?).with("/rails/root/config/solr.yml").returns(true)
+          ActiveFedora.get_config_path(:solr).should eql("/rails/root/config/solr.yml")
+        end
+
+        it "should look in ./config/solr.yml if no rails root" do
+          Dir.expects(:getwd).at_least_once.returns("/current/working/directory")
+          File.expects(:file?).with("/current/working/directory/config/solr.yml").returns(true)
+          ActiveFedora.get_config_path(:solr).should eql("/current/working/directory/config/solr.yml")
+        end
+
+        it "should return the default solr.yml file that ships with active-fedora if no other option is set" do
+          Dir.expects(:getwd).at_least_once.returns("/current/working/directory")
+          File.expects(:file?).with("/current/working/directory/config/solr.yml").returns(false)
+          File.expects(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml'))).returns(true)
+          ActiveFedora.get_config_path(:solr).should eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml')))
+        end
+      end
+
+    end
+
+
+    describe "#determine url" do
+      it "should support config['environment']['fedora']['url'] if config_type is fedora" do
+        config = {"test"=> {"fedora"=>{"url"=>"http://fedoraAdmin:fedorAdmin@oldstyle_url:8983/fedora"}}}
+        ActiveFedora.determine_url("fedora",config).should eql("http://fedoraAdmin:fedorAdmin@oldstyle_url:8983/fedora")
+      end
+
+      it "should support config['environment']['url'] if config_type is fedora" do
+        config = {"test"=> {"url"=>"http://fedoraAdmin:fedorAdmin@oldstyle_url:8983/fedora"}}
+        ActiveFedora.determine_url("fedora",config).should eql("http://fedoraAdmin:fedorAdmin@oldstyle_url:8983/fedora")
+      end
+
+      it "should call #get_solr_url to determine the solr url if config_type is solr" do
+        config = {"test"=>{"default" => "http://default.solr:8983"}}
+        ActiveFedora.expects(:get_solr_url).with(config["test"]).returns("http://default.solr:8983")
+        ActiveFedora.determine_url("solr",config).should eql("http://default.solr:8983")
+      end
+    end
+
+    describe "load_config" do
+      it "should load the file specified in fedora_config_path" do
+        ActiveFedora.expects(:fedora_config_path).returns("/path/to/fedora.yml")
+        File.expects(:open).with("/path/to/fedora.yml").returns("test:\n  url: http://myfedora:8080")
+        ActiveFedora.load_config(:fedora).should eql({:url=>"http://myfedora:8080","test"=>{"url"=>"http://myfedora:8080"}})
+        ActiveFedora.fedora_config.should eql({:url=>"http://myfedora:8080","test"=>{"url"=>"http://myfedora:8080"}})
+      end
+      it "should load the file specified in solr_config_path" do
+        ActiveFedora.expects(:solr_config_path).returns("/path/to/solr.yml")
+        File.expects(:open).with("/path/to/solr.yml").returns("development:\n  default:\n    url: http://devsolr:8983\ntest:\n  default:\n    url: http://mysolr:8080")
+        ActiveFedora.load_config(:solr).should eql({:url=>"http://mysolr:8080","development"=>{"default"=>{"url"=>"http://devsolr:8983"}}, "test"=>{"default"=>{"url"=>"http://mysolr:8080"}}})
+        ActiveFedora.solr_config.should eql({:url=>"http://mysolr:8080","development"=>{"default"=>{"url"=>"http://devsolr:8983"}}, "test"=>{"default"=>{"url"=>"http://mysolr:8080"}}})
+      end
+    end
+
+    describe "load_configs" do
+      it "should load the fedora and solr configs" do
+        ActiveFedora.expects(:load_config).with(:fedora)
+        ActiveFedora.expects(:load_config).with(:solr)
+        ActiveFedora.load_configs
+      end
+    end
+
+    describe "register_solr_and_fedora" do
+      it "should regiser instances with the appropriate urls" do
+        ActiveFedora.expects(:solr_config).at_least_once.returns({:url=>"http://megasolr:8983"})
+        ActiveFedora.expects(:fedora_config).at_least_once.returns({:url=>"http://megafedora:8983"})
+        ActiveFedora.register_fedora_and_solr
+        ActiveFedora.solr.conn.url.to_s.should eql("http://megasolr:8983")
+        ActiveFedora.fedora.fedora_url.to_s.should eql("http://megafedora:8983")
+      end
+    end
+
+    describe "check_fedora_path_for_solr" do
+      it "should find the solr.yml file and return it if it exists" do
+        ActiveFedora.expects(:fedora_config_path).returns("/path/to/fedora/fedora.yml")
+        File.expects(:file?).with("/path/to/fedora/solr.yml").returns(true)
+        ActiveFedora.check_fedora_path_for_solr.should == "/path/to/fedora/solr.yml"
+      end
+      it "should return nil if the solr.yml file is not there" do
+        ActiveFedora.expects(:fedora_config_path).returns("/path/to/fedora/fedora.yml")
+        File.expects(:file?).with("/path/to/fedora/solr.yml").returns(false)
+        ActiveFedora.check_fedora_path_for_solr.should be_nil
+      end
+    end
+  end
+
+
+
+  ###########################
+  
+  describe "setting the environment and loading configuration" do
+    
+    before(:all) do
+      @fake_rails_root = File.expand_path(File.dirname(__FILE__) + '/../fixtures/rails_root')
+    end
+    
+    after(:all) do
+      ActiveFedora.init(File.join(File.dirname(__FILE__), "..", "..", "config", "fedora.yml"))
+    end
+  
+    it "can tell its config paths" do
+      ActiveFedora.init
+      ActiveFedora.should respond_to(:fedora_config_path)
+      ActiveFedora.should respond_to(:solr_config_path)
+    end
+    it "loads a config from the current working directory as a second choice" do
+      Dir.stubs(:getwd).returns(@fake_rails_root)
+      ActiveFedora.init
+      ActiveFedora.fedora_config_path.should eql("#{@fake_rails_root}/config/fedora.yml")
+      ActiveFedora.solr_config_path.should eql("#{@fake_rails_root}/config/solr.yml")
+    end
+    it "loads the config that ships with this gem as a last choice" do
+      Dir.stubs(:getwd).returns("/fake/path")
+      ActiveFedora.init
+      expected_config = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config"))
+      ActiveFedora.fedora_config_path.should eql(expected_config+'/fedora.yml')
+      ActiveFedora.solr_config_path.should eql(expected_config+'/solr.yml')
+    end
+    it "overrides any other config file when a file is passed in explicitly" do
+      ActiveFedora.init("#{@fake_rails_root}/config/fake_fedora.yml")
+      ActiveFedora.fedora_config_path.should eql("#{@fake_rails_root}/config/fake_fedora.yml")
+#ActiveFedora.config_path.should eql("#{@fake_rails_root}/config/fake_fedora.yml")
+    end
+    it "raises an error if you pass in a non-existant config file" do
+      lambda{ ActiveFedora.init("really_fake_fedora.yml") }.should raise_exception(ActiveFedoraConfigurationException)
+    end
+    
+    describe "within Rails" do
+      before(:all) do        
+        stub_rails(:root=>File.dirname(__FILE__) + '/../fixtures/rails_root')
+      end
+
+      after(:all) do
+        unstub_rails
+      end
+      
+      it "loads a config from Rails.root as a first choice" do
+        ActiveFedora.init
+        ActiveFedora.fedora_config_path.should eql("#{Rails.root}/config/fedora.yml")
+        ActiveFedora.solr_config_path.should eql("#{Rails.root}/config/solr.yml")
+      end
+      
+      it "can tell what environment it is set to run in" do
+        stub_rails(:env=>"development")
+        ActiveFedora.init
+        ActiveFedora.environment.should eql("development")
+      end
+      
+    end
+  end
+  
+  ##########################
+  
   describe ".push_models_to_fedora" do
     it "should push the model definition for each of the ActiveFedora models into Fedora CModel objects" do
       pending
@@ -74,7 +334,8 @@ describe ActiveFedora do
     
     after(:all) do
       # Restore to default fedora configs
-      ActiveFedora.init()
+      ActiveFedora.init(File.join(File.dirname(__FILE__), "..", "..", "config", "fedora.yml"))
+
     end
 
     describe "outside of rails" do
@@ -90,25 +351,26 @@ describe ActiveFedora do
 
     describe "within rails" do
 
-      before(:all) do
-        Object.const_set("Rails",String)
-      end
-
       after(:all) do
-        if Rails == String
-          Object.send(:remove_const,:Rails)
-        end
+        unstub_rails
       end
 
       describe "versions prior to 3.0" do
         describe "with explicit config path passed in" do
           it "should load the specified config path" do
-            config_hash={"test"=>{"fedora"=>{"url"=>"http://fedoraAdmin:fedoraAdmin@127.0.0.1:8983/fedora"},"solr"=>{"url"=>"http://127.0.0.1:8983/solr/test/"}}}
-            config_path = File.expand_path(File.join(File.dirname(__FILE__),"config"))
-            mock_yaml(config_hash,File.join(config_path,"fedora.yml"))
-            File.expects(:exist?).with(File.join(config_path,"predicate_mappings.yml")).returns(true)
-            ActiveFedora.expects(:valid_predicate_mapping?).returns(true)
-            ActiveFedora.init(File.join(config_path,"fedora.yml"))
+            fedora_config="test:\n  fedora:\n    url: http://fedoraAdmin:fedoraAdmin@127.0.0.1:8983/fedora"
+            solr_config = "test:\n  default:\n    url: http://foosolr:8983"
+
+            fedora_config_path = File.expand_path(File.join(File.dirname(__FILE__),"../fixtures/rails_root/config/fedora.yml"))
+            solr_config_path = File.expand_path(File.join(File.dirname(__FILE__),"../fixtures/rails_root/config/solr.yml"))
+            pred_config_path = File.expand_path(File.join(File.dirname(__FILE__),"../fixtures/rails_root/config/predicate_mappings.yml"))
+            
+            File.stubs(:open).with(fedora_config_path).returns(fedora_config)
+            File.stubs(:open).with(solr_config_path).returns(solr_config)
+
+            ActiveFedora.expects(:build_predicate_config_path)
+
+            ActiveFedora.init(:fedora_config_path=>fedora_config_path,:solr_config_path=>solr_config_path)
             ActiveFedora.solr.class.should == ActiveFedora::SolrService
             ActiveFedora.fedora.class.should == Fedora::Repository
           end
@@ -116,14 +378,14 @@ describe ActiveFedora do
 
         describe "with no explicit config path" do
           it "should look for the file in the path defined at Rails.root" do
-            Rails.expects(:root).returns(File.join(File.dirname(__FILE__),"../fixtures/rails_root"))
+            stub_rails(:root=>File.join(File.dirname(__FILE__),"../fixtures/rails_root"))
             ActiveFedora.init()
             ActiveFedora.solr.class.should == ActiveFedora::SolrService
             ActiveFedora.fedora.class.should == Fedora::Repository
             ActiveFedora.fedora.fedora_url.to_s.should == "http://fedoraAdmin:fedoraAdmin@testhost.com:8983/fedora"
           end
           it "should load the default file if no config is found at Rails.root" do
-            Rails.expects(:root).returns(File.join(File.dirname(__FILE__),"../fixtures/bad/path/to/rails_root"))
+            stub_rails(:root=>File.join(File.dirname(__FILE__),"../fixtures/bad/path/to/rails_root"))
             ActiveFedora.init()
             ActiveFedora.solr.class.should == ActiveFedora::SolrService
             ActiveFedora.fedora.class.should == Fedora::Repository
@@ -145,3 +407,33 @@ end
 def default_predicate_mapping_file
   File.expand_path(File.join(File.dirname(__FILE__),"..","..","config","predicate_mappings.yml"))
 end
+
+def stub_rails(opts={})
+  Object.const_set("Rails",Class)
+  Rails.send(:undef_method,:env) if Rails.respond_to?(:env)
+  Rails.send(:undef_method,:root) if Rails.respond_to?(:root)
+  opts.each { |k,v| Rails.send(:define_method,k){ return v } }
+end
+
+def unstub_rails
+  Object.send(:remove_const,:Rails) if defined?(Rails)
+end
+    
+def stub_blacklight(opts={})
+  Object.const_set("Blacklight",Class)
+  Blacklight.send(:undef_method,:solr_config) if Blacklight.respond_to?(:solr_config)
+  if opts[:solr_config]
+    Blacklight.send(:define_method,:solr_config) do
+      opts[:solr_config]
+    end
+  end
+end
+
+def unstub_blacklight
+  Object.send(:remove_const,:Blacklight) if defined?(Blacklight)
+end
+
+def setup_pretest_env
+  ENV['RAILS_ENV']='test'
+  ENV['environment']='test'
+end