tinkit 0.0.0

data/spec/couchrest_glue_spec.rb

@@ -0,0 +1,246 @@
+#require helper for cleaner require statements
+require File.join(File.expand_path(File.dirname(__FILE__)), '../lib/helpers/require_helper')
+
+require Tinkit.glue 'couchrest_glue_env'
+
+GlueTestDb = CouchRest.database!("http://127.0.0.1:5984/couchrest_glue_test")
+GlueTestDb.compact!
+
+describe CouchrestEnv::GlueEnv, "Initialization" do
+  before(:each) do
+    #set up env
+    persist_env = { :host => GlueTestDb.host,
+                          :path => GlueTestDb.uri,
+                          :user_id => 'couch_glue_user'}
+    
+
+    @persist_env = {:name => :couchrest_glue_spec, :env => persist_env}
+    
+    key_fields = { :required_keys => [:my_id],
+                        :primary_key => :my_id }
+    
+    @data_model_bindings =  { :key_fields => key_fields,
+                                          :views => nil }
+    
+  end
+  
+  after(:each) do
+    GlueTestDb.delete!
+  end
+  
+  it "should initialize properly" do
+    couchrest_glue_obj = CouchrestEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+    #@data_dir = couchrest_glue_obj.user_datastore_location
+    
+    #couchrest_glue_obj.dbh.connected?.should == true
+    
+    couchrest_glue_obj.user_id.should == @persist_env[:env][:user_id]
+    couchrest_glue_obj.required_instance_keys.should == @data_model_bindings[:key_fields][:required_keys]
+    couchrest_glue_obj.required_save_keys.should == @data_model_bindings[:key_fields][:required_keys]
+    couchrest_glue_obj.node_key.should == @data_model_bindings[:key_fields][:primary_key]
+    required_metadata_keys = [couchrest_glue_obj.version_key, 
+                                        couchrest_glue_obj.persist_layer_key,
+                                        couchrest_glue_obj.namespace_key]
+    (couchrest_glue_obj.metadata_keys & required_metadata_keys).sort.should == required_metadata_keys.sort
+    path = @persist_env[:env][:path]
+    user_id = @persist_env[:env][:user_id]
+    #p GlueTestDb.to_s
+    couchrest_glue_obj.user_datastore_location.should == user_id #?
+    couchrest_glue_obj._files_mgr_class.class.should_not == nil    #The file manager class will handle file attachments
+  end  
+  
+end
+
+
+describe CouchrestEnv::GlueEnv, "Persistent Layer Basic Operations" do
+  
+  before(:each) do
+    #set up env
+    persist_env = { :host => GlueTestDb.host,
+                          :path => GlueTestDb.uri,
+                          :user_id => 'couch_glue_user'}
+    
+    #name isn't used in these specs, since that's used by the node factory to select the glue env
+    #but shown for clarity
+    @persist_env = {:name => :couchrest_glue_test, :env => persist_env}
+    
+    key_fields = { :required_keys => [:my_id],
+                        :primary_key => :my_id }
+    
+    @data_model_bindings =  { :key_fields => key_fields,
+                                          :views => nil }
+    
+    @couchrest_glue_obj = CouchrestEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+  end
+  
+  after(:each) do
+    GlueTestDb.delete!
+  end
+  
+  it "should persist data and be able to retrieve it" do
+    @couchrest_glue_obj.should_not == nil
+    #:id was defined as the primary key
+    data1 = {:my_id => "test_id1", :data => "test data"}
+    empty_data = @couchrest_glue_obj.get(data1[:my_id]) #hasn't been saved yet
+    empty_data.should == nil
+    @couchrest_glue_obj.save(data1)
+    #Don't use native get_attributes, use obj's get,  it will block until save is finished
+    persisted_data = @couchrest_glue_obj.get(data1[:my_id]) 
+    persisted_data.should_not == nil
+    #puts "Persisted data for my_id: #{persisted_data}"
+    persisted_data[:my_id].should == data1[:my_id]
+    persisted_data[:data].should == data1[:data]
+  end
+
+  it "should be able to delete data" do
+    data1 = {:my_id => "test_id1", :data => "test data1"}
+    data2 = {:my_id => "test_id2", :data => "test data2"}
+    @couchrest_glue_obj.save(data1)
+    @couchrest_glue_obj.save(data2)
+    persisted_data1 = @couchrest_glue_obj.get(data1[:my_id])
+    persisted_data2 = @couchrest_glue_obj.get(data2[:my_id])
+    persisted_data1[:data].should == "test data1"
+    persisted_data2[:data].should == "test data2"
+    @couchrest_glue_obj.destroy_node({:my_id => data2[:my_id]})
+    persisted_data1 = @couchrest_glue_obj.get(data1[:my_id])
+    persisted_data2 = @couchrest_glue_obj.get(data2[:my_id])
+    persisted_data1[:data].should == "test data1"
+    persisted_data2.should == nil    
+  end
+end
+
+
+describe CouchrestEnv::GlueEnv, "Persistent Layer Collection Operations" do
+
+  before(:each) do
+    #set up env
+    persist_env = { :host => GlueTestDb.host,
+                          :path => GlueTestDb.uri,
+                          :user_id => 'couch_glue_user'}
+    
+    #name isn't used in these specs, since that's used by the node factory to select the glue env
+    #but shown for clarity
+    @persist_env = {:name => :couchrest_glue_test, :env => persist_env}
+    
+    key_fields = { :required_keys => [:my_id],
+                        :primary_key => :my_id }
+    
+    @data_model_bindings =  { :key_fields => key_fields,
+                                          :views => nil }
+    
+    @couchrest_glue_obj = CouchrestEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+  end
+  
+  after(:each) do
+    #GlueTestDb.delete!
+  end
+
+  it "should be able to query all" do
+    data1 = {:my_id => "test_id1", :data => "test data1"}
+    data2 = {:my_id => "test_id2", :data => "test data2"}
+    @couchrest_glue_obj.save(data1)
+    @couchrest_glue_obj.save(data2)
+  
+    results = @couchrest_glue_obj.query_all
+    results.size.should == 2
+    results.each do |raw_data|
+      case raw_data[:my_id]
+        when "test_id1"
+          raw_data[:data].should == "test data1"
+        when "test_id2"
+          raw_data[:data].should == "test data2"  
+        else
+          raise "Unknown dataset #{raw_data.inspect}"
+      end#case
+    end#each
+  end
+
+  it "should be able to find matching data" do
+    data1 = {:my_id => "test_id1", :data => "test data1", :tags => ['a', 'b', 'c']}
+    data2 = {:my_id => "test_id2", :data => "test data2", :tags => ['c', 'd', 'e']}
+    data3 = {:my_id => "test_id3", :data => "test data2", :tags => ['c', 'b', 'z']}
+    data_list = [data1, data2, data3]
+    data_list.each {|data| @couchrest_glue_obj.save(data)}
+    
+    result1 = @couchrest_glue_obj.find_nodes_where(:my_id, :equals, "test_id1")
+    result1.size.should == 1
+    result1.first[:my_id].should == "test_id1"
+    
+    result2 = @couchrest_glue_obj.find_nodes_where(:my_id, :equals, "oops")
+    result2.should be_empty
+    
+    result3 = @couchrest_glue_obj.find_nodes_where(:data, :equals, "test data2")
+    result3.size.should == 2
+    ["test_id2", "test_id3"].should include result3.first[:my_id]
+    ["test_id2", "test_id3"].should include result3.last[:my_id]
+    
+    result4 = @couchrest_glue_obj.find_nodes_where(:tags, :equals, ['c', 'd', 'e'])
+    result4.size.should == 1
+    result4.first[:my_id].should == "test_id2"    
+  end
+
+  it "should be able to find containting data" do
+    data1 = {:my_id => "test_id1", :data => "test data1", :tags => ['a', 'b', 'c']}
+    data2 = {:my_id => "test_id2", :data => "test data2", :tags => ['c', 'd', 'e']}
+    data3 = {:my_id => "test_id3", :data => "test data2", :tags => ['c', 'b', 'z']}
+    data_list = [data1, data2, data3]
+    data_list.each {|data| @couchrest_glue_obj.save(data)}
+    
+    result1 = @couchrest_glue_obj.find_nodes_where(:my_id, :contains, "test_id2")
+    result1.size.should == 1
+    result1.first[:my_id].should == "test_id2"
+    
+    result2 = @couchrest_glue_obj.find_nodes_where(:tags, :contains, "c")
+    result2.size.should == 3
+    
+    result3 = @couchrest_glue_obj.find_nodes_where(:tags, :contains, "b")
+    result3.size.should == 2
+    ["test_id1", "test_id3"].should include result3.first[:my_id]
+    ["test_id1", "test_id3"].should include result3.last[:my_id]
+    
+    result4 = @couchrest_glue_obj.find_nodes_where(:tags, :contains, "oops")
+    result4.should be_empty
+  end
+
+  it "should be able to delete in bulk" do  
+    data1 = {:my_id => "test_id1", :data => "delete me"}
+    data2 = {:my_id => "test_id2", :data => "keep me"}
+    data3 = {:my_id => "test_id3", :data => "delete me too"}
+    @couchrest_glue_obj.save(data1)
+    @couchrest_glue_obj.save(data2)
+    @couchrest_glue_obj.save(data3)
+    
+    results = @couchrest_glue_obj.query_all
+
+    results.each do |raw_data|
+      case raw_data[:my_id]
+        when "test_id1"
+          raw_data[:data].should == "delete me"
+        when "test_id2"
+          raw_data[:data].should == "keep me"
+        when "test_id3"
+          raw_data[:data].should == "delete me too"
+        else
+          raise "Unknown dataset"
+      end#case
+    end#each
+
+    raw_rcds_to_delete = [data1, data3]
+    @couchrest_glue_obj.destroy_bulk(raw_rcds_to_delete)
+    
+    results = @couchrest_glue_obj.query_all
+    #puts "Destroy Bulk results: #{results.inspect}"
+    results.each do |raw_data|
+      case raw_data[:my_id]
+        when "test_id1"
+          raise "Oops should have been deleted"
+        when "test_id2"
+          raw_data[:data].should == "keep me"
+        when "test_id3"
+          raise "Oops should have been deleted"
+        else
+          raise "Unknown dataset"
+      end#case
+    end#each    
+  end#it
+end

data/spec/filesystem_files_mgr_spec.rb

@@ -0,0 +1,236 @@
+#require helper for cleaner require statements
+require File.join(File.expand_path(File.dirname(__FILE__)), '../lib/helpers/require_helper')
+require Tinkit.glue 'filesystem/filesystem_files_mgr'
+
+include FilesystemInterface
+GlueEnvMock = Struct.new(:model_key, :user_datastore_location)
+
+describe FilesMgr, "Setup and intialization" do
+
+  before(:all) do
+    
+    @glue_env_mock = GlueEnvMock.new("_id", "/tmp/datastore_location")
+    @node_key = :_id
+    
+    file1_data = "Example File1\nJust some text"
+    file2_data = "Example File2\nJust some more text"
+    file1_fname = "/tmp/example_file1.txt"
+    file2_fname = "/tmp/example_file2.txt"
+    files = {file1_fname => file1_data, file2_fname => file2_data}
+    files.each do |fname, data|
+      File.open(fname, 'w'){|f| f.write(data)}
+    end
+    @file_datas = [{:src_filename => file1_fname}, {:src_filename => file2_fname}]
+    @node1_data = {:_id => 'spec_test1', :data => 'stuff1'}
+  end
+  
+  it "should initialize" do
+    node_key_value = @node1_data[@node_key]
+    attach_handler = FilesMgr.new(@glue_env_mock, node_key_value)
+    
+    #note actual table is setup in glue_env, not file_mgr
+    attach_handler.attachment_location.should == "#{@glue_env_mock.user_datastore_location}/#{node_key_value}"
+  end
+end
+  
+describe FilesMgr, "Basic Operations" do
+  before(:all) do
+    @user_datastore_location = "/tmp/datastore_location"
+    @file1_fname = "/tmp/example_file1.txt"
+    @file2_fname = "/tmp/example_file2.txt"
+    f1_bname = File.basename(@file1_fname)
+    f2_bname = File.basename(@file2_fname)
+    @file_stored_data = { f1_bname => File.open(@file1_fname, 'rb'){|f| f.read},
+                      f2_bname =>File.open(@file2_fname, 'rb'){|f| f.read} }
+                      
+    @mock_key = :_id
+    @nodeMockClass = Struct.new(@mock_key, :my_GlueEnv)
+    
+    @glue_env_mock = GlueEnvMock.new(@mock_key,
+                                                   @user_datastore_location)
+
+    #set up table for spec
+
+    @file_datas = [{:src_filename => @file1_fname}, {:src_filename => @file2_fname}]
+  end
+  
+  
+  before(:each) do
+    @node1_data = {:_id => 'spec_test1', :data => 'stuff1'}
+    @node_mock = @nodeMockClass.new(@node1_data[@mock_key], 
+                                                        @glue_env_mock)
+    
+    node_key_value = @node1_data[@mock_key]
+    @attach_handler = FilesMgr.new(@glue_env_mock, node_key_value)
+    #@attach_handler.subtract_files(nil, :all)
+  end
+  
+  after(:all) do
+    FileUtils.rm_rf(@user_datastore_location)
+    @file_datas.each do |file_data|
+      FileUtils.rm(file_data[:src_filename])
+    end
+  end
+  
+  it "should add and retrieve files" do
+    node = @node_mock
+
+    @file_datas.each do |file_data|
+      file_basename = File.basename(file_data[:src_filename])
+      data = @attach_handler.get_raw_data(node, file_basename) 
+      data.should be_nil
+    end
+      
+    #Add the Files  
+    @attach_handler.add(node, @file_datas)
+    
+    #Get the files and verify data
+    @file_datas.each do |file_data|
+      file_basename = File.basename(file_data[:src_filename])
+      data = @attach_handler.get_raw_data(node, file_basename) 
+      data.should == @file_stored_data[file_basename]
+    end
+  end
+  
+  it "should list attachment files" do
+    files = @attach_handler.list(@node_mock)
+    files.sort.should == @file_stored_data.keys.sort
+  end
+
+  it "should list metadata" do
+    
+    md = @attach_handler.get_attachments_metadata(@node_mock)
+    md.should_not == nil
+    @file_datas.each do |file_data|
+      file_basename = File.basename(file_data[:src_filename]) 
+      each_md = md[file_basename.to_sym]
+      each_md.should_not == nil
+      each_md.keys.should include :content_type
+      each_md.keys.should include :file_modified
+      
+      file_basename = File.basename(file_data[:src_filename])
+      md[file_basename.to_sym][:content_type].should =~ /^text\/plain/
+      time_str = md[file_basename.to_sym][:file_modified]
+      Time.parse(time_str).should > Time.now - 1 #should have been modified less than a second ago
+    end
+  end
+
+  it "should be well behaved adding more files" do 
+    node = @node_mock
+
+    #Get the original files and verify data
+    @file_datas.each do |file_data|
+      file_basename = File.basename(file_data[:src_filename])
+      data = @attach_handler.get_raw_data(node, file_basename) 
+      data.should == @file_stored_data[file_basename]
+    end    
+    
+    #create some more files
+    file1_data = "Example File1\nNEW!! text"
+    file3_data = "Example File3\nYet more text"
+    file4_data = "Example File4\nand more text"
+    file3_fname = "/tmp/example_file3.txt"
+    file4_fname = "/tmp/example_file4.txt"
+    files = {@file1_fname => file1_data, file3_fname => file3_data, file4_fname => file4_data}
+    files.each do |fname, data|
+      File.open(fname, 'w'){|f| f.write(data)}
+    end
+    file1_data.should == File.open(@file1_fname){|f| f.read}
+    @file_datas2 = [{:src_filename => @file1_fname},
+                          {:src_filename => file3_fname},
+                          {:src_filename => file4_fname}]
+    
+    #add them
+    @attach_handler.add(node, @file_datas2)
+
+    #Check the unchanged file (file2)
+    file2_basename = File.basename(@file2_fname)
+    data2 = @attach_handler.get_raw_data(node, file2_basename)
+    data2.should == @file_stored_data[file2_basename]
+    
+    #Get the changed files and verify it is the new data
+    file1_basename = File.basename(@file1_fname)
+    data1 = @attach_handler.get_raw_data(node, file1_basename)
+    data1.should == file1_data
+    
+    file3_basename  = File.basename(file3_fname)
+    data3 = @attach_handler.get_raw_data(node, file3_basename)
+    data3.should == file3_data    
+
+    file4_basename  = File.basename(file4_fname)
+    data4 = @attach_handler.get_raw_data(node, file4_basename)
+    data4.should == file4_data
+  end
+  
+  it "should delete files" do
+    node = @node_mock
+    files_to_delete = [@file1_fname, @file2_fname]
+    #they should exist in the node
+    files_to_delete.each do |fname|
+      file_basename = File.basename(fname)
+      data = @attach_handler.get_raw_data(node, file_basename)
+      data.should match /^Example File/
+    end
+    
+    basenames_to_delete = files_to_delete.map{|f| File.basename(f)}
+    @attach_handler.subtract(node, basenames_to_delete)
+    
+    files_to_delete.each do |fname|
+      file_basename = File.basename(fname)
+      data = @attach_handler.get_raw_data(node, file_basename)
+      data.should be_nil
+    end    
+  end
+  
+  it "should add attachments from the raw data" do
+    node = @node_mock
+
+    raw_data = "Example File3\nYet more text"
+    content_type = "text/plain"
+    modified_at = Time.now.to_s
+    att_name = "example_raw_data.txt"
+    
+
+    
+    #Add the Raw Data
+    @attach_handler.add_raw_data(node, att_name, content_type, raw_data, modified_at)
+    
+    #Get the files and verify data
+
+    data = @attach_handler.get_raw_data(node, att_name) 
+    md = @attach_handler.get_attachments_metadata(node)[att_name.to_sym]
+      
+    data.should == raw_data
+    md[:content_type].should == content_type
+    md[:file_modified].should == modified_at
+  end
+  
+    it "should delete all (subtract_all) files" do
+    node = @node_mock
+    
+    #create some more attachments
+    del_data = {}
+    del_data["del_data1"] = "my life will be short"
+    del_data["del_data2"] = "alas too short"
+    
+    #add the attachments
+    del_data.each do |name, data|
+      @attach_handler.add_raw_data(node, name, "text/plain", data, Time.now.to_s)
+    end
+    
+    #verify it's there
+    del_data.each do |name, data|
+      stored_data = @attach_handler.get_raw_data(node, name)
+      stored_data.should == data
+    end
+    
+    #delete it all
+    @attach_handler.subtract(node, :all)
+    
+    #verify it'snot  there
+    del_data.each do |name, data|
+      stored_data = @attach_handler.get_raw_data(node, name)
+      stored_data.should be_nil
+    end
+  end
+end