app/taggable/taggable_tests.py - soc - Git at Google

 #!/usr/bin/env python

 #Copyright 2008 Adam A. Crossland
 #
 #Licensed under the Apache License, Version 2.0 (the "License");
 #you may not use this file except in compliance with the License.
 #You may obtain a copy of the License at
 #
 #http://www.apache.org/licenses/LICENSE-2.0
 #
 #Unless required by applicable law or agreed to in writing, software
 #distributed under the License is distributed on an "AS IS" BASIS,
 #WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #See the License for the specific language governing permissions and
 #limitations under the License.

 import sys
 import os.path

 APPENGINE_PATH = '../../thirdparty/google_appengine'

 # Add app-engine related libraries to your path
 paths = [
     APPENGINE_PATH,
     os.path.join(APPENGINE_PATH, 'lib', 'django'),
     os.path.join(APPENGINE_PATH, 'lib', 'webob'),
     os.path.join(APPENGINE_PATH, 'lib', 'yaml', 'lib')
 ]
 for path in paths:
   if not os.path.exists(path):
     raise 'Path does not exist: %s' % path
 sys.path = paths + sys.path

 import unittest
 from google.appengine.api import apiproxy_stub_map
 from google.appengine.api import datastore_file_stub
 from google.appengine.api import mail_stub
 from google.appengine.api import user_service_stub
 from google.appengine.ext import webapp
 from google.appengine.ext import db
 from google.appengine.api.memcache import memcache_stub
 from taggable import *

 APP_ID = u'taggable'
 AUTH_DOMAIN = 'gmail.com'
 LOGGED_IN_USER = 'me@example.com'  # set to '' for no logged in user

 BLOG_NAME='test_blog'

 class BlogIndex(db.Model):
     "A global counter used to provide the index of the next blog post."
     index = db.IntegerProperty(required=True, default=0)
     "The next available index for a Post."

 class Post(Taggable, db.Model):
     index = db.IntegerProperty(required=True, default=0)
     body = db.TextProperty(required = True)
     title = db.StringProperty()
     added = db.DateTimeProperty(auto_now_add=True)
     added_month = db.IntegerProperty()
     added_year = db.IntegerProperty()
     edited = db.DateTimeProperty()

     def __init__(self, parent=None, key_name=None, app=None, **entity_values):
         db.Model.__init__(self, parent, key_name, app, **entity_values)
         Taggable.__init__(self)

     def get_all_posts():
         return db.GqlQuery("SELECT * from Post ORDER BY added DESC")
     Get_All_Posts = staticmethod(get_all_posts)

     @classmethod
     def get_posts(cls, start_index=0, count=10):
         start_index = int(start_index) # Just make sure that we have an int
         posts = Post.gql('WHERE index <= :1 ORDER BY index DESC', start_index).fetch(count + 1)
         if len(posts) > count:
             posts = posts[:count]

         return posts

     @classmethod
     def new_post(cls, new_title=None, new_body=None, new_tags=[]):
         new_post = None
         if new_title is not None and new_body is not None:
             def txn():
                 blog_index = BlogIndex.get_by_key_name(BLOG_NAME)
                 if blog_index is None:
                     blog_index = BlogIndex(key_name=BLOG_NAME)
                 new_index = blog_index.index
                 blog_index.index += 1
                 blog_index.put()

                 new_post_key_name = BLOG_NAME + str(new_index)
                 new_post = Post(key_name=new_post_key_name, parent=blog_index,
                                index = new_index, title = new_title,
                                body = new_body)
                 new_post.put()

                 return new_post
             new_post = db.run_in_transaction(txn)

             new_post.tags = new_tags
             new_post.put()
         else:
             raise Exception("Must supply both new_title and new_body when creating a new Post.")

         return new_post

     def delete(self):
         # Perform any actions that are required to maintain data integrity
         # when this Post is delete.
         # Disassociate this Post from any Tag
         self.set_tags([])

         # Finally, call the real delete
         db.Model.delete(self)

 class MyTest(unittest.TestCase):

     def setUp(self):
       # Start with a fresh api proxy.
       apiproxy_stub_map.apiproxy = apiproxy_stub_map.APIProxyStubMap()

       # Use a fresh stub datastore.
       stub = datastore_file_stub.DatastoreFileStub(APP_ID, '/dev/null', '/dev/null')
       apiproxy_stub_map.apiproxy.RegisterStub('datastore_v3', stub)

       # Use a fresh memcache stub.
       apiproxy_stub_map.apiproxy.RegisterStub('memcache', memcache_stub.MemcacheServiceStub())

       # Use a fresh stub UserService.
       apiproxy_stub_map.apiproxy.RegisterStub(
           'user', user_service_stub.UserServiceStub())
       os.environ['AUTH_DOMAIN'] = AUTH_DOMAIN
       os.environ['USER_EMAIL'] = LOGGED_IN_USER
       os.environ['APPLICATION_ID'] = APP_ID

     def testSimpleTagAdding(self):
       new_post = Post.new_post(new_title='test post 1', new_body='This is a test post.  Please ignore.')
       assert new_post is not None

       new_post.tags = "test, testing, tests"
       self.assertEqual(len(new_post.tags), 3)

     def testComplexTagAdding(self):
       new_post = Post.new_post(new_title='test post 1', new_body='This is a test post.  Please ignore.')
       assert new_post is not None

       new_post.tags = "  test, testing, tests,,,tag with spaces"
       self.assertEqual(len(new_post.tags), 4)

       tag = new_post.tags[3]
       assert tag is not None
       self.assertEqual(tag.tag, 'tag with spaces')
       self.assertEqual(tag.tagged_count, 1)

       tag2 = Tag.get_by_name('tag with spaces')
       assert tag2 is not None
       self.assertEqual(tag.tag, 'tag with spaces')
       self.assertEqual(tag.tagged_count, 1)

     def testTagDeletion(self):
       new_post = Post.new_post(new_title='test post 2', new_body='This is a test post.  Please continue to ignore.')
       assert new_post is not None

       new_post.tags = "test, testing, tests"
       self.assertEqual(len(new_post.tags), 3)

       new_post.tags = "test"
       self.assertEqual(len(new_post.tags), 1)

     def testTagCounts(self):
       new_post3 = Post.new_post(new_title='test post 3', new_body='This is a test post.  Please continue to ignore.')
       assert new_post3 is not None
       new_post3.tags = "foo, bar, baz"
       new_post4 = Post.new_post(new_title='test post 4', new_body='This is a test post.  Please continue to ignore.')
       assert new_post4 is not None
       new_post4.tags = "bar, baz, bletch"
       new_post5 = Post.new_post(new_title='test post 5', new_body='This is a test post.  Please continue to ignore.')
       assert new_post5 is not None
       new_post5.tags = "baz, bletch, quux"

       foo_tag = Tag.get_by_name('foo')
       assert foo_tag is not None
       self.assertEqual(foo_tag.tagged_count, 1)

       bar_tag = Tag.get_by_name('bar')
       assert bar_tag is not None
       self.assertEqual(bar_tag.tagged_count, 2)

       baz_tag = Tag.get_by_name('baz')
       assert baz_tag is not None
       self.assertEqual(baz_tag.tagged_count, 3)

       bletch_tag = Tag.get_by_name('bletch')
       assert bletch_tag is not None
       self.assertEqual(bletch_tag.tagged_count, 2)

       quux_tag = Tag.get_by_name('quux')
       assert quux_tag is not None
       self.assertEqual(quux_tag.tagged_count, 1)

       new_post3.tags = 'bar, baz'
       foo_tag = Tag.get_by_name('foo')
       assert foo_tag is not None
       self.assertEqual(len(new_post3.tags), 2)
       self.assertEqual(foo_tag.tagged_count, 0)

     def testTagGetTagsForKey(self):
       new_post = Post.new_post(new_title='test post 6', new_body='This is a test post.  Please continue to ignore.', new_tags='foo,bar,bletch,quux')
       assert new_post is not None

       tags = Tag.get_tags_for_key(new_post.key())
       assert tags is not None
       self.assertEqual(type(tags), type([]))
       self.assertEqual(len(tags), 4)

     def testTagGetByName(self):
       new_post = Post.new_post(new_title='test post 6', new_body='This is a test post.  Please continue to ignore.', new_tags='foo,bar,bletch,quux')
       assert new_post is not None

       quux_tag = Tag.get_by_name('quux')
       assert quux_tag is not None

       zizzle_tag = Tag.get_by_name('zizzle')
       assert zizzle_tag is None

     def testTagsString(self):
       new_post = Post.new_post(new_title='test post 6', new_body='This is a test post.  Please continue to ignore.', new_tags='  pal,poll ,,pip,pony')
       assert new_post is not None
       self.assertEqual(new_post.tags_string(), "pal,poll,pip,pony")
       new_post.tag_separator = "|"
       self.assertEqual(new_post.tags_string(), "pal|poll|pip|pony")
       new_post.tag_separator = " , "
       self.assertEqual(new_post.tags_string(), "pal , poll , pip , pony")

       new_post.tag_separator = ", "
       new_post.tags = "pal, pill, pip"
       self.assertEqual(len(new_post.tags), 3)
       self.assertEqual(new_post.tags_string(), "pal, pill, pip")

 if __name__ == '__main__':
     unittest.main()
	#!/usr/bin/env python

	#Copyright 2008 Adam A. Crossland
	#
	#Licensed under the Apache License, Version 2.0 (the "License");
	#you may not use this file except in compliance with the License.
	#You may obtain a copy of the License at
	#
	#http://www.apache.org/licenses/LICENSE-2.0
	#
	#Unless required by applicable law or agreed to in writing, software
	#distributed under the License is distributed on an "AS IS" BASIS,
	#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	#See the License for the specific language governing permissions and
	#limitations under the License.

	import sys
	import os.path

	APPENGINE_PATH = '../../thirdparty/google_appengine'

	# Add app-engine related libraries to your path
	paths = [
	APPENGINE_PATH,
	os.path.join(APPENGINE_PATH, 'lib', 'django'),
	os.path.join(APPENGINE_PATH, 'lib', 'webob'),
	os.path.join(APPENGINE_PATH, 'lib', 'yaml', 'lib')
	]
	for path in paths:
	if not os.path.exists(path):
	raise 'Path does not exist: %s' % path
	sys.path = paths + sys.path

	import unittest
	from google.appengine.api import apiproxy_stub_map
	from google.appengine.api import datastore_file_stub
	from google.appengine.api import mail_stub
	from google.appengine.api import user_service_stub
	from google.appengine.ext import webapp
	from google.appengine.ext import db
	from google.appengine.api.memcache import memcache_stub
	from taggable import *

	APP_ID = u'taggable'
	AUTH_DOMAIN = 'gmail.com'
	LOGGED_IN_USER = 'me@example.com' # set to '' for no logged in user

	BLOG_NAME='test_blog'

	class BlogIndex(db.Model):
	"A global counter used to provide the index of the next blog post."
	index = db.IntegerProperty(required=True, default=0)
	"The next available index for a Post."

	class Post(Taggable, db.Model):
	index = db.IntegerProperty(required=True, default=0)
	body = db.TextProperty(required = True)
	title = db.StringProperty()
	added = db.DateTimeProperty(auto_now_add=True)
	added_month = db.IntegerProperty()
	added_year = db.IntegerProperty()
	edited = db.DateTimeProperty()

	def __init__(self, parent=None, key_name=None, app=None, **entity_values):
	db.Model.__init__(self, parent, key_name, app, **entity_values)
	Taggable.__init__(self)

	def get_all_posts():
	return db.GqlQuery("SELECT * from Post ORDER BY added DESC")
	Get_All_Posts = staticmethod(get_all_posts)

	@classmethod
	def get_posts(cls, start_index=0, count=10):
	start_index = int(start_index) # Just make sure that we have an int
	posts = Post.gql('WHERE index <= :1 ORDER BY index DESC', start_index).fetch(count + 1)
	if len(posts) > count:
	posts = posts[:count]

	return posts

	@classmethod
	def new_post(cls, new_title=None, new_body=None, new_tags=[]):
	new_post = None
	if new_title is not None and new_body is not None:
	def txn():
	blog_index = BlogIndex.get_by_key_name(BLOG_NAME)
	if blog_index is None:
	blog_index = BlogIndex(key_name=BLOG_NAME)
	new_index = blog_index.index
	blog_index.index += 1
	blog_index.put()

	new_post_key_name = BLOG_NAME + str(new_index)
	new_post = Post(key_name=new_post_key_name, parent=blog_index,
	index = new_index, title = new_title,
	body = new_body)
	new_post.put()

	return new_post
	new_post = db.run_in_transaction(txn)

	new_post.tags = new_tags
	new_post.put()
	else:
	raise Exception("Must supply both new_title and new_body when creating a new Post.")

	return new_post

	def delete(self):
	# Perform any actions that are required to maintain data integrity
	# when this Post is delete.
	# Disassociate this Post from any Tag
	self.set_tags([])

	# Finally, call the real delete
	db.Model.delete(self)

	class MyTest(unittest.TestCase):

	def setUp(self):
	# Start with a fresh api proxy.
	apiproxy_stub_map.apiproxy = apiproxy_stub_map.APIProxyStubMap()

	# Use a fresh stub datastore.
	stub = datastore_file_stub.DatastoreFileStub(APP_ID, '/dev/null', '/dev/null')
	apiproxy_stub_map.apiproxy.RegisterStub('datastore_v3', stub)

	# Use a fresh memcache stub.
	apiproxy_stub_map.apiproxy.RegisterStub('memcache', memcache_stub.MemcacheServiceStub())

	# Use a fresh stub UserService.
	apiproxy_stub_map.apiproxy.RegisterStub(
	'user', user_service_stub.UserServiceStub())
	os.environ['AUTH_DOMAIN'] = AUTH_DOMAIN
	os.environ['USER_EMAIL'] = LOGGED_IN_USER
	os.environ['APPLICATION_ID'] = APP_ID

	def testSimpleTagAdding(self):
	new_post = Post.new_post(new_title='test post 1', new_body='This is a test post. Please ignore.')
	assert new_post is not None

	new_post.tags = "test, testing, tests"
	self.assertEqual(len(new_post.tags), 3)

	def testComplexTagAdding(self):
	new_post = Post.new_post(new_title='test post 1', new_body='This is a test post. Please ignore.')
	assert new_post is not None

	new_post.tags = " test, testing, tests,,,tag with spaces"
	self.assertEqual(len(new_post.tags), 4)

	tag = new_post.tags[3]
	assert tag is not None
	self.assertEqual(tag.tag, 'tag with spaces')
	self.assertEqual(tag.tagged_count, 1)

	tag2 = Tag.get_by_name('tag with spaces')
	assert tag2 is not None
	self.assertEqual(tag.tag, 'tag with spaces')
	self.assertEqual(tag.tagged_count, 1)

	def testTagDeletion(self):
	new_post = Post.new_post(new_title='test post 2', new_body='This is a test post. Please continue to ignore.')
	assert new_post is not None

	new_post.tags = "test, testing, tests"
	self.assertEqual(len(new_post.tags), 3)

	new_post.tags = "test"
	self.assertEqual(len(new_post.tags), 1)

	def testTagCounts(self):
	new_post3 = Post.new_post(new_title='test post 3', new_body='This is a test post. Please continue to ignore.')
	assert new_post3 is not None
	new_post3.tags = "foo, bar, baz"
	new_post4 = Post.new_post(new_title='test post 4', new_body='This is a test post. Please continue to ignore.')
	assert new_post4 is not None
	new_post4.tags = "bar, baz, bletch"
	new_post5 = Post.new_post(new_title='test post 5', new_body='This is a test post. Please continue to ignore.')
	assert new_post5 is not None
	new_post5.tags = "baz, bletch, quux"

	foo_tag = Tag.get_by_name('foo')
	assert foo_tag is not None
	self.assertEqual(foo_tag.tagged_count, 1)

	bar_tag = Tag.get_by_name('bar')
	assert bar_tag is not None
	self.assertEqual(bar_tag.tagged_count, 2)

	baz_tag = Tag.get_by_name('baz')
	assert baz_tag is not None
	self.assertEqual(baz_tag.tagged_count, 3)

	bletch_tag = Tag.get_by_name('bletch')
	assert bletch_tag is not None
	self.assertEqual(bletch_tag.tagged_count, 2)

	quux_tag = Tag.get_by_name('quux')
	assert quux_tag is not None
	self.assertEqual(quux_tag.tagged_count, 1)

	new_post3.tags = 'bar, baz'
	foo_tag = Tag.get_by_name('foo')
	assert foo_tag is not None
	self.assertEqual(len(new_post3.tags), 2)
	self.assertEqual(foo_tag.tagged_count, 0)

	def testTagGetTagsForKey(self):
	new_post = Post.new_post(new_title='test post 6', new_body='This is a test post. Please continue to ignore.', new_tags='foo,bar,bletch,quux')
	assert new_post is not None

	tags = Tag.get_tags_for_key(new_post.key())
	assert tags is not None
	self.assertEqual(type(tags), type([]))
	self.assertEqual(len(tags), 4)

	def testTagGetByName(self):
	new_post = Post.new_post(new_title='test post 6', new_body='This is a test post. Please continue to ignore.', new_tags='foo,bar,bletch,quux')
	assert new_post is not None

	quux_tag = Tag.get_by_name('quux')
	assert quux_tag is not None

	zizzle_tag = Tag.get_by_name('zizzle')
	assert zizzle_tag is None

	def testTagsString(self):
	new_post = Post.new_post(new_title='test post 6', new_body='This is a test post. Please continue to ignore.', new_tags=' pal,poll ,,pip,pony')
	assert new_post is not None
	self.assertEqual(new_post.tags_string(), "pal,poll,pip,pony")
	new_post.tag_separator = "\|"
	self.assertEqual(new_post.tags_string(), "pal\|poll\|pip\|pony")
	new_post.tag_separator = " , "
	self.assertEqual(new_post.tags_string(), "pal , poll , pip , pony")

	new_post.tag_separator = ", "
	new_post.tags = "pal, pill, pip"
	self.assertEqual(len(new_post.tags), 3)
	self.assertEqual(new_post.tags_string(), "pal, pill, pip")

	if __name__ == '__main__':
	unittest.main()