tinkit 0.0.0

data/spec/tinkit_node_factory_spec.rb

@@ -0,0 +1,1108 @@
+#require helper for cleaner require statements
+require File.join(File.expand_path(File.dirname(__FILE__)), '../lib/helpers/require_helper')
+
+require Tinkit.spec_helpers 'bufs_test_environments'
+
+#Test Environments
+#The test environments sets up the following:
+# 4 seperate persistent layers
+# - 2 CouchDB databases using CouchRest 
+# - 2 File Systems (just different directories)  using File and FileUtils
+# A data structure called Tinkit
+# 2 "Glue" enviroments that bind the persistent layers to the data structure
+# The 4 low level persistent layers  are mapped to a common model framework
+# using the glue environments to bind the datastructure and persistent layers 
+# to the framework
+
+#Node Helpers
+# make_doc_no_attachment - makes a common framework node without attachment
+#   arguments: user_class, parameters
+# make_doc_w_attach_from_ile - makes a node with the file as an attachment
+#   arguments: user_class, filename, parameters)
+
+module MakeUserClasses
+    @user1_id = "CouchUser001"
+    @user2_id = "CouchUser002"
+    @user3_id = "FileSysUser003"
+    @user4_id = "FileSysUser004"
+    @user5_id = "SDBS3User005"
+    @user6_id = "MysqlUser006"
+    node_class_id1 = "TinkitInfoNode#{@user1_id}"
+    node_class_id2 = "TinkitInfoNode#{@user2_id}"
+    node_class_id3 = "TinkitFile#{@user3_id}"
+    node_class_id4 = "TinkitFile#{@user4_id}"
+    node_class_id5 = "TinkitSdbS3#{@user5_id}"
+    node_class_id6 = "MysqlUser006#{@user6_id}"
+    node_env1 = NodeHelper.env_builder("couchrest", node_class_id1, @user1_id, CouchDB.uri, CouchDB.host)
+    node_env2 = NodeHelper.env_builder("couchrest", node_class_id2, @user2_id, CouchDB.uri, CouchDB.host)
+    node_env3 = NodeHelper.env_builder("filesystem", node_class_id3, @user3_id, FileSystem1)
+    node_env4 = NodeHelper.env_builder("filesystem", node_class_id4, @user4_id, FileSystem2)
+    node_env5 = NodeHelper.env_builder("sdb_s3", node_class_id5, @user5_id, "MyDomain")
+    node_env6 = NodeHelper.env_builder("mysql", node_class_id6, @user6_id, "MyTable")
+    #node_env2 = CouchRestNodeHelpers.env_builder(node_class_id2, CouchDB2, @user2_id)
+    #node_env3 = FileSystemNodeHelpers.env_builder(node_class_id3, FileSystem1, @user3_id)
+    #node_env4 = FileSystemNodeHelpers.env_builder(node_class_id4, FileSystem2, @user4_id)
+    User1Class =  TinkitNodeFactory.make(node_env1)
+    User2Class =  TinkitNodeFactory.make(node_env2)
+    User3Class =  TinkitNodeFactory.make(node_env3)
+    User4Class =  TinkitNodeFactory.make(node_env4)
+    User5Class =  TinkitNodeFactory.make(node_env5)
+    User6Class =  TinkitNodeFactory.make(node_env6)
+    
+     #User5Class (AWS) is quirky and slow due to aws, add only when needed
+    ClassesToTest = [User1Class, User2Class, User3Class, User4Class, User6Class]
+end
+
+describe TinkitNodeFactory, "Making the Class" do
+  include MakeUserClasses
+
+  before(:each) do
+    @user_classes = ClassesToTest
+  end
+
+  after(:each) do
+    @user_classes.each do |user_class|
+      user_class.destroy_all
+    end
+  end
+
+  it "should initialize user docs properly" do
+    user_docs = {}
+    #test
+    @user_classes.each do |user_class|
+      #TODO: Fix Filesystem so we don't have to do this
+      my_cat_data = "#{user_class.name.gsub("::","_")}_data"
+      user_docs[user_class] = user_class.new({:my_category => my_cat_data})
+    end
+    #user2_doc = @user2_class.new({:my_category => "user2_data"})
+
+    #check results
+    user_docs.each do |user_class, user_node|
+      my_cat_data = "#{user_class.name.gsub("::","_")}_data"
+      user_node.my_category.should == my_cat_data
+    end 
+    #user1_doc.my_category.should == "user1_data"
+    #user2_doc.my_category.should == "user2_data"
+
+    #users should be in different databases
+    #raise @user_classes.inspect
+    couchrest_users = @user_classes.select{|u| u.to_s =~ /TinkitInfoNode/}
+    couchrest_users.size.should == 2
+    user0_db = couchrest_users[0].myGlueEnv.moab_data[:db]
+    user1_db = couchrest_users[1].myGlueEnv.moab_data[:db]
+    user0_db.should_not == user1_db
+
+    #users should be in different directories
+    filesystem_users = @user_classes.select{|u| u.to_s =~ /TinkitFile/}
+    filesystem_users.size.should == 2
+    user_dirs = filesystem_users.map{|f| f.myGlueEnv.user_datastore_location}
+    user_dirs[0].should_not == user_dirs[1]
+  end
+end
+
+describe TinkitNodeFactory, "Basic Operations" do
+  include MakeUserClasses
+  include NodeHelpers
+
+  before(:each) do
+    @user_classes = ClassesToTest
+  end
+
+  after(:each) do
+    @user_classes.each do |user_class|
+    user_class.destroy_all
+    end
+  end
+
+  it "should initialize correctly with no nodes" do
+    #check initial conditions
+    @user_classes.each do |user_class|
+      user_class.all.size.should == 0
+    end
+    #test
+    default_docs = []
+    @user_classes.each do |user_class|
+      default_docs << user_class.new(get_default_params)
+    end
+    #check results
+    default_docs.each do |default_doc|
+      default_doc.my_category.should == get_default_params[:my_category]
+      default_doc.parent_categories.should == get_default_params[:parent_categories]
+      default_doc.description.should == get_default_params[:description]
+    end
+    #we haven't saved it to the database yet
+    @user_classes.each do |user_class|
+      user_class.all.size.should == 0
+    end
+  end
+
+
+  #TODO: Add full collections testing
+  #FIXME: This test is not very robust
+  it "should be able to retrieve all records" do
+    user_docs = {}
+
+    @user_classes.each do |user_class|
+
+      #TODO: fix filesystem to handle strange characters
+      #my_cat_data = "#{user_class.name.gsub("::","_")}_data2"
+      my_cat_data = "#{user_class.name}_data2"
+      #my_cat_data = "flat_test"
+      user_docs[user_class] = user_class.new({:my_category => my_cat_data})
+    end
+
+
+    #user1_doc = @user1_class.new({:my_category => "user1_data"})
+    #user2_doc = @user2_class.new({:my_category => "user2_data"})
+    user_docs.each do |user_class, node|
+      #p node.my_category
+      #raise "::'s" if node.my_category =~ /::/
+      node.__save
+    end
+    #user1_doc.__save
+    #user2_doc.__save
+    #@user1_class.all.first.my_category.should == "user1_data"  
+    #@user2_class.all.first.my_category.should == "user2_data"
+
+    @user_classes.each do |user_class|
+      my_cat_data = "#{user_class.name}_data2"
+      user_class.all.first.my_category.should == my_cat_data
+    end
+  end
+
+  it "should not save if required fields don't exist" do
+    #set initial condition
+    orig_size = {}
+    @user_classes.each do |user_class|
+      orig_size[user_class] = user_class.all.size
+      lambda { user_class.new(:parent_categories => ['no_my_category'],
+                              :description => 'some description',
+                              :file_metadata => {})
+             }.should raise_error(ArgumentError)
+    end
+
+    @user_classes.each do |user_class|
+      user_class.all.size.should == orig_size[user_class]
+    end
+  end
+
+  it "should save" do
+    #set initial conditions
+    orig_size = {}
+    docs_params = {}
+    docs_to_save = {}
+    @user_classes.each do |user_class|
+      orig_size[user_class] = user_class.all.size
+      docs_params[user_class] = get_default_params.merge({:my_category => 'save_test'})
+      docs_to_save[user_class] = make_doc_no_attachment(user_class, docs_params[user_class].dup)
+    end
+
+    #test
+    docs_to_save.each do |user_class, doc_to_save|
+      doc_to_save.__save
+    end
+
+    #check results
+    @user_classes.each do |user_class|
+      docs_params[user_class].keys.each do |param|
+        persist_layer_key = user_class.myGlueEnv.persist_layer_key
+        doc_id = docs_to_save[user_class]._model_metadata[persist_layer_key]
+        #no longer just db, any persistent layer
+        doc_from_db = user_class.get(doc_id)
+        db_param = doc_from_db.__send__(param)
+        docs_to_save[user_class]._user_data[param].should == db_param
+        #test accessor method
+        docs_to_save[user_class].__send__(param).should == db_param
+      end
+    end
+    
+    @user_classes.each do |user_class|
+      user_class.all.size.should == orig_size[user_class] + 1
+    end 
+  end
+
+  #adding categories
+  it  "should add a single category (and add the property :parent_categories) for an initial category setting for a new doc" do
+    #set initial conditions
+    orig_parent_cats = {}
+    doc_params = {}
+    initial_revs = {}
+    aftersave_revs = {}
+    docs_with_new_parent_cat = {}
+    @user_classes.each do |user_class|
+      orig_parent_cats[user_class] = ['old parent cat']
+      new_params = get_default_params.merge({:my_category => "cat_test#{(user_class.hash).to_s}", :parent_categories => orig_parent_cats[user_class]})
+      doc_params[user_class] = new_params
+      docs_with_new_parent_cat[user_class] = make_doc_no_attachment(user_class, doc_params[user_class])
+      initial_revs[user_class] = docs_with_new_parent_cat[user_class]._model_metadata[:_rev]
+      #puts "#{user_class.inspect} rev: #{initial_revs[user_class].inspect}"
+    end
+    new_cat = 'new parent cat'
+
+    #test
+    @user_classes.each do |user_class|
+     docs_with_new_parent_cat[user_class].parent_categories_add(new_cat)
+     aftersave_revs[user_class] = docs_with_new_parent_cat[user_class]._model_metadata[:_rev]
+     #puts "AS: #{user_class.inspect} rev: #{aftersave_revs[user_class].inspect}"
+    end
+
+    #check results
+    @user_classes.each do |user_class|
+      #check doc in memory
+      docs_with_new_parent_cat[user_class].parent_categories.should include new_cat
+      #check database
+      doc_params[user_class].keys.each do |param|
+        persist_layer_key = user_class.myGlueEnv.persist_layer_key
+        node = docs_with_new_parent_cat[user_class]
+        node_id = node._model_metadata[persist_layer_key]
+        model_node = node.class.get(node_id)
+        db_param = model_node.__send__(param.to_sym)
+        docs_with_new_parent_cat[user_class]._user_data[param].should == db_param
+        #test accessor method
+        docs_with_new_parent_cat[user_class].__send__(param).should == db_param
+      end
+    end
+  end
+
+  it "should add categories to existing categories and existing doc" do
+    #set initial conditions
+    orig_parent_cats = {}
+    doc_params = {}
+    doc_existing_new_parent_cats = {}
+    @user_classes.each do |user_class|
+      orig_parent_cats[user_class]  = ["#{user_class.hash.to_s}-orig_cat1", "#{user_class.hash.to_s}-orig_cat2"]
+      doc_params[user_class] = get_default_params.merge({:my_category => "#{user_class.hash.to_s}-cat_test2",
+                                                      :parent_categories => orig_parent_cats[user_class]})
+      doc_existing_new_parent_cats[user_class] = make_doc_no_attachment(user_class, doc_params[user_class])
+      doc_existing_new_parent_cats[user_class].__save
+    end
+    #verify initial conditions
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_params[user_class].keys.each do |param|
+        doc_id = doc_existing_new_parent_cats[user_class]._model_metadata[persist_layer_key]
+        db_doc = user_class.get(doc_id)
+        #raise doc_id unless db_doc #._model_metadata.inspect
+        db_param = db_doc._user_data[param]
+        doc_existing_new_parent_cats[user_class]._user_data[param].should == db_param
+        #test accessor method
+        doc_existing_new_parent_cats[user_class].__send__(param).should == db_param
+      end
+    end
+    #continue with initial conditions
+    new_cats = ['new_cat1', 'new cat2', 'orig_cat2']
+    #test
+    @user_classes.each do |user_class|
+      doc_existing_new_parent_cats[user_class].parent_categories_add(new_cats)
+    end
+    #check results
+    #check doc in memory
+    @user_classes.each do |user_class|
+      new_cats.each do |new_cat|
+        doc_existing_new_parent_cats[user_class].parent_categories.should include new_cat
+      end
+    end
+    #check database
+    parent_cats = {}
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      parent_cats[user_class] = user_class.get(doc_existing_new_parent_cats[user_class]._model_metadata[persist_layer_key]).parent_categories
+      new_cats.each do |cat|
+        parent_cats[user_class].should include cat
+      end
+    end
+    #check all cats are there and are unique
+    @user_classes.each do |user_class|
+      parent_cats[user_class].sort.should == (orig_parent_cats[user_class] + new_cats).uniq.sort
+    end
+  end
+
+  it "should be able to remove parent categories" do
+    orig_parent_cats = {}
+    doc_params = {}
+    doc_remove_parent_cats = {}
+    #set initial conditions
+    @user_classes.each do |user_class|
+      orig_parent_cats[user_class]  = ['orig_cat3', 'orig_cat4', 'del_this_cat1', "del_this_cat2-#{user_class.to_s}"]
+      doc_params[user_class] = get_default_params.merge({:my_category => 'cat_test3', :parent_categories => orig_parent_cats[user_class]})
+      doc_remove_parent_cats[user_class] = make_doc_no_attachment(user_class, doc_params[user_class])
+      doc_remove_parent_cats[user_class].__save
+    end
+    #verify initial conditions
+    @user_classes.each do |user_class|
+      doc_params[user_class].keys.each do |param|
+        persist_layer_key = user_class.myGlueEnv.persist_layer_key
+        db_param = user_class.get(doc_remove_parent_cats[user_class]._model_metadata[persist_layer_key])._user_data[param]
+        doc_remove_parent_cats[user_class]._user_data[param].should == db_param
+        #test accessor method
+        doc_remove_parent_cats[user_class].__send__(param).should == db_param
+      end
+    end
+    #continue with initial conditions
+    remove_multi_cats = {}
+    @user_classes.each do |user_class|
+      remove_multi_cats[user_class] = ['del_this_cat1', "del_this_cat2-#{user_class.to_s}"]
+      remove_multi_cats[user_class].each do |cat|
+        doc_remove_parent_cats[user_class].parent_categories.should include cat
+      end
+    end
+
+    #test
+    @user_classes.each do |user_class|
+      doc_remove_parent_cats[user_class].parent_categories_subtract(remove_multi_cats[user_class])
+    end
+
+    #verify results
+    @user_classes.each do |user_class|
+      remove_multi_cats[user_class].each do |cat|
+        doc_remove_parent_cats[user_class].parent_categories.should_not include cat
+      end
+    end
+
+    cats_in_db = {}
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = doc_remove_parent_cats[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      cats_in_db[user_class] = db_doc._user_data[:parent_categories].inspect
+      remove_multi_cats[user_class].each do |removed_cat|
+        cats_in_db[user_class].should_not include removed_cat
+      end
+    end
+  end
+
+  it "should only have unique categories" do
+    #verify initial state
+    @user_classes.each do |user_class|
+      user_class.all.size.should == 0
+    end
+
+    orig_parent_cats = {}
+    doc_params = {}
+    doc_uniq_parent_cats = {}
+    orig_sizes = {}
+    new_cats = {}
+    expected_sizes = {}
+    #set initial conditions
+    @user_classes.each do |user_class|
+      orig_parent_cats[user_class] = ['dup cat1', 'dup cat2', 'uniq cat1']
+      doc_params[user_class] = get_default_params.merge({:my_category => 'cat_test3', :parent_categories => orig_parent_cats[user_class]})
+      doc_uniq_parent_cats[user_class] = make_doc_no_attachment(user_class, doc_params[user_class])
+      doc_uniq_parent_cats[user_class].__save
+      orig_sizes[user_class] = doc_uniq_parent_cats[user_class].parent_categories.size
+      new_cats[user_class] = ['dup cat1', 'dup cat2', 'uniq_cat2']
+      expected_sizes[user_class] = orig_sizes[user_class] + 1 #uniq_cat2
+    end
+
+    #test
+    @user_classes.each do |user_class|
+      doc_uniq_parent_cats[user_class].parent_categories_add(new_cats[user_class])
+    end
+
+    #verify results
+    records = {}
+    @user_classes.each do |user_class|
+      expected_sizes[user_class].should == doc_uniq_parent_cats[user_class].parent_categories.size
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = doc_uniq_parent_cats[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      #puts "Doc ID searched: #{doc_id.inspect}"
+      db_doc._user_data[:parent_categories].sort.should == doc_uniq_parent_cats[user_class].parent_categories.sort
+      #records[user_class] = user_class.call_view(:parent_categories, 'dup cat2')
+      records[user_class] = user_class.find_nodes_where(:parent_categories, :contains, 'dup cat2')
+      records[user_class].size.should == 1
+      records[user_class].first.parent_categories.should include 'dup cat2'
+    end
+  end
+
+  it "should allow new data fields to be added to the data structure" do
+    #set initial conditions
+    orig_parent_cats = {}
+    node_params = {}
+    nodes = {}
+    @user_classes.each do |user_class|
+      orig_parent_cats[user_class] = ['dyn data parent cat']
+      new_params = get_default_params.merge({:my_category => "cat_test#{(user_class.hash).to_s}",
+                                             :parent_categories => orig_parent_cats[user_class] })
+      node_params[user_class] = new_params
+      nodes[user_class] = make_doc_no_attachment(user_class, node_params[user_class])
+    end
+    new_key_field = :links
+    #test for new field
+    @user_classes.each do |user_class|
+      nodes[user_class].__set_userdata_key(new_key_field, nil)
+    end
+    @user_classes.each do |user_class|
+    #verify new field exists and works
+      nodes[user_class].respond_to?(new_key_field).should == true
+      nodes[user_class].__send__(new_key_field).should == nil
+    #initial conditions for  adding data
+    #NOTE: :links has a special operations for add and subtract
+    #defined in the Node Operations (see midas directory)
+      new_data = {:link_name => ["blah"], :link_src =>["http:\\\\to.somewhere.blah"]}
+      add_method = "#{new_key_field}_add".to_sym
+      link_add_op = DefaultOpSets::KListAddOpDef
+    #test adding new data
+      nodes[user_class].__send__(add_method, new_data)
+    #verify new data was added appropriately
+      updated_data = nodes[user_class].__send__(new_key_field)
+      updated_data.should == new_data #old links version it would not be equal
+      magically_transformed_data = link_add_op.call(nil, new_data)[:update_this]
+      magically_transformed_data.should == updated_data  #added to a list
+    end
+  end
+
+  it "should be able to delete basic nodes" do
+    #set initial conditions
+    orig_size = {}
+    docs_params = {}
+    docs_to_save = {}
+    docs_to_delete = {}
+    @user_classes.each do |user_class|
+      orig_size[user_class] = user_class.all.size
+      docs_params[user_class] = get_default_params.merge({:my_category => 'save_test'})
+      docs_to_save[user_class] = make_doc_no_attachment(user_class, docs_params[user_class].dup)
+      docs_to_save[user_class].__save
+    end
+    @user_classes.each do |user_class|
+      orig_size[user_class] = user_class.all.size
+      docs_params[user_class] = get_default_params.merge({:my_category => 'delete_test'})
+      docs_to_delete[user_class] = make_doc_no_attachment(user_class, docs_params[user_class].dup)
+      docs_to_delete[user_class].__save
+    end
+    #verify initial conditions
+    @user_classes.each do |user_class|
+      docs = user_class.all  #docs from persistent layer
+      docs.size.should == 2
+      my_cats = ['save_test', 'delete_test']
+      #verifies all docs exist
+      docs.each do |doc|
+        my_cats.include?(doc.my_category).should == true
+        my_cats.delete(doc.my_category)
+      end#each doc
+    end#each user_class
+  
+    #test
+    @user_classes.each do |user_class|
+      docs_to_delete[user_class].__destroy_node
+    end
+    
+    
+    #verify
+    @user_classes.each do |user_class|
+      docs = user_class.all  #docs from persistent layer
+      docs.size.should == 1
+      
+      #verifies all docs exist
+      docs.each do |doc|
+        doc.my_category.should == 'save_test'
+        doc.my_category.should_not == 'delete_test'
+      end#each doc
+    end#each user_class    
+  end#it
+
+  #it should distinguish between user model data and the persistence layer data
+end
+
+describe TinkitNodeFactory, "Document Operations with Attachments" do
+  include MakeUserClasses
+  include NodeHelpers
+  #include UserNodeSpecHelpers
+
+  before(:all) do
+    @test_files = TinkitFixtures.test_files
+  end
+
+  before(:each) do
+    @user_classes = ClassesToTest
+  end
+
+  after(:each) do
+    @user_classes.each do |user_class|
+      user_class.destroy_all
+    end
+  end
+
+  #This spec may not be needed anymore. Originally the models were defining
+  #the files manager's methods, but that's been moved into the base node
+  #so this test really only is a flag to an interface change (which may be more 
+  #annoying than userful)
+  it "has a file manager associated with its nodes" do
+     _files_mgr_methods = [:add_files, :add_raw_data, :subtract_files, 
+                          :get_raw_data, :get_attachments_metadata]
+    #set initial conditions
+    orig_parent_cats = {}
+    node_params = {}
+    nodes = {}
+    @user_classes.each do |user_class|
+      orig_parent_cats[user_class] = ['old parent cat']
+      new_params = get_default_params.merge({:my_category => "cat_test#{(user_class.hash).to_s}",
+                                             :parent_categories => orig_parent_cats[user_class] })
+      node_params[user_class] = new_params
+      nodes[user_class] = make_doc_no_attachment(user_class, node_params[user_class])
+    end
+     
+     responds_to_method = {}
+     should_respond_to_method = {}
+     @user_classes.each do |user_class|
+       _files_mgr_methods.each do |meth|
+         responds_to_method[meth] = nodes[user_class]._files_mgr.respond_to?(meth)
+         should_respond_to_method[meth] = true
+         #nodes[user_class]._files_mgr.respond_to?(meth).should == true
+       end
+       responds_to_method.should == should_respond_to_method
+     end
+   end
+
+  it "should save data files as an attachment with metadata" do
+    #initial conditions (attachment file)
+    #TODO: vary filename by user
+    test_filename = @test_files['binary_data_spaces_in_fname_pptx']
+    test_basename = File.basename(test_filename)
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    #intial conditions (doc)
+    parent_cats = {}
+    doc_params = {}
+    basic_docs = {}
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['docs with attachments']
+      doc_params[user_class] = get_default_params.merge({:my_category => 'doc_w_att1', :parent_categories => parent_cats[user_class]})
+      basic_docs[user_class] = make_doc_no_attachment(user_class, doc_params[user_class])
+      basic_docs[user_class].__save #doc must be saved before we can attach
+    end
+
+    #check initial conditions
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      db_doc._model_metadata['attachment_doc_id'].should == nil
+      #(user_class.get(basic_docs[user_class]._model_metadata['_id'])['attachment_doc_id']).should == nil
+    end
+    #test
+    #using just the filename
+    file_data = {:src_filename => test_filename}
+    @user_classes.each do |user_class|
+      basic_docs[user_class].files_add(file_data)
+    end
+
+    #check results
+    att_doc_ids = {}
+    att_docs = {}
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      id_of_doc_w_att = basic_docs[user_class]._model_metadata[persist_layer_key]
+      doc_w_att = user_class.get(id_of_doc_w_att)
+      doc_w_att.attached_files.size.should == 1
+      doc_w_att._user_data.should == basic_docs[user_class]._user_data
+      doc_w_att.attached_files.should == basic_docs[user_class].attached_files
+    end
+  end
+
+  it "should cleanly remove all attachments" do
+    #initial conditions 
+    #TODO: vary filename by user
+    test_filename = @test_files['binary_data_spaces_in_fname_pptx']
+    parent_cats = {}
+    doc_params = {}
+    basic_docs = {}
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['docs with attachments']
+      doc_params[user_class] = get_default_params.merge({:my_category => 'doc_w_att1', :parent_categories => parent_cats[user_class]})
+      basic_docs[user_class] = make_doc_w_attach_from_file(user_class, test_filename, doc_params[user_class])
+    end
+    #verify initial conditions
+    att_doc_ids = {}
+    att_files = {}
+    test_basename = File.basename(test_filename)
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      #raise db_doc.attachment_doc_id.inspect
+      att_files[user_class] = db_doc.attached_files
+      att_files[user_class].size.should == 1
+      att_files[user_class].first.should == TkEscape.escape(test_basename)
+    end
+    #test
+    attachment_name = test_basename
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc = user_class.get(basic_docs[user_class]._model_metadata[persist_layer_key])
+      doc.files_remove_all
+    end
+    #check results
+    #TODO: Highlight the fact that basic doc still has attachments in memory?
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      db_doc.attached_files.should == nil
+    end
+  end
+
+  it "should cleanly remove a single  attachment" do
+    #initial conditions
+    #TODO: vary filename by user
+    test_filename1 = @test_files['binary_data_spaces_in_fname_pptx']
+    test_filename2 = @test_files['binary_data2_docx'] 
+    parent_cats = {}
+    doc_params = {}
+    basic_docs = {}
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['docs with attachments']
+      doc_params[user_class] = get_default_params.merge({:my_category => 'doc_w_att2', :parent_categories => parent_cats[user_class]})
+      basic_docs[user_class] = make_doc_w_attach_from_file(user_class, test_filename1, doc_params[user_class])
+      basic_docs[user_class].files_add(:src_filename => test_filename2)
+    end
+
+    test_basename1 = File.basename(test_filename1)
+    test_basename2 = File.basename(test_filename2)
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      db_doc.attached_files.size.should == 2
+    end
+    #test
+    attachment_name1 = TkEscape.escape(test_basename1)
+    attachment_name2 = TkEscape.escape(test_basename2)
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc = user_class.get(basic_docs[user_class]._model_metadata[persist_layer_key])
+      doc.files_subtract(attachment_name1)
+    end
+    #check results
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      db_doc.attached_files.size.should == 1
+      db_doc.attached_files.first.should == TkEscape.escape(attachment_name2)
+    end
+    #delete again so that all attachments are deleted
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc = user_class.get(basic_docs[user_class]._model_metadata[persist_layer_key])
+      doc.files_subtract(attachment_name2)
+    end
+    #check results
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      db_doc.attached_files.size.should == 0
+    end
+  end
+
+  it "should list attachment list" do
+    #initial conditions
+    #TODO: vary filename by user, support multiple attachments
+    test_filename = @test_files['binary_data_spaces_in_fname_pptx']
+    parent_cats = {}
+    doc_params = {}
+    basic_docs = {}
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['docs with attachments']
+      doc_params[user_class] = get_default_params.merge({:my_category => 'doc_w_att1', :parent_categories => parent_cats[user_class]})
+
+      basic_docs[user_class] = make_doc_w_attach_from_file(user_class, test_filename, doc_params[user_class])
+    end
+    #verify initial conditions
+    att_doc_ids = {}
+    att_docs = {}
+    test_basename = File.basename(test_filename)
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      db_doc.attached_files.size.should == 1
+      db_doc.attached_files.first.should == TkEscape.escape(test_basename)
+    end
+    #test
+    attachment_names = {}
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      attachment_names[user_class] = db_doc.attached_files
+    end
+    #check results
+    @user_classes.each do |user_class|
+      attachment_names[user_class].size.should == 1
+      attachment_names[user_class].first.should == TkEscape.escape(test_basename)
+    end
+  end
+
+  it "should avoid creating hellish names when escaping and unescaping" do
+    #initial conditions (attachment file)
+    #this file has spaces in the file name
+    test_filename = @test_files['strange_characters_in_file_name']
+    test_basename = File.basename(test_filename)
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    #intial conditions (doc)
+    parent_cats = {}
+    doc_params = {}
+    basic_docs = {}
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['text file', 'test file']
+      doc_params[user_class] = get_default_params.merge({:my_category => 'strange_characters', :parent_categories => parent_cats[user_class]})
+      basic_docs[user_class] = make_doc_no_attachment(user_class, doc_params[user_class])
+      basic_docs[user_class].__save #doc must be saved before we can attach
+    end
+    #test
+    @user_classes.each do |user_class|
+      basic_docs[user_class].files_add(:src_filename => test_filename)
+    end
+    #check results
+    @user_classes.each do |user_class|
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      db_doc.attached_files.first.should == TkEscape.escape(test_basename)
+    end
+  end
+
+  it "should create an attachment from raw data" do
+    #TODO organize the test and chekcing results sections
+    #set initial conditions
+    data_file = @test_files['binary_data3_pptx'] #@test_files['strange_characters_in_file_name']
+    binary_data = File.open(data_file, 'rb'){|f| f.read}
+    binary_data_content_type = "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    attach_name = File.basename(data_file)
+    #intial conditions (doc)
+    parent_cats = {}
+    doc_params = {}
+    basic_docs = {}
+    metadata = {}
+    att_doc_ids = {}
+    att_docs = {}
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['docs with attachments']
+      doc_params[user_class] = get_default_params.merge({:my_category => 'doc_w_raw_data_att', :parent_categories => parent_cats[user_class]})
+      basic_docs[user_class] = make_doc_no_attachment(user_class, doc_params[user_class])
+      basic_docs[user_class].__save
+      #test
+      #metadata[user_class] = basic_docs[user_class].add_raw_data(attach_name, binary_data_content_type, binary_data)
+      #metadata[user_class].should == ["should be the metadata for that user"]
+      basic_docs[user_class].add_raw_data(attach_name, binary_data_content_type, binary_data)
+      #verify results
+      persist_layer_key = user_class.myGlueEnv.persist_layer_key
+      doc_id = basic_docs[user_class]._model_metadata[persist_layer_key]
+      db_doc = user_class.get(doc_id)
+      db_doc.attached_files.size.should == 1
+      att_file = db_doc.attached_files.first
+      att_file.should == TkEscape.escape(attach_name)
+      #TODO: More rigorous testing of attached data from raw data
+    end
+  end
+
+  it "should be able to retrieve the metadata for a single attachment" do
+    test_filename = @test_files['simple_text_file']
+    test_basename = File.basename(test_filename)
+    parent_cats = {}
+    node_params = {}
+    basic_nodes = {}
+    attached_basenames = {}
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    #set initial conditions
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['nodes with attachments']
+      my_cat = 'doc_w_att1'
+      params = {:my_category => my_cat, :parent_categories => parent_cats[user_class]}
+      node_params[user_class] = get_default_params.merge(params)
+      basic_nodes[user_class] = make_doc_no_attachment(user_class, node_params[user_class])
+      basic_nodes[user_class].__save
+      basic_nodes[user_class].files_add(:src_filename => test_filename)
+    end
+    #check initial conditions
+    @user_classes.each do |user_class|
+      attached_basenames[user_class] = basic_nodes[user_class].attached_files
+      attached_basenames[user_class].size.should == 1
+      attached_basename= attached_basenames[user_class].first
+      attached_basename.should == TkEscape.escape(test_basename)
+      #test
+      moab_att_metadata = basic_nodes[user_class].__get_attachment_metadata(attached_basename)
+      md = moab_att_metadata
+      md[:file_modified].should == File.mtime(test_filename).to_s
+      md[:content_type].should =~ /text\/plain/
+      #TODO Test for content type match too
+    end
+  end
+  
+  it "should be able to retrieve the metadata for an attachment" do
+    test_filename = @test_files['simple_text_file']
+    test_basename = File.basename(test_filename)
+    parent_cats = {}
+    node_params = {}
+    basic_nodes = {}
+    attached_basenames = {}
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    #set initial conditions
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['nodes with attachments']
+      my_cat = 'doc_w_att1'
+      params = {:my_category => my_cat, :parent_categories => parent_cats[user_class]}
+      node_params[user_class] = get_default_params.merge(params)
+      basic_nodes[user_class] = make_doc_no_attachment(user_class, node_params[user_class])
+      basic_nodes[user_class].__save
+      basic_nodes[user_class].files_add(:src_filename => test_filename)
+    end
+    #check initial conditions
+    @user_classes.each do |user_class|
+      attached_basenames[user_class] = basic_nodes[user_class].attached_files
+      attached_basenames[user_class].size.should == 1
+      attached_basename= attached_basenames[user_class].first
+      attached_basename.should == TkEscape.escape(test_basename)
+      #test
+      moab_att_metadata = basic_nodes[user_class].__get_attachments_metadata
+      md = moab_att_metadata[test_basename.to_sym]
+      md[:file_modified].should == File.mtime(test_filename).to_s
+      #TODO Test for content type match too
+    end
+  end
+
+  it "should be able to retrieve the raw data for an attachment" do
+    test_filename = @test_files['simple_text_file']
+    test_basename = File.basename(test_filename)
+    parent_cats = {}
+    node_params = {}
+    basic_nodes = {}
+    attached_basenames = {}
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    #set initial conditions
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['nodes with attachments']
+      my_cat = 'doc_w_att1'
+      params = {:my_category => my_cat, :parent_categories => parent_cats[user_class]}
+      node_params[user_class] = get_default_params.merge(params)
+      basic_nodes[user_class] = make_doc_no_attachment(user_class, node_params[user_class])
+      basic_nodes[user_class].__save
+      basic_nodes[user_class].files_add(:src_filename => test_filename)
+    end
+    #check initial conditions
+    @user_classes.each do |user_class|
+      attached_basenames[user_class] = basic_nodes[user_class].attached_files
+      attached_basenames[user_class].size.should == 1
+      attached_basename = attached_basenames[user_class].first
+      attached_basename.should == TkEscape.escape(test_basename)
+    #test
+      moab_raw_data = basic_nodes[user_class].get_raw_data(attached_basename)
+      file_raw_data = File.open(test_filename, "r"){|f| f.read}
+      moab_raw_data.should == file_raw_data
+    end
+  end
+
+  it "should have an export function for attachments" do
+    test_filename = @test_files['simple_text_file']
+    test_basename = File.basename(test_filename)
+    parent_cats = {}
+    node_params = {}
+    basic_nodes = {}
+    attached_basenames = {}
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    #set initial conditions
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['nodes with attachments']
+      my_cat = 'doc_w_att1'
+      params = {:my_category => my_cat, :parent_categories => parent_cats[user_class]}
+      node_params[user_class] = get_default_params.merge(params)
+      basic_nodes[user_class] = make_doc_no_attachment(user_class, node_params[user_class])
+      basic_nodes[user_class].__save
+      basic_nodes[user_class].files_add(:src_filename => test_filename)
+    end
+    #check initial conditions
+    @user_classes.each do |user_class|
+      attached_basenames[user_class] = basic_nodes[user_class].attached_files
+      attached_basenames[user_class].size.should == 1
+      attached_basename = attached_basenames[user_class].first
+      attached_basename.should == TkEscape.escape(test_basename)
+    #test
+      exported_att_data = basic_nodes[user_class].__export_attachment(attached_basename)
+      exported_att_data[:metadata].should == basic_nodes[user_class].__get_attachment_metadata(attached_basename)
+      exported_att_data[:raw_data].should == basic_nodes[user_class].get_raw_data(attached_basename)
+    end
+  end
+
+  it "should have an import function for attachments" do
+    test_filename = @test_files['simple_text_file']
+    test_basename = File.basename(test_filename)
+    parent_cats = {}
+    node_params = {}
+    basic_nodes = {}
+    attached_basenames = {}
+    att_names = {}
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    #set initial conditions
+    @user_classes.each do |user_class|
+      parent_cats[user_class] = ['nodes with attachments']
+      my_cat = 'doc_w_att1'
+      params = {:my_category => my_cat, :parent_categories => parent_cats[user_class]}
+      node_params[user_class] = get_default_params.merge(params)
+      basic_nodes[user_class] = make_doc_no_attachment(user_class, node_params[user_class])
+      basic_nodes[user_class].__save
+      file_modified = File.mtime(test_filename).to_s
+      content_type = MimeNew.for_ofc_x(test_filename)
+      metadata = {:file_modified => file_modified, :content_type => content_type}
+      raw_data = File.open(test_filename, "r"){|f| f.read}
+      import_format = {:raw_data => raw_data, :metadata => metadata}
+      att_names[user_class] = TkEscape.escape(test_basename)
+    #test
+      basic_nodes[user_class].__import_attachment(att_names[user_class], import_format)
+    end
+    #verify results
+    @user_classes.each do |user_class|
+      basic_nodes[user_class].attached_files.size.should == 1
+      basic_nodes[user_class].attached_files.first.should == att_names[user_class]
+    end
+  end
+
+
+  it "should be able to create a node from another node" do
+    #other node is from the first user class
+    test_filename = @test_files['simple_text_file']
+    test_basename = File.basename(test_filename)
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    #set initial conditions
+    parent_cats = ['nodes from other nodes']
+    my_cat1 = 'doc_w_att_xfer1'
+    my_cat2 = 'doc_w_att_xfer2'
+    params1 = {:my_category => my_cat1, :parent_categories => parent_cats}
+    params2 = {:my_category => my_cat2, :parent_categories => parent_cats}
+    node_params1 = get_default_params.merge(params1)
+    node_params2 = get_default_params.merge(params2)
+    #here is where we create the node from the first user class
+    user_class1 = @user_classes[0]
+    #TODO: Figure out better way that doesn't break when reconfiguring user classes
+    user_class2 = @user_classes[2] #||@user_classes[0]
+    raise "User Class is nil" unless (user_class1 && user_class2)
+    other_node1 = make_doc_no_attachment(user_class1, node_params1)
+    #plus one from a different class
+    other_node2 = make_doc_no_attachment(user_class2, node_params2)
+    other_node1.__save
+    other_node2.__save
+    other_node1.files_add(:src_filename => test_filename)
+    other_node2.files_add(:src_filename => test_filename)
+    #check initial conditions
+    other_node1.my_category.should == my_cat1
+    other_node1.attached_files.first.should == TkEscape.escape(test_basename)
+    other_node2.my_category.should == my_cat2
+    other_node2.attached_files.first.should == TkEscape.escape(test_basename)
+    #test
+    this_node = user_class2.__create_from_other_node(other_node1)
+    #test_inverse
+    this_other_node = user_class1.__create_from_other_node(other_node2)
+    #verify results
+    this_node.class.should == other_node2.class
+    this_node.class.should_not == other_node1.class
+    this_node.my_category.should == my_cat1
+    this_node.attached_files.first.should == TkEscape.escape(test_basename)
+    #verify inverse
+    this_other_node.class.should == other_node1.class
+    this_other_node.class.should_not == other_node2.class
+    this_other_node.my_category.should == my_cat2
+    this_other_node.attached_files.first.should == TkEscape.escape(test_basename)
+  end
+end
+
+#Note these tests use the default categories, rather than the buf categories
+describe TinkitNodeFactory, "Portable Views" do
+  include MakeUserClasses
+  include NodeHelpers
+
+  before(:each) do
+    @user_classes = [User1Class, User2Class, User3Class, User4Class]
+  end
+
+  after(:each) do
+    @user_classes.each do |user_class|
+      user_class.destroy_all
+    end
+  end
+
+  it "should be able to query all records in the persitence layer" do
+    user_docs = {}
+    @user_classes.each do |user_class|
+      node_list = [user_class.new({:my_category => "#{user_class.name}_data1"}),
+                       user_class.new({:my_category => "#{user_class.name}_data2"}),
+                       user_class.new({:my_category => "#{user_class.name}_data3"})]
+      node_list.each {|n| n.__save}
+      user_docs[user_class] = node_list
+      #user_docs[user_class] = user_class.new({:my_category => "#{user_class.name}_data2"})
+      #user_docs[user_class].__save
+    end
+
+     #tests the "all" class method to return all fields
+    @user_classes.each do |user_class|
+      user_nodes = user_class.all
+      user_nodes.size.should == 3
+      my_categories = user_nodes.map{|n| n.my_category}
+      my_categories.should include "#{user_class.name}_data1"
+      my_categories.should include "#{user_class.name}_data2"
+      #user_class.all.first.my_category.should == "blah" #"#{user_class.name}_data1"
+    end
+  end
+
+=begin 
+  it "should be able to select certain data" do
+    user_docs = {}
+    @user_classes.each do |user_class|
+      node_list = [user_class.new({:my_category => "#{user_class.name}_cat1", :label =>"#{user_class.name}_label"}),
+                       user_class.new({:my_category => "#{user_class.name}_cat2", :label =>"#{user_class.name}_label"}),
+                       user_class.new({:my_category => "#{user_class.name}_cat3", :other => "some other"})]
+      node_list.each {|n| n.__save}
+      user_docs[user_class] = node_list
+    end
+    
+     @user_classes.each do |user_class|
+      user_nodes = user_class.call_view
+      user_nodes.size.should == 2
+      my_categories = user_nodes.map{|n| n.my_category}
+      my_categories.should include "#{user_class.name}_data1"
+      my_categories.should include "#{user_class.name}_data2"
+      #user_class.all.first.my_category.should == "blah" #"#{user_class.name}_data1"
+    end
+  end
+=end
+end
+
+
+
+describe "Cleanup" do
+  include MakeUserClasses
+    before(:all) do
+    @test_files = TinkitFixtures.test_files
+  end
+
+  before(:each) do
+    @user_classes = [User1Class, User2Class,  User3Class, User4Class]
+  end
+
+  after(:each) do
+    @user_classes.each do |user_class|
+      user_class.destroy_all
+    end
+  end
+
+  #TODO: update for other persist layers
+  it "should leave underlying persistence models empty" do
+    #initial conditions
+    #check initial conditions
+    #persistence models used in specs
+    CouchDB.class.should == CouchRest::Database
+    File.exist?(FileSystem1).should == true
+    File.exist?(FileSystem2).should == true
+    #test
+    @user_classes.each do |user_class| 
+      user_class.destroy_all
+    end
+    doc_ids_in_db = CouchDB.documents['rows'].map{|i| i['id'] unless i['id'] =~ /^_design/ }.compact!
+    doc_ids_in_db.should == []
+    Dir.glob("#{FileSystem1}/#{@user_id3}/.model/**", File::FNM_DOTMATCH).should == []
+    Dir.glob("#{FileSystem2}/#{@user_id4}/.model/**", File::FNM_DOTMATCH).should == []
+    #note: A failure may mean changes were made to primary keys
+  end
+
+end
+
+#TODO:  Need to test boundary conditions