ferry 1.2.1 → 1.3.0

data/spec/tests/dumper_tests.rb

@@ -0,0 +1,12 @@
+dumper = Ferry::Dumper.new
+
+Dir.chdir("spec") unless Dir.pwd.split('/').last == "spec"
+
+describe "dumper" do
+  describe "sqlite3" do
+  end
+  describe "postgresql" do
+  end
+  describe "mysql2" do
+  end
+end

data/spec/tests/exporter_tests.rb

@@ -2,171 +2,191 @@ exporter = Ferry::Exporter.new
 
 Dir.chdir("spec") unless Dir.pwd.split('/').last == "spec"
 
-describe("export functionality") do
-	describe "#export" do
-		describe "sqlite3 db" do
-			before(:all) do
-				connect("sqlite3")
-				Contexts.setup
-			end
-			after(:all) do
-				Contexts.teardown
-				FileUtils.rm_rf('db')
-			end
-
-      it "should error if specified table does not exist" do
-        expect{exporter.to_csv('sqlite3', 'cart')}.to raise_error
-      end
+# TODO: test db func expo
+describe "exporting" do
+  describe "sqlite3 db" do
+    before(:all) do
+      connect("sqlite3")
+      Contexts.setup
+    end
+    after(:all) do
+      Contexts.teardown
+      FileUtils.rm_rf('db')
+    end
 
-      describe "to_csv" do
-    		it "call should create a populated csv file" do
-    			exporter.to_csv('sqlite3', 'carts')
-    			file_path = File.expand_path("..",Dir.pwd) + "/spec/db/csv/sqlite3/carts.csv"
-    			expect(File).to exist(file_path)
-    			lines = CSV.read(file_path)
-    			expect(lines.length).to eql(27)
-    			expect(lines[0]).to eql(["id", "email"])
-    			expect(lines[1]).to eql(["1", "abby@example.com"])
-    			expect(lines[26]).to eql(["26", "zach@example.com"])
-      	end
-      end
+    it "should error if specified table does not exist" do
+      expect{exporter.to_csv('sqlite3', 'cart')}.to raise_error
+    end
 
-      describe "to_yaml" do
-      	it "call should create a populated yaml file" do
-    			exporter.to_yaml('sqlite3', 'carts')
-    			file_path = File.expand_path("..", Dir.pwd) + "/spec/db/yaml/sqlite3/carts.yml"
-    			expect(File).to exist(file_path)
-    			output = YAML.load_file(file_path)
-    			expect(output["carts"].length).to eql(2)
-    			expect(output["carts"].keys).to eql(["columns","records"])
-    			expect(output["carts"]["columns"]).to eql(["id","email"])
-    			expect(output["carts"]["records"][0]).to eql([1,"abby@example.com"])
-    			expect(output["carts"]["records"][25]).to eql([26,"zach@example.com"])
-      	end
+    describe "to_csv" do
+      it "call should create a populated csv file" do
+        exporter.to_csv('sqlite3', 'carts')
+        file_path = File.expand_path("..",Dir.pwd) + "/spec/db/csv/sqlite3/carts.csv"
+        expect(File).to exist(file_path)
+        lines = CSV.read(file_path)
+        expect(lines.length).to eql(27)
+        expect(lines[0]).to eql(["id", "email"])
+        expect(lines[1]).to eql(["1", "abby@example.com"])
+        expect(lines[26]).to eql(["26", "zach@example.com"])
       end
+    end
 
-      describe "to_json" do
-        it "should create a correctly formatted json file" do
-          exporter.to_json('sqlite3', 'carts')
-          file_path = File.expand_path("..", Dir.pwd) + "/spec/db/json/sqlite3/carts.json"
-          file_content = File.read(file_path)
-          expect(File).to exist(file_path)
-          output = JSON.parse(file_content)
-          expect(output.length).to eql(26)
-          expect(output[0]["email"]).to eql("abby@example.com")
-          expect(output[25]["email"]).to eql("zach@example.com")
-        end
+    describe "to_yaml" do
+      it "call should create a populated yaml file" do
+        exporter.to_yaml('sqlite3', 'carts')
+        file_path = File.expand_path("..", Dir.pwd) + "/spec/db/yaml/sqlite3/carts.yml"
+        expect(File).to exist(file_path)
+        output = YAML.load_file(file_path)
+        expect(output["carts"].length).to eql(2)
+        expect(output["carts"].keys).to eql(["columns","records"])
+        expect(output["carts"]["columns"]).to eql(["id","email"])
+        expect(output["carts"]["records"][0]).to eql([1,"abby@example.com"])
+        expect(output["carts"]["records"][25]).to eql([26,"zach@example.com"])
       end
-		end
-
-	  describe "postgresql db" do
-			before(:all) do
-				connect("postgresql")
-				Contexts.setup
-			end
-			after(:all) do
-				Contexts.teardown
-				FileUtils.rm_rf('db')
-			end
-
-      it "should error if specified table does not exist" do
-        expect{exporter.to_csv('postgresql', 'cart')}.to raise_error
+    end
+
+    describe "to_json" do
+      it "should create a correctly formatted json file" do
+        exporter.to_json('sqlite3', 'carts')
+        file_path = File.expand_path("..", Dir.pwd) + "/spec/db/json/sqlite3/carts.json"
+        file_content = File.read(file_path)
+        expect(File).to exist(file_path)
+        output = JSON.parse(file_content)
+        expect(output.length).to eql(26)
+        expect(output[0]["email"]).to eql("abby@example.com")
+        expect(output[25]["email"]).to eql("zach@example.com")
       end
+    end
+
+    # describe "export db dumps" do
+    #   it "should be able to export a full sql dump to a file" do
+    #     pending("waiting to be written")
+    #     raise "so were failing for now"
+    #   end
+    # end
+  end
+
+  describe "postgresql db" do
+    before(:all) do
+      connect("postgresql")
+      Contexts.setup
+    end
+    after(:all) do
+      Contexts.teardown
+      FileUtils.rm_rf('db')
+    end
 
-      describe "to_csv" do
-    		it "call should create a populated csv file" do
-    			exporter.to_csv('postgresql', 'carts')
-    			file_path = File.expand_path("..",Dir.pwd) + "/spec/db/csv/postgresql/carts.csv"
-    			expect(File).to exist(file_path)
-    			lines = CSV.read(file_path)
-    			expect(lines.length).to eql(27)
-    			expect(lines[0]).to eql(["id", "email"])
-    			expect(lines[1]).to eql(["1", "abby@example.com"])
-    			expect(lines[26]).to eql(["26", "zach@example.com"])
-      	end
+    it "should error if specified table does not exist" do
+      expect{exporter.to_csv('postgresql', 'cart')}.to raise_error
+    end
+
+    describe "to_csv" do
+      it "call should create a populated csv file" do
+        exporter.to_csv('postgresql', 'carts')
+        file_path = File.expand_path("..",Dir.pwd) + "/spec/db/csv/postgresql/carts.csv"
+        expect(File).to exist(file_path)
+        lines = CSV.read(file_path)
+        expect(lines.length).to eql(27)
+        expect(lines[0]).to eql(["id", "email"])
+        expect(lines[1]).to eql(["1", "abby@example.com"])
+        expect(lines[26]).to eql(["26", "zach@example.com"])
       end
+    end
 
-      describe "to_yaml" do
-      	it "call should create a populated yaml file" do
-    			exporter.to_yaml('postgresql', 'carts')
-    			file_path = File.expand_path("..",Dir.pwd) + "/spec/db/yaml/postgresql/carts.yml"
-    			expect(File).to exist(file_path)
-    			output = YAML.load_file(file_path)
-    			expect(output["carts"].length).to eql(2)
-    			expect(output["carts"].keys).to eql(["columns","records"])
-    			expect(output["carts"]["columns"]).to eql(["id","email"])
-    			expect(output["carts"]["records"][0]).to eql(["1","abby@example.com"])
-    			expect(output["carts"]["records"][25]).to eql(["26","zach@example.com"])
-      	end
+    describe "to_yaml" do
+      it "call should create a populated yaml file" do
+        exporter.to_yaml('postgresql', 'carts')
+        file_path = File.expand_path("..",Dir.pwd) + "/spec/db/yaml/postgresql/carts.yml"
+        expect(File).to exist(file_path)
+        output = YAML.load_file(file_path)
+        expect(output["carts"].length).to eql(2)
+        expect(output["carts"].keys).to eql(["columns","records"])
+        expect(output["carts"]["columns"]).to eql(["id","email"])
+        expect(output["carts"]["records"][0]).to eql(["1","abby@example.com"])
+        expect(output["carts"]["records"][25]).to eql(["26","zach@example.com"])
       end
+    end
 
-      describe "to_json" do
-        it "should create a correctly formatted json file" do
-          exporter.to_json('postgresql', 'carts')
-          file_path = File.expand_path("..", Dir.pwd) + "/spec/db/json/postgresql/carts.json"
-          file_content = File.read(file_path)
-          expect(File).to exist(file_path)
-          output = JSON.parse(file_content)
-          expect(output.length).to eql(26)
-          expect(output[0]["email"]).to eql("abby@example.com")
-          expect(output[25]["email"]).to eql("zach@example.com")
-        end
+    describe "to_json" do
+      it "should create a correctly formatted json file" do
+        exporter.to_json('postgresql', 'carts')
+        file_path = File.expand_path("..", Dir.pwd) + "/spec/db/json/postgresql/carts.json"
+        file_content = File.read(file_path)
+        expect(File).to exist(file_path)
+        output = JSON.parse(file_content)
+        expect(output.length).to eql(26)
+        expect(output[0]["email"]).to eql("abby@example.com")
+        expect(output[25]["email"]).to eql("zach@example.com")
       end
     end
 
-	  describe "mysql2 db" do
-			before(:all) do
-				connect("mysql2")
-				Contexts.setup
-			end
-			after(:all) do
-				Contexts.teardown
-				FileUtils.rm_rf('db')
-			end
+    # describe "export db dumps" do
+    #   it "should be able to export a full sql dump to a file" do
+    #     pending("waiting to be written")
+    #     raise "so were failing for now"
+    #   end
+    # end
+  end
 
-      it "should error if specified table does not exist" do
-        expect{exporter.to_csv('mysql2', 'cart')}.to raise_error
-      end
+  describe "mysql2 db" do
+    before(:all) do
+      connect("mysql2")
+      Contexts.setup
+    end
+    after(:all) do
+      Contexts.teardown
+      FileUtils.rm_rf('db')
+    end
+
+    it "should error if specified table does not exist" do
+      expect{exporter.to_csv('mysql2', 'cart')}.to raise_error
+    end
 
-      describe "to_csv" do
-    		it "call should create a populated csv file" do
-    			exporter.to_csv('mysql2', 'carts')
-    			file_path = File.expand_path("..",Dir.pwd) + "/spec/db/csv/mysql2/carts.csv"
-    			expect(File).to exist(file_path)
-    			lines = CSV.read(file_path)
-    			expect(lines.length).to eql(27)
-    			expect(lines[0]).to eql(["id", "email"])
-    			expect(lines[1]).to eql(["1", "abby@example.com"])
-    			expect(lines[26]).to eql(["26", "zach@example.com"])
-      	end
+    describe "to_csv" do
+      it "call should create a populated csv file" do
+        exporter.to_csv('mysql2', 'carts')
+        file_path = File.expand_path("..",Dir.pwd) + "/spec/db/csv/mysql2/carts.csv"
+        expect(File).to exist(file_path)
+        lines = CSV.read(file_path)
+        expect(lines.length).to eql(27)
+        expect(lines[0]).to eql(["id", "email"])
+        expect(lines[1]).to eql(["1", "abby@example.com"])
+        expect(lines[26]).to eql(["26", "zach@example.com"])
       end
+    end
 
-      describe "to_yaml" do
-      	it "call should create a populated yaml file" do
-    			exporter.to_yaml('mysql2', 'carts')
-    			file_path = File.expand_path("..",Dir.pwd) + "/spec/db/yaml/mysql2/carts.yml"
-    			expect(File).to exist(file_path)
-    			output = YAML.load_file(file_path)
-    			expect(output["carts"].length).to eql(2)
-    			expect(output["carts"].keys).to eql(["columns","records"])
-    			expect(output["carts"]["columns"]).to eql(["id","email"])
-    			expect(output["carts"]["records"][0]).to eql([1,"abby@example.com"])
-    			expect(output["carts"]["records"][25]).to eql([26,"zach@example.com"])
-      	end
+    describe "to_yaml" do
+      it "call should create a populated yaml file" do
+        exporter.to_yaml('mysql2', 'carts')
+        file_path = File.expand_path("..",Dir.pwd) + "/spec/db/yaml/mysql2/carts.yml"
+        expect(File).to exist(file_path)
+        output = YAML.load_file(file_path)
+        expect(output["carts"].length).to eql(2)
+        expect(output["carts"].keys).to eql(["columns","records"])
+        expect(output["carts"]["columns"]).to eql(["id","email"])
+        expect(output["carts"]["records"][0]).to eql([1,"abby@example.com"])
+        expect(output["carts"]["records"][25]).to eql([26,"zach@example.com"])
       end
+    end
 
-      describe "to_json" do
-        it "should create a correctly formatted json file" do
-          exporter.to_json('mysql2', 'carts')
-          file_path = File.expand_path("..", Dir.pwd) + "/spec/db/json/mysql2/carts.json"
-          file_content = File.read(file_path)
-          expect(File).to exist(file_path)
-          output = JSON.parse(file_content)
-          expect(output.length).to eql(26)
-          expect(output[0]["email"]).to eql("abby@example.com")
-          expect(output[25]["email"]).to eql("zach@example.com")
-        end
+    describe "to_json" do
+      it "should create a correctly formatted json file" do
+        exporter.to_json('mysql2', 'carts')
+        file_path = File.expand_path("..", Dir.pwd) + "/spec/db/json/mysql2/carts.json"
+        file_content = File.read(file_path)
+        expect(File).to exist(file_path)
+        output = JSON.parse(file_content)
+        expect(output.length).to eql(26)
+        expect(output[0]["email"]).to eql("abby@example.com")
+        expect(output[25]["email"]).to eql("zach@example.com")
       end
     end
+
+    # describe "export db dumps" do
+    #   it "should be able to export a full sql dump to a file" do
+    #     pending("waiting to be written")
+    #     raise "so were failing for now"
+    #   end
+    # end
   end
 end

data/spec/tests/importer_tests.rb

@@ -2,8 +2,9 @@ importer = Ferry::Importer.new
 
 Dir.chdir("spec") unless Dir.pwd.split('/').last == "spec"
 
-describe "#import" do
-
+# TODO: import json tests - will need sample json file
+# TODO: import db things - will need sample db file
+describe "import" do
 	describe "sqlite3 db" do
 
 		before(:all) do
@@ -18,7 +19,7 @@ describe "#import" do
 
 		it "should import a valid csv into ActiveRecord" do
 			import_path = File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.csv"
-			importer.import("sqlite3", "categories", import_path)
+			importer.import_csv("sqlite3", "categories", import_path)
 			expect(Category.all.length).to eql(146)
 			expect(Category.find_by(id: 42).name).to eql("outdoor decor")
 			expect(Category.find_by(id: 42).description).to eql("Pellentesque magna odio, blandit in nisi fringilla, commodo.")
@@ -27,29 +28,41 @@ describe "#import" do
       expect(Category.find_by(id: 9).name).to eql("boys' clothing")
   	end
 
-    #SQL INSERT tests
     it "should error if given a non-csv file" do
-      expect{importer.import("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.xml")}.to raise_error
+      expect{importer.import_csv("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.xml")}.to raise_error
     end
 
     it "should error if file does not exist" do
-      expect{importer.import("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/invalid.csv")}.to raise_error
+      expect{importer.import_csv("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/invalid.csv")}.to raise_error
     end
 
     it "should error if invalid table name" do
-      expect{importer.import("sqlite3", "category", File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.csv")}.to raise_error
+      expect{importer.import_csv("sqlite3", "category", File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.csv")}.to raise_error
     end
 
     it "should error if columns are invalid" do
-      expect{importer.import("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_invalid_col.csv")}.to raise_error
+      expect{importer.import_csv("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_invalid_col.csv")}.to raise_error
     end
 
     it "should error if values do not meet db constraints" do
-      expect{importer.import("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_null_name.csv")}.to raise_error
+      expect{importer.import_csv("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_null_name.csv")}.to raise_error
+      expect{importer.import_csv("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_repeat_id.csv")}.to raise_error
+    end
 
-      expect{importer.import("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_repeat_id.csv")}.to raise_error
+    it "should be able to import a json file into ActiveRecord" do
+      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_import.json"
+      importer.import_json("sqlite3", "carts", import_path)
+      expect(Cart.find_by(id: 42).email).to eql("Albert@example.com")
+      expect(Cart.find_by(id: 542).email).to eql("Agustu@example.com")
+      expect(Cart.find_by(id: 1042).email).to eql("Smith@example.com")
+      expect(Cart.find_by(id: 1542).email).to eql("Kare@example.com")
+      expect(Cart.find_by(id: 2042).email).to eql("Yolanda@example.com")
     end
 
+    # it "should be able to import a full sql dump" do
+    #   pending("waiting to be written")
+    #   raise "so were failing for now"
+    # end
 	end
 
   describe "mass insert tests (sqlite)" do
@@ -65,8 +78,9 @@ describe "#import" do
     end
 
     it "should be able to import > 500 records" do
-      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_import.csv" #2100 records
-      importer.import("sqlite3", "carts", import_path)
+      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_import.csv"
+      importer.import_csv("sqlite3", "carts", import_path)
+      expect(Cart.all.length).to eql(2126)
       expect(Cart.find_by(id: 42).email).to eql("Albert@example.com")
       expect(Cart.find_by(id: 542).email).to eql("Agustu@example.com")
       expect(Cart.find_by(id: 1042).email).to eql("Smith@example.com")
@@ -75,33 +89,32 @@ describe "#import" do
     end
 
     it "should not commit import if any record errors" do
-      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_invalid.csv" #2100 records, last one is invalid
-      expect{importer.import("sqlite3", "carts", import_path)}.to raise_error
+      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_invalid.csv"
+      expect{importer.import_csv("sqlite3", "carts", import_path)}.to raise_error
       expect(Cart.find_by(id: 42)).to eql(nil)
       expect(Cart.find_by(id: 542)).to eql(nil)
       expect(Cart.find_by(id: 1042)).to eql(nil)
       expect(Cart.find_by(id: 1542)).to eql(nil)
       expect(Cart.find_by(id: 2042)).to eql(nil)
     end
-
   end
 
 	describe "postgresql db" do
 
-		before(:all) do
+		before(:each) do
 			connect("postgresql")
-			# requires you to have a ferry_test db in pg
 			Contexts.setup
 		end
 
-		after(:all) do
+		after(:each) do
 			Contexts.teardown
-			Category.delete_all
+      Category.delete_all
+      Cart.delete_all
 		end
 
 		it "should import a valid csv into ActiveRecord" do
 			import_path = File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.csv"
-			importer.import("postgresql", "categories", import_path)
+			importer.import_csv("postgresql", "categories", import_path)
 			expect(Category.all.length).to eql(146)
 			expect(Category.find_by(id: 42).name).to eql("outdoor decor")
 			expect(Category.find_by(id: 42).description).to eql("Pellentesque magna odio, blandit in nisi fringilla, commodo.")
@@ -110,10 +123,23 @@ describe "#import" do
       expect(Category.find_by(id: 9).name).to eql("boys' clothing")
   	end
 
+    it "should be able to import a json file correctly" do
+      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_import.json"
+      importer.import_json("sqlite3", "carts", import_path)
+      expect(Cart.find_by(id: 42).email).to eql("Albert@example.com")
+      expect(Cart.find_by(id: 542).email).to eql("Agustu@example.com")
+      expect(Cart.find_by(id: 1042).email).to eql("Smith@example.com")
+      expect(Cart.find_by(id: 1542).email).to eql("Kare@example.com")
+      expect(Cart.find_by(id: 2042).email).to eql("Yolanda@example.com")
+    end
+
+    # it "should be able to import a full sql dump" do
+    #   pending("waiting to be written")
+    #   raise "so were failing for now"
+    # end
 	end
 
   describe "mass insert tests (postgresql)" do
-
     before(:each) do
       connect("postgresql")
       Contexts.setup
@@ -124,44 +150,32 @@ describe "#import" do
       Cart.delete_all
     end
 
-    it "should be able to import >500 records" do
-      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_import.csv" #2100 records
-      importer.import("sqlite3", "carts", import_path)
-      expect(Cart.find_by(id: 42).email).to eql("Albert@example.com")
-      expect(Cart.find_by(id: 542).email).to eql("Agustu@example.com")
-      expect(Cart.find_by(id: 1042).email).to eql("Smith@example.com")
-      expect(Cart.find_by(id: 1542).email).to eql("Kare@example.com")
-      expect(Cart.find_by(id: 2042).email).to eql("Yolanda@example.com")
-    end
-
     it "should not commit import if any record errors" do
-      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_invalid.csv" #2100 records, last one is invalid
-      expect{importer.import("sqlite3", "carts", import_path)}.to raise_error
+      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_invalid.csv"
+      expect{importer.import_csv("sqlite3", "carts", import_path)}.to raise_error
       expect(Cart.find_by(id: 42)).to eql(nil)
       expect(Cart.find_by(id: 542)).to eql(nil)
       expect(Cart.find_by(id: 1042)).to eql(nil)
       expect(Cart.find_by(id: 1542)).to eql(nil)
       expect(Cart.find_by(id: 2042)).to eql(nil)
     end
-
   end
 
 	describe "mysql2 db" do
-
 		before(:all) do
 			connect("mysql2")
-			# requires you to have a ferry_test db in pg
 			Contexts.setup
 		end
 
 		after(:all) do
 			Contexts.teardown
 			Category.delete_all
+      Cart.delete_all
 		end
 
 		it "should import a valid csv values into ActiveRecord" do
 			import_path = File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.csv"
-			importer.import("mysql2", "categories", import_path)
+			importer.import_csv("mysql2", "categories", import_path)
 			expect(Category.all.length).to eql(146)
 			expect(Category.find_by(id: 42).name).to eql("outdoor decor")
 			expect(Category.find_by(id: 42).description).to eql("Pellentesque magna odio, blandit in nisi fringilla, commodo.")
@@ -170,10 +184,23 @@ describe "#import" do
       expect(Category.find_by(id: 9).name).to eql("boys' clothing")
   	end
 
+    it "should be able to import a json file correctly" do
+      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_import.json"
+      importer.import_json("sqlite3", "carts", import_path)
+      expect(Cart.find_by(id: 42).email).to eql("Albert@example.com")
+      expect(Cart.find_by(id: 542).email).to eql("Agustu@example.com")
+      expect(Cart.find_by(id: 1042).email).to eql("Smith@example.com")
+      expect(Cart.find_by(id: 1542).email).to eql("Kare@example.com")
+      expect(Cart.find_by(id: 2042).email).to eql("Yolanda@example.com")
+    end
+
+    # it "should be able to import a full sql dump" do
+    #   pending("waiting to be written")
+    #   raise "so were failing for now"
+    # end
 	end
 
   describe "mass insert tests (mysql2)" do
-
     before(:each) do
       connect("mysql2")
       Contexts.setup
@@ -185,25 +212,13 @@ describe "#import" do
     end
 
     it "should be able to import >500 records" do
-      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_import.csv" #2100 records
-      importer.import("sqlite3", "carts", import_path)
+      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_import.csv"
+      importer.import_csv("sqlite3", "carts", import_path)
       expect(Cart.find_by(id: 42).email).to eql("Albert@example.com")
       expect(Cart.find_by(id: 542).email).to eql("Agustu@example.com")
       expect(Cart.find_by(id: 1042).email).to eql("Smith@example.com")
       expect(Cart.find_by(id: 1542).email).to eql("Kare@example.com")
       expect(Cart.find_by(id: 2042).email).to eql("Yolanda@example.com")
     end
-
-    it "should not commit import if any record errors" do
-      import_path = File.expand_path("..",Dir.pwd) + "/spec/support/emails_invalid.csv" #2100 records, last one is invalid
-      expect{importer.import("sqlite3", "carts", import_path)}.to raise_error
-      expect(Cart.find_by(id: 42)).to eql(nil)
-      expect(Cart.find_by(id: 542)).to eql(nil)
-      expect(Cart.find_by(id: 1042)).to eql(nil)
-      expect(Cart.find_by(id: 1542)).to eql(nil)
-      expect(Cart.find_by(id: 2042)).to eql(nil)
-    end
-
   end
-
 end