class Test_export_html(object): def setUp(self): self.database = Database( Connection_wrapper( sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES, check_same_thread=False) ), cache=Stub_cache(), ) self.database.execute_script(file("model/schema.sqlite").read(), commit=True) self.username = u"mulder" self.password = u"trustno1" self.email_address = u"*****@*****.**" self.user = User.create(self.database.next_id(User), self.username, self.password, self.email_address) self.database.save(self.user, commit=False) self.trash = Notebook.create(self.database.next_id(Notebook), u"trash") self.database.save(self.trash, commit=False) self.notebook = Notebook.create( self.database.next_id(Notebook), u"notebook", self.trash.object_id, user_id=self.user.object_id ) self.database.save(self.notebook, commit=False) note_id = self.database.next_id(Note) self.note1 = Note.create( note_id, u"<h3>my title</h3>blah", notebook_id=self.notebook.object_id, startup=True, user_id=self.user.object_id, ) self.database.save(self.note1, commit=False) note_id = self.database.next_id(Note) self.note2 = Note.create( note_id, u"<h3>other title</h3>whee", notebook_id=self.notebook.object_id, user_id=self.user.object_id ) self.database.save(self.note2, commit=False) def test_export_html(self): note3 = Note.create("55", u"<h3>blah</h3>foo", notebook_id=self.notebook.object_id) self.database.save(note3) response_headers = {} expected_notes = (self.note1, self.note2, note3) result = invoke("export", "html", self.database, self.notebook, expected_notes, response_headers) # response headers should be unchanged assert response_headers == {} notes = result.get("notes") assert len(notes) == len(expected_notes) # assert that the notes are in the expected order for (note, expected_note) in zip(notes, expected_notes): assert note.object_id == expected_note.object_id assert note.revision == expected_note.revision assert note.title == expected_note.title assert note.contents == expected_note.contents assert note.notebook_id == expected_note.notebook_id assert note.startup == expected_note.startup assert note.deleted_from_id == expected_note.deleted_from_id assert note.rank == expected_note.rank assert note.user_id == expected_note.user_id assert note.creation == expected_note.creation
class Test_database( object ): def setUp( self ): # make an in-memory sqlite database to use during testing self.connection = Connection_wrapper( sqlite.connect( ":memory:", detect_types = sqlite.PARSE_DECLTYPES, check_same_thread = False ) ) self.cache = Stub_cache() cursor = self.connection.cursor() cursor.execute( Stub_object.sql_create_table() ) self.database = Database( self.connection, self.cache ) def tearDown( self ): self.database.close() def test_save_and_load( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision self.database.save( basic_obj ) obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj.object_id == basic_obj.object_id assert obj.revision.replace( tzinfo = utc ) == original_revision assert obj.value == basic_obj.value def test_save_and_load_without_commit( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision self.database.save( basic_obj, commit = False ) self.connection.rollback() # if commit wasn't called, this should back out the save obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj == None def test_save_and_load_with_explicit_commit( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision self.database.save( basic_obj, commit = False ) self.database.commit() self.connection.rollback() # should have no effect because of the call to commit obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj.object_id == basic_obj.object_id assert obj.revision.replace( tzinfo = utc ) == original_revision assert obj.value == basic_obj.value def test_select_one( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision self.database.save( basic_obj ) obj = self.database.select_one( Stub_object, Stub_object.sql_load( basic_obj.object_id ) ) assert obj.object_id == basic_obj.object_id assert obj.revision.replace( tzinfo = utc ) == original_revision assert obj.value == basic_obj.value def test_select_datetime( self ): # this revision (with .504099) happens to test for a bug caused by floating point rounding errors original_revision = "2008-01-01 01:00:42.504099+00:00" basic_obj = Stub_object( object_id = "5", revision = original_revision, value = 1 ) self.database.save( basic_obj ) obj = self.database.select_one( Stub_object, Stub_object.sql_load( basic_obj.object_id ) ) assert obj.object_id == basic_obj.object_id assert str( obj.revision.replace( tzinfo = utc ) ) == original_revision assert obj.value == basic_obj.value def test_select_datetime_with_many_fractional_digits( self ): original_revision = "2008-01-01 01:00:42.5032429489284+00:00" basic_obj = Stub_object( object_id = "5", revision = original_revision, value = 1 ) self.database.save( basic_obj ) obj = self.database.select_one( Stub_object, Stub_object.sql_load( basic_obj.object_id ) ) assert obj.object_id == basic_obj.object_id assert str( obj.revision.replace( tzinfo = utc ) ) == "2008-01-01 01:00:42.503242+00:00" assert obj.value == basic_obj.value def test_select_datetime_with_zero_fractional_seconds( self ): original_revision = "2008-01-01 01:00:42.0+00:00" basic_obj = Stub_object( object_id = "5", revision = original_revision, value = 1 ) self.database.save( basic_obj ) obj = self.database.select_one( Stub_object, Stub_object.sql_load( basic_obj.object_id ) ) assert obj.object_id == basic_obj.object_id assert str( obj.revision.replace( tzinfo = utc ) ) == "2008-01-01 01:00:42+00:00" assert obj.value == basic_obj.value def test_select_one_tuple( self ): obj = self.database.select_one( tuple, Stub_object.sql_tuple() ) assert len( obj ) == 2 assert obj[ 0 ] == 1 assert obj[ 1 ] == 2 def test_select_many( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision basic_obj2 = Stub_object( object_id = "6", value = 2 ) original_revision2 = basic_obj2.revision self.database.save( basic_obj ) self.database.save( basic_obj2 ) objs = self.database.select_many( Stub_object, Stub_object.sql_load_em_all() ) assert len( objs ) == 2 assert objs[ 0 ].object_id == basic_obj.object_id assert objs[ 0 ].revision.replace( tzinfo = utc ) == original_revision assert objs[ 0 ].value == basic_obj.value assert objs[ 1 ].object_id == basic_obj2.object_id assert objs[ 1 ].revision.replace( tzinfo = utc ) == original_revision2 assert objs[ 1 ].value == basic_obj2.value def test_select_many_tuples( self ): objs = self.database.select_many( tuple, Stub_object.sql_tuple() ) assert len( objs ) == 1 assert len( objs[ 0 ] ) == 2 assert objs[ 0 ][ 0 ] == 1 assert objs[ 0 ][ 1 ] == 2 def test_select_many_with_no_matches( self ): objs = self.database.select_many( Stub_object, Stub_object.sql_load_em_all() ) assert len( objs ) == 0 def test_save_and_load_revision( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision self.database.save( basic_obj ) basic_obj.value = 2 self.database.save( basic_obj ) obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj.object_id == basic_obj.object_id assert obj.revision.replace( tzinfo = utc ) == basic_obj.revision assert obj.value == basic_obj.value revised = self.database.load( Stub_object, basic_obj.object_id, revision = original_revision ) assert revised.object_id == basic_obj.object_id assert revised.value == 1 assert revised.revision.replace( tzinfo = utc ) == original_revision def test_execute( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision self.database.execute( basic_obj.sql_create() ) obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj.object_id == basic_obj.object_id assert obj.revision.replace( tzinfo = utc ) == original_revision assert obj.value == basic_obj.value def test_execute_without_commit( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision self.database.execute( basic_obj.sql_create(), commit = False ) self.connection.rollback() obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj == None def test_execute_with_explicit_commit( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) original_revision = basic_obj.revision self.database.execute( basic_obj.sql_create(), commit = False ) self.database.commit() obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj.object_id == basic_obj.object_id assert obj.revision.replace( tzinfo = utc ) == original_revision assert obj.value == basic_obj.value def test_load_unknown( self ): basic_obj = Stub_object( object_id = "5", value = 1 ) obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj == None def test_next_id( self ): next_id = self.database.next_id( Stub_object ) assert next_id assert self.database.load( Stub_object, next_id ) prev_ids = [ next_id ] next_id = self.database.next_id( Stub_object ) assert next_id assert next_id not in prev_ids assert self.database.load( Stub_object, next_id ) prev_ids.append( next_id ) next_id = self.database.next_id( Stub_object ) assert next_id assert next_id not in prev_ids assert self.database.load( Stub_object, next_id ) def test_next_id_without_commit( self ): next_id = self.database.next_id( Stub_object, commit = False ) self.connection.rollback() assert self.database.load( Stub_object, next_id ) == None def test_next_id_with_explicit_commit( self ): next_id = self.database.next_id( Stub_object, commit = False ) self.database.commit() assert next_id assert self.database.load( Stub_object, next_id ) def test_synchronize( self ): def make_objects(): for i in range( 50 ): object_id = self.database.next_id( Stub_object ) basic_obj = Stub_object( object_id, value = 1 ) original_revision = basic_obj.revision self.database.execute( basic_obj.sql_create() ) obj = self.database.load( Stub_object, basic_obj.object_id ) assert obj.object_id == basic_obj.object_id delta = abs( obj.revision.replace( tzinfo = utc ) - original_revision ) assert delta <= timedelta( seconds = 0.000001 ) assert obj.value == basic_obj.value object_id = self.database.next_id( Stub_object ) # if synchronization (locking) is working properly, then these two threads should be able to run # simultaneously without error. without locking, SQLite will raise thread1 = Thread( target = make_objects ) thread2 = Thread( target = make_objects ) thread1.start() thread2.start() thread1.join() thread2.join() def test_backend( self ): assert self.database.backend == Persistent.SQLITE_BACKEND
class Test_export_html(object): def setUp(self): self.database = Database( Connection_wrapper( sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES, check_same_thread=False)), cache=Stub_cache(), ) self.database.execute_script(file("model/schema.sqlite").read(), commit=True) self.username = u"mulder" self.password = u"trustno1" self.email_address = u"*****@*****.**" self.user = User.create(self.database.next_id(User), self.username, self.password, self.email_address) self.database.save(self.user, commit=False) self.trash = Notebook.create(self.database.next_id(Notebook), u"trash") self.database.save(self.trash, commit=False) self.notebook = Notebook.create(self.database.next_id(Notebook), u"notebook", self.trash.object_id, user_id=self.user.object_id) self.database.save(self.notebook, commit=False) note_id = self.database.next_id(Note) self.note1 = Note.create(note_id, u"<h3>my title</h3>blah", notebook_id=self.notebook.object_id, startup=True, user_id=self.user.object_id) self.database.save(self.note1, commit=False) note_id = self.database.next_id(Note) self.note2 = Note.create(note_id, u"<h3>other title</h3>whee", notebook_id=self.notebook.object_id, user_id=self.user.object_id) self.database.save(self.note2, commit=False) def test_export_html(self): note3 = Note.create("55", u"<h3>blah</h3>foo", notebook_id=self.notebook.object_id) self.database.save(note3) response_headers = {} expected_notes = (self.note1, self.note2, note3) result = invoke( "export", "html", self.database, self.notebook, expected_notes, response_headers, ) # response headers should be unchanged assert response_headers == {} notes = result.get("notes") assert len(notes) == len(expected_notes) # assert that the notes are in the expected order for (note, expected_note) in zip(notes, expected_notes): assert note.object_id == expected_note.object_id assert note.revision == expected_note.revision assert note.title == expected_note.title assert note.contents == expected_note.contents assert note.notebook_id == expected_note.notebook_id assert note.startup == expected_note.startup assert note.deleted_from_id == expected_note.deleted_from_id assert note.rank == expected_note.rank assert note.user_id == expected_note.user_id assert note.creation == expected_note.creation
class Test_database(object): def setUp(self): # make an in-memory sqlite database to use during testing self.connection = Connection_wrapper( sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES, check_same_thread=False)) self.cache = Stub_cache() cursor = self.connection.cursor() cursor.execute(Stub_object.sql_create_table()) self.database = Database(self.connection, self.cache) def tearDown(self): self.database.close() def test_save_and_load(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision self.database.save(basic_obj) obj = self.database.load(Stub_object, basic_obj.object_id) assert obj.object_id == basic_obj.object_id assert obj.revision.replace(tzinfo=utc) == original_revision assert obj.value == basic_obj.value def test_save_and_load_without_commit(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision self.database.save(basic_obj, commit=False) self.connection.rollback( ) # if commit wasn't called, this should back out the save obj = self.database.load(Stub_object, basic_obj.object_id) assert obj == None def test_save_and_load_with_explicit_commit(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision self.database.save(basic_obj, commit=False) self.database.commit() self.connection.rollback( ) # should have no effect because of the call to commit obj = self.database.load(Stub_object, basic_obj.object_id) assert obj.object_id == basic_obj.object_id assert obj.revision.replace(tzinfo=utc) == original_revision assert obj.value == basic_obj.value def test_select_one(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision self.database.save(basic_obj) obj = self.database.select_one( Stub_object, Stub_object.sql_load(basic_obj.object_id)) assert obj.object_id == basic_obj.object_id assert obj.revision.replace(tzinfo=utc) == original_revision assert obj.value == basic_obj.value def test_select_datetime(self): # this revision (with .504099) happens to test for a bug caused by floating point rounding errors original_revision = "2008-01-01 01:00:42.504099+00:00" basic_obj = Stub_object(object_id="5", revision=original_revision, value=1) self.database.save(basic_obj) obj = self.database.select_one( Stub_object, Stub_object.sql_load(basic_obj.object_id)) assert obj.object_id == basic_obj.object_id assert str(obj.revision.replace(tzinfo=utc)) == original_revision assert obj.value == basic_obj.value def test_select_datetime_with_many_fractional_digits(self): original_revision = "2008-01-01 01:00:42.5032429489284+00:00" basic_obj = Stub_object(object_id="5", revision=original_revision, value=1) self.database.save(basic_obj) obj = self.database.select_one( Stub_object, Stub_object.sql_load(basic_obj.object_id)) assert obj.object_id == basic_obj.object_id assert str(obj.revision.replace( tzinfo=utc)) == "2008-01-01 01:00:42.503242+00:00" assert obj.value == basic_obj.value def test_select_datetime_with_zero_fractional_seconds(self): original_revision = "2008-01-01 01:00:42.0+00:00" basic_obj = Stub_object(object_id="5", revision=original_revision, value=1) self.database.save(basic_obj) obj = self.database.select_one( Stub_object, Stub_object.sql_load(basic_obj.object_id)) assert obj.object_id == basic_obj.object_id assert str( obj.revision.replace(tzinfo=utc)) == "2008-01-01 01:00:42+00:00" assert obj.value == basic_obj.value def test_select_one_tuple(self): obj = self.database.select_one(tuple, Stub_object.sql_tuple()) assert len(obj) == 2 assert obj[0] == 1 assert obj[1] == 2 def test_select_many(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision basic_obj2 = Stub_object(object_id="6", value=2) original_revision2 = basic_obj2.revision self.database.save(basic_obj) self.database.save(basic_obj2) objs = self.database.select_many(Stub_object, Stub_object.sql_load_em_all()) assert len(objs) == 2 assert objs[0].object_id == basic_obj.object_id assert objs[0].revision.replace(tzinfo=utc) == original_revision assert objs[0].value == basic_obj.value assert objs[1].object_id == basic_obj2.object_id assert objs[1].revision.replace(tzinfo=utc) == original_revision2 assert objs[1].value == basic_obj2.value def test_select_many_tuples(self): objs = self.database.select_many(tuple, Stub_object.sql_tuple()) assert len(objs) == 1 assert len(objs[0]) == 2 assert objs[0][0] == 1 assert objs[0][1] == 2 def test_select_many_with_no_matches(self): objs = self.database.select_many(Stub_object, Stub_object.sql_load_em_all()) assert len(objs) == 0 def test_save_and_load_revision(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision self.database.save(basic_obj) basic_obj.value = 2 self.database.save(basic_obj) obj = self.database.load(Stub_object, basic_obj.object_id) assert obj.object_id == basic_obj.object_id assert obj.revision.replace(tzinfo=utc) == basic_obj.revision assert obj.value == basic_obj.value revised = self.database.load(Stub_object, basic_obj.object_id, revision=original_revision) assert revised.object_id == basic_obj.object_id assert revised.value == 1 assert revised.revision.replace(tzinfo=utc) == original_revision def test_execute(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision self.database.execute(basic_obj.sql_create()) obj = self.database.load(Stub_object, basic_obj.object_id) assert obj.object_id == basic_obj.object_id assert obj.revision.replace(tzinfo=utc) == original_revision assert obj.value == basic_obj.value def test_execute_without_commit(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision self.database.execute(basic_obj.sql_create(), commit=False) self.connection.rollback() obj = self.database.load(Stub_object, basic_obj.object_id) assert obj == None def test_execute_with_explicit_commit(self): basic_obj = Stub_object(object_id="5", value=1) original_revision = basic_obj.revision self.database.execute(basic_obj.sql_create(), commit=False) self.database.commit() obj = self.database.load(Stub_object, basic_obj.object_id) assert obj.object_id == basic_obj.object_id assert obj.revision.replace(tzinfo=utc) == original_revision assert obj.value == basic_obj.value def test_load_unknown(self): basic_obj = Stub_object(object_id="5", value=1) obj = self.database.load(Stub_object, basic_obj.object_id) assert obj == None def test_next_id(self): next_id = self.database.next_id(Stub_object) assert next_id assert self.database.load(Stub_object, next_id) prev_ids = [next_id] next_id = self.database.next_id(Stub_object) assert next_id assert next_id not in prev_ids assert self.database.load(Stub_object, next_id) prev_ids.append(next_id) next_id = self.database.next_id(Stub_object) assert next_id assert next_id not in prev_ids assert self.database.load(Stub_object, next_id) def test_next_id_without_commit(self): next_id = self.database.next_id(Stub_object, commit=False) self.connection.rollback() assert self.database.load(Stub_object, next_id) == None def test_next_id_with_explicit_commit(self): next_id = self.database.next_id(Stub_object, commit=False) self.database.commit() assert next_id assert self.database.load(Stub_object, next_id) def test_synchronize(self): def make_objects(): for i in range(50): object_id = self.database.next_id(Stub_object) basic_obj = Stub_object(object_id, value=1) original_revision = basic_obj.revision self.database.execute(basic_obj.sql_create()) obj = self.database.load(Stub_object, basic_obj.object_id) assert obj.object_id == basic_obj.object_id delta = abs( obj.revision.replace(tzinfo=utc) - original_revision) assert delta <= timedelta(seconds=0.000001) assert obj.value == basic_obj.value object_id = self.database.next_id(Stub_object) # if synchronization (locking) is working properly, then these two threads should be able to run # simultaneously without error. without locking, SQLite will raise thread1 = Thread(target=make_objects) thread2 = Thread(target=make_objects) thread1.start() thread2.start() thread1.join() thread2.join() def test_backend(self): assert self.database.backend == Persistent.SQLITE_BACKEND
class Test_export_csv( object ): def setUp( self ): self.database = Database( Connection_wrapper( sqlite.connect( ":memory:", detect_types = sqlite.PARSE_DECLTYPES, check_same_thread = False ) ), cache = Stub_cache(), ) self.database.execute_script( file( "model/schema.sqlite" ).read(), commit = True ) self.username = u"mulder" self.password = u"trustno1" self.email_address = u"*****@*****.**" self.user = User.create( self.database.next_id( User ), self.username, self.password, self.email_address ) self.database.save( self.user, commit = False ) self.trash = Notebook.create( self.database.next_id( Notebook ), u"trash" ) self.database.save( self.trash, commit = False ) self.notebook = Notebook.create( self.database.next_id( Notebook ), u"notebook", self.trash.object_id, user_id = self.user.object_id ) self.database.save( self.notebook, commit = False ) note_id = self.database.next_id( Note ) self.note1 = Note.create( note_id, u"<h3>my title</h3>blah", notebook_id = self.notebook.object_id, startup = True, user_id = self.user.object_id ) self.database.save( self.note1, commit = False ) note_id = self.database.next_id( Note ) self.note2 = Note.create( note_id, u"<h3>other title</h3>whee", notebook_id = self.notebook.object_id, user_id = self.user.object_id ) self.database.save( self.note2, commit = False ) def test_export_csv( self, note_contents = None, expected_contents = None ): if not note_contents: note_contents = u"<h3>blah</h3>foo" note3 = Note.create( self.database.next_id( Note ), note_contents, notebook_id = self.notebook.object_id, user_id = self.user.object_id ) self.database.save( note3 ) response_headers = {} expected_notes = ( self.note1, self.note2, note3 ) result = invoke( "export", "csv", self.database, self.notebook, expected_notes, response_headers, ) assert response_headers assert response_headers[ u"Content-Type" ] == u"text/csv;charset=utf-8" assert response_headers[ u"Content-Disposition" ] == 'attachment; filename=%s.csv' % self.notebook.friendly_id assert isinstance( result, types.GeneratorType ) pieces = [] for piece in result: pieces.append( piece ) csv_data = "".join( pieces ) reader = csv.reader( StringIO( csv_data ) ) row = reader.next() expected_header = [ u"contents", u"title", u"note_id", u"startup", u"username", u"revision_date" ] assert row == expected_header note_count = 0 # assert that startup notes come first, then normal notes in descending revision order for row in reader: assert len( row ) == len( expected_header ) ( contents, title, note_id, startup, username, revision_date ) = row assert note_count < len( expected_notes ) expected_note = expected_notes[ note_count ] assert expected_note if expected_contents and note_id == note3.object_id: assert contents.decode( "utf8" ) == expected_contents.replace( "\n", " " ).strip() else: assert contents.decode( "utf8" ) == expected_note.contents.replace( "\n", " " ).strip() if expected_note.title: assert title.decode( "utf8" ) == expected_note.title.strip() else: assert not title assert note_id.decode( "utf8" ) == expected_note.object_id assert startup.decode( "utf8" ) == expected_note.startup and u"1" or "0" assert username.decode( "utf8" ) == ( expected_note.user_id and self.user.username or u"" ) assert revision_date.decode( "utf8" ) == unicode( expected_note.revision ) note_count += 1 assert note_count == len( expected_notes ) def test_export_csv_with_unicode( self ): self.test_export_csv( note_contents = u"<h3>blah</h3>ümlaut.png" ) def test_export_csv_without_note_title( self ): self.test_export_csv( note_contents = u"there's no title" ) def test_export_csv_with_trailing_newline_in_title( self ): self.test_export_csv( note_contents = u"<h3>blah\n</h3>foo" ) def test_export_csv_with_trailing_newline_in_contents( self ): self.test_export_csv( note_contents = u"<h3>blah</h3>foo\n" ) def test_export_csv_with_file_attachment_in_contents( self ): self.test_export_csv( note_contents = u"<h3>blah</h3>foo<a href=\"/files/download?file_id=blah"e_filename=False\">file</a>", expected_contents = "<h3>blah</h3>foo<a>file</a>", ) def test_export_csv_with_image_in_contents( self ): self.test_export_csv( note_contents = u"<h3>blah</h3>foo<a href=\"/files/download?file_id=blah"e_filename=False\"><img src=\"whee.png\" /></a>", expected_contents = "<h3>blah</h3>foo<a></a>", ) def test_export_csv_with_blank_username( self ): self.user._User__username = None self.database.save( self.user ) self.test_export_csv( note_contents = u"<h3>blah</h3>foo" )
class Test_export_csv(object): def setUp(self): self.database = Database( Connection_wrapper( sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES, check_same_thread=False)), cache=Stub_cache(), ) self.database.execute_script(file("model/schema.sqlite").read(), commit=True) self.username = u"mulder" self.password = u"trustno1" self.email_address = u"*****@*****.**" self.user = User.create(self.database.next_id(User), self.username, self.password, self.email_address) self.database.save(self.user, commit=False) self.trash = Notebook.create(self.database.next_id(Notebook), u"trash") self.database.save(self.trash, commit=False) self.notebook = Notebook.create(self.database.next_id(Notebook), u"notebook", self.trash.object_id, user_id=self.user.object_id) self.database.save(self.notebook, commit=False) note_id = self.database.next_id(Note) self.note1 = Note.create(note_id, u"<h3>my title</h3>blah", notebook_id=self.notebook.object_id, startup=True, user_id=self.user.object_id) self.database.save(self.note1, commit=False) note_id = self.database.next_id(Note) self.note2 = Note.create(note_id, u"<h3>other title</h3>whee", notebook_id=self.notebook.object_id, user_id=self.user.object_id) self.database.save(self.note2, commit=False) def test_export_csv(self, note_contents=None, expected_contents=None): if not note_contents: note_contents = u"<h3>blah</h3>foo" note3 = Note.create(self.database.next_id(Note), note_contents, notebook_id=self.notebook.object_id, user_id=self.user.object_id) self.database.save(note3) response_headers = {} expected_notes = (self.note1, self.note2, note3) result = invoke( "export", "csv", self.database, self.notebook, expected_notes, response_headers, ) assert response_headers assert response_headers[u"Content-Type"] == u"text/csv;charset=utf-8" assert response_headers[ u"Content-Disposition"] == 'attachment; filename=%s.csv' % self.notebook.friendly_id assert isinstance(result, types.GeneratorType) pieces = [] for piece in result: pieces.append(piece) csv_data = "".join(pieces) reader = csv.reader(StringIO(csv_data)) row = reader.next() expected_header = [ u"contents", u"title", u"note_id", u"startup", u"username", u"revision_date" ] assert row == expected_header note_count = 0 # assert that startup notes come first, then normal notes in descending revision order for row in reader: assert len(row) == len(expected_header) (contents, title, note_id, startup, username, revision_date) = row assert note_count < len(expected_notes) expected_note = expected_notes[note_count] assert expected_note if expected_contents and note_id == note3.object_id: assert contents.decode("utf8") == expected_contents.replace( "\n", " ").strip() else: assert contents.decode( "utf8") == expected_note.contents.replace("\n", " ").strip() if expected_note.title: assert title.decode("utf8") == expected_note.title.strip() else: assert not title assert note_id.decode("utf8") == expected_note.object_id assert startup.decode( "utf8") == expected_note.startup and u"1" or "0" assert username.decode("utf8") == (expected_note.user_id and self.user.username or u"") assert revision_date.decode("utf8") == unicode( expected_note.revision) note_count += 1 assert note_count == len(expected_notes) def test_export_csv_with_unicode(self): self.test_export_csv(note_contents=u"<h3>blah</h3>ümlaut.png") def test_export_csv_without_note_title(self): self.test_export_csv(note_contents=u"there's no title") def test_export_csv_with_trailing_newline_in_title(self): self.test_export_csv(note_contents=u"<h3>blah\n</h3>foo") def test_export_csv_with_trailing_newline_in_contents(self): self.test_export_csv(note_contents=u"<h3>blah</h3>foo\n") def test_export_csv_with_file_attachment_in_contents(self): self.test_export_csv( note_contents= u"<h3>blah</h3>foo<a href=\"/files/download?file_id=blah"e_filename=False\">file</a>", expected_contents="<h3>blah</h3>foo<a>file</a>", ) def test_export_csv_with_image_in_contents(self): self.test_export_csv( note_contents= u"<h3>blah</h3>foo<a href=\"/files/download?file_id=blah"e_filename=False\"><img src=\"whee.png\" /></a>", expected_contents="<h3>blah</h3>foo<a></a>", ) def test_export_csv_with_blank_username(self): self.user._User__username = None self.database.save(self.user) self.test_export_csv(note_contents=u"<h3>blah</h3>foo")