ferry 1.0.0 → 1.0.1

data/spec/support/schema.rb

@@ -18,7 +18,7 @@ ActiveRecord::Schema.define do
   end
 
   create_table :carts, :force=>true do |t|
-    t.column :email, :string
+    t.column :email, :string, :null => false
   end
 
   create_table :orders, :force=>true do |t|

data/spec/tests/exporter_tests.rb

@@ -13,27 +13,43 @@ describe("export functionality") do
 				Contexts.teardown
 				FileUtils.rm_rf('db')
 			end
-  		it "to_csv 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
-    	it "to_yaml 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
+
+        it "should error if specified table does not exist" do
+          expect{exporter.to_csv('sqlite3', 'cart')}.to raise_error #correct table is "carts"
+        end
+
+      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
+
+        it "should error if specified table does not exist" do
+          expect{exporter.to_yaml('sqlite3', 'cart')}.to raise_error #correct table is "carts"
+        end
+      end
+
 		end
 
 	  describe "postgresql db" do
@@ -46,27 +62,40 @@ describe("export functionality") do
 				Contexts.teardown
 				FileUtils.rm_rf('db')
 			end
-  		it "to_csv 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 "to_yaml 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_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 #correct table is "carts"
+        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
+
+        it "should error if specified table does not exist" do
+          expect{exporter.to_yaml('postgresql', 'cart')}.to raise_error #correct table is "carts"
+        end
+      end
     end
 
 	  describe "mysql2 db" do
@@ -79,27 +108,39 @@ describe("export functionality") do
 				Contexts.teardown
 				FileUtils.rm_rf('db')
 			end
-  		it "to_csv 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
-    	it "to_yaml 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_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
+        it "should error if specified table does not exist" do
+          expect{exporter.to_csv('mysql2', 'cart')}.to raise_error #correct table is "carts"
+        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
+        it "should error if specified table does not exist" do
+          expect{exporter.to_yaml('mysql2', 'cart')}.to raise_error #correct table is "carts"
+        end
+      end
     end
   end
 end

data/spec/tests/importer_tests.rb

@@ -2,68 +2,195 @@ importer = Ferry::Importer.new
 
 Dir.chdir("spec") unless Dir.pwd.split('/').last == "spec"
 
-describe("import functionality") do
-	describe "#import" do
-		describe "sqlite3 db" do
-			before(:all) do
-				connect("sqlite3")
-				Contexts.setup
-			end
-			after(:all) do
-				Contexts.teardown
-				Category.delete_all
-			end
-  		it "import should import valid csv values into ActiveRecord and the db" do
-  			import_path = File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.csv"
-  			importer.import("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.")
-  			expect(Category.find_by(id: 42).float_score).to eql(42.42)
-  			expect(Category.find_by(id: 42).active).to eql(true)
-    	end
+
+describe "#import" do
+	describe "sqlite3 db" do
+		before(:all) do
+			connect("sqlite3")
+			Contexts.setup
+		end
+		after(:all) do
+			Contexts.teardown
+			Category.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("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.")
+			expect(Category.find_by(id: 42).float_score).to eql(42.42)
+			expect(Category.find_by(id: 42).active).to eql(true)
+      expect(Category.find_by(id: 9).name).to eql("boys' clothing")
   	end
 
-  	describe "postgresql db" do
-			before(:all) do
-				connect("postgresql")
-				# requires you to have a ferry_test db in pg
-				Contexts.setup
-			end
-			after(:all) do
-				Contexts.teardown
-				Category.delete_all
-			end
-  		it "import should import valid csv values into ActiveRecord and the db" do
-  			import_path = File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.csv"
-  			importer.import("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.")
-  			expect(Category.find_by(id: 42).float_score).to eql(42.42)
-  			expect(Category.find_by(id: 42).active).to eql(true)
-    	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
+    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
+    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
+    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
+    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("sqlite3", "categories", File.expand_path("..",Dir.pwd) + "/spec/support/categories_repeat_id.csv")}.to raise_error
+    end
+
+	end
+
+  describe "mass insert tests (sqlite)" do
+    before(:each) do
+      connect("sqlite3")
+      Contexts.setup
+    end
+    after(:each) do
+      Contexts.teardown
+      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
+      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
+			connect("postgresql")
+			# requires you to have a ferry_test db in pg
+			Contexts.setup
+		end
+		after(:all) do
+			Contexts.teardown
+			Category.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)
+			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.")
+			expect(Category.find_by(id: 42).float_score).to eql(42.42)
+			expect(Category.find_by(id: 42).active).to eql(true)
+      expect(Category.find_by(id: 9).name).to eql("boys' clothing")
   	end
+	end
+
+  describe "mass insert tests (postgresql)" do
+    before(:each) do
+      connect("postgresql")
+      Contexts.setup
+    end
+    after(:each) do
+      Contexts.teardown
+      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
+      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
+
 
-  	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
-			end
-  		it "import should import valid csv values into ActiveRecord and the db" do
-  			import_path = File.expand_path("..",Dir.pwd) + "/spec/support/categories_import.csv"
-  			importer.import("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.")
-  			expect(Category.find_by(id: 42).float_score).to eql(42.42)
-  			expect(Category.find_by(id: 42).active).to eql(true)
-    	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
+		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)
+			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.")
+			expect(Category.find_by(id: 42).float_score).to eql(42.42)
+			expect(Category.find_by(id: 42).active).to eql(true)
+      expect(Category.find_by(id: 9).name).to eql("boys' clothing")
   	end
 	end
+
+  describe "mass insert tests (mysql2)" do
+    before(:each) do
+      connect("mysql2")
+      Contexts.setup
+    end
+    after(:each) do
+      Contexts.teardown
+      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
+      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

data/spec/tests/utilities_tests.rb

@@ -0,0 +1,32 @@
+utils = Ferry::Utilities.new
+
+Dir.chdir("spec") unless Dir.pwd.split('/').last == "spec"
+
+describe("utility functions") do
+	describe "#db_connect" do
+
+  		it "#sqlite3" do
+  			expect{utils.db_connect("sqlite3")}.not_to raise_error
+        expect(ActiveRecord::Base.connection.adapter_name).to eql('SQLite')
+    	end
+
+      it "#postgresql" do
+        expect{utils.db_connect("postgresql")}.not_to raise_error
+        expect(ActiveRecord::Base.connection.adapter_name).to eql('PostgreSQL')
+      end
+
+      it "#mysql2" do
+        expect{utils.db_connect("mysql2")}.not_to raise_error
+        expect(ActiveRecord::Base.connection.adapter_name).to eql('Mysql2')
+      end
+
+      it "#no environment with given name" do
+        expect{utils.db_connect("invalid_env")}.to raise_error
+      end
+
+      it "#unsupported DB type" do
+        expect{utils.db_connect("oracle")}.to raise_error
+      end
+
+  end
+end