def test_inequality(self):
"""testing the inequality of sequences
"""
from stalker import Entity, Sequence
new_seq1 = Sequence(**self.kwargs)
new_seq2 = Sequence(**self.kwargs)
new_entity = Entity(**self.kwargs)
self.kwargs["name"] = "a different sequence"
new_seq3 = Sequence(**self.kwargs)
assert not new_seq1 != new_seq2
assert new_seq1 != new_seq3
assert new_seq1 != new_entity
def test_equality(self):
"""testing the equality of scenes
"""
new_seq1 = Scene(**self.kwargs)
new_seq2 = Scene(**self.kwargs)
from stalker import Entity
new_entity = Entity(**self.kwargs)
self.kwargs["name"] = "a different scene"
new_seq3 = Scene(**self.kwargs)
assert new_seq1 == new_seq2
assert not new_seq1 == new_seq3
assert not new_seq1 == new_entity
def test_tags_argument_set_to_something_other_than_a_list(self):
"""testing if a TypeError is going to be raised when initializing the
tags with something other than a list
"""
import copy
kwargs = copy.copy(self.kwargs)
kwargs["tags"] = ["a tag", 1243, 12.12]
with self.assertRaises(TypeError) as cm:
Entity(**kwargs)
self.assertEqual(
str(cm.exception),
'Entity.tag should be a stalker.models.tag.Tag instance, not str'
)
def test_inequality(self):
"""testing the inequality of scenes
"""
new_seq1 = Scene(**self.kwargs)
new_seq2 = Scene(**self.kwargs)
from stalker import Entity
new_entity = Entity(**self.kwargs)
self.kwargs["name"] = "a different scene"
new_seq3 = Scene(**self.kwargs)
self.assertFalse(new_seq1 != new_seq2)
self.assertTrue(new_seq1 != new_seq3)
self.assertTrue(new_seq1 != new_entity)
def setUp(self):
"""setting up some proper values
"""
super(EntityTester, self).setUp()
# create a user
from stalker import db, User
self.test_user = User(
name="Test User",
login="******",
email="*****@*****.**",
password="******"
)
db.DBSession.add(self.test_user)
# create some test Tag objects, not necessarily needed but create them
from stalker import Tag
self.test_tag1 = Tag(name="Test Tag 1")
self.test_tag2 = Tag(name="Test Tag 1") # make it equal to tag1
self.test_tag3 = Tag(name="Test Tag 3")
db.DBSession.add_all([self.test_tag1, self.test_tag2, self.test_tag3])
self.tags = [self.test_tag1, self.test_tag2]
# create a couple of test Note objects
from stalker import Note
self.test_note1 = Note(name="test note1", content="test note1")
self.test_note2 = Note(name="test note2", content="test note2")
self.test_note3 = Note(name="test note3", content="test note3")
db.DBSession.add_all([
self.test_note1, self.test_note2, self.test_note3
])
self.notes = [self.test_note1, self.test_note2]
self.kwargs = {
"name": "Test Entity",
"description": "This is a test entity, and this is a proper \
description for it",
"created_by": self.test_user,
"updated_by": self.test_user,
"tags": self.tags,
"notes": self.notes,
}
# create a proper SimpleEntity to use it later in the tests
self.test_entity = Entity(**self.kwargs)
db.DBSession.add(self.test_entity)
db.DBSession.commit()
def test_update_notes_is_working_properly_with_patch(self):
"""testing if update_notes is working properly when the request method
is PATCH
"""
from stalker import db, Entity, Note
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
# Note 1
test_note1 = Note(content='Note 1')
db.DBSession.add(test_note1)
# Note 2
test_note2 = Note(content='Note 2')
db.DBSession.add(test_note2)
# Note 3
test_note3 = Note(content='Note 3')
db.DBSession.add(test_note3)
# Note 4
test_note4 = Note(content='Note 4')
db.DBSession.add(test_note4)
# Note 5
test_note5 = Note(content='Note 5')
db.DBSession.add(test_note5)
test_entity.notes = [test_note1, test_note2, test_note3]
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.matchdict['id'] = test_entity.id
request.method = 'PATCH'
# add the 4th and 5th notes
request.params = DummyMultiDict()
request.params['note_id'] = [test_note4.id, test_note5.id]
request.POST = request.params
entity_view = entity.EntityViews(request)
entity_view.update_notes()
test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
self.assertEqual(
sorted(test_entity.notes),
sorted(
[test_note1, test_note2, test_note3, test_note4, test_note5]))
def test_notes_argument_set_to_something_other_than_a_list(self):
"""testing if a TypeError will be raised when setting the notes
argument something other than a list
"""
import copy
kwargs = copy.copy(self.kwargs)
kwargs['notes'] = ["a string note"]
with self.assertRaises(TypeError) as cm:
Entity(**kwargs)
self.assertEqual(
str(cm.exception),
'Entity.note should be a stalker.models.note.Note instance, not '
'str'
)
def setUp(self):
"""set up the test
"""
self.kwargs = {
"name": "test type",
'code': 'test',
"description": "this is a test type",
"target_entity_type": "SimpleEntity"
}
self.test_type = Type(**self.kwargs)
# create another Entity with the same name of the
# test_type for __eq__ and __ne__ tests
self.entity1 = Entity(**self.kwargs)
def setUp(self):
"""setup the test
"""
super(StatusTest, self).setUp()
self.kwargs = {
'name': 'Complete',
'description': 'use this when the object is complete',
'code': 'CMPLT',
}
# create an entity object with same kwargs for __eq__ and __ne__ tests
# (it should return False for __eq__ and True for __ne__ for same
# kwargs)
self.entity1 = Entity(**self.kwargs)
def test_notes_argument_set_to_a_list_of_other_objects(self):
"""testing if a TypeError will be raised when trying to set the notes
argument to a list of other kind of objects than Note objects
"""
import copy
kwargs = copy.copy(self.kwargs)
kwargs["notes"] = \
[1, 12.2, "this is a string"]
with pytest.raises(TypeError) as cm:
Entity(**kwargs)
assert str(cm.value) == \
'Entity.note should be a stalker.models.note.Note instance, ' \
'not int'
def test_inequality(self):
"""testing inequality of two Department objects
"""
dep1 = Department(**self.kwargs)
dep2 = Department(**self.kwargs)
entity_kwargs = self.kwargs.copy()
entity_kwargs.pop("users")
entity1 = Entity(**entity_kwargs)
self.kwargs["name"] = "Animation"
dep3 = Department(**self.kwargs)
self.assertFalse(dep1 != dep2)
self.assertTrue(dep1 != dep3)
self.assertTrue(dep1 != entity1)
def test_inequality(self):
"""testing inequality of two Department objects
"""
from stalker import Entity
dep1 = Department(**self.kwargs)
dep2 = Department(**self.kwargs)
entity_kwargs = self.kwargs.copy()
entity_kwargs.pop("users")
entity1 = Entity(**entity_kwargs)
self.kwargs["name"] = "Animation"
dep3 = Department(**self.kwargs)
assert not dep1 != dep2
assert dep1 != dep3
assert dep1 != entity1
def test_inequality(self):
"""testing inequality of two Client objects
"""
dep1 = Client(**self.kwargs)
dep2 = Client(**self.kwargs)
entity_kwargs = self.kwargs.copy()
entity_kwargs.pop("users")
entity_kwargs.pop("projects")
entity1 = Entity(**entity_kwargs)
self.kwargs["name"] = "Company X"
dep3 = Client(**self.kwargs)
self.assertFalse(dep1 != dep2)
self.assertTrue(dep1 != dep3)
self.assertTrue(dep1 != entity1)
def test_inequality(self):
"""testing inequality of two Client objects
"""
client1 = Client(**self.kwargs)
client2 = Client(**self.kwargs)
entity_kwargs = self.kwargs.copy()
entity_kwargs.pop("users")
entity_kwargs.pop("projects")
from stalker import Entity
entity1 = Entity(**entity_kwargs)
self.kwargs["name"] = "Company X"
client3 = Client(**self.kwargs)
assert not client1 != client2
assert client1 != client3
assert client1 != entity1
def test_delete_entity_method_is_working_properly(self):
"""testing if DELETE /api/entities/{id} is working properly
"""
from stalker import db, Entity
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
db.DBSession.commit()
test_entity_db = Entity.query\
.filter(Entity.name == test_entity.name).first()
self.assertIsNotNone(test_entity_db)
self.test_app.delete('/api/entities/%s' % test_entity_db.id,
status=200)
test_entity_db = Entity.query\
.filter(Entity.name == test_entity.name).first()
self.assertIsNone(test_entity_db)
def test_equality(self):
"""testing equality of two Asset objects
"""
from stalker import Asset, Entity
new_asset1 = Asset(**self.kwargs)
new_asset2 = Asset(**self.kwargs)
new_entity1 = Entity(**self.kwargs)
self.kwargs["type"] = self.asset_type2
new_asset3 = Asset(**self.kwargs)
self.kwargs["name"] = "another name"
new_asset4 = Asset(**self.kwargs)
self.assertTrue(new_asset1 == new_asset2)
self.assertFalse(new_asset1 == new_asset3)
self.assertFalse(new_asset1 == new_asset4)
self.assertFalse(new_asset3 == new_asset4)
self.assertFalse(new_asset1 == new_entity1)
def test_inequality(self):
"""testing inequality of two Asset objects
"""
from stalker import Asset, Entity
new_asset1 = Asset(**self.kwargs)
new_asset2 = Asset(**self.kwargs)
new_entity1 = Entity(**self.kwargs)
self.kwargs["type"] = self.asset_type2
new_asset3 = Asset(**self.kwargs)
self.kwargs["name"] = "another name"
new_asset4 = Asset(**self.kwargs)
assert not new_asset1 != new_asset2
assert new_asset1 != new_asset3
assert new_asset1 != new_asset4
assert new_asset3 != new_asset4
assert new_asset1 != new_entity1
def test_equality(self):
"""testing equality of shot objects
"""
self.kwargs["code"] = "SH123A"
new_shot1 = Shot(**self.kwargs)
self.kwargs["project"] = self.test_project2
new_shot2 = Shot(**self.kwargs)
# an entity with the same parameters
# just set the name to the code too
self.kwargs["name"] = self.kwargs["code"]
new_entity = Entity(**self.kwargs)
# another shot with different code
self.kwargs["code"] = "SHAnotherShot"
new_shot3 = Shot(**self.kwargs)
self.assertFalse(new_shot1 == new_shot2)
self.assertFalse(new_shot1 == new_entity)
self.assertFalse(new_shot1 == new_shot3)
def test_inequality(self):
"""testing inequality of shot objects
"""
self.kwargs['code'] = 'SH123A'
new_shot1 = Shot(**self.kwargs)
self.kwargs['project'] = self.test_project2
new_shot2 = Shot(**self.kwargs)
# an entity with the same parameters
# just set the name to the code too
self.kwargs['name'] = self.kwargs['code']
new_entity = Entity(**self.kwargs)
# another shot with different code
self.kwargs['code'] = 'SHAnotherShot'
new_shot3 = Shot(**self.kwargs)
self.assertTrue(new_shot1 != new_shot2)
self.assertTrue(new_shot1 != new_entity)
self.assertTrue(new_shot1 != new_shot3)
def test_inequality(self):
"""testing inequality of two Asset objects
"""
new_asset1 = Asset(**self.kwargs)
new_asset2 = Asset(**self.kwargs)
new_entity1 = Entity(**self.kwargs)
self.kwargs["type"] = self.asset_type2
new_asset3 = Asset(**self.kwargs)
self.kwargs["name"] = "another name"
new_asset4 = Asset(**self.kwargs)
self.assertFalse(new_asset1 != new_asset2)
self.assertTrue(new_asset1 != new_asset3)
self.assertTrue(new_asset1 != new_asset4)
self.assertTrue(new_asset3 != new_asset4)
self.assertTrue(new_asset1 != new_entity1)
def test_get_notes_is_working_properly(self):
"""testing get_notes() is working properly
"""
# create a test entity with notes
from stalker import db, Entity, Note
# test note 1
test_note1 = Note(content='Test note 1')
db.DBSession.add(test_note1)
# test note 2
test_note2 = Note(content='Test note 2')
db.DBSession.add(test_note2)
# test note 3
test_note3 = Note(content='Test note 3')
db.DBSession.add(test_note3)
# some other note
test_note4 = Note(content='Test note 4')
db.DBSession.add(test_note4)
test_entity = Entity(name='Test Entity',
notes=[test_note1, test_note2, test_note3])
db.DBSession.add(test_entity)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
dummy_request = DummyRequest()
dummy_request.matchdict['id'] = test_entity.id
entity_view = entity.EntityViews(dummy_request)
response = entity_view.get_notes()
self.assertEqual(
sorted(response.json_body),
sorted([{
'id': n.id,
'$ref': '/api/notes/%s' % n.id,
'name': n.name,
'entity_type': n.entity_type
} for n in [test_note1, test_note2, test_note3]]))
def test_inequality(self):
"""testing the inequality of FilenameTemplate objects
"""
ft1 = FilenameTemplate(**self.kwargs)
new_entity = Entity(**self.kwargs)
self.kwargs["target_entity_type"] = "Entity"
ft2 = FilenameTemplate(**self.kwargs)
self.kwargs["path"] = "different path"
ft3 = FilenameTemplate(**self.kwargs)
self.kwargs["filename"] = "different filename"
ft4 = FilenameTemplate(**self.kwargs)
self.assertFalse(self.filename_template != ft1)
self.assertTrue(self.filename_template != new_entity)
self.assertTrue(ft1 != ft2)
self.assertTrue(ft2 != ft3)
self.assertTrue(ft3 != ft4)
def test_update_entity_is_working_properly_with_post(self):
"""testing if the update_entity() method is working properly when the
request method is POST
"""
from stalker import db, Entity, User
test_user_1 = User(name='Test User 1',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(test_user_1)
test_user_2 = User(name='Test User 2',
login='******',
email='*****@*****.**',
password='******')
db.DBSession.add(test_user_2)
test_entity = Entity(name='Test Entity', created_by=test_user_1)
db.DBSession.add(test_entity)
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest, DummyMultiDict
request = DummyRequest()
request.method = 'POST'
request.matchdict['id'] = test_entity.id
request.params = DummyMultiDict()
request.params['name'] = 'New Entity Name'
request.params['description'] = 'New Description'
request.params['updated_by_id'] = test_user_2.id
self.patch_logged_in_user(request)
entity_view = entity.EntityViews(request)
entity_view.update_entity()
test_entity_db = Entity.query.get(test_entity.id)
self.assertEqual(test_entity_db.name, 'New Entity Name')
self.assertEqual(test_entity_db.description, 'New Description')
self.assertEqual(test_entity_db.updated_by, test_user_2)
def test_equality(self):
"""testing the equality of FilenameTemplate objects
"""
ft1 = FilenameTemplate(**self.kwargs)
from stalker import Entity
new_entity = Entity(**self.kwargs)
self.kwargs["target_entity_type"] = "Entity"
ft2 = FilenameTemplate(**self.kwargs)
self.kwargs["path"] = "different path"
ft3 = FilenameTemplate(**self.kwargs)
self.kwargs["filename"] = "different filename"
ft4 = FilenameTemplate(**self.kwargs)
self.assertTrue(self.filename_template == ft1)
self.assertFalse(self.filename_template == new_entity)
self.assertFalse(ft1 == ft2)
self.assertFalse(ft2 == ft3)
self.assertFalse(ft3 == ft4)
def test_inequality(self):
"""testing the inequality of FilenameTemplate objects
"""
ft1 = FilenameTemplate(**self.kwargs)
from stalker import Entity
new_entity = Entity(**self.kwargs)
self.kwargs["target_entity_type"] = "Entity"
ft2 = FilenameTemplate(**self.kwargs)
self.kwargs["path"] = "different path"
ft3 = FilenameTemplate(**self.kwargs)
self.kwargs["filename"] = "different filename"
ft4 = FilenameTemplate(**self.kwargs)
assert not self.filename_template != ft1
assert self.filename_template != new_entity
assert ft1 != ft2
assert ft2 != ft3
assert ft3 != ft4
def test_update_notes_is_working_properly_with_patch(self):
"""testing if PATCH /api/entities/{id}/notes view is working properly
"""
from stalker import db, Entity, Note
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
# Note 1
test_note1 = Note(content='Note 1')
db.DBSession.add(test_note1)
# Note 2
test_note2 = Note(content='Note 2')
db.DBSession.add(test_note2)
# Note 3
test_note3 = Note(content='Note 3')
db.DBSession.add(test_note3)
# Note 4
test_note4 = Note(content='Note 4')
db.DBSession.add(test_note4)
# Note 5
test_note5 = Note(content='Note 5')
db.DBSession.add(test_note5)
test_entity.notes = [test_note1, test_note2, test_note3]
db.DBSession.commit()
self.test_app.patch('/api/entities/%s/notes' % test_entity.id,
params={'note_id': [test_note4.id, test_note5.id]},
status=200)
test_entity = Entity.query.filter(Entity.id == test_entity.id).first()
self.assertEqual(
sorted(test_entity.notes),
sorted(
[test_note1, test_note2, test_note3, test_note4, test_note5]))
def test_delete_entity_method_is_working_properly(self):
"""testing if the delete_entity() method is working properly
"""
from stalker import db, Entity
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
db.DBSession.commit()
test_entity_db = Entity.query\
.filter(Entity.name == test_entity.name).first()
self.assertIsNotNone(test_entity_db)
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = test_entity_db.id
entity_view = entity.EntityViews(request)
entity_view.delete_entity()
test_entity_db = Entity.query\
.filter(Entity.name == test_entity.name).first()
self.assertIsNone(test_entity_db)
def test_get_tags_is_working_properly(self):
"""testing if get tags is working properly
"""
# create some tags
from stalker import db, Tag
t1 = Tag(name='tag1')
t2 = Tag(name='tag2')
t3 = Tag(name='tag3')
# create a test entity
from stalker import Entity
test_entity = Entity(name='Test Entity')
db.DBSession.add(test_entity)
test_entity.tags = [t1, t2]
db.DBSession.add_all([t1, t2, t3, test_entity])
db.DBSession.commit()
from stalker_pyramid.testing import DummyRequest
request = DummyRequest()
request.matchdict['id'] = test_entity.id
# get the tags of the entity
entity_view = entity.EntityViews(request)
response = entity_view.get_tags()
expected = [{
'id': t1.id,
'$ref': '/api/tags/%s' % t1.id,
'name': 'tag1',
'entity_type': 'Tag'
}, {
'id': t2.id,
'$ref': '/api/tags/%s' % t2.id,
'name': 'tag2',
'entity_type': 'Tag'
}]
self.assertEqual(sorted(response.json_body), sorted(expected))
def test_notes_argument_being_omitted(self):
"""testing if no error raised when omitted the notes argument
"""
self.kwargs.pop("notes")
new_entity = Entity(**self.kwargs)
self.assertTrue(isinstance(new_entity, Entity))
def test_get_entities_view_is_working_properly(self):
"""testing if GET /api/entities view is working properly
"""
# create a couple of test entities
from stalker import db, Entity, Type
test_type = Type(name='Test User',
code='testuser',
target_entity_type='User')
db.DBSession.add(test_type)
from stalker import Link
test_thumbnail = Link(full_path='/some/full/path')
db.DBSession.add(test_thumbnail)
import datetime
date_created = datetime.datetime(2016, 6, 20, 13, 55)
# Test Entity 1
test_entity1 = Entity(name='Test Entity 1',
description='This is a test description',
created_by=self.admin,
type=test_type,
date_created=date_created,
thumbnail=test_thumbnail)
db.DBSession.add(test_entity1)
# Test Entity 2
test_entity2 = Entity(name='Test Entity 2',
description='This is a test description',
created_by=self.admin,
type=test_type,
date_created=date_created,
thumbnail=test_thumbnail)
db.DBSession.add(test_entity2)
# Test Entity 3
test_entity3 = Entity(name='Test Entity 3',
description='This is a test description',
created_by=self.admin,
type=test_type,
date_created=date_created,
thumbnail=test_thumbnail)
db.DBSession.add(test_entity3)
# commit data
db.DBSession.commit()
response = self.test_app.get('/api/entities', status=200)
# admins department
admins_department = Entity.query \
.filter(Entity.name == 'admins') \
.filter(Entity.entity_type == 'Department') \
.first()
# admins group
admins_group = Entity.query \
.filter(Entity.name == 'admins') \
.filter(Entity.entity_type == 'Group') \
.first()
# Statuses
status_new = Entity.query \
.filter(Entity.name == 'New').first()
status_accepted = Entity.query \
.filter(Entity.name == 'Accepted').first()
status_assigned = Entity.query \
.filter(Entity.name == 'Assigned').first()
status_reopened = Entity.query \
.filter(Entity.name == 'Reopened').first()
status_closed = Entity.query \
.filter(Entity.name == 'Closed').first()
status_open = Entity.query \
.filter(Entity.name == 'Open').first()
status_wfd = Entity.query \
.filter(Entity.name == 'Waiting For Dependency').first()
status_rts = Entity.query \
.filter(Entity.name == 'Ready To Start').first()
status_wip = Entity.query \
.filter(Entity.name == 'Work In Progress').first()
status_prev = Entity.query \
.filter(Entity.name == 'Pending Review').first()
status_hrev = Entity.query \
.filter(Entity.name == 'Has Revision').first()
status_drev = Entity.query \
.filter(Entity.name == 'Dependency Has Revision').first()
status_oh = Entity.query \
.filter(Entity.name == 'On Hold').first()
status_stop = Entity.query \
.filter(Entity.name == 'Stopped').first()
status_cmpl = Entity.query \
.filter(Entity.name == 'Completed').first()
status_rrev = Entity.query \
.filter(Entity.name == 'Requested Revision').first()
status_app = Entity.query \
.filter(Entity.name == 'Approved').first()
# Status Lists
ticket_statuses = Entity.query \
.filter(Entity.name == 'Ticket Statuses').first()
daily_statuses = Entity.query \
.filter(Entity.name == 'Daily Statuses').first()
task_statuses = Entity.query \
.filter(Entity.name == 'Task Statuses').first()
asset_statuses = Entity.query \
.filter(Entity.name == 'Asset Statuses').first()
shot_statuses = Entity.query \
.filter(Entity.name == 'Shot Statuses').first()
sequence_statuses = Entity.query \
.filter(Entity.name == 'Sequence Statuses').first()
review_statuses = Entity.query \
.filter(Entity.name == 'Review Statuses').first()
# Types
type_defect = Entity.query \
.filter(Entity.name == 'Defect').first()
type_enhancement = Entity.query \
.filter(Entity.name == 'Enhancement').first()
all_data = [
test_entity1,
test_entity2,
test_entity3,
admins_department,
admins_group,
self.admin,
status_new,
status_accepted,
status_assigned,
status_reopened,
status_closed,
status_open,
status_wfd,
status_rts,
status_wip,
status_prev,
status_hrev,
status_drev,
status_oh,
status_stop,
status_cmpl,
status_rrev,
status_app,
ticket_statuses,
daily_statuses,
task_statuses,
asset_statuses,
shot_statuses,
sequence_statuses,
review_statuses,
type_defect,
type_enhancement,
test_type,
test_thumbnail,
]
self.maxDiff = None
from stalker_pyramid import entity_type_to_url
expected_response = [{
'id':
r.id,
'$ref':
'%s/%s' % (entity_type_to_url[r.entity_type], r.id),
'name':
r.name,
'entity_type':
r.entity_type
} for r in all_data]
self.assertEqual(sorted(response.json_body, key=lambda x: x['id']),
sorted(expected_response, key=lambda x: x['id']))