tinkit 0.0.0

data/spec/helpers/bufs_test_environments.rb

@@ -0,0 +1,81 @@
+DirEnvHelpers = File.dirname(__FILE__)
+DirBaseEnvHelpers = File.join(DirEnvHelpers, '../../')
+DirFixEnvHelpers = File.join(DirBaseEnvHelpers, 'bufs_fixtures/bufs_fixtures')
+
+#include fixtures
+require DirFixEnvHelpers
+
+require 'couchrest'
+node_db_name = "http://bufs.younghawk.org:5984/bufs_test_spec/"
+CouchDB = TinkitFixtures::CouchDB #CouchRest.database!(node_db_name)
+CouchDB.compact!
+CouchDB2 = TinkitFixtures::CouchDB2
+CouchDB2.compact!
+FileSystem1 = "/home/bufs/bufs/sandbox_for_specs/file_system_specs/group1"
+FileSystem2 = "/home/bufs/bufs/sandbox_for_specs/file_system_specs/group2"
+
+require File.join(DirBaseEnvHelpers, 'lib/tinkit_node_factory')
+
+module UserNodeSpecHelpers
+  TinkitNodeLibs = [File.join(DirBaseEnvHelpers,'lib/glue_envs/bufs_couchrest_glue_env')]
+  TinkitNodeIncludes = [:CouchRestEnv]
+  TinkitFileLibs = [File.join(DirBaseEnvHelpers, 'lib/glue_envs/bufs_filesystem_glue_env')]
+  TinkitFileIncludes = [:FileSystemEnv]
+end
+
+#TODO: Combine this and the next module
+module NodeHelper
+  def self.env_builder(model_name, node_class_id, user_id, path, host = nil)
+        #binding data (note this occurs in two different places in the env)
+    
+    key_fields = {:required_keys => [:my_category],
+                         :primary_key => :my_category }
+    #data model
+    field_op_set ={:my_category => :static_ops,
+                          :description => :replace_ops,
+                             :parent_categories => :list_ops,
+                             :links => :key_list_ops }
+    #op_set_mod => <Using default definitions>
+    
+    data_model = {:field_op_set => field_op_set, :key_fields => key_fields}
+    
+    #persistence layer model
+    pmodel_env = { :host => host,
+                          :path => path,
+                          :user_id => user_id}
+    persist_model = {:name => model_name, :env => pmodel_env, :key_fields => key_fields}
+    
+    #final env model
+    env = { :node_class_id => node_class_id,
+                :data_model => data_model,
+                :persist_model => persist_model }
+  end
+end
+#for testing CouchRest model
+
+module NodeHelpers
+  DefaultNodeParams = {:my_category => 'default',
+                      :parent_categories => ['default_parent'],
+                      :description => 'default description'}
+
+  def get_default_params
+    DefaultNodeParams.dup #to avoid a couchrest weirdness don't use the params directly
+  end
+
+  def make_doc_no_attachment(user_class, override_defaults={})
+    init_params = get_default_params.merge(override_defaults)
+    return user_class.new(init_params)
+  end
+
+  def make_doc_w_attach_from_file(user_class, att_fname, override_defaults={})
+    test_filename = att_fname
+    test_basename = File.basename(test_filename)
+    raise "can't find file #{test_filename.inspect}" unless File.exists?(test_filename)
+    new_doc = make_doc_no_attachment(user_class, override_defaults)
+    new_doc.__save #doc must be saved before we can attach
+    file_data = {:src_filename => test_filename}
+    new_doc.files_add(file_data)
+    #new_doc.add_data_file(test_filename)
+    return new_doc
+  end
+end

data/spec/helpers/tmp_view_cleaner.rb

@@ -0,0 +1,15 @@
+require "fileutils"
+
+dirs_to_clean = ["/media-ec2/ec2a/projects/bufs/sandbox_for_specs/bufs_file_view_maker_spec/SampleCouchUser001",
+                 "/media-ec2/ec2a/projects/bufs/sandbox_for_specs/bufs_file_view_maker_spec/SampleCouchUser002",
+                 "/media-ec2/ec2a/projects/bufs/sandbox_for_specs/sample_data/SampleFileSysUser003/aa",
+                 "/media-ec2/ec2a/projects/bufs/sandbox_for_specs/sample_data/SampleFileSysUser003/b",
+                 "/media-ec2/ec2a/projects/bufs/sandbox_for_specs/sample_data/SampleFileSysUser003/c",
+                 "/media-ec2/ec2a/projects/bufs/sandbox_for_specs/sample_data/SampleFileSysUser004/aa",
+                 "/media-ec2/ec2a/projects/bufs/sandbox_for_specs/sample_data/SampleFileSysUser004/b",
+                 "/media-ec2/ec2a/projects/bufs/sandbox_for_specs/sample_data/SampleFileSysUser004/c"]
+
+dirs_to_clean.each do |dir|
+  FileUtils.rm_rf(dir)
+end
+

data/spec/lib_helpers/tk_escape_spec.rb

@@ -0,0 +1,45 @@
+#require helper for cleaner require statements
+require File.join(File.expand_path(File.dirname(__FILE__)), '../../lib/tinkit')
+
+require 'couchrest'
+
+require Tinkit.fixtures 'bufs_fixtures'
+require Tinkit.helpers 'tk_escape'
+
+doc_db_name = "http://127.0.0.1:5984/tk_escape_spec/"
+EscapeTestDB = CouchRest.database!(doc_db_name)
+EscapeTestDB.compact!
+
+describe TkEscape do
+
+  before(:each) do
+    EscapeTestDB.recreate!
+  end
+
+  it "should escape and unescape properly to the database" do
+    #set initial conditions
+    test_file_name = TinkitFixtures.test_files['strange_characters_in_file_name']
+    test_file_basename = File.basename(test_file_name)
+    test_file_data = File.open(test_file_name) {|f| f.read}
+    test_doc_params = {'_id' => 'test_doc'}
+    EscapeTestDB.save_doc(test_doc_params)
+    doc = EscapeTestDB.get(test_doc_params['_id'])
+    #test
+    att_name = TkEscape.escape(test_file_basename)
+    EscapeTestDB.put_attachment(doc, att_name, test_file_data)
+    #verify results
+    couchdb_name = EscapeTestDB.get(test_doc_params['_id'])['_attachments'].keys.first
+    att_name.should == couchdb_name
+
+    #test round trip
+    EscapeTestDB.delete_attachment(EscapeTestDB.get(test_doc_params['_id']), att_name)
+    EscapeTestDB.put_attachment(EscapeTestDB.get(test_doc_params['_id']), couchdb_name, test_file_data)
+    couchdb_name_rt1 = EscapeTestDB.get(test_doc_params['_id'])['_attachments'].keys.first
+
+    #verify results
+    att_name.should == couchdb_name_rt1
+
+    EscapeTestDB.delete_doc(EscapeTestDB.get(test_doc_params['_id']))
+  end
+end
+

data/spec/mysql_files_mgr_spec.rb

@@ -0,0 +1,250 @@
+#require helper for cleaner require statements
+require File.join(File.expand_path(File.dirname(__FILE__)), '../lib/helpers/require_helper')
+require Tinkit.glue 'mysql/mysql_files_mgr'
+
+include MysqlInterface
+GlueEnvMock = Struct.new(:model_key, :file_mgr_table)
+
+describe FilesMgr, "Setup and intialization" do
+
+  before(:all) do
+    
+    @glue_env_mock = GlueEnvMock.new("_id", "fake_file_table_name")
+    @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
+    
+    #we're not creating the table yet, as that depends on the glue and user
+    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.file_table_name.should == @glue_env_mock.file_mgr_table
+  end
+end
+  
+describe FilesMgr, "Basic Operations" do
+  before(:all) do
+    @file_table_name = "attachment_spec__node_loc"
+    @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.to_s,
+                                                   @file_table_name)
+
+    #set up table for spec
+    
+    primary_key = '__pkid-file'
+    home_dir = ENV["HOME"]  
+    my_pw = File.open("#{home_dir}/.locker/tinkit_mysql"){|f| f.read}.strip
+    @dbh = DBI.connect("DBI:Mysql:tinkit:localhost", "tinkit", my_pw)
+    
+    sql = "CREATE TABLE IF NOT EXISTS `#{@file_table_name}` (
+          `#{primary_key}` INT NOT NULL AUTO_INCREMENT,
+          node_name VARCHAR(255),
+          basename VARCHAR(255) NOT NULL,
+          content_type VARCHAR(255),
+          modified_at VARCHAR(255),
+          raw_content LONGBLOB,
+          PRIMARY KEY (`#{primary_key}`),
+          UNIQUE KEY (node_name, basename) )"
+     @dbh.do(sql)    
+    #
+    @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[@node_key]
+    @attach_handler = FilesMgr.new(@glue_env_mock, node_key_value)
+    #@attach_handler.subtract_files(nil, :all)
+  end
+  
+  after(:all) do
+    sql = "DROP TABLE `#{@file_table_name}`"
+    @dbh.do(sql)
+  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]
+      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][:content_type].should =~ /^text\/plain/
+      time_str = md[file_basename][: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 (subtract) 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]
+      
+    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's not  there
+    del_data.each do |name, data|
+      stored_data = @attach_handler.get_raw_data(node, name)
+      stored_data.should be_nil
+    end
+  end
+end

data/spec/mysql_glue_spec.rb

@@ -0,0 +1,214 @@
+#require helper for cleaner require statements
+require File.join(File.expand_path(File.dirname(__FILE__)), '../lib/helpers/require_helper')
+
+require Tinkit.glue 'mysql_glue_env'
+
+
+
+describe MysqlEnv::GlueEnv, "Initialization" do
+  
+  before(:each) do
+    #host is the database
+    persist_env = {:host => nil, :path => 'test_domain', :user_id => 'init_test_user'}
+    @persist_env = {:name => 'mysql_glue_test', :env => persist_env}
+    key_fields = {:required_keys => [:my_id],
+                         :primary_key => :my_id }
+    @data_model_bindings = {:key_fields => key_fields, :views => nil}
+  end
+  
+  it "should initialize properly" do
+    mysql_glue_obj = MysqlEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+    mysql_glue_obj.dbh.connected?.should == true
+    
+    mysql_glue_obj.user_id.should == @persist_env[:env][:user_id]
+    mysql_glue_obj.required_instance_keys.should == @data_model_bindings[:key_fields][:required_keys]
+    mysql_glue_obj.required_save_keys.should == @data_model_bindings[:key_fields][:required_keys]
+    mysql_glue_obj.node_key.should == @data_model_bindings[:key_fields][:primary_key]
+    mysql_glue_obj.metadata_keys.should == [mysql_glue_obj.persist_layer_key,
+                                                              mysql_glue_obj.version_key, 
+                                                            mysql_glue_obj.namespace_key]
+    path = @persist_env[:env][:path]
+    mysql_glue_obj.user_datastore_location.should == "#{path}__#{mysql_glue_obj.user_id}"
+    mysql_glue_obj._files_mgr_class.class.should_not == nil  #temp test
+    #sdb_glue_obj.views.should_not == nil #temp test
+    #sdb_glue_obj.moab_data.should_not == nil #temp test
+  end  
+end
+
+describe MysqlEnv::GlueEnv, "Persistent Layer Basic Operations" do
+  
+  before(:each) do
+    env = {:host => nil, :path => 'test_domain', :user_id => 'init_test_user'}
+    @persist_env = {:env => env}
+    key_fields = {:required_keys => [:my_id],
+                         :primary_key => :my_id }
+    @data_model_bindings = {:key_fields => key_fields, :views => nil}
+    @mysql_glue_obj = MysqlEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+  end
+  
+  after(:each) do
+    table = @mysql_glue_obj.model_save_params[:table]
+    dbh = @mysql_glue_obj.model_save_params[:dbh]
+    sql = "DROP TABLE `#{table}`"
+    dbh.do(sql)
+  end
+  
+  it "should persist data and be able to retrieve it" do
+    @mysql_glue_obj.should_not == nil
+    #:id was defined as the primary key
+    data1 = {:my_id => "test_id1", :data => "test data"}
+    empty_data = @mysql_glue_obj.get(data1[:my_id]) #hasn't been saved yet
+    empty_data.should == nil
+    @mysql_glue_obj.save(data1)
+    #Don't use native get_attributes, use obj's get,  it will block until save is finished
+    persisted_data = @mysql_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"}
+    @mysql_glue_obj.save(data1)
+    @mysql_glue_obj.save(data2)
+    persisted_data1 = @mysql_glue_obj.get(data1[:my_id])
+    persisted_data2 = @mysql_glue_obj.get(data2[:my_id])
+    persisted_data1[:data].should == "test data1"
+    persisted_data2[:data].should == "test data2"
+    @mysql_glue_obj.destroy_node({:my_id => data2[:my_id]})
+    persisted_data1 = @mysql_glue_obj.get(data1[:my_id])
+    persisted_data2 = @mysql_glue_obj.get(data2[:my_id])
+    persisted_data1[:data].should == "test data1"
+    persisted_data2.should == nil    
+  end
+end
+  
+describe MysqlEnv::GlueEnv, "Persistent Layer Collection Operations" do
+
+  before(:each) do
+    env = {:host => nil, :path => 'test_domain', :user_id => 'init_test_user'}
+    @persist_env = {:env => env}
+    key_fields = {:required_keys => [:my_id],
+                         :primary_key => :my_id }
+    @data_model_bindings = {:key_fields => key_fields, :views => nil}
+    @mysql_glue_obj = MysqlEnv::GlueEnv.new(@persist_env, @data_model_bindings)
+  end
+  
+  after(:each) do
+    table = @mysql_glue_obj.model_save_params[:table]
+    dbh = @mysql_glue_obj.model_save_params[:dbh]
+    sql = "DROP TABLE `#{table}`"
+    dbh.do(sql)
+  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"}
+    @mysql_glue_obj.save(data1)
+    @mysql_glue_obj.save(data2)
+  
+    results = @mysql_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| @mysql_glue_obj.save(data)}
+    
+    result1 = @mysql_glue_obj.find_nodes_where(:my_id, :equals, "test_id1")
+    result1.size.should == 1
+    result1.first[:my_id].should == "test_id1"
+    
+    result2 = @mysql_glue_obj.find_nodes_where(:my_id, :equals, "oops")
+    result2.should be_empty
+    
+    result3 = @mysql_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 = @mysql_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| @mysql_glue_obj.save(data)}
+    
+    result1 = @mysql_glue_obj.find_nodes_where(:my_id, :contains, "test_id2")
+    result1.size.should == 1
+    result1.first[:my_id].should == "test_id2"
+    
+    result2 = @mysql_glue_obj.find_nodes_where(:tags, :contains, "c")
+    result2.size.should == 3
+    
+    result3 = @mysql_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 = @mysql_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"}
+    @mysql_glue_obj.save(data1)
+    @mysql_glue_obj.save(data2)
+    @mysql_glue_obj.save(data3)
+    
+    results = @mysql_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]
+    @mysql_glue_obj.destroy_bulk(raw_rcds_to_delete)
+    
+    results = @mysql_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
+