tinkit 0.0.0

data/spec/filesystem_glue_spec.rb

@@ -0,0 +1,243 @@
+#require helper for cleaner require statements
+require File.join(File.expand_path(File.dirname(__FILE__)), '../lib/helpers/require_helper')
+
+require Tinkit.glue 'filesystem_glue_env'
+
+FilesystemGlueSpecDir = File.expand_path('../sandbox_for_specs/file_system_specs/glue_spec')
+
+describe FilesystemEnv::GlueEnv, "Initialization" do
+  before(:each) do
+    #set up env
+    persist_env = { :host => nil,
+                          :path => FilesystemGlueSpecDir,
+                          :user_id => 'fs_glue_user'}
+    
+    @persist_env = {:name => :filesystem_glue_test, :env => persist_env}
+    
+    key_fields = { :required_keys => [:my_category],
+                        :primary_key => :my_category }
+    
+    @data_model_bindings =  { :key_fields => key_fields,
+                                          :views => nil }
+    
+  end
+  
+  after(:each) do
+    fs_dir = File.dirname(@persist_env[:env][:path])
+    FileUtils.rm_rf(fs_dir) if fs_dir
+  end
+  
+  it "should initialize properly" do
+    filesystem_glue_obj = FilesystemEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+    #@data_dir = filesystem_glue_obj.user_datastore_location
+    
+    #filesystem_glue_obj.dbh.connected?.should == true
+    
+    filesystem_glue_obj.user_id.should == @persist_env[:env][:user_id]
+    filesystem_glue_obj.required_instance_keys.should == @data_model_bindings[:key_fields][:required_keys]
+    filesystem_glue_obj.required_save_keys.should == @data_model_bindings[:key_fields][:required_keys]
+    filesystem_glue_obj.node_key.should == @data_model_bindings[:key_fields][:primary_key]
+    filesystem_glue_obj.metadata_keys.should == [filesystem_glue_obj.persist_layer_key,
+                                                                    filesystem_glue_obj.version_key, 
+                                                                    filesystem_glue_obj.namespace_key]
+    base_dir = ".model"
+    path = @persist_env[:env][:path]
+    user_id = @persist_env[:env][:user_id]
+    filesystem_glue_obj.user_datastore_location.should == File.join(path, user_id, base_dir)
+    filesystem_glue_obj._files_mgr_class.class.should_not == nil    #The file manager class will handle file attachments
+  end  
+  
+end
+
+describe FilesystemEnv::GlueEnv, "Persistent Layer Basic Operations" do
+  
+  before(:each) do
+    #set up env
+    persist_env = { :host => nil,
+                          :path => FilesystemGlueSpecDir,
+                          :user_id => 'fs_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 => :filesystem, :env => persist_env}
+    
+    key_fields = { :required_keys => [:my_id],
+                        :primary_key => :my_id }
+    
+    @data_model_bindings =  { :key_fields => key_fields,
+                                          :views => nil }
+    
+    @filesystem_glue_obj = FilesystemEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+  end
+  
+  after(:all) do
+    fs_dir = File.dirname(@persist_env[:env][:path])
+    FileUtils.rm_rf(fs_dir) if fs_dir
+  end
+  
+  it "should persist data and be able to retrieve it" do
+    @filesystem_glue_obj.should_not == nil
+    #:id was defined as the primary key
+    data1 = {:my_id => "test_id1", :data => "test data"}
+    empty_data = @filesystem_glue_obj.get(data1[:my_id]) #hasn't been saved yet
+    empty_data.should == []
+    @filesystem_glue_obj.save(data1)
+    #Don't use native get_attributes, use obj's get,  it will block until save is finished
+    persisted_data = @filesystem_glue_obj.get(data1[:my_id]) 
+    persisted_data.should_not == nil
+    #p 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"}
+    @filesystem_glue_obj.save(data1)
+    @filesystem_glue_obj.save(data2)
+    persisted_data1 = @filesystem_glue_obj.get(data1[:my_id])
+    persisted_data2 = @filesystem_glue_obj.get(data2[:my_id])
+    persisted_data1[:data].should == "test data1"
+    persisted_data2[:data].should == "test data2"
+    @filesystem_glue_obj.destroy_node({:my_id => data2[:my_id]})
+    persisted_data1 = @filesystem_glue_obj.get(data1[:my_id])
+    persisted_data2 = @filesystem_glue_obj.get(data2[:my_id])
+    persisted_data1[:data].should == "test data1"
+    persisted_data2.should == []    
+  end
+end
+
+describe FilesystemEnv::GlueEnv, "Persistent Layer Collection Operations" do
+
+  before(:each) do
+    #set up env
+    persist_env = { :host => nil,
+                          :path => FilesystemGlueSpecDir,
+                          :user_id => 'fs_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 => :filesystem, :env => persist_env}
+    
+    key_fields = { :required_keys => [:my_id],
+                        :primary_key => :my_id }
+    
+    @data_model_bindings =  { :key_fields => key_fields,
+                                          :views => nil }
+    
+    @filesystem_glue_obj = FilesystemEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+  end
+  
+  after(:each) do
+    fs_dir = File.dirname(@persist_env[:env][:path])
+    FileUtils.rm_rf(fs_dir) if fs_dir
+  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"}
+    @filesystem_glue_obj.save(data1)
+    @filesystem_glue_obj.save(data2)
+  
+    results = @filesystem_glue_obj.query_all
+    #results.should == 'blah'
+    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"
+      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| @filesystem_glue_obj.save(data)}
+    
+    result1 = @filesystem_glue_obj.find_nodes_where(:my_id, :equals, "test_id1")
+    result1.size.should == 1
+    result1.first[:my_id].should == "test_id1"
+    
+    result2 = @filesystem_glue_obj.find_nodes_where(:my_id, :equals, "oops")
+    result2.should be_empty
+    
+    result3 = @filesystem_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 = @filesystem_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| @filesystem_glue_obj.save(data)}
+    
+    result1 = @filesystem_glue_obj.find_nodes_where(:my_id, :contains, "test_id2")
+    result1.size.should == 1
+    result1.first[:my_id].should == "test_id2"
+    
+    result2 = @filesystem_glue_obj.find_nodes_where(:tags, :contains, "c")
+    result2.size.should == 3
+    
+    result3 = @filesystem_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 = @filesystem_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"}
+    @filesystem_glue_obj.save(data1)
+    @filesystem_glue_obj.save(data2)
+    @filesystem_glue_obj.save(data3)
+    
+    results = @filesystem_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]
+    @filesystem_glue_obj.destroy_bulk(raw_rcds_to_delete)
+    
+    results = @filesystem_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_helpers_spec.rb

@@ -0,0 +1,42 @@
+#require helper for cleaner require statements
+require File.join(File.dirname(__FILE__), '../lib/helpers/require_helper')
+
+require Tinkit.helpers 'filesystem_helpers'
+
+require 'fileutils'
+
+describe DirFilter do
+  before(:each) do
+    root_test_dir = '/tmp'
+    working_dir = 'dir_filter_tests'
+    @basenames_to_make = ['keep1', 
+                                        'keep2', 
+                                        '.dot_file', 
+                                        'ignore_this_file', 
+                                        'ignore_this_file_too',
+                                        'another_file_to_ignore',
+                                        'skip_this_one_too',
+                                        'but_dont_skip_this_one']
+                
+    @working_path = File.join(root_test_dir, working_dir)
+    @files_to_make = @basenames_to_make.map{|b| File.join(@working_path, b)}
+    #create directory for tests
+    FileUtils.mkdir_p(@working_path)
+    FileUtils.touch(@files_to_make)
+  end
+  
+  after(:each) do
+    FileUtils.rm_rf(@working_path)
+  end
+  
+  it "should have made files to test with" do
+    expected_entries = @basenames_to_make + [".", ".."]
+    Dir.entries(@working_path).sort.should == expected_entries.sort
+  end
+  
+  it "should filter appropriate entries" do
+    filter = DirFilter.new([/ignore/, /^skip/])
+    filter.filter_entries(@working_path).sort.should == ['but_dont_skip_this_one', 'keep1', 'keep2']
+  end
+  
+end

data/spec/helpers/bufs_node_builder.rb

@@ -0,0 +1,17 @@
+module TinkitNodeBuilder
+  DefaultDocParams = {:my_category => 'default',
+                      :parent_categories => ['default_parent'],
+                      :description => 'default description'}
+
+  def get_default_params
+    DefaultDocParams.dup #to avoid a couchrest weirdness don't use the params directly
+  end
+  
+  def make_doc_no_attachment(override_defaults={})
+    #default_params = {:my_category => 'default', 
+    #                  :parent_categories => ['default_parent'],
+    #	      :description => 'default description'}
+    init_params = get_default_params.merge(override_defaults)
+    return TinkitBaseNode.new(init_params)
+  end
+end

data/spec/helpers/bufs_sample_dataset.rb

@@ -0,0 +1,160 @@
+SampleDataSpec = File.dirname(__FILE__)
+require File.join(SampleDataSpec, 'bufs_test_environments')
+
+node_db_name = "http://127.0.0.1:5984/sample_data/"
+SampleCouchDB = CouchRest.database!(node_db_name)
+SampleCouchDB.compact!
+
+FileSystem = "/home/bufs/bufs/sandbox_for_specs/sample_data"
+
+
+module MakeUserClasses
+    @user1_id = "SampleCouchUser001"
+    @user2_id = "SampleCouchUser002"
+    @user3_id = "SampleFileSysUser003"
+    @user4_id = "SampleFileSysUser004"
+    node_class_id1 = "TinkitInfoNode#{@user1_id}"
+    node_class_id2 = "TinkitInfoNode#{@user2_id}"
+    node_class_id3 = "TinkitFile#{@user3_id}"
+    node_class_id4 = "TinkitFile#{@user4_id}"
+    couchpath = SampleCouchDB.uri
+    couchhost = SampleCouchDB.host
+    node_env1 = NodeHelper.env_builder("couchrest", node_class_id1, @user1_id, couchpath, couchhost)
+    node_env2 = NodeHelper.env_builder("couchrest", node_class_id2, @user2_id, couchpath, couchhost)
+    node_env3 = NodeHelper.env_builder("filesystem", node_class_id3, @user3_id, FileSystem)
+    node_env4 = NodeHelper.env_builder("filesystem", node_class_id4, @user4_id, FileSystem)
+    User1Class =  TinkitNodeFactory.make(node_env1)
+    User2Class =  TinkitNodeFactory.make(node_env2)
+    User3Class =  TinkitNodeFactory.make(node_env3)
+    User4Class =  TinkitNodeFactory.make(node_env4)
+end
+
+
+#file list
+#---------------------------------
+#- Test Filenames and References -
+#---------------------------------
+#binary_data_pptx                  ->  test_files/spec_test1.pptx
+#binary_data_spaces_in_fname_pptx  ->  test_files/spec test2 v1.3.pptx
+#binary_data2_docx                 ->  test_files/spec test2.docx
+#binary_data3_pptx                 ->  test_files/spec_test3.pptx
+#fresh_file                        ->  test_files/test_modified_time_fresh.txt
+#simple_text_file                  ->  test_files/simple_text_file1.txt
+#simple_text_file2                 ->  test_files/simple text file 2.txt
+#simple_text_file3                 ->  test_files/simple text file 3.txt
+#simple_text_file4                 ->  test_files/simple text file 4.txt
+#stale_file                        ->  test_files/test_modified_time_stale.txt
+#strange_characters_in_file_name   ->  test_files/Test%_+- .,^^,. -+_%.txt
+
+module SampleDataSets
+  module Sample1
+    data_set = {}
+    keys = [:a, :aa, :ab, :ac, :aaa, :b, :ba, :bb, :bc, :bbb, :bcc, :c, :cc]
+    keys.each {|key| data_set[key] ={} }  #set all to hash
+    
+    data_set[:a][:my_category] = 'a'
+    data_set[:a][:parent_categories] = ['aa']
+    
+    data_set[:aa][:my_category] = 'aa'
+    data_set[:aa][:parent_categories] = ['a']
+    data_set[:aa][:files] = ['simple_text_file', 'binary_data_pptx']
+    
+    data_set[:ab][:my_category] = 'ab'
+    data_set[:ab][:parent_categories] = ['a', 'aaa', 'bb', 'just_a_label2']
+    
+    data_set[:ac][:my_category] = 'ac'
+    data_set[:ac][:parent_categories] = ['a']
+    data_set[:ac][:files] = ['binary_data_spaces_in_fname_pptx']
+    data_set[:ac][:links] = [['google', 'http://www.google.com']]
+    
+    data_set[:aaa][:my_category] = 'aaa'
+    data_set[:aaa][:parent_categories] = ['aa', 'just_a_label']
+    
+    data_set[:b][:my_category] = 'b'
+    data_set[:b][:parent_categories] = ['just_a_label']
+    data_set[:b][:files] = ['simple_text_file2', 'simple_text_file3']
+    data_set[:b][:links] = [['yahoo', 'http://www.yahoo.com'], ['google', 'http://www.google.com']]
+    
+    data_set[:ba][:my_category] = 'ba'
+    data_set[:ba][:parent_categories] = ['b', 'ab']
+    data_set[:ba][:files] = ['simple_text_file']
+    data_set[:ba][:links] = [['yahoo2', 'http://www.yahoo.com'], ['google', 'http://www.google.com']]
+    
+    data_set[:bb][:my_category] = 'bb'
+    data_set[:bb][:parent_categories] = ['b']
+    data_set[:bb][:files] = ['strange_characters_in_file_name']
+    
+    data_set[:bc][:my_category] = 'bc'
+    data_set[:bc][:parent_categories] = ['b', 'bbb', 'just_a_label2']
+    
+    data_set[:bbb][:my_category] = 'bbb'
+    data_set[:bbb][:parent_categories] = ['bb', 'aaa']
+    
+    data_set[:bcc][:my_category] = 'bcc'
+    data_set[:bcc][:parent_categories] = ['bc']
+    data_set[:bcc][:links] = [[['MeFi'], 'http:\\www.metafilter.com']]
+    
+    data_set[:c][:my_category] = 'c'
+    data_set[:c][:parent_categories] = []
+    data_set[:cc][:my_category] = 'cc'
+    data_set[:cc][:parent_categories] = ['c']
+    data_set[:cc][:files] = ['simple_text_file']
+    data_set[:cc][:links] = [['google2', 'http:\\www.google.com']]
+
+    DataSet = data_set
+  end
+end
+
+module PopulatePersistenceModels
+include MakeUserClasses
+include SampleDataSets
+include NodeHelpers
+
+  @user_classes = [User1Class, User2Class, User3Class, User4Class]
+  @test_files = TinkitFixtures.test_files
+  
+  #stupid hack so I don't have to go change existing stuff
+  class Dummy
+    include NodeHelpers
+  end
+
+  def self.convert_links_to_hash(links)
+    link_hash = {}
+    return unless links
+    links.each do |link_pair|
+      link_hash[link_pair[1]] = link_pair[0]
+    end
+    link_hash
+  end
+  
+  def self.add_data_set_to_model(data_set = Sample1::DataSet)
+    data_set.each do |node, node_data|
+      params = { :my_category => node_data[:my_category],
+                       :parent_categories => node_data[:parent_categories],
+                       :links => self.convert_links_to_hash(node_data[:links]),
+                       :description => "test"}
+      raise "Params Issue with :my_category #{params.inspect}" unless node_data[:my_category]
+      raise "Params Issue with :parent_categories #{params.inspect}" unless node_data[:parent_categories]
+      @user_classes.each do |user_class|
+        node = Dummy.new.make_doc_no_attachment(user_class, params)
+        node.description = "from: #{node.my_GlueEnv.user_id}"
+        
+        #add files to node
+        if node_data[:files]
+          file_references = node_data[:files]
+          file_data = file_references.map{|ref| {:src_filename => @test_files[ref]}}
+          node.files_add(file_data)
+        end
+        
+        #Another Hack to be able to find the user as root in a tree
+        user_id = user_class.myGlueEnv.user_id
+        if node.my_category == 'a'|| node.my_category == 'b'|| node.my_category == 'c'
+          node.parent_categories_add(user_id)
+        end
+        node.__save
+      end
+    end
+    @user_classes
+  end
+
+end