taps 0.2.26 → 0.3.0

data/spec/client_session_spec.rb

@@ -1,88 +0,0 @@
-require File.dirname(__FILE__) + '/base'
-require File.dirname(__FILE__) + '/../lib/taps/client_session'
-
-describe Taps::ClientSession do
-	before do
-		@client = Taps::ClientSession.new('sqlite://my.db', 'http://example.com:3000', 1000)
-		@client.stubs(:session_resource).returns(mock('session resource'))
-	end
-
-	it "starts a session and yields the session object to the block" do
-		Taps::ClientSession.start('x', 'y', 1000) do |session|
-			session.database_url.should == 'x'
-			session.remote_url.should == 'y'
-			session.default_chunksize.should == 1000
-		end
-	end
-
-	it "opens the local db connection via sequel and the database url" do
-		Sequel.expects(:connect).with('sqlite://my.db').returns(:con)
-		@client.db.should == :con
-	end
-
-	it "creates a restclient resource to the remote server" do
-		@client.server.url.should == 'http://example.com:3000'
-	end
-
-	it "verifies the db version, receive the schema, data, indexes, then reset the sequences" do
-		@client.expects(:verify_server)
-		@client.expects(:cmd_receive_schema)
-		@client.expects(:cmd_receive_data)
-		@client.expects(:cmd_receive_indexes)
-		@client.expects(:cmd_reset_sequences)
-		@client.cmd_receive.should.be.nil
-	end
-
-	it "checks the version of the server by seeing if it has access" do
-		@client.stubs(:server).returns(mock('server'))
-		@request = mock('request')
-		@client.server.expects(:[]).with('/').returns(@request)
-		@request.expects(:get).with({:taps_version => Taps.compatible_version})
-
-		lambda { @client.verify_server }.should.not.raise
-	end
-
-	it "receives data from a remote taps server" do
-		@client.stubs(:puts)
-		@progressbar = mock('progressbar')
-		ProgressBar.stubs(:new).with('mytable', 2).returns(@progressbar)
-		@progressbar.stubs(:inc)
-		@progressbar.stubs(:finish)
-		@mytable = mock('mytable')
-		@client.expects(:fetch_remote_tables_info).returns([ { :mytable => 2 }, 2 ])
-		@client.stubs(:db).returns(mock('db'))
-		@client.db.stubs(:[]).with(:mytable).returns(@mytable)
-		@client.expects(:fetch_table_rows).with(:mytable, 1000, 0).returns([ 1000, { :header => [:x, :y], :data => [[1, 2], [3, 4]] } ])
-		@client.expects(:fetch_table_rows).with(:mytable, 1000, 2).returns([ 1000, { }])
-		@mytable.expects(:import).with([:x, :y], [[1, 2], [3, 4]])
-
-		lambda { @client.cmd_receive_data }.should.not.raise
-	end
-
-	it "fetches remote tables info from taps server" do
-		@marshal_data = Marshal.dump({ :mytable => 2 })
-		@client.session_resource.stubs(:[]).with('tables').returns(mock('tables'))
-		@client.session_resource['tables'].stubs(:get).with(:taps_version => Taps.compatible_version).returns(@marshal_data)
-		@client.fetch_remote_tables_info.should == [ { :mytable => 2 }, 2 ]
-	end
-
-	it "fetches table rows given a chunksize and offset from taps server" do
-		@data = { :header => [ :x, :y ], :data => [ [1, 2], [3, 4] ] }
-		@gzip_data = Taps::Utils.gzip(Marshal.dump(@data))
-		Taps::Utils.stubs(:calculate_chunksize).with(1000).yields(1000).returns(1000)
-
-		@response = mock('response')
-		@client.session_resource.stubs(:[]).with('tables/mytable/1000?offset=0').returns(mock('table resource'))
-		@client.session_resource['tables/mytable/1000?offset=0'].expects(:get).with(:taps_version => Taps.compatible_version).returns(@response)
-		@response.stubs(:to_s).returns(@gzip_data)
-		@response.stubs(:headers).returns({ :taps_checksum => Taps::Utils.checksum(@gzip_data) })
-		@client.fetch_table_rows('mytable', 1000, 0).should == [ 1000, { :header => [:x, :y], :data => [[1, 2], [3, 4]] } ]
-	end
-
-	it "hides the password in urls" do
-		@client.safe_url("postgres://postgres:password@localhost/mydb").should == "postgres://postgres:[hidden]@localhost/mydb"
-		@client.safe_url("postgres://postgres@localhost/mydb").should == "postgres://postgres@localhost/mydb"
-		@client.safe_url("http://x:y@localhost:5000").should == "http://x:[hidden]@localhost:5000"
-	end
-end
-

data/spec/schema_spec.rb

@@ -1,45 +0,0 @@
-require File.dirname(__FILE__) + '/base'
-require File.dirname(__FILE__) + '/../lib/taps/schema'
-
-describe Taps::Schema do
-	before do
-		Taps::AdapterHacks.stubs(:load)
-		@connection = mock("AR connection")
-		ActiveRecord::Base.stubs(:connection).returns(@connection)
-	end
-
-	it "parses a database url and returns a config hash for activerecord" do
-		Taps::Schema.create_config("postgres://myuser:mypass@localhost/mydb").should == {
-			'adapter' => 'postgresql',
-			'database' => 'mydb',
-			'username' => 'myuser',
-			'password' => 'mypass',
-			'host' => 'localhost'
-		}
-	end
-
-	it "translates sqlite in the database url to sqlite3" do
-		Taps::Schema.create_config("sqlite://mydb")['adapter'].should == 'sqlite3'
-	end
-
-	it "translates sqlite database path" do
-		Taps::Schema.create_config("sqlite://pathtodb/mydb")['database'].should == 'pathtodb/mydb'
-		Taps::Schema.create_config("sqlite:///pathtodb/mydb")['database'].should == '/pathtodb/mydb'
-		Taps::Schema.create_config("sqlite:///pathtodb/mydb?encoding=utf8")['database'].should == '/pathtodb/mydb'
-	end
-
-	it "connects activerecord to the database" do
-		Taps::Schema.expects(:create_config).with("postgres://myuser:mypass@localhost/mydb").returns("db config")
-		ActiveRecord::Base.expects(:establish_connection).with("db config").returns(true)
-		Taps::Schema.connection("postgres://myuser:mypass@localhost/mydb").should == true
-	end
-
-	it "resets the db tables' primary keys" do
-		Taps::Schema.stubs(:connection)
-		ActiveRecord::Base.connection.expects(:respond_to?).with(:reset_pk_sequence!).returns(true)
-		ActiveRecord::Base.connection.stubs(:tables).returns(['table1'])
-		ActiveRecord::Base.connection.expects(:reset_pk_sequence!).with('table1')
-		should.not.raise { Taps::Schema.reset_db_sequences("postgres://myuser:mypass@localhost/mydb") }
-	end
-end
-